(self["webpackChunkjc_web_im"] = self["webpackChunkjc_web_im"] || []).push([[504],{ /***/ 144: /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { "use strict"; /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ C4: function() { return /* binding */ pauseTracking; }, /* harmony export */ EW: function() { return /* binding */ computed; }, /* harmony export */ Gc: function() { return /* binding */ shallowReactive; }, /* harmony export */ IG: function() { return /* binding */ markRaw; }, /* harmony export */ KR: function() { return /* binding */ ref; }, /* harmony export */ Kh: function() { return /* binding */ reactive; }, /* harmony export */ Pr: function() { return /* binding */ proxyRefs; }, /* harmony export */ QW: function() { return /* binding */ toRefs; }, /* harmony export */ R1: function() { return /* binding */ unref; }, /* harmony export */ X2: function() { return /* binding */ ReactiveEffect; }, /* harmony export */ bl: function() { return /* binding */ resetTracking; }, /* harmony export */ fE: function() { return /* binding */ isShallow; }, /* harmony export */ g8: function() { return /* binding */ isReactive; }, /* harmony export */ hV: function() { return /* binding */ traverse; }, /* harmony export */ hZ: function() { return /* binding */ trigger; }, /* harmony export */ i9: function() { return /* binding */ isRef; }, /* harmony export */ jr: function() { return /* binding */ onScopeDispose; }, /* harmony export */ ju: function() { return /* binding */ isProxy; }, /* harmony export */ o5: function() { return /* binding */ getCurrentScope; }, /* harmony export */ qA: function() { return /* binding */ shallowReadArray; }, /* harmony export */ u4: function() { return /* binding */ track; }, /* harmony export */ uY: function() { return /* binding */ effectScope; }, /* harmony export */ ux: function() { return /* binding */ toRaw; }, /* harmony export */ wB: function() { return /* binding */ watch; }, /* harmony export */ yC: function() { return /* binding */ EffectScope; } /* harmony export */ }); /* unused harmony exports ARRAY_ITERATE_KEY, EffectFlags, ITERATE_KEY, MAP_KEY_ITERATE_KEY, ReactiveFlags, TrackOpTypes, TriggerOpTypes, WatchErrorCodes, customRef, effect, enableTracking, getCurrentWatcher, isReadonly, onEffectCleanup, onWatcherCleanup, reactiveReadArray, readonly, shallowReadonly, shallowRef, stop, toReadonly, toRef, toValue, triggerRef */ /* unused harmony import specifier */ var extend; /* unused harmony import specifier */ var toRawType; /* unused harmony import specifier */ var isFunction; /* unused harmony import specifier */ var isObject; /* harmony import */ var core_js_modules_es_array_push_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4114); /* harmony import */ var core_js_modules_es_array_push_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_array_push_js__WEBPACK_IMPORTED_MODULE_0__); /* harmony import */ var core_js_modules_es_iterator_constructor_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8111); /* harmony import */ var core_js_modules_es_iterator_constructor_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_constructor_js__WEBPACK_IMPORTED_MODULE_1__); /* harmony import */ var core_js_modules_es_iterator_filter_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2489); /* harmony import */ var core_js_modules_es_iterator_filter_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_filter_js__WEBPACK_IMPORTED_MODULE_2__); /* harmony import */ var core_js_modules_es_iterator_for_each_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7588); /* harmony import */ var core_js_modules_es_iterator_for_each_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_for_each_js__WEBPACK_IMPORTED_MODULE_3__); /* harmony import */ var core_js_modules_es_iterator_map_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(1701); /* harmony import */ var core_js_modules_es_iterator_map_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_map_js__WEBPACK_IMPORTED_MODULE_4__); /* harmony import */ var core_js_modules_es_iterator_some_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(3579); /* harmony import */ var core_js_modules_es_iterator_some_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_some_js__WEBPACK_IMPORTED_MODULE_5__); /* harmony import */ var core_js_modules_es_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(5367); /* harmony import */ var core_js_modules_es_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_6__); /* harmony import */ var core_js_modules_es_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(2731); /* harmony import */ var core_js_modules_es_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_7__); /* harmony import */ var core_js_modules_es_set_difference_v2_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(7642); /* harmony import */ var core_js_modules_es_set_difference_v2_js__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_difference_v2_js__WEBPACK_IMPORTED_MODULE_8__); /* harmony import */ var core_js_modules_es_set_intersection_v2_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(8004); /* harmony import */ var core_js_modules_es_set_intersection_v2_js__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_intersection_v2_js__WEBPACK_IMPORTED_MODULE_9__); /* harmony import */ var core_js_modules_es_set_is_disjoint_from_v2_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(3853); /* harmony import */ var core_js_modules_es_set_is_disjoint_from_v2_js__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_is_disjoint_from_v2_js__WEBPACK_IMPORTED_MODULE_10__); /* harmony import */ var core_js_modules_es_set_is_subset_of_v2_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(5876); /* harmony import */ var core_js_modules_es_set_is_subset_of_v2_js__WEBPACK_IMPORTED_MODULE_11___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_is_subset_of_v2_js__WEBPACK_IMPORTED_MODULE_11__); /* harmony import */ var core_js_modules_es_set_is_superset_of_v2_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(2475); /* harmony import */ var core_js_modules_es_set_is_superset_of_v2_js__WEBPACK_IMPORTED_MODULE_12___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_is_superset_of_v2_js__WEBPACK_IMPORTED_MODULE_12__); /* harmony import */ var core_js_modules_es_set_symmetric_difference_v2_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(5024); /* harmony import */ var core_js_modules_es_set_symmetric_difference_v2_js__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_symmetric_difference_v2_js__WEBPACK_IMPORTED_MODULE_13__); /* harmony import */ var core_js_modules_es_set_union_v2_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(1698); /* harmony import */ var core_js_modules_es_set_union_v2_js__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_union_v2_js__WEBPACK_IMPORTED_MODULE_14__); /* harmony import */ var core_js_modules_es_weak_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(8454); /* harmony import */ var core_js_modules_es_weak_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_weak_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_15__); /* harmony import */ var core_js_modules_es_weak_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(9452); /* harmony import */ var core_js_modules_es_weak_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_16___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_weak_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_16__); /* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(6107); /** * @vue/reactivity v3.5.13 * (c) 2018-present Yuxi (Evan) You and Vue contributors * @license MIT **/ function warn(msg, ...args) { console.warn(`[Vue warn] ${msg}`, ...args); } let activeEffectScope; class EffectScope { constructor(detached = false) { this.detached = detached; /** * @internal */ this._active = true; /** * @internal */ this.effects = []; /** * @internal */ this.cleanups = []; this._isPaused = false; this.parent = activeEffectScope; if (!detached && activeEffectScope) { this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1; } } get active() { return this._active; } pause() { if (this._active) { this._isPaused = true; let i, l; if (this.scopes) { for (i = 0, l = this.scopes.length; i < l; i++) { this.scopes[i].pause(); } } for (i = 0, l = this.effects.length; i < l; i++) { this.effects[i].pause(); } } } /** * Resumes the effect scope, including all child scopes and effects. */ resume() { if (this._active) { if (this._isPaused) { this._isPaused = false; let i, l; if (this.scopes) { for (i = 0, l = this.scopes.length; i < l; i++) { this.scopes[i].resume(); } } for (i = 0, l = this.effects.length; i < l; i++) { this.effects[i].resume(); } } } } run(fn) { if (this._active) { const currentEffectScope = activeEffectScope; try { activeEffectScope = this; return fn(); } finally { activeEffectScope = currentEffectScope; } } else if (false) // removed by dead control flow {} } /** * This should only be called on non-detached scopes * @internal */ on() { activeEffectScope = this; } /** * This should only be called on non-detached scopes * @internal */ off() { activeEffectScope = this.parent; } stop(fromParent) { if (this._active) { this._active = false; let i, l; for (i = 0, l = this.effects.length; i < l; i++) { this.effects[i].stop(); } this.effects.length = 0; for (i = 0, l = this.cleanups.length; i < l; i++) { this.cleanups[i](); } this.cleanups.length = 0; if (this.scopes) { for (i = 0, l = this.scopes.length; i < l; i++) { this.scopes[i].stop(true); } this.scopes.length = 0; } 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; } } } function effectScope(detached) { return new EffectScope(detached); } function getCurrentScope() { return activeEffectScope; } function onScopeDispose(fn, failSilently = false) { if (activeEffectScope) { activeEffectScope.cleanups.push(fn); } else if (false) // removed by dead control flow {} } let activeSub; const EffectFlags = (/* unused pure expression or super */ null && ({ "ACTIVE": 1, "1": "ACTIVE", "RUNNING": 2, "2": "RUNNING", "TRACKING": 4, "4": "TRACKING", "NOTIFIED": 8, "8": "NOTIFIED", "DIRTY": 16, "16": "DIRTY", "ALLOW_RECURSE": 32, "32": "ALLOW_RECURSE", "PAUSED": 64, "64": "PAUSED" })); const pausedQueueEffects = /* @__PURE__ */new WeakSet(); class ReactiveEffect { constructor(fn) { this.fn = fn; /** * @internal */ this.deps = void 0; /** * @internal */ this.depsTail = void 0; /** * @internal */ this.flags = 1 | 4; /** * @internal */ this.next = void 0; /** * @internal */ this.cleanup = void 0; this.scheduler = void 0; if (activeEffectScope && activeEffectScope.active) { activeEffectScope.effects.push(this); } } pause() { this.flags |= 64; } resume() { if (this.flags & 64) { this.flags &= ~64; if (pausedQueueEffects.has(this)) { pausedQueueEffects.delete(this); this.trigger(); } } } /** * @internal */ notify() { if (this.flags & 2 && !(this.flags & 32)) { return; } if (!(this.flags & 8)) { batch(this); } } run() { if (!(this.flags & 1)) { return this.fn(); } this.flags |= 2; cleanupEffect(this); prepareDeps(this); const prevEffect = activeSub; const prevShouldTrack = shouldTrack; activeSub = this; shouldTrack = true; try { return this.fn(); } finally { if (false) // removed by dead control flow {} cleanupDeps(this); activeSub = prevEffect; shouldTrack = prevShouldTrack; this.flags &= ~2; } } stop() { if (this.flags & 1) { for (let link = this.deps; link; link = link.nextDep) { removeSub(link); } this.deps = this.depsTail = void 0; cleanupEffect(this); this.onStop && this.onStop(); this.flags &= ~1; } } trigger() { if (this.flags & 64) { pausedQueueEffects.add(this); } else if (this.scheduler) { this.scheduler(); } else { this.runIfDirty(); } } /** * @internal */ runIfDirty() { if (isDirty(this)) { this.run(); } } get dirty() { return isDirty(this); } } let batchDepth = 0; let batchedSub; let batchedComputed; function batch(sub, isComputed = false) { sub.flags |= 8; if (isComputed) { sub.next = batchedComputed; batchedComputed = sub; return; } sub.next = batchedSub; batchedSub = sub; } function startBatch() { batchDepth++; } function endBatch() { if (--batchDepth > 0) { return; } if (batchedComputed) { let e = batchedComputed; batchedComputed = void 0; while (e) { const next = e.next; e.next = void 0; e.flags &= ~8; e = next; } } let error; while (batchedSub) { let e = batchedSub; batchedSub = void 0; while (e) { const next = e.next; e.next = void 0; e.flags &= ~8; if (e.flags & 1) { try { ; e.trigger(); } catch (err) { if (!error) error = err; } } e = next; } } if (error) throw error; } function prepareDeps(sub) { for (let link = sub.deps; link; link = link.nextDep) { link.version = -1; link.prevActiveLink = link.dep.activeLink; link.dep.activeLink = link; } } function cleanupDeps(sub) { let head; let tail = sub.depsTail; let link = tail; while (link) { const prev = link.prevDep; if (link.version === -1) { if (link === tail) tail = prev; removeSub(link); removeDep(link); } else { head = link; } link.dep.activeLink = link.prevActiveLink; link.prevActiveLink = void 0; link = prev; } sub.deps = head; sub.depsTail = tail; } function isDirty(sub) { for (let link = sub.deps; link; link = link.nextDep) { if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) { return true; } } if (sub._dirty) { return true; } return false; } function refreshComputed(computed) { if (computed.flags & 4 && !(computed.flags & 16)) { return; } computed.flags &= ~16; if (computed.globalVersion === globalVersion) { return; } computed.globalVersion = globalVersion; const dep = computed.dep; computed.flags |= 2; if (dep.version > 0 && !computed.isSSR && computed.deps && !isDirty(computed)) { computed.flags &= ~2; return; } const prevSub = activeSub; const prevShouldTrack = shouldTrack; activeSub = computed; shouldTrack = true; try { prepareDeps(computed); const value = computed.fn(computed._value); if (dep.version === 0 || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasChanged */ .$H)(value, computed._value)) { computed._value = value; dep.version++; } } catch (err) { dep.version++; throw err; } finally { activeSub = prevSub; shouldTrack = prevShouldTrack; cleanupDeps(computed); computed.flags &= ~2; } } function removeSub(link, soft = false) { const { dep, prevSub, nextSub } = link; if (prevSub) { prevSub.nextSub = nextSub; link.prevSub = void 0; } if (nextSub) { nextSub.prevSub = prevSub; link.nextSub = void 0; } if (false) // removed by dead control flow {} if (dep.subs === link) { dep.subs = prevSub; if (!prevSub && dep.computed) { dep.computed.flags &= ~4; for (let l = dep.computed.deps; l; l = l.nextDep) { removeSub(l, true); } } } if (!soft && ! --dep.sc && dep.map) { dep.map.delete(dep.key); } } function removeDep(link) { const { prevDep, nextDep } = link; if (prevDep) { prevDep.nextDep = nextDep; link.prevDep = void 0; } if (nextDep) { nextDep.prevDep = prevDep; link.nextDep = void 0; } } function effect(fn, options) { if (fn.effect instanceof ReactiveEffect) { fn = fn.effect.fn; } const e = new ReactiveEffect(fn); if (options) { extend(e, options); } try { e.run(); } catch (err) { e.stop(); throw err; } const runner = e.run.bind(e); runner.effect = e; return runner; } function stop(runner) { runner.effect.stop(); } let shouldTrack = true; const trackStack = []; function pauseTracking() { trackStack.push(shouldTrack); shouldTrack = false; } function enableTracking() { trackStack.push(shouldTrack); shouldTrack = true; } function resetTracking() { const last = trackStack.pop(); shouldTrack = last === void 0 ? true : last; } function onEffectCleanup(fn, failSilently = false) { if (activeSub instanceof ReactiveEffect) { activeSub.cleanup = fn; } else if (false) // removed by dead control flow {} } function cleanupEffect(e) { const { cleanup } = e; e.cleanup = void 0; if (cleanup) { const prevSub = activeSub; activeSub = void 0; try { cleanup(); } finally { activeSub = prevSub; } } } let globalVersion = 0; class Link { constructor(sub, dep) { this.sub = sub; this.dep = dep; this.version = dep.version; this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0; } } class Dep { constructor(computed) { this.computed = computed; this.version = 0; /** * Link between this dep and the current active effect */ this.activeLink = void 0; /** * Doubly linked list representing the subscribing effects (tail) */ this.subs = void 0; /** * For object property deps cleanup */ this.map = void 0; this.key = void 0; /** * Subscriber counter */ this.sc = 0; if (false) // removed by dead control flow {} } track(debugInfo) { if (!activeSub || !shouldTrack || activeSub === this.computed) { return; } let link = this.activeLink; if (link === void 0 || link.sub !== activeSub) { link = this.activeLink = new Link(activeSub, this); if (!activeSub.deps) { activeSub.deps = activeSub.depsTail = link; } else { link.prevDep = activeSub.depsTail; activeSub.depsTail.nextDep = link; activeSub.depsTail = link; } addSub(link); } else if (link.version === -1) { link.version = this.version; if (link.nextDep) { const next = link.nextDep; next.prevDep = link.prevDep; if (link.prevDep) { link.prevDep.nextDep = next; } link.prevDep = activeSub.depsTail; link.nextDep = void 0; activeSub.depsTail.nextDep = link; activeSub.depsTail = link; if (activeSub.deps === link) { activeSub.deps = next; } } } if (false) // removed by dead control flow {} return link; } trigger(debugInfo) { this.version++; globalVersion++; this.notify(debugInfo); } notify(debugInfo) { startBatch(); try { if (false) // removed by dead control flow {} for (let link = this.subs; link; link = link.prevSub) { if (link.sub.notify()) { ; link.sub.dep.notify(); } } } finally { endBatch(); } } } function addSub(link) { link.dep.sc++; if (link.sub.flags & 4) { const computed = link.dep.computed; if (computed && !link.dep.subs) { computed.flags |= 4 | 16; for (let l = computed.deps; l; l = l.nextDep) { addSub(l); } } const currentTail = link.dep.subs; if (currentTail !== link) { link.prevSub = currentTail; if (currentTail) currentTail.nextSub = link; } if (false) // removed by dead control flow {} link.dep.subs = link; } } const targetMap = /* @__PURE__ */new WeakMap(); const ITERATE_KEY = Symbol( false ? 0 : ""); const MAP_KEY_ITERATE_KEY = Symbol( false ? 0 : ""); const ARRAY_ITERATE_KEY = Symbol( false ? 0 : ""); function track(target, type, key) { if (shouldTrack && activeSub) { 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 = new Dep()); dep.map = depsMap; dep.key = key; } if (false) // removed by dead control flow {} else { dep.track(); } } } function trigger(target, type, key, newValue, oldValue, oldTarget) { const depsMap = targetMap.get(target); if (!depsMap) { globalVersion++; return; } const run = dep => { if (dep) { if (false) // removed by dead control flow {} else { dep.trigger(); } } }; startBatch(); if (type === "clear") { depsMap.forEach(run); } else { const targetIsArray = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isArray */ .cy)(target); const isArrayIndex = targetIsArray && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isIntegerKey */ .yI)(key); if (targetIsArray && key === "length") { const newLength = Number(newValue); depsMap.forEach((dep, key2) => { if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isSymbol */ .Bm)(key2) && key2 >= newLength) { run(dep); } }); } else { if (key !== void 0 || depsMap.has(void 0)) { run(depsMap.get(key)); } if (isArrayIndex) { run(depsMap.get(ARRAY_ITERATE_KEY)); } switch (type) { case "add": if (!targetIsArray) { run(depsMap.get(ITERATE_KEY)); if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isMap */ .CE)(target)) { run(depsMap.get(MAP_KEY_ITERATE_KEY)); } } else if (isArrayIndex) { run(depsMap.get("length")); } break; case "delete": if (!targetIsArray) { run(depsMap.get(ITERATE_KEY)); if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isMap */ .CE)(target)) { run(depsMap.get(MAP_KEY_ITERATE_KEY)); } } break; case "set": if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isMap */ .CE)(target)) { run(depsMap.get(ITERATE_KEY)); } break; } } } endBatch(); } function getDepFromReactive(object, key) { const depMap = targetMap.get(object); return depMap && depMap.get(key); } function reactiveReadArray(array) { const raw = toRaw(array); if (raw === array) return raw; track(raw, "iterate", ARRAY_ITERATE_KEY); return isShallow(array) ? raw : raw.map(toReactive); } function shallowReadArray(arr) { track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY); return arr; } const arrayInstrumentations = { __proto__: null, [Symbol.iterator]() { return iterator(this, Symbol.iterator, toReactive); }, concat(...args) { return reactiveReadArray(this).concat(...args.map(x => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isArray */ .cy)(x) ? reactiveReadArray(x) : x)); }, entries() { return iterator(this, "entries", value => { value[1] = toReactive(value[1]); return value; }); }, every(fn, thisArg) { return apply(this, "every", fn, thisArg, void 0, arguments); }, filter(fn, thisArg) { return apply(this, "filter", fn, thisArg, v => v.map(toReactive), arguments); }, find(fn, thisArg) { return apply(this, "find", fn, thisArg, toReactive, arguments); }, findIndex(fn, thisArg) { return apply(this, "findIndex", fn, thisArg, void 0, arguments); }, findLast(fn, thisArg) { return apply(this, "findLast", fn, thisArg, toReactive, arguments); }, findLastIndex(fn, thisArg) { return apply(this, "findLastIndex", fn, thisArg, void 0, arguments); }, // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement forEach(fn, thisArg) { return apply(this, "forEach", fn, thisArg, void 0, arguments); }, includes(...args) { return searchProxy(this, "includes", args); }, indexOf(...args) { return searchProxy(this, "indexOf", args); }, join(separator) { return reactiveReadArray(this).join(separator); }, // keys() iterator only reads `length`, no optimisation required lastIndexOf(...args) { return searchProxy(this, "lastIndexOf", args); }, map(fn, thisArg) { return apply(this, "map", fn, thisArg, void 0, arguments); }, pop() { return noTracking(this, "pop"); }, push(...args) { return noTracking(this, "push", args); }, reduce(fn, ...args) { return reduce(this, "reduce", fn, args); }, reduceRight(fn, ...args) { return reduce(this, "reduceRight", fn, args); }, shift() { return noTracking(this, "shift"); }, // slice could use ARRAY_ITERATE but also seems to beg for range tracking some(fn, thisArg) { return apply(this, "some", fn, thisArg, void 0, arguments); }, splice(...args) { return noTracking(this, "splice", args); }, toReversed() { return reactiveReadArray(this).toReversed(); }, toSorted(comparer) { return reactiveReadArray(this).toSorted(comparer); }, toSpliced(...args) { return reactiveReadArray(this).toSpliced(...args); }, unshift(...args) { return noTracking(this, "unshift", args); }, values() { return iterator(this, "values", toReactive); } }; function iterator(self, method, wrapValue) { const arr = shallowReadArray(self); const iter = arr[method](); if (arr !== self && !isShallow(self)) { iter._next = iter.next; iter.next = () => { const result = iter._next(); if (result.value) { result.value = wrapValue(result.value); } return result; }; } return iter; } const arrayProto = Array.prototype; function apply(self, method, fn, thisArg, wrappedRetFn, args) { const arr = shallowReadArray(self); const needsWrap = arr !== self && !isShallow(self); const methodFn = arr[method]; if (methodFn !== arrayProto[method]) { const result2 = methodFn.apply(self, args); return needsWrap ? toReactive(result2) : result2; } let wrappedFn = fn; if (arr !== self) { if (needsWrap) { wrappedFn = function (item, index) { return fn.call(this, toReactive(item), index, self); }; } else if (fn.length > 2) { wrappedFn = function (item, index) { return fn.call(this, item, index, self); }; } } const result = methodFn.call(arr, wrappedFn, thisArg); return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result; } function reduce(self, method, fn, args) { const arr = shallowReadArray(self); let wrappedFn = fn; if (arr !== self) { if (!isShallow(self)) { wrappedFn = function (acc, item, index) { return fn.call(this, acc, toReactive(item), index, self); }; } else if (fn.length > 3) { wrappedFn = function (acc, item, index) { return fn.call(this, acc, item, index, self); }; } } return arr[method](wrappedFn, ...args); } function searchProxy(self, method, args) { const arr = toRaw(self); track(arr, "iterate", ARRAY_ITERATE_KEY); const res = arr[method](...args); if ((res === -1 || res === false) && isProxy(args[0])) { args[0] = toRaw(args[0]); return arr[method](...args); } return res; } function noTracking(self, method, args = []) { pauseTracking(); startBatch(); const res = toRaw(self)[method].apply(self, args); endBatch(); resetTracking(); return res; } const isNonTrackableKeys = /* @__PURE__ */(0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .makeMap */ .pD)(`__proto__,__v_isRef,__isVue`); const builtInSymbols = new Set(/* @__PURE__ */Object.getOwnPropertyNames(Symbol).filter(key => key !== "arguments" && key !== "caller").map(key => Symbol[key]).filter(_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isSymbol */ .Bm)); function hasOwnProperty(key) { if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isSymbol */ .Bm)(key)) key = String(key); const obj = toRaw(this); track(obj, "has", key); return obj.hasOwnProperty(key); } class BaseReactiveHandler { constructor(_isReadonly = false, _isShallow = false) { this._isReadonly = _isReadonly; this._isShallow = _isShallow; } get(target, key, receiver) { if (key === "__v_skip") return target["__v_skip"]; const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow; if (key === "__v_isReactive") { return !isReadonly2; } else if (key === "__v_isReadonly") { return isReadonly2; } else if (key === "__v_isShallow") { return isShallow2; } else if (key === "__v_raw") { if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype // this means the receiver is a user proxy of the reactive proxy Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) { return target; } return; } const targetIsArray = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isArray */ .cy)(target); if (!isReadonly2) { let fn; if (targetIsArray && (fn = arrayInstrumentations[key])) { return fn; } if (key === "hasOwnProperty") { return hasOwnProperty; } } const res = Reflect.get(target, key, // if this is a proxy wrapping a ref, return methods using the raw ref // as receiver so that we don't have to call `toRaw` on the ref in all // its class methods isRef(target) ? target : receiver); if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isSymbol */ .Bm)(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { return res; } if (!isReadonly2) { track(target, "get", key); } if (isShallow2) { return res; } if (isRef(res)) { return targetIsArray && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isIntegerKey */ .yI)(key) ? res : res.value; } if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isObject */ .Gv)(res)) { return isReadonly2 ? readonly(res) : reactive(res); } return res; } } class MutableReactiveHandler extends BaseReactiveHandler { constructor(isShallow2 = false) { super(false, isShallow2); } set(target, key, value, receiver) { let oldValue = target[key]; if (!this._isShallow) { const isOldValueReadonly = isReadonly(oldValue); if (!isShallow(value) && !isReadonly(value)) { oldValue = toRaw(oldValue); value = toRaw(value); } if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isArray */ .cy)(target) && isRef(oldValue) && !isRef(value)) { if (isOldValueReadonly) { return false; } else { oldValue.value = value; return true; } } } const hadKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isArray */ .cy)(target) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isIntegerKey */ .yI)(key) ? Number(key) < target.length : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasOwn */ .$3)(target, key); const result = Reflect.set(target, key, value, isRef(target) ? target : receiver); if (target === toRaw(receiver)) { if (!hadKey) { trigger(target, "add", key, value); } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasChanged */ .$H)(value, oldValue)) { trigger(target, "set", key, value, oldValue); } } return result; } deleteProperty(target, key) { const hadKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasOwn */ .$3)(target, key); const oldValue = target[key]; const result = Reflect.deleteProperty(target, key); if (result && hadKey) { trigger(target, "delete", key, void 0, oldValue); } return result; } has(target, key) { const result = Reflect.has(target, key); if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isSymbol */ .Bm)(key) || !builtInSymbols.has(key)) { track(target, "has", key); } return result; } ownKeys(target) { track(target, "iterate", (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isArray */ .cy)(target) ? "length" : ITERATE_KEY); return Reflect.ownKeys(target); } } class ReadonlyReactiveHandler extends BaseReactiveHandler { constructor(isShallow2 = false) { super(true, isShallow2); } set(target, key) { if (false) // removed by dead control flow {} return true; } deleteProperty(target, key) { if (false) // removed by dead control flow {} return true; } } const mutableHandlers = /* @__PURE__ */new MutableReactiveHandler(); const readonlyHandlers = /* @__PURE__ */new ReadonlyReactiveHandler(); const shallowReactiveHandlers = /* @__PURE__ */new MutableReactiveHandler(true); const shallowReadonlyHandlers = /* @__PURE__ */(/* unused pure expression or super */ null && (new ReadonlyReactiveHandler(true))); const toShallow = value => value; const getProto = v => Reflect.getPrototypeOf(v); function createIterableMethod(method, isReadonly2, isShallow2) { return function (...args) { const target = this["__v_raw"]; const rawTarget = toRaw(target); const targetIsMap = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isMap */ .CE)(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 { // iterator protocol next() { const { value, done } = innerIterator.next(); return done ? { value, done } : { value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), done }; }, // iterable protocol [Symbol.iterator]() { return this; } }; }; } function createReadonlyMethod(type) { return function (...args) { if (false) // removed by dead control flow {} return type === "delete" ? false : type === "clear" ? void 0 : this; }; } function createInstrumentations(readonly, shallow) { const instrumentations = { get(key) { const target = this["__v_raw"]; const rawTarget = toRaw(target); const rawKey = toRaw(key); if (!readonly) { if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasChanged */ .$H)(key, rawKey)) { track(rawTarget, "get", key); } track(rawTarget, "get", rawKey); } const { has } = getProto(rawTarget); const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive; if (has.call(rawTarget, key)) { return wrap(target.get(key)); } else if (has.call(rawTarget, rawKey)) { return wrap(target.get(rawKey)); } else if (target !== rawTarget) { target.get(key); } }, get size() { const target = this["__v_raw"]; !readonly && track(toRaw(target), "iterate", ITERATE_KEY); return Reflect.get(target, "size", target); }, has(key) { const target = this["__v_raw"]; const rawTarget = toRaw(target); const rawKey = toRaw(key); if (!readonly) { if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasChanged */ .$H)(key, rawKey)) { track(rawTarget, "has", key); } track(rawTarget, "has", rawKey); } return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); }, forEach(callback, thisArg) { const observed = this; const target = observed["__v_raw"]; const rawTarget = toRaw(target); const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive; !readonly && track(rawTarget, "iterate", ITERATE_KEY); return target.forEach((value, key) => { return callback.call(thisArg, wrap(value), wrap(key), observed); }); } }; (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .extend */ .X$)(instrumentations, readonly ? { add: createReadonlyMethod("add"), set: createReadonlyMethod("set"), delete: createReadonlyMethod("delete"), clear: createReadonlyMethod("clear") } : { add(value) { if (!shallow && !isShallow(value) && !isReadonly(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; }, set(key, value) { if (!shallow && !isShallow(value) && !isReadonly(value)) { value = toRaw(value); } const target = toRaw(this); const { has, get } = getProto(target); let hadKey = has.call(target, key); if (!hadKey) { key = toRaw(key); hadKey = has.call(target, key); } else if (false) // removed by dead control flow {} const oldValue = get.call(target, key); target.set(key, value); if (!hadKey) { trigger(target, "add", key, value); } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasChanged */ .$H)(value, oldValue)) { trigger(target, "set", key, value, oldValue); } return this; }, delete(key) { const target = toRaw(this); const { has, get } = getProto(target); let hadKey = has.call(target, key); if (!hadKey) { key = toRaw(key); hadKey = has.call(target, key); } else if (false) // removed by dead control flow {} const oldValue = get ? get.call(target, key) : void 0; const result = target.delete(key); if (hadKey) { trigger(target, "delete", key, void 0, oldValue); } return result; }, clear() { const target = toRaw(this); const hadItems = target.size !== 0; const oldTarget = false ? 0 : void 0; const result = target.clear(); if (hadItems) { trigger(target, "clear", void 0, void 0, oldTarget); } return result; } }); const iteratorMethods = ["keys", "values", "entries", Symbol.iterator]; iteratorMethods.forEach(method => { instrumentations[method] = createIterableMethod(method, readonly, shallow); }); return instrumentations; } function createInstrumentationGetter(isReadonly2, shallow) { const instrumentations = createInstrumentations(isReadonly2, shallow); 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((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasOwn */ .$3)(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 = (/* unused pure expression or super */ null && ({ get: /* @__PURE__ */createInstrumentationGetter(true, true) })); function checkIdentityKeys(target, has, key) { const rawKey = toRaw(key); if (rawKey !== key && has.call(target, rawKey)) { const type = toRawType(target); 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) { case "Object": case "Array": return 1 /* COMMON */; case "Map": case "Set": case "WeakMap": case "WeakSet": return 2 /* COLLECTION */; default: return 0 /* INVALID */; } } function getTargetType(value) { return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .toRawType */ .Zf)(value)); } function reactive(target) { if (isReadonly(target)) { return target; } return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); } function shallowReactive(target) { return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); } function readonly(target) { return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); } function shallowReadonly(target) { return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap); } function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) { if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isObject */ .Gv)(target)) { if (false) // removed by dead control flow {} 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 /* INVALID */) { return target; } const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers); proxyMap.set(target, proxy); return proxy; } function isReactive(value) { if (isReadonly(value)) { return isReactive(value["__v_raw"]); } return !!(value && value["__v_isReactive"]); } function isReadonly(value) { return !!(value && value["__v_isReadonly"]); } function isShallow(value) { return !!(value && value["__v_isShallow"]); } function isProxy(value) { return value ? !!value["__v_raw"] : false; } function toRaw(observed) { const raw = observed && observed["__v_raw"]; return raw ? toRaw(raw) : observed; } function markRaw(value) { if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasOwn */ .$3)(value, "__v_skip") && Object.isExtensible(value)) { (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .def */ .yQ)(value, "__v_skip", true); } return value; } const toReactive = value => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isObject */ .Gv)(value) ? reactive(value) : value; const toReadonly = value => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isObject */ .Gv)(value) ? readonly(value) : value; function isRef(r) { return r ? r["__v_isRef"] === true : false; } function ref(value) { return createRef(value, false); } function shallowRef(value) { return createRef(value, true); } function createRef(rawValue, shallow) { if (isRef(rawValue)) { return rawValue; } return new RefImpl(rawValue, shallow); } class RefImpl { constructor(value, isShallow2) { this.dep = new Dep(); this["__v_isRef"] = true; this["__v_isShallow"] = false; this._rawValue = isShallow2 ? value : toRaw(value); this._value = isShallow2 ? value : toReactive(value); this["__v_isShallow"] = isShallow2; } get value() { if (false) // removed by dead control flow {} else { this.dep.track(); } return this._value; } set value(newValue) { const oldValue = this._rawValue; const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue); newValue = useDirectValue ? newValue : toRaw(newValue); if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasChanged */ .$H)(newValue, oldValue)) { this._rawValue = newValue; this._value = useDirectValue ? newValue : toReactive(newValue); if (false) // removed by dead control flow {} else { this.dep.trigger(); } } } } function triggerRef(ref2) { if (ref2.dep) { if (false) // removed by dead control flow {} else { ref2.dep.trigger(); } } } function unref(ref2) { return isRef(ref2) ? ref2.value : ref2; } function toValue(source) { return isFunction(source) ? source() : unref(source); } const shallowUnwrapHandlers = { get: (target, key, receiver) => key === "__v_raw" ? target : 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); } } }; function proxyRefs(objectWithRefs) { return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers); } class CustomRefImpl { constructor(factory) { this["__v_isRef"] = true; this._value = void 0; const dep = this.dep = new Dep(); const { get, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep)); this._get = get; this._set = set; } get value() { return this._value = this._get(); } set value(newVal) { this._set(newVal); } } function customRef(factory) { return new CustomRefImpl(factory); } function toRefs(object) { if (false) // removed by dead control flow {} const ret = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isArray */ .cy)(object) ? new Array(object.length) : {}; for (const key in object) { ret[key] = propertyToRef(object, key); } return ret; } class ObjectRefImpl { constructor(_object, _key, _defaultValue) { this._object = _object; this._key = _key; this._defaultValue = _defaultValue; this["__v_isRef"] = true; this._value = void 0; } get value() { const val = this._object[this._key]; return this._value = val === void 0 ? this._defaultValue : val; } set value(newVal) { this._object[this._key] = newVal; } get dep() { return getDepFromReactive(toRaw(this._object), this._key); } } class GetterRefImpl { constructor(_getter) { this._getter = _getter; this["__v_isRef"] = true; this["__v_isReadonly"] = true; this._value = void 0; } get value() { return this._value = this._getter(); } } function toRef(source, key, defaultValue) { if (isRef(source)) { return source; } else if (isFunction(source)) { return new GetterRefImpl(source); } else if (isObject(source) && arguments.length > 1) { return propertyToRef(source, key, defaultValue); } else { return ref(source); } } function propertyToRef(source, key, defaultValue) { const val = source[key]; return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue); } class ComputedRefImpl { constructor(fn, setter, isSSR) { this.fn = fn; this.setter = setter; /** * @internal */ this._value = void 0; /** * @internal */ this.dep = new Dep(this); /** * @internal */ this.__v_isRef = true; // TODO isolatedDeclarations "__v_isReadonly" // A computed is also a subscriber that tracks other deps /** * @internal */ this.deps = void 0; /** * @internal */ this.depsTail = void 0; /** * @internal */ this.flags = 16; /** * @internal */ this.globalVersion = globalVersion - 1; /** * @internal */ this.next = void 0; // for backwards compat this.effect = this; this["__v_isReadonly"] = !setter; this.isSSR = isSSR; } /** * @internal */ notify() { this.flags |= 16; if (!(this.flags & 8) && // avoid infinite self recursion activeSub !== this) { batch(this, true); return true; } else if (false) // removed by dead control flow {} } get value() { const link = false ? 0 : this.dep.track(); refreshComputed(this); if (link) { link.version = this.dep.version; } return this._value; } set value(newValue) { if (this.setter) { this.setter(newValue); } else if (false) // removed by dead control flow {} } } function computed(getterOrOptions, debugOptions, isSSR = false) { let getter; let setter; if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isFunction */ .Tn)(getterOrOptions)) { getter = getterOrOptions; } else { getter = getterOrOptions.get; setter = getterOrOptions.set; } const cRef = new ComputedRefImpl(getter, setter, isSSR); if (false) // removed by dead control flow {} return cRef; } const TrackOpTypes = (/* unused pure expression or super */ null && ({ "GET": "get", "HAS": "has", "ITERATE": "iterate" })); const TriggerOpTypes = (/* unused pure expression or super */ null && ({ "SET": "set", "ADD": "add", "DELETE": "delete", "CLEAR": "clear" })); const ReactiveFlags = (/* unused pure expression or super */ null && ({ "SKIP": "__v_skip", "IS_REACTIVE": "__v_isReactive", "IS_READONLY": "__v_isReadonly", "IS_SHALLOW": "__v_isShallow", "RAW": "__v_raw", "IS_REF": "__v_isRef" })); const WatchErrorCodes = (/* unused pure expression or super */ null && ({ "WATCH_GETTER": 2, "2": "WATCH_GETTER", "WATCH_CALLBACK": 3, "3": "WATCH_CALLBACK", "WATCH_CLEANUP": 4, "4": "WATCH_CLEANUP" })); const INITIAL_WATCHER_VALUE = {}; const cleanupMap = /* @__PURE__ */new WeakMap(); let activeWatcher = void 0; function getCurrentWatcher() { return activeWatcher; } function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) { if (owner) { let cleanups = cleanupMap.get(owner); if (!cleanups) cleanupMap.set(owner, cleanups = []); cleanups.push(cleanupFn); } else if (false) // removed by dead control flow {} } function watch(source, cb, options = _vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .EMPTY_OBJ */ .MZ) { const { immediate, deep, once, scheduler, augmentJob, call } = options; const warnInvalidSource = s => { (options.onWarn || warn)(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`); }; const reactiveGetter = source2 => { if (deep) return source2; if (isShallow(source2) || deep === false || deep === 0) return traverse(source2, 1); return traverse(source2); }; let effect; let getter; let cleanup; let boundCleanup; let forceTrigger = false; let isMultiSource = false; if (isRef(source)) { getter = () => source.value; forceTrigger = isShallow(source); } else if (isReactive(source)) { getter = () => reactiveGetter(source); forceTrigger = true; } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isArray */ .cy)(source)) { isMultiSource = true; forceTrigger = source.some(s => isReactive(s) || isShallow(s)); getter = () => source.map(s => { if (isRef(s)) { return s.value; } else if (isReactive(s)) { return reactiveGetter(s); } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isFunction */ .Tn)(s)) { return call ? call(s, 2) : s(); } else { false && 0; } }); } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isFunction */ .Tn)(source)) { if (cb) { getter = call ? () => call(source, 2) : source; } else { getter = () => { if (cleanup) { pauseTracking(); try { cleanup(); } finally { resetTracking(); } } const currentEffect = activeWatcher; activeWatcher = effect; try { return call ? call(source, 3, [boundCleanup]) : source(boundCleanup); } finally { activeWatcher = currentEffect; } }; } } else { getter = _vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .NOOP */ .tE; false && 0; } if (cb && deep) { const baseGetter = getter; const depth = deep === true ? Infinity : deep; getter = () => traverse(baseGetter(), depth); } const scope = getCurrentScope(); const watchHandle = () => { effect.stop(); if (scope && scope.active) { (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .remove */ .TF)(scope.effects, effect); } }; if (once && cb) { const _cb = cb; cb = (...args) => { _cb(...args); watchHandle(); }; } let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE; const job = immediateFirstRun => { if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) { return; } if (cb) { const newValue = effect.run(); if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasChanged */ .$H)(v, oldValue[i])) : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .hasChanged */ .$H)(newValue, oldValue))) { if (cleanup) { cleanup(); } const currentWatcher = activeWatcher; activeWatcher = effect; try { const args = [newValue, // pass undefined as the old value when it's changed for the first time oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue, boundCleanup]; call ? call(cb, 3, args) : // @ts-expect-error cb(...args); oldValue = newValue; } finally { activeWatcher = currentWatcher; } } } else { effect.run(); } }; if (augmentJob) { augmentJob(job); } effect = new ReactiveEffect(getter); effect.scheduler = scheduler ? () => scheduler(job, false) : job; boundCleanup = fn => onWatcherCleanup(fn, false, effect); cleanup = effect.onStop = () => { const cleanups = cleanupMap.get(effect); if (cleanups) { if (call) { call(cleanups, 4); } else { for (const cleanup2 of cleanups) cleanup2(); } cleanupMap.delete(effect); } }; if (false) // removed by dead control flow {} if (cb) { if (immediate) { job(true); } else { oldValue = effect.run(); } } else if (scheduler) { scheduler(job.bind(null, true), true); } else { effect.run(); } watchHandle.pause = effect.pause.bind(effect); watchHandle.resume = effect.resume.bind(effect); watchHandle.stop = watchHandle; return watchHandle; } function traverse(value, depth = Infinity, seen) { if (depth <= 0 || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isObject */ .Gv)(value) || value["__v_skip"]) { return value; } seen = seen || /* @__PURE__ */new Set(); if (seen.has(value)) { return value; } seen.add(value); depth--; if (isRef(value)) { traverse(value.value, depth, seen); } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isArray */ .cy)(value)) { for (let i = 0; i < value.length; i++) { traverse(value[i], depth, seen); } } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isSet */ .vM)(value) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isMap */ .CE)(value)) { value.forEach(v => { traverse(v, depth, seen); }); } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_17__/* .isPlainObject */ .Qd)(value)) { for (const key in value) { traverse(value[key], depth, seen); } for (const key of Object.getOwnPropertySymbols(value)) { if (Object.prototype.propertyIsEnumerable.call(value, key)) { traverse(value[key], depth, seen); } } } return value; } /* harmony export */ __webpack_require__.d(__webpack_exports__, [ /* harmony export */ "lJ", 0, /* binding */ toReactive /* harmony export */ ]); /***/ }), /***/ 6107: /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { "use strict"; /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ pD: function() { return /* binding */ makeMap; } /* harmony export */ }); /* unused harmony exports EMPTY_ARR, NO, PatchFlagNames, PatchFlags, ShapeFlags, SlotFlags, camelize, capitalize, cssVarNameEscapeSymbolsRE, escapeHtml, escapeHtmlComment, genCacheKey, genPropsAccessExp, generateCodeFrame, getEscapedCssVarName, getGlobalThis, hyphenate, includeBooleanAttr, invokeArrayFns, isBooleanAttr, isBuiltInDirective, isDate, isGloballyAllowed, isGloballyWhitelisted, isHTMLTag, isKnownHtmlAttr, isKnownMathMLAttr, isKnownSvgAttr, isMathMLTag, isModelListener, isOn, isPromise, isRegExp, isRenderableAttrValue, isReservedProp, isSSRSafeAttrName, isSVGTag, isSpecialBooleanAttr, isString, isVoidTag, looseEqual, looseIndexOf, looseToNumber, normalizeClass, normalizeProps, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, slotFlagsText, stringifyStyle, toDisplayString, toHandlerKey, toNumber, toTypeString */ /* harmony import */ var core_js_modules_es_array_push_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4114); /* harmony import */ var core_js_modules_es_array_push_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_array_push_js__WEBPACK_IMPORTED_MODULE_0__); /* harmony import */ var core_js_modules_es_iterator_constructor_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8111); /* harmony import */ var core_js_modules_es_iterator_constructor_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_constructor_js__WEBPACK_IMPORTED_MODULE_1__); /* harmony import */ var core_js_modules_es_iterator_filter_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2489); /* harmony import */ var core_js_modules_es_iterator_filter_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_filter_js__WEBPACK_IMPORTED_MODULE_2__); /* harmony import */ var core_js_modules_es_iterator_for_each_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7588); /* harmony import */ var core_js_modules_es_iterator_for_each_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_for_each_js__WEBPACK_IMPORTED_MODULE_3__); /** * @vue/shared v3.5.13 * (c) 2018-present Yuxi (Evan) You and Vue contributors * @license MIT **/ /*! #__NO_SIDE_EFFECTS__ */ // @__NO_SIDE_EFFECTS__ function makeMap(str) { const map = /* @__PURE__ */Object.create(null); for (const key of str.split(",")) map[key] = 1; return val => val in map; } const EMPTY_OBJ = false ? 0 : {}; const EMPTY_ARR = false ? 0 : []; const NOOP = () => {}; const NO = () => false; const isOn = key => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && ( // uppercase letter key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97); const isModelListener = key => key.startsWith("onUpdate:"); const extend = Object.assign; const remove = (arr, el) => { const i = arr.indexOf(el); if (i > -1) { arr.splice(i, 1); } }; const hasOwnProperty = Object.prototype.hasOwnProperty; const hasOwn = (val, key) => hasOwnProperty.call(val, key); const isArray = Array.isArray; const isMap = val => toTypeString(val) === "[object Map]"; const isSet = val => toTypeString(val) === "[object Set]"; const isDate = val => toTypeString(val) === "[object Date]"; const isRegExp = val => toTypeString(val) === "[object RegExp]"; 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 = val => { return (isObject(val) || isFunction(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 = val => toTypeString(val) === "[object Object]"; const isIntegerKey = key => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key; const isReservedProp = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap( // the leading comma is intentional so empty string "" is also included ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"))); const isBuiltInDirective = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"))); const cacheStringFunction = fn => { const cache = /* @__PURE__ */Object.create(null); return str => { const hit = cache[str]; return hit || (cache[str] = fn(str)); }; }; const camelizeRE = /-(\w)/g; const camelize = cacheStringFunction(str => { return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : ""); }); const hyphenateRE = /\B([A-Z])/g; const hyphenate = cacheStringFunction(str => str.replace(hyphenateRE, "-$1").toLowerCase()); const capitalize = cacheStringFunction(str => { return str.charAt(0).toUpperCase() + str.slice(1); }); const toHandlerKey = cacheStringFunction(str => { const s = str ? `on${capitalize(str)}` : ``; return s; }); 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, writable = false) => { Object.defineProperty(obj, key, { configurable: true, enumerable: false, writable, value }); }; 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 __webpack_require__.g !== "undefined" ? __webpack_require__.g : {}); }; const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/; function genPropsAccessExp(name) { return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`; } function genCacheKey(source, options) { return source + JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val); } const PatchFlags = (/* unused pure expression or super */ null && ({ "TEXT": 1, "1": "TEXT", "CLASS": 2, "2": "CLASS", "STYLE": 4, "4": "STYLE", "PROPS": 8, "8": "PROPS", "FULL_PROPS": 16, "16": "FULL_PROPS", "NEED_HYDRATION": 32, "32": "NEED_HYDRATION", "STABLE_FRAGMENT": 64, "64": "STABLE_FRAGMENT", "KEYED_FRAGMENT": 128, "128": "KEYED_FRAGMENT", "UNKEYED_FRAGMENT": 256, "256": "UNKEYED_FRAGMENT", "NEED_PATCH": 512, "512": "NEED_PATCH", "DYNAMIC_SLOTS": 1024, "1024": "DYNAMIC_SLOTS", "DEV_ROOT_FRAGMENT": 2048, "2048": "DEV_ROOT_FRAGMENT", "CACHED": -1, "-1": "CACHED", "BAIL": -2, "-2": "BAIL" })); const PatchFlagNames = (/* unused pure expression or super */ null && ({ [1]: `TEXT`, [2]: `CLASS`, [4]: `STYLE`, [8]: `PROPS`, [16]: `FULL_PROPS`, [32]: `NEED_HYDRATION`, [64]: `STABLE_FRAGMENT`, [128]: `KEYED_FRAGMENT`, [256]: `UNKEYED_FRAGMENT`, [512]: `NEED_PATCH`, [1024]: `DYNAMIC_SLOTS`, [2048]: `DEV_ROOT_FRAGMENT`, [-1]: `HOISTED`, [-2]: `BAIL` })); const ShapeFlags = (/* unused pure expression or super */ null && ({ "ELEMENT": 1, "1": "ELEMENT", "FUNCTIONAL_COMPONENT": 2, "2": "FUNCTIONAL_COMPONENT", "STATEFUL_COMPONENT": 4, "4": "STATEFUL_COMPONENT", "TEXT_CHILDREN": 8, "8": "TEXT_CHILDREN", "ARRAY_CHILDREN": 16, "16": "ARRAY_CHILDREN", "SLOTS_CHILDREN": 32, "32": "SLOTS_CHILDREN", "TELEPORT": 64, "64": "TELEPORT", "SUSPENSE": 128, "128": "SUSPENSE", "COMPONENT_SHOULD_KEEP_ALIVE": 256, "256": "COMPONENT_SHOULD_KEEP_ALIVE", "COMPONENT_KEPT_ALIVE": 512, "512": "COMPONENT_KEPT_ALIVE", "COMPONENT": 6, "6": "COMPONENT" })); const SlotFlags = (/* unused pure expression or super */ null && ({ "STABLE": 1, "1": "STABLE", "DYNAMIC": 2, "2": "DYNAMIC", "FORWARDED": 3, "3": "FORWARDED" })); const slotFlagsText = (/* unused pure expression or super */ null && ({ [1]: "STABLE", [2]: "DYNAMIC", [3]: "FORWARDED" })); const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol"; const isGloballyAllowed = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap(GLOBALS_ALLOWED))); const isGloballyWhitelisted = (/* unused pure expression or super */ null && (isGloballyAllowed)); const range = 2; function generateCodeFrame(source, start = 0, end = source.length) { start = Math.max(0, Math.min(start, source.length)); end = Math.max(0, Math.min(end, source.length)); if (start > end) return ""; let lines = source.split(/(\r?\n)/); const newlineSequences = lines.filter((_, idx) => idx % 2 === 1); lines = lines.filter((_, idx) => idx % 2 === 0); let count = 0; const res = []; for (let i = 0; i < lines.length; i++) { count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0); if (count >= start) { for (let j = i - range; j <= i + range || end > count; j++) { if (j < 0 || j >= lines.length) continue; const line = j + 1; res.push(`${line}${" ".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`); const lineLength = lines[j].length; const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0; if (j === i) { const pad = start - (count - (lineLength + newLineSeqLength)); const length = Math.max(1, end > count ? lineLength - pad : end - start); res.push(` | ` + " ".repeat(pad) + "^".repeat(length)); } else if (j > i) { if (end > count) { const length = Math.max(Math.min(end - count, lineLength), 1); res.push(` | ` + "^".repeat(length)); } count += lineLength + newLineSeqLength; } } break; } } return res.join("\n"); } 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]; } } } return res; } else if (isString(value) || isObject(value)) { return value; } } const listDelimiterRE = /;(?![^(]*\))/g; const propertyDelimiterRE = /:([^]+)/; const styleCommentRE = /\/\*[^]*?\*\//g; 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 stringifyStyle(styles) { if (!styles) return ""; if (isString(styles)) return styles; let ret = ""; for (const key in styles) { const value = styles[key]; if (isString(value) || typeof value === "number") { const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key); ret += `${normalizedKey}:${value};`; } } return ret; } 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 + " "; } } } else if (isObject(value)) { for (const name in value) { if (value[name]) { res += name + " "; } } } return res.trim(); } function normalizeProps(props) { if (!props) return null; let { class: klass, style } = props; if (klass && !isString(klass)) { props.class = normalizeClass(klass); } if (style) { props.style = normalizeStyle(style); } return props; } 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 MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics"; const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr"; const isHTMLTag = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap(HTML_TAGS))); const isSVGTag = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap(SVG_TAGS))); const isMathMLTag = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap(MATH_TAGS))); const isVoidTag = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap(VOID_TAGS))); const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`; const isSpecialBooleanAttr = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap(specialBooleanAttrs))); const isBooleanAttr = /* @__PURE__ */makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`); function includeBooleanAttr(value) { return !!value || value === ""; } const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; const attrValidationCache = (/* unused pure expression or super */ null && ({})); function isSSRSafeAttrName(name) { if (attrValidationCache.hasOwnProperty(name)) { return attrValidationCache[name]; } const isUnsafe = unsafeAttrCharRE.test(name); if (isUnsafe) { console.error(`unsafe attribute name: ${name}`); } return attrValidationCache[name] = !isUnsafe; } const propsToAttrMap = (/* unused pure expression or super */ null && ({ acceptCharset: "accept-charset", className: "class", htmlFor: "for", httpEquiv: "http-equiv" })); const isKnownHtmlAttr = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`))); const isKnownSvgAttr = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap(`xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`))); const isKnownMathMLAttr = /* @__PURE__ */(/* unused pure expression or super */ null && (makeMap(`accent,accentunder,actiontype,align,alignmentscope,altimg,altimg-height,altimg-valign,altimg-width,alttext,bevelled,close,columnsalign,columnlines,columnspan,denomalign,depth,dir,display,displaystyle,encoding,equalcolumns,equalrows,fence,fontstyle,fontweight,form,frame,framespacing,groupalign,height,href,id,indentalign,indentalignfirst,indentalignlast,indentshift,indentshiftfirst,indentshiftlast,indextype,justify,largetop,largeop,lquote,lspace,mathbackground,mathcolor,mathsize,mathvariant,maxsize,minlabelspacing,mode,other,overflow,position,rowalign,rowlines,rowspan,rquote,rspace,scriptlevel,scriptminsize,scriptsizemultiplier,selection,separator,separators,shift,side,src,stackalign,stretchy,subscriptshift,superscriptshift,symmetric,voffset,width,widths,xlink:href,xlink:show,xlink:type,xmlns`))); function isRenderableAttrValue(value) { if (value == null) { return false; } const type = typeof value; return type === "string" || type === "number" || type === "boolean"; } const escapeRE = /["'&<>]/; function escapeHtml(string) { const str = "" + string; const match = escapeRE.exec(str); if (!match) { return str; } let html = ""; let escaped; let index; let lastIndex = 0; for (index = match.index; index < str.length; index++) { switch (str.charCodeAt(index)) { case 34: escaped = """; break; case 38: escaped = "&"; break; case 39: escaped = "'"; break; case 60: escaped = "<"; break; case 62: escaped = ">"; break; default: continue; } if (lastIndex !== index) { html += str.slice(lastIndex, index); } lastIndex = index + 1; html += escaped; } return lastIndex !== index ? html + str.slice(lastIndex, index) : html; } const commentStripRE = /^-?>||--!>|?@[\\\]^`{|}~]/g; function getEscapedCssVarName(key, doubleEscape) { return key.replace(cssVarNameEscapeSymbolsRE, s => doubleEscape ? s === '"' ? '\\\\\\"' : `\\\\${s}` : `\\${s}`); } function looseCompareArrays(a, b) { if (a.length !== b.length) return false; let equal = true; for (let i = 0; equal && i < a.length; i++) { equal = looseEqual(a[i], b[i]); } return equal; } function looseEqual(a, b) { if (a === b) return true; let aValidType = isDate(a); let bValidType = isDate(b); if (aValidType || bValidType) { return aValidType && bValidType ? a.getTime() === b.getTime() : false; } aValidType = isSymbol(a); bValidType = isSymbol(b); if (aValidType || bValidType) { return a === b; } aValidType = isArray(a); bValidType = isArray(b); if (aValidType || bValidType) { return aValidType && bValidType ? looseCompareArrays(a, b) : false; } aValidType = isObject(a); bValidType = isObject(b); if (aValidType || bValidType) { if (!aValidType || !bValidType) { return false; } const aKeysCount = Object.keys(a).length; const bKeysCount = Object.keys(b).length; if (aKeysCount !== bKeysCount) { return false; } for (const key in a) { const aHasKey = a.hasOwnProperty(key); const bHasKey = b.hasOwnProperty(key); if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) { return false; } } } return String(a) === String(b); } function looseIndexOf(arr, val) { return arr.findIndex(item => looseEqual(item, val)); } const isRef = val => { return !!(val && val["__v_isRef"] === true); }; const toDisplayString = val => { return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val); }; const replacer = (_key, val) => { if (isRef(val)) { return replacer(_key, val.value); } else if (isMap(val)) { return { [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2], i) => { entries[stringifySymbol(key, i) + " =>"] = val2; return entries; }, {}) }; } else if (isSet(val)) { return { [`Set(${val.size})`]: [...val.values()].map(v => stringifySymbol(v)) }; } else if (isSymbol(val)) { return stringifySymbol(val); } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) { return String(val); } return val; }; const stringifySymbol = (v, i = "") => { var _a; return ( // Symbol.description in es2019+ so we need to cast here to pass // the lib: es2016 check isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v ); }; /* harmony export */ __webpack_require__.d(__webpack_exports__, [ /* harmony export */ "$3", 0, /* binding */ hasOwn, /* harmony export */ "$H", 0, /* binding */ hasChanged, /* harmony export */ "Bm", 0, /* binding */ isSymbol, /* harmony export */ "CE", 0, /* binding */ isMap, /* harmony export */ "Gv", 0, /* binding */ isObject, /* harmony export */ "MZ", 0, /* binding */ EMPTY_OBJ, /* harmony export */ "Qd", 0, /* binding */ isPlainObject, /* harmony export */ "TF", 0, /* binding */ remove, /* harmony export */ "Tn", 0, /* binding */ isFunction, /* harmony export */ "X$", 0, /* binding */ extend, /* harmony export */ "Zf", 0, /* binding */ toRawType, /* harmony export */ "cy", 0, /* binding */ isArray, /* harmony export */ "tE", 0, /* binding */ NOOP, /* harmony export */ "vM", 0, /* binding */ isSet, /* harmony export */ "yI", 0, /* binding */ isIntegerKey, /* harmony export */ "yQ", 0, /* binding */ def /* harmony export */ ]); /***/ }), /***/ 6768: /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { "use strict"; /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ CE: function() { return /* binding */ createElementBlock; }, /* harmony export */ Fv: function() { return /* binding */ createStaticVNode; }, /* harmony export */ K9: function() { return /* binding */ createRenderer; }, /* harmony export */ Lk: function() { return /* binding */ createBaseVNode; }, /* harmony export */ PS: function() { return /* binding */ hasInjectionContext; }, /* harmony export */ Q3: function() { return /* binding */ createCommentVNode; }, /* harmony export */ WQ: function() { return /* binding */ inject; }, /* harmony export */ Wv: function() { return /* binding */ createBlock; }, /* harmony export */ bo: function() { return /* binding */ withDirectives; }, /* harmony export */ dY: function() { return /* binding */ nextTick; }, /* harmony export */ eW: function() { return /* binding */ createTextVNode; }, /* harmony export */ h: function() { return /* binding */ h; }, /* harmony export */ pI: function() { return /* binding */ renderList; }, /* harmony export */ pM: function() { return /* binding */ defineComponent; }, /* harmony export */ qL: function() { return /* binding */ callWithAsyncErrorHandling; }, /* harmony export */ uX: function() { return /* binding */ openBlock; }, /* harmony export */ wB: function() { return /* binding */ watch; } /* harmony export */ }); /* unused harmony exports BaseTransition, BaseTransitionPropsValidators, Comment, DeprecationTypes, ErrorCodes, ErrorTypeStrings, KeepAlive, Static, Suspense, Text, assertNumber, callWithErrorHandling, cloneVNode, compatUtils, createHydrationRenderer, createPropsRestProxy, createSlots, defineAsyncComponent, defineEmits, defineExpose, defineModel, defineOptions, defineProps, defineSlots, devtools, getCurrentInstance, getTransitionRawChildren, guardReactiveProps, handleError, hydrateOnIdle, hydrateOnInteraction, hydrateOnMediaQuery, hydrateOnVisible, initCustomFormatter, isMemoSame, isRuntimeOnly, isVNode, mergeDefaults, mergeModels, mergeProps, onActivated, onBeforeMount, onBeforeUpdate, onDeactivated, onErrorCaptured, onRenderTracked, onRenderTriggered, onServerPrefetch, onUnmounted, onUpdated, popScopeId, provide, pushScopeId, queuePostFlushCb, registerRuntimeCompiler, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveFilter, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, ssrContextKey, ssrUtils, toHandlers, transformVNodeArgs, useAttrs, useId, useModel, useSSRContext, useSlots, useTemplateRef, useTransitionState, version, warn, watchEffect, watchPostEffect, watchSyncEffect, withAsyncContext, withCtx, withDefaults, withMemo, withScopeId */ /* unused harmony import specifier */ var pauseTracking; /* unused harmony import specifier */ var resetTracking; /* unused harmony import specifier */ var isRef; /* unused harmony import specifier */ var toRaw; /* unused harmony import specifier */ var shallowRef; /* unused harmony import specifier */ var isReactive; /* unused harmony import specifier */ var ref; /* unused harmony import specifier */ var customRef; /* unused harmony import specifier */ var track; /* unused harmony import specifier */ var isShallow; /* unused harmony import specifier */ var isString; /* unused harmony import specifier */ var isFunction; /* unused harmony import specifier */ var extend; /* unused harmony import specifier */ var isBuiltInDirective; /* unused harmony import specifier */ var isArray; /* unused harmony import specifier */ var EMPTY_OBJ; /* unused harmony import specifier */ var isOn; /* unused harmony import specifier */ var isReservedProp; /* unused harmony import specifier */ var normalizeClass; /* unused harmony import specifier */ var stringifyStyle; /* unused harmony import specifier */ var normalizeStyle; /* unused harmony import specifier */ var isKnownSvgAttr; /* unused harmony import specifier */ var isBooleanAttr; /* unused harmony import specifier */ var isKnownHtmlAttr; /* unused harmony import specifier */ var includeBooleanAttr; /* unused harmony import specifier */ var isRenderableAttrValue; /* unused harmony import specifier */ var getEscapedCssVarName; /* unused harmony import specifier */ var invokeArrayFns; /* unused harmony import specifier */ var isRegExp; /* unused harmony import specifier */ var camelize; /* unused harmony import specifier */ var capitalize; /* unused harmony import specifier */ var isSymbol; /* unused harmony import specifier */ var toHandlerKey; /* unused harmony import specifier */ var isGloballyAllowed; /* unused harmony import specifier */ var NOOP; /* unused harmony import specifier */ var isPromise; /* unused harmony import specifier */ var makeMap; /* unused harmony import specifier */ var isObject; /* unused harmony import specifier */ var toRawType; /* unused harmony import specifier */ var hyphenate; /* unused harmony import specifier */ var hasChanged; /* unused harmony import specifier */ var toNumber; /* harmony import */ var core_js_modules_es_array_includes_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4423); /* harmony import */ var core_js_modules_es_array_includes_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_array_includes_js__WEBPACK_IMPORTED_MODULE_0__); /* harmony import */ var core_js_modules_es_array_push_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4114); /* harmony import */ var core_js_modules_es_array_push_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_array_push_js__WEBPACK_IMPORTED_MODULE_1__); /* harmony import */ var core_js_modules_es_iterator_constructor_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8111); /* harmony import */ var core_js_modules_es_iterator_constructor_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_constructor_js__WEBPACK_IMPORTED_MODULE_2__); /* harmony import */ var core_js_modules_es_iterator_every_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1148); /* harmony import */ var core_js_modules_es_iterator_every_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_every_js__WEBPACK_IMPORTED_MODULE_3__); /* harmony import */ var core_js_modules_es_iterator_filter_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(2489); /* harmony import */ var core_js_modules_es_iterator_filter_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_filter_js__WEBPACK_IMPORTED_MODULE_4__); /* harmony import */ var core_js_modules_es_iterator_for_each_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(7588); /* harmony import */ var core_js_modules_es_iterator_for_each_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_for_each_js__WEBPACK_IMPORTED_MODULE_5__); /* harmony import */ var core_js_modules_es_iterator_map_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1701); /* harmony import */ var core_js_modules_es_iterator_map_js__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_map_js__WEBPACK_IMPORTED_MODULE_6__); /* harmony import */ var core_js_modules_es_iterator_reduce_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(8237); /* harmony import */ var core_js_modules_es_iterator_reduce_js__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_reduce_js__WEBPACK_IMPORTED_MODULE_7__); /* harmony import */ var core_js_modules_es_iterator_some_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(3579); /* harmony import */ var core_js_modules_es_iterator_some_js__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_iterator_some_js__WEBPACK_IMPORTED_MODULE_8__); /* harmony import */ var core_js_modules_es_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(5367); /* harmony import */ var core_js_modules_es_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_9__); /* harmony import */ var core_js_modules_es_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(2731); /* harmony import */ var core_js_modules_es_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_10__); /* harmony import */ var core_js_modules_es_set_difference_v2_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(7642); /* harmony import */ var core_js_modules_es_set_difference_v2_js__WEBPACK_IMPORTED_MODULE_11___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_difference_v2_js__WEBPACK_IMPORTED_MODULE_11__); /* harmony import */ var core_js_modules_es_set_intersection_v2_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(8004); /* harmony import */ var core_js_modules_es_set_intersection_v2_js__WEBPACK_IMPORTED_MODULE_12___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_intersection_v2_js__WEBPACK_IMPORTED_MODULE_12__); /* harmony import */ var core_js_modules_es_set_is_disjoint_from_v2_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(3853); /* harmony import */ var core_js_modules_es_set_is_disjoint_from_v2_js__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_is_disjoint_from_v2_js__WEBPACK_IMPORTED_MODULE_13__); /* harmony import */ var core_js_modules_es_set_is_subset_of_v2_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(5876); /* harmony import */ var core_js_modules_es_set_is_subset_of_v2_js__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_is_subset_of_v2_js__WEBPACK_IMPORTED_MODULE_14__); /* harmony import */ var core_js_modules_es_set_is_superset_of_v2_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(2475); /* harmony import */ var core_js_modules_es_set_is_superset_of_v2_js__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_is_superset_of_v2_js__WEBPACK_IMPORTED_MODULE_15__); /* harmony import */ var core_js_modules_es_set_symmetric_difference_v2_js__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(5024); /* harmony import */ var core_js_modules_es_set_symmetric_difference_v2_js__WEBPACK_IMPORTED_MODULE_16___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_symmetric_difference_v2_js__WEBPACK_IMPORTED_MODULE_16__); /* harmony import */ var core_js_modules_es_set_union_v2_js__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(1698); /* harmony import */ var core_js_modules_es_set_union_v2_js__WEBPACK_IMPORTED_MODULE_17___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_set_union_v2_js__WEBPACK_IMPORTED_MODULE_17__); /* harmony import */ var core_js_modules_es_weak_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(8454); /* harmony import */ var core_js_modules_es_weak_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_18___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_weak_map_get_or_insert_js__WEBPACK_IMPORTED_MODULE_18__); /* harmony import */ var core_js_modules_es_weak_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(9452); /* harmony import */ var core_js_modules_es_weak_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_19___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_weak_map_get_or_insert_computed_js__WEBPACK_IMPORTED_MODULE_19__); /* harmony import */ var _vue_reactivity__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(144); /* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(5187); /** * @vue/runtime-core v3.5.13 * (c) 2018-present Yuxi (Evan) You and Vue contributors * @license MIT **/ const stack = (/* unused pure expression or super */ null && ([])); function pushWarningContext(vnode) { stack.push(vnode); } function popWarningContext() { stack.pop(); } let isWarning = false; function warn$1(msg, ...args) { if (isWarning) return; isWarning = true; pauseTracking(); const instance = stack.length ? stack[stack.length - 1].component : null; const appWarnHandler = instance && instance.appContext.config.warnHandler; const trace = getComponentTrace(); if (appWarnHandler) { callWithErrorHandling(appWarnHandler, instance, 11, [ // eslint-disable-next-line no-restricted-syntax msg + args.map(a => { var _a, _b; return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a); }).join(""), instance && instance.proxy, trace.map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`).join("\n"), trace]); } else { const warnArgs = [`[Vue warn]: ${msg}`, ...args]; if (trace.length && // avoid spamming console during tests true) { warnArgs.push(` `, ...formatTrace(trace)); } console.warn(...warnArgs); } resetTracking(); isWarning = false; } function getComponentTrace() { let currentVNode = stack[stack.length - 1]; if (!currentVNode) { 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 open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`; const close = `>` + postfix; return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + 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 (true) return; // removed by dead control flow } const ErrorCodes = (/* unused pure expression or super */ null && ({ "SETUP_FUNCTION": 0, "0": "SETUP_FUNCTION", "RENDER_FUNCTION": 1, "1": "RENDER_FUNCTION", "NATIVE_EVENT_HANDLER": 5, "5": "NATIVE_EVENT_HANDLER", "COMPONENT_EVENT_HANDLER": 6, "6": "COMPONENT_EVENT_HANDLER", "VNODE_HOOK": 7, "7": "VNODE_HOOK", "DIRECTIVE_HOOK": 8, "8": "DIRECTIVE_HOOK", "TRANSITION_HOOK": 9, "9": "TRANSITION_HOOK", "APP_ERROR_HANDLER": 10, "10": "APP_ERROR_HANDLER", "APP_WARN_HANDLER": 11, "11": "APP_WARN_HANDLER", "FUNCTION_REF": 12, "12": "FUNCTION_REF", "ASYNC_COMPONENT_LOADER": 13, "13": "ASYNC_COMPONENT_LOADER", "SCHEDULER": 14, "14": "SCHEDULER", "COMPONENT_UPDATE": 15, "15": "COMPONENT_UPDATE", "APP_UNMOUNT_CLEANUP": 16, "16": "APP_UNMOUNT_CLEANUP" })); const ErrorTypeStrings$1 = (/* unused pure expression or super */ null && ({ ["sp"]: "serverPrefetch hook", ["bc"]: "beforeCreate hook", ["c"]: "created hook", ["bm"]: "beforeMount hook", ["m"]: "mounted hook", ["bu"]: "beforeUpdate hook", ["u"]: "updated", ["bum"]: "beforeUnmount hook", ["um"]: "unmounted hook", ["a"]: "activated hook", ["da"]: "deactivated hook", ["ec"]: "errorCaptured hook", ["rtc"]: "renderTracked hook", ["rtg"]: "renderTriggered hook", [0]: "setup function", [1]: "render function", [2]: "watcher getter", [3]: "watcher callback", [4]: "watcher cleanup function", [5]: "native event handler", [6]: "component event handler", [7]: "vnode hook", [8]: "directive hook", [9]: "transition hook", [10]: "app errorHandler", [11]: "app warnHandler", [12]: "ref function", [13]: "async component loader", [14]: "scheduler flush", [15]: "component update", [16]: "app unmount cleanup function" })); function callWithErrorHandling(fn, instance, type, args) { try { return args ? fn(...args) : fn(); } catch (err) { handleError(err, instance, type); } } function callWithAsyncErrorHandling(fn, instance, type, args) { if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isFunction */ .Tn)(fn)) { const res = callWithErrorHandling(fn, instance, type, args); if (res && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isPromise */ .yL)(res)) { res.catch(err => { handleError(err, instance, type); }); } return res; } if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isArray */ .cy)(fn)) { const values = []; for (let i = 0; i < fn.length; i++) { values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); } return values; } else if (false) // removed by dead control flow {} } function handleError(err, instance, type, throwInDev = true) { const contextVNode = instance ? instance.vnode : null; const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .EMPTY_OBJ */ .MZ; if (instance) { let cur = instance.parent; const exposedInstance = instance.proxy; const errorInfo = false ? 0 : `https://vuejs.org/error-reference/#runtime-${type}`; while (cur) { const errorCapturedHooks = cur.ec; if (errorCapturedHooks) { for (let i = 0; i < errorCapturedHooks.length; i++) { if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { return; } } } cur = cur.parent; } if (errorHandler) { (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .pauseTracking */ .C4)(); callWithErrorHandling(errorHandler, null, 10, [err, exposedInstance, errorInfo]); (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .resetTracking */ .bl)(); return; } } logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction); } function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) { if (false) // removed by dead control flow {} else if (throwInProd) { throw err; } else { console.error(err); } } const queue = []; let flushIndex = -1; const pendingPostFlushCbs = []; let activePostFlushCbs = null; let postFlushIndex = 0; const resolvedPromise = /* @__PURE__ */Promise.resolve(); let currentFlushPromise = null; const RECURSION_LIMIT = 100; function nextTick(fn) { const p = currentFlushPromise || resolvedPromise; return fn ? p.then(this ? fn.bind(this) : fn) : p; } function findInsertionIndex(id) { let start = flushIndex + 1; let end = queue.length; while (start < end) { const middle = start + end >>> 1; const middleJob = queue[middle]; const middleJobId = getId(middleJob); if (middleJobId < id || middleJobId === id && middleJob.flags & 2) { start = middle + 1; } else { end = middle; } } return start; } function queueJob(job) { if (!(job.flags & 1)) { const jobId = getId(job); const lastJob = queue[queue.length - 1]; if (!lastJob || // fast path when the job id is larger than the tail !(job.flags & 2) && jobId >= getId(lastJob)) { queue.push(job); } else { queue.splice(findInsertionIndex(jobId), 0, job); } job.flags |= 1; queueFlush(); } } function queueFlush() { if (!currentFlushPromise) { currentFlushPromise = resolvedPromise.then(flushJobs); } } function queuePostFlushCb(cb) { if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isArray */ .cy)(cb)) { if (activePostFlushCbs && cb.id === -1) { activePostFlushCbs.splice(postFlushIndex + 1, 0, cb); } else if (!(cb.flags & 1)) { pendingPostFlushCbs.push(cb); cb.flags |= 1; } } else { pendingPostFlushCbs.push(...cb); } queueFlush(); } function flushPreFlushCbs(instance, seen, i = flushIndex + 1) { if (false) // removed by dead control flow {} for (; i < queue.length; i++) { const cb = queue[i]; if (cb && cb.flags & 2) { if (instance && cb.id !== instance.uid) { continue; } if (false) // removed by dead control flow {} queue.splice(i, 1); i--; if (cb.flags & 4) { cb.flags &= ~1; } cb(); if (!(cb.flags & 4)) { cb.flags &= ~1; } } } } function flushPostFlushCbs(seen) { if (pendingPostFlushCbs.length) { const deduped = [...new Set(pendingPostFlushCbs)].sort((a, b) => getId(a) - getId(b)); pendingPostFlushCbs.length = 0; if (activePostFlushCbs) { activePostFlushCbs.push(...deduped); return; } activePostFlushCbs = deduped; if (false) // removed by dead control flow {} for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { const cb = activePostFlushCbs[postFlushIndex]; if (false) // removed by dead control flow {} if (cb.flags & 4) { cb.flags &= ~1; } if (!(cb.flags & 8)) cb(); cb.flags &= ~1; } activePostFlushCbs = null; postFlushIndex = 0; } } const getId = job => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id; function flushJobs(seen) { if (false) // removed by dead control flow {} const check = false ? 0 : _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .NOOP */ .tE; try { for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { const job = queue[flushIndex]; if (job && !(job.flags & 8)) { if (false) // removed by dead control flow {} if (job.flags & 4) { job.flags &= ~1; } callWithErrorHandling(job, job.i, job.i ? 15 : 14); if (!(job.flags & 4)) { job.flags &= ~1; } } } } finally { for (; flushIndex < queue.length; flushIndex++) { const job = queue[flushIndex]; if (job) { job.flags &= ~1; } } flushIndex = -1; queue.length = 0; flushPostFlushCbs(seen); currentFlushPromise = null; if (queue.length || pendingPostFlushCbs.length) { flushJobs(seen); } } } function checkRecursiveUpdates(seen, fn) { const count = seen.get(fn) || 0; if (count > RECURSION_LIMIT) { const instance = fn.i; const componentName = instance && getComponentName(instance.type); handleError(`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.`, null, 10); return true; } seen.set(fn, count + 1); return false; } let isHmrUpdating = false; const hmrDirtyComponents = /* @__PURE__ */(/* unused pure expression or super */ null && (new Map())); if (false) // removed by dead control flow {} const map = /* @__PURE__ */(/* unused pure expression or super */ null && (new Map())); function registerHMR(instance) { const id = instance.type.__hmrId; let record = map.get(id); if (!record) { createRecord(id, instance.type); record = map.get(id); } record.instances.add(instance); } function unregisterHMR(instance) { map.get(instance.type.__hmrId).instances.delete(instance); } function createRecord(id, initialDef) { if (map.has(id)) { return false; } map.set(id, { initialDef: normalizeClassComponent(initialDef), instances: /* @__PURE__ */new Set() }); return true; } function normalizeClassComponent(component) { return isClassComponent(component) ? component.__vccOpts : component; } function rerender(id, newRender) { const record = map.get(id); if (!record) { return; } record.initialDef.render = newRender; [...record.instances].forEach(instance => { if (newRender) { instance.render = newRender; normalizeClassComponent(instance.type).render = newRender; } instance.renderCache = []; isHmrUpdating = true; instance.update(); isHmrUpdating = false; }); } function reload(id, newComp) { const record = map.get(id); if (!record) return; newComp = normalizeClassComponent(newComp); updateComponentDef(record.initialDef, newComp); const instances = [...record.instances]; for (let i = 0; i < instances.length; i++) { const instance = instances[i]; const oldComp = normalizeClassComponent(instance.type); let dirtyInstances = hmrDirtyComponents.get(oldComp); if (!dirtyInstances) { if (oldComp !== record.initialDef) { updateComponentDef(oldComp, newComp); } hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */new Set()); } dirtyInstances.add(instance); instance.appContext.propsCache.delete(instance.type); instance.appContext.emitsCache.delete(instance.type); instance.appContext.optionsCache.delete(instance.type); if (instance.ceReload) { dirtyInstances.add(instance); instance.ceReload(newComp.styles); dirtyInstances.delete(instance); } else if (instance.parent) { queueJob(() => { isHmrUpdating = true; instance.parent.update(); isHmrUpdating = false; dirtyInstances.delete(instance); }); } else if (instance.appContext.reload) { instance.appContext.reload(); } else if (typeof window !== "undefined") { window.location.reload(); } else { console.warn("[HMR] Root or manually mounted instance modified. Full reload required."); } if (instance.root.ce && instance !== instance.root) { instance.root.ce._removeChildStyle(oldComp); } } queuePostFlushCb(() => { hmrDirtyComponents.clear(); }); } function updateComponentDef(oldComp, newComp) { extend(oldComp, newComp); for (const key in oldComp) { if (key !== "__file" && !(key in newComp)) { delete oldComp[key]; } } } function tryWrap(fn) { return (id, arg) => { 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$1; let buffer = (/* unused pure expression or super */ null && ([])); let devtoolsNotInstalled = false; function emit$1(event, ...args) { if (devtools$1) { devtools$1.emit(event, ...args); } else if (!devtoolsNotInstalled) { buffer.push({ event, args }); } } function setDevtoolsHook$1(hook, target) { var _a, _b; devtools$1 = hook; if (devtools$1) { devtools$1.enabled = true; buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args)); buffer = []; } else if ( // handle late devtools injection - only do this if we are in an actual // browser environment to avoid the timer handle stalling test runner exit // (#4815) typeof window !== "undefined" && // some envs mock window but not fully window.HTMLElement && // also exclude jsdom // eslint-disable-next-line no-restricted-syntax !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))) { const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || []; replay.push(newHook => { setDevtoolsHook$1(newHook, target); }); setTimeout(() => { if (!devtools$1) { target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null; devtoolsNotInstalled = true; buffer = []; } }, 3e3); } else { devtoolsNotInstalled = true; buffer = []; } } function devtoolsInitApp(app, version) { emit$1("app:init" /* APP_INIT */, app, version, { Fragment, Text, Comment, Static }); } function devtoolsUnmountApp(app) { emit$1("app:unmount" /* APP_UNMOUNT */, app); } const devtoolsComponentAdded = /* @__PURE__ */(/* unused pure expression or super */ null && (createDevtoolsComponentHook("component:added" /* COMPONENT_ADDED */))); const devtoolsComponentUpdated = /* @__PURE__ */(/* unused pure expression or super */ null && (createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */))); const _devtoolsComponentRemoved = /* @__PURE__ */(/* unused pure expression or super */ null && (createDevtoolsComponentHook("component:removed" /* COMPONENT_REMOVED */))); const devtoolsComponentRemoved = component => { if (devtools$1 && typeof devtools$1.cleanupBuffer === "function" && // remove the component if it wasn't buffered !devtools$1.cleanupBuffer(component)) { _devtoolsComponentRemoved(component); } }; /*! #__NO_SIDE_EFFECTS__ */ // @__NO_SIDE_EFFECTS__ function createDevtoolsComponentHook(hook) { return component => { emit$1(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : void 0, component); }; } const devtoolsPerfStart = /* @__PURE__ */(/* unused pure expression or super */ null && (createDevtoolsPerformanceHook("perf:start" /* PERFORMANCE_START */))); const devtoolsPerfEnd = /* @__PURE__ */(/* unused pure expression or super */ null && (createDevtoolsPerformanceHook("perf:end" /* PERFORMANCE_END */))); function createDevtoolsPerformanceHook(hook) { return (component, type, time) => { emit$1(hook, component.appContext.app, component.uid, component, type, time); }; } function devtoolsComponentEmit(component, event, params) { emit$1("component:emit" /* COMPONENT_EMIT */, component.appContext.app, component, event, params); } let currentRenderingInstance = null; let currentScopeId = null; function setCurrentRenderingInstance(instance) { const prev = currentRenderingInstance; currentRenderingInstance = instance; currentScopeId = instance && instance.type.__scopeId || null; return prev; } function pushScopeId(id) { currentScopeId = id; } function popScopeId() { currentScopeId = null; } const withScopeId = _id => withCtx; 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; try { res = fn(...args); } finally { setCurrentRenderingInstance(prevInstance); if (renderFnWithContext._d) { setBlockTracking(1); } } if (false) // removed by dead control flow {} return res; }; renderFnWithContext._n = true; renderFnWithContext._c = true; renderFnWithContext._d = true; return renderFnWithContext; } function validateDirectiveName(name) { if (isBuiltInDirective(name)) { warn$1("Do not use built-in directive ids as custom directive id: " + name); } } function withDirectives(vnode, directives) { if (currentRenderingInstance === null) { false && 0; return vnode; } const instance = getComponentPublicInstance(currentRenderingInstance); const bindings = vnode.dirs || (vnode.dirs = []); for (let i = 0; i < directives.length; i++) { let [dir, value, arg, modifiers = _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .EMPTY_OBJ */ .MZ] = directives[i]; if (dir) { if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isFunction */ .Tn)(dir)) { dir = { mounted: dir, updated: dir }; } if (dir.deep) { (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .traverse */ .hV)(value); } bindings.push({ dir, instance, value, oldValue: void 0, arg, modifiers }); } } return vnode; } function invokeDirectiveHook(vnode, prevVNode, instance, name) { const bindings = vnode.dirs; const oldBindings = prevVNode && prevVNode.dirs; for (let i = 0; i < bindings.length; i++) { const binding = bindings[i]; if (oldBindings) { binding.oldValue = oldBindings[i].value; } let hook = binding.dir[name]; if (hook) { (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .pauseTracking */ .C4)(); callWithAsyncErrorHandling(hook, instance, 8, [vnode.el, binding, vnode, prevVNode]); (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .resetTracking */ .bl)(); } } } const TeleportEndKey = Symbol("_vte"); const isTeleport = type => type.__isTeleport; const isTeleportDisabled = props => props && (props.disabled || props.disabled === ""); const isTeleportDeferred = props => props && (props.defer || props.defer === ""); const isTargetSVG = target => typeof SVGElement !== "undefined" && target instanceof SVGElement; const isTargetMathML = target => typeof MathMLElement === "function" && target instanceof MathMLElement; const resolveTarget = (props, select) => { const targetSelector = props && props.to; if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isString */ .Kg)(targetSelector)) { if (!select) { false && 0; return null; } else { const target = select(targetSelector); if (false) // removed by dead control flow {} return target; } } else { if (false) // removed by dead control flow {} return targetSelector; } }; const TeleportImpl = { name: "Teleport", __isTeleport: true, process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) { const { mc: mountChildren, pc: patchChildren, pbc: patchBlockChildren, o: { insert, querySelector, createText, createComment } } = internals; const disabled = isTeleportDisabled(n2.props); let { shapeFlag, children, dynamicChildren } = n2; if (false) // removed by dead control flow {} if (n1 == null) { const placeholder = n2.el = false ? 0 : createText(""); const mainAnchor = n2.anchor = false ? 0 : createText(""); insert(placeholder, container, anchor); insert(mainAnchor, container, anchor); const mount = (container2, anchor2) => { if (shapeFlag & 16) { if (parentComponent && parentComponent.isCE) { parentComponent.ce._teleportTarget = container2; } mountChildren(children, container2, anchor2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized); } }; const mountToTarget = () => { const target = n2.target = resolveTarget(n2.props, querySelector); const targetAnchor = prepareAnchor(target, n2, createText, insert); if (target) { if (namespace !== "svg" && isTargetSVG(target)) { namespace = "svg"; } else if (namespace !== "mathml" && isTargetMathML(target)) { namespace = "mathml"; } if (!disabled) { mount(target, targetAnchor); updateCssVars(n2, false); } } else if (false) // removed by dead control flow {} }; if (disabled) { mount(container, mainAnchor); updateCssVars(n2, true); } if (isTeleportDeferred(n2.props)) { queuePostRenderEffect(() => { mountToTarget(); n2.el.__isMounted = true; }, parentSuspense); } else { mountToTarget(); } } else { if (isTeleportDeferred(n2.props) && !n1.el.__isMounted) { queuePostRenderEffect(() => { TeleportImpl.process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals); delete n1.el.__isMounted; }, parentSuspense); return; } n2.el = n1.el; n2.targetStart = n1.targetStart; const mainAnchor = n2.anchor = n1.anchor; const target = n2.target = n1.target; const targetAnchor = n2.targetAnchor = n1.targetAnchor; const wasDisabled = isTeleportDisabled(n1.props); const currentContainer = wasDisabled ? container : target; const currentAnchor = wasDisabled ? mainAnchor : targetAnchor; if (namespace === "svg" || isTargetSVG(target)) { namespace = "svg"; } else if (namespace === "mathml" || isTargetMathML(target)) { namespace = "mathml"; } if (dynamicChildren) { patchBlockChildren(n1.dynamicChildren, dynamicChildren, currentContainer, parentComponent, parentSuspense, namespace, slotScopeIds); traverseStaticChildren(n1, n2, true); } else if (!optimized) { patchChildren(n1, n2, currentContainer, currentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, false); } if (disabled) { if (!wasDisabled) { moveTeleport(n2, container, mainAnchor, internals, 1); } else { if (n2.props && n1.props && n2.props.to !== n1.props.to) { n2.props.to = n1.props.to; } } } else { if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) { const nextTarget = n2.target = resolveTarget(n2.props, querySelector); if (nextTarget) { moveTeleport(n2, nextTarget, null, internals, 0); } else if (false) // removed by dead control flow {} } else if (wasDisabled) { moveTeleport(n2, target, targetAnchor, internals, 1); } } updateCssVars(n2, disabled); } }, remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) { const { shapeFlag, children, anchor, targetStart, targetAnchor, target, props } = vnode; if (target) { hostRemove(targetStart); hostRemove(targetAnchor); } doRemove && hostRemove(anchor); if (shapeFlag & 16) { const shouldRemove = doRemove || !isTeleportDisabled(props); for (let i = 0; i < children.length; i++) { const child = children[i]; unmount(child, parentComponent, parentSuspense, shouldRemove, !!child.dynamicChildren); } } }, move: moveTeleport, hydrate: hydrateTeleport }; function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) { if (moveType === 0) { insert(vnode.targetAnchor, container, parentAnchor); } const { el, anchor, shapeFlag, children, props } = vnode; const isReorder = moveType === 2; if (isReorder) { insert(el, container, parentAnchor); } if (!isReorder || isTeleportDisabled(props)) { if (shapeFlag & 16) { for (let i = 0; i < children.length; i++) { move(children[i], container, parentAnchor, 2); } } } if (isReorder) { insert(anchor, container, parentAnchor); } } function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, { o: { nextSibling, parentNode, querySelector, insert, createText } }, hydrateChildren) { const target = vnode.target = resolveTarget(vnode.props, querySelector); if (target) { const disabled = isTeleportDisabled(vnode.props); const targetNode = target._lpa || target.firstChild; if (vnode.shapeFlag & 16) { if (disabled) { vnode.anchor = hydrateChildren(nextSibling(node), vnode, parentNode(node), parentComponent, parentSuspense, slotScopeIds, optimized); vnode.targetStart = targetNode; vnode.targetAnchor = targetNode && nextSibling(targetNode); } else { vnode.anchor = nextSibling(node); let targetAnchor = targetNode; while (targetAnchor) { if (targetAnchor && targetAnchor.nodeType === 8) { if (targetAnchor.data === "teleport start anchor") { vnode.targetStart = targetAnchor; } else if (targetAnchor.data === "teleport anchor") { vnode.targetAnchor = targetAnchor; target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor); break; } } targetAnchor = nextSibling(targetAnchor); } if (!vnode.targetAnchor) { prepareAnchor(target, vnode, createText, insert); } hydrateChildren(targetNode && nextSibling(targetNode), vnode, target, parentComponent, parentSuspense, slotScopeIds, optimized); } } updateCssVars(vnode, disabled); } return vnode.anchor && nextSibling(vnode.anchor); } const Teleport = TeleportImpl; function updateCssVars(vnode, isDisabled) { const ctx = vnode.ctx; if (ctx && ctx.ut) { let node, anchor; if (isDisabled) { node = vnode.el; anchor = vnode.anchor; } else { node = vnode.targetStart; anchor = vnode.targetAnchor; } while (node && node !== anchor) { if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid); node = node.nextSibling; } ctx.ut(); } } function prepareAnchor(target, vnode, createText, insert) { const targetStart = vnode.targetStart = createText(""); const targetAnchor = vnode.targetAnchor = createText(""); targetStart[TeleportEndKey] = targetAnchor; if (target) { insert(targetStart, target); insert(targetAnchor, target); } return targetAnchor; } const leaveCbKey = Symbol("_leaveCb"); const enterCbKey = Symbol("_enterCb"); function useTransitionState() { const state = { isMounted: false, isLeaving: false, isUnmounting: false, leavingVNodes: /* @__PURE__ */new Map() }; onMounted(() => { state.isMounted = true; }); onBeforeUnmount(() => { state.isUnmounting = true; }); return state; } const TransitionHookValidator = (/* unused pure expression or super */ null && ([Function, Array])); const BaseTransitionPropsValidators = (/* unused pure expression or super */ null && ({ mode: String, appear: Boolean, persisted: Boolean, // enter onBeforeEnter: TransitionHookValidator, onEnter: TransitionHookValidator, onAfterEnter: TransitionHookValidator, onEnterCancelled: TransitionHookValidator, // leave onBeforeLeave: TransitionHookValidator, onLeave: TransitionHookValidator, onAfterLeave: TransitionHookValidator, onLeaveCancelled: TransitionHookValidator, // appear onBeforeAppear: TransitionHookValidator, onAppear: TransitionHookValidator, onAfterAppear: TransitionHookValidator, onAppearCancelled: TransitionHookValidator })); const recursiveGetSubtree = instance => { const subTree = instance.subTree; return subTree.component ? recursiveGetSubtree(subTree.component) : subTree; }; const BaseTransitionImpl = (/* unused pure expression or super */ null && ({ name: `BaseTransition`, props: BaseTransitionPropsValidators, setup(props, { slots }) { const instance = getCurrentInstance(); const state = useTransitionState(); return () => { const children = slots.default && getTransitionRawChildren(slots.default(), true); if (!children || !children.length) { return; } const child = findNonCommentChild(children); const rawProps = toRaw(props); const { mode } = rawProps; if (false) // removed by dead control flow {} if (state.isLeaving) { return emptyPlaceholder(child); } const innerChild = getInnerChild$1(child); if (!innerChild) { return emptyPlaceholder(child); } let enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance, // #11061, ensure enterHooks is fresh after clone hooks => enterHooks = hooks); if (innerChild.type !== Comment) { setTransitionHooks(innerChild, enterHooks); } let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree); if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) { let leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance); setTransitionHooks(oldInnerChild, leavingHooks); if (mode === "out-in" && innerChild.type !== Comment) { state.isLeaving = true; leavingHooks.afterLeave = () => { state.isLeaving = false; if (!(instance.job.flags & 8)) { instance.update(); } delete leavingHooks.afterLeave; oldInnerChild = void 0; }; return emptyPlaceholder(child); } else if (mode === "in-out" && innerChild.type !== Comment) { leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => { const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild); leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild; el[leaveCbKey] = () => { earlyRemove(); el[leaveCbKey] = void 0; delete enterHooks.delayedLeave; oldInnerChild = void 0; }; enterHooks.delayedLeave = () => { delayedLeave(); delete enterHooks.delayedLeave; oldInnerChild = void 0; }; }; } else { oldInnerChild = void 0; } } else if (oldInnerChild) { oldInnerChild = void 0; } return child; }; } })); function findNonCommentChild(children) { let child = children[0]; if (children.length > 1) { let hasFound = false; for (const c of children) { if (c.type !== Comment) { if (false) // removed by dead control flow {} child = c; hasFound = true; if (true) break; } } } return child; } const BaseTransition = (/* unused pure expression or super */ null && (BaseTransitionImpl)); function getLeavingNodesForType(state, vnode) { const { leavingVNodes } = state; let leavingVNodesCache = leavingVNodes.get(vnode.type); if (!leavingVNodesCache) { leavingVNodesCache = /* @__PURE__ */Object.create(null); leavingVNodes.set(vnode.type, leavingVNodesCache); } return leavingVNodesCache; } function resolveTransitionHooks(vnode, props, state, instance, postClone) { const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props; const key = String(vnode.key); const leavingVNodesCache = getLeavingNodesForType(state, vnode); const callHook = (hook, args) => { hook && callWithAsyncErrorHandling(hook, instance, 9, args); }; const callAsyncHook = (hook, args) => { const done = args[1]; callHook(hook, args); if (isArray(hook)) { if (hook.every(hook2 => hook2.length <= 1)) done(); } else if (hook.length <= 1) { done(); } }; const hooks = { mode, persisted, beforeEnter(el) { let hook = onBeforeEnter; if (!state.isMounted) { if (appear) { hook = onBeforeAppear || onBeforeEnter; } else { return; } } if (el[leaveCbKey]) { el[leaveCbKey](true /* cancelled */); } const leavingVNode = leavingVNodesCache[key]; if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) { leavingVNode.el[leaveCbKey](); } callHook(hook, [el]); }, enter(el) { let hook = onEnter; let afterHook = onAfterEnter; let cancelHook = onEnterCancelled; if (!state.isMounted) { if (appear) { hook = onAppear || onEnter; afterHook = onAfterAppear || onAfterEnter; cancelHook = onAppearCancelled || onEnterCancelled; } else { return; } } let called = false; const done = el[enterCbKey] = cancelled => { if (called) return; called = true; if (cancelled) { callHook(cancelHook, [el]); } else { callHook(afterHook, [el]); } if (hooks.delayedLeave) { hooks.delayedLeave(); } el[enterCbKey] = void 0; }; if (hook) { callAsyncHook(hook, [el, done]); } else { done(); } }, leave(el, remove) { const key2 = String(vnode.key); if (el[enterCbKey]) { el[enterCbKey](true /* cancelled */); } if (state.isUnmounting) { return remove(); } callHook(onBeforeLeave, [el]); let called = false; const done = el[leaveCbKey] = cancelled => { if (called) return; called = true; remove(); if (cancelled) { callHook(onLeaveCancelled, [el]); } else { callHook(onAfterLeave, [el]); } el[leaveCbKey] = void 0; if (leavingVNodesCache[key2] === vnode) { delete leavingVNodesCache[key2]; } }; leavingVNodesCache[key2] = vnode; if (onLeave) { callAsyncHook(onLeave, [el, done]); } else { done(); } }, clone(vnode2) { const hooks2 = resolveTransitionHooks(vnode2, props, state, instance, postClone); if (postClone) postClone(hooks2); return hooks2; } }; return hooks; } function emptyPlaceholder(vnode) { if (isKeepAlive(vnode)) { vnode = cloneVNode(vnode); vnode.children = null; return vnode; } } function getInnerChild$1(vnode) { if (!isKeepAlive(vnode)) { if (isTeleport(vnode.type) && vnode.children) { return findNonCommentChild(vnode.children); } return vnode; } if (false) // removed by dead control flow {} const { shapeFlag, children } = vnode; if (children) { if (shapeFlag & 16) { return children[0]; } if (shapeFlag & 32 && isFunction(children.default)) { return children.default(); } } } function setTransitionHooks(vnode, hooks) { if (vnode.shapeFlag & 6 && vnode.component) { vnode.transition = hooks; setTransitionHooks(vnode.component.subTree, hooks); } else if (vnode.shapeFlag & 128) { vnode.ssContent.transition = hooks.clone(vnode.ssContent); vnode.ssFallback.transition = hooks.clone(vnode.ssFallback); } else { vnode.transition = hooks; } } function getTransitionRawChildren(children, keepComment = false, parentKey) { let ret = []; let keyedFragmentCount = 0; for (let i = 0; i < children.length; i++) { let child = children[i]; const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i); if (child.type === Fragment) { if (child.patchFlag & 128) keyedFragmentCount++; ret = ret.concat(getTransitionRawChildren(child.children, keepComment, key)); } else if (keepComment || child.type !== Comment) { ret.push(key != null ? cloneVNode(child, { key }) : child); } } if (keyedFragmentCount > 1) { for (let i = 0; i < ret.length; i++) { ret[i].patchFlag = -2; } } return ret; } /*! #__NO_SIDE_EFFECTS__ */ // @__NO_SIDE_EFFECTS__ function defineComponent(options, extraOptions) { return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isFunction */ .Tn)(options) ? // #8236: extend call and options.name access are considered side-effects // by Rollup, so we have to wrap it in a pure-annotated IIFE. /* @__PURE__ */ (() => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .extend */ .X$)({ name: options.name }, extraOptions, { setup: options }))() : options; } function useId() { const i = getCurrentInstance(); if (i) { return (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++; } else if (false) // removed by dead control flow {} return ""; } function markAsyncBoundary(instance) { instance.ids = [instance.ids[0] + instance.ids[2]++ + "-", 0, 0]; } const knownTemplateRefs = /* @__PURE__ */(/* unused pure expression or super */ null && (new WeakSet())); function useTemplateRef(key) { const i = getCurrentInstance(); const r = shallowRef(null); if (i) { const refs = i.refs === EMPTY_OBJ ? i.refs = {} : i.refs; let desc; if (false) // removed by dead control flow {} else { Object.defineProperty(refs, key, { enumerable: true, get: () => r.value, set: val => r.value = val }); } } else if (false) // removed by dead control flow {} const ret = false ? 0 : r; if (false) // removed by dead control flow {} return ret; } function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) { if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isArray */ .cy)(rawRef)) { rawRef.forEach((r, i) => setRef(r, oldRawRef && ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isArray */ .cy)(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount)); return; } if (isAsyncWrapper(vnode) && !isUnmount) { if (vnode.shapeFlag & 512 && vnode.type.__asyncResolved && vnode.component.subTree.component) { setRef(rawRef, oldRawRef, parentSuspense, vnode.component.subTree); } return; } const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el; const value = isUnmount ? null : refValue; const { i: owner, r: ref } = rawRef; if (false) // removed by dead control flow {} const oldRef = oldRawRef && oldRawRef.r; const refs = owner.refs === _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .EMPTY_OBJ */ .MZ ? owner.refs = {} : owner.refs; const setupState = owner.setupState; const rawSetupState = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .toRaw */ .ux)(setupState); const canSetSetupRef = setupState === _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .EMPTY_OBJ */ .MZ ? () => false : key => { if (false) // removed by dead control flow {} return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(rawSetupState, key); }; if (oldRef != null && oldRef !== ref) { if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isString */ .Kg)(oldRef)) { refs[oldRef] = null; if (canSetSetupRef(oldRef)) { setupState[oldRef] = null; } } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .isRef */ .i9)(oldRef)) { oldRef.value = null; } } if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isFunction */ .Tn)(ref)) { callWithErrorHandling(ref, owner, 12, [value, refs]); } else { const _isString = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isString */ .Kg)(ref); const _isRef = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .isRef */ .i9)(ref); if (_isString || _isRef) { const doSet = () => { if (rawRef.f) { const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : ref.value; if (isUnmount) { (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isArray */ .cy)(existing) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .remove */ .TF)(existing, refValue); } else { if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isArray */ .cy)(existing)) { if (_isString) { refs[ref] = [refValue]; if (canSetSetupRef(ref)) { setupState[ref] = refs[ref]; } } else { ref.value = [refValue]; if (rawRef.k) refs[rawRef.k] = ref.value; } } else if (!existing.includes(refValue)) { existing.push(refValue); } } } else if (_isString) { refs[ref] = value; if (canSetSetupRef(ref)) { setupState[ref] = value; } } else if (_isRef) { ref.value = value; if (rawRef.k) refs[rawRef.k] = value; } else if (false) // removed by dead control flow {} }; if (value) { doSet.id = -1; queuePostRenderEffect(doSet, parentSuspense); } else { doSet(); } } else if (false) // removed by dead control flow {} } } let hasLoggedMismatchError = false; const logMismatchError = () => { if (hasLoggedMismatchError) { return; } console.error("Hydration completed but contains mismatches."); hasLoggedMismatchError = true; }; const isSVGContainer = container => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject"; const isMathMLContainer = container => container.namespaceURI.includes("MathML"); const getContainerType = container => { if (container.nodeType !== 1) return void 0; if (isSVGContainer(container)) return "svg"; if (isMathMLContainer(container)) return "mathml"; return void 0; }; const isComment = node => node.nodeType === 8; function createHydrationFunctions(rendererInternals) { const { mt: mountComponent, p: patch, o: { patchProp, createText, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals; const hydrate = (vnode, container) => { if (!container.hasChildNodes()) { ( false) && 0; patch(null, vnode, container); flushPostFlushCbs(); container._vnode = vnode; return; } hydrateNode(container.firstChild, vnode, null, null, null); flushPostFlushCbs(); container._vnode = vnode; }; const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => { optimized = optimized || !!vnode.dynamicChildren; const isFragmentStart = isComment(node) && node.data === "["; const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart); const { type, ref, shapeFlag, patchFlag } = vnode; let domType = node.nodeType; vnode.el = node; if (false) // removed by dead control flow {} if (patchFlag === -2) { optimized = false; vnode.dynamicChildren = null; } let nextNode = null; switch (type) { case Text: if (domType !== 3) { if (vnode.children === "") { insert(vnode.el = createText(""), parentNode(node), node); nextNode = node; } else { nextNode = onMismatch(); } } else { if (node.data !== vnode.children) { ( false) && 0; logMismatchError(); node.data = vnode.children; } nextNode = nextSibling(node); } break; case Comment: if (isTemplateNode(node)) { nextNode = nextSibling(node); replaceNode(vnode.el = node.content.firstChild, node, parentComponent); } else if (domType !== 8 || isFragmentStart) { nextNode = onMismatch(); } else { nextNode = nextSibling(node); } break; case Static: if (isFragmentStart) { node = nextSibling(node); domType = node.nodeType; } if (domType === 1 || domType === 3) { nextNode = node; const needToAdoptContent = !vnode.children.length; for (let i = 0; i < vnode.staticCount; i++) { if (needToAdoptContent) vnode.children += nextNode.nodeType === 1 ? nextNode.outerHTML : nextNode.data; if (i === vnode.staticCount - 1) { vnode.anchor = nextNode; } nextNode = nextSibling(nextNode); } return isFragmentStart ? nextSibling(nextNode) : nextNode; } else { onMismatch(); } break; case Fragment: if (!isFragmentStart) { nextNode = onMismatch(); } else { nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); } break; default: if (shapeFlag & 1) { if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) { nextNode = onMismatch(); } else { nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); } } else if (shapeFlag & 6) { vnode.slotScopeIds = slotScopeIds; const container = parentNode(node); if (isFragmentStart) { nextNode = locateClosingAnchor(node); } else if (isComment(node) && node.data === "teleport start") { nextNode = locateClosingAnchor(node, node.data, "teleport end"); } else { nextNode = nextSibling(node); } mountComponent(vnode, container, null, parentComponent, parentSuspense, getContainerType(container), optimized); if (isAsyncWrapper(vnode) && !vnode.type.__asyncResolved) { let subTree; if (isFragmentStart) { subTree = createVNode(Fragment); subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild; } else { subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div"); } subTree.el = node; vnode.component.subTree = subTree; } } else if (shapeFlag & 64) { if (domType !== 8) { nextNode = onMismatch(); } else { nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren); } } else if (shapeFlag & 128) { nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, getContainerType(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode); } else if (false) // removed by dead control flow {} } if (ref != null) { setRef(ref, null, parentSuspense, vnode); } return nextNode; }; const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { optimized = optimized || !!vnode.dynamicChildren; const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode; const forcePatch = type === "input" || type === "option"; if ( false || forcePatch || patchFlag !== -1) { if (dirs) { invokeDirectiveHook(vnode, null, parentComponent, "created"); } let needCallTransitionHooks = false; if (isTemplateNode(el)) { needCallTransitionHooks = needTransition(null, // no need check parentSuspense in hydration transition) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear; const content = el.content.firstChild; if (needCallTransitionHooks) { transition.beforeEnter(content); } replaceNode(content, el, parentComponent); vnode.el = el = content; } if (shapeFlag & 16 && // skip if element has innerHTML / textContent !(props && (props.innerHTML || props.textContent))) { let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, slotScopeIds, optimized); let hasWarned = false; while (next) { if (!isMismatchAllowed(el, 1 /* CHILDREN */)) { if (false) // removed by dead control flow {} logMismatchError(); } const cur = next; next = next.nextSibling; remove(cur); } } else if (shapeFlag & 8) { let clientText = vnode.children; if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) { clientText = clientText.slice(1); } if (el.textContent !== clientText) { if (!isMismatchAllowed(el, 0 /* TEXT */)) { ( false) && 0; logMismatchError(); } el.textContent = vnode.children; } } if (props) { if ( false || forcePatch || !optimized || patchFlag & (16 | 32)) { const isCustomElement = el.tagName.includes("-"); for (const key in props) { if (false) // removed by dead control flow {} if (forcePatch && (key.endsWith("value") || key === "indeterminate") || isOn(key) && !isReservedProp(key) || // force hydrate v-bind with .prop modifiers key[0] === "." || isCustomElement) { patchProp(el, key, null, props[key], void 0, parentComponent); } } } else if (props.onClick) { patchProp(el, "onClick", null, props.onClick, void 0, parentComponent); } else if (patchFlag & 4 && isReactive(props.style)) { for (const key in props.style) props.style[key]; } } let vnodeHooks; if (vnodeHooks = props && props.onVnodeBeforeMount) { invokeVNodeHook(vnodeHooks, parentComponent, vnode); } if (dirs) { invokeDirectiveHook(vnode, null, parentComponent, "beforeMount"); } if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) { queueEffectWithSuspense(() => { vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode); needCallTransitionHooks && transition.enter(el); dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted"); }, parentSuspense); } } return el.nextSibling; }; const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => { optimized = optimized || !!parentVNode.dynamicChildren; const children = parentVNode.children; const l = children.length; let hasWarned = false; for (let i = 0; i < l; i++) { const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]); const isText = vnode.type === Text; if (node) { if (isText && !optimized) { if (i + 1 < l && normalizeVNode(children[i + 1]).type === Text) { insert(createText(node.data.slice(vnode.children.length)), container, nextSibling(node)); node.data = vnode.children; } } node = hydrateNode(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); } else if (isText && !vnode.children) { insert(vnode.el = createText(""), container); } else { if (!isMismatchAllowed(container, 1 /* CHILDREN */)) { if (false) // removed by dead control flow {} logMismatchError(); } patch(null, vnode, container, null, parentComponent, parentSuspense, getContainerType(container), slotScopeIds); } } return node; }; const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { const { slotScopeIds: fragmentSlotScopeIds } = vnode; if (fragmentSlotScopeIds) { slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds; } const container = parentNode(node); const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized); if (next && isComment(next) && next.data === "]") { return nextSibling(vnode.anchor = next); } else { logMismatchError(); insert(vnode.anchor = createComment(`]`), container, next); return next; } }; const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => { if (!isMismatchAllowed(node.parentElement, 1 /* CHILDREN */)) { ( false) && 0; logMismatchError(); } vnode.el = null; if (isFragment) { const end = locateClosingAnchor(node); while (true) { const next2 = nextSibling(node); if (next2 && next2 !== end) { remove(next2); } else { break; } } } const next = nextSibling(node); const container = parentNode(node); remove(node); patch(null, vnode, container, next, parentComponent, parentSuspense, getContainerType(container), slotScopeIds); if (parentComponent) { parentComponent.vnode.el = vnode.el; updateHOCHostEl(parentComponent, vnode.el); } return next; }; const locateClosingAnchor = (node, open = "[", close = "]") => { let match = 0; while (node) { node = nextSibling(node); if (node && isComment(node)) { if (node.data === open) match++; if (node.data === close) { if (match === 0) { return nextSibling(node); } else { match--; } } } } return node; }; const replaceNode = (newNode, oldNode, parentComponent) => { const parentNode2 = oldNode.parentNode; if (parentNode2) { parentNode2.replaceChild(newNode, oldNode); } let parent = parentComponent; while (parent) { if (parent.vnode.el === oldNode) { parent.vnode.el = parent.subTree.el = newNode; } parent = parent.parent; } }; const isTemplateNode = node => { return node.nodeType === 1 && node.tagName === "TEMPLATE"; }; return [hydrate, hydrateNode]; } function propHasMismatch(el, key, clientValue, vnode, instance) { let mismatchType; let mismatchKey; let actual; let expected; if (key === "class") { actual = el.getAttribute("class"); expected = normalizeClass(clientValue); if (!isSetEqual(toClassSet(actual || ""), toClassSet(expected))) { mismatchType = 2 /* CLASS */; mismatchKey = `class`; } } else if (key === "style") { actual = el.getAttribute("style") || ""; expected = isString(clientValue) ? clientValue : stringifyStyle(normalizeStyle(clientValue)); const actualMap = toStyleMap(actual); const expectedMap = toStyleMap(expected); if (vnode.dirs) { for (const { dir, value } of vnode.dirs) { if (dir.name === "show" && !value) { expectedMap.set("display", "none"); } } } if (instance) { resolveCssVars(instance, vnode, expectedMap); } if (!isMapEqual(actualMap, expectedMap)) { mismatchType = 3 /* STYLE */; mismatchKey = "style"; } } else if (el instanceof SVGElement && isKnownSvgAttr(key) || el instanceof HTMLElement && (isBooleanAttr(key) || isKnownHtmlAttr(key))) { if (isBooleanAttr(key)) { actual = el.hasAttribute(key); expected = includeBooleanAttr(clientValue); } else if (clientValue == null) { actual = el.hasAttribute(key); expected = false; } else { if (el.hasAttribute(key)) { actual = el.getAttribute(key); } else if (key === "value" && el.tagName === "TEXTAREA") { actual = el.value; } else { actual = false; } expected = isRenderableAttrValue(clientValue) ? String(clientValue) : false; } if (actual !== expected) { mismatchType = 4 /* ATTRIBUTE */; mismatchKey = key; } } if (mismatchType != null && !isMismatchAllowed(el, mismatchType)) { const format = v => v === false ? `(not rendered)` : `${mismatchKey}="${v}"`; const preSegment = `Hydration ${MismatchTypeString[mismatchType]} mismatch on`; const postSegment = ` - rendered on server: ${format(actual)} - expected on client: ${format(expected)} Note: this mismatch is check-only. The DOM will not be rectified in production due to performance overhead. You should fix the source of the mismatch.`; { warn$1(preSegment, el, postSegment); } return true; } return false; } function toClassSet(str) { return new Set(str.trim().split(/\s+/)); } function isSetEqual(a, b) { if (a.size !== b.size) { return false; } for (const s of a) { if (!b.has(s)) { return false; } } return true; } function toStyleMap(str) { const styleMap = /* @__PURE__ */new Map(); for (const item of str.split(";")) { let [key, value] = item.split(":"); key = key.trim(); value = value && value.trim(); if (key && value) { styleMap.set(key, value); } } return styleMap; } function isMapEqual(a, b) { if (a.size !== b.size) { return false; } for (const [key, value] of a) { if (value !== b.get(key)) { return false; } } return true; } function resolveCssVars(instance, vnode, expectedMap) { const root = instance.subTree; if (instance.getCssVars && (vnode === root || root && root.type === Fragment && root.children.includes(vnode))) { const cssVars = instance.getCssVars(); for (const key in cssVars) { expectedMap.set(`--${getEscapedCssVarName(key, false)}`, String(cssVars[key])); } } if (vnode === root && instance.parent) { resolveCssVars(instance.parent, instance.vnode, expectedMap); } } const allowMismatchAttr = "data-allow-mismatch"; const MismatchTypeString = (/* unused pure expression or super */ null && ({ [0 /* TEXT */]: "text", [1 /* CHILDREN */]: "children", [2 /* CLASS */]: "class", [3 /* STYLE */]: "style", [4 /* ATTRIBUTE */]: "attribute" })); function isMismatchAllowed(el, allowedType) { if (allowedType === 0 /* TEXT */ || allowedType === 1 /* CHILDREN */) { while (el && !el.hasAttribute(allowMismatchAttr)) { el = el.parentElement; } } const allowedAttr = el && el.getAttribute(allowMismatchAttr); if (allowedAttr == null) { return false; } else if (allowedAttr === "") { return true; } else { const list = allowedAttr.split(","); if (allowedType === 0 /* TEXT */ && list.includes("children")) { return true; } return allowedAttr.split(",").includes(MismatchTypeString[allowedType]); } } const requestIdleCallback = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .getGlobalThis */ .We)().requestIdleCallback || (cb => setTimeout(cb, 1)); const cancelIdleCallback = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .getGlobalThis */ .We)().cancelIdleCallback || (id => clearTimeout(id)); const hydrateOnIdle = (timeout = 1e4) => hydrate => { const id = requestIdleCallback(hydrate, { timeout }); return () => cancelIdleCallback(id); }; function elementIsVisibleInViewport(el) { const { top, left, bottom, right } = el.getBoundingClientRect(); const { innerHeight, innerWidth } = window; return (top > 0 && top < innerHeight || bottom > 0 && bottom < innerHeight) && (left > 0 && left < innerWidth || right > 0 && right < innerWidth); } const hydrateOnVisible = opts => (hydrate, forEach) => { const ob = new IntersectionObserver(entries => { for (const e of entries) { if (!e.isIntersecting) continue; ob.disconnect(); hydrate(); break; } }, opts); forEach(el => { if (!(el instanceof Element)) return; if (elementIsVisibleInViewport(el)) { hydrate(); ob.disconnect(); return false; } ob.observe(el); }); return () => ob.disconnect(); }; const hydrateOnMediaQuery = query => hydrate => { if (query) { const mql = matchMedia(query); if (mql.matches) { hydrate(); } else { mql.addEventListener("change", hydrate, { once: true }); return () => mql.removeEventListener("change", hydrate); } } }; const hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => { if (isString(interactions)) interactions = [interactions]; let hasHydrated = false; const doHydrate = e => { if (!hasHydrated) { hasHydrated = true; teardown(); hydrate(); e.target.dispatchEvent(new e.constructor(e.type, e)); } }; const teardown = () => { forEach(el => { for (const i of interactions) { el.removeEventListener(i, doHydrate); } }); }; forEach(el => { for (const i of interactions) { el.addEventListener(i, doHydrate, { once: true }); } }); return teardown; }; function forEachElement(node, cb) { if (isComment(node) && node.data === "[") { let depth = 1; let next = node.nextSibling; while (next) { if (next.nodeType === 1) { const result = cb(next); if (result === false) { break; } } else if (isComment(next)) { if (next.data === "]") { if (--depth === 0) break; } else if (next.data === "[") { depth++; } } next = next.nextSibling; } } else { cb(node); } } const isAsyncWrapper = i => !!i.type.__asyncLoader; /*! #__NO_SIDE_EFFECTS__ */ // @__NO_SIDE_EFFECTS__ function defineAsyncComponent(source) { if (isFunction(source)) { source = { loader: source }; } const { loader, loadingComponent, errorComponent, delay = 200, hydrate: hydrateStrategy, timeout, // undefined = never times out suspensible = true, onError: userOnError } = source; let pendingRequest = null; let resolvedComp; let retries = 0; const retry = () => { retries++; pendingRequest = null; return load(); }; const load = () => { let thisRequest; return pendingRequest || (thisRequest = pendingRequest = loader().catch(err => { err = err instanceof Error ? err : new Error(String(err)); if (userOnError) { return new Promise((resolve, reject) => { const userRetry = () => resolve(retry()); const userFail = () => reject(err); userOnError(err, userRetry, userFail, retries + 1); }); } else { throw err; } }).then(comp => { if (thisRequest !== pendingRequest && pendingRequest) { return pendingRequest; } if (false) // removed by dead control flow {} if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) { comp = comp.default; } if (false) // removed by dead control flow {} resolvedComp = comp; return comp; })); }; return defineComponent({ name: "AsyncComponentWrapper", __asyncLoader: load, __asyncHydrate(el, instance, hydrate) { const doHydrate = hydrateStrategy ? () => { const teardown = hydrateStrategy(hydrate, cb => forEachElement(el, cb)); if (teardown) { (instance.bum || (instance.bum = [])).push(teardown); } } : hydrate; if (resolvedComp) { doHydrate(); } else { load().then(() => !instance.isUnmounted && doHydrate()); } }, get __asyncResolved() { return resolvedComp; }, setup() { const instance = currentInstance; markAsyncBoundary(instance); if (resolvedComp) { return () => createInnerComp(resolvedComp, instance); } const onError = err => { pendingRequest = null; handleError(err, instance, 13, !errorComponent); }; if (suspensible && instance.suspense || isInSSRComponentSetup) { return load().then(comp => { return () => createInnerComp(comp, instance); }).catch(err => { onError(err); return () => errorComponent ? createVNode(errorComponent, { error: err }) : null; }); } const loaded = ref(false); const error = ref(); const delayed = ref(!!delay); if (delay) { setTimeout(() => { delayed.value = false; }, delay); } if (timeout != null) { setTimeout(() => { if (!loaded.value && !error.value) { const err = new Error(`Async component timed out after ${timeout}ms.`); onError(err); error.value = err; } }, timeout); } load().then(() => { loaded.value = true; if (instance.parent && isKeepAlive(instance.parent.vnode)) { instance.parent.update(); } }).catch(err => { onError(err); error.value = err; }); return () => { if (loaded.value && resolvedComp) { return createInnerComp(resolvedComp, instance); } else if (error.value && errorComponent) { return createVNode(errorComponent, { error: error.value }); } else if (loadingComponent && !delayed.value) { return createVNode(loadingComponent); } }; } }); } function createInnerComp(comp, parent) { const { ref: ref2, props, children, ce } = parent.vnode; const vnode = createVNode(comp, props, children); vnode.ref = ref2; vnode.ce = ce; delete parent.vnode.ce; return vnode; } const isKeepAlive = vnode => vnode.type.__isKeepAlive; const KeepAliveImpl = (/* unused pure expression or super */ null && ({ name: `KeepAlive`, // Marker for special handling inside the renderer. We are not using a === // check directly on KeepAlive in the renderer, because importing it directly // would prevent it from being tree-shaken. __isKeepAlive: true, props: { include: [String, RegExp, Array], exclude: [String, RegExp, Array], max: [String, Number] }, setup(props, { slots }) { const instance = getCurrentInstance(); const sharedContext = instance.ctx; if (!sharedContext.renderer) { return () => { const children = slots.default && slots.default(); return children && children.length === 1 ? children[0] : children; }; } const cache = /* @__PURE__ */new Map(); const keys = /* @__PURE__ */new Set(); let current = null; if (false) // removed by dead control flow {} const parentSuspense = instance.suspense; const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext; const storageContainer = createElement("div"); sharedContext.activate = (vnode, container, anchor, namespace, optimized) => { const instance2 = vnode.component; move(vnode, container, anchor, 0, parentSuspense); patch(instance2.vnode, vnode, container, anchor, instance2, parentSuspense, namespace, vnode.slotScopeIds, optimized); queuePostRenderEffect(() => { instance2.isDeactivated = false; if (instance2.a) { invokeArrayFns(instance2.a); } const vnodeHook = vnode.props && vnode.props.onVnodeMounted; if (vnodeHook) { invokeVNodeHook(vnodeHook, instance2.parent, vnode); } }, parentSuspense); if (false) // removed by dead control flow {} }; sharedContext.deactivate = vnode => { const instance2 = vnode.component; invalidateMount(instance2.m); invalidateMount(instance2.a); move(vnode, storageContainer, null, 1, parentSuspense); queuePostRenderEffect(() => { if (instance2.da) { invokeArrayFns(instance2.da); } const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted; if (vnodeHook) { invokeVNodeHook(vnodeHook, instance2.parent, vnode); } instance2.isDeactivated = true; }, parentSuspense); if (false) // removed by dead control flow {} }; function unmount(vnode) { resetShapeFlag(vnode); _unmount(vnode, instance, parentSuspense, true); } function pruneCache(filter) { cache.forEach((vnode, key) => { const name = getComponentName(vnode.type); if (name && !filter(name)) { pruneCacheEntry(key); } }); } function pruneCacheEntry(key) { const cached = cache.get(key); if (cached && (!current || !isSameVNodeType(cached, current))) { unmount(cached); } else if (current) { resetShapeFlag(current); } cache.delete(key); keys.delete(key); } watch(() => [props.include, props.exclude], ([include, exclude]) => { include && pruneCache(name => matches(include, name)); exclude && pruneCache(name => !matches(exclude, name)); }, // prune post-render after `current` has been updated { flush: "post", deep: true }); let pendingCacheKey = null; const cacheSubtree = () => { if (pendingCacheKey != null) { if (isSuspense(instance.subTree.type)) { queuePostRenderEffect(() => { cache.set(pendingCacheKey, getInnerChild(instance.subTree)); }, instance.subTree.suspense); } else { cache.set(pendingCacheKey, getInnerChild(instance.subTree)); } } }; onMounted(cacheSubtree); onUpdated(cacheSubtree); onBeforeUnmount(() => { cache.forEach(cached => { const { subTree, suspense } = instance; const vnode = getInnerChild(subTree); if (cached.type === vnode.type && cached.key === vnode.key) { resetShapeFlag(vnode); const da = vnode.component.da; da && queuePostRenderEffect(da, suspense); return; } unmount(cached); }); }); return () => { pendingCacheKey = null; if (!slots.default) { return current = null; } const children = slots.default(); const rawVNode = children[0]; if (children.length > 1) { if (false) // removed by dead control flow {} current = null; return children; } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) { current = null; return rawVNode; } let vnode = getInnerChild(rawVNode); if (vnode.type === Comment) { current = null; return vnode; } const comp = vnode.type; const name = getComponentName(isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp); const { include, exclude, max } = props; if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) { vnode.shapeFlag &= ~256; current = vnode; return rawVNode; } const key = vnode.key == null ? comp : vnode.key; const cachedVNode = cache.get(key); if (vnode.el) { vnode = cloneVNode(vnode); if (rawVNode.shapeFlag & 128) { rawVNode.ssContent = vnode; } } pendingCacheKey = key; if (cachedVNode) { vnode.el = cachedVNode.el; vnode.component = cachedVNode.component; if (vnode.transition) { setTransitionHooks(vnode, vnode.transition); } vnode.shapeFlag |= 512; keys.delete(key); keys.add(key); } else { keys.add(key); if (max && keys.size > parseInt(max, 10)) { pruneCacheEntry(keys.values().next().value); } } vnode.shapeFlag |= 256; current = vnode; return isSuspense(rawVNode.type) ? rawVNode : vnode; }; } })); const KeepAlive = (/* unused pure expression or super */ null && (KeepAliveImpl)); function matches(pattern, name) { if (isArray(pattern)) { return pattern.some(p => matches(p, name)); } else if (isString(pattern)) { return pattern.split(",").includes(name); } else if (isRegExp(pattern)) { pattern.lastIndex = 0; return pattern.test(name); } return false; } function onActivated(hook, target) { registerKeepAliveHook(hook, "a", target); } function onDeactivated(hook, target) { registerKeepAliveHook(hook, "da", target); } function registerKeepAliveHook(hook, type, target = currentInstance) { const wrappedHook = hook.__wdc || (hook.__wdc = () => { let current = target; while (current) { if (current.isDeactivated) { return; } current = current.parent; } return hook(); }); injectHook(type, wrappedHook, target); if (target) { let current = target.parent; while (current && current.parent) { if (isKeepAlive(current.parent.vnode)) { injectToKeepAliveRoot(wrappedHook, type, target, current); } current = current.parent; } } } function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */); onUnmounted(() => { (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .remove */ .TF)(keepAliveRoot[type], injected); }, target); } function resetShapeFlag(vnode) { vnode.shapeFlag &= ~256; vnode.shapeFlag &= ~512; } function getInnerChild(vnode) { return vnode.shapeFlag & 128 ? vnode.ssContent : vnode; } function injectHook(type, hook, target = currentInstance, prepend = false) { if (target) { const hooks = target[type] || (target[type] = []); const wrappedHook = hook.__weh || (hook.__weh = (...args) => { (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .pauseTracking */ .C4)(); const reset = setCurrentInstance(target); const res = callWithAsyncErrorHandling(hook, target, type, args); reset(); (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .resetTracking */ .bl)(); return res; }); if (prepend) { hooks.unshift(wrappedHook); } else { hooks.push(wrappedHook); } return wrappedHook; } else if (false) // removed by dead control flow {} } const createHook = lifecycle => (hook, target = currentInstance) => { if (!isInSSRComponentSetup || lifecycle === "sp") { injectHook(lifecycle, (...args) => hook(...args), target); } }; const onBeforeMount = createHook("bm"); const onMounted = createHook("m"); const onBeforeUpdate = createHook("bu"); const onUpdated = createHook("u"); const onBeforeUnmount = createHook("bum"); const onUnmounted = createHook("um"); const onServerPrefetch = createHook("sp"); const onRenderTriggered = createHook("rtg"); const onRenderTracked = createHook("rtc"); function onErrorCaptured(hook, target = currentInstance) { injectHook("ec", hook, target); } const COMPONENTS = "components"; const DIRECTIVES = "directives"; function resolveComponent(name, maybeSelfReference) { return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name; } const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc"); function resolveDynamicComponent(component) { if (isString(component)) { return resolveAsset(COMPONENTS, component, false) || component; } else { return component || NULL_DYNAMIC_COMPONENT; } } function resolveDirective(name) { return resolveAsset(DIRECTIVES, name); } function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) { const instance = currentRenderingInstance || currentInstance; if (instance) { const Component = instance.type; if (type === COMPONENTS) { const selfName = getComponentName(Component, false); if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) { return Component; } } const res = // local registration // check instance[type] first which is resolved for options API resolve(instance[type] || Component[type], name) || // global registration resolve(instance.appContext[type], name); if (!res && maybeSelfReference) { return Component; } if (false) // removed by dead control flow {} return res; } else if (false) // removed by dead control flow {} } function resolve(registry, name) { return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]); } function renderList(source, renderItem, cache, index) { let ret; const cached = cache && cache[index]; const sourceIsArray = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isArray */ .cy)(source); if (sourceIsArray || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isString */ .Kg)(source)) { const sourceIsReactiveArray = sourceIsArray && (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .isReactive */ .g8)(source); let needsWrap = false; if (sourceIsReactiveArray) { needsWrap = !(0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .isShallow */ .fE)(source); source = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .shallowReadArray */ .qA)(source); } ret = new Array(source.length); for (let i = 0, l = source.length; i < l; i++) { ret[i] = renderItem(needsWrap ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .toReactive */ .lJ)(source[i]) : source[i], i, void 0, cached && cached[i]); } } else if (typeof source === "number") { if (false) // removed by dead control flow {} ret = new Array(source); for (let i = 0; i < source; i++) { ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]); } } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .isObject */ .Gv)(source)) { if (source[Symbol.iterator]) { ret = Array.from(source, (item, i) => renderItem(item, i, void 0, cached && cached[i])); } else { const keys = Object.keys(source); ret = new Array(keys.length); for (let i = 0, l = keys.length; i < l; i++) { const key = keys[i]; ret[i] = renderItem(source[key], key, i, cached && cached[i]); } } } else { ret = []; } if (cache) { cache[index] = ret; } return ret; } function createSlots(slots, dynamicSlots) { for (let i = 0; i < dynamicSlots.length; i++) { const slot = dynamicSlots[i]; if (isArray(slot)) { for (let j = 0; j < slot.length; j++) { slots[slot[j].name] = slot[j].fn; } } else if (slot) { slots[slot.name] = slot.key ? (...args) => { const res = slot.fn(...args); if (res) res.key = slot.key; return res; } : slot.fn; } } return slots; } function renderSlot(slots, name, props = {}, fallback, noSlotted) { if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) { if (name !== "default") props.name = name; return openBlock(), createBlock(Fragment, null, [createVNode("slot", props, fallback && fallback())], 64); } let slot = slots[name]; if (false) // removed by dead control flow {} if (slot && slot._c) { slot._d = false; } openBlock(); const validSlotContent = slot && ensureValidVNode(slot(props)); const slotKey = props.key || // slot content array of a dynamic conditional slot may have a branch // key attached in the `createSlots` helper, respect that validSlotContent && validSlotContent.key; const rendered = createBlock(Fragment, { key: (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) + ( // #7256 force differentiate fallback content from actual content !validSlotContent && fallback ? "_fb" : "") }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 ? 64 : -2); if (!noSlotted && rendered.scopeId) { rendered.slotScopeIds = [rendered.scopeId + "-s"]; } if (slot && slot._c) { slot._d = true; } return rendered; } function ensureValidVNode(vnodes) { return vnodes.some(child => { if (!isVNode(child)) return true; if (child.type === Comment) return false; if (child.type === Fragment && !ensureValidVNode(child.children)) return false; return true; }) ? vnodes : null; } function toHandlers(obj, preserveCaseIfNecessary) { const ret = {}; if (false) // removed by dead control flow {} for (const key in obj) { ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key]; } return ret; } const getPublicInstance = i => { if (!i) return null; if (isStatefulComponent(i)) return getComponentPublicInstance(i); return getPublicInstance(i.parent); }; const publicPropertiesMap = // Move PURE marker to new line to workaround compiler discarding it // due to type annotation /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .extend */ .X$)(/* @__PURE__ */Object.create(null), { $: i => i, $el: i => i.vnode.el, $data: i => i.data, $props: i => false ? 0 : i.props, $attrs: i => false ? 0 : i.attrs, $slots: i => false ? 0 : i.slots, $refs: i => false ? 0 : i.refs, $parent: i => getPublicInstance(i.parent), $root: i => getPublicInstance(i.root), $host: i => i.ce, $emit: i => i.emit, $options: i => true ? resolveMergedOptions(i) : 0, $forceUpdate: i => i.f || (i.f = () => { queueJob(i.update); }), $nextTick: i => i.n || (i.n = nextTick.bind(i.proxy)), $watch: i => true ? instanceWatch.bind(i) : 0 }); const isReservedPrefix = key => key === "_" || key === "$"; const hasSetupBinding = (state, key) => state !== _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .EMPTY_OBJ */ .MZ && !state.__isScriptSetup && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(state, key); const PublicInstanceProxyHandlers = { get({ _: instance }, key) { if (key === "__v_skip") { return true; } const { ctx, setupState, data, props, accessCache, type, appContext } = instance; if (false) // removed by dead control flow {} let normalizedProps; if (key[0] !== "$") { const n = accessCache[key]; if (n !== void 0) { switch (n) { case 1 /* SETUP */: return setupState[key]; case 2 /* DATA */: return data[key]; case 4 /* CONTEXT */: return ctx[key]; case 3 /* PROPS */: return props[key]; } } else if (hasSetupBinding(setupState, key)) { accessCache[key] = 1 /* SETUP */; return setupState[key]; } else if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .EMPTY_OBJ */ .MZ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(data, key)) { accessCache[key] = 2 /* DATA */; return data[key]; } else if ( // only cache other properties when instance has declared (thus stable) // props (normalizedProps = instance.propsOptions[0]) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(normalizedProps, key)) { accessCache[key] = 3 /* PROPS */; return props[key]; } else if (ctx !== _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .EMPTY_OBJ */ .MZ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(ctx, key)) { accessCache[key] = 4 /* CONTEXT */; return ctx[key]; } else if ( false || shouldCacheAccess) { accessCache[key] = 0 /* OTHER */; } } const publicGetter = publicPropertiesMap[key]; let cssModule, globalProperties; if (publicGetter) { if (key === "$attrs") { (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_20__/* .track */ .u4)(instance.attrs, "get", ""); false && 0; } else if (false) // removed by dead control flow {} return publicGetter(instance); } else if ( // css module (injected by vue-loader) (cssModule = type.__cssModules) && (cssModule = cssModule[key])) { return cssModule; } else if (ctx !== _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .EMPTY_OBJ */ .MZ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(ctx, key)) { accessCache[key] = 4 /* CONTEXT */; return ctx[key]; } else if ( // global properties globalProperties = appContext.config.globalProperties, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(globalProperties, key)) { { return globalProperties[key]; } } else if (false) // removed by dead control flow {} }, set({ _: instance }, key, value) { const { data, setupState, ctx } = instance; if (hasSetupBinding(setupState, key)) { setupState[key] = value; return true; } else if (false) // removed by dead control flow {} else if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .EMPTY_OBJ */ .MZ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(data, key)) { data[key] = value; return true; } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(instance.props, key)) { false && 0; return false; } if (key[0] === "$" && key.slice(1) in instance) { false && 0; return false; } else { if (false) // removed by dead control flow {} else { ctx[key] = value; } } return true; }, has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) { let normalizedProps; return !!accessCache[key] || data !== _vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .EMPTY_OBJ */ .MZ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(normalizedProps, key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(ctx, key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(publicPropertiesMap, key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(appContext.config.globalProperties, key); }, defineProperty(target, key, descriptor) { if (descriptor.get != null) { target._.accessCache[key] = 0; } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_21__/* .hasOwn */ .$3)(descriptor, "value")) { this.set(target, key, descriptor.value, null); } return Reflect.defineProperty(target, key, descriptor); } }; if (false) // removed by dead control flow {} const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */(/* unused pure expression or super */ null && (extend({}, PublicInstanceProxyHandlers, { get(target, key) { if (key === Symbol.unscopables) { return; } return PublicInstanceProxyHandlers.get(target, key, target); }, has(_, key) { const has = key[0] !== "_" && !isGloballyAllowed(key); if (false) // removed by dead control flow {} return has; } }))); function createDevRenderContext(instance) { const target = {}; Object.defineProperty(target, `_`, { configurable: true, enumerable: false, get: () => instance }); Object.keys(publicPropertiesMap).forEach(key => { Object.defineProperty(target, key, { configurable: true, enumerable: false, get: () => publicPropertiesMap[key](instance), // intercepted by the proxy so no need for implementation, // but needed to prevent set errors set: NOOP }); }); return target; } function exposePropsOnRenderContext(instance) { const { ctx, propsOptions: [propsOptions] } = instance; if (propsOptions) { Object.keys(propsOptions).forEach(key => { Object.defineProperty(ctx, key, { enumerable: true, configurable: true, get: () => instance.props[key], set: NOOP }); }); } } function exposeSetupStateOnRenderContext(instance) { const { ctx, setupState } = instance; Object.keys(toRaw(setupState)).forEach(key => { if (!setupState.__isScriptSetup) { if (isReservedPrefix(key[0])) { warn$1(`setup() return property ${JSON.stringify(key)} should not start with "$" or "_" which are reserved prefixes for Vue internals.`); return; } Object.defineProperty(ctx, key, { enumerable: true, configurable: true, get: () => setupState[key], set: NOOP }); } }); } const warnRuntimeUsage = method => warn$1(`${method}() is a compiler-hint helper that is only usable inside