From 22d00f0ac18fe68dbacf207820bb90a9738b7fcb Mon Sep 17 00:00:00 2001 From: Robin Pedersen Date: Sun, 20 Dec 2020 19:11:30 +0100 Subject: [PATCH 1/4] Migrate to Vue 3 --- dist/vue-virtual-scroller.css | 2 +- dist/vue-virtual-scroller.esm.js | 503 +- dist/vue-virtual-scroller.esm.js.map | 2 +- dist/vue-virtual-scroller.min.js | 2 +- dist/vue-virtual-scroller.min.js.map | 2 +- dist/vue-virtual-scroller.umd.js | 7503 ++++++++++++++++++++++-- dist/vue-virtual-scroller.umd.js.map | 2 +- package.json | 10 +- src/components/DynamicScrollerItem.vue | 2 +- src/components/RecycleScroller.vue | 23 +- src/mixins/IdState.js | 13 +- yarn.lock | 1384 +---- 12 files changed, 7298 insertions(+), 2150 deletions(-) diff --git a/dist/vue-virtual-scroller.css b/dist/vue-virtual-scroller.css index a0d607b8..e7edcb39 100644 --- a/dist/vue-virtual-scroller.css +++ b/dist/vue-virtual-scroller.css @@ -1 +1 @@ -.vue-recycle-scroller{position:relative}.vue-recycle-scroller.direction-vertical:not(.page-mode){overflow-y:auto}.vue-recycle-scroller.direction-horizontal:not(.page-mode){overflow-x:auto}.vue-recycle-scroller.direction-horizontal{display:-webkit-box;display:-ms-flexbox;display:flex}.vue-recycle-scroller__slot{-webkit-box-flex:1;-ms-flex:auto 0 0px;flex:auto 0 0}.vue-recycle-scroller__item-wrapper{-webkit-box-flex:1;-ms-flex:1;flex:1;-webkit-box-sizing:border-box;box-sizing:border-box;overflow:hidden;position:relative}.vue-recycle-scroller.ready .vue-recycle-scroller__item-view{position:absolute;top:0;left:0;will-change:transform}.vue-recycle-scroller.direction-vertical .vue-recycle-scroller__item-wrapper{width:100%}.vue-recycle-scroller.direction-horizontal .vue-recycle-scroller__item-wrapper{height:100%}.vue-recycle-scroller.ready.direction-vertical .vue-recycle-scroller__item-view{width:100%}.vue-recycle-scroller.ready.direction-horizontal .vue-recycle-scroller__item-view{height:100%}.resize-observer[data-v-b329ee4c]{position:absolute;top:0;left:0;z-index:-1;width:100%;height:100%;border:none;background-color:transparent;pointer-events:none;display:block;overflow:hidden;opacity:0}.resize-observer[data-v-b329ee4c] object{display:block;position:absolute;top:0;left:0;height:100%;width:100%;overflow:hidden;pointer-events:none;z-index:-1} \ No newline at end of file +.vue-recycle-scroller{position:relative}.vue-recycle-scroller.direction-vertical:not(.page-mode){overflow-y:auto}.vue-recycle-scroller.direction-horizontal:not(.page-mode){overflow-x:auto}.vue-recycle-scroller.direction-horizontal{display:flex}.vue-recycle-scroller__slot{flex:auto 0 0}.vue-recycle-scroller__item-wrapper{flex:1;box-sizing:border-box;overflow:hidden;position:relative}.vue-recycle-scroller.ready .vue-recycle-scroller__item-view{position:absolute;top:0;left:0;will-change:transform}.vue-recycle-scroller.direction-vertical .vue-recycle-scroller__item-wrapper{width:100%}.vue-recycle-scroller.direction-horizontal .vue-recycle-scroller__item-wrapper{height:100%}.vue-recycle-scroller.ready.direction-vertical .vue-recycle-scroller__item-view{width:100%}.vue-recycle-scroller.ready.direction-horizontal .vue-recycle-scroller__item-view{height:100%}.resize-observer[data-v-b329ee4c]{position:absolute;top:0;left:0;z-index:-1;width:100%;height:100%;border:none;background-color:transparent;pointer-events:none;display:block;overflow:hidden;opacity:0}.resize-observer[data-v-b329ee4c] object{display:block;position:absolute;top:0;left:0;height:100%;width:100%;overflow:hidden;pointer-events:none;z-index:-1} \ No newline at end of file diff --git a/dist/vue-virtual-scroller.esm.js b/dist/vue-virtual-scroller.esm.js index 33e441d9..4881bd9b 100644 --- a/dist/vue-virtual-scroller.esm.js +++ b/dist/vue-virtual-scroller.esm.js @@ -1,7 +1,7 @@ +import { shallowReactive, resolveComponent, resolveDirective, withDirectives, openBlock, createBlock, renderSlot, createCommentVNode, createVNode, Fragment, renderList, mergeProps, toHandlers, withCtx, reactive } from 'vue'; import { ResizeObserver as ResizeObserver$1 } from 'vue-resize'; import { ObserveVisibility } from 'vue-observe-visibility'; import ScrollParent from 'scrollparent'; -import Vue from 'vue'; var config = { itemsLimit: 1000 @@ -311,25 +311,21 @@ var script = { _this.ready = true; }); }, - beforeDestroy: function beforeDestroy() { + beforeUnmount: function beforeUnmount() { this.removeListeners(); }, methods: { addView: function addView(pool, index, item, key, type) { - var view = { + var view = shallowReactive({ item: item, - position: 0 - }; - var nonReactive = { - id: uid++, - index: index, - used: true, - key: key, - type: type - }; - Object.defineProperty(view, 'nr', { - configurable: false, - value: nonReactive + position: 0, + nr: { + id: uid++, + index: index, + used: true, + key: key, + type: type + } }); pool.push(view); return view; @@ -706,224 +702,73 @@ var script = { } }; -function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) { - if (typeof shadowMode !== 'boolean') { - createInjectorSSR = createInjector; - createInjector = shadowMode; - shadowMode = false; - } - // Vue.extend constructor export interop. - const options = typeof script === 'function' ? script.options : script; - // render functions - if (template && template.render) { - options.render = template.render; - options.staticRenderFns = template.staticRenderFns; - options._compiled = true; - // functional template - if (isFunctionalTemplate) { - options.functional = true; - } - } - // scopedId - if (scopeId) { - options._scopeId = scopeId; - } - let hook; - if (moduleIdentifier) { - // server build - hook = function (context) { - // 2.3 injection - context = - context || // cached call - (this.$vnode && this.$vnode.ssrContext) || // stateful - (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext); // functional - // 2.2 with runInNewContext: true - if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') { - context = __VUE_SSR_CONTEXT__; - } - // inject component styles - if (style) { - style.call(this, createInjectorSSR(context)); - } - // register component module identifier for async chunk inference - if (context && context._registeredComponents) { - context._registeredComponents.add(moduleIdentifier); - } - }; - // used by ssr in case component is cached and beforeCreate - // never gets called - options._ssrRegister = hook; - } - else if (style) { - hook = shadowMode - ? function (context) { - style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot)); - } - : function (context) { - style.call(this, createInjector(context)); - }; - } - if (hook) { - if (options.functional) { - // register for functional component in vue file - const originalRender = options.render; - options.render = function renderWithStyleInjection(h, context) { - hook.call(context); - return originalRender(h, context); - }; - } - else { - // inject component registration as beforeCreate hook - const existing = options.beforeCreate; - options.beforeCreate = existing ? [].concat(existing, hook) : [hook]; - } - } - return script; +var _hoisted_1 = { + key: 0, + class: "vue-recycle-scroller__slot" +}; +var _hoisted_2 = { + key: 1, + class: "vue-recycle-scroller__slot" +}; +function render(_ctx, _cache, $props, $setup, $data, $options) { + var _component_ResizeObserver = resolveComponent("ResizeObserver"); + + var _directive_observe_visibility = resolveDirective("observe-visibility"); + + return withDirectives((openBlock(), createBlock("div", { + class: ["vue-recycle-scroller", _defineProperty({ + ready: $data.ready, + 'page-mode': $props.pageMode + }, "direction-".concat(_ctx.direction), true)], + onScrollPassive: _cache[2] || (_cache[2] = function () { + return $options.handleScroll && $options.handleScroll.apply($options, arguments); + }) + }, [_ctx.$slots.before ? (openBlock(), createBlock("div", _hoisted_1, [renderSlot(_ctx.$slots, "before")])) : createCommentVNode("v-if", true), createVNode("div", { + ref: "wrapper", + style: _defineProperty({}, _ctx.direction === 'vertical' ? 'minHeight' : 'minWidth', $data.totalSize + 'px'), + class: "vue-recycle-scroller__item-wrapper" + }, [(openBlock(true), createBlock(Fragment, null, renderList($data.pool, function (view) { + return openBlock(), createBlock("div", { + key: view.nr.id, + style: $data.ready ? { + transform: "translate".concat(_ctx.direction === 'vertical' ? 'Y' : 'X', "(").concat(view.position, "px)") + } : null, + class: ["vue-recycle-scroller__item-view", { + hover: $data.hoverKey === view.nr.key + }], + onMouseenter: function onMouseenter($event) { + return $data.hoverKey = view.nr.key; + }, + onMouseleave: _cache[1] || (_cache[1] = function ($event) { + return $data.hoverKey = null; + }) + }, [renderSlot(_ctx.$slots, "default", { + item: view.item, + index: view.nr.index, + active: view.nr.used + })], 46 + /* CLASS, STYLE, PROPS, HYDRATE_EVENTS */ + , ["onMouseenter"]); + }), 128 + /* KEYED_FRAGMENT */ + ))], 4 + /* STYLE */ + ), _ctx.$slots.after ? (openBlock(), createBlock("div", _hoisted_2, [renderSlot(_ctx.$slots, "after")])) : createCommentVNode("v-if", true), createVNode(_component_ResizeObserver, { + onNotify: $options.handleResize + }, null, 8 + /* PROPS */ + , ["onNotify"])], 34 + /* CLASS, HYDRATE_EVENTS */ + )), [[_directive_observe_visibility, $options.handleVisibilityChange]]); } -/* script */ -const __vue_script__ = script; -/* template */ -var __vue_render__ = function() { - var _obj, _obj$1; - var _vm = this; - var _h = _vm.$createElement; - var _c = _vm._self._c || _h; - return _c( - "div", - { - directives: [ - { - name: "observe-visibility", - rawName: "v-observe-visibility", - value: _vm.handleVisibilityChange, - expression: "handleVisibilityChange" - } - ], - staticClass: "vue-recycle-scroller", - class: - ((_obj = { - ready: _vm.ready, - "page-mode": _vm.pageMode - }), - (_obj["direction-" + _vm.direction] = true), - _obj), - on: { - "&scroll": function($event) { - return _vm.handleScroll($event) - } - } - }, - [ - _vm.$slots.before - ? _c( - "div", - { staticClass: "vue-recycle-scroller__slot" }, - [_vm._t("before")], - 2 - ) - : _vm._e(), - _vm._v(" "), - _c( - "div", - { - ref: "wrapper", - staticClass: "vue-recycle-scroller__item-wrapper", - style: - ((_obj$1 = {}), - (_obj$1[_vm.direction === "vertical" ? "minHeight" : "minWidth"] = - _vm.totalSize + "px"), - _obj$1) - }, - _vm._l(_vm.pool, function(view) { - return _c( - "div", - { - key: view.nr.id, - staticClass: "vue-recycle-scroller__item-view", - class: { hover: _vm.hoverKey === view.nr.key }, - style: _vm.ready - ? { - transform: - "translate" + - (_vm.direction === "vertical" ? "Y" : "X") + - "(" + - view.position + - "px)" - } - : null, - on: { - mouseenter: function($event) { - _vm.hoverKey = view.nr.key; - }, - mouseleave: function($event) { - _vm.hoverKey = null; - } - } - }, - [ - _vm._t("default", null, { - item: view.item, - index: view.nr.index, - active: view.nr.used - }) - ], - 2 - ) - }), - 0 - ), - _vm._v(" "), - _vm.$slots.after - ? _c( - "div", - { staticClass: "vue-recycle-scroller__slot" }, - [_vm._t("after")], - 2 - ) - : _vm._e(), - _vm._v(" "), - _c("ResizeObserver", { on: { notify: _vm.handleResize } }) - ], - 1 - ) -}; -var __vue_staticRenderFns__ = []; -__vue_render__._withStripped = true; - - /* style */ - const __vue_inject_styles__ = undefined; - /* scoped */ - const __vue_scope_id__ = undefined; - /* module identifier */ - const __vue_module_identifier__ = undefined; - /* functional template */ - const __vue_is_functional_template__ = false; - /* style inject */ - - /* style inject SSR */ - - /* style inject shadow dom */ - - - - const __vue_component__ = normalizeComponent( - { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ }, - __vue_inject_styles__, - __vue_script__, - __vue_scope_id__, - __vue_is_functional_template__, - __vue_module_identifier__, - false, - undefined, - undefined, - undefined - ); +script.render = render; +script.__file = "src/components/RecycleScroller.vue"; var script$1 = { name: 'DynamicScroller', components: { - RecycleScroller: __vue_component__ + RecycleScroller: script }, inheritAttrs: false, provide: function provide() { @@ -1105,96 +950,46 @@ var script$1 = { } }; -/* script */ -const __vue_script__$1 = script$1; - -/* template */ -var __vue_render__$1 = function() { - var _vm = this; - var _h = _vm.$createElement; - var _c = _vm._self._c || _h; - return _c( - "RecycleScroller", - _vm._g( - _vm._b( - { - ref: "scroller", - attrs: { - items: _vm.itemsWithSize, - "min-item-size": _vm.minItemSize, - direction: _vm.direction, - "key-field": "id" - }, - on: { resize: _vm.onScrollerResize, visible: _vm.onScrollerVisible }, - scopedSlots: _vm._u( - [ - { - key: "default", - fn: function(ref) { - var itemWithSize = ref.item; - var index = ref.index; - var active = ref.active; - return [ - _vm._t("default", null, null, { - item: itemWithSize.item, - index: index, - active: active, - itemWithSize: itemWithSize - }) - ] - } - } - ], - null, - true - ) - }, - "RecycleScroller", - _vm.$attrs, - false - ), - _vm.listeners - ), - [ - _vm._v(" "), - _c("template", { slot: "before" }, [_vm._t("before")], 2), - _vm._v(" "), - _c("template", { slot: "after" }, [_vm._t("after")], 2) - ], - 2 - ) +var _hoisted_1$1 = { + "slot-scope": "{ item: itemWithSize, index, active }" }; -var __vue_staticRenderFns__$1 = []; -__vue_render__$1._withStripped = true; - - /* style */ - const __vue_inject_styles__$1 = undefined; - /* scoped */ - const __vue_scope_id__$1 = undefined; - /* module identifier */ - const __vue_module_identifier__$1 = undefined; - /* functional template */ - const __vue_is_functional_template__$1 = false; - /* style inject */ - - /* style inject SSR */ - - /* style inject shadow dom */ - - - - const __vue_component__$1 = normalizeComponent( - { render: __vue_render__$1, staticRenderFns: __vue_staticRenderFns__$1 }, - __vue_inject_styles__$1, - __vue_script__$1, - __vue_scope_id__$1, - __vue_is_functional_template__$1, - __vue_module_identifier__$1, - false, - undefined, - undefined, - undefined - ); +var _hoisted_2$1 = { + slot: "before" +}; +var _hoisted_3 = { + slot: "after" +}; +function render$1(_ctx, _cache, $props, $setup, $data, $options) { + var _component_RecycleScroller = resolveComponent("RecycleScroller"); + + return openBlock(), createBlock(_component_RecycleScroller, mergeProps({ + ref: "scroller", + items: $options.itemsWithSize, + "min-item-size": $props.minItemSize, + direction: _ctx.direction, + "key-field": "id" + }, _ctx.$attrs, { + onResize: $options.onScrollerResize, + onVisible: $options.onScrollerVisible + }, toHandlers($options.listeners)), { + default: withCtx(function () { + return [createVNode("template", _hoisted_1$1, [renderSlot(_ctx.$slots, "default", { + item: _ctx.itemWithSize.item, + index: _ctx.index, + active: _ctx.active, + itemWithSize: _ctx.itemWithSize + })]), createVNode("template", _hoisted_2$1, [renderSlot(_ctx.$slots, "before")]), createVNode("template", _hoisted_3, [renderSlot(_ctx.$slots, "after")])]; + }), + _: 3 + /* FORWARDED */ + + }, 16 + /* FULL_PROPS */ + , ["items", "min-item-size", "direction", "onResize", "onVisible"]); +} + +script$1.render = render$1; +script$1.__file = "src/components/DynamicScroller.vue"; var script$2 = { name: 'DynamicScrollerItem', @@ -1209,8 +1004,8 @@ var script$2 = { default: false }, - /** - * Indicates if the view is actively used to display an item. + /** + * Indicates if the view is actively used to display an item. */ active: { type: Boolean, @@ -1305,7 +1100,7 @@ var script$2 = { this.observeSize(); } }, - beforeDestroy: function beforeDestroy() { + beforeUnmount: function beforeUnmount() { this.vscrollParent.$off('vscroll:update', this.onVscrollUpdate); this.vscrollParent.$off('vscroll:update-size', this.onVscrollUpdateSize); this.unobserveSize(); @@ -1398,43 +1193,12 @@ var script$2 = { } }, render: function render(h) { + console.log('render', h); return h(this.tag, this.$slots.default); } }; -/* script */ -const __vue_script__$2 = script$2; - -/* template */ - - /* style */ - const __vue_inject_styles__$2 = undefined; - /* scoped */ - const __vue_scope_id__$2 = undefined; - /* module identifier */ - const __vue_module_identifier__$2 = undefined; - /* functional template */ - const __vue_is_functional_template__$2 = undefined; - /* style inject */ - - /* style inject SSR */ - - /* style inject shadow dom */ - - - - const __vue_component__$2 = normalizeComponent( - {}, - __vue_inject_styles__$2, - __vue_script__$2, - __vue_scope_id__$2, - __vue_is_functional_template__$2, - __vue_module_identifier__$2, - false, - undefined, - undefined, - undefined - ); +script$2.__file = "src/components/DynamicScrollerItem.vue"; function IdState () { var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, @@ -1443,14 +1207,7 @@ function IdState () { return vm.item.id; } : _ref$idProp; - var store = {}; - var vm = new Vue({ - data: function data() { - return { - store: store - }; - } - }); // @vue/component + var store = reactive({}); // @vue/component return { data: function data() { @@ -1489,16 +1246,16 @@ function IdState () { this.$_updateIdState(); }, methods: { - /** - * Initialize an idState - * @param {number|string} id Unique id for the data + /** + * Initialize an idState + * @param {number|string} id Unique id for the data */ $_idStateInit: function $_idStateInit(id) { var factory = this.$options.idState; if (typeof factory === 'function') { var data = factory.call(this, this); - vm.$set(store, id, data); + store[id] = data; this.$_id = id; return data; } else { @@ -1506,8 +1263,8 @@ function IdState () { } }, - /** - * Ensure idState is created and up-to-date + /** + * Ensure idState is created and up-to-date */ $_updateIdState: function $_updateIdState() { var id = this.$_getId(); @@ -1529,12 +1286,12 @@ function IdState () { } function registerComponents(Vue, prefix) { - Vue.component("".concat(prefix, "recycle-scroller"), __vue_component__); - Vue.component("".concat(prefix, "RecycleScroller"), __vue_component__); - Vue.component("".concat(prefix, "dynamic-scroller"), __vue_component__$1); - Vue.component("".concat(prefix, "DynamicScroller"), __vue_component__$1); - Vue.component("".concat(prefix, "dynamic-scroller-item"), __vue_component__$2); - Vue.component("".concat(prefix, "DynamicScrollerItem"), __vue_component__$2); + Vue.component("".concat(prefix, "recycle-scroller"), script); + Vue.component("".concat(prefix, "RecycleScroller"), script); + Vue.component("".concat(prefix, "dynamic-scroller"), script$1); + Vue.component("".concat(prefix, "DynamicScroller"), script$1); + Vue.component("".concat(prefix, "dynamic-scroller-item"), script$2); + Vue.component("".concat(prefix, "DynamicScrollerItem"), script$2); } var plugin = { @@ -1571,5 +1328,5 @@ if (GlobalVue) { } export default plugin; -export { __vue_component__$1 as DynamicScroller, __vue_component__$2 as DynamicScrollerItem, IdState, __vue_component__ as RecycleScroller }; +export { script$1 as DynamicScroller, script$2 as DynamicScrollerItem, IdState, script as RecycleScroller }; //# sourceMappingURL=vue-virtual-scroller.esm.js.map diff --git a/dist/vue-virtual-scroller.esm.js.map b/dist/vue-virtual-scroller.esm.js.map index 9ec17bea..b7502f5a 100644 --- a/dist/vue-virtual-scroller.esm.js.map +++ b/dist/vue-virtual-scroller.esm.js.map @@ -1 +1 @@ -{"version":3,"file":"vue-virtual-scroller.esm.js","sources":["../src/config.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../node_modules/vue-runtime-helpers/dist/normalize-component.mjs","../src/components/DynamicScroller.vue","../src/components/DynamicScrollerItem.vue","../src/mixins/IdState.js","../src/index.js"],"sourcesContent":["export default {\n itemsLimit: 1000,\n}\n","export const props = {\n items: {\n type: Array,\n required: true,\n },\n\n keyField: {\n type: String,\n default: 'id',\n },\n\n direction: {\n type: String,\n default: 'vertical',\n validator: (value) => ['vertical', 'horizontal'].includes(value),\n },\n}\n\nexport function simpleArray () {\n return this.items.length && typeof this.items[0] !== 'object'\n}\n","export let supportsPassive = false\n\nif (typeof window !== 'undefined') {\n supportsPassive = false\n try {\n var opts = Object.defineProperty({}, 'passive', {\n get () {\n supportsPassive = true\n },\n })\n window.addEventListener('test', null, opts)\n } catch (e) {}\n}\n","\n\n\n\n\n","function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {\r\n if (typeof shadowMode !== 'boolean') {\r\n createInjectorSSR = createInjector;\r\n createInjector = shadowMode;\r\n shadowMode = false;\r\n }\r\n // Vue.extend constructor export interop.\r\n const options = typeof script === 'function' ? script.options : script;\r\n // render functions\r\n if (template && template.render) {\r\n options.render = template.render;\r\n options.staticRenderFns = template.staticRenderFns;\r\n options._compiled = true;\r\n // functional template\r\n if (isFunctionalTemplate) {\r\n options.functional = true;\r\n }\r\n }\r\n // scopedId\r\n if (scopeId) {\r\n options._scopeId = scopeId;\r\n }\r\n let hook;\r\n if (moduleIdentifier) {\r\n // server build\r\n hook = function (context) {\r\n // 2.3 injection\r\n context =\r\n context || // cached call\r\n (this.$vnode && this.$vnode.ssrContext) || // stateful\r\n (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext); // functional\r\n // 2.2 with runInNewContext: true\r\n if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\r\n context = __VUE_SSR_CONTEXT__;\r\n }\r\n // inject component styles\r\n if (style) {\r\n style.call(this, createInjectorSSR(context));\r\n }\r\n // register component module identifier for async chunk inference\r\n if (context && context._registeredComponents) {\r\n context._registeredComponents.add(moduleIdentifier);\r\n }\r\n };\r\n // used by ssr in case component is cached and beforeCreate\r\n // never gets called\r\n options._ssrRegister = hook;\r\n }\r\n else if (style) {\r\n hook = shadowMode\r\n ? function (context) {\r\n style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot));\r\n }\r\n : function (context) {\r\n style.call(this, createInjector(context));\r\n };\r\n }\r\n if (hook) {\r\n if (options.functional) {\r\n // register for functional component in vue file\r\n const originalRender = options.render;\r\n options.render = function renderWithStyleInjection(h, context) {\r\n hook.call(context);\r\n return originalRender(h, context);\r\n };\r\n }\r\n else {\r\n // inject component registration as beforeCreate hook\r\n const existing = options.beforeCreate;\r\n options.beforeCreate = existing ? [].concat(existing, hook) : [hook];\r\n }\r\n }\r\n return script;\r\n}\n\nexport default normalizeComponent;\n//# sourceMappingURL=normalize-component.mjs.map\n","\n\n\n","\n","import Vue from 'vue'\n\nexport default function ({\n idProp = vm => vm.item.id,\n} = {}) {\n const store = {}\n const vm = new Vue({\n data () {\n return {\n store,\n }\n },\n })\n\n // @vue/component\n return {\n data () {\n return {\n idState: null,\n }\n },\n\n created () {\n this.$_id = null\n if (typeof idProp === 'function') {\n this.$_getId = () => idProp.call(this, this)\n } else {\n this.$_getId = () => this[idProp]\n }\n this.$watch(this.$_getId, {\n handler (value) {\n this.$nextTick(() => {\n this.$_id = value\n })\n },\n immediate: true,\n })\n this.$_updateIdState()\n },\n\n beforeUpdate () {\n this.$_updateIdState()\n },\n\n methods: {\n /**\n * Initialize an idState\n * @param {number|string} id Unique id for the data\n */\n $_idStateInit (id) {\n const factory = this.$options.idState\n if (typeof factory === 'function') {\n const data = factory.call(this, this)\n vm.$set(store, id, data)\n this.$_id = id\n return data\n } else {\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\n }\n },\n\n /**\n * Ensure idState is created and up-to-date\n */\n $_updateIdState () {\n const id = this.$_getId()\n if (id == null) {\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\n }\n if (id !== this.$_id) {\n if (!store[id]) {\n this.$_idStateInit(id)\n }\n this.idState = store[id]\n }\n },\n },\n }\n}\n","import config from './config'\n\nimport RecycleScroller from './components/RecycleScroller.vue'\nimport DynamicScroller from './components/DynamicScroller.vue'\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\n\nexport { default as IdState } from './mixins/IdState'\n\nexport {\n RecycleScroller,\n DynamicScroller,\n DynamicScrollerItem,\n}\n\nfunction registerComponents (Vue, prefix) {\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\n}\n\nconst plugin = {\n // eslint-disable-next-line no-undef\n version: VERSION,\n install (Vue, options) {\n const finalOptions = Object.assign({}, {\n installComponents: true,\n componentsPrefix: '',\n }, options)\n\n for (const key in finalOptions) {\n if (typeof finalOptions[key] !== 'undefined') {\n config[key] = finalOptions[key]\n }\n }\n\n if (finalOptions.installComponents) {\n registerComponents(Vue, finalOptions.componentsPrefix)\n }\n },\n}\n\nexport default plugin\n\n// Auto-install\nlet GlobalVue = null\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue\n}\nif (GlobalVue) {\n GlobalVue.use(plugin)\n}\n"],"names":["itemsLimit","props","items","type","Array","required","keyField","String","default","direction","validator","value","includes","simpleArray","length","supportsPassive","window","opts","Object","defineProperty","get","addEventListener","e","idProp","vm","item","id","store","Vue","data","idState","created","$_id","$_getId","call","$watch","handler","$nextTick","immediate","$_updateIdState","beforeUpdate","methods","$_idStateInit","factory","$options","$set","Error","console","warn","registerComponents","prefix","component","RecycleScroller","DynamicScroller","DynamicScrollerItem","plugin","version","VERSION","install","options","finalOptions","assign","installComponents","componentsPrefix","key","config","GlobalVue","global","use"],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"vue-virtual-scroller.esm.js","sources":["../src/config.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../src/components/RecycleScroller.vue?vue&type=template&id=093a936d&lang.js","../src/components/DynamicScroller.vue","../src/components/DynamicScroller.vue?vue&type=template&id=76e15f19&lang.js","../src/components/DynamicScrollerItem.vue","../src/mixins/IdState.js","../src/index.js"],"sourcesContent":["export default {\r\n itemsLimit: 1000,\r\n}\r\n","export const props = {\r\n items: {\r\n type: Array,\r\n required: true,\r\n },\r\n\r\n keyField: {\r\n type: String,\r\n default: 'id',\r\n },\r\n\r\n direction: {\r\n type: String,\r\n default: 'vertical',\r\n validator: (value) => ['vertical', 'horizontal'].includes(value),\r\n },\r\n}\r\n\r\nexport function simpleArray () {\r\n return this.items.length && typeof this.items[0] !== 'object'\r\n}\r\n","export let supportsPassive = false\r\n\r\nif (typeof window !== 'undefined') {\r\n supportsPassive = false\r\n try {\r\n var opts = Object.defineProperty({}, 'passive', {\r\n get () {\r\n supportsPassive = true\r\n },\r\n })\r\n window.addEventListener('test', null, opts)\r\n } catch (e) {}\r\n}\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n","import { reactive } from 'vue'\r\n\r\nexport default function ({\r\n idProp = vm => vm.item.id,\r\n} = {}) {\r\n const store = reactive({})\r\n\r\n // @vue/component\r\n return {\r\n data () {\r\n return {\r\n idState: null,\r\n }\r\n },\r\n\r\n created () {\r\n this.$_id = null\r\n if (typeof idProp === 'function') {\r\n this.$_getId = () => idProp.call(this, this)\r\n } else {\r\n this.$_getId = () => this[idProp]\r\n }\r\n this.$watch(this.$_getId, {\r\n handler (value) {\r\n this.$nextTick(() => {\r\n this.$_id = value\r\n })\r\n },\r\n immediate: true,\r\n })\r\n this.$_updateIdState()\r\n },\r\n\r\n beforeUpdate () {\r\n this.$_updateIdState()\r\n },\r\n\r\n methods: {\r\n /**\r\n * Initialize an idState\r\n * @param {number|string} id Unique id for the data\r\n */\r\n $_idStateInit (id) {\r\n const factory = this.$options.idState\r\n if (typeof factory === 'function') {\r\n const data = factory.call(this, this)\r\n store[id] = data\r\n this.$_id = id\r\n return data\r\n } else {\r\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\r\n }\r\n },\r\n\r\n /**\r\n * Ensure idState is created and up-to-date\r\n */\r\n $_updateIdState () {\r\n const id = this.$_getId()\r\n if (id == null) {\r\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\r\n }\r\n if (id !== this.$_id) {\r\n if (!store[id]) {\r\n this.$_idStateInit(id)\r\n }\r\n this.idState = store[id]\r\n }\r\n },\r\n },\r\n }\r\n}\r\n","import config from './config'\r\n\r\nimport RecycleScroller from './components/RecycleScroller.vue'\r\nimport DynamicScroller from './components/DynamicScroller.vue'\r\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\r\n\r\nexport { default as IdState } from './mixins/IdState'\r\n\r\nexport {\r\n RecycleScroller,\r\n DynamicScroller,\r\n DynamicScrollerItem,\r\n}\r\n\r\nfunction registerComponents (Vue, prefix) {\r\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\r\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\r\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\r\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\r\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\r\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\r\n}\r\n\r\nconst plugin = {\r\n // eslint-disable-next-line no-undef\r\n version: VERSION,\r\n install (Vue, options) {\r\n const finalOptions = Object.assign({}, {\r\n installComponents: true,\r\n componentsPrefix: '',\r\n }, options)\r\n\r\n for (const key in finalOptions) {\r\n if (typeof finalOptions[key] !== 'undefined') {\r\n config[key] = finalOptions[key]\r\n }\r\n }\r\n\r\n if (finalOptions.installComponents) {\r\n registerComponents(Vue, finalOptions.componentsPrefix)\r\n }\r\n },\r\n}\r\n\r\nexport default plugin\r\n\r\n// Auto-install\r\nlet GlobalVue = null\r\nif (typeof window !== 'undefined') {\r\n GlobalVue = window.Vue\r\n} else if (typeof global !== 'undefined') {\r\n GlobalVue = global.Vue\r\n}\r\nif (GlobalVue) {\r\n GlobalVue.use(plugin)\r\n}\r\n"],"names":["itemsLimit","props","items","type","Array","required","keyField","String","default","direction","validator","value","includes","simpleArray","length","supportsPassive","window","opts","Object","defineProperty","get","addEventListener","e","uid","name","components","ResizeObserver","directives","ObserveVisibility","itemSize","Number","minItemSize","sizeField","typeField","buffer","pageMode","Boolean","prerender","emitUpdate","data","pool","totalSize","ready","hoverKey","computed","sizes","accumulator","field","computedMinSize","current","i","l","size","$_computedMinItemSize","watch","updateVisibleItems","applyPageMode","handler","deep","created","$_startIndex","$_endIndex","$_views","Map","$_unusedViews","$_scrollDirty","$_lastUpdateScrollPosition","$_prerender","mounted","$nextTick","beforeUnmount","removeListeners","methods","addView","index","item","key","view","shallowReactive","position","nr","id","used","push","unuseView","fake","unusedViews","unusedPool","set","delete","handleResize","$emit","handleScroll","event","requestAnimationFrame","continuous","clearTimeout","$_refreshTimout","setTimeout","handleVisibilityChange","isVisible","entry","boundingClientRect","width","height","checkItem","checkPositionDiff","count","views","startIndex","endIndex","scroll","getScroll","positionDiff","start","end","h","a","b","oldI","Math","ceil","config","itemsLimitError","$_continuous","clear","findIndex","unusedIndex","v","Error","pop","$_sortTimer","sortViews","getListenerTarget","target","ScrollParent","$el","document","documentElement","body","el","isVertical","scrollState","bounds","getBoundingClientRect","boundsSize","top","left","innerHeight","innerWidth","scrollTop","clientHeight","scrollLeft","clientWidth","addListeners","listenerTarget","passive","removeEventListener","scrollToItem","scrollToPosition","console","log","sort","viewA","viewB","class","_createBlock","$options","_ctx","before","_hoisted_1","_renderSlot","_createVNode","ref","style","$data","onMouseenter","onMouseleave","active","after","_hoisted_2","onNotify","RecycleScroller","inheritAttrs","provide","$_resizeObserver","entries","CustomEvent","detail","contentRect","dispatchEvent","vscrollData","vscrollParent","vscrollResizeObserver","validSizes","itemsWithSize","result","$_undefinedMap","listeners","$listeners","forceUpdate","immediate","$_updates","$_undefinedSizes","activated","deactivated","onScrollerResize","scroller","$refs","onScrollerVisible","force","getItemSize","undefined","indexOf","scrollToBottom","$_scrollingToBottom","scrollHeight","cb","slot","_mergeProps","$props","onResize","onVisible","_toHandlers","_hoisted_3","inject","watchData","sizeDependencies","emitResize","tag","finalActive","onDataUpdate","observeSize","unobserveSize","$_pendingVScrollUpdate","updateSize","$isServer","$_forceNextVScrollUpdate","updateWatchData","k","$watch","$on","onVscrollUpdate","onVscrollUpdateSize","$off","$_pendingSizeUpdate","computeSize","$_watchData","offsetWidth","offsetHeight","applySize","round","$set","observe","parentNode","unobserve","render","$slots","idProp","vm","store","reactive","idState","$_id","$_getId","call","$_updateIdState","beforeUpdate","$_idStateInit","factory","warn","registerComponents","Vue","prefix","component","DynamicScroller","DynamicScrollerItem","plugin","version","VERSION","install","options","finalOptions","assign","installComponents","componentsPrefix","GlobalVue","global","use"],"mappings":"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"} \ No newline at end of file diff --git a/dist/vue-virtual-scroller.min.js b/dist/vue-virtual-scroller.min.js index ba5df9d2..ece89c69 100644 --- a/dist/vue-virtual-scroller.min.js +++ b/dist/vue-virtual-scroller.min.js @@ -1,2 +1,2 @@ -var VueVirtualScroller=function(e,t){"use strict";t=t&&Object.prototype.hasOwnProperty.call(t,"default")?t.default:t;var i={itemsLimit:1e3};function n(e){return(n="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function r(e,t,i){return t in e?Object.defineProperty(e,t,{value:i,enumerable:!0,configurable:!0,writable:!0}):e[t]=i,e}function s(e,t){var i=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),i.push.apply(i,n)}return i}function o(e){for(var t=1;te.length)&&(t=e.length);for(var i=0,n=new Array(t);i=e.length?{done:!0}:{done:!1,value:e[t++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var n,r,s=!0,o=!1;return{s:function(){n=e[Symbol.iterator]()},n:function(){var e=n.next();return s=e.done,e},e:function(e){o=!0,r=e},f:function(){try{s||null==n.return||n.return()}finally{if(o)throw r}}}}var c=void 0;function d(){d.init||(d.init=!0,c=-1!==function(){var e=window.navigator.userAgent,t=e.indexOf("MSIE ");if(t>0)return parseInt(e.substring(t+5,e.indexOf(".",t)),10);if(e.indexOf("Trident/")>0){var i=e.indexOf("rv:");return parseInt(e.substring(i+3,e.indexOf(".",i)),10)}var n=e.indexOf("Edge/");return n>0?parseInt(e.substring(n+5,e.indexOf(".",n)),10):-1}())}var u={render:function(){var e=this.$createElement;return(this._self._c||e)("div",{staticClass:"resize-observer",attrs:{tabindex:"-1"}})},staticRenderFns:[],_scopeId:"data-v-b329ee4c",name:"resize-observer",methods:{compareAndNotify:function(){this._w===this.$el.offsetWidth&&this._h===this.$el.offsetHeight||(this._w=this.$el.offsetWidth,this._h=this.$el.offsetHeight,this.$emit("notify"))},addResizeHandlers:function(){this._resizeObject.contentDocument.defaultView.addEventListener("resize",this.compareAndNotify),this.compareAndNotify()},removeResizeHandlers:function(){this._resizeObject&&this._resizeObject.onload&&(!c&&this._resizeObject.contentDocument&&this._resizeObject.contentDocument.defaultView.removeEventListener("resize",this.compareAndNotify),delete this._resizeObject.onload)}},mounted:function(){var e=this;d(),this.$nextTick((function(){e._w=e.$el.offsetWidth,e._h=e.$el.offsetHeight}));var t=document.createElement("object");this._resizeObject=t,t.setAttribute("aria-hidden","true"),t.setAttribute("tabindex",-1),t.onload=this.addResizeHandlers,t.type="text/html",c&&this.$el.appendChild(t),t.data="about:blank",c||this.$el.appendChild(t)},beforeDestroy:function(){this.removeResizeHandlers()}};var h={version:"0.4.5",install:function(e){e.component("resize-observer",u),e.component("ResizeObserver",u)}},f=null;function v(e){return(v="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function p(e,t){for(var i=0;i2&&void 0!==arguments[2]?arguments[2]:{},o=function(o){for(var l=arguments.length,a=new Array(l>1?l-1:0),c=1;c1){var n=e.find((function(e){return e.isIntersecting}));n&&(t=n)}if(i.callback){var r=t.isIntersecting&&t.intersectionRatio>=i.threshold;if(r===i.oldResult)return;i.oldResult=r,i.callback(r,t)}}),this.options.intersection),t.context.$nextTick((function(){i.observer&&i.observer.observe(i.el)}))}}},{key:"destroyObserver",value:function(){this.observer&&(this.observer.disconnect(),this.observer=null),this.callback&&this.callback._clear&&(this.callback._clear(),this.callback=null)}},{key:"threshold",get:function(){return this.options.intersection&&this.options.intersection.threshold||0}}])&&p(t.prototype,i),n&&p(t,n),e}();function b(e,t,i){var n=t.value;if(n)if("undefined"==typeof IntersectionObserver)console.warn("[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill");else{var r=new y(e,n,i);e._vue_visibilityState=r}}function _(e){var t=e._vue_visibilityState;t&&(t.destroyObserver(),delete e._vue_visibilityState)}var g={bind:b,update:function(e,t,i){var n=t.value;if(!function e(t,i){if(t===i)return!0;if("object"===v(t)){for(var n in t)if(!e(t[n],i[n]))return!1;return!0}return!1}(n,t.oldValue)){var r=e._vue_visibilityState;n?r?r.createObserver(n,i):b(e,{value:n},i):_(e)}},unbind:_};var $={version:"0.4.6",install:function(e){e.directive("observe-visibility",g)}},S=null;"undefined"!=typeof window?S=window.Vue:"undefined"!=typeof global&&(S=global.Vue),S&&S.use($);var z="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};var w=function(e,t){return e(t={exports:{}},t.exports),t.exports}((function(e){var t,i;t=z,i=function(){var e=/(auto|scroll)/,t=function(e,i){return null===e.parentNode?i:t(e.parentNode,i.concat([e]))},i=function(e,t){return getComputedStyle(e,null).getPropertyValue(t)},n=function(t){return e.test(function(e){return i(e,"overflow")+i(e,"overflow-y")+i(e,"overflow-x")}(t))};return function(e){if(e instanceof HTMLElement||e instanceof SVGElement){for(var i=t(e.parentNode,[]),r=0;r1&&void 0!==arguments[1]&&arguments[1],i=this.$_unusedViews,n=e.nr.type,r=i.get(n);r||(r=[],i.set(n,r)),r.push(e),t||(e.nr.used=!1,e.position=-9999,this.$_views.delete(e.nr.key))},handleResize:function(){this.$emit("resize"),this.ready&&this.updateVisibleItems(!1)},handleScroll:function(e){var t=this;this.$_scrollDirty||(this.$_scrollDirty=!0,requestAnimationFrame((function(){t.$_scrollDirty=!1,t.updateVisibleItems(!1,!0).continuous||(clearTimeout(t.$_refreshTimout),t.$_refreshTimout=setTimeout(t.handleScroll,100))})))},handleVisibilityChange:function(e,t){var i=this;this.ready&&(e||0!==t.boundingClientRect.width||0!==t.boundingClientRect.height?(this.$emit("visible"),requestAnimationFrame((function(){i.updateVisibleItems(!1)}))):this.$emit("hidden"))},updateVisibleItems:function(e){var t,n,r,s,o=arguments.length>1&&void 0!==arguments[1]&&arguments[1],l=this.itemSize,a=this.$_computedMinItemSize,c=this.typeField,d=this.simpleArray?null:this.keyField,u=this.items,h=u.length,f=this.sizes,v=this.$_views,p=this.$_unusedViews,m=this.pool;if(h)if(this.$_prerender)t=0,n=this.prerender,r=null;else{var y=this.getScroll();if(o){var b=y.start-this.$_lastUpdateScrollPosition;if(b<0&&(b=-b),null===l&&by.start&&(S=z),z=~~(($+S)/2)}while(z!==g);for(z<0&&(z=0),t=z,r=f[h-1].accumulator,n=z;nh&&(n=h)}else(t=~~(y.start/l))<0&&(t=0),(n=Math.ceil(y.end/l))>h&&(n=h),r=h*l}else t=n=r=0;n-t>i.itemsLimit&&this.itemsLimitError(),this.totalSize=r;var w=t<=this.$_endIndex&&n>=this.$_startIndex;if(this.$_continuous!==w){if(w){v.clear(),p.clear();for(var O=0,x=m.length;O=n)&&this.unuseView(s));for(var D,R,T,P,k=w?null:new Map,A=t;A=T.length)&&(s=this.addView(m,A,D,E,R),this.unuseView(s,!0),T=p.get(R)),(s=T[P]).item=D,s.nr.used=!0,s.nr.index=A,s.nr.key=E,s.nr.type=R,k.set(R,P+1),P++),v.set(E,s)),s.position=null===l?f[A-1].accumulator:A*l):s&&this.unuseView(s)}return this.$_startIndex=t,this.$_endIndex=n,this.emitUpdate&&this.$emit("update",t,n),clearTimeout(this.$_sortTimer),this.$_sortTimer=setTimeout(this.sortViews,300),{continuous:w}},getListenerTarget:function(){var e=w(this.$el);return!window.document||e!==window.document.documentElement&&e!==window.document.body||(e=window),e},getScroll:function(){var e,t=this.$el,i="vertical"===this.direction;if(this.pageMode){var n=t.getBoundingClientRect(),r=i?n.height:n.width,s=-(i?n.top:n.left),o=i?window.innerHeight:window.innerWidth;s<0&&(o+=s,s=0),s+o>r&&(o=r-s),e={start:s,end:s+o}}else e=i?{start:t.scrollTop,end:t.scrollTop+t.clientHeight}:{start:t.scrollLeft,end:t.scrollLeft+t.clientWidth};return e},applyPageMode:function(){this.pageMode?this.addListeners():this.removeListeners()},addListeners:function(){this.listenerTarget=this.getListenerTarget(),this.listenerTarget.addEventListener("scroll",this.handleScroll,!!I&&{passive:!0}),this.listenerTarget.addEventListener("resize",this.handleResize)},removeListeners:function(){this.listenerTarget&&(this.listenerTarget.removeEventListener("scroll",this.handleScroll),this.listenerTarget.removeEventListener("resize",this.handleResize),this.listenerTarget=null)},scrollToItem:function(e){var t;t=null===this.itemSize?e>0?this.sizes[e-1].accumulator:0:e*this.itemSize,this.scrollToPosition(t)},scrollToPosition:function(e){"vertical"===this.direction?this.$el.scrollTop=e:this.$el.scrollLeft=e},itemsLimitError:function(){var e=this;throw setTimeout((function(){console.log("It seems the scroller element isn't scrolling, so it tries to render all the items at once.","Scroller:",e.$el),console.log("Make sure the scroller has a fixed height (or width) and 'overflow-y' (or 'overflow-x') set to 'auto' so it can scroll correctly and only render the items visible in the scroll viewport.")})),new Error("Rendered items limit reached")},sortViews:function(){this.pool.sort((function(e,t){return e.nr.index-t.nr.index}))}}};var P=function(){var e,t,i=this,n=i.$createElement,r=i._self._c||n;return r("div",{directives:[{name:"observe-visibility",rawName:"v-observe-visibility",value:i.handleVisibilityChange,expression:"handleVisibilityChange"}],staticClass:"vue-recycle-scroller",class:(e={ready:i.ready,"page-mode":i.pageMode},e["direction-"+i.direction]=!0,e),on:{"&scroll":function(e){return i.handleScroll(e)}}},[i.$slots.before?r("div",{staticClass:"vue-recycle-scroller__slot"},[i._t("before")],2):i._e(),i._v(" "),r("div",{ref:"wrapper",staticClass:"vue-recycle-scroller__item-wrapper",style:(t={},t["vertical"===i.direction?"minHeight":"minWidth"]=i.totalSize+"px",t)},i._l(i.pool,(function(e){return r("div",{key:e.nr.id,staticClass:"vue-recycle-scroller__item-view",class:{hover:i.hoverKey===e.nr.key},style:i.ready?{transform:"translate"+("vertical"===i.direction?"Y":"X")+"("+e.position+"px)"}:null,on:{mouseenter:function(t){i.hoverKey=e.nr.key},mouseleave:function(e){i.hoverKey=null}}},[i._t("default",null,{item:e.item,index:e.nr.index,active:e.nr.used})],2)})),0),i._v(" "),i.$slots.after?r("div",{staticClass:"vue-recycle-scroller__slot"},[i._t("after")],2):i._e(),i._v(" "),r("ResizeObserver",{on:{notify:i.handleResize}})],1)};P._withStripped=!0;const k=R({render:P,staticRenderFns:[]},void 0,T,void 0,!1,void 0,!1,void 0,void 0,void 0);const A={name:"DynamicScroller",components:{RecycleScroller:k},inheritAttrs:!1,provide:function(){return"undefined"!=typeof ResizeObserver&&(this.$_resizeObserver=new ResizeObserver((function(e){var t,i=a(e);try{for(i.s();!(t=i.n()).done;){var n=t.value;if(n.target){var r=new CustomEvent("resize",{detail:{contentRect:n.contentRect}});n.target.dispatchEvent(r)}}}catch(e){i.e(e)}finally{i.f()}}))),{vscrollData:this.vscrollData,vscrollParent:this,vscrollResizeObserver:this.$_resizeObserver}},props:o({},O,{minItemSize:{type:[Number,String],required:!0}}),data:function(){return{vscrollData:{active:!0,sizes:{},validSizes:{},keyField:this.keyField,simpleArray:!1}}},computed:{simpleArray:x,itemsWithSize:function(){for(var e=[],t=this.items,i=this.keyField,n=this.simpleArray,r=this.vscrollData.sizes,s=0;s0&&void 0!==arguments[0])||arguments[0];(e||this.simpleArray)&&(this.vscrollData.validSizes={}),this.$emit("vscroll:update",{force:!0})},scrollToItem:function(e){var t=this.$refs.scroller;t&&t.scrollToItem(e)},getItemSize:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:void 0,i=this.simpleArray?null!=t?t:this.items.indexOf(e):e[this.keyField];return this.vscrollData.sizes[i]||0},scrollToBottom:function(){var e=this;if(!this.$_scrollingToBottom){this.$_scrollingToBottom=!0;var t=this.$el;this.$nextTick((function(){t.scrollTop=t.scrollHeight+5e3;requestAnimationFrame((function i(){t.scrollTop=t.scrollHeight+5e3,requestAnimationFrame((function(){t.scrollTop=t.scrollHeight+5e3,0===e.$_undefinedSizes?e.$_scrollingToBottom=!1:requestAnimationFrame(i)}))}))}))}}}};var E=function(){var e=this,t=e.$createElement,i=e._self._c||t;return i("RecycleScroller",e._g(e._b({ref:"scroller",attrs:{items:e.itemsWithSize,"min-item-size":e.minItemSize,direction:e.direction,"key-field":"id"},on:{resize:e.onScrollerResize,visible:e.onScrollerVisible},scopedSlots:e._u([{key:"default",fn:function(t){var i=t.item,n=t.index,r=t.active;return[e._t("default",null,null,{item:i.item,index:n,active:r,itemWithSize:i})]}}],null,!0)},"RecycleScroller",e.$attrs,!1),e.listeners),[e._v(" "),i("template",{slot:"before"},[e._t("before")],2),e._v(" "),i("template",{slot:"after"},[e._t("after")],2)],2)};E._withStripped=!0;const j=R({render:E,staticRenderFns:[]},void 0,A,void 0,!1,void 0,!1,void 0,void 0,void 0);const U=R({},void 0,{name:"DynamicScrollerItem",inject:["vscrollData","vscrollParent","vscrollResizeObserver"],props:{item:{required:!0},watchData:{type:Boolean,default:!1},active:{type:Boolean,required:!0},index:{type:Number,default:void 0},sizeDependencies:{type:[Array,Object],default:null},emitResize:{type:Boolean,default:!1},tag:{type:String,default:"div"}},computed:{id:function(){return this.vscrollData.simpleArray?this.index:this.item[this.vscrollData.keyField]},size:function(){return this.vscrollData.validSizes[this.id]&&this.vscrollData.sizes[this.id]||0},finalActive:function(){return this.active&&this.vscrollData.active}},watch:{watchData:"updateWatchData",id:function(){this.size||this.onDataUpdate()},finalActive:function(e){this.size||(e?this.vscrollParent.$_undefinedMap[this.id]||(this.vscrollParent.$_undefinedSizes++,this.vscrollParent.$_undefinedMap[this.id]=!0):this.vscrollParent.$_undefinedMap[this.id]&&(this.vscrollParent.$_undefinedSizes--,this.vscrollParent.$_undefinedMap[this.id]=!1)),this.vscrollResizeObserver?e?this.observeSize():this.unobserveSize():e&&this.$_pendingVScrollUpdate===this.id&&this.updateSize()}},created:function(){var e=this;if(!this.$isServer&&(this.$_forceNextVScrollUpdate=null,this.updateWatchData(),!this.vscrollResizeObserver)){var t=function(t){e.$watch((function(){return e.sizeDependencies[t]}),e.onDataUpdate)};for(var i in this.sizeDependencies)t(i);this.vscrollParent.$on("vscroll:update",this.onVscrollUpdate),this.vscrollParent.$on("vscroll:update-size",this.onVscrollUpdateSize)}},mounted:function(){this.vscrollData.active&&(this.updateSize(),this.observeSize())},beforeDestroy:function(){this.vscrollParent.$off("vscroll:update",this.onVscrollUpdate),this.vscrollParent.$off("vscroll:update-size",this.onVscrollUpdateSize),this.unobserveSize()},methods:{updateSize:function(){this.finalActive?this.$_pendingSizeUpdate!==this.id&&(this.$_pendingSizeUpdate=this.id,this.$_forceNextVScrollUpdate=null,this.$_pendingVScrollUpdate=null,this.computeSize(this.id)):this.$_forceNextVScrollUpdate=this.id},updateWatchData:function(){var e=this;this.watchData?this.$_watchData=this.$watch("data",(function(){e.onDataUpdate()}),{deep:!0}):this.$_watchData&&(this.$_watchData(),this.$_watchData=null)},onVscrollUpdate:function(e){var t=e.force;!this.finalActive&&t&&(this.$_pendingVScrollUpdate=this.id),this.$_forceNextVScrollUpdate!==this.id&&!t&&this.size||this.updateSize()},onDataUpdate:function(){this.updateSize()},computeSize:function(e){var t=this;this.$nextTick((function(){if(t.id===e){var i=t.$el.offsetWidth,n=t.$el.offsetHeight;t.applySize(i,n)}t.$_pendingSizeUpdate=null}))},applySize:function(e,t){var i=Math.round("vertical"===this.vscrollParent.direction?t:e);i&&this.size!==i&&(this.vscrollParent.$_undefinedMap[this.id]&&(this.vscrollParent.$_undefinedSizes--,this.vscrollParent.$_undefinedMap[this.id]=void 0),this.$set(this.vscrollData.sizes,this.id,i),this.$set(this.vscrollData.validSizes,this.id,!0),this.emitResize&&this.$emit("resize",this.id))},observeSize:function(){this.vscrollResizeObserver&&(this.vscrollResizeObserver.observe(this.$el.parentNode),this.$el.parentNode.addEventListener("resize",this.onResize))},unobserveSize:function(){this.vscrollResizeObserver&&(this.vscrollResizeObserver.unobserve(this.$el.parentNode),this.$el.parentNode.removeEventListener("resize",this.onResize))},onResize:function(e){var t=e.detail.contentRect,i=t.width,n=t.height;this.applySize(i,n)}},render:function(e){return e(this.tag,this.$slots.default)}},void 0,void 0,void 0,!1,void 0,void 0,void 0);var C={version:"1.0.10",install:function(e,t){var n=Object.assign({},{installComponents:!0,componentsPrefix:""},t);for(var r in n)void 0!==n[r]&&(i[r]=n[r]);n.installComponents&&function(e,t){e.component("".concat(t,"recycle-scroller"),k),e.component("".concat(t,"RecycleScroller"),k),e.component("".concat(t,"dynamic-scroller"),j),e.component("".concat(t,"DynamicScroller"),j),e.component("".concat(t,"dynamic-scroller-item"),U),e.component("".concat(t,"DynamicScrollerItem"),U)}(e,n.componentsPrefix)}},M=null;return"undefined"!=typeof window?M=window.Vue:"undefined"!=typeof global&&(M=global.Vue),M&&M.use(C),e.DynamicScroller=j,e.DynamicScrollerItem=U,e.IdState=function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},i=e.idProp,n=void 0===i?function(e){return e.item.id}:i,r={},s=new t({data:function(){return{store:r}}});return{data:function(){return{idState:null}},created:function(){var e=this;this.$_id=null,this.$_getId="function"==typeof n?function(){return n.call(e,e)}:function(){return e[n]},this.$watch(this.$_getId,{handler:function(e){var t=this;this.$nextTick((function(){t.$_id=e}))},immediate:!0}),this.$_updateIdState()},beforeUpdate:function(){this.$_updateIdState()},methods:{$_idStateInit:function(e){var t=this.$options.idState;if("function"==typeof t){var i=t.call(this,this);return s.$set(r,e,i),this.$_id=e,i}throw new Error("[mixin IdState] Missing `idState` function on component definition.")},$_updateIdState:function(){var e=this.$_getId();null==e&&console.warn("No id found for IdState with idProp: '".concat(n,"'.")),e!==this.$_id&&(r[e]||this.$_idStateInit(e),this.idState=r[e])}}}},e.RecycleScroller=k,e.default=C,e}({},Vue); +var VueVirtualScroller=function(e,t){"use strict";var n,r={itemsLimit:1e3};function o(e){return(o="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function i(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function a(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function s(e){for(var t=1;te.length)&&(t=e.length);for(var n=0,r=new Array(t);n1&&(t[n[0].trim()]=n[1].trim())}})),t}function m(e){var t="";if(A(e))t=e;else if(R(e))for(var n=0;n-1&&e.splice(n,1)},D=Object.prototype.hasOwnProperty,z=function(e,t){return D.call(e,t)},R=Array.isArray,C=function(e){return"[object Map]"===U(e)},I=function(e){return"[object Set]"===U(e)},P=function(e){return"function"==typeof e},A=function(e){return"string"==typeof e},j=function(e){return"symbol"===o(e)},T=function(e){return null!==e&&"object"===o(e)},M=Object.prototype.toString,U=function(e){return M.call(e)},F=function(e){return U(e).slice(8,-1)},L=function(e){return A(e)&&"NaN"!==e&&"-"!==e[0]&&""+parseInt(e,10)===e},H=(_=function(e){return e.charAt(0).toUpperCase()+e.slice(1)},b=Object.create(null),function(e){return b[e]||(b[e]=_(e))}),B=function(e,t){return e!==t&&(e==e||t==t)},W=new WeakMap,q=[],K=Symbol("production"!==process.env.NODE_ENV?"iterate":""),J=Symbol("production"!==process.env.NODE_ENV?"Map key iterate":"");function G(e){return e&&!0===e._isEffect}function X(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:N;G(e)&&(e=e.raw);var n=Q(e,t);return t.lazy||n(),n}function Y(e){e.active&&(ee(e),e.options.onStop&&e.options.onStop(),e.active=!1)}var Z=0;function Q(e,t){var n=function(){if(!n.active)return t.scheduler?void 0:e();if(!q.includes(n)){ee(n);try{return ne.push(te),te=!0,q.push(n),E=n,e()}finally{q.pop(),oe(),E=q[q.length-1]}}};return n.id=Z++,n.allowRecurse=!!t.allowRecurse,n._isEffect=!0,n.active=!0,n.raw=e,n.deps=[],n.options=t,n}function ee(e){var t=e.deps;if(t.length){for(var n=0;n=r)&&c(e)}));else switch(void 0!==n&&c(a.get(n)),t){case"add":R(e)?L(n)&&c(a.get("length")):(c(a.get(K)),C(e)&&c(a.get(J)));break;case"delete":R(e)||(c(a.get(K)),C(e)&&c(a.get(J)));break;case"set":C(e)&&c(a.get(K))}s.forEach((function(a){"production"!==process.env.NODE_ENV&&a.options.onTrigger&&a.options.onTrigger({effect:a,target:e,key:n,type:t,newValue:r,oldValue:o,oldTarget:i}),a.options.scheduler?a.options.scheduler(a):a()}))}}var se=new Set(Object.getOwnPropertyNames(Symbol).map((function(e){return Symbol[e]})).filter(j)),ce=pe(),ue=pe(!1,!0),le=pe(!0),fe=pe(!0,!0),de={};function pe(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0],t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return function(n,r,o){if("__v_isReactive"===r)return!e;if("__v_isReadonly"===r)return e;if("__v_raw"===r&&o===(e?Ue:Me).get(n))return n;var i=R(n);if(!e&&i&&z(de,r))return Reflect.get(de,r,o);var a=Reflect.get(n,r,o);return(j(r)?se.has(r):"__proto__"===r||"__v_isRef"===r)?a:(e||ie(n,"get",r),t?a:Ge(a)?!i||!L(r)?a.value:a:T(a)?e?Le(a):Fe(a):a)}}function ve(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0];return function(t,n,r,o){var i=t[n];if(!e&&(r=Je(r),!R(t)&&Ge(i)&&!Ge(r)))return i.value=r,!0;var a=R(t)&&L(n)?Number(n)2&&void 0!==arguments[2]&&arguments[2],r=arguments.length>3&&void 0!==arguments[3]&&arguments[3],o=Je(e=e.__v_raw),i=Je(t);t!==i&&!n&&ie(o,"get",t),!n&&ie(o,"get",i);var a=we(o),s=a.has,c=n?_e:r?be:me;return s.call(o,t)?c(e.get(t)):s.call(o,i)?c(e.get(i)):void 0}function Ne(e){var t=arguments.length>1&&void 0!==arguments[1]&&arguments[1],n=this.__v_raw,r=Je(n),o=Je(e);return e!==o&&!t&&ie(r,"has",e),!t&&ie(r,"has",o),e===o?n.has(e):n.has(e)||n.has(o)}function Se(e){var t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return e=e.__v_raw,!t&&ie(Je(e),"iterate",K),Reflect.get(e,"size",e)}function Oe(e){e=Je(e);var t=Je(this),n=we(t).has.call(t,e);return t.add(e),n||ae(t,"add",e,e),this}function Ve(e,t){t=Je(t);var n=Je(this),r=we(n),o=r.has,i=r.get,a=o.call(n,e);a?"production"!==process.env.NODE_ENV&&Te(n,o,e):(e=Je(e),a=o.call(n,e));var s=i.call(n,e);return n.set(e,t),a?B(t,s)&&ae(n,"set",e,t,s):ae(n,"add",e,t),this}function ke(e){var t=Je(this),n=we(t),r=n.has,o=n.get,i=r.call(t,e);i?"production"!==process.env.NODE_ENV&&Te(t,r,e):(e=Je(e),i=r.call(t,e));var a=o?o.call(t,e):void 0,s=t.delete(e);return i&&ae(t,"delete",e,void 0,a),s}function $e(){var e=Je(this),t=0!==e.size,n="production"!==process.env.NODE_ENV?C(e)?new Map(e):new Set(e):void 0,r=e.clear();return t&&ae(e,"clear",void 0,void 0,n),r}function xe(e,t){return function(n,r){var o=this,i=o.__v_raw,a=Je(i),s=e?_e:t?be:me;return!e&&ie(a,"iterate",K),i.forEach((function(e,t){return n.call(r,s(e),s(t),o)}))}}function De(e,t,n){return function(){var r=this.__v_raw,o=Je(r),a=C(o),s="entries"===e||e===Symbol.iterator&&a,c="keys"===e&&a,u=r[e].apply(r,arguments),l=t?_e:n?be:me;return!t&&ie(o,"iterate",c?J:K),i({next:function(){var e=u.next(),t=e.value,n=e.done;return n?{value:t,done:n}:{value:s?[l(t[0]),l(t[1])]:l(t),done:n}}},Symbol.iterator,(function(){return this}))}}function ze(e){return function(){if("production"!==process.env.NODE_ENV){var t=(arguments.length<=0?void 0:arguments[0])?'on key "'.concat(arguments.length<=0?void 0:arguments[0],'" '):"";console.warn("".concat(H(e)," operation ").concat(t,"failed: target is readonly."),Je(this))}return"delete"!==e&&this}}var Re={get:function(e){return Ee(this,e)},get size(){return Se(this)},has:Ne,add:Oe,set:Ve,delete:ke,clear:$e,forEach:xe(!1,!1)},Ce={get:function(e){return Ee(this,e,!1,!0)},get size(){return Se(this)},has:Ne,add:Oe,set:Ve,delete:ke,clear:$e,forEach:xe(!1,!0)},Ie={get:function(e){return Ee(this,e,!0)},get size(){return Se(this,!0)},has:function(e){return Ne.call(this,e,!0)},add:ze("add"),set:ze("set"),delete:ze("delete"),clear:ze("clear"),forEach:xe(!0,!1)};function Pe(e,t){var n=t?Ce:e?Ie:Re;return function(t,r,o){return"__v_isReactive"===r?!e:"__v_isReadonly"===r?e:"__v_raw"===r?t:Reflect.get(z(n,r)&&r in t?n:t,r,o)}}["keys","values","entries",Symbol.iterator].forEach((function(e){Re[e]=De(e,!1,!1),Ie[e]=De(e,!0,!1),Ce[e]=De(e,!1,!0)}));var Ae={get:Pe(!1,!1)},je={get:Pe(!0,!1)};function Te(e,t,n){var r=Je(n);if(r!==n&&t.call(e,r)){var o=F(e);console.warn("Reactive ".concat(o," contains both the raw and reactive ")+"versions of the same object".concat("Map"===o?" 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.")}}var Me=new WeakMap,Ue=new WeakMap;function Fe(e){return e&&e.__v_isReadonly?e:Be(e,!1,he,Ae)}function Le(e){return Be(e,!0,ye,je)}function He(e){return Be(e,!0,ge,je)}function Be(e,t,n,r){if(!T(e))return"production"!==process.env.NODE_ENV&&console.warn("value cannot be made reactive: ".concat(String(e))),e;if(e.__v_raw&&(!t||!e.__v_isReactive))return e;var o=t?Ue:Me,i=o.get(e);if(i)return i;var a,s=(a=e).__v_skip||!Object.isExtensible(a)?0:function(e){switch(e){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}(F(a));if(0===s)return e;var c=new Proxy(e,2===s?r:n);return o.set(e,c),c}function We(e){return qe(e)?We(e.__v_raw):!(!e||!e.__v_isReactive)}function qe(e){return!(!e||!e.__v_isReadonly)}function Ke(e){return We(e)||qe(e)}function Je(e){return e&&Je(e.__v_raw)||e}function Ge(e){return Boolean(e&&!0===e.__v_isRef)}var Xe=[];function Ye(e){Xe.push(e)}function Ze(){Xe.pop()}function Qe(e){re();for(var t=Xe.length?Xe[Xe.length-1].component:null,n=t&&t.appContext.config.warnHandler,r=et(),o=arguments.length,i=new Array(o>1?o-1:0),a=1;a")})).join("\n"),r]);else{var s,c=["[Vue warn]: ".concat(e)].concat(i);r.length&&c.push.apply(c,["\n"].concat(u(tt(r)))),(s=console).warn.apply(s,u(c))}oe()}function et(){var e=Xe[Xe.length-1];if(!e)return[];for(var t=[];e;){var n=t[0];n&&n.vnode===e?n.recurseCount++:t.push({vnode:e,recurseCount:0});var r=e.component&&e.component.parent;e=r&&r.vnode}return t}function tt(e){var t=[];return e.forEach((function(e,n){var r,o,i,a,s,c,l;t.push.apply(t,u(0===n?[]:["\n"]).concat(u((o=(r=e).vnode,i=r.recurseCount,a=i>0?"... (".concat(i," recursive calls)"):"",s=!!o.component&&null==o.component.parent,c=" at <".concat(wn(o.component,o.type,s)),l=">"+a,o.props?[c].concat(u(function(e){var t=[],n=Object.keys(e);return n.slice(0,3).forEach((function(n){t.push.apply(t,u(function e(t,n,r){return A(n)?(n=JSON.stringify(n),r?n:["".concat(t,"=").concat(n)]):"number"==typeof n||"boolean"==typeof n||null==n?r?n:["".concat(t,"=").concat(n)]:Ge(n)?(n=e(t,Je(n.value),!0),r?n:["".concat(t,"=Ref<"),n,">"]):P(n)?["".concat(t,"=fn").concat(n.name?"<".concat(n.name,">"):"")]:(n=Je(n),r?n:["".concat(t,"="),n])}(n,e[n])))})),n.length>3&&t.push(" ..."),t}(o.props)),[l]):[c+l]))))})),t}var nt=(i(n={},"bc","beforeCreate hook"),i(n,"c","created hook"),i(n,"bm","beforeMount hook"),i(n,"m","mounted hook"),i(n,"bu","beforeUpdate hook"),i(n,"u","updated"),i(n,"bum","beforeUnmount hook"),i(n,"um","unmounted hook"),i(n,"a","activated hook"),i(n,"da","deactivated hook"),i(n,"ec","errorCaptured hook"),i(n,"rtc","renderTracked hook"),i(n,"rtg","renderTriggered hook"),i(n,0,"setup function"),i(n,1,"render function"),i(n,2,"watcher getter"),i(n,3,"watcher callback"),i(n,4,"watcher cleanup function"),i(n,5,"native event handler"),i(n,6,"component event handler"),i(n,7,"vnode hook"),i(n,8,"directive hook"),i(n,9,"transition hook"),i(n,10,"app errorHandler"),i(n,11,"app warnHandler"),i(n,12,"ref function"),i(n,13,"async component loader"),i(n,14,"scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next"),n);function rt(e,t,n,r){var o;try{o=r?e.apply(void 0,u(r)):e()}catch(e){it(e,t,n)}return o}function ot(e,t,n,r){if(P(e)){var o=rt(e,t,n,r);return o&&(T(i=o)&&P(i.then)&&P(i.catch))&&o.catch((function(e){it(e,t,n)})),o}for(var i,a=[],s=0;s3&&void 0!==arguments[3])||arguments[3],o=t?t.vnode:null;if(t){for(var i=t.parent,a=t.proxy,s="production"!==process.env.NODE_ENV?nt[n]:n;i;){var c=i.ec;if(c)for(var u=0;u3&&void 0!==arguments[3])||arguments[3];if("production"!==process.env.NODE_ENV){var o=nt[t];if(n&&Ye(n),Qe("Unhandled error".concat(o?" during execution of ".concat(o):"")),n&&Ze(),r)throw e;console.error(e)}else console.error(e)}var st=!1,ct=!1,ut=[],lt=0,ft=[],dt=null,pt=0,vt=[],ht=null,yt=0,gt=Promise.resolve(),mt=null,_t=null;function bt(e){var t=mt||gt;return e?t.then(this?e.bind(this):e):t}function wt(e){ut.length&&ut.includes(e,st&&e.allowRecurse?lt+1:lt)||e===_t||(ut.push(e),Et())}function Et(){st||ct||(ct=!0,mt=gt.then(kt))}function Nt(e,t,n,r){R(e)?n.push.apply(n,u(e)):t&&t.includes(e,e.allowRecurse?r+1:r)||n.push(e),Et()}function St(e){Nt(e,dt,ft,pt)}function Ot(e){Nt(e,ht,vt,yt)}var Vt=function(e){return null==e.id?1/0:e.id};function kt(e){ct=!1,st=!0,"production"!==process.env.NODE_ENV&&(e=e||new Map),function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(ft.length){for(_t=n,dt=u(new Set(ft)),ft.length=0,"production"!==process.env.NODE_ENV&&(t=t||new Map),pt=0;pt100)throw new Error("Maximum recursive updates exceeded. 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.");e.set(t,n+1)}else e.set(t,1)}var xt=new Set;"production"!==process.env.NODE_ENV&&(("undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{}).__VUE_HMR_RUNTIME__={createRecord:zt((function(e,t){t||(Qe("HMR API usage is out of date.\nPlease upgrade vue-loader/vite/rollup-plugin-vue or other relevant depdendency that handles Vue SFC compilation."),t={});if(Dt.has(e))return!1;return Dt.set(e,{component:En(t)?t.__vccOpts:t,instances:new Set}),!0})),rerender:zt((function(e,t){var n=Dt.get(e);if(!n)return;t&&(n.component.render=t);Array.from(n.instances).forEach((function(e){t&&(e.render=t),e.renderCache=[],e.update()}))})),reload:zt((function(e,t){var n=Dt.get(e);if(!n)return;var r=n.component,o=n.instances;if(!xt.has(r)){for(var i in t=En(t)?t.__vccOpts:t,$(r,t),r)i in t||delete r[i];xt.add(r),Ot((function(){xt.delete(r)}))}Array.from(o).forEach((function(e){e.parent?wt(e.parent.update):e.appContext.reload?e.appContext.reload():"undefined"!=typeof window?window.location.reload():console.warn("[HMR] Root or manually mounted instance modified. Full reload required.")}))}))});var Dt=new Map;function zt(e){return function(t,n){try{return e(t,n)}catch(e){console.error(e),console.warn("[HMR] Something went wrong during Vue component hot-reload. Full reload required.")}}}var Rt=null;function Ct(e){Rt=e}var It=function(e){return e.__isSuspense};function Pt(e){var t,n,r=e.shapeFlag,o=e.children;return 32&r?(t=At(o.default),n=At(o.fallback)):(t=At(o),n=fn(null)),{content:t,fallback:n}}function At(e){if(P(e)&&(e=e()),R(e)){var t=function(e){for(var t,n=0;n slots expect a single root node."),e=t}return fn(e)}var jt=0,Tt=function(e){return jt+=e};var Mt=null,Ut=[];function Ft(e){Ut.push(Mt=e)}function Lt(){Ut.pop(),Mt=Ut[Ut.length-1]||null}function Ht(e){return function(t){return function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Rt;if(!t)return e;var n=function(){jt||tn(!0);var n=Rt;Ct(t);var r=e.apply(void 0,arguments);return Ct(n),jt||nn(),r};return n._c=!0,n}((function(){Ft(e);var n=t.apply(this,arguments);return Lt(),n}))}}var Bt={};function Wt(e,t,n){var r=this.proxy;return function(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:N,r=n.immediate,o=n.deep,i=n.flush,a=n.onTrack,s=n.onTrigger,c=arguments.length>3&&void 0!==arguments[3]?arguments[3]:gn;"production"===process.env.NODE_ENV||t||(void 0!==r&&Qe('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'),void 0!==o&&Qe('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'));var u,l,f=function(e){Qe("Invalid watch source: ",e,"A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.")},d=!1;if(Ge(e)?(u=function(){return e.value},d=!!e._shallow):We(e)?(u=function(){return e},o=!0):R(e)?u=function(){return e.map((function(e){return Ge(e)?e.value:We(e)?qt(e):P(e)?rt(e,c,2):void("production"!==process.env.NODE_ENV&&f(e))}))}:P(e)?u=t?function(){return rt(e,c,2)}:function(){if(!c||!c.isUnmounted)return l&&l(),rt(e,c,3,[v])}:(u=O,"production"!==process.env.NODE_ENV&&f(e)),t&&o){var p=u;u=function(){return qt(p())}}var v=function(e){l=g.options.onStop=function(){rt(e,c,4)}},h=R(e)?[]:Bt,y=function(){if(g.active)if(t){var e=g();(o||d||B(e,h))&&(l&&l(),ot(t,c,3,[e,h===Bt?void 0:h,v]),h=e)}else g()};y.allowRecurse=!!t;var g=X(u,{lazy:!0,onTrack:a,onTrigger:s,scheduler:"sync"===i?y:"post"===i?function(){return Kt(y,c&&c.suspense)}:function(){!c||c.isMounted?St(y):y()}});return mn(g,c),t?r?y():h=g():"post"===i?Kt(g,c&&c.suspense):g(),function(){Y(g),c&&x(c.effects,g)}}(A(e)?function(){return r[e]}:e.bind(r),t.bind(r),n,this)}function qt(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:new Set;if(!T(e)||t.has(e))return e;if(t.add(e),Ge(e))qt(e.value,t);else if(R(e))for(var n=0;n0&&void 0!==arguments[0]&&arguments[0];Qt.push(en=e?null:[])}function nn(){Qt.pop(),en=Qt[Qt.length-1]||null}function rn(e){return!!e&&!0===e.__v_isVNode}var on=function(e){var t=e.key;return null!=t?t:null},an=function(e){var t=e.ref;return null!=t?A(t)||Ge(t)||P(t)?{i:Rt,r:t}:t:null},sn="production"!==process.env.NODE_ENV?function(){return cn.apply(void 0,arguments)}:cn;function cn(e){var t,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,a=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null,s=arguments.length>5&&void 0!==arguments[5]&&arguments[5];if(e&&e!==Gt||("production"===process.env.NODE_ENV||e||Qe("Invalid vnode type when creating vnode: ".concat(e,".")),e=Zt),rn(e)){var c=un(e,n,!0);return r&&dn(c,r),c}if(En(e)&&(e=e.__vccOpts),n){(Ke(n)||"__vInternal"in n)&&(n=$({},n));var u=n,l=u.class,f=u.style;l&&!A(l)&&(n.class=m(l)),T(f)&&(Ke(f)&&!R(f)&&(f=$({},f)),n.style=v(f))}var d=A(e)?1:It(e)?128:Jt(e)?64:T(e)?4:P(e)?2:0;"production"!==process.env.NODE_ENV&&4&d&&Ke(e)&&Qe("Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.","\nComponent that was made reactive: ",e=Je(e));var p=(i(t={__v_isVNode:!0},"__v_skip",!0),i(t,"type",e),i(t,"props",n),i(t,"key",n&&on(n)),i(t,"ref",n&&an(n)),i(t,"scopeId",Mt),i(t,"children",null),i(t,"component",null),i(t,"suspense",null),i(t,"ssContent",null),i(t,"ssFallback",null),i(t,"dirs",null),i(t,"transition",null),i(t,"el",null),i(t,"anchor",null),i(t,"target",null),i(t,"targetAnchor",null),i(t,"staticCount",0),i(t,"shapeFlag",d),i(t,"patchFlag",o),i(t,"dynamicProps",a),i(t,"dynamicChildren",null),i(t,"appContext",null),t);if("production"!==process.env.NODE_ENV&&p.key!=p.key&&Qe("VNode created with invalid key (NaN). VNode type:",p.type),dn(p,r),128&d){var h=Pt(p),y=h.content,g=h.fallback;p.ssContent=y,p.ssFallback=g}return!s&&en&&(o>0||6&d)&&32!==o&&en.push(p),p}function un(e,t){var n,r=arguments.length>2&&void 0!==arguments[2]&&arguments[2],o=e.props,a=e.ref,s=e.patchFlag,c=t?pn(o||{},t):o;return i(n={__v_isVNode:!0},"__v_skip",!0),i(n,"type",e.type),i(n,"props",c),i(n,"key",c&&on(c)),i(n,"ref",t&&t.ref?r&&a?R(a)?a.concat(an(t)):[a,an(t)]:an(t):a),i(n,"scopeId",e.scopeId),i(n,"children",e.children),i(n,"target",e.target),i(n,"targetAnchor",e.targetAnchor),i(n,"staticCount",e.staticCount),i(n,"shapeFlag",e.shapeFlag),i(n,"patchFlag",t&&e.type!==Xt?-1===s?16:16|s:s),i(n,"dynamicProps",e.dynamicProps),i(n,"dynamicChildren",e.dynamicChildren),i(n,"appContext",e.appContext),i(n,"dirs",e.dirs),i(n,"transition",e.transition),i(n,"component",e.component),i(n,"suspense",e.suspense),i(n,"ssContent",e.ssContent&&un(e.ssContent)),i(n,"ssFallback",e.ssFallback&&un(e.ssFallback)),i(n,"el",e.el),i(n,"anchor",e.anchor),n}function ln(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:" ",t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return sn(Yt,null,e,t)}function fn(e){return null==e||"boolean"==typeof e?sn(Zt):R(e)?sn(Xt,null,e):"object"===o(e)?null===e.el?e:un(e):sn(Yt,null,String(e))}function dn(e,t){var n=0,r=e.shapeFlag;if(null==t)t=null;else if(R(t))n=16;else if("object"===o(t)){if(1&r||64&r){var i=t.default;return void(i&&(i._c&&Tt(1),dn(e,i()),i._c&&Tt(-1)))}n=32;var a=t._;a||"__vInternal"in t?3===a&&Rt&&(1024&Rt.vnode.patchFlag?(t._=2,e.patchFlag|=1024):t._=1):t._ctx=Rt}else P(t)?(t={default:t,_ctx:Rt},n=32):(t=String(t),64&r?(n=16,t=[ln(t)]):n=8);e.children=t,e.shapeFlag|=n}function pn(){for(var e=$({},arguments.length<=0?void 0:arguments[0]),t=1;t1&&void 0!==arguments[1]?arguments[1]:gn;t&&(t.effects||(t.effects=[])).push(e)}var _n=/(?:^|[-_])(\w)/g,bn=function(e){return e.replace(_n,(function(e){return e.toUpperCase()})).replace(/[-_]/g,"")};function wn(e,t){var n=arguments.length>2&&void 0!==arguments[2]&&arguments[2],r=P(t)&&t.displayName||t.name;if(!r&&t.__file){var o=t.__file.match(/([^/\\]+)\.\w+$/);o&&(r=o[1])}if(!r&&e&&e.parent){var i=function(e){for(var n in e)if(e[n]===t)return n};r=i(e.components||e.parent.type.components)||i(e.appContext.components)}return r?bn(r):n?"App":"Anonymous"}function En(e){return P(e)&&"__vccOpts"in e}var Nn,Sn;Symbol("production"!==process.env.NODE_ENV?"ssrContext":"");function On(){if("production"!==process.env.NODE_ENV&&"undefined"!=typeof window){var e={style:"color:#3ba776"},t={style:"color:#0b1bc9"},n={style:"color:#b62e24"},r={style:"color:#9d288c"},o={header:function(t){return T(t)?t.__isVue?["div",e,"VueInstance"]:Ge(t)?["div",{},["span",e,l(t)],"<",a(t.value),">"]:We(t)?["div",{},["span",e,"Reactive"],"<",a(t),">".concat(qe(t)?" (readonly)":"")]:qe(t)?["div",{},["span",e,"Readonly"],"<",a(t),">"]:null:null},hasBody:function(e){return e&&e.__isVue},body:function(e){if(e&&e.__isVue)return["div",{}].concat(u(function(e){var t=[];e.type.props&&e.props&&t.push(i("props",Je(e.props)));e.setupState!==N&&t.push(i("setup",e.setupState));e.data!==N&&t.push(i("data",Je(e.data)));var n=s(e,"computed");n&&t.push(i("computed",n));var o=s(e,"inject");o&&t.push(i("injected",o));return t.push(["div",{},["span",{style:r.style+";opacity:0.66"},"$ (internal): "],["object",{object:e}]]),t}(e.$)))}};window.devtoolsFormatters?window.devtoolsFormatters.push(o):window.devtoolsFormatters=[o]}function i(e,t){return t=$({},t),Object.keys(t).length?["div",{style:"line-height:1.25em;margin-bottom:0.6em"},["div",{style:"color:#476582"},e],["div",{style:"padding-left:1.25em"}].concat(u(Object.keys(t).map((function(e){return["div",{},["span",r,e+": "],a(t[e],!1)]}))))]:["span",{}]}function a(e){var o=!(arguments.length>1&&void 0!==arguments[1])||arguments[1];return"number"==typeof e?["span",t,e]:"string"==typeof e?["span",n,JSON.stringify(e)]:"boolean"==typeof e?["span",r,e]:T(e)?["object",{object:o?Je(e):e}]:["span",n,String(e)]}function s(e,t){var n=e.type;if(!P(n)){var r={};for(var o in e.ctx)c(n,o,t)&&(r[o]=e.ctx[o]);return r}}function c(e,t,n){var r=e[n];return!!(R(r)&&r.includes(t)||T(r)&&t in r)||(!(!e.extends||!c(e.extends,t,n))||(!(!e.mixins||!e.mixins.some((function(e){return c(e,t,n)})))||void 0))}function l(e){return e._shallow?"ShallowRef":e.effect?"ComputedRef":"Ref"}}function Vn(){Vn.init||(Vn.init=!0,Sn=-1!==function(){var e=window.navigator.userAgent,t=e.indexOf("MSIE ");if(t>0)return parseInt(e.substring(t+5,e.indexOf(".",t)),10);if(e.indexOf("Trident/")>0){var n=e.indexOf("rv:");return parseInt(e.substring(n+3,e.indexOf(".",n)),10)}var r=e.indexOf("Edge/");return r>0?parseInt(e.substring(r+5,e.indexOf(".",r)),10):-1}())}"production"!==process.env.NODE_ENV&&((Nn=w||(w="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof window?window:"undefined"!=typeof global?global:{})).__VUE__=!0,Nn.__VUE_DEVTOOLS_GLOBAL_HOOK__,On());var kn={name:"ResizeObserver",mounted:function(){var e=this;Vn(),bt((function(){e._w=e.$el.offsetWidth,e._h=e.$el.offsetHeight}));var t=document.createElement("object");this._resizeObject=t,t.setAttribute("aria-hidden","true"),t.setAttribute("tabindex",-1),t.onload=this.addResizeHandlers,t.type="text/html",Sn&&this.$el.appendChild(t),t.data="about:blank",Sn||this.$el.appendChild(t)},beforeUnmount:function(){this.removeResizeHandlers()},methods:{compareAndNotify:function(){this._w===this.$el.offsetWidth&&this._h===this.$el.offsetHeight||(this._w=this.$el.offsetWidth,this._h=this.$el.offsetHeight,this.$emit("notify",{width:this._w,height:this._h}))},addResizeHandlers:function(){this._resizeObject.contentDocument.defaultView.addEventListener("resize",this.compareAndNotify),this.compareAndNotify()},removeResizeHandlers:function(){this._resizeObject&&this._resizeObject.onload&&(!Sn&&this._resizeObject.contentDocument&&this._resizeObject.contentDocument.defaultView.removeEventListener("resize",this.compareAndNotify),this.$el.removeChild(this._resizeObject),this._resizeObject.onload=null,this._resizeObject=null)}}},$n=Ht("data-v-b329ee4c");Ft("data-v-b329ee4c");var xn={class:"resize-observer",tabindex:"-1"};Lt();var Dn=$n((function(e,t,n,r,o,i){return tn(),function(e,t,n,r,o){var i=sn(e,t,n,r,o,!0);return i.dynamicChildren=en||S,nn(),en&&en.push(i),i}("div",xn)}));kn.render=Dn,kn.__scopeId="data-v-b329ee4c",kn.__file="src/components/ResizeObserver.vue";var zn,Rn={version:"0.5.0",install:function(e){e.component("resize-observer",kn),e.component("ResizeObserver",kn)}},Cn=null;function In(e){return(In="function"==typeof Symbol&&"symbol"===o(Symbol.iterator)?function(e){return o(e)}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":o(e)})(e)}function Pn(e,t){for(var n=0;n1&&(t[n[0].trim()]=n[1].trim())}})),t}function Bn(e){var t="";if(ar(e))t=e;else if(nr(e))for(var n=0;n-1&&e.splice(n,1)},er=Object.prototype.hasOwnProperty,tr=function(e,t){return er.call(e,t)},nr=Array.isArray,rr=function(e){return"[object Map]"===lr(e)},or=function(e){return"[object Set]"===lr(e)},ir=function(e){return"function"==typeof e},ar=function(e){return"string"==typeof e},sr=function(e){return"symbol"===o(e)},cr=function(e){return null!==e&&"object"===o(e)},ur=Object.prototype.toString,lr=function(e){return ur.call(e)},fr=function(e){return lr(e).slice(8,-1)},dr=function(e){return ar(e)&&"NaN"!==e&&"-"!==e[0]&&""+parseInt(e,10)===e},pr=function(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}},vr=/-(\w)/g,hr=pr((function(e){return e.replace(vr,(function(e,t){return t?t.toUpperCase():""}))})),yr=/\B([A-Z])/g,gr=pr((function(e){return e.replace(yr,"-$1").toLowerCase()})),mr=pr((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),_r=function(e,t){return e!==t&&(e==e||t==t)},br=new WeakMap,wr=[],Er=Symbol("production"!==process.env.NODE_ENV?"iterate":""),Nr=Symbol("production"!==process.env.NODE_ENV?"Map key iterate":"");function Sr(e){return e&&!0===e._isEffect}function Or(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Kn;Sr(e)&&(e=e.raw);var n=$r(e,t);return t.lazy||n(),n}function Vr(e){e.active&&(xr(e),e.options.onStop&&e.options.onStop(),e.active=!1)}var kr=0;function $r(e,t){var n=function(){if(!n.active)return t.scheduler?void 0:e();if(!wr.includes(n)){xr(n);try{return zr.push(Dr),Dr=!0,wr.push(n),qn=n,e()}finally{wr.pop(),Cr(),qn=wr[wr.length-1]}}};return n.id=kr++,n.allowRecurse=!!t.allowRecurse,n._isEffect=!0,n.active=!0,n.raw=e,n.deps=[],n.options=t,n}function xr(e){var t=e.deps;if(t.length){for(var n=0;n=r)&&c(e)}));else switch(void 0!==n&&c(a.get(n)),t){case"add":nr(e)?dr(n)&&c(a.get("length")):(c(a.get(Er)),rr(e)&&c(a.get(Nr)));break;case"delete":nr(e)||(c(a.get(Er)),rr(e)&&c(a.get(Nr)));break;case"set":rr(e)&&c(a.get(Er))}s.forEach((function(a){"production"!==process.env.NODE_ENV&&a.options.onTrigger&&a.options.onTrigger({effect:a,target:e,key:n,type:t,newValue:r,oldValue:o,oldTarget:i}),a.options.scheduler?a.options.scheduler(a):a()}))}}var Ar=new Set(Object.getOwnPropertyNames(Symbol).map((function(e){return Symbol[e]})).filter(sr)),jr=Lr(),Tr=Lr(!1,!0),Mr=Lr(!0),Ur=Lr(!0,!0),Fr={};function Lr(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0],t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return function(n,r,o){if("__v_isReactive"===r)return!e;if("__v_isReadonly"===r)return e;if("__v_raw"===r&&o===(e?yo:ho).get(n))return n;var i=nr(n);if(!e&&i&&tr(Fr,r))return Reflect.get(Fr,r,o);var a=Reflect.get(n,r,o);return(sr(r)?Ar.has(r):"__proto__"===r||"__v_isRef"===r)?a:(e||Ir(n,"get",r),t?a:Oo(a)?!i||!dr(r)?a.value:a:cr(a)?e?mo(a):go(a):a)}}function Hr(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0];return function(t,n,r,o){var i=t[n];if(!e&&(r=So(r),!nr(t)&&Oo(i)&&!Oo(r)))return i.value=r,!0;var a=nr(t)&&dr(n)?Number(n)2&&void 0!==arguments[2]&&arguments[2],r=arguments.length>3&&void 0!==arguments[3]&&arguments[3],o=So(e=e.__v_raw),i=So(t);t!==i&&!n&&Ir(o,"get",t),!n&&Ir(o,"get",i);var a=Xr(o),s=a.has,c=n?Jr:r?Gr:Kr;return s.call(o,t)?c(e.get(t)):s.call(o,i)?c(e.get(i)):void 0}function Zr(e){var t=arguments.length>1&&void 0!==arguments[1]&&arguments[1],n=this.__v_raw,r=So(n),o=So(e);return e!==o&&!t&&Ir(r,"has",e),!t&&Ir(r,"has",o),e===o?n.has(e):n.has(e)||n.has(o)}function Qr(e){var t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return e=e.__v_raw,!t&&Ir(So(e),"iterate",Er),Reflect.get(e,"size",e)}function eo(e){e=So(e);var t=So(this),n=Xr(t).has.call(t,e);return t.add(e),n||Pr(t,"add",e,e),this}function to(e,t){t=So(t);var n=So(this),r=Xr(n),o=r.has,i=r.get,a=o.call(n,e);a?"production"!==process.env.NODE_ENV&&vo(n,o,e):(e=So(e),a=o.call(n,e));var s=i.call(n,e);return n.set(e,t),a?_r(t,s)&&Pr(n,"set",e,t,s):Pr(n,"add",e,t),this}function no(e){var t=So(this),n=Xr(t),r=n.has,o=n.get,i=r.call(t,e);i?"production"!==process.env.NODE_ENV&&vo(t,r,e):(e=So(e),i=r.call(t,e));var a=o?o.call(t,e):void 0,s=t.delete(e);return i&&Pr(t,"delete",e,void 0,a),s}function ro(){var e=So(this),t=0!==e.size,n="production"!==process.env.NODE_ENV?rr(e)?new Map(e):new Set(e):void 0,r=e.clear();return t&&Pr(e,"clear",void 0,void 0,n),r}function oo(e,t){return function(n,r){var o=this,i=o.__v_raw,a=So(i),s=e?Jr:t?Gr:Kr;return!e&&Ir(a,"iterate",Er),i.forEach((function(e,t){return n.call(r,s(e),s(t),o)}))}}function io(e,t,n){return function(){var r=this.__v_raw,o=So(r),a=rr(o),s="entries"===e||e===Symbol.iterator&&a,c="keys"===e&&a,u=r[e].apply(r,arguments),l=t?Jr:n?Gr:Kr;return!t&&Ir(o,"iterate",c?Nr:Er),i({next:function(){var e=u.next(),t=e.value,n=e.done;return n?{value:t,done:n}:{value:s?[l(t[0]),l(t[1])]:l(t),done:n}}},Symbol.iterator,(function(){return this}))}}function ao(e){return function(){if("production"!==process.env.NODE_ENV){var t=(arguments.length<=0?void 0:arguments[0])?'on key "'.concat(arguments.length<=0?void 0:arguments[0],'" '):"";console.warn("".concat(mr(e)," operation ").concat(t,"failed: target is readonly."),So(this))}return"delete"!==e&&this}}var so={get:function(e){return Yr(this,e)},get size(){return Qr(this)},has:Zr,add:eo,set:to,delete:no,clear:ro,forEach:oo(!1,!1)},co={get:function(e){return Yr(this,e,!1,!0)},get size(){return Qr(this)},has:Zr,add:eo,set:to,delete:no,clear:ro,forEach:oo(!1,!0)},uo={get:function(e){return Yr(this,e,!0)},get size(){return Qr(this,!0)},has:function(e){return Zr.call(this,e,!0)},add:ao("add"),set:ao("set"),delete:ao("delete"),clear:ao("clear"),forEach:oo(!0,!1)};function lo(e,t){var n=t?co:e?uo:so;return function(t,r,o){return"__v_isReactive"===r?!e:"__v_isReadonly"===r?e:"__v_raw"===r?t:Reflect.get(tr(n,r)&&r in t?n:t,r,o)}}["keys","values","entries",Symbol.iterator].forEach((function(e){so[e]=io(e,!1,!1),uo[e]=io(e,!0,!1),co[e]=io(e,!1,!0)}));var fo={get:lo(!1,!1)},po={get:lo(!0,!1)};function vo(e,t,n){var r=So(n);if(r!==n&&t.call(e,r)){var o=fr(e);console.warn("Reactive ".concat(o," contains both the raw and reactive ")+"versions of the same object".concat("Map"===o?" 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.")}}var ho=new WeakMap,yo=new WeakMap;function go(e){return e&&e.__v_isReadonly?e:bo(e,!1,Br,fo)}function mo(e){return bo(e,!0,Wr,po)}function _o(e){return bo(e,!0,qr,po)}function bo(e,t,n,r){if(!cr(e))return"production"!==process.env.NODE_ENV&&console.warn("value cannot be made reactive: ".concat(String(e))),e;if(e.__v_raw&&(!t||!e.__v_isReactive))return e;var o=t?yo:ho,i=o.get(e);if(i)return i;var a,s=(a=e).__v_skip||!Object.isExtensible(a)?0:function(e){switch(e){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}(fr(a));if(0===s)return e;var c=new Proxy(e,2===s?r:n);return o.set(e,c),c}function wo(e){return Eo(e)?wo(e.__v_raw):!(!e||!e.__v_isReactive)}function Eo(e){return!(!e||!e.__v_isReadonly)}function No(e){return wo(e)||Eo(e)}function So(e){return e&&So(e.__v_raw)||e}function Oo(e){return Boolean(e&&!0===e.__v_isRef)}var Vo=[];function ko(e){Vo.push(e)}function $o(){Vo.pop()}function xo(e){Rr();for(var t=Vo.length?Vo[Vo.length-1].component:null,n=t&&t.appContext.config.warnHandler,r=Do(),o=arguments.length,i=new Array(o>1?o-1:0),a=1;a")})).join("\n"),r]);else{var s,c=["[Vue warn]: ".concat(e)].concat(i);r.length&&c.push.apply(c,["\n"].concat(u(zo(r)))),(s=console).warn.apply(s,u(c))}Cr()}function Do(){var e=Vo[Vo.length-1];if(!e)return[];for(var t=[];e;){var n=t[0];n&&n.vnode===e?n.recurseCount++:t.push({vnode:e,recurseCount:0});var r=e.component&&e.component.parent;e=r&&r.vnode}return t}function zo(e){var t=[];return e.forEach((function(e,n){var r,o,i,a,s,c,l;t.push.apply(t,u(0===n?[]:["\n"]).concat(u((o=(r=e).vnode,i=r.recurseCount,a=i>0?"... (".concat(i," recursive calls)"):"",s=!!o.component&&null==o.component.parent,c=" at <".concat(Mi(o.component,o.type,s)),l=">"+a,o.props?[c].concat(u(function(e){var t=[],n=Object.keys(e);return n.slice(0,3).forEach((function(n){t.push.apply(t,u(function e(t,n,r){return ar(n)?(n=JSON.stringify(n),r?n:["".concat(t,"=").concat(n)]):"number"==typeof n||"boolean"==typeof n||null==n?r?n:["".concat(t,"=").concat(n)]:Oo(n)?(n=e(t,So(n.value),!0),r?n:["".concat(t,"=Ref<"),n,">"]):ir(n)?["".concat(t,"=fn").concat(n.name?"<".concat(n.name,">"):"")]:(n=So(n),r?n:["".concat(t,"="),n])}(n,e[n])))})),n.length>3&&t.push(" ..."),t}(o.props)),[l]):[c+l]))))})),t}var Ro=(i(zn={},"bc","beforeCreate hook"),i(zn,"c","created hook"),i(zn,"bm","beforeMount hook"),i(zn,"m","mounted hook"),i(zn,"bu","beforeUpdate hook"),i(zn,"u","updated"),i(zn,"bum","beforeUnmount hook"),i(zn,"um","unmounted hook"),i(zn,"a","activated hook"),i(zn,"da","deactivated hook"),i(zn,"ec","errorCaptured hook"),i(zn,"rtc","renderTracked hook"),i(zn,"rtg","renderTriggered hook"),i(zn,0,"setup function"),i(zn,1,"render function"),i(zn,2,"watcher getter"),i(zn,3,"watcher callback"),i(zn,4,"watcher cleanup function"),i(zn,5,"native event handler"),i(zn,6,"component event handler"),i(zn,7,"vnode hook"),i(zn,8,"directive hook"),i(zn,9,"transition hook"),i(zn,10,"app errorHandler"),i(zn,11,"app warnHandler"),i(zn,12,"ref function"),i(zn,13,"async component loader"),i(zn,14,"scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next"),zn);function Co(e,t,n,r){var o;try{o=r?e.apply(void 0,u(r)):e()}catch(e){Po(e,t,n)}return o}function Io(e,t,n,r){if(ir(e)){var o=Co(e,t,n,r);return o&&(cr(i=o)&&ir(i.then)&&ir(i.catch))&&o.catch((function(e){Po(e,t,n)})),o}for(var i,a=[],s=0;s3&&void 0!==arguments[3])||arguments[3],o=t?t.vnode:null;if(t){for(var i=t.parent,a=t.proxy,s="production"!==process.env.NODE_ENV?Ro[n]:n;i;){var c=i.ec;if(c)for(var u=0;u3&&void 0!==arguments[3])||arguments[3];if("production"!==process.env.NODE_ENV){var o=Ro[t];if(n&&ko(n),xo("Unhandled error".concat(o?" during execution of ".concat(o):"")),n&&$o(),r)throw e;console.error(e)}else console.error(e)}var jo=!1,To=!1,Mo=[],Uo=0,Fo=[],Lo=null,Ho=0,Bo=[],Wo=null,qo=0,Ko=Promise.resolve(),Jo=null,Go=null;function Xo(e){var t=Jo||Ko;return e?t.then(this?e.bind(this):e):t}function Yo(e){Mo.length&&Mo.includes(e,jo&&e.allowRecurse?Uo+1:Uo)||e===Go||(Mo.push(e),Zo())}function Zo(){jo||To||(To=!0,Jo=Ko.then(ri))}function Qo(e,t,n,r){nr(e)?n.push.apply(n,u(e)):t&&t.includes(e,e.allowRecurse?r+1:r)||n.push(e),Zo()}function ei(e){Qo(e,Lo,Fo,Ho)}function ti(e){Qo(e,Wo,Bo,qo)}var ni=function(e){return null==e.id?1/0:e.id};function ri(e){To=!1,jo=!0,"production"!==process.env.NODE_ENV&&(e=e||new Map),function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(Fo.length){for(Go=n,Lo=u(new Set(Fo)),Fo.length=0,"production"!==process.env.NODE_ENV&&(t=t||new Map),Ho=0;Ho100)throw new Error("Maximum recursive updates exceeded. 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.");e.set(t,n+1)}else e.set(t,1)}var ii=new Set;"production"!==process.env.NODE_ENV&&(("undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{}).__VUE_HMR_RUNTIME__={createRecord:si((function(e,t){t||(xo("HMR API usage is out of date.\nPlease upgrade vue-loader/vite/rollup-plugin-vue or other relevant depdendency that handles Vue SFC compilation."),t={});if(ai.has(e))return!1;return ai.set(e,{component:Ui(t)?t.__vccOpts:t,instances:new Set}),!0})),rerender:si((function(e,t){var n=ai.get(e);if(!n)return;t&&(n.component.render=t);Array.from(n.instances).forEach((function(e){t&&(e.render=t),e.renderCache=[],e.update()}))})),reload:si((function(e,t){var n=ai.get(e);if(!n)return;var r=n.component,o=n.instances;if(!ii.has(r)){for(var i in t=Ui(t)?t.__vccOpts:t,Zn(r,t),r)i in t||delete r[i];ii.add(r),ti((function(){ii.delete(r)}))}Array.from(o).forEach((function(e){e.parent?Yo(e.parent.update):e.appContext.reload?e.appContext.reload():"undefined"!=typeof window?window.location.reload():console.warn("[HMR] Root or manually mounted instance modified. Full reload required.")}))}))});var ai=new Map;function si(e){return function(t,n){try{return e(t,n)}catch(e){console.error(e),console.warn("[HMR] Something went wrong during Vue component hot-reload. Full reload required.")}}}var ci=function(e){return e.__isSuspense};function ui(e){var t,n,r=e.shapeFlag,o=e.children;return 32&r?(t=li(o.default),n=li(o.fallback)):(t=li(o),n=xi(null)),{content:t,fallback:n}}function li(e){if(ir(e)&&(e=e()),nr(e)){var t=function(e){for(var t,n=0;n slots expect a single root node."),e=t}return xi(e)}var fi=0,di=function(e){return fi+=e},pi={};function vi(e,t,n){var r=this.proxy;return function(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:Kn,r=n.immediate,o=n.deep,i=n.flush,a=n.onTrack,s=n.onTrigger,c=arguments.length>3&&void 0!==arguments[3]?arguments[3]:Pi;"production"===process.env.NODE_ENV||t||(void 0!==r&&xo('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'),void 0!==o&&xo('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'));var u,l,f=function(e){xo("Invalid watch source: ",e,"A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.")},d=!1;if(Oo(e)?(u=function(){return e.value},d=!!e._shallow):wo(e)?(u=function(){return e},o=!0):nr(e)?u=function(){return e.map((function(e){return Oo(e)?e.value:wo(e)?hi(e):ir(e)?Co(e,c,2):void("production"!==process.env.NODE_ENV&&f(e))}))}:ir(e)?u=t?function(){return Co(e,c,2)}:function(){if(!c||!c.isUnmounted)return l&&l(),Co(e,c,3,[v])}:(u=Jn,"production"!==process.env.NODE_ENV&&f(e)),t&&o){var p=u;u=function(){return hi(p())}}var v=function(e){l=g.options.onStop=function(){Co(e,c,4)}},h=nr(e)?[]:pi,y=function(){if(g.active)if(t){var e=g();(o||d||_r(e,h))&&(l&&l(),Io(t,c,3,[e,h===pi?void 0:h,v]),h=e)}else g()};y.allowRecurse=!!t;var g=Or(u,{lazy:!0,onTrack:a,onTrigger:s,scheduler:"sync"===i?y:"post"===i?function(){return yi(y,c&&c.suspense)}:function(){!c||c.isMounted?ei(y):y()}});return Ai(g,c),t?r?y():h=g():"post"===i?yi(g,c&&c.suspense):g(),function(){Vr(g),c&&Qn(c.effects,g)}}(ar(e)?function(){return r[e]}:e.bind(r),t.bind(r),n,this)}function hi(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:new Set;if(!cr(e)||t.has(e))return e;if(t.add(e),Oo(e))hi(e.value,t);else if(nr(e))for(var n=0;n1&&void 0!==arguments[1]?arguments[1]:null,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,a=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null;arguments.length>5&&void 0!==arguments[5]&&arguments[5];if(e&&e!==mi||("production"===process.env.NODE_ENV||e||xo("Invalid vnode type when creating vnode: ".concat(e,".")),e=wi),Ei(e)){var s=ki(e,n,!0);return r&&Di(s,r),s}if(Ui(e)&&(e=e.__vccOpts),n){(No(n)||"__vInternal"in n)&&(n=Zn({},n));var c=n,u=c.class,l=c.style;u&&!ar(u)&&(n.class=Bn(u)),cr(l)&&(No(l)&&!nr(l)&&(l=Zn({},l)),n.style=Un(l))}var f=ar(e)?1:ci(e)?128:gi(e)?64:cr(e)?4:ir(e)?2:0;"production"!==process.env.NODE_ENV&&4&f&&No(e)&&xo("Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.","\nComponent that was made reactive: ",e=So(e));var d=(i(t={__v_isVNode:!0},"__v_skip",!0),i(t,"type",e),i(t,"props",n),i(t,"key",n&&Ni(n)),i(t,"ref",n&&Si(n)),i(t,"scopeId",null),i(t,"children",null),i(t,"component",null),i(t,"suspense",null),i(t,"ssContent",null),i(t,"ssFallback",null),i(t,"dirs",null),i(t,"transition",null),i(t,"el",null),i(t,"anchor",null),i(t,"target",null),i(t,"targetAnchor",null),i(t,"staticCount",0),i(t,"shapeFlag",f),i(t,"patchFlag",o),i(t,"dynamicProps",a),i(t,"dynamicChildren",null),i(t,"appContext",null),t);if("production"!==process.env.NODE_ENV&&d.key!=d.key&&xo("VNode created with invalid key (NaN). VNode type:",d.type),Di(d,r),128&f){var p=ui(d),v=p.content,h=p.fallback;d.ssContent=v,d.ssFallback=h}return d}function ki(e,t){var n,r=arguments.length>2&&void 0!==arguments[2]&&arguments[2],o=e.props,a=e.ref,s=e.patchFlag,c=t?zi(o||{},t):o;return i(n={__v_isVNode:!0},"__v_skip",!0),i(n,"type",e.type),i(n,"props",c),i(n,"key",c&&Ni(c)),i(n,"ref",t&&t.ref?r&&a?nr(a)?a.concat(Si(t)):[a,Si(t)]:Si(t):a),i(n,"scopeId",e.scopeId),i(n,"children",e.children),i(n,"target",e.target),i(n,"targetAnchor",e.targetAnchor),i(n,"staticCount",e.staticCount),i(n,"shapeFlag",e.shapeFlag),i(n,"patchFlag",t&&e.type!==_i?-1===s?16:16|s:s),i(n,"dynamicProps",e.dynamicProps),i(n,"dynamicChildren",e.dynamicChildren),i(n,"appContext",e.appContext),i(n,"dirs",e.dirs),i(n,"transition",e.transition),i(n,"component",e.component),i(n,"suspense",e.suspense),i(n,"ssContent",e.ssContent&&ki(e.ssContent)),i(n,"ssFallback",e.ssFallback&&ki(e.ssFallback)),i(n,"el",e.el),i(n,"anchor",e.anchor),n}function $i(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:" ",t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return Oi(bi,null,e,t)}function xi(e){return null==e||"boolean"==typeof e?Oi(wi):nr(e)?Oi(_i,null,e):"object"===o(e)?null===e.el?e:ki(e):Oi(bi,null,String(e))}function Di(e,t){var n=0,r=e.shapeFlag;if(null==t)t=null;else if(nr(t))n=16;else if("object"===o(t)){if(1&r||64&r){var i=t.default;return void(i&&(i._c&&di(1),Di(e,i()),i._c&&di(-1)))}n=32;var a=t._;a||"__vInternal"in t||(t._ctx=null)}else ir(t)?(t={default:t,_ctx:null},n=32):(t=String(t),64&r?(n=16,t=[$i(t)]):n=8);e.children=t,e.shapeFlag|=n}function zi(){for(var e=Zn({},arguments.length<=0?void 0:arguments[0]),t=1;t1&&void 0!==arguments[1]?arguments[1]:Pi;t&&(t.effects||(t.effects=[])).push(e)}var ji=/(?:^|[-_])(\w)/g,Ti=function(e){return e.replace(ji,(function(e){return e.toUpperCase()})).replace(/[-_]/g,"")};function Mi(e,t){var n=arguments.length>2&&void 0!==arguments[2]&&arguments[2],r=ir(t)&&t.displayName||t.name;if(!r&&t.__file){var o=t.__file.match(/([^/\\]+)\.\w+$/);o&&(r=o[1])}if(!r&&e&&e.parent){var i=function(e){for(var n in e)if(e[n]===t)return n};r=i(e.components||e.parent.type.components)||i(e.appContext.components)}return r?Ti(r):n?"App":"Anonymous"}function Ui(e){return ir(e)&&"__vccOpts"in e}Symbol("production"!==process.env.NODE_ENV?"ssrContext":"");function Fi(){if("production"!==process.env.NODE_ENV&&"undefined"!=typeof window){var e={style:"color:#3ba776"},t={style:"color:#0b1bc9"},n={style:"color:#b62e24"},r={style:"color:#9d288c"},o={header:function(t){return cr(t)?t.__isVue?["div",e,"VueInstance"]:Oo(t)?["div",{},["span",e,l(t)],"<",a(t.value),">"]:wo(t)?["div",{},["span",e,"Reactive"],"<",a(t),">".concat(Eo(t)?" (readonly)":"")]:Eo(t)?["div",{},["span",e,"Readonly"],"<",a(t),">"]:null:null},hasBody:function(e){return e&&e.__isVue},body:function(e){if(e&&e.__isVue)return["div",{}].concat(u(function(e){var t=[];e.type.props&&e.props&&t.push(i("props",So(e.props)));e.setupState!==Kn&&t.push(i("setup",e.setupState));e.data!==Kn&&t.push(i("data",So(e.data)));var n=s(e,"computed");n&&t.push(i("computed",n));var o=s(e,"inject");o&&t.push(i("injected",o));return t.push(["div",{},["span",{style:r.style+";opacity:0.66"},"$ (internal): "],["object",{object:e}]]),t}(e.$)))}};window.devtoolsFormatters?window.devtoolsFormatters.push(o):window.devtoolsFormatters=[o]}function i(e,t){return t=Zn({},t),Object.keys(t).length?["div",{style:"line-height:1.25em;margin-bottom:0.6em"},["div",{style:"color:#476582"},e],["div",{style:"padding-left:1.25em"}].concat(u(Object.keys(t).map((function(e){return["div",{},["span",r,e+": "],a(t[e],!1)]}))))]:["span",{}]}function a(e){var o=!(arguments.length>1&&void 0!==arguments[1])||arguments[1];return"number"==typeof e?["span",t,e]:"string"==typeof e?["span",n,JSON.stringify(e)]:"boolean"==typeof e?["span",r,e]:cr(e)?["object",{object:o?So(e):e}]:["span",n,String(e)]}function s(e,t){var n=e.type;if(!ir(n)){var r={};for(var o in e.ctx)c(n,o,t)&&(r[o]=e.ctx[o]);return r}}function c(e,t,n){var r=e[n];return!!(nr(r)&&r.includes(t)||cr(r)&&t in r)||(!(!e.extends||!c(e.extends,t,n))||(!(!e.mixins||!e.mixins.some((function(e){return c(e,t,n)})))||void 0))}function l(e){return e._shallow?"ShallowRef":e.effect?"ComputedRef":"Ref"}}var Li,Hi,Bi="http://www.w3.org/2000/svg",Wi="undefined"!=typeof document?document:null,qi={insert:function(e,t,n){t.insertBefore(e,n||null)},remove:function(e){var t=e.parentNode;t&&t.removeChild(e)},createElement:function(e,t,n){return t?Wi.createElementNS(Bi,e):Wi.createElement(e,n?{is:n}:void 0)},createText:function(e){return Wi.createTextNode(e)},createComment:function(e){return Wi.createComment(e)},setText:function(e,t){e.nodeValue=t},setElementText:function(e,t){e.textContent=t},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},querySelector:function(e){return Wi.querySelector(e)},setScopeId:function(e,t){e.setAttribute(t,"")},cloneNode:function(e){return e.cloneNode(!0)},insertStaticContent:function(e,t,n,r){var o=r?Hi||(Hi=Wi.createElementNS(Bi,"svg")):Li||(Li=Wi.createElement("div"));o.innerHTML=e;for(var i=o.firstChild,a=i,s=a;a;)s=a,qi.insert(a,t,n),a=o.firstChild;return[i,s]}};function Ki(e,t,n){if(null==t&&(t=""),n)e.setAttribute("class",t);else{var r=e._vtc;r&&(t=(t?[t].concat(u(r)):u(r)).join(" ")),e.className=t}}function Ji(e,t,n){var r=e.style;if(n)if(ar(n))t!==n&&(r.cssText=n);else{for(var o in n)Xi(r,o,n[o]);if(t&&!ar(t))for(var i in t)null==n[i]&&Xi(r,i,"")}else e.removeAttribute("style")}var Gi=/\s*!important$/;function Xi(e,t,n){if(nr(n))n.forEach((function(n){return Xi(e,t,n)}));else if(t.startsWith("--"))e.setProperty(t,n);else{var r=function(e,t){var n=Zi[t];if(n)return n;var r=hr(t);if("filter"!==r&&r in e)return Zi[t]=r;r=mr(r);for(var o=0;o: ")+"value ".concat(n," is invalid."),r)}}else{e._value=n;var u=null==n?"":n;e.value!==u&&(e.value=u)}}var na=Date.now;"undefined"!=typeof document&&na()>document.createEvent("Event").timeStamp&&(na=function(){return performance.now()});var ra=0,oa=Promise.resolve(),ia=function(){ra=0};function aa(e,t,n,r){e.addEventListener(t,n,r)}function sa(e,t,n,r){e.removeEventListener(t,n,r)}function ca(e,t,n,r){var o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null,i=e._vei||(e._vei={}),a=i[t];if(r&&a)a.value=r;else{var s=la(t),u=c(s,2),l=u[0],f=u[1];if(r){var d=i[t]=fa(r,o);aa(e,l,d,f)}else a&&(sa(e,l,a,f),i[t]=void 0)}}var ua=/(?:Once|Passive|Capture)$/;function la(e){var t,n;if(ua.test(e))for(t={};n=e.match(ua);)e=e.slice(0,e.length-n[0].length),t[n[0].toLowerCase()]=!0;return[e.slice(2).toLowerCase(),t]}function fa(e,t){var n=function e(n){(n.timeStamp||na())>=e.attached-1&&Io(function(e,t){if(nr(t)){var n=e.stopImmediatePropagation;return e.stopImmediatePropagation=function(){n.call(e),e._stopped=!0},t.map((function(e){return function(t){return!t._stopped&&e(t)}}))}return t}(n,e.value),t,5,[n])};return n.value=e,n.attached=ra||(oa.then(ia),ra=na()),n}var da=/^on[a-z]/;function pa(e,t,n,r){return r?"innerHTML"===t||!!(t in e&&da.test(t)&&ir(n)):"spellcheck"!==t&&"draggable"!==t&&(("form"!==t||"string"!=typeof n)&&(("list"!==t||"INPUT"!==e.tagName)&&((!da.test(t)||!ar(n))&&t in e)))}Zn({patchProp:function(e,t,n,r){var o=arguments.length>4&&void 0!==arguments[4]&&arguments[4],i=arguments.length>5?arguments[5]:void 0,a=arguments.length>6?arguments[6]:void 0,s=arguments.length>7?arguments[7]:void 0,c=arguments.length>8?arguments[8]:void 0;switch(t){case"class":Ki(e,r,o);break;case"style":Ji(e,n,r);break;default:Xn(t)?Yn(t)||ca(e,t,n,r,a):pa(e,t,r,o)?ta(e,t,r,i,a,s,c):("true-value"===t?e._trueValue=r:"false-value"===t&&(e._falseValue=r),ea(e,t,r,o))}},forcePatchProp:function(e,t){return"value"===t}},qi);"production"!==process.env.NODE_ENV&&function(){var e=Wn||(Wn="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof window?window:"undefined"!=typeof global?global:{});e.__VUE__=!0,e.__VUE_DEVTOOLS_GLOBAL_HOOK__,Fi()}();var va=function(){function e(t,n,r){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),this.el=t,this.observer=null,this.frozen=!1,this.createObserver(n,r)}var t,n,r;return t=e,(n=[{key:"createObserver",value:function(e,t){var n=this;if(this.observer&&this.destroyObserver(),!this.frozen){var r;if(this.options="function"==typeof(r=e)?{callback:r}:r,this.callback=function(e,t){n.options.callback(e,t),e&&n.options.once&&(n.frozen=!0,n.destroyObserver())},this.callback&&this.options.throttle){var o=(this.options.throttleOptions||{}).leading;this.callback=function(e,t){var n,r,o,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},a=function(a){for(var s=arguments.length,c=new Array(s>1?s-1:0),u=1;u1){var r=e.find((function(e){return e.isIntersecting}));r&&(t=r)}if(n.callback){var o=t.isIntersecting&&t.intersectionRatio>=n.threshold;if(o===n.oldResult)return;n.oldResult=o,n.callback(o,t)}}),this.options.intersection),Xo((function(){n.observer&&n.observer.observe(n.el)}))}}},{key:"destroyObserver",value:function(){this.observer&&(this.observer.disconnect(),this.observer=null),this.callback&&this.callback._clear&&(this.callback._clear(),this.callback=null)}},{key:"threshold",get:function(){return this.options.intersection&&this.options.intersection.threshold||0}}])&&Pn(t.prototype,n),r&&Pn(t,r),e}();function ha(e,t,n){var r=t.value;if(r)if("undefined"==typeof IntersectionObserver)console.warn("[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill");else{var o=new va(e,r,n);e._vue_visibilityState=o}}function ya(e){var t=e._vue_visibilityState;t&&(t.destroyObserver(),delete e._vue_visibilityState)}var ga={beforeMount:ha,updated:function(e,t,n){var r=t.value;if(!function e(t,n){if(t===n)return!0;if("object"===In(t)){for(var r in t)if(!e(t[r],n[r]))return!1;return!0}return!1}(r,t.oldValue)){var o=e._vue_visibilityState;r?o?o.createObserver(r,n):ha(e,{value:r},n):ya(e)}},unmounted:ya};var ma={version:"0.4.6",install:function(e){e.directive("observe-visibility",ga)}},_a=null;"undefined"!=typeof window?_a=window.Vue:"undefined"!=typeof global&&(_a=global.Vue),_a&&_a.use(ma);var ba="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};var wa=function(e,t){return e(t={exports:{}},t.exports),t.exports}((function(e){var t,n;t=ba,n=function(){var e=/(auto|scroll)/,t=function(e,n){return null===e.parentNode?n:t(e.parentNode,n.concat([e]))},n=function(e,t){return getComputedStyle(e,null).getPropertyValue(t)},r=function(t){return e.test(function(e){return n(e,"overflow")+n(e,"overflow-y")+n(e,"overflow-x")}(t))};return function(e){if(e instanceof HTMLElement||e instanceof SVGElement){for(var n=t(e.parentNode,[]),o=0;o1&&void 0!==arguments[1]&&arguments[1],n=this.$_unusedViews,r=e.nr.type,o=n.get(r);o||(o=[],n.set(r,o)),o.push(e),t||(e.nr.used=!1,e.position=-9999,this.$_views.delete(e.nr.key))},handleResize:function(){this.$emit("resize"),this.ready&&this.updateVisibleItems(!1)},handleScroll:function(e){var t=this;this.$_scrollDirty||(this.$_scrollDirty=!0,requestAnimationFrame((function(){t.$_scrollDirty=!1,t.updateVisibleItems(!1,!0).continuous||(clearTimeout(t.$_refreshTimout),t.$_refreshTimout=setTimeout(t.handleScroll,100))})))},handleVisibilityChange:function(e,t){var n=this;this.ready&&(e||0!==t.boundingClientRect.width||0!==t.boundingClientRect.height?(this.$emit("visible"),requestAnimationFrame((function(){n.updateVisibleItems(!1)}))):this.$emit("hidden"))},updateVisibleItems:function(e){var t,n,o,i,a=arguments.length>1&&void 0!==arguments[1]&&arguments[1],s=this.itemSize,c=this.$_computedMinItemSize,u=this.typeField,l=this.simpleArray?null:this.keyField,f=this.items,d=f.length,p=this.sizes,v=this.$_views,h=this.$_unusedViews,y=this.pool;if(d)if(this.$_prerender)t=0,n=this.prerender,o=null;else{var g=this.getScroll();if(a){var m=g.start-this.$_lastUpdateScrollPosition;if(m<0&&(m=-m),null===s&&mg.start&&(E=N),N=~~((w+E)/2)}while(N!==b);for(N<0&&(N=0),t=N,o=p[d-1].accumulator,n=N;nd&&(n=d)}else(t=~~(g.start/s))<0&&(t=0),(n=Math.ceil(g.end/s))>d&&(n=d),o=d*s}else t=n=o=0;n-t>r.itemsLimit&&this.itemsLimitError(),this.totalSize=o;var S=t<=this.$_endIndex&&n>=this.$_startIndex;if(this.$_continuous!==S){if(S){v.clear(),h.clear();for(var O=0,V=y.length;O=n)&&this.unuseView(i));for(var x,D,z,R,C=S?null:new Map,I=t;I=z.length)&&(i=this.addView(y,I,x,P,D),this.unuseView(i,!0),z=h.get(D)),(i=z[R]).item=x,i.nr.used=!0,i.nr.index=I,i.nr.key=P,i.nr.type=D,C.set(D,R+1),R++),v.set(P,i)),i.position=null===s?p[I-1].accumulator:I*s):i&&this.unuseView(i)}return this.$_startIndex=t,this.$_endIndex=n,this.emitUpdate&&this.$emit("update",t,n),clearTimeout(this.$_sortTimer),this.$_sortTimer=setTimeout(this.sortViews,300),{continuous:S}},getListenerTarget:function(){var e=wa(this.$el);return!window.document||e!==window.document.documentElement&&e!==window.document.body||(e=window),e},getScroll:function(){var e,t=this.$el,n="vertical"===this.direction;if(this.pageMode){var r=t.getBoundingClientRect(),o=n?r.height:r.width,i=-(n?r.top:r.left),a=n?window.innerHeight:window.innerWidth;i<0&&(a+=i,i=0),i+a>o&&(a=o-i),e={start:i,end:i+a}}else e=n?{start:t.scrollTop,end:t.scrollTop+t.clientHeight}:{start:t.scrollLeft,end:t.scrollLeft+t.clientWidth};return e},applyPageMode:function(){this.pageMode?this.addListeners():this.removeListeners()},addListeners:function(){this.listenerTarget=this.getListenerTarget(),this.listenerTarget.addEventListener("scroll",this.handleScroll,!!Sa&&{passive:!0}),this.listenerTarget.addEventListener("resize",this.handleResize)},removeListeners:function(){this.listenerTarget&&(this.listenerTarget.removeEventListener("scroll",this.handleScroll),this.listenerTarget.removeEventListener("resize",this.handleResize),this.listenerTarget=null)},scrollToItem:function(e){var t;t=null===this.itemSize?e>0?this.sizes[e-1].accumulator:0:e*this.itemSize,this.scrollToPosition(t)},scrollToPosition:function(e){"vertical"===this.direction?this.$el.scrollTop=e:this.$el.scrollLeft=e},itemsLimitError:function(){var e=this;throw setTimeout((function(){console.log("It seems the scroller element isn't scrolling, so it tries to render all the items at once.","Scroller:",e.$el),console.log("Make sure the scroller has a fixed height (or width) and 'overflow-y' (or 'overflow-x') set to 'auto' so it can scroll correctly and only render the items visible in the scroll viewport.")})),new Error("Rendered items limit reached")},sortViews:function(){this.pool.sort((function(e,t){return e.nr.index-t.nr.index}))}}},$a={key:0,class:"vue-recycle-scroller__slot"},xa={key:1,class:"vue-recycle-scroller__slot"};ka.render=function(e,n,r,o,a,s){var c=t.resolveComponent("ResizeObserver"),u=t.resolveDirective("observe-visibility");return t.withDirectives((t.openBlock(),t.createBlock("div",{class:["vue-recycle-scroller",i({ready:a.ready,"page-mode":r.pageMode},"direction-".concat(e.direction),!0)],onScrollPassive:n[2]||(n[2]=function(){return s.handleScroll&&s.handleScroll.apply(s,arguments)})},[e.$slots.before?(t.openBlock(),t.createBlock("div",$a,[t.renderSlot(e.$slots,"before")])):t.createCommentVNode("v-if",!0),t.createVNode("div",{ref:"wrapper",style:i({},"vertical"===e.direction?"minHeight":"minWidth",a.totalSize+"px"),class:"vue-recycle-scroller__item-wrapper"},[(t.openBlock(!0),t.createBlock(t.Fragment,null,t.renderList(a.pool,(function(r){return t.openBlock(),t.createBlock("div",{key:r.nr.id,style:a.ready?{transform:"translate".concat("vertical"===e.direction?"Y":"X","(").concat(r.position,"px)")}:null,class:["vue-recycle-scroller__item-view",{hover:a.hoverKey===r.nr.key}],onMouseenter:function(e){return a.hoverKey=r.nr.key},onMouseleave:n[1]||(n[1]=function(e){return a.hoverKey=null})},[t.renderSlot(e.$slots,"default",{item:r.item,index:r.nr.index,active:r.nr.used})],46,["onMouseenter"])})),128))],4),e.$slots.after?(t.openBlock(),t.createBlock("div",xa,[t.renderSlot(e.$slots,"after")])):t.createCommentVNode("v-if",!0),t.createVNode(c,{onNotify:s.handleResize},null,8,["onNotify"])],34)),[[u,s.handleVisibilityChange]])},ka.__file="src/components/RecycleScroller.vue";var Da={name:"DynamicScroller",components:{RecycleScroller:ka},inheritAttrs:!1,provide:function(){return"undefined"!=typeof ResizeObserver&&(this.$_resizeObserver=new ResizeObserver((function(e){var t,n=function(e){if("undefined"==typeof Symbol||null==e[Symbol.iterator]){if(Array.isArray(e)||(e=l(e))){var t=0,n=function(){};return{s:n,n:function(){return t>=e.length?{done:!0}:{done:!1,value:e[t++]}},e:function(e){throw e},f:n}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var r,o,i=!0,a=!1;return{s:function(){r=e[Symbol.iterator]()},n:function(){var e=r.next();return i=e.done,e},e:function(e){a=!0,o=e},f:function(){try{i||null==r.return||r.return()}finally{if(a)throw o}}}}(e);try{for(n.s();!(t=n.n()).done;){var r=t.value;if(r.target){var o=new CustomEvent("resize",{detail:{contentRect:r.contentRect}});r.target.dispatchEvent(o)}}}catch(e){n.e(e)}finally{n.f()}}))),{vscrollData:this.vscrollData,vscrollParent:this,vscrollResizeObserver:this.$_resizeObserver}},props:s({},Ea,{minItemSize:{type:[Number,String],required:!0}}),data:function(){return{vscrollData:{active:!0,sizes:{},validSizes:{},keyField:this.keyField,simpleArray:!1}}},computed:{simpleArray:Na,itemsWithSize:function(){for(var e=[],t=this.items,n=this.keyField,r=this.simpleArray,o=this.vscrollData.sizes,i=0;i0&&void 0!==arguments[0])||arguments[0];(e||this.simpleArray)&&(this.vscrollData.validSizes={}),this.$emit("vscroll:update",{force:!0})},scrollToItem:function(e){var t=this.$refs.scroller;t&&t.scrollToItem(e)},getItemSize:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:void 0,n=this.simpleArray?null!=t?t:this.items.indexOf(e):e[this.keyField];return this.vscrollData.sizes[n]||0},scrollToBottom:function(){var e=this;if(!this.$_scrollingToBottom){this.$_scrollingToBottom=!0;var t=this.$el;this.$nextTick((function(){t.scrollTop=t.scrollHeight+5e3;requestAnimationFrame((function n(){t.scrollTop=t.scrollHeight+5e3,requestAnimationFrame((function(){t.scrollTop=t.scrollHeight+5e3,0===e.$_undefinedSizes?e.$_scrollingToBottom=!1:requestAnimationFrame(n)}))}))}))}}}},za={"slot-scope":"{ item: itemWithSize, index, active }"},Ra={slot:"before"},Ca={slot:"after"};Da.render=function(e,n,r,o,i,a){var s=t.resolveComponent("RecycleScroller");return t.openBlock(),t.createBlock(s,t.mergeProps({ref:"scroller",items:a.itemsWithSize,"min-item-size":r.minItemSize,direction:e.direction,"key-field":"id"},e.$attrs,{onResize:a.onScrollerResize,onVisible:a.onScrollerVisible},t.toHandlers(a.listeners)),{default:t.withCtx((function(){return[t.createVNode("template",za,[t.renderSlot(e.$slots,"default",{item:e.itemWithSize.item,index:e.index,active:e.active,itemWithSize:e.itemWithSize})]),t.createVNode("template",Ra,[t.renderSlot(e.$slots,"before")]),t.createVNode("template",Ca,[t.renderSlot(e.$slots,"after")])]})),_:3},16,["items","min-item-size","direction","onResize","onVisible"])},Da.__file="src/components/DynamicScroller.vue";var Ia={name:"DynamicScrollerItem",inject:["vscrollData","vscrollParent","vscrollResizeObserver"],props:{item:{required:!0},watchData:{type:Boolean,default:!1},active:{type:Boolean,required:!0},index:{type:Number,default:void 0},sizeDependencies:{type:[Array,Object],default:null},emitResize:{type:Boolean,default:!1},tag:{type:String,default:"div"}},computed:{id:function(){return this.vscrollData.simpleArray?this.index:this.item[this.vscrollData.keyField]},size:function(){return this.vscrollData.validSizes[this.id]&&this.vscrollData.sizes[this.id]||0},finalActive:function(){return this.active&&this.vscrollData.active}},watch:{watchData:"updateWatchData",id:function(){this.size||this.onDataUpdate()},finalActive:function(e){this.size||(e?this.vscrollParent.$_undefinedMap[this.id]||(this.vscrollParent.$_undefinedSizes++,this.vscrollParent.$_undefinedMap[this.id]=!0):this.vscrollParent.$_undefinedMap[this.id]&&(this.vscrollParent.$_undefinedSizes--,this.vscrollParent.$_undefinedMap[this.id]=!1)),this.vscrollResizeObserver?e?this.observeSize():this.unobserveSize():e&&this.$_pendingVScrollUpdate===this.id&&this.updateSize()}},created:function(){var e=this;if(!this.$isServer&&(this.$_forceNextVScrollUpdate=null,this.updateWatchData(),!this.vscrollResizeObserver)){var t=function(t){e.$watch((function(){return e.sizeDependencies[t]}),e.onDataUpdate)};for(var n in this.sizeDependencies)t(n);this.vscrollParent.$on("vscroll:update",this.onVscrollUpdate),this.vscrollParent.$on("vscroll:update-size",this.onVscrollUpdateSize)}},mounted:function(){this.vscrollData.active&&(this.updateSize(),this.observeSize())},beforeUnmount:function(){this.vscrollParent.$off("vscroll:update",this.onVscrollUpdate),this.vscrollParent.$off("vscroll:update-size",this.onVscrollUpdateSize),this.unobserveSize()},methods:{updateSize:function(){this.finalActive?this.$_pendingSizeUpdate!==this.id&&(this.$_pendingSizeUpdate=this.id,this.$_forceNextVScrollUpdate=null,this.$_pendingVScrollUpdate=null,this.computeSize(this.id)):this.$_forceNextVScrollUpdate=this.id},updateWatchData:function(){var e=this;this.watchData?this.$_watchData=this.$watch("data",(function(){e.onDataUpdate()}),{deep:!0}):this.$_watchData&&(this.$_watchData(),this.$_watchData=null)},onVscrollUpdate:function(e){var t=e.force;!this.finalActive&&t&&(this.$_pendingVScrollUpdate=this.id),this.$_forceNextVScrollUpdate!==this.id&&!t&&this.size||this.updateSize()},onDataUpdate:function(){this.updateSize()},computeSize:function(e){var t=this;this.$nextTick((function(){if(t.id===e){var n=t.$el.offsetWidth,r=t.$el.offsetHeight;t.applySize(n,r)}t.$_pendingSizeUpdate=null}))},applySize:function(e,t){var n=Math.round("vertical"===this.vscrollParent.direction?t:e);n&&this.size!==n&&(this.vscrollParent.$_undefinedMap[this.id]&&(this.vscrollParent.$_undefinedSizes--,this.vscrollParent.$_undefinedMap[this.id]=void 0),this.$set(this.vscrollData.sizes,this.id,n),this.$set(this.vscrollData.validSizes,this.id,!0),this.emitResize&&this.$emit("resize",this.id))},observeSize:function(){this.vscrollResizeObserver&&(this.vscrollResizeObserver.observe(this.$el.parentNode),this.$el.parentNode.addEventListener("resize",this.onResize))},unobserveSize:function(){this.vscrollResizeObserver&&(this.vscrollResizeObserver.unobserve(this.$el.parentNode),this.$el.parentNode.removeEventListener("resize",this.onResize))},onResize:function(e){var t=e.detail.contentRect,n=t.width,r=t.height;this.applySize(n,r)}},render:function(e){return console.log("render",e),e(this.tag,this.$slots.default)}};Ia.__file="src/components/DynamicScrollerItem.vue";var Pa={version:"1.0.10",install:function(e,t){var n=Object.assign({},{installComponents:!0,componentsPrefix:""},t);for(var o in n)void 0!==n[o]&&(r[o]=n[o]);n.installComponents&&function(e,t){e.component("".concat(t,"recycle-scroller"),ka),e.component("".concat(t,"RecycleScroller"),ka),e.component("".concat(t,"dynamic-scroller"),Da),e.component("".concat(t,"DynamicScroller"),Da),e.component("".concat(t,"dynamic-scroller-item"),Ia),e.component("".concat(t,"DynamicScrollerItem"),Ia)}(e,n.componentsPrefix)}},Aa=null;return"undefined"!=typeof window?Aa=window.Vue:"undefined"!=typeof global&&(Aa=global.Vue),Aa&&Aa.use(Pa),e.DynamicScroller=Da,e.DynamicScrollerItem=Ia,e.IdState=function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=e.idProp,r=void 0===n?function(e){return e.item.id}:n,o=t.reactive({});return{data:function(){return{idState:null}},created:function(){var e=this;this.$_id=null,this.$_getId="function"==typeof r?function(){return r.call(e,e)}:function(){return e[r]},this.$watch(this.$_getId,{handler:function(e){var t=this;this.$nextTick((function(){t.$_id=e}))},immediate:!0}),this.$_updateIdState()},beforeUpdate:function(){this.$_updateIdState()},methods:{$_idStateInit:function(e){var t=this.$options.idState;if("function"==typeof t){var n=t.call(this,this);return o[e]=n,this.$_id=e,n}throw new Error("[mixin IdState] Missing `idState` function on component definition.")},$_updateIdState:function(){var e=this.$_getId();null==e&&console.warn("No id found for IdState with idProp: '".concat(r,"'.")),e!==this.$_id&&(o[e]||this.$_idStateInit(e),this.idState=o[e])}}}},e.RecycleScroller=ka,e.default=Pa,e}({},vue); //# sourceMappingURL=vue-virtual-scroller.min.js.map diff --git a/dist/vue-virtual-scroller.min.js.map b/dist/vue-virtual-scroller.min.js.map index 9060c89b..f3693c43 100644 --- a/dist/vue-virtual-scroller.min.js.map +++ b/dist/vue-virtual-scroller.min.js.map @@ -1 +1 @@ -{"version":3,"file":"vue-virtual-scroller.min.js","sources":["../src/config.js","../node_modules/vue-resize/dist/vue-resize.esm.js","../node_modules/vue-observe-visibility/dist/vue-observe-visibility.esm.js","../node_modules/scrollparent/scrollparent.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../node_modules/vue-runtime-helpers/dist/normalize-component.mjs","../src/components/DynamicScroller.vue","../src/components/DynamicScrollerItem.vue","../src/index.js","../src/mixins/IdState.js"],"sourcesContent":["export default {\n itemsLimit: 1000,\n}\n","function getInternetExplorerVersion() {\n\tvar ua = window.navigator.userAgent;\n\n\tvar msie = ua.indexOf('MSIE ');\n\tif (msie > 0) {\n\t\t// IE 10 or older => return version number\n\t\treturn parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);\n\t}\n\n\tvar trident = ua.indexOf('Trident/');\n\tif (trident > 0) {\n\t\t// IE 11 => return version number\n\t\tvar rv = ua.indexOf('rv:');\n\t\treturn parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);\n\t}\n\n\tvar edge = ua.indexOf('Edge/');\n\tif (edge > 0) {\n\t\t// Edge (IE 12+) => return version number\n\t\treturn parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);\n\t}\n\n\t// other browser\n\treturn -1;\n}\n\nvar isIE = void 0;\n\nfunction initCompat() {\n\tif (!initCompat.init) {\n\t\tinitCompat.init = true;\n\t\tisIE = getInternetExplorerVersion() !== -1;\n\t}\n}\n\nvar ResizeObserver = { render: function render() {\n\t\tvar _vm = this;var _h = _vm.$createElement;var _c = _vm._self._c || _h;return _c('div', { staticClass: \"resize-observer\", attrs: { \"tabindex\": \"-1\" } });\n\t}, staticRenderFns: [], _scopeId: 'data-v-b329ee4c',\n\tname: 'resize-observer',\n\n\tmethods: {\n\t\tcompareAndNotify: function compareAndNotify() {\n\t\t\tif (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) {\n\t\t\t\tthis._w = this.$el.offsetWidth;\n\t\t\t\tthis._h = this.$el.offsetHeight;\n\t\t\t\tthis.$emit('notify');\n\t\t\t}\n\t\t},\n\t\taddResizeHandlers: function addResizeHandlers() {\n\t\t\tthis._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify);\n\t\t\tthis.compareAndNotify();\n\t\t},\n\t\tremoveResizeHandlers: function removeResizeHandlers() {\n\t\t\tif (this._resizeObject && this._resizeObject.onload) {\n\t\t\t\tif (!isIE && this._resizeObject.contentDocument) {\n\t\t\t\t\tthis._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify);\n\t\t\t\t}\n\t\t\t\tdelete this._resizeObject.onload;\n\t\t\t}\n\t\t}\n\t},\n\n\tmounted: function mounted() {\n\t\tvar _this = this;\n\n\t\tinitCompat();\n\t\tthis.$nextTick(function () {\n\t\t\t_this._w = _this.$el.offsetWidth;\n\t\t\t_this._h = _this.$el.offsetHeight;\n\t\t});\n\t\tvar object = document.createElement('object');\n\t\tthis._resizeObject = object;\n\t\tobject.setAttribute('aria-hidden', 'true');\n\t\tobject.setAttribute('tabindex', -1);\n\t\tobject.onload = this.addResizeHandlers;\n\t\tobject.type = 'text/html';\n\t\tif (isIE) {\n\t\t\tthis.$el.appendChild(object);\n\t\t}\n\t\tobject.data = 'about:blank';\n\t\tif (!isIE) {\n\t\t\tthis.$el.appendChild(object);\n\t\t}\n\t},\n\tbeforeDestroy: function beforeDestroy() {\n\t\tthis.removeResizeHandlers();\n\t}\n};\n\n// Install the components\nfunction install(Vue) {\n\tVue.component('resize-observer', ResizeObserver);\n\tVue.component('ResizeObserver', ResizeObserver);\n}\n\n// Plugin\nvar plugin = {\n\t// eslint-disable-next-line no-undef\n\tversion: \"0.4.5\",\n\tinstall: install\n};\n\n// Auto-install\nvar GlobalVue = null;\nif (typeof window !== 'undefined') {\n\tGlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n\tGlobalVue = global.Vue;\n}\nif (GlobalVue) {\n\tGlobalVue.use(plugin);\n}\n\nexport { install, ResizeObserver };\nexport default plugin;\n","function _typeof(obj) {\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n}\n\nfunction _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n return arr2;\n }\n}\n\nfunction _iterableToArray(iter) {\n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\nfunction processOptions(value) {\n var options;\n\n if (typeof value === 'function') {\n // Simple options (callback-only)\n options = {\n callback: value\n };\n } else {\n // Options object\n options = value;\n }\n\n return options;\n}\nfunction throttle(callback, delay) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var timeout;\n var lastState;\n var currentArgs;\n\n var throttled = function throttled(state) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n currentArgs = args;\n if (timeout && state === lastState) return;\n var leading = options.leading;\n\n if (typeof leading === 'function') {\n leading = leading(state, lastState);\n }\n\n if ((!timeout || state !== lastState) && leading) {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n }\n\n lastState = state;\n clearTimeout(timeout);\n timeout = setTimeout(function () {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n timeout = 0;\n }, delay);\n };\n\n throttled._clear = function () {\n clearTimeout(timeout);\n timeout = null;\n };\n\n return throttled;\n}\nfunction deepEqual(val1, val2) {\n if (val1 === val2) return true;\n\n if (_typeof(val1) === 'object') {\n for (var key in val1) {\n if (!deepEqual(val1[key], val2[key])) {\n return false;\n }\n }\n\n return true;\n }\n\n return false;\n}\n\nvar VisibilityState =\n/*#__PURE__*/\nfunction () {\n function VisibilityState(el, options, vnode) {\n _classCallCheck(this, VisibilityState);\n\n this.el = el;\n this.observer = null;\n this.frozen = false;\n this.createObserver(options, vnode);\n }\n\n _createClass(VisibilityState, [{\n key: \"createObserver\",\n value: function createObserver(options, vnode) {\n var _this = this;\n\n if (this.observer) {\n this.destroyObserver();\n }\n\n if (this.frozen) return;\n this.options = processOptions(options);\n\n this.callback = function (result, entry) {\n _this.options.callback(result, entry);\n\n if (result && _this.options.once) {\n _this.frozen = true;\n\n _this.destroyObserver();\n }\n }; // Throttle\n\n\n if (this.callback && this.options.throttle) {\n var _ref = this.options.throttleOptions || {},\n _leading = _ref.leading;\n\n this.callback = throttle(this.callback, this.options.throttle, {\n leading: function leading(state) {\n return _leading === 'both' || _leading === 'visible' && state || _leading === 'hidden' && !state;\n }\n });\n }\n\n this.oldResult = undefined;\n this.observer = new IntersectionObserver(function (entries) {\n var entry = entries[0];\n\n if (entries.length > 1) {\n var intersectingEntry = entries.find(function (e) {\n return e.isIntersecting;\n });\n\n if (intersectingEntry) {\n entry = intersectingEntry;\n }\n }\n\n if (_this.callback) {\n // Use isIntersecting if possible because browsers can report isIntersecting as true, but intersectionRatio as 0, when something very slowly enters the viewport.\n var result = entry.isIntersecting && entry.intersectionRatio >= _this.threshold;\n if (result === _this.oldResult) return;\n _this.oldResult = result;\n\n _this.callback(result, entry);\n }\n }, this.options.intersection); // Wait for the element to be in document\n\n vnode.context.$nextTick(function () {\n if (_this.observer) {\n _this.observer.observe(_this.el);\n }\n });\n }\n }, {\n key: \"destroyObserver\",\n value: function destroyObserver() {\n if (this.observer) {\n this.observer.disconnect();\n this.observer = null;\n } // Cancel throttled call\n\n\n if (this.callback && this.callback._clear) {\n this.callback._clear();\n\n this.callback = null;\n }\n }\n }, {\n key: \"threshold\",\n get: function get() {\n return this.options.intersection && this.options.intersection.threshold || 0;\n }\n }]);\n\n return VisibilityState;\n}();\n\nfunction bind(el, _ref2, vnode) {\n var value = _ref2.value;\n if (!value) return;\n\n if (typeof IntersectionObserver === 'undefined') {\n console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');\n } else {\n var state = new VisibilityState(el, value, vnode);\n el._vue_visibilityState = state;\n }\n}\n\nfunction update(el, _ref3, vnode) {\n var value = _ref3.value,\n oldValue = _ref3.oldValue;\n if (deepEqual(value, oldValue)) return;\n var state = el._vue_visibilityState;\n\n if (!value) {\n unbind(el);\n return;\n }\n\n if (state) {\n state.createObserver(value, vnode);\n } else {\n bind(el, {\n value: value\n }, vnode);\n }\n}\n\nfunction unbind(el) {\n var state = el._vue_visibilityState;\n\n if (state) {\n state.destroyObserver();\n delete el._vue_visibilityState;\n }\n}\n\nvar ObserveVisibility = {\n bind: bind,\n update: update,\n unbind: unbind\n};\n\nfunction install(Vue) {\n Vue.directive('observe-visibility', ObserveVisibility);\n /* -- Add more components here -- */\n}\n/* -- Plugin definition & Auto-install -- */\n\n/* You shouldn't have to modify the code below */\n// Plugin\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.4.6\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { ObserveVisibility, install };\n","(function (root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define([], factory);\n } else if (typeof module === \"object\" && module.exports) {\n module.exports = factory();\n } else {\n root.Scrollparent = factory();\n }\n}(this, function () {\n var regex = /(auto|scroll)/;\n\n var parents = function (node, ps) {\n if (node.parentNode === null) { return ps; }\n\n return parents(node.parentNode, ps.concat([node]));\n };\n\n var style = function (node, prop) {\n return getComputedStyle(node, null).getPropertyValue(prop);\n };\n\n var overflow = function (node) {\n return style(node, \"overflow\") + style(node, \"overflow-y\") + style(node, \"overflow-x\");\n };\n\n var scroll = function (node) {\n return regex.test(overflow(node));\n };\n\n var scrollParent = function (node) {\n if (!(node instanceof HTMLElement || node instanceof SVGElement)) {\n return ;\n }\n\n var ps = parents(node.parentNode, []);\n\n for (var i = 0; i < ps.length; i += 1) {\n if (scroll(ps[i])) {\n return ps[i];\n }\n }\n\n return document.scrollingElement || document.documentElement;\n };\n\n return scrollParent;\n}));\n","export const props = {\n items: {\n type: Array,\n required: true,\n },\n\n keyField: {\n type: String,\n default: 'id',\n },\n\n direction: {\n type: String,\n default: 'vertical',\n validator: (value) => ['vertical', 'horizontal'].includes(value),\n },\n}\n\nexport function simpleArray () {\n return this.items.length && typeof this.items[0] !== 'object'\n}\n","export let supportsPassive = false\n\nif (typeof window !== 'undefined') {\n supportsPassive = false\n try {\n var opts = Object.defineProperty({}, 'passive', {\n get () {\n supportsPassive = true\n },\n })\n window.addEventListener('test', null, opts)\n } catch (e) {}\n}\n","\n\n\n\n\n","function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {\r\n if (typeof shadowMode !== 'boolean') {\r\n createInjectorSSR = createInjector;\r\n createInjector = shadowMode;\r\n shadowMode = false;\r\n }\r\n // Vue.extend constructor export interop.\r\n const options = typeof script === 'function' ? script.options : script;\r\n // render functions\r\n if (template && template.render) {\r\n options.render = template.render;\r\n options.staticRenderFns = template.staticRenderFns;\r\n options._compiled = true;\r\n // functional template\r\n if (isFunctionalTemplate) {\r\n options.functional = true;\r\n }\r\n }\r\n // scopedId\r\n if (scopeId) {\r\n options._scopeId = scopeId;\r\n }\r\n let hook;\r\n if (moduleIdentifier) {\r\n // server build\r\n hook = function (context) {\r\n // 2.3 injection\r\n context =\r\n context || // cached call\r\n (this.$vnode && this.$vnode.ssrContext) || // stateful\r\n (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext); // functional\r\n // 2.2 with runInNewContext: true\r\n if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\r\n context = __VUE_SSR_CONTEXT__;\r\n }\r\n // inject component styles\r\n if (style) {\r\n style.call(this, createInjectorSSR(context));\r\n }\r\n // register component module identifier for async chunk inference\r\n if (context && context._registeredComponents) {\r\n context._registeredComponents.add(moduleIdentifier);\r\n }\r\n };\r\n // used by ssr in case component is cached and beforeCreate\r\n // never gets called\r\n options._ssrRegister = hook;\r\n }\r\n else if (style) {\r\n hook = shadowMode\r\n ? function (context) {\r\n style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot));\r\n }\r\n : function (context) {\r\n style.call(this, createInjector(context));\r\n };\r\n }\r\n if (hook) {\r\n if (options.functional) {\r\n // register for functional component in vue file\r\n const originalRender = options.render;\r\n options.render = function renderWithStyleInjection(h, context) {\r\n hook.call(context);\r\n return originalRender(h, context);\r\n };\r\n }\r\n else {\r\n // inject component registration as beforeCreate hook\r\n const existing = options.beforeCreate;\r\n options.beforeCreate = existing ? [].concat(existing, hook) : [hook];\r\n }\r\n }\r\n return script;\r\n}\n\nexport default normalizeComponent;\n//# sourceMappingURL=normalize-component.mjs.map\n","\n\n\n","\n","import config from './config'\n\nimport RecycleScroller from './components/RecycleScroller.vue'\nimport DynamicScroller from './components/DynamicScroller.vue'\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\n\nexport { default as IdState } from './mixins/IdState'\n\nexport {\n RecycleScroller,\n DynamicScroller,\n DynamicScrollerItem,\n}\n\nfunction registerComponents (Vue, prefix) {\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\n}\n\nconst plugin = {\n // eslint-disable-next-line no-undef\n version: VERSION,\n install (Vue, options) {\n const finalOptions = Object.assign({}, {\n installComponents: true,\n componentsPrefix: '',\n }, options)\n\n for (const key in finalOptions) {\n if (typeof finalOptions[key] !== 'undefined') {\n config[key] = finalOptions[key]\n }\n }\n\n if (finalOptions.installComponents) {\n registerComponents(Vue, finalOptions.componentsPrefix)\n }\n },\n}\n\nexport default plugin\n\n// Auto-install\nlet GlobalVue = null\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue\n}\nif (GlobalVue) {\n GlobalVue.use(plugin)\n}\n","import Vue from 'vue'\n\nexport default function ({\n idProp = vm => vm.item.id,\n} = {}) {\n const store = {}\n const vm = new Vue({\n data () {\n return {\n store,\n }\n },\n })\n\n // @vue/component\n return {\n data () {\n return {\n idState: null,\n }\n },\n\n created () {\n this.$_id = null\n if (typeof idProp === 'function') {\n this.$_getId = () => idProp.call(this, this)\n } else {\n this.$_getId = () => this[idProp]\n }\n this.$watch(this.$_getId, {\n handler (value) {\n this.$nextTick(() => {\n this.$_id = value\n })\n },\n immediate: true,\n })\n this.$_updateIdState()\n },\n\n beforeUpdate () {\n this.$_updateIdState()\n },\n\n methods: {\n /**\n * Initialize an idState\n * @param {number|string} id Unique id for the data\n */\n $_idStateInit (id) {\n const factory = this.$options.idState\n if (typeof factory === 'function') {\n const data = factory.call(this, this)\n vm.$set(store, id, data)\n this.$_id = id\n return data\n } else {\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\n }\n },\n\n /**\n * Ensure idState is created and up-to-date\n */\n $_updateIdState () {\n const id = this.$_getId()\n if (id == null) {\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\n }\n if (id !== this.$_id) {\n if (!store[id]) {\n this.$_idStateInit(id)\n }\n this.idState = store[id]\n }\n },\n },\n }\n}\n"],"names":["itemsLimit","isIE","initCompat","init","ua","window","navigator","userAgent","msie","indexOf","parseInt","substring","rv","edge","getInternetExplorerVersion","ResizeObserver","render","_h","this","$createElement","_self","_c","staticClass","attrs","tabindex","staticRenderFns","_scopeId","name","methods","compareAndNotify","_w","$el","offsetWidth","offsetHeight","$emit","addResizeHandlers","_resizeObject","contentDocument","defaultView","addEventListener","removeResizeHandlers","onload","removeEventListener","mounted","_this","$nextTick","object","document","createElement","setAttribute","type","appendChild","data","beforeDestroy","plugin","version","install","Vue","component","GlobalVue","_typeof","obj","Symbol","iterator","constructor","prototype","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_toConsumableArray","arr","Array","isArray","arr2","_arrayWithoutHoles","iter","toString","call","from","_iterableToArray","TypeError","_nonIterableSpread","global","use","VisibilityState","el","options","vnode","instance","Constructor","_classCallCheck","observer","frozen","createObserver","protoProps","staticProps","value","destroyObserver","callback","result","entry","once","throttle","_leading","throttleOptions","leading","delay","timeout","lastState","currentArgs","arguments","undefined","throttled","state","_len","args","_key","apply","concat","clearTimeout","setTimeout","_clear","oldResult","IntersectionObserver","entries","intersectingEntry","find","e","isIntersecting","intersectionRatio","threshold","intersection","context","observe","disconnect","get","bind","_ref2","console","warn","_vue_visibilityState","unbind","ObserveVisibility","update","_ref3","deepEqual","val1","val2","oldValue","directive","root","factory","regex","parents","node","ps","parentNode","style","prop","getComputedStyle","getPropertyValue","scroll","test","overflow","HTMLElement","SVGElement","scrollingElement","documentElement","module","exports","Scrollparent","items","required","keyField","String","default","direction","validator","includes","simpleArray","supportsPassive","opts","normalizeComponent","template","script","scopeId","isFunctionalTemplate","moduleIdentifier","shadowMode","createInjector","createInjectorSSR","createInjectorShadow","hook","_compiled","functional","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","originalRender","h","existing","beforeCreate","VERSION","finalOptions","assign","installComponents","componentsPrefix","config","prefix","RecycleScroller","DynamicScroller","DynamicScrollerItem","registerComponents","idProp","vm","item","id","store","idState","created","$_id","$_getId","$watch","handler","_this2","immediate","$_updateIdState","beforeUpdate","$_idStateInit","$set","Error"],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"vue-virtual-scroller.min.js","sources":["../src/config.js","../../vue-resize/dist/vue-resize.esm.js","../../vue-observe-visibility/dist/vue-observe-visibility.esm.js","../node_modules/scrollparent/scrollparent.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../src/components/RecycleScroller.vue?vue&type=template&id=093a936d&lang.js","../src/components/DynamicScroller.vue","../src/components/DynamicScroller.vue?vue&type=template&id=76e15f19&lang.js","../src/components/DynamicScrollerItem.vue","../src/index.js","../src/mixins/IdState.js"],"sourcesContent":["export default {\r\n itemsLimit: 1000,\r\n}\r\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction setCurrentRenderingInstance(instance) {\r\n currentRenderingInstance = instance;\r\n}\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n/**\r\n * Wrap a slot function to memoize current rendering instance\r\n * @private\r\n */\r\nfunction withCtx(fn, ctx = currentRenderingInstance) {\r\n if (!ctx)\r\n return fn;\r\n const renderFnWithContext = (...args) => {\r\n // If a user calls a compiled slot inside a template expression (#1745), it\r\n // can mess up block tracking, so by default we need to push a null block to\r\n // avoid that. This isn't necessary if rendering a compiled ``.\r\n if (!isRenderingCompiledSlot) {\r\n openBlock(true /* null block that disables tracking */);\r\n }\r\n const owner = currentRenderingInstance;\r\n setCurrentRenderingInstance(ctx);\r\n const res = fn(...args);\r\n setCurrentRenderingInstance(owner);\r\n if (!isRenderingCompiledSlot) {\r\n closeBlock();\r\n }\r\n return res;\r\n };\r\n renderFnWithContext._c = true;\r\n return renderFnWithContext;\r\n}\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\nconst scopeIdStack = [];\r\n/**\r\n * @private\r\n */\r\nfunction pushScopeId(id) {\r\n scopeIdStack.push((currentScopeId = id));\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction popScopeId() {\r\n scopeIdStack.pop();\r\n currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null;\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction withScopeId(id) {\r\n return ((fn) => withCtx(function () {\r\n pushScopeId(id);\r\n const res = fn.apply(this, arguments);\r\n popScopeId();\r\n return res;\r\n }));\r\n}\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\n// Since v-if and v-for are the two possible ways node structure can dynamically\r\n// change, once we consider v-if branches and each v-for fragment a block, we\r\n// can divide a template into nested blocks, and within each block the node\r\n// structure would be stable. This allows us to skip most children diffing\r\n// and only worry about the dynamic nodes (indicated by patch flags).\r\nconst blockStack = [];\r\nlet currentBlock = null;\r\n/**\r\n * Open a block.\r\n * This must be called before `createBlock`. It cannot be part of `createBlock`\r\n * because the children of the block are evaluated before `createBlock` itself\r\n * is called. The generated code typically looks like this:\r\n *\r\n * ```js\r\n * function render() {\r\n * return (openBlock(),createBlock('div', null, [...]))\r\n * }\r\n * ```\r\n * disableTracking is true when creating a v-for fragment block, since a v-for\r\n * fragment always diffs its children.\r\n *\r\n * @private\r\n */\r\nfunction openBlock(disableTracking = false) {\r\n blockStack.push((currentBlock = disableTracking ? null : []));\r\n}\r\nfunction closeBlock() {\r\n blockStack.pop();\r\n currentBlock = blockStack[blockStack.length - 1] || null;\r\n}\r\n/**\r\n * Create a block root vnode. Takes the same exact arguments as `createVNode`.\r\n * A block root keeps track of dynamic nodes within the block in the\r\n * `dynamicChildren` array.\r\n *\r\n * @private\r\n */\r\nfunction createBlock(type, props, children, patchFlag, dynamicProps) {\r\n const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */);\r\n // save current block children on the block vnode\r\n vnode.dynamicChildren = currentBlock || EMPTY_ARR;\r\n // close block\r\n closeBlock();\r\n // a block is always going to be patched, so track it as a child of its\r\n // parent block\r\n if ( currentBlock) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...( args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction getInternetExplorerVersion() {\n var ua = window.navigator.userAgent;\n var msie = ua.indexOf('MSIE ');\n\n if (msie > 0) {\n // IE 10 or older => return version number\n return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);\n }\n\n var trident = ua.indexOf('Trident/');\n\n if (trident > 0) {\n // IE 11 => return version number\n var rv = ua.indexOf('rv:');\n return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);\n }\n\n var edge = ua.indexOf('Edge/');\n\n if (edge > 0) {\n // Edge (IE 12+) => return version number\n return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);\n } // other browser\n\n\n return -1;\n}\n\nvar isIE;\n\nfunction initCompat() {\n if (!initCompat.init) {\n initCompat.init = true;\n isIE = getInternetExplorerVersion() !== -1;\n }\n}\n\nvar script = {\n name: 'ResizeObserver',\n mounted: function mounted() {\n var _this = this;\n\n initCompat();\n nextTick(function () {\n _this._w = _this.$el.offsetWidth;\n _this._h = _this.$el.offsetHeight;\n });\n var object = document.createElement('object');\n this._resizeObject = object;\n object.setAttribute('aria-hidden', 'true');\n object.setAttribute('tabindex', -1);\n object.onload = this.addResizeHandlers;\n object.type = 'text/html';\n\n if (isIE) {\n this.$el.appendChild(object);\n }\n\n object.data = 'about:blank';\n\n if (!isIE) {\n this.$el.appendChild(object);\n }\n },\n beforeUnmount: function beforeUnmount() {\n this.removeResizeHandlers();\n },\n methods: {\n compareAndNotify: function compareAndNotify() {\n if (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) {\n this._w = this.$el.offsetWidth;\n this._h = this.$el.offsetHeight;\n this.$emit('notify', {\n width: this._w,\n height: this._h\n });\n }\n },\n addResizeHandlers: function addResizeHandlers() {\n this._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify);\n\n this.compareAndNotify();\n },\n removeResizeHandlers: function removeResizeHandlers() {\n if (this._resizeObject && this._resizeObject.onload) {\n if (!isIE && this._resizeObject.contentDocument) {\n this._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify);\n }\n\n this.$el.removeChild(this._resizeObject);\n this._resizeObject.onload = null;\n this._resizeObject = null;\n }\n }\n }\n};\n\nvar _withId = /*#__PURE__*/withScopeId(\"data-v-b329ee4c\");\n\npushScopeId(\"data-v-b329ee4c\");\n\nvar _hoisted_1 = {\n class: \"resize-observer\",\n tabindex: \"-1\"\n};\n\npopScopeId();\n\nvar render = /*#__PURE__*/_withId(function (_ctx, _cache, $props, $setup, $data, $options) {\n return openBlock(), createBlock(\"div\", _hoisted_1);\n});\n\nscript.render = render;\nscript.__scopeId = \"data-v-b329ee4c\";\nscript.__file = \"src/components/ResizeObserver.vue\";\n\nfunction install(Vue) {\n Vue.component('resize-observer', script);\n Vue.component('ResizeObserver', script);\n}\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.5.0\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { script as ResizeObserver, install };\n//# sourceMappingURL=vue-resize.esm.js.map\n","function _typeof(obj) {\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n}\n\nfunction _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n return arr2;\n }\n}\n\nfunction _iterableToArray(iter) {\n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\n/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase());\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\nlet currentBlock = null;\r\n// Whether we should be tracking dynamic child nodes inside a block.\r\n// Only tracks when this value is > 0\r\n// We are not using a simple boolean because this value may need to be\r\n// incremented/decremented by nested usage of v-once (see below)\r\nlet shouldTrack$1 = 1;\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nlet vnodeArgsTransformer;\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...(vnodeArgsTransformer\r\n ? vnodeArgsTransformer(args, currentRenderingInstance)\r\n : args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (shouldTrack$1 > 0 &&\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nconst svgNS = 'http://www.w3.org/2000/svg';\r\nconst doc = (typeof document !== 'undefined' ? document : null);\r\nlet tempContainer;\r\nlet tempSVGContainer;\r\nconst nodeOps = {\r\n insert: (child, parent, anchor) => {\r\n parent.insertBefore(child, anchor || null);\r\n },\r\n remove: child => {\r\n const parent = child.parentNode;\r\n if (parent) {\r\n parent.removeChild(child);\r\n }\r\n },\r\n createElement: (tag, isSVG, is) => isSVG\r\n ? doc.createElementNS(svgNS, tag)\r\n : doc.createElement(tag, is ? { is } : undefined),\r\n createText: text => doc.createTextNode(text),\r\n createComment: text => doc.createComment(text),\r\n setText: (node, text) => {\r\n node.nodeValue = text;\r\n },\r\n setElementText: (el, text) => {\r\n el.textContent = text;\r\n },\r\n parentNode: node => node.parentNode,\r\n nextSibling: node => node.nextSibling,\r\n querySelector: selector => doc.querySelector(selector),\r\n setScopeId(el, id) {\r\n el.setAttribute(id, '');\r\n },\r\n cloneNode(el) {\r\n return el.cloneNode(true);\r\n },\r\n // __UNSAFE__\r\n // Reason: innerHTML.\r\n // Static content here can only come from compiled templates.\r\n // As long as the user only uses trusted templates, this is safe.\r\n insertStaticContent(content, parent, anchor, isSVG) {\r\n const temp = isSVG\r\n ? tempSVGContainer ||\r\n (tempSVGContainer = doc.createElementNS(svgNS, 'svg'))\r\n : tempContainer || (tempContainer = doc.createElement('div'));\r\n temp.innerHTML = content;\r\n const first = temp.firstChild;\r\n let node = first;\r\n let last = node;\r\n while (node) {\r\n last = node;\r\n nodeOps.insert(node, parent, anchor);\r\n node = temp.firstChild;\r\n }\r\n return [first, last];\r\n }\r\n};\n\n// compiler should normalize class + :class bindings on the same element\r\n// into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n if (value == null) {\r\n value = '';\r\n }\r\n if (isSVG) {\r\n el.setAttribute('class', value);\r\n }\r\n else {\r\n // directly setting className should be faster than setAttribute in theory\r\n // if this is an element during a transition, take the temporary transition\r\n // classes into account.\r\n const transitionClasses = el._vtc;\r\n if (transitionClasses) {\r\n value = (value\r\n ? [value, ...transitionClasses]\r\n : [...transitionClasses]).join(' ');\r\n }\r\n el.className = value;\r\n }\r\n}\n\nfunction patchStyle(el, prev, next) {\r\n const style = el.style;\r\n if (!next) {\r\n el.removeAttribute('style');\r\n }\r\n else if (isString(next)) {\r\n if (prev !== next) {\r\n style.cssText = next;\r\n }\r\n }\r\n else {\r\n for (const key in next) {\r\n setStyle(style, key, next[key]);\r\n }\r\n if (prev && !isString(prev)) {\r\n for (const key in prev) {\r\n if (next[key] == null) {\r\n setStyle(style, key, '');\r\n }\r\n }\r\n }\r\n }\r\n}\r\nconst importantRE = /\\s*!important$/;\r\nfunction setStyle(style, name, val) {\r\n if (isArray(val)) {\r\n val.forEach(v => setStyle(style, name, v));\r\n }\r\n else {\r\n if (name.startsWith('--')) {\r\n // custom property definition\r\n style.setProperty(name, val);\r\n }\r\n else {\r\n const prefixed = autoPrefix(style, name);\r\n if (importantRE.test(val)) {\r\n // !important\r\n style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');\r\n }\r\n else {\r\n style[prefixed] = val;\r\n }\r\n }\r\n }\r\n}\r\nconst prefixes = ['Webkit', 'Moz', 'ms'];\r\nconst prefixCache = {};\r\nfunction autoPrefix(style, rawName) {\r\n const cached = prefixCache[rawName];\r\n if (cached) {\r\n return cached;\r\n }\r\n let name = camelize(rawName);\r\n if (name !== 'filter' && name in style) {\r\n return (prefixCache[rawName] = name);\r\n }\r\n name = capitalize(name);\r\n for (let i = 0; i < prefixes.length; i++) {\r\n const prefixed = prefixes[i] + name;\r\n if (prefixed in style) {\r\n return (prefixCache[rawName] = prefixed);\r\n }\r\n }\r\n return rawName;\r\n}\n\nconst xlinkNS = 'http://www.w3.org/1999/xlink';\r\nfunction patchAttr(el, key, value, isSVG) {\r\n if (isSVG && key.startsWith('xlink:')) {\r\n if (value == null) {\r\n el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\r\n }\r\n else {\r\n el.setAttributeNS(xlinkNS, key, value);\r\n }\r\n }\r\n else {\r\n // note we are only checking boolean attributes that don't have a\r\n // corresponding dom prop of the same name here.\r\n const isBoolean = isSpecialBooleanAttr(key);\r\n if (value == null || (isBoolean && value === false)) {\r\n el.removeAttribute(key);\r\n }\r\n else {\r\n el.setAttribute(key, isBoolean ? '' : value);\r\n }\r\n }\r\n}\n\n// __UNSAFE__\r\n// functions. The user is responsible for using them with only trusted content.\r\nfunction patchDOMProp(el, key, value, \r\n// the following args are passed only due to potential innerHTML/textContent\r\n// overriding existing VNodes, in which case the old tree must be properly\r\n// unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n if (key === 'innerHTML' || key === 'textContent') {\r\n if (prevChildren) {\r\n unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n }\r\n el[key] = value == null ? '' : value;\r\n return;\r\n }\r\n if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n // store value as _value as well since\r\n // non-string values will be stringified.\r\n el._value = value;\r\n const newValue = value == null ? '' : value;\r\n if (el.value !== newValue) {\r\n el.value = newValue;\r\n }\r\n return;\r\n }\r\n if (value === '' || value == null) {\r\n const type = typeof el[key];\r\n if (value === '' && type === 'boolean') {\r\n // e.g. with\r\n // :true-value & :false-value\r\n // store value as dom properties since non-string values will be\r\n // stringified.\r\n if (key === 'true-value') {\r\n el._trueValue = nextValue;\r\n }\r\n else if (key === 'false-value') {\r\n el._falseValue = nextValue;\r\n }\r\n patchAttr(el, key, nextValue, isSVG);\r\n }\r\n break;\r\n }\r\n};\r\nfunction shouldSetAsProp(el, key, value, isSVG) {\r\n if (isSVG) {\r\n // most keys must be set as attribute on svg elements to work\r\n // ...except innerHTML\r\n if (key === 'innerHTML') {\r\n return true;\r\n }\r\n // or native onclick with function values\r\n if (key in el && nativeOnRE.test(key) && isFunction(value)) {\r\n return true;\r\n }\r\n return false;\r\n }\r\n // spellcheck and draggable are numerated attrs, however their\r\n // corresponding DOM properties are actually booleans - this leads to\r\n // setting it with a string \"false\" value leading it to be coerced to\r\n // `true`, so we need to always treat them as attributes.\r\n // Note that `contentEditable` doesn't have this problem: its DOM\r\n // property is also enumerated string values.\r\n if (key === 'spellcheck' || key === 'draggable') {\r\n return false;\r\n }\r\n // #1787 form as an attribute must be a string, while it accepts an Element as\r\n // a prop\r\n if (key === 'form' && typeof value === 'string') {\r\n return false;\r\n }\r\n // #1526 must be set as attribute\r\n if (key === 'list' && el.tagName === 'INPUT') {\r\n return false;\r\n }\r\n // native onclick with string value, must be set as attribute\r\n if (nativeOnRE.test(key) && isString(value)) {\r\n return false;\r\n }\r\n return key in el;\r\n}\n\nconst rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps);\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction processOptions(value) {\n var options;\n\n if (typeof value === 'function') {\n // Simple options (callback-only)\n options = {\n callback: value\n };\n } else {\n // Options object\n options = value;\n }\n\n return options;\n}\nfunction throttle(callback, delay) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var timeout;\n var lastState;\n var currentArgs;\n\n var throttled = function throttled(state) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n currentArgs = args;\n if (timeout && state === lastState) return;\n var leading = options.leading;\n\n if (typeof leading === 'function') {\n leading = leading(state, lastState);\n }\n\n if ((!timeout || state !== lastState) && leading) {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n }\n\n lastState = state;\n clearTimeout(timeout);\n timeout = setTimeout(function () {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n timeout = 0;\n }, delay);\n };\n\n throttled._clear = function () {\n clearTimeout(timeout);\n timeout = null;\n };\n\n return throttled;\n}\nfunction deepEqual(val1, val2) {\n if (val1 === val2) return true;\n\n if (_typeof(val1) === 'object') {\n for (var key in val1) {\n if (!deepEqual(val1[key], val2[key])) {\n return false;\n }\n }\n\n return true;\n }\n\n return false;\n}\n\nvar VisibilityState =\n/*#__PURE__*/\nfunction () {\n function VisibilityState(el, options, vnode) {\n _classCallCheck(this, VisibilityState);\n\n this.el = el;\n this.observer = null;\n this.frozen = false;\n this.createObserver(options, vnode);\n }\n\n _createClass(VisibilityState, [{\n key: \"createObserver\",\n value: function createObserver(options, vnode) {\n var _this = this;\n\n if (this.observer) {\n this.destroyObserver();\n }\n\n if (this.frozen) return;\n this.options = processOptions(options);\n\n this.callback = function (result, entry) {\n _this.options.callback(result, entry);\n\n if (result && _this.options.once) {\n _this.frozen = true;\n\n _this.destroyObserver();\n }\n }; // Throttle\n\n\n if (this.callback && this.options.throttle) {\n var _ref = this.options.throttleOptions || {},\n _leading = _ref.leading;\n\n this.callback = throttle(this.callback, this.options.throttle, {\n leading: function leading(state) {\n return _leading === 'both' || _leading === 'visible' && state || _leading === 'hidden' && !state;\n }\n });\n }\n\n this.oldResult = undefined;\n this.observer = new IntersectionObserver(function (entries) {\n var entry = entries[0];\n\n if (entries.length > 1) {\n var intersectingEntry = entries.find(function (e) {\n return e.isIntersecting;\n });\n\n if (intersectingEntry) {\n entry = intersectingEntry;\n }\n }\n\n if (_this.callback) {\n // Use isIntersecting if possible because browsers can report isIntersecting as true, but intersectionRatio as 0, when something very slowly enters the viewport.\n var result = entry.isIntersecting && entry.intersectionRatio >= _this.threshold;\n if (result === _this.oldResult) return;\n _this.oldResult = result;\n\n _this.callback(result, entry);\n }\n }, this.options.intersection); // Wait for the element to be in document\n\n nextTick(function () {\n if (_this.observer) {\n _this.observer.observe(_this.el);\n }\n });\n }\n }, {\n key: \"destroyObserver\",\n value: function destroyObserver() {\n if (this.observer) {\n this.observer.disconnect();\n this.observer = null;\n } // Cancel throttled call\n\n\n if (this.callback && this.callback._clear) {\n this.callback._clear();\n\n this.callback = null;\n }\n }\n }, {\n key: \"threshold\",\n get: function get() {\n return this.options.intersection && this.options.intersection.threshold || 0;\n }\n }]);\n\n return VisibilityState;\n}();\n\nfunction bind(el, _ref2, vnode) {\n var value = _ref2.value;\n if (!value) return;\n\n if (typeof IntersectionObserver === 'undefined') {\n console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');\n } else {\n var state = new VisibilityState(el, value, vnode);\n el._vue_visibilityState = state;\n }\n}\n\nfunction update(el, _ref3, vnode) {\n var value = _ref3.value,\n oldValue = _ref3.oldValue;\n if (deepEqual(value, oldValue)) return;\n var state = el._vue_visibilityState;\n\n if (!value) {\n unbind(el);\n return;\n }\n\n if (state) {\n state.createObserver(value, vnode);\n } else {\n bind(el, {\n value: value\n }, vnode);\n }\n}\n\nfunction unbind(el) {\n var state = el._vue_visibilityState;\n\n if (state) {\n state.destroyObserver();\n delete el._vue_visibilityState;\n }\n}\n\nvar ObserveVisibility = {\n beforeMount: bind,\n updated: update,\n unmounted: unbind\n};\n\nfunction install(Vue) {\n Vue.directive('observe-visibility', ObserveVisibility);\n /* -- Add more components here -- */\n}\n/* -- Plugin definition & Auto-install -- */\n\n/* You shouldn't have to modify the code below */\n// Plugin\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.4.6\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { ObserveVisibility, install };\n","(function (root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define([], factory);\n } else if (typeof module === \"object\" && module.exports) {\n module.exports = factory();\n } else {\n root.Scrollparent = factory();\n }\n}(this, function () {\n var regex = /(auto|scroll)/;\n\n var parents = function (node, ps) {\n if (node.parentNode === null) { return ps; }\n\n return parents(node.parentNode, ps.concat([node]));\n };\n\n var style = function (node, prop) {\n return getComputedStyle(node, null).getPropertyValue(prop);\n };\n\n var overflow = function (node) {\n return style(node, \"overflow\") + style(node, \"overflow-y\") + style(node, \"overflow-x\");\n };\n\n var scroll = function (node) {\n return regex.test(overflow(node));\n };\n\n var scrollParent = function (node) {\n if (!(node instanceof HTMLElement || node instanceof SVGElement)) {\n return ;\n }\n\n var ps = parents(node.parentNode, []);\n\n for (var i = 0; i < ps.length; i += 1) {\n if (scroll(ps[i])) {\n return ps[i];\n }\n }\n\n return document.scrollingElement || document.documentElement;\n };\n\n return scrollParent;\n}));\n","export const props = {\r\n items: {\r\n type: Array,\r\n required: true,\r\n },\r\n\r\n keyField: {\r\n type: String,\r\n default: 'id',\r\n },\r\n\r\n direction: {\r\n type: String,\r\n default: 'vertical',\r\n validator: (value) => ['vertical', 'horizontal'].includes(value),\r\n },\r\n}\r\n\r\nexport function simpleArray () {\r\n return this.items.length && typeof this.items[0] !== 'object'\r\n}\r\n","export let supportsPassive = false\r\n\r\nif (typeof window !== 'undefined') {\r\n supportsPassive = false\r\n try {\r\n var opts = Object.defineProperty({}, 'passive', {\r\n get () {\r\n supportsPassive = true\r\n },\r\n })\r\n window.addEventListener('test', null, opts)\r\n } catch (e) {}\r\n}\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n","import config from './config'\r\n\r\nimport RecycleScroller from './components/RecycleScroller.vue'\r\nimport DynamicScroller from './components/DynamicScroller.vue'\r\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\r\n\r\nexport { default as IdState } from './mixins/IdState'\r\n\r\nexport {\r\n RecycleScroller,\r\n DynamicScroller,\r\n DynamicScrollerItem,\r\n}\r\n\r\nfunction registerComponents (Vue, prefix) {\r\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\r\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\r\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\r\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\r\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\r\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\r\n}\r\n\r\nconst plugin = {\r\n // eslint-disable-next-line no-undef\r\n version: VERSION,\r\n install (Vue, options) {\r\n const finalOptions = Object.assign({}, {\r\n installComponents: true,\r\n componentsPrefix: '',\r\n }, options)\r\n\r\n for (const key in finalOptions) {\r\n if (typeof finalOptions[key] !== 'undefined') {\r\n config[key] = finalOptions[key]\r\n }\r\n }\r\n\r\n if (finalOptions.installComponents) {\r\n registerComponents(Vue, finalOptions.componentsPrefix)\r\n }\r\n },\r\n}\r\n\r\nexport default plugin\r\n\r\n// Auto-install\r\nlet GlobalVue = null\r\nif (typeof window !== 'undefined') {\r\n GlobalVue = window.Vue\r\n} else if (typeof global !== 'undefined') {\r\n GlobalVue = global.Vue\r\n}\r\nif (GlobalVue) {\r\n GlobalVue.use(plugin)\r\n}\r\n","import { reactive } from 'vue'\r\n\r\nexport default function ({\r\n idProp = vm => vm.item.id,\r\n} = {}) {\r\n const store = reactive({})\r\n\r\n // @vue/component\r\n return {\r\n data () {\r\n return {\r\n idState: null,\r\n }\r\n },\r\n\r\n created () {\r\n this.$_id = null\r\n if (typeof idProp === 'function') {\r\n this.$_getId = () => idProp.call(this, this)\r\n } else {\r\n this.$_getId = () => this[idProp]\r\n }\r\n this.$watch(this.$_getId, {\r\n handler (value) {\r\n this.$nextTick(() => {\r\n this.$_id = value\r\n })\r\n },\r\n immediate: true,\r\n })\r\n this.$_updateIdState()\r\n },\r\n\r\n beforeUpdate () {\r\n this.$_updateIdState()\r\n },\r\n\r\n methods: {\r\n /**\r\n * Initialize an idState\r\n * @param {number|string} id Unique id for the data\r\n */\r\n $_idStateInit (id) {\r\n const factory = this.$options.idState\r\n if (typeof factory === 'function') {\r\n const data = factory.call(this, this)\r\n store[id] = data\r\n this.$_id = id\r\n return data\r\n } else {\r\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\r\n }\r\n },\r\n\r\n /**\r\n * Ensure idState is created and up-to-date\r\n */\r\n $_updateIdState () {\r\n const id = this.$_getId()\r\n if (id == null) {\r\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\r\n }\r\n if (id !== this.$_id) {\r\n if (!store[id]) {\r\n this.$_idStateInit(id)\r\n }\r\n this.idState = store[id]\r\n }\r\n },\r\n },\r\n }\r\n}\r\n"],"names":["itemsLimit","makeMap","str","expectsLowerCase","map","Object","create","list","split","i","length","val","toLowerCase","isGloballyWhitelisted","normalizeStyle","value","isArray","res","item","normalized","isString","parseStringStyle","key","isObject","listDelimiterRE","propertyDelimiterRE","cssText","ret","forEach","tmp","trim","normalizeClass","name","fn","cache","_globalThis","EMPTY_OBJ","process","env","NODE_ENV","freeze","EMPTY_ARR","NOOP","onRE","isOn","test","extend","assign","remove","arr","el","indexOf","splice","hasOwnProperty","prototype","hasOwn","call","Array","isMap","toTypeString","isSet","isFunction","isSymbol","_typeof","objectToString","toString","toRawType","slice","isIntegerKey","parseInt","capitalize","charAt","toUpperCase","hasChanged","oldValue","then","catch","globalThis","self","window","global","obj","Symbol","_typeof2","iterator","constructor","_defineProperties","target","props","descriptor","enumerable","configurable","writable","defineProperty","_toConsumableArray","arr2","_arrayWithoutHoles","iter","from","_iterableToArray","TypeError","_nonIterableSpread","isSpecialBooleanAttr","activeEffect","isModelListener","startsWith","cacheStringFunction","camelizeRE","camelize","replace","_","c","hyphenateRE","hyphenate","targetMap","WeakMap","effectStack","ITERATE_KEY","MAP_KEY_ITERATE_KEY","isEffect","_isEffect","effect","options","raw","createReactiveEffect","lazy","stop","active","cleanup","onStop","uid","scheduler","undefined","includes","trackStack","push","shouldTrack","pop","resetTracking","id","allowRecurse","deps","delete","pauseTracking","last","track","type","depsMap","get","set","Map","dep","Set","has","add","onTrack","trigger","newValue","oldTarget","effects","effectsToAdd","onTrigger","builtInSymbols","getOwnPropertyNames","filter","createGetter","shallowGet","readonlyGet","shallowReadonlyGet","arrayInstrumentations","isReadonly","shallow","receiver","readonlyMap","reactiveMap","targetIsArray","Reflect","isRef","readonly","reactive","createSetter","toRaw","hadKey","Number","result","method","this","l","args","apply","mutableHandlers","deleteProperty","ownKeys","readonlyHandlers","console","warn","String","shallowReadonlyHandlers","toReactive","toReadonly","toShallow","getProto","v","getPrototypeOf","get$1","isShallow","rawTarget","rawKey","wrap","has$1","size","set$1","checkIdentityKeys","deleteEntry","clear","hadItems","createForEach","callback","thisArg","observed","createIterableMethod","targetIsMap","isPair","isKeyOnly","innerIterator","next","done","createReadonlyMethod","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","createInstrumentationGetter","instrumentations","mutableCollectionHandlers","readonlyCollectionHandlers","createReactiveObject","shallowReadonly","baseHandlers","collectionHandlers","proxyMap","existingProxy","targetType","isExtensible","rawType","targetTypeMap","proxy","Proxy","isReactive","isProxy","r","Boolean","__v_isRef","stack","pushWarningContext","vnode","popWarningContext","msg","instance","component","appWarnHandler","appContext","config","warnHandler","trace","getComponentTrace","callWithErrorHandling","join","formatComponentName","warnArgs","formatTrace","currentVNode","normalizedStack","recurseCount","parentInstance","parent","logs","entry","postfix","isRoot","open","close","keys","formatProp","JSON","stringify","formatProps","ErrorTypeStrings","err","handleError","callWithAsyncErrorHandling","values","throwInDev","contextVNode","cur","exposedInstance","errorInfo","errorCapturedHooks","ec","appErrorHandler","errorHandler","logError","info","error","isFlushing","isFlushPending","queue","flushIndex","pendingPreFlushCbs","activePreFlushCbs","preFlushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","Promise","resolve","currentFlushPromise","currentPreFlushParentJob","nextTick","p","bind","queueJob","job","queueFlush","flushJobs","queueCb","cb","activeQueue","pendingQueue","index","queuePreFlushCb","queuePostFlushCb","getId","Infinity","seen","flushPreFlushCbs","parentJob","checkRecursiveUpdates","sort","a","b","deduped","flushPostFlushCbs","count","Error","hmrDirtyComponents","__VUE_HMR_RUNTIME__","createRecord","tryWrap","isClassComponent","__vccOpts","instances","rerender","newRender","record","render","renderCache","update","reload","newComp","location","arg","e","isSuspense","__isSuspense","normalizeSuspenseChildren","content","fallback","shapeFlag","children","normalizeSuspenseSlot","default","normalizeVNode","s","singleChild","singleRoot","child","isVNode","Comment","filterSingleRoot","isRenderingCompiledSlot","setCompiledSlotRendering","n","INITIAL_WATCHER_VALUE","instanceWatch","source","publicThis","immediate","deep","flush","currentInstance","getter","warnInvalidSource","forceTrigger","_shallow","traverse","isUnmounted","onInvalidate","baseGetter","runner","queuePostRenderEffect","suspense","isMounted","recordInstanceBoundEffect","doWatch","pendingBranch","isTeleport","__isTeleport","NULL_DYNAMIC_COMPONENT","Fragment","Text","__v_isVNode","normalizeKey","normalizeRef","ref","createVNode","_createVNode","patchFlag","dynamicProps","cloned","cloneVNode","normalizeChildren","klass","class","style","ssContent","ssFallback","extraProps","mergeRef","mergedProps","mergeProps","concat","scopeId","targetAnchor","staticCount","dynamicChildren","dirs","transition","anchor","createTextVNode","text","flag","slot","_c","slotFlag","_ctx","arguments","toMerge","existing","incoming","mergeOptions","to","strats","optionMergeStrategies","mixins","extendsOptions","extends","m","publicPropertiesMap","$","$el","$data","data","$props","$attrs","attrs","$slots","slots","$refs","refs","$parent","getPublicInstance","$root","root","$emit","emit","$options","__VUE_OPTIONS_API__","__merged","globalMixins","resolveMergedOptions","$forceUpdate","$nextTick","$watch","PublicInstanceProxyHandlers","normalizedProps","ctx","setupState","accessCache","propsOptions","cssModule","globalProperties","publicGetter","__cssModules","unscopables","classifyRE","classify","Component","displayName","__file","match","inferFromRegistry","registry","components","initCustomFormatter","vueStyle","numberStyle","stringStyle","keywordStyle","formatter","header","__isVue","genRefFlag","formatValue","hasBody","body","blocks","createInstanceBlock","computed","extractKeys","injected","object","formatInstance","devtoolsFormatters","asRaw","Comp","extracted","isKeyOfType","opts","some","tempContainer","tempSVGContainer","svgNS","doc","document","nodeOps","insert","insertBefore","parentNode","removeChild","createElement","tag","isSVG","is","createElementNS","createText","createTextNode","createComment","setText","node","nodeValue","setElementText","textContent","nextSibling","querySelector","selector","setScopeId","setAttribute","cloneNode","insertStaticContent","temp","innerHTML","first","firstChild","patchClass","transitionClasses","_vtc","className","patchStyle","prev","setStyle","removeAttribute","importantRE","setProperty","prefixed","rawName","cached","prefixCache","prefixes","autoPrefix","xlinkNS","patchAttr","removeAttributeNS","setAttributeNS","isBoolean","patchDOMProp","prevChildren","parentComponent","parentSuspense","unmountChildren","tagName","_value","_getNow","Date","now","createEvent","timeStamp","performance","cachedNow","reset","addEventListener","event","handler","removeEventListener","patchEvent","prevValue","nextValue","invokers","_vei","existingInvoker","parseName","invoker","createInvoker","optionsModifierRE","initialValue","attached","originalStop","stopImmediatePropagation","_stopped","patchStopImmediatePropagation","nativeOnRE","shouldSetAsProp","patchProp","_trueValue","_falseValue","forcePatchProp","__VUE__","__VUE_DEVTOOLS_GLOBAL_HOOK__","initDev","VisibilityState","Constructor","_classCallCheck","observer","frozen","createObserver","protoProps","staticProps","_this","destroyObserver","once","throttle","_leading","throttleOptions","leading","delay","timeout","lastState","currentArgs","throttled","state","_len","_key","clearTimeout","setTimeout","_clear","oldResult","IntersectionObserver","entries","intersectingEntry","find","isIntersecting","intersectionRatio","threshold","intersection","observe","disconnect","_ref2","_vue_visibilityState","unbind","ObserveVisibility","beforeMount","updated","_ref3","deepEqual","val1","val2","unmounted","plugin","version","install","Vue","directive","GlobalVue","use","factory","regex","parents","ps","prop","getComputedStyle","getPropertyValue","scroll","overflow","HTMLElement","SVGElement","scrollingElement","documentElement","module","exports","Scrollparent","items","required","keyField","direction","validator","simpleArray","supportsPassive","ResizeObserver","directives","itemSize","minItemSize","sizeField","typeField","buffer","pageMode","prerender","emitUpdate","pool","totalSize","ready","hoverKey","sizes","current","accumulator","field","computedMinSize","$_computedMinItemSize","watch","updateVisibleItems","applyPageMode","created","$_startIndex","$_endIndex","$_views","$_unusedViews","$_scrollDirty","$_lastUpdateScrollPosition","$_prerender","mounted","beforeUnmount","removeListeners","methods","addView","view","shallowReactive","position","nr","used","unuseView","fake","unusedViews","unusedPool","handleResize","handleScroll","requestAnimationFrame","_this2","continuous","$_refreshTimout","handleVisibilityChange","isVisible","boundingClientRect","width","height","_this3","checkItem","startIndex","endIndex","checkPositionDiff","views","getScroll","positionDiff","start","end","oldI","Math","ceil","itemsLimitError","$_continuous","findIndex","unusedIndex","$_sortTimer","sortViews","getListenerTarget","ScrollParent","scrollState","isVertical","bounds","getBoundingClientRect","boundsSize","top","left","innerHeight","innerWidth","scrollTop","clientHeight","scrollLeft","clientWidth","addListeners","listenerTarget","passive","scrollToItem","scrollToPosition","log","_this4","viewA","viewB","_createBlock","before","_hoisted_1","_renderSlot","onMouseenter","onMouseleave","after","_hoisted_2","onNotify","RecycleScroller","inheritAttrs","provide","$_resizeObserver","CustomEvent","detail","contentRect","dispatchEvent","vscrollData","vscrollParent","vscrollResizeObserver","validSizes","itemsWithSize","$_undefinedMap","listeners","$listeners","forceUpdate","$_updates","$_undefinedSizes","activated","deactivated","onScrollerResize","scroller","onScrollerVisible","force","getItemSize","scrollToBottom","$_scrollingToBottom","scrollHeight","_mergeProps","onResize","onVisible","_toHandlers","_hoisted_3","inject","watchData","sizeDependencies","emitResize","finalActive","onDataUpdate","observeSize","unobserveSize","$_pendingVScrollUpdate","updateSize","$isServer","$_forceNextVScrollUpdate","updateWatchData","k","$on","onVscrollUpdate","onVscrollUpdateSize","$off","$_pendingSizeUpdate","computeSize","$_watchData","offsetWidth","offsetHeight","applySize","round","$set","unobserve","h","VERSION","finalOptions","installComponents","componentsPrefix","prefix","DynamicScroller","DynamicScrollerItem","registerComponents","idProp","vm","store","idState","$_id","$_getId","$_updateIdState","beforeUpdate","$_idStateInit"],"mappings":"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"} \ No newline at end of file diff --git a/dist/vue-virtual-scroller.umd.js b/dist/vue-virtual-scroller.umd.js index 1853f791..76b639c1 100644 --- a/dist/vue-virtual-scroller.umd.js +++ b/dist/vue-virtual-scroller.umd.js @@ -1,10 +1,8 @@ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) : typeof define === 'function' && define.amd ? define(['exports', 'vue'], factory) : - (global = global || self, factory(global['vue-virtual-scroller'] = {}, global.Vue)); -}(this, (function (exports, Vue) { 'use strict'; - - Vue = Vue && Object.prototype.hasOwnProperty.call(Vue, 'default') ? Vue['default'] : Vue; + (global = global || self, factory(global['vue-virtual-scroller'] = {}, global.vue)); +}(this, (function (exports, vue) { 'use strict'; var config = { itemsLimit: 1000 @@ -23,299 +21,6787 @@ }; } - return _typeof(obj); + return _typeof(obj); + } + + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; + } + + function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; + } + + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); + } + + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(n); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; + } + + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _createForOfIteratorHelper(o) { + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var it, + normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; + } + + var _ErrorTypeStrings; + + /** + * Make a map and return a function for checking if a key + * is in that map. + * IMPORTANT: all calls of this function must be prefixed with + * \/\*#\_\_PURE\_\_\*\/ + * So that rollup can tree-shake them if necessary. + */ + function makeMap(str, expectsLowerCase) { + var map = Object.create(null); + var list = str.split(','); + + for (var i = 0; i < list.length; i++) { + map[list[i]] = true; + } + + return expectsLowerCase ? function (val) { + return !!map[val.toLowerCase()]; + } : function (val) { + return !!map[val]; + }; + } + + var GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl'; + var isGloballyWhitelisted = /*#__PURE__*/makeMap(GLOBALS_WHITE_LISTED); + + function normalizeStyle(value) { + if (isArray(value)) { + var res = {}; + + for (var i = 0; i < value.length; i++) { + var item = value[i]; + var normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item); + + if (normalized) { + for (var key in normalized) { + res[key] = normalized[key]; + } + } + } + + return res; + } else if (isObject(value)) { + return value; + } + } + + var listDelimiterRE = /;(?![^(]*\))/g; + var propertyDelimiterRE = /:(.+)/; + + function parseStringStyle(cssText) { + var ret = {}; + cssText.split(listDelimiterRE).forEach(function (item) { + if (item) { + var tmp = item.split(propertyDelimiterRE); + tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); + } + }); + return ret; + } + + function normalizeClass(value) { + var res = ''; + + if (isString(value)) { + res = value; + } else if (isArray(value)) { + for (var i = 0; i < value.length; i++) { + res += normalizeClass(value[i]) + ' '; + } + } else if (isObject(value)) { + for (var name in value) { + if (value[name]) { + res += name + ' '; + } + } + } + + return res.trim(); + } + + var EMPTY_OBJ = process.env.NODE_ENV !== 'production' ? Object.freeze({}) : {}; + var EMPTY_ARR = process.env.NODE_ENV !== 'production' ? Object.freeze([]) : []; + + var NOOP = function NOOP() {}; + + var onRE = /^on[^a-z]/; + + var isOn = function isOn(key) { + return onRE.test(key); + }; + + var extend = Object.assign; + + var remove = function remove(arr, el) { + var i = arr.indexOf(el); + + if (i > -1) { + arr.splice(i, 1); + } + }; + + var hasOwnProperty = Object.prototype.hasOwnProperty; + + var hasOwn = function hasOwn(val, key) { + return hasOwnProperty.call(val, key); + }; + + var isArray = Array.isArray; + + var isMap = function isMap(val) { + return toTypeString(val) === '[object Map]'; + }; + + var isSet = function isSet(val) { + return toTypeString(val) === '[object Set]'; + }; + + var isFunction = function isFunction(val) { + return typeof val === 'function'; + }; + + var isString = function isString(val) { + return typeof val === 'string'; + }; + + var isSymbol = function isSymbol(val) { + return _typeof(val) === 'symbol'; + }; + + var isObject = function isObject(val) { + return val !== null && _typeof(val) === 'object'; + }; + + var isPromise = function isPromise(val) { + return isObject(val) && isFunction(val.then) && isFunction(val.catch); + }; + + var objectToString = Object.prototype.toString; + + var toTypeString = function toTypeString(value) { + return objectToString.call(value); + }; + + var toRawType = function toRawType(value) { + // extract "RawType" from strings like "[object RawType]" + return toTypeString(value).slice(8, -1); + }; + + var isIntegerKey = function isIntegerKey(key) { + return isString(key) && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key; + }; + + var cacheStringFunction = function cacheStringFunction(fn) { + var cache = Object.create(null); + return function (str) { + var hit = cache[str]; + return hit || (cache[str] = fn(str)); + }; + }; + /** + * @private + */ + + + var capitalize = cacheStringFunction(function (str) { + return str.charAt(0).toUpperCase() + str.slice(1); + }); // compare whether a value has changed, accounting for NaN. + + var hasChanged = function hasChanged(value, oldValue) { + return value !== oldValue && (value === value || oldValue === oldValue); + }; + + var _globalThis; + + var getGlobalThis = function getGlobalThis() { + return _globalThis || (_globalThis = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {}); + }; + + var targetMap = new WeakMap(); + var effectStack = []; + var activeEffect; + var ITERATE_KEY = Symbol(process.env.NODE_ENV !== 'production' ? 'iterate' : ''); + var MAP_KEY_ITERATE_KEY = Symbol(process.env.NODE_ENV !== 'production' ? 'Map key iterate' : ''); + + function isEffect(fn) { + return fn && fn._isEffect === true; + } + + function effect(fn) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_OBJ; + + if (isEffect(fn)) { + fn = fn.raw; + } + + var effect = createReactiveEffect(fn, options); + + if (!options.lazy) { + effect(); + } + + return effect; + } + + function stop(effect) { + if (effect.active) { + cleanup(effect); + + if (effect.options.onStop) { + effect.options.onStop(); + } + + effect.active = false; + } + } + + var uid = 0; + + function createReactiveEffect(fn, options) { + var effect = function reactiveEffect() { + if (!effect.active) { + return options.scheduler ? undefined : fn(); + } + + if (!effectStack.includes(effect)) { + cleanup(effect); + + try { + enableTracking(); + effectStack.push(effect); + activeEffect = effect; + return fn(); + } finally { + effectStack.pop(); + resetTracking(); + activeEffect = effectStack[effectStack.length - 1]; + } + } + }; + + effect.id = uid++; + effect.allowRecurse = !!options.allowRecurse; + effect._isEffect = true; + effect.active = true; + effect.raw = fn; + effect.deps = []; + effect.options = options; + return effect; + } + + function cleanup(effect) { + var deps = effect.deps; + + if (deps.length) { + for (var i = 0; i < deps.length; i++) { + deps[i].delete(effect); + } + + deps.length = 0; + } + } + + var shouldTrack = true; + var trackStack = []; + + function pauseTracking() { + trackStack.push(shouldTrack); + shouldTrack = false; + } + + function enableTracking() { + trackStack.push(shouldTrack); + shouldTrack = true; + } + + function resetTracking() { + var last = trackStack.pop(); + shouldTrack = last === undefined ? true : last; + } + + function track(target, type, key) { + if (!shouldTrack || activeEffect === undefined) { + return; + } + + var depsMap = targetMap.get(target); + + if (!depsMap) { + targetMap.set(target, depsMap = new Map()); + } + + var dep = depsMap.get(key); + + if (!dep) { + depsMap.set(key, dep = new Set()); + } + + if (!dep.has(activeEffect)) { + dep.add(activeEffect); + activeEffect.deps.push(dep); + + if (process.env.NODE_ENV !== 'production' && activeEffect.options.onTrack) { + activeEffect.options.onTrack({ + effect: activeEffect, + target: target, + type: type, + key: key + }); + } + } + } + + function trigger(target, type, key, newValue, oldValue, oldTarget) { + var depsMap = targetMap.get(target); + + if (!depsMap) { + // never been tracked + return; + } + + var effects = new Set(); + + var add = function add(effectsToAdd) { + if (effectsToAdd) { + effectsToAdd.forEach(function (effect) { + if (effect !== activeEffect || effect.allowRecurse) { + effects.add(effect); + } + }); + } + }; + + if (type === "clear" + /* CLEAR */ + ) { + // collection being cleared + // trigger all effects for target + depsMap.forEach(add); + } else if (key === 'length' && isArray(target)) { + depsMap.forEach(function (dep, key) { + if (key === 'length' || key >= newValue) { + add(dep); + } + }); + } else { + // schedule runs for SET | ADD | DELETE + if (key !== void 0) { + add(depsMap.get(key)); + } // also run for iteration key on ADD | DELETE | Map.SET + + + switch (type) { + case "add" + /* ADD */ + : + if (!isArray(target)) { + add(depsMap.get(ITERATE_KEY)); + + if (isMap(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } else if (isIntegerKey(key)) { + // new index added to array -> length changes + add(depsMap.get('length')); + } + + break; + + case "delete" + /* DELETE */ + : + if (!isArray(target)) { + add(depsMap.get(ITERATE_KEY)); + + if (isMap(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + + break; + + case "set" + /* SET */ + : + if (isMap(target)) { + add(depsMap.get(ITERATE_KEY)); + } + + break; + } + } + + var run = function run(effect) { + if (process.env.NODE_ENV !== 'production' && effect.options.onTrigger) { + effect.options.onTrigger({ + effect: effect, + target: target, + key: key, + type: type, + newValue: newValue, + oldValue: oldValue, + oldTarget: oldTarget + }); + } + + if (effect.options.scheduler) { + effect.options.scheduler(effect); + } else { + effect(); + } + }; + + effects.forEach(run); + } + + var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map(function (key) { + return Symbol[key]; + }).filter(isSymbol)); + var get = /*#__PURE__*/createGetter(); + var shallowGet = /*#__PURE__*/createGetter(false, true); + var readonlyGet = /*#__PURE__*/createGetter(true); + var shallowReadonlyGet = /*#__PURE__*/createGetter(true, true); + var arrayInstrumentations = {}; + ['includes', 'indexOf', 'lastIndexOf'].forEach(function (key) { + var method = Array.prototype[key]; + + arrayInstrumentations[key] = function () { + var arr = toRaw(this); + + for (var i = 0, l = this.length; i < l; i++) { + track(arr, "get" + /* GET */ + , i + ''); + } // we run the method using the original args first (which may be reactive) + + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + var res = method.apply(arr, args); + + if (res === -1 || res === false) { + // if that didn't work, run it again using raw values. + return method.apply(arr, args.map(toRaw)); + } else { + return res; + } + }; + }); + ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(function (key) { + var method = Array.prototype[key]; + + arrayInstrumentations[key] = function () { + pauseTracking(); + + for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + var res = method.apply(this, args); + resetTracking(); + return res; + }; + }); + + function createGetter() { + var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var shallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + return function get(target, key, receiver) { + if (key === "__v_isReactive" + /* IS_REACTIVE */ + ) { + return !isReadonly; + } else if (key === "__v_isReadonly" + /* IS_READONLY */ + ) { + return isReadonly; + } else if (key === "__v_raw" + /* RAW */ + && receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) { + return target; + } + + var targetIsArray = isArray(target); + + if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver); + } + + var res = Reflect.get(target, key, receiver); + + if (isSymbol(key) ? builtInSymbols.has(key) : key === "__proto__" || key === "__v_isRef") { + return res; + } + + if (!isReadonly) { + track(target, "get" + /* GET */ + , key); + } + + if (shallow) { + return res; + } + + if (isRef(res)) { + // ref unwrapping - does not apply for Array + integer key. + var shouldUnwrap = !targetIsArray || !isIntegerKey(key); + return shouldUnwrap ? res.value : res; + } + + if (isObject(res)) { + // Convert returned value into a proxy as well. we do the isObject check + // here to avoid invalid value warning. Also need to lazy access readonly + // and reactive here to avoid circular dependency. + return isReadonly ? readonly(res) : reactive(res); + } + + return res; + }; + } + + var set = /*#__PURE__*/createSetter(); + var shallowSet = /*#__PURE__*/createSetter(true); + + function createSetter() { + var shallow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + return function set(target, key, value, receiver) { + var oldValue = target[key]; + + if (!shallow) { + value = toRaw(value); + + if (!isArray(target) && isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } + } + + var hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key); + var result = Reflect.set(target, key, value, receiver); // don't trigger if target is something up in the prototype chain of original + + if (target === toRaw(receiver)) { + if (!hadKey) { + trigger(target, "add" + /* ADD */ + , key, value); + } else if (hasChanged(value, oldValue)) { + trigger(target, "set" + /* SET */ + , key, value, oldValue); + } + } + + return result; + }; + } + + function deleteProperty(target, key) { + var hadKey = hasOwn(target, key); + var oldValue = target[key]; + var result = Reflect.deleteProperty(target, key); + + if (result && hadKey) { + trigger(target, "delete" + /* DELETE */ + , key, undefined, oldValue); + } + + return result; + } + + function has(target, key) { + var result = Reflect.has(target, key); + + if (!isSymbol(key) || !builtInSymbols.has(key)) { + track(target, "has" + /* HAS */ + , key); + } + + return result; + } + + function ownKeys$1(target) { + track(target, "iterate" + /* ITERATE */ + , isArray(target) ? 'length' : ITERATE_KEY); + return Reflect.ownKeys(target); + } + + var mutableHandlers = { + get: get, + set: set, + deleteProperty: deleteProperty, + has: has, + ownKeys: ownKeys$1 + }; + var readonlyHandlers = { + get: readonlyGet, + set: function set(target, key) { + if (process.env.NODE_ENV !== 'production') { + console.warn("Set operation on key \"".concat(String(key), "\" failed: target is readonly."), target); + } + + return true; + }, + deleteProperty: function deleteProperty(target, key) { + if (process.env.NODE_ENV !== 'production') { + console.warn("Delete operation on key \"".concat(String(key), "\" failed: target is readonly."), target); + } + + return true; + } + }; + var shallowReactiveHandlers = extend({}, mutableHandlers, { + get: shallowGet, + set: shallowSet + }); // Props handlers are special in the sense that it should not unwrap top-level + // refs (in order to allow refs to be explicitly passed down), but should + // retain the reactivity of the normal readonly object. + + var shallowReadonlyHandlers = extend({}, readonlyHandlers, { + get: shallowReadonlyGet + }); + + var toReactive = function toReactive(value) { + return isObject(value) ? reactive(value) : value; + }; + + var toReadonly = function toReadonly(value) { + return isObject(value) ? readonly(value) : value; + }; + + var toShallow = function toShallow(value) { + return value; + }; + + var getProto = function getProto(v) { + return Reflect.getPrototypeOf(v); + }; + + function get$1(target, key) { + var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var isShallow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + // #1772: readonly(reactive(Map)) should return readonly + reactive version + // of the value + target = target["__v_raw" + /* RAW */ + ]; + var rawTarget = toRaw(target); + var rawKey = toRaw(key); + + if (key !== rawKey) { + !isReadonly && track(rawTarget, "get" + /* GET */ + , key); + } + + !isReadonly && track(rawTarget, "get" + /* GET */ + , rawKey); + + var _getProto = getProto(rawTarget), + has = _getProto.has; + + var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; + + if (has.call(rawTarget, key)) { + return wrap(target.get(key)); + } else if (has.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } + } + + function has$1(key) { + var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var target = this["__v_raw" + /* RAW */ + ]; + var rawTarget = toRaw(target); + var rawKey = toRaw(key); + + if (key !== rawKey) { + !isReadonly && track(rawTarget, "has" + /* HAS */ + , key); + } + + !isReadonly && track(rawTarget, "has" + /* HAS */ + , rawKey); + return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); + } + + function size(target) { + var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + target = target["__v_raw" + /* RAW */ + ]; + !isReadonly && track(toRaw(target), "iterate" + /* ITERATE */ + , ITERATE_KEY); + return Reflect.get(target, 'size', target); + } + + function add(value) { + value = toRaw(value); + var target = toRaw(this); + var proto = getProto(target); + var hadKey = proto.has.call(target, value); + target.add(value); + + if (!hadKey) { + trigger(target, "add" + /* ADD */ + , value, value); + } + + return this; + } + + function set$1(key, value) { + value = toRaw(value); + var target = toRaw(this); + + var _getProto2 = getProto(target), + has = _getProto2.has, + get = _getProto2.get; + + var hadKey = has.call(target, key); + + if (!hadKey) { + key = toRaw(key); + hadKey = has.call(target, key); + } else if (process.env.NODE_ENV !== 'production') { + checkIdentityKeys(target, has, key); + } + + var oldValue = get.call(target, key); + target.set(key, value); + + if (!hadKey) { + trigger(target, "add" + /* ADD */ + , key, value); + } else if (hasChanged(value, oldValue)) { + trigger(target, "set" + /* SET */ + , key, value, oldValue); + } + + return this; + } + + function deleteEntry(key) { + var target = toRaw(this); + + var _getProto3 = getProto(target), + has = _getProto3.has, + get = _getProto3.get; + + var hadKey = has.call(target, key); + + if (!hadKey) { + key = toRaw(key); + hadKey = has.call(target, key); + } else if (process.env.NODE_ENV !== 'production') { + checkIdentityKeys(target, has, key); + } + + var oldValue = get ? get.call(target, key) : undefined; // forward the operation before queueing reactions + + var result = target.delete(key); + + if (hadKey) { + trigger(target, "delete" + /* DELETE */ + , key, undefined, oldValue); + } + + return result; + } + + function clear() { + var target = toRaw(this); + var hadItems = target.size !== 0; + var oldTarget = process.env.NODE_ENV !== 'production' ? isMap(target) ? new Map(target) : new Set(target) : undefined; // forward the operation before queueing reactions + + var result = target.clear(); + + if (hadItems) { + trigger(target, "clear" + /* CLEAR */ + , undefined, undefined, oldTarget); + } + + return result; + } + + function createForEach(isReadonly, isShallow) { + return function forEach(callback, thisArg) { + var observed = this; + var target = observed["__v_raw" + /* RAW */ + ]; + var rawTarget = toRaw(target); + var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; + !isReadonly && track(rawTarget, "iterate" + /* ITERATE */ + , ITERATE_KEY); + return target.forEach(function (value, key) { + // important: make sure the callback is + // 1. invoked with the reactive map as `this` and 3rd arg + // 2. the value received should be a corresponding reactive/readonly. + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; + } + + function createIterableMethod(method, isReadonly, isShallow) { + return function () { + var target = this["__v_raw" + /* RAW */ + ]; + var rawTarget = toRaw(target); + var targetIsMap = isMap(rawTarget); + var isPair = method === 'entries' || method === Symbol.iterator && targetIsMap; + var isKeyOnly = method === 'keys' && targetIsMap; + var innerIterator = target[method].apply(target, arguments); + var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; + !isReadonly && track(rawTarget, "iterate" + /* ITERATE */ + , isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); // return a wrapped iterator which returns observed versions of the + // values emitted from the real iterator + + return _defineProperty({ + // iterator protocol + next: function next() { + var _innerIterator$next = innerIterator.next(), + value = _innerIterator$next.value, + done = _innerIterator$next.done; + + return done ? { + value: value, + done: done + } : { + value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), + done: done + }; + } + }, Symbol.iterator, function () { + return this; + }); + }; + } + + function createReadonlyMethod(type) { + return function () { + if (process.env.NODE_ENV !== 'production') { + var key = (arguments.length <= 0 ? undefined : arguments[0]) ? "on key \"".concat(arguments.length <= 0 ? undefined : arguments[0], "\" ") : ""; + console.warn("".concat(capitalize(type), " operation ").concat(key, "failed: target is readonly."), toRaw(this)); + } + + return type === "delete" + /* DELETE */ + ? false : this; + }; + } + + var mutableInstrumentations = { + get: function get(key) { + return get$1(this, key); + }, + + get size() { + return size(this); + }, + + has: has$1, + add: add, + set: set$1, + delete: deleteEntry, + clear: clear, + forEach: createForEach(false, false) + }; + var shallowInstrumentations = { + get: function get(key) { + return get$1(this, key, false, true); + }, + + get size() { + return size(this); + }, + + has: has$1, + add: add, + set: set$1, + delete: deleteEntry, + clear: clear, + forEach: createForEach(false, true) + }; + var readonlyInstrumentations = { + get: function get(key) { + return get$1(this, key, true); + }, + + get size() { + return size(this, true); + }, + + has: function has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod("add" + /* ADD */ + ), + set: createReadonlyMethod("set" + /* SET */ + ), + delete: createReadonlyMethod("delete" + /* DELETE */ + ), + clear: createReadonlyMethod("clear" + /* CLEAR */ + ), + forEach: createForEach(true, false) + }; + var iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]; + iteratorMethods.forEach(function (method) { + mutableInstrumentations[method] = createIterableMethod(method, false, false); + readonlyInstrumentations[method] = createIterableMethod(method, true, false); + shallowInstrumentations[method] = createIterableMethod(method, false, true); + }); + + function createInstrumentationGetter(isReadonly, shallow) { + var instrumentations = shallow ? shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations; + return function (target, key, receiver) { + if (key === "__v_isReactive" + /* IS_REACTIVE */ + ) { + return !isReadonly; + } else if (key === "__v_isReadonly" + /* IS_READONLY */ + ) { + return isReadonly; + } else if (key === "__v_raw" + /* RAW */ + ) { + return target; + } + + return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver); + }; + } + + var mutableCollectionHandlers = { + get: createInstrumentationGetter(false, false) + }; + var readonlyCollectionHandlers = { + get: createInstrumentationGetter(true, false) + }; + + function checkIdentityKeys(target, has, key) { + var rawKey = toRaw(key); + + if (rawKey !== key && has.call(target, rawKey)) { + var type = toRawType(target); + console.warn("Reactive ".concat(type, " contains both the raw and reactive ") + "versions of the same object".concat(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."); + } + } + + var reactiveMap = new WeakMap(); + var readonlyMap = 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" + /* SKIP */ + ] || !Object.isExtensible(value) ? 0 + /* INVALID */ + : targetTypeMap(toRawType(value)); + } + + function reactive(target) { + // if trying to observe a readonly proxy, return the readonly version. + if (target && target["__v_isReadonly" + /* IS_READONLY */ + ]) { + return target; + } + + return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers); + } + /** + * Creates a readonly copy of the original object. Note the returned copy is not + * made reactive, but `readonly` can be called on an already reactive object. + */ + + + function readonly(target) { + return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers); + } + /** + * Returns a reactive-copy of the original object, where only the root level + * properties are readonly, and does NOT unwrap refs nor recursively convert + * returned properties. + * This is used for creating the props proxy object for stateful components. + */ + + + function shallowReadonly(target) { + return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers); + } + + function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) { + if (!isObject(target)) { + if (process.env.NODE_ENV !== 'production') { + console.warn("value cannot be made reactive: ".concat(String(target))); + } + + return target; + } // target is already a Proxy, return it. + // exception: calling readonly() on a reactive object + + + if (target["__v_raw" + /* RAW */ + ] && !(isReadonly && target["__v_isReactive" + /* IS_REACTIVE */ + ])) { + return target; + } // target already has corresponding Proxy + + + var proxyMap = isReadonly ? readonlyMap : reactiveMap; + var existingProxy = proxyMap.get(target); + + if (existingProxy) { + return existingProxy; + } // only a whitelist of value types can be observed. + + + var targetType = getTargetType(target); + + if (targetType === 0 + /* INVALID */ + ) { + return target; + } + + var 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" + /* RAW */ + ]); + } + + return !!(value && value["__v_isReactive" + /* IS_REACTIVE */ + ]); + } + + function isReadonly(value) { + return !!(value && value["__v_isReadonly" + /* IS_READONLY */ + ]); + } + + function isProxy(value) { + return isReactive(value) || isReadonly(value); + } + + function toRaw(observed) { + return observed && toRaw(observed["__v_raw" + /* RAW */ + ]) || observed; + } + + function isRef(r) { + return Boolean(r && r.__v_isRef === true); + } + + var stack = []; + + function pushWarningContext(vnode) { + stack.push(vnode); + } + + function popWarningContext() { + stack.pop(); + } + + function warn(msg) { + // avoid props formatting or warn handler tracking deps that might be mutated + // during patch, leading to infinite recursion. + pauseTracking(); + var instance = stack.length ? stack[stack.length - 1].component : null; + var appWarnHandler = instance && instance.appContext.config.warnHandler; + var trace = getComponentTrace(); + + for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) { + args[_key3 - 1] = arguments[_key3]; + } + + if (appWarnHandler) { + callWithErrorHandling(appWarnHandler, instance, 11 + /* APP_WARN_HANDLER */ + , [msg + args.join(''), instance && instance.proxy, trace.map(function (_ref2) { + var vnode = _ref2.vnode; + return "at <".concat(formatComponentName(instance, vnode.type), ">"); + }).join('\n'), trace]); + } else { + var _console; + + var warnArgs = ["[Vue warn]: ".concat(msg)].concat(args); + /* istanbul ignore if */ + + if (trace.length && // avoid spamming console during tests + !false) { + warnArgs.push.apply(warnArgs, ["\n"].concat(_toConsumableArray(formatTrace(trace)))); + } + + (_console = console).warn.apply(_console, _toConsumableArray(warnArgs)); + } + + resetTracking(); + } + + function getComponentTrace() { + var currentVNode = stack[stack.length - 1]; + + if (!currentVNode) { + return []; + } // we can't just use the stack because it will be incomplete during updates + // that did not start from the root. Re-construct the parent chain using + // instance parent pointers. + + + var normalizedStack = []; + + while (currentVNode) { + var last = normalizedStack[0]; + + if (last && last.vnode === currentVNode) { + last.recurseCount++; + } else { + normalizedStack.push({ + vnode: currentVNode, + recurseCount: 0 + }); + } + + var parentInstance = currentVNode.component && currentVNode.component.parent; + currentVNode = parentInstance && parentInstance.vnode; + } + + return normalizedStack; + } + /* istanbul ignore next */ + + + function formatTrace(trace) { + var logs = []; + trace.forEach(function (entry, i) { + logs.push.apply(logs, _toConsumableArray(i === 0 ? [] : ["\n"]).concat(_toConsumableArray(formatTraceEntry(entry)))); + }); + return logs; + } + + function formatTraceEntry(_ref3) { + var vnode = _ref3.vnode, + recurseCount = _ref3.recurseCount; + var postfix = recurseCount > 0 ? "... (".concat(recurseCount, " recursive calls)") : ""; + var isRoot = vnode.component ? vnode.component.parent == null : false; + var open = " at <".concat(formatComponentName(vnode.component, vnode.type, isRoot)); + var close = ">" + postfix; + return vnode.props ? [open].concat(_toConsumableArray(formatProps(vnode.props)), [close]) : [open + close]; + } + /* istanbul ignore next */ + + + function formatProps(props) { + var res = []; + var keys = Object.keys(props); + keys.slice(0, 3).forEach(function (key) { + res.push.apply(res, _toConsumableArray(formatProp(key, props[key]))); + }); + + if (keys.length > 3) { + res.push(" ..."); + } + + return res; + } + /* istanbul ignore next */ + + + function formatProp(key, value, raw) { + if (isString(value)) { + value = JSON.stringify(value); + return raw ? value : ["".concat(key, "=").concat(value)]; + } else if (typeof value === 'number' || typeof value === 'boolean' || value == null) { + return raw ? value : ["".concat(key, "=").concat(value)]; + } else if (isRef(value)) { + value = formatProp(key, toRaw(value.value), true); + return raw ? value : ["".concat(key, "=Ref<"), value, ">"]; + } else if (isFunction(value)) { + return ["".concat(key, "=fn").concat(value.name ? "<".concat(value.name, ">") : "")]; + } else { + value = toRaw(value); + return raw ? value : ["".concat(key, "="), value]; + } + } + + var ErrorTypeStrings = (_ErrorTypeStrings = {}, _defineProperty(_ErrorTypeStrings, "bc" + /* BEFORE_CREATE */ + , 'beforeCreate hook'), _defineProperty(_ErrorTypeStrings, "c" + /* CREATED */ + , 'created hook'), _defineProperty(_ErrorTypeStrings, "bm" + /* BEFORE_MOUNT */ + , 'beforeMount hook'), _defineProperty(_ErrorTypeStrings, "m" + /* MOUNTED */ + , 'mounted hook'), _defineProperty(_ErrorTypeStrings, "bu" + /* BEFORE_UPDATE */ + , 'beforeUpdate hook'), _defineProperty(_ErrorTypeStrings, "u" + /* UPDATED */ + , 'updated'), _defineProperty(_ErrorTypeStrings, "bum" + /* BEFORE_UNMOUNT */ + , 'beforeUnmount hook'), _defineProperty(_ErrorTypeStrings, "um" + /* UNMOUNTED */ + , 'unmounted hook'), _defineProperty(_ErrorTypeStrings, "a" + /* ACTIVATED */ + , 'activated hook'), _defineProperty(_ErrorTypeStrings, "da" + /* DEACTIVATED */ + , 'deactivated hook'), _defineProperty(_ErrorTypeStrings, "ec" + /* ERROR_CAPTURED */ + , 'errorCaptured hook'), _defineProperty(_ErrorTypeStrings, "rtc" + /* RENDER_TRACKED */ + , 'renderTracked hook'), _defineProperty(_ErrorTypeStrings, "rtg" + /* RENDER_TRIGGERED */ + , 'renderTriggered hook'), _defineProperty(_ErrorTypeStrings, 0 + /* SETUP_FUNCTION */ + , 'setup function'), _defineProperty(_ErrorTypeStrings, 1 + /* RENDER_FUNCTION */ + , 'render function'), _defineProperty(_ErrorTypeStrings, 2 + /* WATCH_GETTER */ + , 'watcher getter'), _defineProperty(_ErrorTypeStrings, 3 + /* WATCH_CALLBACK */ + , 'watcher callback'), _defineProperty(_ErrorTypeStrings, 4 + /* WATCH_CLEANUP */ + , 'watcher cleanup function'), _defineProperty(_ErrorTypeStrings, 5 + /* NATIVE_EVENT_HANDLER */ + , 'native event handler'), _defineProperty(_ErrorTypeStrings, 6 + /* COMPONENT_EVENT_HANDLER */ + , 'component event handler'), _defineProperty(_ErrorTypeStrings, 7 + /* VNODE_HOOK */ + , 'vnode hook'), _defineProperty(_ErrorTypeStrings, 8 + /* DIRECTIVE_HOOK */ + , 'directive hook'), _defineProperty(_ErrorTypeStrings, 9 + /* TRANSITION_HOOK */ + , 'transition hook'), _defineProperty(_ErrorTypeStrings, 10 + /* APP_ERROR_HANDLER */ + , 'app errorHandler'), _defineProperty(_ErrorTypeStrings, 11 + /* APP_WARN_HANDLER */ + , 'app warnHandler'), _defineProperty(_ErrorTypeStrings, 12 + /* FUNCTION_REF */ + , 'ref function'), _defineProperty(_ErrorTypeStrings, 13 + /* ASYNC_COMPONENT_LOADER */ + , 'async component loader'), _defineProperty(_ErrorTypeStrings, 14 + /* SCHEDULER */ + , 'scheduler flush. This is likely a Vue internals bug. ' + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'), _ErrorTypeStrings); + + function callWithErrorHandling(fn, instance, type, args) { + var res; + + try { + res = args ? fn.apply(void 0, _toConsumableArray(args)) : fn(); + } catch (err) { + handleError(err, instance, type); + } + + return res; + } + + function callWithAsyncErrorHandling(fn, instance, type, args) { + if (isFunction(fn)) { + var res = callWithErrorHandling(fn, instance, type, args); + + if (res && isPromise(res)) { + res.catch(function (err) { + handleError(err, instance, type); + }); + } + + return res; + } + + var values = []; + + for (var i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); + } + + return values; + } + + function handleError(err, instance, type) { + var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + var contextVNode = instance ? instance.vnode : null; + + if (instance) { + var cur = instance.parent; // the exposed instance is the render proxy to keep it consistent with 2.x + + var exposedInstance = instance.proxy; // in production the hook receives only the error code + + var errorInfo = process.env.NODE_ENV !== 'production' ? ErrorTypeStrings[type] : type; + + while (cur) { + var errorCapturedHooks = cur.ec; + + if (errorCapturedHooks) { + for (var i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { + return; + } + } + } + + cur = cur.parent; + } // app-level handling + + + var appErrorHandler = instance.appContext.config.errorHandler; + + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10 + /* APP_ERROR_HANDLER */ + , [err, exposedInstance, errorInfo]); + return; + } + } + + logError(err, type, contextVNode, throwInDev); + } + + function logError(err, type, contextVNode) { + var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + + if (process.env.NODE_ENV !== 'production') { + var info = ErrorTypeStrings[type]; + + if (contextVNode) { + pushWarningContext(contextVNode); + } + + warn("Unhandled error".concat(info ? " during execution of ".concat(info) : "")); + + if (contextVNode) { + popWarningContext(); + } // crash in dev by default so it's more noticeable + + + if (throwInDev) { + throw err; + } else { + console.error(err); + } + } else { + // recover in prod to reduce the impact on end-user + console.error(err); + } + } + + var isFlushing = false; + var isFlushPending = false; + var queue = []; + var flushIndex = 0; + var pendingPreFlushCbs = []; + var activePreFlushCbs = null; + var preFlushIndex = 0; + var pendingPostFlushCbs = []; + var activePostFlushCbs = null; + var postFlushIndex = 0; + var resolvedPromise = Promise.resolve(); + var currentFlushPromise = null; + var currentPreFlushParentJob = null; + var RECURSION_LIMIT = 100; + + function nextTick(fn) { + var p = currentFlushPromise || resolvedPromise; + return fn ? p.then(this ? fn.bind(this) : fn) : p; + } + + function queueJob(job) { + // the dedupe search uses the startIndex argument of Array.includes() + // by default the search index includes the current job that is being run + // so it cannot recursively trigger itself again. + // if the job is a watch() callback, the search will start with a +1 index to + // allow it recursively trigger itself - it is the user's responsibility to + // ensure it doesn't end up in an infinite loop. + if ((!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && job !== currentPreFlushParentJob) { + queue.push(job); + queueFlush(); + } + } + + function queueFlush() { + if (!isFlushing && !isFlushPending) { + isFlushPending = true; + currentFlushPromise = resolvedPromise.then(flushJobs); + } + } + + function queueCb(cb, activeQueue, pendingQueue, index) { + if (!isArray(cb)) { + if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { + pendingQueue.push(cb); + } + } else { + // if cb is an array, it is a component lifecycle hook which can only be + // triggered by a job, which is already deduped in the main queue, so + // we can skip duplicate check here to improve perf + pendingQueue.push.apply(pendingQueue, _toConsumableArray(cb)); + } + + queueFlush(); + } + + function queuePreFlushCb(cb) { + queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); + } + + function queuePostFlushCb(cb) { + queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); + } + + function flushPreFlushCbs(seen) { + var parentJob = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + + if (pendingPreFlushCbs.length) { + currentPreFlushParentJob = parentJob; + activePreFlushCbs = _toConsumableArray(new Set(pendingPreFlushCbs)); + pendingPreFlushCbs.length = 0; + + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map(); + } + + for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { + if (process.env.NODE_ENV !== 'production') { + checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]); + } + + activePreFlushCbs[preFlushIndex](); + } + + activePreFlushCbs = null; + preFlushIndex = 0; + currentPreFlushParentJob = null; // recursively flush until it drains + + flushPreFlushCbs(seen, parentJob); + } + } + + function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + var deduped = _toConsumableArray(new Set(pendingPostFlushCbs)); + + pendingPostFlushCbs.length = 0; // #1947 already has active queue, nested flushPostFlushCbs call + + if (activePostFlushCbs) { + var _activePostFlushCbs; + + (_activePostFlushCbs = activePostFlushCbs).push.apply(_activePostFlushCbs, _toConsumableArray(deduped)); + + return; + } + + activePostFlushCbs = deduped; + + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map(); + } + + activePostFlushCbs.sort(function (a, b) { + return getId(a) - getId(b); + }); + + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + if (process.env.NODE_ENV !== 'production') { + checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]); + } + + activePostFlushCbs[postFlushIndex](); + } + + activePostFlushCbs = null; + postFlushIndex = 0; + } + } + + var getId = function getId(job) { + return job.id == null ? Infinity : job.id; + }; + + function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map(); + } + + flushPreFlushCbs(seen); // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child so its render effect will have smaller + // priority number) + // 2. If a component is unmounted during a parent component's update, + // its update can be skipped. + + queue.sort(function (a, b) { + return getId(a) - getId(b); + }); + + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + var job = queue[flushIndex]; + + if (job) { + if (process.env.NODE_ENV !== 'production') { + checkRecursiveUpdates(seen, job); + } + + callWithErrorHandling(job, null, 14 + /* SCHEDULER */ + ); + } + } + } finally { + flushIndex = 0; + queue.length = 0; + flushPostFlushCbs(seen); + isFlushing = false; + currentFlushPromise = null; // some postFlushCb queued jobs! + // keep flushing until it drains. + + if (queue.length || pendingPostFlushCbs.length) { + flushJobs(seen); + } + } + } + + function checkRecursiveUpdates(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } else { + var count = seen.get(fn); + + if (count > RECURSION_LIMIT) { + throw new Error("Maximum recursive updates exceeded. " + "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."); + } else { + seen.set(fn, count + 1); + } + } + } + + var hmrDirtyComponents = new Set(); // Expose the HMR runtime on the global object + // This makes it entirely tree-shakable without polluting the exports and makes + // it easier to be used in toolings like vue-loader + // Note: for a component to be eligible for HMR it also needs the __hmrId option + // to be set so that its instances can be registered / removed. + + if (process.env.NODE_ENV !== 'production') { + var globalObject = typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {}; + globalObject.__VUE_HMR_RUNTIME__ = { + createRecord: tryWrap(createRecord), + rerender: tryWrap(rerender), + reload: tryWrap(reload) + }; + } + + var map = new Map(); + + function createRecord(id, component) { + if (!component) { + warn("HMR API usage is out of date.\n" + "Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant " + "depdendency that handles Vue SFC compilation."); + component = {}; + } + + if (map.has(id)) { + return false; + } + + map.set(id, { + component: isClassComponent(component) ? component.__vccOpts : component, + instances: new Set() + }); + return true; + } + + function rerender(id, newRender) { + var record = map.get(id); + if (!record) return; + if (newRender) record.component.render = newRender; // Array.from creates a snapshot which avoids the set being mutated during + // updates + + Array.from(record.instances).forEach(function (instance) { + if (newRender) { + instance.render = newRender; + } + + instance.renderCache = []; + instance.update(); + }); + } + + function reload(id, newComp) { + var record = map.get(id); + if (!record) return; // Array.from creates a snapshot which avoids the set being mutated during + // updates + + var component = record.component, + instances = record.instances; + + if (!hmrDirtyComponents.has(component)) { + // 1. Update existing comp definition to match new one + newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp; + extend(component, newComp); + + for (var key in component) { + if (!(key in newComp)) { + delete component[key]; + } + } // 2. Mark component dirty. This forces the renderer to replace the component + // on patch. + + + hmrDirtyComponents.add(component); // 3. Make sure to unmark the component after the reload. + + queuePostFlushCb(function () { + hmrDirtyComponents.delete(component); + }); + } + + Array.from(instances).forEach(function (instance) { + if (instance.parent) { + // 4. Force the parent instance to re-render. This will cause all updated + // components to be unmounted and re-mounted. Queue the update so that we + // don't end up forcing the same parent to re-render multiple times. + queueJob(instance.parent.update); + } else if (instance.appContext.reload) { + // root instance mounted via createApp() has a reload method + instance.appContext.reload(); + } else if (typeof window !== 'undefined') { + // root instance inside tree created via raw render(). Force reload. + window.location.reload(); + } else { + console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); + } + }); + } + + function tryWrap(fn) { + return function (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."); + } + }; + } + + function setDevtoolsHook(hook) {} + /** + * mark the current rendering instance for asset resolution (e.g. + * resolveComponent, resolveDirective) during render + */ + + + var currentRenderingInstance = null; + + function setCurrentRenderingInstance(instance) { + currentRenderingInstance = instance; + } + + function markAttrsAccessed() {} + + function filterSingleRoot(children) { + var singleRoot; + + for (var i = 0; i < children.length; i++) { + var child = children[i]; + + if (isVNode(child)) { + // ignore user comment + if (child.type !== Comment || child.children === 'v-if') { + if (singleRoot) { + // has more than 1 non-comment child, return now + return; + } else { + singleRoot = child; + } + } + } else { + return; + } + } + + return singleRoot; + } + + var isSuspense = function isSuspense(type) { + return type.__isSuspense; + }; + + function normalizeSuspenseChildren(vnode) { + var shapeFlag = vnode.shapeFlag, + children = vnode.children; + var content; + var fallback; + + if (shapeFlag & 32 + /* SLOTS_CHILDREN */ + ) { + content = normalizeSuspenseSlot(children.default); + fallback = normalizeSuspenseSlot(children.fallback); + } else { + content = normalizeSuspenseSlot(children); + fallback = normalizeVNode(null); + } + + return { + content: content, + fallback: fallback + }; + } + + function normalizeSuspenseSlot(s) { + if (isFunction(s)) { + s = s(); + } + + if (isArray(s)) { + var singleChild = filterSingleRoot(s); + + if (process.env.NODE_ENV !== 'production' && !singleChild) { + warn(" slots expect a single root node."); + } + + s = singleChild; + } + + return normalizeVNode(s); + } + + function queueEffectWithSuspense(fn, suspense) { + if (suspense && suspense.pendingBranch) { + if (isArray(fn)) { + var _suspense$effects; + + (_suspense$effects = suspense.effects).push.apply(_suspense$effects, _toConsumableArray(fn)); + } else { + suspense.effects.push(fn); + } + } else { + queuePostFlushCb(fn); + } + } + + var isRenderingCompiledSlot = 0; + + var setCompiledSlotRendering = function setCompiledSlotRendering(n) { + return isRenderingCompiledSlot += n; + }; + /** + * Wrap a slot function to memoize current rendering instance + * @private + */ + + + function withCtx(fn) { + var ctx = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentRenderingInstance; + if (!ctx) return fn; + + var renderFnWithContext = function renderFnWithContext() { + // If a user calls a compiled slot inside a template expression (#1745), it + // can mess up block tracking, so by default we need to push a null block to + // avoid that. This isn't necessary if rendering a compiled ``. + if (!isRenderingCompiledSlot) { + openBlock(true + /* null block that disables tracking */ + ); + } + + var owner = currentRenderingInstance; + setCurrentRenderingInstance(ctx); + var res = fn.apply(void 0, arguments); + setCurrentRenderingInstance(owner); + + if (!isRenderingCompiledSlot) { + closeBlock(); + } + + return res; + }; + + renderFnWithContext._c = true; + return renderFnWithContext; + } // SFC scoped style ID management. + + + var currentScopeId = null; + var scopeIdStack = []; + /** + * @private + */ + + function pushScopeId(id) { + scopeIdStack.push(currentScopeId = id); + } + /** + * @private + */ + + + function popScopeId() { + scopeIdStack.pop(); + currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null; + } + /** + * @private + */ + + + function withScopeId(id) { + return function (fn) { + return withCtx(function () { + pushScopeId(id); + var res = fn.apply(this, arguments); + popScopeId(); + return res; + }); + }; + } // initial value for watchers to trigger on undefined initial values + + + var INITIAL_WATCHER_VALUE = {}; + + function doWatch(source, cb) { + var _ref4 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_OBJ, + immediate = _ref4.immediate, + deep = _ref4.deep, + flush = _ref4.flush, + onTrack = _ref4.onTrack, + onTrigger = _ref4.onTrigger; + + var instance = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : currentInstance; + + if (process.env.NODE_ENV !== 'production' && !cb) { + if (immediate !== undefined) { + warn("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature."); + } + + if (deep !== undefined) { + warn("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature."); + } + } + + var warnInvalidSource = function warnInvalidSource(s) { + 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."); + }; + + var getter; + var forceTrigger = false; + + if (isRef(source)) { + getter = function getter() { + return source.value; + }; + + forceTrigger = !!source._shallow; + } else if (isReactive(source)) { + getter = function getter() { + return source; + }; + + deep = true; + } else if (isArray(source)) { + getter = function getter() { + return source.map(function (s) { + if (isRef(s)) { + return s.value; + } else if (isReactive(s)) { + return traverse(s); + } else if (isFunction(s)) { + return callWithErrorHandling(s, instance, 2 + /* WATCH_GETTER */ + ); + } else { + process.env.NODE_ENV !== 'production' && warnInvalidSource(s); + } + }); + }; + } else if (isFunction(source)) { + if (cb) { + // getter with cb + getter = function getter() { + return callWithErrorHandling(source, instance, 2 + /* WATCH_GETTER */ + ); + }; + } else { + // no cb -> simple effect + getter = function getter() { + if (instance && instance.isUnmounted) { + return; + } + + if (cleanup) { + cleanup(); + } + + return callWithErrorHandling(source, instance, 3 + /* WATCH_CALLBACK */ + , [onInvalidate]); + }; + } + } else { + getter = NOOP; + process.env.NODE_ENV !== 'production' && warnInvalidSource(source); + } + + if (cb && deep) { + var baseGetter = getter; + + getter = function getter() { + return traverse(baseGetter()); + }; + } + + var cleanup; + + var onInvalidate = function onInvalidate(fn) { + cleanup = runner.options.onStop = function () { + callWithErrorHandling(fn, instance, 4 + /* WATCH_CLEANUP */ + ); + }; + }; + + var oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE; + + var job = function job() { + if (!runner.active) { + return; + } + + if (cb) { + // watch(source, cb) + var newValue = runner(); + + if (deep || forceTrigger || hasChanged(newValue, oldValue)) { + // cleanup before running cb again + if (cleanup) { + cleanup(); + } + + callWithAsyncErrorHandling(cb, instance, 3 + /* WATCH_CALLBACK */ + , [newValue, // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, onInvalidate]); + oldValue = newValue; + } + } else { + // watchEffect + runner(); + } + }; // important: mark the job as a watcher callback so that scheduler knows + // it is allowed to self-trigger (#1727) + + + job.allowRecurse = !!cb; + var scheduler; + + if (flush === 'sync') { + scheduler = job; + } else if (flush === 'post') { + scheduler = function scheduler() { + return queuePostRenderEffect(job, instance && instance.suspense); + }; + } else { + // default: 'pre' + scheduler = function scheduler() { + if (!instance || instance.isMounted) { + queuePreFlushCb(job); + } else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job(); + } + }; + } + + var runner = effect(getter, { + lazy: true, + onTrack: onTrack, + onTrigger: onTrigger, + scheduler: scheduler + }); + recordInstanceBoundEffect(runner, instance); // initial run + + if (cb) { + if (immediate) { + job(); + } else { + oldValue = runner(); + } + } else if (flush === 'post') { + queuePostRenderEffect(runner, instance && instance.suspense); + } else { + runner(); + } + + return function () { + stop(runner); + + if (instance) { + remove(instance.effects, runner); + } + }; + } // this.$watch + + + function instanceWatch(source, cb, options) { + var publicThis = this.proxy; + var getter = isString(source) ? function () { + return publicThis[source]; + } : source.bind(publicThis); + return doWatch(getter, cb.bind(publicThis), options, this); + } + + function traverse(value) { + var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set(); + + if (!isObject(value) || seen.has(value)) { + return value; + } + + seen.add(value); + + if (isRef(value)) { + traverse(value.value, seen); + } else if (isArray(value)) { + for (var i = 0; i < value.length; i++) { + traverse(value[i], seen); + } + } else if (isSet(value) || isMap(value)) { + value.forEach(function (v) { + traverse(v, seen); + }); + } else { + for (var key in value) { + traverse(value[key], seen); + } + } + + return value; + } + + var queuePostRenderEffect = queueEffectWithSuspense; + + var isTeleport = function isTeleport(type) { + return type.__isTeleport; + }; + + var NULL_DYNAMIC_COMPONENT = Symbol(); + var Fragment = Symbol(process.env.NODE_ENV !== 'production' ? 'Fragment' : undefined); + var Text = Symbol(process.env.NODE_ENV !== 'production' ? 'Text' : undefined); + var Comment = Symbol(process.env.NODE_ENV !== 'production' ? 'Comment' : undefined); + var Static = Symbol(process.env.NODE_ENV !== 'production' ? 'Static' : undefined); // Since v-if and v-for are the two possible ways node structure can dynamically + // change, once we consider v-if branches and each v-for fragment a block, we + // can divide a template into nested blocks, and within each block the node + // structure would be stable. This allows us to skip most children diffing + // and only worry about the dynamic nodes (indicated by patch flags). + + var blockStack = []; + var currentBlock = null; + /** + * Open a block. + * This must be called before `createBlock`. It cannot be part of `createBlock` + * because the children of the block are evaluated before `createBlock` itself + * is called. The generated code typically looks like this: + * + * ```js + * function render() { + * return (openBlock(),createBlock('div', null, [...])) + * } + * ``` + * disableTracking is true when creating a v-for fragment block, since a v-for + * fragment always diffs its children. + * + * @private + */ + + function openBlock() { + var disableTracking = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + blockStack.push(currentBlock = disableTracking ? null : []); + } + + function closeBlock() { + blockStack.pop(); + currentBlock = blockStack[blockStack.length - 1] || null; + } + /** + * Create a block root vnode. Takes the same exact arguments as `createVNode`. + * A block root keeps track of dynamic nodes within the block in the + * `dynamicChildren` array. + * + * @private + */ + + + function createBlock(type, props, children, patchFlag, dynamicProps) { + var vnode = createVNode(type, props, children, patchFlag, dynamicProps, true + /* isBlock: prevent a block from tracking itself */ + ); // save current block children on the block vnode + + vnode.dynamicChildren = currentBlock || EMPTY_ARR; // close block + + closeBlock(); // a block is always going to be patched, so track it as a child of its + // parent block + + if (currentBlock) { + currentBlock.push(vnode); + } + + return vnode; + } + + function isVNode(value) { + return value ? value.__v_isVNode === true : false; + } + + var createVNodeWithArgsTransform = function createVNodeWithArgsTransform() { + return _createVNode.apply(void 0, arguments); + }; + + var InternalObjectKey = "__vInternal"; + + var normalizeKey = function normalizeKey(_ref5) { + var key = _ref5.key; + return key != null ? key : null; + }; + + var normalizeRef = function normalizeRef(_ref6) { + var ref = _ref6.ref; + return ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? { + i: currentRenderingInstance, + r: ref + } : ref : null; + }; + + var createVNode = process.env.NODE_ENV !== 'production' ? createVNodeWithArgsTransform : _createVNode; + + function _createVNode(type) { + var _vnode; + + var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + var children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; + var patchFlag = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0; + var dynamicProps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null; + var isBlockNode = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false; + + if (!type || type === NULL_DYNAMIC_COMPONENT) { + if (process.env.NODE_ENV !== 'production' && !type) { + warn("Invalid vnode type when creating vnode: ".concat(type, ".")); + } + + type = Comment; + } + + if (isVNode(type)) { + // createVNode receiving an existing vnode. This happens in cases like + // + // #2078 make sure to merge refs during the clone instead of overwriting it + var cloned = cloneVNode(type, props, true + /* mergeRef: true */ + ); + + if (children) { + normalizeChildren(cloned, children); + } + + return cloned; + } // class component normalization. + + + if (isClassComponent(type)) { + type = type.__vccOpts; + } // class & style normalization. + + + if (props) { + // for reactive or proxy objects, we need to clone it to enable mutation. + if (isProxy(props) || InternalObjectKey in props) { + props = extend({}, props); + } + + var _props = props, + klass = _props.class, + style = _props.style; + + if (klass && !isString(klass)) { + props.class = normalizeClass(klass); + } + + if (isObject(style)) { + // reactive state objects need to be cloned since they are likely to be + // mutated + if (isProxy(style) && !isArray(style)) { + style = extend({}, style); + } + + props.style = normalizeStyle(style); + } + } // encode the vnode type information into a bitmap + + + var shapeFlag = isString(type) ? 1 + /* ELEMENT */ + : isSuspense(type) ? 128 + /* SUSPENSE */ + : isTeleport(type) ? 64 + /* TELEPORT */ + : isObject(type) ? 4 + /* STATEFUL_COMPONENT */ + : isFunction(type) ? 2 + /* FUNCTIONAL_COMPONENT */ + : 0; + + if (process.env.NODE_ENV !== 'production' && shapeFlag & 4 + /* STATEFUL_COMPONENT */ + && isProxy(type)) { + type = toRaw(type); + warn("Vue received a Component which was made a reactive object. This can " + "lead to unnecessary performance overhead, and should be avoided by " + "marking the component with `markRaw` or using `shallowRef` " + "instead of `ref`.", "\nComponent that was made reactive: ", type); + } + + var vnode = (_vnode = { + __v_isVNode: true + }, _defineProperty(_vnode, "__v_skip" + /* SKIP */ + , true), _defineProperty(_vnode, "type", type), _defineProperty(_vnode, "props", props), _defineProperty(_vnode, "key", props && normalizeKey(props)), _defineProperty(_vnode, "ref", props && normalizeRef(props)), _defineProperty(_vnode, "scopeId", currentScopeId), _defineProperty(_vnode, "children", null), _defineProperty(_vnode, "component", null), _defineProperty(_vnode, "suspense", null), _defineProperty(_vnode, "ssContent", null), _defineProperty(_vnode, "ssFallback", null), _defineProperty(_vnode, "dirs", null), _defineProperty(_vnode, "transition", null), _defineProperty(_vnode, "el", null), _defineProperty(_vnode, "anchor", null), _defineProperty(_vnode, "target", null), _defineProperty(_vnode, "targetAnchor", null), _defineProperty(_vnode, "staticCount", 0), _defineProperty(_vnode, "shapeFlag", shapeFlag), _defineProperty(_vnode, "patchFlag", patchFlag), _defineProperty(_vnode, "dynamicProps", dynamicProps), _defineProperty(_vnode, "dynamicChildren", null), _defineProperty(_vnode, "appContext", null), _vnode); // validate key + + if (process.env.NODE_ENV !== 'production' && vnode.key !== vnode.key) { + warn("VNode created with invalid key (NaN). VNode type:", vnode.type); + } + + normalizeChildren(vnode, children); // normalize suspense children + + if (shapeFlag & 128 + /* SUSPENSE */ + ) { + var _normalizeSuspenseChi = normalizeSuspenseChildren(vnode), + content = _normalizeSuspenseChi.content, + fallback = _normalizeSuspenseChi.fallback; + + vnode.ssContent = content; + vnode.ssFallback = fallback; + } + + if ( // avoid a block node from tracking itself + !isBlockNode && // has current parent block + currentBlock && ( // presence of a patch flag indicates this node needs patching on updates. + // component nodes also should always be patched, because even if the + // component doesn't need to update, it needs to persist the instance on to + // the next vnode so that it can be properly unmounted later. + patchFlag > 0 || shapeFlag & 6 + /* COMPONENT */ + ) && // the EVENTS flag is only for hydration and if it is the only flag, the + // vnode should not be considered dynamic due to handler caching. + patchFlag !== 32 + /* HYDRATE_EVENTS */ + ) { + currentBlock.push(vnode); + } + + return vnode; + } + + function cloneVNode(vnode, extraProps) { + var _ref7; + + var mergeRef = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + // This is intentionally NOT using spread or extend to avoid the runtime + // key enumeration cost. + var props = vnode.props, + ref = vnode.ref, + patchFlag = vnode.patchFlag; + var mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props; + return _ref7 = { + __v_isVNode: true + }, _defineProperty(_ref7, "__v_skip" + /* SKIP */ + , true), _defineProperty(_ref7, "type", vnode.type), _defineProperty(_ref7, "props", mergedProps), _defineProperty(_ref7, "key", mergedProps && normalizeKey(mergedProps)), _defineProperty(_ref7, "ref", extraProps && extraProps.ref ? // #2078 in the case of + // if the vnode itself already has a ref, cloneVNode will need to merge + // the refs so the single vnode can be set on multiple refs + mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref), _defineProperty(_ref7, "scopeId", vnode.scopeId), _defineProperty(_ref7, "children", vnode.children), _defineProperty(_ref7, "target", vnode.target), _defineProperty(_ref7, "targetAnchor", vnode.targetAnchor), _defineProperty(_ref7, "staticCount", vnode.staticCount), _defineProperty(_ref7, "shapeFlag", vnode.shapeFlag), _defineProperty(_ref7, "patchFlag", extraProps && vnode.type !== Fragment ? patchFlag === -1 // hoisted node + ? 16 + /* FULL_PROPS */ + : patchFlag | 16 + /* FULL_PROPS */ + : patchFlag), _defineProperty(_ref7, "dynamicProps", vnode.dynamicProps), _defineProperty(_ref7, "dynamicChildren", vnode.dynamicChildren), _defineProperty(_ref7, "appContext", vnode.appContext), _defineProperty(_ref7, "dirs", vnode.dirs), _defineProperty(_ref7, "transition", vnode.transition), _defineProperty(_ref7, "component", vnode.component), _defineProperty(_ref7, "suspense", vnode.suspense), _defineProperty(_ref7, "ssContent", vnode.ssContent && cloneVNode(vnode.ssContent)), _defineProperty(_ref7, "ssFallback", vnode.ssFallback && cloneVNode(vnode.ssFallback)), _defineProperty(_ref7, "el", vnode.el), _defineProperty(_ref7, "anchor", vnode.anchor), _ref7; + } + /** + * @private + */ + + + function createTextVNode() { + var text = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ' '; + var flag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + return createVNode(Text, null, text, flag); + } + + function normalizeVNode(child) { + if (child == null || typeof child === 'boolean') { + // empty placeholder + return createVNode(Comment); + } else if (isArray(child)) { + // fragment + return createVNode(Fragment, null, child); + } else if (_typeof(child) === 'object') { + // already vnode, this should be the most common since compiled templates + // always produce all-vnode children arrays + return child.el === null ? child : cloneVNode(child); + } else { + // strings and numbers + return createVNode(Text, null, String(child)); + } + } + + function normalizeChildren(vnode, children) { + var type = 0; + var shapeFlag = vnode.shapeFlag; + + if (children == null) { + children = null; + } else if (isArray(children)) { + type = 16 + /* ARRAY_CHILDREN */ + ; + } else if (_typeof(children) === 'object') { + if (shapeFlag & 1 + /* ELEMENT */ + || shapeFlag & 64 + /* TELEPORT */ + ) { + // Normalize slot to plain children for plain element and Teleport + var slot = children.default; + + if (slot) { + // _c marker is added by withCtx() indicating this is a compiled slot + slot._c && setCompiledSlotRendering(1); + normalizeChildren(vnode, slot()); + slot._c && setCompiledSlotRendering(-1); + } + + return; + } else { + type = 32 + /* SLOTS_CHILDREN */ + ; + var slotFlag = children._; + + if (!slotFlag && !(InternalObjectKey in children)) { + children._ctx = currentRenderingInstance; + } else if (slotFlag === 3 + /* FORWARDED */ + && currentRenderingInstance) { + // a child component receives forwarded slots from the parent. + // its slot type is determined by its parent's slot type. + if (currentRenderingInstance.vnode.patchFlag & 1024 + /* DYNAMIC_SLOTS */ + ) { + children._ = 2 + /* DYNAMIC */ + ; + vnode.patchFlag |= 1024 + /* DYNAMIC_SLOTS */ + ; + } else { + children._ = 1 + /* STABLE */ + ; + } + } + } + } else if (isFunction(children)) { + children = { + default: children, + _ctx: currentRenderingInstance + }; + type = 32 + /* SLOTS_CHILDREN */ + ; + } else { + children = String(children); // force teleport children to array so it can be moved around + + if (shapeFlag & 64 + /* TELEPORT */ + ) { + type = 16 + /* ARRAY_CHILDREN */ + ; + children = [createTextVNode(children)]; + } else { + type = 8 + /* TEXT_CHILDREN */ + ; + } + } + + vnode.children = children; + vnode.shapeFlag |= type; + } + + function mergeProps() { + var ret = extend({}, arguments.length <= 0 ? undefined : arguments[0]); + + for (var i = 1; i < arguments.length; i++) { + var toMerge = i < 0 || arguments.length <= i ? undefined : arguments[i]; + + for (var key in toMerge) { + if (key === 'class') { + if (ret.class !== toMerge.class) { + ret.class = normalizeClass([ret.class, toMerge.class]); + } + } else if (key === 'style') { + ret.style = normalizeStyle([ret.style, toMerge.style]); + } else if (isOn(key)) { + var existing = ret[key]; + var incoming = toMerge[key]; + + if (existing !== incoming) { + ret[key] = existing ? [].concat(existing, toMerge[key]) : incoming; + } + } else if (key !== '') { + ret[key] = toMerge[key]; + } + } + } + + return ret; + } + + var isInBeforeCreate = false; + + function resolveMergedOptions(instance) { + var raw = instance.type; + var __merged = raw.__merged, + mixins = raw.mixins, + extendsOptions = raw.extends; + if (__merged) return __merged; + var globalMixins = instance.appContext.mixins; + if (!globalMixins.length && !mixins && !extendsOptions) return raw; + var options = {}; + globalMixins.forEach(function (m) { + return mergeOptions(options, m, instance); + }); + mergeOptions(options, raw, instance); + return raw.__merged = options; + } + + function mergeOptions(to, from, instance) { + var strats = instance.appContext.config.optionMergeStrategies; + var mixins = from.mixins, + extendsOptions = from.extends; + extendsOptions && mergeOptions(to, extendsOptions, instance); + mixins && mixins.forEach(function (m) { + return mergeOptions(to, m, instance); + }); + + for (var key in from) { + if (strats && hasOwn(strats, key)) { + to[key] = strats[key](to[key], from[key], instance.proxy, key); + } else { + to[key] = from[key]; + } + } + } + /** + * #2437 In Vue 3, functional components do not have a public instance proxy but + * they exist in the internal parent chain. For code that relies on traversing + * public $parent chains, skip functional ones and go to the parent instead. + */ + + + var getPublicInstance = function getPublicInstance(i) { + return i && (i.proxy ? i.proxy : getPublicInstance(i.parent)); + }; + + var publicPropertiesMap = extend(Object.create(null), { + $: function $(i) { + return i; + }, + $el: function $el(i) { + return i.vnode.el; + }, + $data: function $data(i) { + return i.data; + }, + $props: function $props(i) { + return process.env.NODE_ENV !== 'production' ? shallowReadonly(i.props) : i.props; + }, + $attrs: function $attrs(i) { + return process.env.NODE_ENV !== 'production' ? shallowReadonly(i.attrs) : i.attrs; + }, + $slots: function $slots(i) { + return process.env.NODE_ENV !== 'production' ? shallowReadonly(i.slots) : i.slots; + }, + $refs: function $refs(i) { + return process.env.NODE_ENV !== 'production' ? shallowReadonly(i.refs) : i.refs; + }, + $parent: function $parent(i) { + return getPublicInstance(i.parent); + }, + $root: function $root(i) { + return i.root && i.root.proxy; + }, + $emit: function $emit(i) { + return i.emit; + }, + $options: function $options(i) { + return __VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type; + }, + $forceUpdate: function $forceUpdate(i) { + return function () { + return queueJob(i.update); + }; + }, + $nextTick: function $nextTick(i) { + return nextTick.bind(i.proxy); + }, + $watch: function $watch(i) { + return __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP; + } + }); + var PublicInstanceProxyHandlers = { + get: function get(_ref8, key) { + var instance = _ref8._; + var ctx = instance.ctx, + setupState = instance.setupState, + data = instance.data, + props = instance.props, + accessCache = instance.accessCache, + type = instance.type, + appContext = instance.appContext; // let @vue/reactivity know it should never observe Vue public instances. + + if (key === "__v_skip" + /* SKIP */ + ) { + return true; + } // for internal formatters to know that this is a Vue instance + + + if (process.env.NODE_ENV !== 'production' && key === '__isVue') { + return true; + } // data / props / ctx + // This getter gets called for every property access on the render context + // during render and is a major hotspot. The most expensive part of this + // is the multiple hasOwn() calls. It's much faster to do a simple property + // access on a plain object, so we use an accessCache object (with null + // prototype) to memoize what access type a key corresponds to. + + + var normalizedProps; + + if (key[0] !== '$') { + var n = accessCache[key]; + + if (n !== undefined) { + switch (n) { + case 0 + /* SETUP */ + : + return setupState[key]; + + case 1 + /* DATA */ + : + return data[key]; + + case 3 + /* CONTEXT */ + : + return ctx[key]; + + case 2 + /* PROPS */ + : + return props[key]; + // default: just fallthrough + } + } else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + accessCache[key] = 0 + /* SETUP */ + ; + return setupState[key]; + } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + accessCache[key] = 1 + /* DATA */ + ; + return data[key]; + } else if ( // only cache other properties when instance has declared (thus stable) + // props + (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)) { + accessCache[key] = 2 + /* PROPS */ + ; + return props[key]; + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 3 + /* CONTEXT */ + ; + return ctx[key]; + } else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) { + accessCache[key] = 4 + /* OTHER */ + ; + } + } + + var publicGetter = publicPropertiesMap[key]; + var cssModule, globalProperties; // public $xxx properties + + if (publicGetter) { + if (key === '$attrs') { + track(instance, "get" + /* GET */ + , key); + process.env.NODE_ENV !== 'production' && markAttrsAccessed(); + } + + return publicGetter(instance); + } else if ( // css module (injected by vue-loader) + (cssModule = type.__cssModules) && (cssModule = cssModule[key])) { + return cssModule; + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + // user may set custom properties to `this` that start with `$` + accessCache[key] = 3 + /* CONTEXT */ + ; + return ctx[key]; + } else if ( // global properties + globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) { + return globalProperties[key]; + } else if (process.env.NODE_ENV !== 'production' && currentRenderingInstance && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading + // to infinite warning loop + key.indexOf('__v') !== 0)) { + if (data !== EMPTY_OBJ && (key[0] === '$' || key[0] === '_') && hasOwn(data, key)) { + warn("Property ".concat(JSON.stringify(key), " must be accessed via $data because it starts with a reserved ") + "character (\"$\" or \"_\") and is not proxied on the render context."); + } else { + warn("Property ".concat(JSON.stringify(key), " was accessed during render ") + "but is not defined on instance."); + } + } + }, + set: function set(_ref9, key, value) { + var instance = _ref9._; + var data = instance.data, + setupState = instance.setupState, + ctx = instance.ctx; + + if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + setupState[key] = value; + } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + data[key] = value; + } else if (key in instance.props) { + process.env.NODE_ENV !== 'production' && warn("Attempting to mutate prop \"".concat(key, "\". Props are readonly."), instance); + return false; + } + + if (key[0] === '$' && key.slice(1) in instance) { + process.env.NODE_ENV !== 'production' && warn("Attempting to mutate public property \"".concat(key, "\". ") + "Properties starting with $ are reserved and readonly.", instance); + return false; + } else { + if (process.env.NODE_ENV !== 'production' && key in instance.appContext.config.globalProperties) { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + value: value + }); + } else { + ctx[key] = value; + } + } + + return true; + }, + has: function has(_ref10, key) { + var _ref10$_ = _ref10._, + data = _ref10$_.data, + setupState = _ref10$_.setupState, + accessCache = _ref10$_.accessCache, + ctx = _ref10$_.ctx, + appContext = _ref10$_.appContext, + propsOptions = _ref10$_.propsOptions; + var normalizedProps; + return accessCache[key] !== undefined || data !== EMPTY_OBJ && hasOwn(data, key) || setupState !== EMPTY_OBJ && hasOwn(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key); + } + }; + + if (process.env.NODE_ENV !== 'production' && !false) { + PublicInstanceProxyHandlers.ownKeys = function (target) { + warn("Avoid app logic that relies on enumerating keys on a component instance. " + "The keys will be empty in production mode to avoid performance overhead."); + return Reflect.ownKeys(target); + }; + } + + var RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, { + get: function get(target, key) { + // fast path for unscopables when using `with` block + if (key === Symbol.unscopables) { + return; + } + + return PublicInstanceProxyHandlers.get(target, key, target); + }, + has: function has(_, key) { + var has = key[0] !== '_' && !isGloballyWhitelisted(key); + + if (process.env.NODE_ENV !== 'production' && !has && PublicInstanceProxyHandlers.has(_, key)) { + warn("Property ".concat(JSON.stringify(key), " should not start with _ which is a reserved prefix for Vue internals.")); + } + + return has; + } + }); + var currentInstance = null; // record effects created during a component's setup() so that they can be + // stopped when the component unmounts + + function recordInstanceBoundEffect(effect) { + var instance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance; + + if (instance) { + (instance.effects || (instance.effects = [])).push(effect); + } + } + + var classifyRE = /(?:^|[-_])(\w)/g; + + var classify = function classify(str) { + return str.replace(classifyRE, function (c) { + return c.toUpperCase(); + }).replace(/[-_]/g, ''); + }; + /* istanbul ignore next */ + + + function formatComponentName(instance, Component) { + var isRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var name = isFunction(Component) ? Component.displayName || Component.name : Component.name; + + if (!name && Component.__file) { + var match = Component.__file.match(/([^/\\]+)\.\w+$/); + + if (match) { + name = match[1]; + } + } + + if (!name && instance && instance.parent) { + // try to infer the name based on reverse resolution + var inferFromRegistry = function inferFromRegistry(registry) { + for (var key in registry) { + if (registry[key] === Component) { + return key; + } + } + }; + + name = inferFromRegistry(instance.components || instance.parent.type.components) || inferFromRegistry(instance.appContext.components); + } + + return name ? classify(name) : isRoot ? "App" : "Anonymous"; + } + + function isClassComponent(value) { + return isFunction(value) && '__vccOpts' in value; + } + + var ssrContextKey = Symbol(process.env.NODE_ENV !== 'production' ? "ssrContext" : ""); + + function initCustomFormatter() { + /* eslint-disable no-restricted-globals */ + if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') { + return; + } + + var vueStyle = { + style: 'color:#3ba776' + }; + var numberStyle = { + style: 'color:#0b1bc9' + }; + var stringStyle = { + style: 'color:#b62e24' + }; + var keywordStyle = { + style: 'color:#9d288c' + }; // custom formatter for Chrome + // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html + + var formatter = { + header: function header(obj) { + // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup + if (!isObject(obj)) { + return null; + } + + if (obj.__isVue) { + return ['div', vueStyle, "VueInstance"]; + } else if (isRef(obj)) { + return ['div', {}, ['span', vueStyle, genRefFlag(obj)], '<', formatValue(obj.value), ">"]; + } else if (isReactive(obj)) { + return ['div', {}, ['span', vueStyle, 'Reactive'], '<', formatValue(obj), ">".concat(isReadonly(obj) ? " (readonly)" : "")]; + } else if (isReadonly(obj)) { + return ['div', {}, ['span', vueStyle, 'Readonly'], '<', formatValue(obj), '>']; + } + + return null; + }, + hasBody: function hasBody(obj) { + return obj && obj.__isVue; + }, + body: function body(obj) { + if (obj && obj.__isVue) { + return ['div', {}].concat(_toConsumableArray(formatInstance(obj.$))); + } + } + }; + + function formatInstance(instance) { + var blocks = []; + + if (instance.type.props && instance.props) { + blocks.push(createInstanceBlock('props', toRaw(instance.props))); + } + + if (instance.setupState !== EMPTY_OBJ) { + blocks.push(createInstanceBlock('setup', instance.setupState)); + } + + if (instance.data !== EMPTY_OBJ) { + blocks.push(createInstanceBlock('data', toRaw(instance.data))); + } + + var computed = extractKeys(instance, 'computed'); + + if (computed) { + blocks.push(createInstanceBlock('computed', computed)); + } + + var injected = extractKeys(instance, 'inject'); + + if (injected) { + blocks.push(createInstanceBlock('injected', injected)); + } + + blocks.push(['div', {}, ['span', { + style: keywordStyle.style + ';opacity:0.66' + }, '$ (internal): '], ['object', { + object: instance + }]]); + return blocks; + } + + function createInstanceBlock(type, target) { + target = extend({}, target); + + if (!Object.keys(target).length) { + return ['span', {}]; + } + + return ['div', { + style: 'line-height:1.25em;margin-bottom:0.6em' + }, ['div', { + style: 'color:#476582' + }, type], ['div', { + style: 'padding-left:1.25em' + }].concat(_toConsumableArray(Object.keys(target).map(function (key) { + return ['div', {}, ['span', keywordStyle, key + ': '], formatValue(target[key], false)]; + })))]; + } + + function formatValue(v) { + var asRaw = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + + if (typeof v === 'number') { + return ['span', numberStyle, v]; + } else if (typeof v === 'string') { + return ['span', stringStyle, JSON.stringify(v)]; + } else if (typeof v === 'boolean') { + return ['span', keywordStyle, v]; + } else if (isObject(v)) { + return ['object', { + object: asRaw ? toRaw(v) : v + }]; + } else { + return ['span', stringStyle, String(v)]; + } + } + + function extractKeys(instance, type) { + var Comp = instance.type; + + if (isFunction(Comp)) { + return; + } + + var extracted = {}; + + for (var key in instance.ctx) { + if (isKeyOfType(Comp, key, type)) { + extracted[key] = instance.ctx[key]; + } + } + + return extracted; + } + + function isKeyOfType(Comp, key, type) { + var opts = Comp[type]; + + if (isArray(opts) && opts.includes(key) || isObject(opts) && key in opts) { + return true; + } + + if (Comp.extends && isKeyOfType(Comp.extends, key, type)) { + return true; + } + + if (Comp.mixins && Comp.mixins.some(function (m) { + return isKeyOfType(m, key, type); + })) { + return true; + } + } + + function genRefFlag(v) { + if (v._shallow) { + return "ShallowRef"; + } + + if (v.effect) { + return "ComputedRef"; + } + + return "Ref"; + } + + if (window.devtoolsFormatters) { + window.devtoolsFormatters.push(formatter); + } else { + window.devtoolsFormatters = [formatter]; + } + } + + function initDev() { + var target = getGlobalThis(); + target.__VUE__ = true; + setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__); + { + initCustomFormatter(); + } + } // This entry exports the runtime only, and is built as + + + process.env.NODE_ENV !== 'production' && initDev(); + + function getInternetExplorerVersion() { + var ua = window.navigator.userAgent; + var msie = ua.indexOf('MSIE '); + + if (msie > 0) { + // IE 10 or older => return version number + return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10); + } + + var trident = ua.indexOf('Trident/'); + + if (trident > 0) { + // IE 11 => return version number + var rv = ua.indexOf('rv:'); + return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10); + } + + var edge = ua.indexOf('Edge/'); + + if (edge > 0) { + // Edge (IE 12+) => return version number + return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10); + } // other browser + + + return -1; + } + + var isIE; + + function initCompat() { + if (!initCompat.init) { + initCompat.init = true; + isIE = getInternetExplorerVersion() !== -1; + } + } + + var script = { + name: 'ResizeObserver', + mounted: function mounted() { + var _this = this; + + initCompat(); + nextTick(function () { + _this._w = _this.$el.offsetWidth; + _this._h = _this.$el.offsetHeight; + }); + var object = document.createElement('object'); + this._resizeObject = object; + object.setAttribute('aria-hidden', 'true'); + object.setAttribute('tabindex', -1); + object.onload = this.addResizeHandlers; + object.type = 'text/html'; + + if (isIE) { + this.$el.appendChild(object); + } + + object.data = 'about:blank'; + + if (!isIE) { + this.$el.appendChild(object); + } + }, + beforeUnmount: function beforeUnmount() { + this.removeResizeHandlers(); + }, + methods: { + compareAndNotify: function compareAndNotify() { + if (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) { + this._w = this.$el.offsetWidth; + this._h = this.$el.offsetHeight; + this.$emit('notify', { + width: this._w, + height: this._h + }); + } + }, + addResizeHandlers: function addResizeHandlers() { + this._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify); + + this.compareAndNotify(); + }, + removeResizeHandlers: function removeResizeHandlers() { + if (this._resizeObject && this._resizeObject.onload) { + if (!isIE && this._resizeObject.contentDocument) { + this._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify); + } + + this.$el.removeChild(this._resizeObject); + this._resizeObject.onload = null; + this._resizeObject = null; + } + } + } + }; + + var _withId = /*#__PURE__*/withScopeId("data-v-b329ee4c"); + + pushScopeId("data-v-b329ee4c"); + var _hoisted_1 = { + class: "resize-observer", + tabindex: "-1" + }; + popScopeId(); + + var render = /*#__PURE__*/_withId(function (_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("div", _hoisted_1); + }); + + script.render = render; + script.__scopeId = "data-v-b329ee4c"; + script.__file = "src/components/ResizeObserver.vue"; + + function install(Vue) { + Vue.component('resize-observer', script); + Vue.component('ResizeObserver', script); + } + + var plugin = { + // eslint-disable-next-line no-undef + version: "0.5.0", + install: install + }; + var GlobalVue = null; + + if (typeof window !== 'undefined') { + GlobalVue = window.Vue; + } else if (typeof global !== 'undefined') { + GlobalVue = global.Vue; + } + + if (GlobalVue) { + GlobalVue.use(plugin); + } + + var _ErrorTypeStrings$1; + + function _typeof$1(obj) { + if (typeof Symbol === "function" && _typeof(Symbol.iterator) === "symbol") { + _typeof$1 = function _typeof$1(obj) { + return _typeof(obj); + }; + } else { + _typeof$1 = function _typeof$1(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof(obj); + }; + } + + return _typeof$1(obj); + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; + } + + function _toConsumableArray$1(arr) { + return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _nonIterableSpread$1(); + } + + function _arrayWithoutHoles$1(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + } + + return arr2; + } + } + + function _iterableToArray$1(iter) { + if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); + } + + function _nonIterableSpread$1() { + throw new TypeError("Invalid attempt to spread non-iterable instance"); + } + /** + * Make a map and return a function for checking if a key + * is in that map. + * IMPORTANT: all calls of this function must be prefixed with + * \/\*#\_\_PURE\_\_\*\/ + * So that rollup can tree-shake them if necessary. + */ + + + function makeMap$1(str, expectsLowerCase) { + var map = Object.create(null); + var list = str.split(','); + + for (var i = 0; i < list.length; i++) { + map[list[i]] = true; + } + + return expectsLowerCase ? function (val) { + return !!map[val.toLowerCase()]; + } : function (val) { + return !!map[val]; + }; + } + + var GLOBALS_WHITE_LISTED$1 = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl'; + var isGloballyWhitelisted$1 = /*#__PURE__*/makeMap$1(GLOBALS_WHITE_LISTED$1); + /** + * On the client we only need to offer special cases for boolean attributes that + * have different names from their corresponding dom properties: + * - itemscope -> N/A + * - allowfullscreen -> allowFullscreen + * - formnovalidate -> formNoValidate + * - ismap -> isMap + * - nomodule -> noModule + * - novalidate -> noValidate + * - readonly -> readOnly + */ + + var specialBooleanAttrs = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly"; + var isSpecialBooleanAttr = /*#__PURE__*/makeMap$1(specialBooleanAttrs); + + function normalizeStyle$1(value) { + if (isArray$1(value)) { + var res = {}; + + for (var i = 0; i < value.length; i++) { + var item = value[i]; + var normalized = normalizeStyle$1(isString$1(item) ? parseStringStyle$1(item) : item); + + if (normalized) { + for (var key in normalized) { + res[key] = normalized[key]; + } + } + } + + return res; + } else if (isObject$1(value)) { + return value; + } + } + + var listDelimiterRE$1 = /;(?![^(]*\))/g; + var propertyDelimiterRE$1 = /:(.+)/; + + function parseStringStyle$1(cssText) { + var ret = {}; + cssText.split(listDelimiterRE$1).forEach(function (item) { + if (item) { + var tmp = item.split(propertyDelimiterRE$1); + tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); + } + }); + return ret; + } + + function normalizeClass$1(value) { + var res = ''; + + if (isString$1(value)) { + res = value; + } else if (isArray$1(value)) { + for (var i = 0; i < value.length; i++) { + res += normalizeClass$1(value[i]) + ' '; + } + } else if (isObject$1(value)) { + for (var name in value) { + if (value[name]) { + res += name + ' '; + } + } + } + + return res.trim(); + } + + var EMPTY_OBJ$1 = process.env.NODE_ENV !== 'production' ? Object.freeze({}) : {}; + var EMPTY_ARR$1 = process.env.NODE_ENV !== 'production' ? Object.freeze([]) : []; + + var NOOP$1 = function NOOP() {}; + + var onRE$1 = /^on[^a-z]/; + + var isOn$1 = function isOn(key) { + return onRE$1.test(key); + }; + + var isModelListener = function isModelListener(key) { + return key.startsWith('onUpdate:'); + }; + + var extend$1 = Object.assign; + + var remove$1 = function remove(arr, el) { + var i = arr.indexOf(el); + + if (i > -1) { + arr.splice(i, 1); + } + }; + + var hasOwnProperty$1 = Object.prototype.hasOwnProperty; + + var hasOwn$1 = function hasOwn(val, key) { + return hasOwnProperty$1.call(val, key); + }; + + var isArray$1 = Array.isArray; + + var isMap$1 = function isMap(val) { + return toTypeString$1(val) === '[object Map]'; + }; + + var isSet$1 = function isSet(val) { + return toTypeString$1(val) === '[object Set]'; + }; + + var isFunction$1 = function isFunction(val) { + return typeof val === 'function'; + }; + + var isString$1 = function isString(val) { + return typeof val === 'string'; + }; + + var isSymbol$1 = function isSymbol(val) { + return _typeof(val) === 'symbol'; + }; + + var isObject$1 = function isObject(val) { + return val !== null && _typeof(val) === 'object'; + }; + + var isPromise$1 = function isPromise(val) { + return isObject$1(val) && isFunction$1(val.then) && isFunction$1(val.catch); + }; + + var objectToString$1 = Object.prototype.toString; + + var toTypeString$1 = function toTypeString(value) { + return objectToString$1.call(value); + }; + + var toRawType$1 = function toRawType(value) { + // extract "RawType" from strings like "[object RawType]" + return toTypeString$1(value).slice(8, -1); + }; + + var isIntegerKey$1 = function isIntegerKey(key) { + return isString$1(key) && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key; + }; + + var cacheStringFunction$1 = function cacheStringFunction(fn) { + var cache = Object.create(null); + return function (str) { + var hit = cache[str]; + return hit || (cache[str] = fn(str)); + }; + }; + + var camelizeRE = /-(\w)/g; + /** + * @private + */ + + var camelize = cacheStringFunction$1(function (str) { + return str.replace(camelizeRE, function (_, c) { + return c ? c.toUpperCase() : ''; + }); + }); + var hyphenateRE = /\B([A-Z])/g; + /** + * @private + */ + + var hyphenate = cacheStringFunction$1(function (str) { + return str.replace(hyphenateRE, '-$1').toLowerCase(); + }); + /** + * @private + */ + + var capitalize$1 = cacheStringFunction$1(function (str) { + return str.charAt(0).toUpperCase() + str.slice(1); + }); // compare whether a value has changed, accounting for NaN. + + var hasChanged$1 = function hasChanged(value, oldValue) { + return value !== oldValue && (value === value || oldValue === oldValue); + }; + + var _globalThis$1; + + var getGlobalThis$1 = function getGlobalThis() { + return _globalThis$1 || (_globalThis$1 = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {}); + }; + + var targetMap$1 = new WeakMap(); + var effectStack$1 = []; + var activeEffect$1; + var ITERATE_KEY$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'iterate' : ''); + var MAP_KEY_ITERATE_KEY$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'Map key iterate' : ''); + + function isEffect$1(fn) { + return fn && fn._isEffect === true; + } + + function effect$1(fn) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_OBJ$1; + + if (isEffect$1(fn)) { + fn = fn.raw; + } + + var effect = createReactiveEffect$1(fn, options); + + if (!options.lazy) { + effect(); + } + + return effect; + } + + function stop$1(effect) { + if (effect.active) { + cleanup$1(effect); + + if (effect.options.onStop) { + effect.options.onStop(); + } + + effect.active = false; + } + } + + var uid$1 = 0; + + function createReactiveEffect$1(fn, options) { + var effect = function reactiveEffect() { + if (!effect.active) { + return options.scheduler ? undefined : fn(); + } + + if (!effectStack$1.includes(effect)) { + cleanup$1(effect); + + try { + enableTracking$1(); + effectStack$1.push(effect); + activeEffect$1 = effect; + return fn(); + } finally { + effectStack$1.pop(); + resetTracking$1(); + activeEffect$1 = effectStack$1[effectStack$1.length - 1]; + } + } + }; + + effect.id = uid$1++; + effect.allowRecurse = !!options.allowRecurse; + effect._isEffect = true; + effect.active = true; + effect.raw = fn; + effect.deps = []; + effect.options = options; + return effect; + } + + function cleanup$1(effect) { + var deps = effect.deps; + + if (deps.length) { + for (var i = 0; i < deps.length; i++) { + deps[i].delete(effect); + } + + deps.length = 0; + } + } + + var shouldTrack$1 = true; + var trackStack$1 = []; + + function pauseTracking$1() { + trackStack$1.push(shouldTrack$1); + shouldTrack$1 = false; + } + + function enableTracking$1() { + trackStack$1.push(shouldTrack$1); + shouldTrack$1 = true; + } + + function resetTracking$1() { + var last = trackStack$1.pop(); + shouldTrack$1 = last === undefined ? true : last; + } + + function track$1(target, type, key) { + if (!shouldTrack$1 || activeEffect$1 === undefined) { + return; + } + + var depsMap = targetMap$1.get(target); + + if (!depsMap) { + targetMap$1.set(target, depsMap = new Map()); + } + + var dep = depsMap.get(key); + + if (!dep) { + depsMap.set(key, dep = new Set()); + } + + if (!dep.has(activeEffect$1)) { + dep.add(activeEffect$1); + activeEffect$1.deps.push(dep); + + if (process.env.NODE_ENV !== 'production' && activeEffect$1.options.onTrack) { + activeEffect$1.options.onTrack({ + effect: activeEffect$1, + target: target, + type: type, + key: key + }); + } + } + } + + function trigger$1(target, type, key, newValue, oldValue, oldTarget) { + var depsMap = targetMap$1.get(target); + + if (!depsMap) { + // never been tracked + return; + } + + var effects = new Set(); + + var add = function add(effectsToAdd) { + if (effectsToAdd) { + effectsToAdd.forEach(function (effect) { + if (effect !== activeEffect$1 || effect.allowRecurse) { + effects.add(effect); + } + }); + } + }; + + if (type === "clear" + /* CLEAR */ + ) { + // collection being cleared + // trigger all effects for target + depsMap.forEach(add); + } else if (key === 'length' && isArray$1(target)) { + depsMap.forEach(function (dep, key) { + if (key === 'length' || key >= newValue) { + add(dep); + } + }); + } else { + // schedule runs for SET | ADD | DELETE + if (key !== void 0) { + add(depsMap.get(key)); + } // also run for iteration key on ADD | DELETE | Map.SET + + + switch (type) { + case "add" + /* ADD */ + : + if (!isArray$1(target)) { + add(depsMap.get(ITERATE_KEY$1)); + + if (isMap$1(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY$1)); + } + } else if (isIntegerKey$1(key)) { + // new index added to array -> length changes + add(depsMap.get('length')); + } + + break; + + case "delete" + /* DELETE */ + : + if (!isArray$1(target)) { + add(depsMap.get(ITERATE_KEY$1)); + + if (isMap$1(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY$1)); + } + } + + break; + + case "set" + /* SET */ + : + if (isMap$1(target)) { + add(depsMap.get(ITERATE_KEY$1)); + } + + break; + } + } + + var run = function run(effect) { + if (process.env.NODE_ENV !== 'production' && effect.options.onTrigger) { + effect.options.onTrigger({ + effect: effect, + target: target, + key: key, + type: type, + newValue: newValue, + oldValue: oldValue, + oldTarget: oldTarget + }); + } + + if (effect.options.scheduler) { + effect.options.scheduler(effect); + } else { + effect(); + } + }; + + effects.forEach(run); + } + + var builtInSymbols$1 = new Set(Object.getOwnPropertyNames(Symbol).map(function (key) { + return Symbol[key]; + }).filter(isSymbol$1)); + var get$2 = /*#__PURE__*/createGetter$1(); + var shallowGet$1 = /*#__PURE__*/createGetter$1(false, true); + var readonlyGet$1 = /*#__PURE__*/createGetter$1(true); + var shallowReadonlyGet$1 = /*#__PURE__*/createGetter$1(true, true); + var arrayInstrumentations$1 = {}; + ['includes', 'indexOf', 'lastIndexOf'].forEach(function (key) { + var method = Array.prototype[key]; + + arrayInstrumentations$1[key] = function () { + var arr = toRaw$1(this); + + for (var i = 0, l = this.length; i < l; i++) { + track$1(arr, "get" + /* GET */ + , i + ''); + } // we run the method using the original args first (which may be reactive) + + + for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + var res = method.apply(arr, args); + + if (res === -1 || res === false) { + // if that didn't work, run it again using raw values. + return method.apply(arr, args.map(toRaw$1)); + } else { + return res; + } + }; + }); + ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(function (key) { + var method = Array.prototype[key]; + + arrayInstrumentations$1[key] = function () { + pauseTracking$1(); + + for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments[_key3]; + } + + var res = method.apply(this, args); + resetTracking$1(); + return res; + }; + }); + + function createGetter$1() { + var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var shallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + return function get(target, key, receiver) { + if (key === "__v_isReactive" + /* IS_REACTIVE */ + ) { + return !isReadonly; + } else if (key === "__v_isReadonly" + /* IS_READONLY */ + ) { + return isReadonly; + } else if (key === "__v_raw" + /* RAW */ + && receiver === (isReadonly ? readonlyMap$1 : reactiveMap$1).get(target)) { + return target; + } + + var targetIsArray = isArray$1(target); + + if (!isReadonly && targetIsArray && hasOwn$1(arrayInstrumentations$1, key)) { + return Reflect.get(arrayInstrumentations$1, key, receiver); + } + + var res = Reflect.get(target, key, receiver); + + if (isSymbol$1(key) ? builtInSymbols$1.has(key) : key === "__proto__" || key === "__v_isRef") { + return res; + } + + if (!isReadonly) { + track$1(target, "get" + /* GET */ + , key); + } + + if (shallow) { + return res; + } + + if (isRef$1(res)) { + // ref unwrapping - does not apply for Array + integer key. + var shouldUnwrap = !targetIsArray || !isIntegerKey$1(key); + return shouldUnwrap ? res.value : res; + } + + if (isObject$1(res)) { + // Convert returned value into a proxy as well. we do the isObject check + // here to avoid invalid value warning. Also need to lazy access readonly + // and reactive here to avoid circular dependency. + return isReadonly ? readonly$1(res) : reactive$1(res); + } + + return res; + }; + } + + var set$2 = /*#__PURE__*/createSetter$1(); + var shallowSet$1 = /*#__PURE__*/createSetter$1(true); + + function createSetter$1() { + var shallow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + return function set(target, key, value, receiver) { + var oldValue = target[key]; + + if (!shallow) { + value = toRaw$1(value); + + if (!isArray$1(target) && isRef$1(oldValue) && !isRef$1(value)) { + oldValue.value = value; + return true; + } + } + + var hadKey = isArray$1(target) && isIntegerKey$1(key) ? Number(key) < target.length : hasOwn$1(target, key); + var result = Reflect.set(target, key, value, receiver); // don't trigger if target is something up in the prototype chain of original + + if (target === toRaw$1(receiver)) { + if (!hadKey) { + trigger$1(target, "add" + /* ADD */ + , key, value); + } else if (hasChanged$1(value, oldValue)) { + trigger$1(target, "set" + /* SET */ + , key, value, oldValue); + } + } + + return result; + }; + } + + function deleteProperty$1(target, key) { + var hadKey = hasOwn$1(target, key); + var oldValue = target[key]; + var result = Reflect.deleteProperty(target, key); + + if (result && hadKey) { + trigger$1(target, "delete" + /* DELETE */ + , key, undefined, oldValue); + } + + return result; + } + + function has$2(target, key) { + var result = Reflect.has(target, key); + + if (!isSymbol$1(key) || !builtInSymbols$1.has(key)) { + track$1(target, "has" + /* HAS */ + , key); + } + + return result; + } + + function ownKeys$2(target) { + track$1(target, "iterate" + /* ITERATE */ + , isArray$1(target) ? 'length' : ITERATE_KEY$1); + return Reflect.ownKeys(target); + } + + var mutableHandlers$1 = { + get: get$2, + set: set$2, + deleteProperty: deleteProperty$1, + has: has$2, + ownKeys: ownKeys$2 + }; + var readonlyHandlers$1 = { + get: readonlyGet$1, + set: function set(target, key) { + if (process.env.NODE_ENV !== 'production') { + console.warn("Set operation on key \"".concat(String(key), "\" failed: target is readonly."), target); + } + + return true; + }, + deleteProperty: function deleteProperty(target, key) { + if (process.env.NODE_ENV !== 'production') { + console.warn("Delete operation on key \"".concat(String(key), "\" failed: target is readonly."), target); + } + + return true; + } + }; + var shallowReactiveHandlers$1 = extend$1({}, mutableHandlers$1, { + get: shallowGet$1, + set: shallowSet$1 + }); // Props handlers are special in the sense that it should not unwrap top-level + // refs (in order to allow refs to be explicitly passed down), but should + // retain the reactivity of the normal readonly object. + + var shallowReadonlyHandlers$1 = extend$1({}, readonlyHandlers$1, { + get: shallowReadonlyGet$1 + }); + + var toReactive$1 = function toReactive(value) { + return isObject$1(value) ? reactive$1(value) : value; + }; + + var toReadonly$1 = function toReadonly(value) { + return isObject$1(value) ? readonly$1(value) : value; + }; + + var toShallow$1 = function toShallow(value) { + return value; + }; + + var getProto$1 = function getProto(v) { + return Reflect.getPrototypeOf(v); + }; + + function get$1$1(target, key) { + var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var isShallow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + // #1772: readonly(reactive(Map)) should return readonly + reactive version + // of the value + target = target["__v_raw" + /* RAW */ + ]; + var rawTarget = toRaw$1(target); + var rawKey = toRaw$1(key); + + if (key !== rawKey) { + !isReadonly && track$1(rawTarget, "get" + /* GET */ + , key); + } + + !isReadonly && track$1(rawTarget, "get" + /* GET */ + , rawKey); + + var _getProto = getProto$1(rawTarget), + has = _getProto.has; + + var wrap = isReadonly ? toReadonly$1 : isShallow ? toShallow$1 : toReactive$1; + + if (has.call(rawTarget, key)) { + return wrap(target.get(key)); + } else if (has.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } + } + + function has$1$1(key) { + var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var target = this["__v_raw" + /* RAW */ + ]; + var rawTarget = toRaw$1(target); + var rawKey = toRaw$1(key); + + if (key !== rawKey) { + !isReadonly && track$1(rawTarget, "has" + /* HAS */ + , key); + } + + !isReadonly && track$1(rawTarget, "has" + /* HAS */ + , rawKey); + return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); + } + + function size$1(target) { + var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + target = target["__v_raw" + /* RAW */ + ]; + !isReadonly && track$1(toRaw$1(target), "iterate" + /* ITERATE */ + , ITERATE_KEY$1); + return Reflect.get(target, 'size', target); + } + + function add$1(value) { + value = toRaw$1(value); + var target = toRaw$1(this); + var proto = getProto$1(target); + var hadKey = proto.has.call(target, value); + target.add(value); + + if (!hadKey) { + trigger$1(target, "add" + /* ADD */ + , value, value); + } + + return this; + } + + function set$1$1(key, value) { + value = toRaw$1(value); + var target = toRaw$1(this); + + var _getProto2 = getProto$1(target), + has = _getProto2.has, + get = _getProto2.get; + + var hadKey = has.call(target, key); + + if (!hadKey) { + key = toRaw$1(key); + hadKey = has.call(target, key); + } else if (process.env.NODE_ENV !== 'production') { + checkIdentityKeys$1(target, has, key); + } + + var oldValue = get.call(target, key); + target.set(key, value); + + if (!hadKey) { + trigger$1(target, "add" + /* ADD */ + , key, value); + } else if (hasChanged$1(value, oldValue)) { + trigger$1(target, "set" + /* SET */ + , key, value, oldValue); + } + + return this; + } + + function deleteEntry$1(key) { + var target = toRaw$1(this); + + var _getProto3 = getProto$1(target), + has = _getProto3.has, + get = _getProto3.get; + + var hadKey = has.call(target, key); + + if (!hadKey) { + key = toRaw$1(key); + hadKey = has.call(target, key); + } else if (process.env.NODE_ENV !== 'production') { + checkIdentityKeys$1(target, has, key); + } + + var oldValue = get ? get.call(target, key) : undefined; // forward the operation before queueing reactions + + var result = target.delete(key); + + if (hadKey) { + trigger$1(target, "delete" + /* DELETE */ + , key, undefined, oldValue); + } + + return result; + } + + function clear$1() { + var target = toRaw$1(this); + var hadItems = target.size !== 0; + var oldTarget = process.env.NODE_ENV !== 'production' ? isMap$1(target) ? new Map(target) : new Set(target) : undefined; // forward the operation before queueing reactions + + var result = target.clear(); + + if (hadItems) { + trigger$1(target, "clear" + /* CLEAR */ + , undefined, undefined, oldTarget); + } + + return result; + } + + function createForEach$1(isReadonly, isShallow) { + return function forEach(callback, thisArg) { + var observed = this; + var target = observed["__v_raw" + /* RAW */ + ]; + var rawTarget = toRaw$1(target); + var wrap = isReadonly ? toReadonly$1 : isShallow ? toShallow$1 : toReactive$1; + !isReadonly && track$1(rawTarget, "iterate" + /* ITERATE */ + , ITERATE_KEY$1); + return target.forEach(function (value, key) { + // important: make sure the callback is + // 1. invoked with the reactive map as `this` and 3rd arg + // 2. the value received should be a corresponding reactive/readonly. + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; + } + + function createIterableMethod$1(method, isReadonly, isShallow) { + return function () { + var target = this["__v_raw" + /* RAW */ + ]; + var rawTarget = toRaw$1(target); + var targetIsMap = isMap$1(rawTarget); + var isPair = method === 'entries' || method === Symbol.iterator && targetIsMap; + var isKeyOnly = method === 'keys' && targetIsMap; + var innerIterator = target[method].apply(target, arguments); + var wrap = isReadonly ? toReadonly$1 : isShallow ? toShallow$1 : toReactive$1; + !isReadonly && track$1(rawTarget, "iterate" + /* ITERATE */ + , isKeyOnly ? MAP_KEY_ITERATE_KEY$1 : ITERATE_KEY$1); // return a wrapped iterator which returns observed versions of the + // values emitted from the real iterator + + return _defineProperty({ + // iterator protocol + next: function next() { + var _innerIterator$next = innerIterator.next(), + value = _innerIterator$next.value, + done = _innerIterator$next.done; + + return done ? { + value: value, + done: done + } : { + value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), + done: done + }; + } + }, Symbol.iterator, function () { + return this; + }); + }; + } + + function createReadonlyMethod$1(type) { + return function () { + if (process.env.NODE_ENV !== 'production') { + var key = (arguments.length <= 0 ? undefined : arguments[0]) ? "on key \"".concat(arguments.length <= 0 ? undefined : arguments[0], "\" ") : ""; + console.warn("".concat(capitalize$1(type), " operation ").concat(key, "failed: target is readonly."), toRaw$1(this)); + } + + return type === "delete" + /* DELETE */ + ? false : this; + }; + } + + var mutableInstrumentations$1 = { + get: function get(key) { + return get$1$1(this, key); + }, + + get size() { + return size$1(this); + }, + + has: has$1$1, + add: add$1, + set: set$1$1, + delete: deleteEntry$1, + clear: clear$1, + forEach: createForEach$1(false, false) + }; + var shallowInstrumentations$1 = { + get: function get(key) { + return get$1$1(this, key, false, true); + }, + + get size() { + return size$1(this); + }, + + has: has$1$1, + add: add$1, + set: set$1$1, + delete: deleteEntry$1, + clear: clear$1, + forEach: createForEach$1(false, true) + }; + var readonlyInstrumentations$1 = { + get: function get(key) { + return get$1$1(this, key, true); + }, + + get size() { + return size$1(this, true); + }, + + has: function has(key) { + return has$1$1.call(this, key, true); + }, + add: createReadonlyMethod$1("add" + /* ADD */ + ), + set: createReadonlyMethod$1("set" + /* SET */ + ), + delete: createReadonlyMethod$1("delete" + /* DELETE */ + ), + clear: createReadonlyMethod$1("clear" + /* CLEAR */ + ), + forEach: createForEach$1(true, false) + }; + var iteratorMethods$1 = ['keys', 'values', 'entries', Symbol.iterator]; + iteratorMethods$1.forEach(function (method) { + mutableInstrumentations$1[method] = createIterableMethod$1(method, false, false); + readonlyInstrumentations$1[method] = createIterableMethod$1(method, true, false); + shallowInstrumentations$1[method] = createIterableMethod$1(method, false, true); + }); + + function createInstrumentationGetter$1(isReadonly, shallow) { + var instrumentations = shallow ? shallowInstrumentations$1 : isReadonly ? readonlyInstrumentations$1 : mutableInstrumentations$1; + return function (target, key, receiver) { + if (key === "__v_isReactive" + /* IS_REACTIVE */ + ) { + return !isReadonly; + } else if (key === "__v_isReadonly" + /* IS_READONLY */ + ) { + return isReadonly; + } else if (key === "__v_raw" + /* RAW */ + ) { + return target; + } + + return Reflect.get(hasOwn$1(instrumentations, key) && key in target ? instrumentations : target, key, receiver); + }; + } + + var mutableCollectionHandlers$1 = { + get: createInstrumentationGetter$1(false, false) + }; + var readonlyCollectionHandlers$1 = { + get: createInstrumentationGetter$1(true, false) + }; + + function checkIdentityKeys$1(target, has, key) { + var rawKey = toRaw$1(key); + + if (rawKey !== key && has.call(target, rawKey)) { + var type = toRawType$1(target); + console.warn("Reactive ".concat(type, " contains both the raw and reactive ") + "versions of the same object".concat(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."); + } + } + + var reactiveMap$1 = new WeakMap(); + var readonlyMap$1 = new WeakMap(); + + function targetTypeMap$1(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$1(value) { + return value["__v_skip" + /* SKIP */ + ] || !Object.isExtensible(value) ? 0 + /* INVALID */ + : targetTypeMap$1(toRawType$1(value)); + } + + function reactive$1(target) { + // if trying to observe a readonly proxy, return the readonly version. + if (target && target["__v_isReadonly" + /* IS_READONLY */ + ]) { + return target; + } + + return createReactiveObject$1(target, false, mutableHandlers$1, mutableCollectionHandlers$1); + } + /** + * Creates a readonly copy of the original object. Note the returned copy is not + * made reactive, but `readonly` can be called on an already reactive object. + */ + + + function readonly$1(target) { + return createReactiveObject$1(target, true, readonlyHandlers$1, readonlyCollectionHandlers$1); + } + /** + * Returns a reactive-copy of the original object, where only the root level + * properties are readonly, and does NOT unwrap refs nor recursively convert + * returned properties. + * This is used for creating the props proxy object for stateful components. + */ + + + function shallowReadonly$1(target) { + return createReactiveObject$1(target, true, shallowReadonlyHandlers$1, readonlyCollectionHandlers$1); + } + + function createReactiveObject$1(target, isReadonly, baseHandlers, collectionHandlers) { + if (!isObject$1(target)) { + if (process.env.NODE_ENV !== 'production') { + console.warn("value cannot be made reactive: ".concat(String(target))); + } + + return target; + } // target is already a Proxy, return it. + // exception: calling readonly() on a reactive object + + + if (target["__v_raw" + /* RAW */ + ] && !(isReadonly && target["__v_isReactive" + /* IS_REACTIVE */ + ])) { + return target; + } // target already has corresponding Proxy + + + var proxyMap = isReadonly ? readonlyMap$1 : reactiveMap$1; + var existingProxy = proxyMap.get(target); + + if (existingProxy) { + return existingProxy; + } // only a whitelist of value types can be observed. + + + var targetType = getTargetType$1(target); + + if (targetType === 0 + /* INVALID */ + ) { + return target; + } + + var proxy = new Proxy(target, targetType === 2 + /* COLLECTION */ + ? collectionHandlers : baseHandlers); + proxyMap.set(target, proxy); + return proxy; + } + + function isReactive$1(value) { + if (isReadonly$1(value)) { + return isReactive$1(value["__v_raw" + /* RAW */ + ]); + } + + return !!(value && value["__v_isReactive" + /* IS_REACTIVE */ + ]); + } + + function isReadonly$1(value) { + return !!(value && value["__v_isReadonly" + /* IS_READONLY */ + ]); + } + + function isProxy$1(value) { + return isReactive$1(value) || isReadonly$1(value); + } + + function toRaw$1(observed) { + return observed && toRaw$1(observed["__v_raw" + /* RAW */ + ]) || observed; + } + + function isRef$1(r) { + return Boolean(r && r.__v_isRef === true); + } + + var stack$1 = []; + + function pushWarningContext$1(vnode) { + stack$1.push(vnode); + } + + function popWarningContext$1() { + stack$1.pop(); + } + + function warn$1(msg) { + // avoid props formatting or warn handler tracking deps that might be mutated + // during patch, leading to infinite recursion. + pauseTracking$1(); + var instance = stack$1.length ? stack$1[stack$1.length - 1].component : null; + var appWarnHandler = instance && instance.appContext.config.warnHandler; + var trace = getComponentTrace$1(); + + for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) { + args[_key4 - 1] = arguments[_key4]; + } + + if (appWarnHandler) { + callWithErrorHandling$1(appWarnHandler, instance, 11 + /* APP_WARN_HANDLER */ + , [msg + args.join(''), instance && instance.proxy, trace.map(function (_ref5) { + var vnode = _ref5.vnode; + return "at <".concat(formatComponentName$1(instance, vnode.type), ">"); + }).join('\n'), trace]); + } else { + var _console; + + var warnArgs = ["[Vue warn]: ".concat(msg)].concat(args); + /* istanbul ignore if */ + + if (trace.length && // avoid spamming console during tests + !false) { + warnArgs.push.apply(warnArgs, ["\n"].concat(_toConsumableArray(formatTrace$1(trace)))); + } + + (_console = console).warn.apply(_console, _toConsumableArray(warnArgs)); + } + + resetTracking$1(); + } + + function getComponentTrace$1() { + var currentVNode = stack$1[stack$1.length - 1]; + + if (!currentVNode) { + return []; + } // we can't just use the stack because it will be incomplete during updates + // that did not start from the root. Re-construct the parent chain using + // instance parent pointers. + + + var normalizedStack = []; + + while (currentVNode) { + var last = normalizedStack[0]; + + if (last && last.vnode === currentVNode) { + last.recurseCount++; + } else { + normalizedStack.push({ + vnode: currentVNode, + recurseCount: 0 + }); + } + + var parentInstance = currentVNode.component && currentVNode.component.parent; + currentVNode = parentInstance && parentInstance.vnode; + } + + return normalizedStack; + } + /* istanbul ignore next */ + + + function formatTrace$1(trace) { + var logs = []; + trace.forEach(function (entry, i) { + logs.push.apply(logs, _toConsumableArray(i === 0 ? [] : ["\n"]).concat(_toConsumableArray(formatTraceEntry$1(entry)))); + }); + return logs; + } + + function formatTraceEntry$1(_ref6) { + var vnode = _ref6.vnode, + recurseCount = _ref6.recurseCount; + var postfix = recurseCount > 0 ? "... (".concat(recurseCount, " recursive calls)") : ""; + var isRoot = vnode.component ? vnode.component.parent == null : false; + var open = " at <".concat(formatComponentName$1(vnode.component, vnode.type, isRoot)); + var close = ">" + postfix; + return vnode.props ? [open].concat(_toConsumableArray(formatProps$1(vnode.props)), [close]) : [open + close]; + } + /* istanbul ignore next */ + + + function formatProps$1(props) { + var res = []; + var keys = Object.keys(props); + keys.slice(0, 3).forEach(function (key) { + res.push.apply(res, _toConsumableArray(formatProp$1(key, props[key]))); + }); + + if (keys.length > 3) { + res.push(" ..."); + } + + return res; + } + /* istanbul ignore next */ + + + function formatProp$1(key, value, raw) { + if (isString$1(value)) { + value = JSON.stringify(value); + return raw ? value : ["".concat(key, "=").concat(value)]; + } else if (typeof value === 'number' || typeof value === 'boolean' || value == null) { + return raw ? value : ["".concat(key, "=").concat(value)]; + } else if (isRef$1(value)) { + value = formatProp$1(key, toRaw$1(value.value), true); + return raw ? value : ["".concat(key, "=Ref<"), value, ">"]; + } else if (isFunction$1(value)) { + return ["".concat(key, "=fn").concat(value.name ? "<".concat(value.name, ">") : "")]; + } else { + value = toRaw$1(value); + return raw ? value : ["".concat(key, "="), value]; + } + } + + var ErrorTypeStrings$1 = (_ErrorTypeStrings$1 = {}, _defineProperty(_ErrorTypeStrings$1, "bc" + /* BEFORE_CREATE */ + , 'beforeCreate hook'), _defineProperty(_ErrorTypeStrings$1, "c" + /* CREATED */ + , 'created hook'), _defineProperty(_ErrorTypeStrings$1, "bm" + /* BEFORE_MOUNT */ + , 'beforeMount hook'), _defineProperty(_ErrorTypeStrings$1, "m" + /* MOUNTED */ + , 'mounted hook'), _defineProperty(_ErrorTypeStrings$1, "bu" + /* BEFORE_UPDATE */ + , 'beforeUpdate hook'), _defineProperty(_ErrorTypeStrings$1, "u" + /* UPDATED */ + , 'updated'), _defineProperty(_ErrorTypeStrings$1, "bum" + /* BEFORE_UNMOUNT */ + , 'beforeUnmount hook'), _defineProperty(_ErrorTypeStrings$1, "um" + /* UNMOUNTED */ + , 'unmounted hook'), _defineProperty(_ErrorTypeStrings$1, "a" + /* ACTIVATED */ + , 'activated hook'), _defineProperty(_ErrorTypeStrings$1, "da" + /* DEACTIVATED */ + , 'deactivated hook'), _defineProperty(_ErrorTypeStrings$1, "ec" + /* ERROR_CAPTURED */ + , 'errorCaptured hook'), _defineProperty(_ErrorTypeStrings$1, "rtc" + /* RENDER_TRACKED */ + , 'renderTracked hook'), _defineProperty(_ErrorTypeStrings$1, "rtg" + /* RENDER_TRIGGERED */ + , 'renderTriggered hook'), _defineProperty(_ErrorTypeStrings$1, 0 + /* SETUP_FUNCTION */ + , 'setup function'), _defineProperty(_ErrorTypeStrings$1, 1 + /* RENDER_FUNCTION */ + , 'render function'), _defineProperty(_ErrorTypeStrings$1, 2 + /* WATCH_GETTER */ + , 'watcher getter'), _defineProperty(_ErrorTypeStrings$1, 3 + /* WATCH_CALLBACK */ + , 'watcher callback'), _defineProperty(_ErrorTypeStrings$1, 4 + /* WATCH_CLEANUP */ + , 'watcher cleanup function'), _defineProperty(_ErrorTypeStrings$1, 5 + /* NATIVE_EVENT_HANDLER */ + , 'native event handler'), _defineProperty(_ErrorTypeStrings$1, 6 + /* COMPONENT_EVENT_HANDLER */ + , 'component event handler'), _defineProperty(_ErrorTypeStrings$1, 7 + /* VNODE_HOOK */ + , 'vnode hook'), _defineProperty(_ErrorTypeStrings$1, 8 + /* DIRECTIVE_HOOK */ + , 'directive hook'), _defineProperty(_ErrorTypeStrings$1, 9 + /* TRANSITION_HOOK */ + , 'transition hook'), _defineProperty(_ErrorTypeStrings$1, 10 + /* APP_ERROR_HANDLER */ + , 'app errorHandler'), _defineProperty(_ErrorTypeStrings$1, 11 + /* APP_WARN_HANDLER */ + , 'app warnHandler'), _defineProperty(_ErrorTypeStrings$1, 12 + /* FUNCTION_REF */ + , 'ref function'), _defineProperty(_ErrorTypeStrings$1, 13 + /* ASYNC_COMPONENT_LOADER */ + , 'async component loader'), _defineProperty(_ErrorTypeStrings$1, 14 + /* SCHEDULER */ + , 'scheduler flush. This is likely a Vue internals bug. ' + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'), _ErrorTypeStrings$1); + + function callWithErrorHandling$1(fn, instance, type, args) { + var res; + + try { + res = args ? fn.apply(void 0, _toConsumableArray(args)) : fn(); + } catch (err) { + handleError$1(err, instance, type); + } + + return res; + } + + function callWithAsyncErrorHandling$1(fn, instance, type, args) { + if (isFunction$1(fn)) { + var res = callWithErrorHandling$1(fn, instance, type, args); + + if (res && isPromise$1(res)) { + res.catch(function (err) { + handleError$1(err, instance, type); + }); + } + + return res; + } + + var values = []; + + for (var i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling$1(fn[i], instance, type, args)); + } + + return values; + } + + function handleError$1(err, instance, type) { + var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + var contextVNode = instance ? instance.vnode : null; + + if (instance) { + var cur = instance.parent; // the exposed instance is the render proxy to keep it consistent with 2.x + + var exposedInstance = instance.proxy; // in production the hook receives only the error code + + var errorInfo = process.env.NODE_ENV !== 'production' ? ErrorTypeStrings$1[type] : type; + + while (cur) { + var errorCapturedHooks = cur.ec; + + if (errorCapturedHooks) { + for (var i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { + return; + } + } + } + + cur = cur.parent; + } // app-level handling + + + var appErrorHandler = instance.appContext.config.errorHandler; + + if (appErrorHandler) { + callWithErrorHandling$1(appErrorHandler, null, 10 + /* APP_ERROR_HANDLER */ + , [err, exposedInstance, errorInfo]); + return; + } + } + + logError$1(err, type, contextVNode, throwInDev); + } + + function logError$1(err, type, contextVNode) { + var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + + if (process.env.NODE_ENV !== 'production') { + var info = ErrorTypeStrings$1[type]; + + if (contextVNode) { + pushWarningContext$1(contextVNode); + } + + warn$1("Unhandled error".concat(info ? " during execution of ".concat(info) : "")); + + if (contextVNode) { + popWarningContext$1(); + } // crash in dev by default so it's more noticeable + + + if (throwInDev) { + throw err; + } else { + console.error(err); + } + } else { + // recover in prod to reduce the impact on end-user + console.error(err); + } + } + + var isFlushing$1 = false; + var isFlushPending$1 = false; + var queue$1 = []; + var flushIndex$1 = 0; + var pendingPreFlushCbs$1 = []; + var activePreFlushCbs$1 = null; + var preFlushIndex$1 = 0; + var pendingPostFlushCbs$1 = []; + var activePostFlushCbs$1 = null; + var postFlushIndex$1 = 0; + var resolvedPromise$1 = Promise.resolve(); + var currentFlushPromise$1 = null; + var currentPreFlushParentJob$1 = null; + var RECURSION_LIMIT$1 = 100; + + function nextTick$1(fn) { + var p = currentFlushPromise$1 || resolvedPromise$1; + return fn ? p.then(this ? fn.bind(this) : fn) : p; + } + + function queueJob$1(job) { + // the dedupe search uses the startIndex argument of Array.includes() + // by default the search index includes the current job that is being run + // so it cannot recursively trigger itself again. + // if the job is a watch() callback, the search will start with a +1 index to + // allow it recursively trigger itself - it is the user's responsibility to + // ensure it doesn't end up in an infinite loop. + if ((!queue$1.length || !queue$1.includes(job, isFlushing$1 && job.allowRecurse ? flushIndex$1 + 1 : flushIndex$1)) && job !== currentPreFlushParentJob$1) { + queue$1.push(job); + queueFlush$1(); + } + } + + function queueFlush$1() { + if (!isFlushing$1 && !isFlushPending$1) { + isFlushPending$1 = true; + currentFlushPromise$1 = resolvedPromise$1.then(flushJobs$1); + } + } + + function queueCb$1(cb, activeQueue, pendingQueue, index) { + if (!isArray$1(cb)) { + if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { + pendingQueue.push(cb); + } + } else { + // if cb is an array, it is a component lifecycle hook which can only be + // triggered by a job, which is already deduped in the main queue, so + // we can skip duplicate check here to improve perf + pendingQueue.push.apply(pendingQueue, _toConsumableArray(cb)); + } + + queueFlush$1(); + } + + function queuePreFlushCb$1(cb) { + queueCb$1(cb, activePreFlushCbs$1, pendingPreFlushCbs$1, preFlushIndex$1); + } + + function queuePostFlushCb$1(cb) { + queueCb$1(cb, activePostFlushCbs$1, pendingPostFlushCbs$1, postFlushIndex$1); + } + + function flushPreFlushCbs$1(seen) { + var parentJob = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + + if (pendingPreFlushCbs$1.length) { + currentPreFlushParentJob$1 = parentJob; + activePreFlushCbs$1 = _toConsumableArray(new Set(pendingPreFlushCbs$1)); + pendingPreFlushCbs$1.length = 0; + + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map(); + } + + for (preFlushIndex$1 = 0; preFlushIndex$1 < activePreFlushCbs$1.length; preFlushIndex$1++) { + if (process.env.NODE_ENV !== 'production') { + checkRecursiveUpdates$1(seen, activePreFlushCbs$1[preFlushIndex$1]); + } + + activePreFlushCbs$1[preFlushIndex$1](); + } + + activePreFlushCbs$1 = null; + preFlushIndex$1 = 0; + currentPreFlushParentJob$1 = null; // recursively flush until it drains + + flushPreFlushCbs$1(seen, parentJob); + } + } + + function flushPostFlushCbs$1(seen) { + if (pendingPostFlushCbs$1.length) { + var deduped = _toConsumableArray(new Set(pendingPostFlushCbs$1)); + + pendingPostFlushCbs$1.length = 0; // #1947 already has active queue, nested flushPostFlushCbs call + + if (activePostFlushCbs$1) { + var _activePostFlushCbs; + + (_activePostFlushCbs = activePostFlushCbs$1).push.apply(_activePostFlushCbs, _toConsumableArray(deduped)); + + return; + } + + activePostFlushCbs$1 = deduped; + + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map(); + } + + activePostFlushCbs$1.sort(function (a, b) { + return getId$1(a) - getId$1(b); + }); + + for (postFlushIndex$1 = 0; postFlushIndex$1 < activePostFlushCbs$1.length; postFlushIndex$1++) { + if (process.env.NODE_ENV !== 'production') { + checkRecursiveUpdates$1(seen, activePostFlushCbs$1[postFlushIndex$1]); + } + + activePostFlushCbs$1[postFlushIndex$1](); + } + + activePostFlushCbs$1 = null; + postFlushIndex$1 = 0; + } + } + + var getId$1 = function getId(job) { + return job.id == null ? Infinity : job.id; + }; + + function flushJobs$1(seen) { + isFlushPending$1 = false; + isFlushing$1 = true; + + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map(); + } + + flushPreFlushCbs$1(seen); // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child so its render effect will have smaller + // priority number) + // 2. If a component is unmounted during a parent component's update, + // its update can be skipped. + + queue$1.sort(function (a, b) { + return getId$1(a) - getId$1(b); + }); + + try { + for (flushIndex$1 = 0; flushIndex$1 < queue$1.length; flushIndex$1++) { + var job = queue$1[flushIndex$1]; + + if (job) { + if (process.env.NODE_ENV !== 'production') { + checkRecursiveUpdates$1(seen, job); + } + + callWithErrorHandling$1(job, null, 14 + /* SCHEDULER */ + ); + } + } + } finally { + flushIndex$1 = 0; + queue$1.length = 0; + flushPostFlushCbs$1(seen); + isFlushing$1 = false; + currentFlushPromise$1 = null; // some postFlushCb queued jobs! + // keep flushing until it drains. + + if (queue$1.length || pendingPostFlushCbs$1.length) { + flushJobs$1(seen); + } + } + } + + function checkRecursiveUpdates$1(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } else { + var count = seen.get(fn); + + if (count > RECURSION_LIMIT$1) { + throw new Error("Maximum recursive updates exceeded. " + "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."); + } else { + seen.set(fn, count + 1); + } + } + } + + var hmrDirtyComponents$1 = new Set(); // Expose the HMR runtime on the global object + // This makes it entirely tree-shakable without polluting the exports and makes + // it easier to be used in toolings like vue-loader + // Note: for a component to be eligible for HMR it also needs the __hmrId option + // to be set so that its instances can be registered / removed. + + if (process.env.NODE_ENV !== 'production') { + var globalObject$1 = typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {}; + globalObject$1.__VUE_HMR_RUNTIME__ = { + createRecord: tryWrap$1(createRecord$1), + rerender: tryWrap$1(rerender$1), + reload: tryWrap$1(reload$1) + }; + } + + var map$1 = new Map(); + + function createRecord$1(id, component) { + if (!component) { + warn$1("HMR API usage is out of date.\n" + "Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant " + "depdendency that handles Vue SFC compilation."); + component = {}; + } + + if (map$1.has(id)) { + return false; + } + + map$1.set(id, { + component: isClassComponent$1(component) ? component.__vccOpts : component, + instances: new Set() + }); + return true; + } + + function rerender$1(id, newRender) { + var record = map$1.get(id); + if (!record) return; + if (newRender) record.component.render = newRender; // Array.from creates a snapshot which avoids the set being mutated during + // updates + + Array.from(record.instances).forEach(function (instance) { + if (newRender) { + instance.render = newRender; + } + + instance.renderCache = []; + instance.update(); + }); + } + + function reload$1(id, newComp) { + var record = map$1.get(id); + if (!record) return; // Array.from creates a snapshot which avoids the set being mutated during + // updates + + var component = record.component, + instances = record.instances; + + if (!hmrDirtyComponents$1.has(component)) { + // 1. Update existing comp definition to match new one + newComp = isClassComponent$1(newComp) ? newComp.__vccOpts : newComp; + extend$1(component, newComp); + + for (var key in component) { + if (!(key in newComp)) { + delete component[key]; + } + } // 2. Mark component dirty. This forces the renderer to replace the component + // on patch. + + + hmrDirtyComponents$1.add(component); // 3. Make sure to unmark the component after the reload. + + queuePostFlushCb$1(function () { + hmrDirtyComponents$1.delete(component); + }); + } + + Array.from(instances).forEach(function (instance) { + if (instance.parent) { + // 4. Force the parent instance to re-render. This will cause all updated + // components to be unmounted and re-mounted. Queue the update so that we + // don't end up forcing the same parent to re-render multiple times. + queueJob$1(instance.parent.update); + } else if (instance.appContext.reload) { + // root instance mounted via createApp() has a reload method + instance.appContext.reload(); + } else if (typeof window !== 'undefined') { + // root instance inside tree created via raw render(). Force reload. + window.location.reload(); + } else { + console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); + } + }); + } + + function tryWrap$1(fn) { + return function (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."); + } + }; + } + + function setDevtoolsHook$1(hook) {} + /** + * mark the current rendering instance for asset resolution (e.g. + * resolveComponent, resolveDirective) during render + */ + + + var currentRenderingInstance$1 = null; + + function markAttrsAccessed$1() {} + + function filterSingleRoot$1(children) { + var singleRoot; + + for (var i = 0; i < children.length; i++) { + var child = children[i]; + + if (isVNode$1(child)) { + // ignore user comment + if (child.type !== Comment$1 || child.children === 'v-if') { + if (singleRoot) { + // has more than 1 non-comment child, return now + return; + } else { + singleRoot = child; + } + } + } else { + return; + } + } + + return singleRoot; + } + + var isSuspense$1 = function isSuspense(type) { + return type.__isSuspense; + }; + + function normalizeSuspenseChildren$1(vnode) { + var shapeFlag = vnode.shapeFlag, + children = vnode.children; + var content; + var fallback; + + if (shapeFlag & 32 + /* SLOTS_CHILDREN */ + ) { + content = normalizeSuspenseSlot$1(children.default); + fallback = normalizeSuspenseSlot$1(children.fallback); + } else { + content = normalizeSuspenseSlot$1(children); + fallback = normalizeVNode$1(null); + } + + return { + content: content, + fallback: fallback + }; + } + + function normalizeSuspenseSlot$1(s) { + if (isFunction$1(s)) { + s = s(); + } + + if (isArray$1(s)) { + var singleChild = filterSingleRoot$1(s); + + if (process.env.NODE_ENV !== 'production' && !singleChild) { + warn$1(" slots expect a single root node."); + } + + s = singleChild; + } + + return normalizeVNode$1(s); + } + + function queueEffectWithSuspense$1(fn, suspense) { + if (suspense && suspense.pendingBranch) { + if (isArray$1(fn)) { + var _suspense$effects; + + (_suspense$effects = suspense.effects).push.apply(_suspense$effects, _toConsumableArray(fn)); + } else { + suspense.effects.push(fn); + } + } else { + queuePostFlushCb$1(fn); + } + } + + var isRenderingCompiledSlot$1 = 0; + + var setCompiledSlotRendering$1 = function setCompiledSlotRendering(n) { + return isRenderingCompiledSlot$1 += n; + }; // SFC scoped style ID management. + + + var currentScopeId$1 = null; // initial value for watchers to trigger on undefined initial values + + var INITIAL_WATCHER_VALUE$1 = {}; + + function doWatch$1(source, cb) { + var _ref7 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_OBJ$1, + immediate = _ref7.immediate, + deep = _ref7.deep, + flush = _ref7.flush, + onTrack = _ref7.onTrack, + onTrigger = _ref7.onTrigger; + + var instance = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : currentInstance$1; + + if (process.env.NODE_ENV !== 'production' && !cb) { + if (immediate !== undefined) { + warn$1("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature."); + } + + if (deep !== undefined) { + warn$1("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature."); + } + } + + var warnInvalidSource = function warnInvalidSource(s) { + warn$1("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."); + }; + + var getter; + var forceTrigger = false; + + if (isRef$1(source)) { + getter = function getter() { + return source.value; + }; + + forceTrigger = !!source._shallow; + } else if (isReactive$1(source)) { + getter = function getter() { + return source; + }; + + deep = true; + } else if (isArray$1(source)) { + getter = function getter() { + return source.map(function (s) { + if (isRef$1(s)) { + return s.value; + } else if (isReactive$1(s)) { + return traverse$1(s); + } else if (isFunction$1(s)) { + return callWithErrorHandling$1(s, instance, 2 + /* WATCH_GETTER */ + ); + } else { + process.env.NODE_ENV !== 'production' && warnInvalidSource(s); + } + }); + }; + } else if (isFunction$1(source)) { + if (cb) { + // getter with cb + getter = function getter() { + return callWithErrorHandling$1(source, instance, 2 + /* WATCH_GETTER */ + ); + }; + } else { + // no cb -> simple effect + getter = function getter() { + if (instance && instance.isUnmounted) { + return; + } + + if (cleanup) { + cleanup(); + } + + return callWithErrorHandling$1(source, instance, 3 + /* WATCH_CALLBACK */ + , [onInvalidate]); + }; + } + } else { + getter = NOOP$1; + process.env.NODE_ENV !== 'production' && warnInvalidSource(source); + } + + if (cb && deep) { + var baseGetter = getter; + + getter = function getter() { + return traverse$1(baseGetter()); + }; + } + + var cleanup; + + var onInvalidate = function onInvalidate(fn) { + cleanup = runner.options.onStop = function () { + callWithErrorHandling$1(fn, instance, 4 + /* WATCH_CLEANUP */ + ); + }; + }; + + var oldValue = isArray$1(source) ? [] : INITIAL_WATCHER_VALUE$1; + + var job = function job() { + if (!runner.active) { + return; + } + + if (cb) { + // watch(source, cb) + var newValue = runner(); + + if (deep || forceTrigger || hasChanged$1(newValue, oldValue)) { + // cleanup before running cb again + if (cleanup) { + cleanup(); + } + + callWithAsyncErrorHandling$1(cb, instance, 3 + /* WATCH_CALLBACK */ + , [newValue, // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE$1 ? undefined : oldValue, onInvalidate]); + oldValue = newValue; + } + } else { + // watchEffect + runner(); + } + }; // important: mark the job as a watcher callback so that scheduler knows + // it is allowed to self-trigger (#1727) + + + job.allowRecurse = !!cb; + var scheduler; + + if (flush === 'sync') { + scheduler = job; + } else if (flush === 'post') { + scheduler = function scheduler() { + return queuePostRenderEffect$1(job, instance && instance.suspense); + }; + } else { + // default: 'pre' + scheduler = function scheduler() { + if (!instance || instance.isMounted) { + queuePreFlushCb$1(job); + } else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job(); + } + }; + } + + var runner = effect$1(getter, { + lazy: true, + onTrack: onTrack, + onTrigger: onTrigger, + scheduler: scheduler + }); + recordInstanceBoundEffect$1(runner, instance); // initial run + + if (cb) { + if (immediate) { + job(); + } else { + oldValue = runner(); + } + } else if (flush === 'post') { + queuePostRenderEffect$1(runner, instance && instance.suspense); + } else { + runner(); + } + + return function () { + stop$1(runner); + + if (instance) { + remove$1(instance.effects, runner); + } + }; + } // this.$watch + + + function instanceWatch$1(source, cb, options) { + var publicThis = this.proxy; + var getter = isString$1(source) ? function () { + return publicThis[source]; + } : source.bind(publicThis); + return doWatch$1(getter, cb.bind(publicThis), options, this); + } + + function traverse$1(value) { + var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set(); + + if (!isObject$1(value) || seen.has(value)) { + return value; + } + + seen.add(value); + + if (isRef$1(value)) { + traverse$1(value.value, seen); + } else if (isArray$1(value)) { + for (var i = 0; i < value.length; i++) { + traverse$1(value[i], seen); + } + } else if (isSet$1(value) || isMap$1(value)) { + value.forEach(function (v) { + traverse$1(v, seen); + }); + } else { + for (var key in value) { + traverse$1(value[key], seen); + } + } + + return value; + } + + var queuePostRenderEffect$1 = queueEffectWithSuspense$1; + + var isTeleport$1 = function isTeleport(type) { + return type.__isTeleport; + }; + + var NULL_DYNAMIC_COMPONENT$1 = Symbol(); + var Fragment$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'Fragment' : undefined); + var Text$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'Text' : undefined); + var Comment$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'Comment' : undefined); + var Static$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'Static' : undefined); + var currentBlock$1 = null; // Whether we should be tracking dynamic child nodes inside a block. + + function isVNode$1(value) { + return value ? value.__v_isVNode === true : false; + } + + var createVNodeWithArgsTransform$1 = function createVNodeWithArgsTransform() { + for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { + args[_key5] = arguments[_key5]; + } + + return _createVNode$1.apply(void 0, _toConsumableArray( args)); + }; + + var InternalObjectKey$1 = "__vInternal"; + + var normalizeKey$1 = function normalizeKey(_ref8) { + var key = _ref8.key; + return key != null ? key : null; + }; + + var normalizeRef$1 = function normalizeRef(_ref9) { + var ref = _ref9.ref; + return ref != null ? isString$1(ref) || isRef$1(ref) || isFunction$1(ref) ? { + i: currentRenderingInstance$1, + r: ref + } : ref : null; + }; + + var createVNode$1 = process.env.NODE_ENV !== 'production' ? createVNodeWithArgsTransform$1 : _createVNode$1; + + function _createVNode$1(type) { + var _vnode; + + var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + var children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; + var patchFlag = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0; + var dynamicProps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null; + var isBlockNode = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false; + + if (!type || type === NULL_DYNAMIC_COMPONENT$1) { + if (process.env.NODE_ENV !== 'production' && !type) { + warn$1("Invalid vnode type when creating vnode: ".concat(type, ".")); + } + + type = Comment$1; + } + + if (isVNode$1(type)) { + // createVNode receiving an existing vnode. This happens in cases like + // + // #2078 make sure to merge refs during the clone instead of overwriting it + var cloned = cloneVNode$1(type, props, true + /* mergeRef: true */ + ); + + if (children) { + normalizeChildren$1(cloned, children); + } + + return cloned; + } // class component normalization. + + + if (isClassComponent$1(type)) { + type = type.__vccOpts; + } // class & style normalization. + + + if (props) { + // for reactive or proxy objects, we need to clone it to enable mutation. + if (isProxy$1(props) || InternalObjectKey$1 in props) { + props = extend$1({}, props); + } + + var _props = props, + klass = _props.class, + style = _props.style; + + if (klass && !isString$1(klass)) { + props.class = normalizeClass$1(klass); + } + + if (isObject$1(style)) { + // reactive state objects need to be cloned since they are likely to be + // mutated + if (isProxy$1(style) && !isArray$1(style)) { + style = extend$1({}, style); + } + + props.style = normalizeStyle$1(style); + } + } // encode the vnode type information into a bitmap + + + var shapeFlag = isString$1(type) ? 1 + /* ELEMENT */ + : isSuspense$1(type) ? 128 + /* SUSPENSE */ + : isTeleport$1(type) ? 64 + /* TELEPORT */ + : isObject$1(type) ? 4 + /* STATEFUL_COMPONENT */ + : isFunction$1(type) ? 2 + /* FUNCTIONAL_COMPONENT */ + : 0; + + if (process.env.NODE_ENV !== 'production' && shapeFlag & 4 + /* STATEFUL_COMPONENT */ + && isProxy$1(type)) { + type = toRaw$1(type); + warn$1("Vue received a Component which was made a reactive object. This can " + "lead to unnecessary performance overhead, and should be avoided by " + "marking the component with `markRaw` or using `shallowRef` " + "instead of `ref`.", "\nComponent that was made reactive: ", type); + } + + var vnode = (_vnode = { + __v_isVNode: true + }, _defineProperty(_vnode, "__v_skip" + /* SKIP */ + , true), _defineProperty(_vnode, "type", type), _defineProperty(_vnode, "props", props), _defineProperty(_vnode, "key", props && normalizeKey$1(props)), _defineProperty(_vnode, "ref", props && normalizeRef$1(props)), _defineProperty(_vnode, "scopeId", currentScopeId$1), _defineProperty(_vnode, "children", null), _defineProperty(_vnode, "component", null), _defineProperty(_vnode, "suspense", null), _defineProperty(_vnode, "ssContent", null), _defineProperty(_vnode, "ssFallback", null), _defineProperty(_vnode, "dirs", null), _defineProperty(_vnode, "transition", null), _defineProperty(_vnode, "el", null), _defineProperty(_vnode, "anchor", null), _defineProperty(_vnode, "target", null), _defineProperty(_vnode, "targetAnchor", null), _defineProperty(_vnode, "staticCount", 0), _defineProperty(_vnode, "shapeFlag", shapeFlag), _defineProperty(_vnode, "patchFlag", patchFlag), _defineProperty(_vnode, "dynamicProps", dynamicProps), _defineProperty(_vnode, "dynamicChildren", null), _defineProperty(_vnode, "appContext", null), _vnode); // validate key + + if (process.env.NODE_ENV !== 'production' && vnode.key !== vnode.key) { + warn$1("VNode created with invalid key (NaN). VNode type:", vnode.type); + } + + normalizeChildren$1(vnode, children); // normalize suspense children + + if (shapeFlag & 128 + /* SUSPENSE */ + ) { + var _normalizeSuspenseChi = normalizeSuspenseChildren$1(vnode), + content = _normalizeSuspenseChi.content, + fallback = _normalizeSuspenseChi.fallback; + + vnode.ssContent = content; + vnode.ssFallback = fallback; + } + + if ( // avoid a block node from tracking itself + !isBlockNode && // has current parent block + currentBlock$1 && ( // presence of a patch flag indicates this node needs patching on updates. + // component nodes also should always be patched, because even if the + // component doesn't need to update, it needs to persist the instance on to + // the next vnode so that it can be properly unmounted later. + patchFlag > 0 || shapeFlag & 6 + /* COMPONENT */ + ) && // the EVENTS flag is only for hydration and if it is the only flag, the + // vnode should not be considered dynamic due to handler caching. + patchFlag !== 32 + /* HYDRATE_EVENTS */ + ) { + currentBlock$1.push(vnode); + } + + return vnode; + } + + function cloneVNode$1(vnode, extraProps) { + var _ref10; + + var mergeRef = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + // This is intentionally NOT using spread or extend to avoid the runtime + // key enumeration cost. + var props = vnode.props, + ref = vnode.ref, + patchFlag = vnode.patchFlag; + var mergedProps = extraProps ? mergeProps$1(props || {}, extraProps) : props; + return _ref10 = { + __v_isVNode: true + }, _defineProperty(_ref10, "__v_skip" + /* SKIP */ + , true), _defineProperty(_ref10, "type", vnode.type), _defineProperty(_ref10, "props", mergedProps), _defineProperty(_ref10, "key", mergedProps && normalizeKey$1(mergedProps)), _defineProperty(_ref10, "ref", extraProps && extraProps.ref ? // #2078 in the case of + // if the vnode itself already has a ref, cloneVNode will need to merge + // the refs so the single vnode can be set on multiple refs + mergeRef && ref ? isArray$1(ref) ? ref.concat(normalizeRef$1(extraProps)) : [ref, normalizeRef$1(extraProps)] : normalizeRef$1(extraProps) : ref), _defineProperty(_ref10, "scopeId", vnode.scopeId), _defineProperty(_ref10, "children", vnode.children), _defineProperty(_ref10, "target", vnode.target), _defineProperty(_ref10, "targetAnchor", vnode.targetAnchor), _defineProperty(_ref10, "staticCount", vnode.staticCount), _defineProperty(_ref10, "shapeFlag", vnode.shapeFlag), _defineProperty(_ref10, "patchFlag", extraProps && vnode.type !== Fragment$1 ? patchFlag === -1 // hoisted node + ? 16 + /* FULL_PROPS */ + : patchFlag | 16 + /* FULL_PROPS */ + : patchFlag), _defineProperty(_ref10, "dynamicProps", vnode.dynamicProps), _defineProperty(_ref10, "dynamicChildren", vnode.dynamicChildren), _defineProperty(_ref10, "appContext", vnode.appContext), _defineProperty(_ref10, "dirs", vnode.dirs), _defineProperty(_ref10, "transition", vnode.transition), _defineProperty(_ref10, "component", vnode.component), _defineProperty(_ref10, "suspense", vnode.suspense), _defineProperty(_ref10, "ssContent", vnode.ssContent && cloneVNode$1(vnode.ssContent)), _defineProperty(_ref10, "ssFallback", vnode.ssFallback && cloneVNode$1(vnode.ssFallback)), _defineProperty(_ref10, "el", vnode.el), _defineProperty(_ref10, "anchor", vnode.anchor), _ref10; + } + /** + * @private + */ + + + function createTextVNode$1() { + var text = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ' '; + var flag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + return createVNode$1(Text$1, null, text, flag); + } + + function normalizeVNode$1(child) { + if (child == null || typeof child === 'boolean') { + // empty placeholder + return createVNode$1(Comment$1); + } else if (isArray$1(child)) { + // fragment + return createVNode$1(Fragment$1, null, child); + } else if (_typeof(child) === 'object') { + // already vnode, this should be the most common since compiled templates + // always produce all-vnode children arrays + return child.el === null ? child : cloneVNode$1(child); + } else { + // strings and numbers + return createVNode$1(Text$1, null, String(child)); + } + } + + function normalizeChildren$1(vnode, children) { + var type = 0; + var shapeFlag = vnode.shapeFlag; + + if (children == null) { + children = null; + } else if (isArray$1(children)) { + type = 16 + /* ARRAY_CHILDREN */ + ; + } else if (_typeof(children) === 'object') { + if (shapeFlag & 1 + /* ELEMENT */ + || shapeFlag & 64 + /* TELEPORT */ + ) { + // Normalize slot to plain children for plain element and Teleport + var slot = children.default; + + if (slot) { + // _c marker is added by withCtx() indicating this is a compiled slot + slot._c && setCompiledSlotRendering$1(1); + normalizeChildren$1(vnode, slot()); + slot._c && setCompiledSlotRendering$1(-1); + } + + return; + } else { + type = 32 + /* SLOTS_CHILDREN */ + ; + var slotFlag = children._; + + if (!slotFlag && !(InternalObjectKey$1 in children)) { + children._ctx = currentRenderingInstance$1; + } else if (slotFlag === 3 + /* FORWARDED */ + && currentRenderingInstance$1) { + // a child component receives forwarded slots from the parent. + // its slot type is determined by its parent's slot type. + if (currentRenderingInstance$1.vnode.patchFlag & 1024 + /* DYNAMIC_SLOTS */ + ) { + children._ = 2 + /* DYNAMIC */ + ; + vnode.patchFlag |= 1024 + /* DYNAMIC_SLOTS */ + ; + } else { + children._ = 1 + /* STABLE */ + ; + } + } + } + } else if (isFunction$1(children)) { + children = { + default: children, + _ctx: currentRenderingInstance$1 + }; + type = 32 + /* SLOTS_CHILDREN */ + ; + } else { + children = String(children); // force teleport children to array so it can be moved around + + if (shapeFlag & 64 + /* TELEPORT */ + ) { + type = 16 + /* ARRAY_CHILDREN */ + ; + children = [createTextVNode$1(children)]; + } else { + type = 8 + /* TEXT_CHILDREN */ + ; + } + } + + vnode.children = children; + vnode.shapeFlag |= type; + } + + function mergeProps$1() { + var ret = extend$1({}, arguments.length <= 0 ? undefined : arguments[0]); + + for (var i = 1; i < arguments.length; i++) { + var toMerge = i < 0 || arguments.length <= i ? undefined : arguments[i]; + + for (var key in toMerge) { + if (key === 'class') { + if (ret.class !== toMerge.class) { + ret.class = normalizeClass$1([ret.class, toMerge.class]); + } + } else if (key === 'style') { + ret.style = normalizeStyle$1([ret.style, toMerge.style]); + } else if (isOn$1(key)) { + var existing = ret[key]; + var incoming = toMerge[key]; + + if (existing !== incoming) { + ret[key] = existing ? [].concat(existing, toMerge[key]) : incoming; + } + } else if (key !== '') { + ret[key] = toMerge[key]; + } + } + } + + return ret; + } + + var isInBeforeCreate$1 = false; + + function resolveMergedOptions$1(instance) { + var raw = instance.type; + var __merged = raw.__merged, + mixins = raw.mixins, + extendsOptions = raw.extends; + if (__merged) return __merged; + var globalMixins = instance.appContext.mixins; + if (!globalMixins.length && !mixins && !extendsOptions) return raw; + var options = {}; + globalMixins.forEach(function (m) { + return mergeOptions$1(options, m, instance); + }); + mergeOptions$1(options, raw, instance); + return raw.__merged = options; + } + + function mergeOptions$1(to, from, instance) { + var strats = instance.appContext.config.optionMergeStrategies; + var mixins = from.mixins, + extendsOptions = from.extends; + extendsOptions && mergeOptions$1(to, extendsOptions, instance); + mixins && mixins.forEach(function (m) { + return mergeOptions$1(to, m, instance); + }); + + for (var key in from) { + if (strats && hasOwn$1(strats, key)) { + to[key] = strats[key](to[key], from[key], instance.proxy, key); + } else { + to[key] = from[key]; + } + } + } + /** + * #2437 In Vue 3, functional components do not have a public instance proxy but + * they exist in the internal parent chain. For code that relies on traversing + * public $parent chains, skip functional ones and go to the parent instead. + */ + + + var getPublicInstance$1 = function getPublicInstance(i) { + return i && (i.proxy ? i.proxy : getPublicInstance(i.parent)); + }; + + var publicPropertiesMap$1 = extend$1(Object.create(null), { + $: function $(i) { + return i; + }, + $el: function $el(i) { + return i.vnode.el; + }, + $data: function $data(i) { + return i.data; + }, + $props: function $props(i) { + return process.env.NODE_ENV !== 'production' ? shallowReadonly$1(i.props) : i.props; + }, + $attrs: function $attrs(i) { + return process.env.NODE_ENV !== 'production' ? shallowReadonly$1(i.attrs) : i.attrs; + }, + $slots: function $slots(i) { + return process.env.NODE_ENV !== 'production' ? shallowReadonly$1(i.slots) : i.slots; + }, + $refs: function $refs(i) { + return process.env.NODE_ENV !== 'production' ? shallowReadonly$1(i.refs) : i.refs; + }, + $parent: function $parent(i) { + return getPublicInstance$1(i.parent); + }, + $root: function $root(i) { + return i.root && i.root.proxy; + }, + $emit: function $emit(i) { + return i.emit; + }, + $options: function $options(i) { + return __VUE_OPTIONS_API__ ? resolveMergedOptions$1(i) : i.type; + }, + $forceUpdate: function $forceUpdate(i) { + return function () { + return queueJob$1(i.update); + }; + }, + $nextTick: function $nextTick(i) { + return nextTick$1.bind(i.proxy); + }, + $watch: function $watch(i) { + return __VUE_OPTIONS_API__ ? instanceWatch$1.bind(i) : NOOP$1; + } + }); + var PublicInstanceProxyHandlers$1 = { + get: function get(_ref11, key) { + var instance = _ref11._; + var ctx = instance.ctx, + setupState = instance.setupState, + data = instance.data, + props = instance.props, + accessCache = instance.accessCache, + type = instance.type, + appContext = instance.appContext; // let @vue/reactivity know it should never observe Vue public instances. + + if (key === "__v_skip" + /* SKIP */ + ) { + return true; + } // for internal formatters to know that this is a Vue instance + + + if (process.env.NODE_ENV !== 'production' && key === '__isVue') { + return true; + } // data / props / ctx + // This getter gets called for every property access on the render context + // during render and is a major hotspot. The most expensive part of this + // is the multiple hasOwn() calls. It's much faster to do a simple property + // access on a plain object, so we use an accessCache object (with null + // prototype) to memoize what access type a key corresponds to. + + + var normalizedProps; + + if (key[0] !== '$') { + var n = accessCache[key]; + + if (n !== undefined) { + switch (n) { + case 0 + /* SETUP */ + : + return setupState[key]; + + case 1 + /* DATA */ + : + return data[key]; + + case 3 + /* CONTEXT */ + : + return ctx[key]; + + case 2 + /* PROPS */ + : + return props[key]; + // default: just fallthrough + } + } else if (setupState !== EMPTY_OBJ$1 && hasOwn$1(setupState, key)) { + accessCache[key] = 0 + /* SETUP */ + ; + return setupState[key]; + } else if (data !== EMPTY_OBJ$1 && hasOwn$1(data, key)) { + accessCache[key] = 1 + /* DATA */ + ; + return data[key]; + } else if ( // only cache other properties when instance has declared (thus stable) + // props + (normalizedProps = instance.propsOptions[0]) && hasOwn$1(normalizedProps, key)) { + accessCache[key] = 2 + /* PROPS */ + ; + return props[key]; + } else if (ctx !== EMPTY_OBJ$1 && hasOwn$1(ctx, key)) { + accessCache[key] = 3 + /* CONTEXT */ + ; + return ctx[key]; + } else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate$1) { + accessCache[key] = 4 + /* OTHER */ + ; + } + } + + var publicGetter = publicPropertiesMap$1[key]; + var cssModule, globalProperties; // public $xxx properties + + if (publicGetter) { + if (key === '$attrs') { + track$1(instance, "get" + /* GET */ + , key); + process.env.NODE_ENV !== 'production' && markAttrsAccessed$1(); + } + + return publicGetter(instance); + } else if ( // css module (injected by vue-loader) + (cssModule = type.__cssModules) && (cssModule = cssModule[key])) { + return cssModule; + } else if (ctx !== EMPTY_OBJ$1 && hasOwn$1(ctx, key)) { + // user may set custom properties to `this` that start with `$` + accessCache[key] = 3 + /* CONTEXT */ + ; + return ctx[key]; + } else if ( // global properties + globalProperties = appContext.config.globalProperties, hasOwn$1(globalProperties, key)) { + return globalProperties[key]; + } else if (process.env.NODE_ENV !== 'production' && currentRenderingInstance$1 && (!isString$1(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading + // to infinite warning loop + key.indexOf('__v') !== 0)) { + if (data !== EMPTY_OBJ$1 && (key[0] === '$' || key[0] === '_') && hasOwn$1(data, key)) { + warn$1("Property ".concat(JSON.stringify(key), " must be accessed via $data because it starts with a reserved ") + "character (\"$\" or \"_\") and is not proxied on the render context."); + } else { + warn$1("Property ".concat(JSON.stringify(key), " was accessed during render ") + "but is not defined on instance."); + } + } + }, + set: function set(_ref12, key, value) { + var instance = _ref12._; + var data = instance.data, + setupState = instance.setupState, + ctx = instance.ctx; + + if (setupState !== EMPTY_OBJ$1 && hasOwn$1(setupState, key)) { + setupState[key] = value; + } else if (data !== EMPTY_OBJ$1 && hasOwn$1(data, key)) { + data[key] = value; + } else if (key in instance.props) { + process.env.NODE_ENV !== 'production' && warn$1("Attempting to mutate prop \"".concat(key, "\". Props are readonly."), instance); + return false; + } + + if (key[0] === '$' && key.slice(1) in instance) { + process.env.NODE_ENV !== 'production' && warn$1("Attempting to mutate public property \"".concat(key, "\". ") + "Properties starting with $ are reserved and readonly.", instance); + return false; + } else { + if (process.env.NODE_ENV !== 'production' && key in instance.appContext.config.globalProperties) { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + value: value + }); + } else { + ctx[key] = value; + } + } + + return true; + }, + has: function has(_ref13, key) { + var _ref13$_ = _ref13._, + data = _ref13$_.data, + setupState = _ref13$_.setupState, + accessCache = _ref13$_.accessCache, + ctx = _ref13$_.ctx, + appContext = _ref13$_.appContext, + propsOptions = _ref13$_.propsOptions; + var normalizedProps; + return accessCache[key] !== undefined || data !== EMPTY_OBJ$1 && hasOwn$1(data, key) || setupState !== EMPTY_OBJ$1 && hasOwn$1(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn$1(normalizedProps, key) || hasOwn$1(ctx, key) || hasOwn$1(publicPropertiesMap$1, key) || hasOwn$1(appContext.config.globalProperties, key); + } + }; + + if (process.env.NODE_ENV !== 'production' && !false) { + PublicInstanceProxyHandlers$1.ownKeys = function (target) { + warn$1("Avoid app logic that relies on enumerating keys on a component instance. " + "The keys will be empty in production mode to avoid performance overhead."); + return Reflect.ownKeys(target); + }; + } + + var RuntimeCompiledPublicInstanceProxyHandlers$1 = extend$1({}, PublicInstanceProxyHandlers$1, { + get: function get(target, key) { + // fast path for unscopables when using `with` block + if (key === Symbol.unscopables) { + return; + } + + return PublicInstanceProxyHandlers$1.get(target, key, target); + }, + has: function has(_, key) { + var has = key[0] !== '_' && !isGloballyWhitelisted$1(key); + + if (process.env.NODE_ENV !== 'production' && !has && PublicInstanceProxyHandlers$1.has(_, key)) { + warn$1("Property ".concat(JSON.stringify(key), " should not start with _ which is a reserved prefix for Vue internals.")); + } + + return has; + } + }); + var currentInstance$1 = null; // record effects created during a component's setup() so that they can be + // stopped when the component unmounts + + function recordInstanceBoundEffect$1(effect) { + var instance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance$1; + + if (instance) { + (instance.effects || (instance.effects = [])).push(effect); + } + } + + var classifyRE$1 = /(?:^|[-_])(\w)/g; + + var classify$1 = function classify(str) { + return str.replace(classifyRE$1, function (c) { + return c.toUpperCase(); + }).replace(/[-_]/g, ''); + }; + /* istanbul ignore next */ + + + function formatComponentName$1(instance, Component) { + var isRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var name = isFunction$1(Component) ? Component.displayName || Component.name : Component.name; + + if (!name && Component.__file) { + var match = Component.__file.match(/([^/\\]+)\.\w+$/); + + if (match) { + name = match[1]; + } + } + + if (!name && instance && instance.parent) { + // try to infer the name based on reverse resolution + var inferFromRegistry = function inferFromRegistry(registry) { + for (var key in registry) { + if (registry[key] === Component) { + return key; + } + } + }; + + name = inferFromRegistry(instance.components || instance.parent.type.components) || inferFromRegistry(instance.appContext.components); + } + + return name ? classify$1(name) : isRoot ? "App" : "Anonymous"; + } + + function isClassComponent$1(value) { + return isFunction$1(value) && '__vccOpts' in value; + } + + var ssrContextKey$1 = Symbol(process.env.NODE_ENV !== 'production' ? "ssrContext" : ""); + + function initCustomFormatter$1() { + /* eslint-disable no-restricted-globals */ + if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') { + return; + } + + var vueStyle = { + style: 'color:#3ba776' + }; + var numberStyle = { + style: 'color:#0b1bc9' + }; + var stringStyle = { + style: 'color:#b62e24' + }; + var keywordStyle = { + style: 'color:#9d288c' + }; // custom formatter for Chrome + // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html + + var formatter = { + header: function header(obj) { + // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup + if (!isObject$1(obj)) { + return null; + } + + if (obj.__isVue) { + return ['div', vueStyle, "VueInstance"]; + } else if (isRef$1(obj)) { + return ['div', {}, ['span', vueStyle, genRefFlag(obj)], '<', formatValue(obj.value), ">"]; + } else if (isReactive$1(obj)) { + return ['div', {}, ['span', vueStyle, 'Reactive'], '<', formatValue(obj), ">".concat(isReadonly$1(obj) ? " (readonly)" : "")]; + } else if (isReadonly$1(obj)) { + return ['div', {}, ['span', vueStyle, 'Readonly'], '<', formatValue(obj), '>']; + } + + return null; + }, + hasBody: function hasBody(obj) { + return obj && obj.__isVue; + }, + body: function body(obj) { + if (obj && obj.__isVue) { + return ['div', {}].concat(_toConsumableArray(formatInstance(obj.$))); + } + } + }; + + function formatInstance(instance) { + var blocks = []; + + if (instance.type.props && instance.props) { + blocks.push(createInstanceBlock('props', toRaw$1(instance.props))); + } + + if (instance.setupState !== EMPTY_OBJ$1) { + blocks.push(createInstanceBlock('setup', instance.setupState)); + } + + if (instance.data !== EMPTY_OBJ$1) { + blocks.push(createInstanceBlock('data', toRaw$1(instance.data))); + } + + var computed = extractKeys(instance, 'computed'); + + if (computed) { + blocks.push(createInstanceBlock('computed', computed)); + } + + var injected = extractKeys(instance, 'inject'); + + if (injected) { + blocks.push(createInstanceBlock('injected', injected)); + } + + blocks.push(['div', {}, ['span', { + style: keywordStyle.style + ';opacity:0.66' + }, '$ (internal): '], ['object', { + object: instance + }]]); + return blocks; + } + + function createInstanceBlock(type, target) { + target = extend$1({}, target); + + if (!Object.keys(target).length) { + return ['span', {}]; + } + + return ['div', { + style: 'line-height:1.25em;margin-bottom:0.6em' + }, ['div', { + style: 'color:#476582' + }, type], ['div', { + style: 'padding-left:1.25em' + }].concat(_toConsumableArray(Object.keys(target).map(function (key) { + return ['div', {}, ['span', keywordStyle, key + ': '], formatValue(target[key], false)]; + })))]; + } + + function formatValue(v) { + var asRaw = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + + if (typeof v === 'number') { + return ['span', numberStyle, v]; + } else if (typeof v === 'string') { + return ['span', stringStyle, JSON.stringify(v)]; + } else if (typeof v === 'boolean') { + return ['span', keywordStyle, v]; + } else if (isObject$1(v)) { + return ['object', { + object: asRaw ? toRaw$1(v) : v + }]; + } else { + return ['span', stringStyle, String(v)]; + } + } + + function extractKeys(instance, type) { + var Comp = instance.type; + + if (isFunction$1(Comp)) { + return; + } + + var extracted = {}; + + for (var key in instance.ctx) { + if (isKeyOfType(Comp, key, type)) { + extracted[key] = instance.ctx[key]; + } + } + + return extracted; + } + + function isKeyOfType(Comp, key, type) { + var opts = Comp[type]; + + if (isArray$1(opts) && opts.includes(key) || isObject$1(opts) && key in opts) { + return true; + } + + if (Comp.extends && isKeyOfType(Comp.extends, key, type)) { + return true; + } + + if (Comp.mixins && Comp.mixins.some(function (m) { + return isKeyOfType(m, key, type); + })) { + return true; + } + } + + function genRefFlag(v) { + if (v._shallow) { + return "ShallowRef"; + } + + if (v.effect) { + return "ComputedRef"; + } + + return "Ref"; + } + + if (window.devtoolsFormatters) { + window.devtoolsFormatters.push(formatter); + } else { + window.devtoolsFormatters = [formatter]; + } + } + + var svgNS = 'http://www.w3.org/2000/svg'; + var doc = typeof document !== 'undefined' ? document : null; + var tempContainer; + var tempSVGContainer; + var nodeOps = { + insert: function insert(child, parent, anchor) { + parent.insertBefore(child, anchor || null); + }, + remove: function remove(child) { + var parent = child.parentNode; + + if (parent) { + parent.removeChild(child); + } + }, + createElement: function createElement(tag, isSVG, is) { + return isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? { + is: is + } : undefined); + }, + createText: function createText(text) { + return doc.createTextNode(text); + }, + createComment: function createComment(text) { + return doc.createComment(text); + }, + setText: function setText(node, text) { + node.nodeValue = text; + }, + setElementText: function setElementText(el, text) { + el.textContent = text; + }, + parentNode: function parentNode(node) { + return node.parentNode; + }, + nextSibling: function nextSibling(node) { + return node.nextSibling; + }, + querySelector: function querySelector(selector) { + return doc.querySelector(selector); + }, + setScopeId: function setScopeId(el, id) { + el.setAttribute(id, ''); + }, + cloneNode: function cloneNode(el) { + return el.cloneNode(true); + }, + // __UNSAFE__ + // Reason: innerHTML. + // Static content here can only come from compiled templates. + // As long as the user only uses trusted templates, this is safe. + insertStaticContent: function insertStaticContent(content, parent, anchor, isSVG) { + var temp = isSVG ? tempSVGContainer || (tempSVGContainer = doc.createElementNS(svgNS, 'svg')) : tempContainer || (tempContainer = doc.createElement('div')); + temp.innerHTML = content; + var first = temp.firstChild; + var node = first; + var last = node; + + while (node) { + last = node; + nodeOps.insert(node, parent, anchor); + node = temp.firstChild; + } + + return [first, last]; + } + }; // compiler should normalize class + :class bindings on the same element + // into a single binding ['staticClass', dynamic] + + function patchClass(el, value, isSVG) { + if (value == null) { + value = ''; + } + + if (isSVG) { + el.setAttribute('class', value); + } else { + // directly setting className should be faster than setAttribute in theory + // if this is an element during a transition, take the temporary transition + // classes into account. + var transitionClasses = el._vtc; + + if (transitionClasses) { + value = (value ? [value].concat(_toConsumableArray(transitionClasses)) : _toConsumableArray(transitionClasses)).join(' '); + } + + el.className = value; + } + } + + function patchStyle(el, prev, next) { + var style = el.style; + + if (!next) { + el.removeAttribute('style'); + } else if (isString$1(next)) { + if (prev !== next) { + style.cssText = next; + } + } else { + for (var key in next) { + setStyle(style, key, next[key]); + } + + if (prev && !isString$1(prev)) { + for (var _key6 in prev) { + if (next[_key6] == null) { + setStyle(style, _key6, ''); + } + } + } + } } - function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { - value: value, - enumerable: true, - configurable: true, - writable: true + var importantRE = /\s*!important$/; + + function setStyle(style, name, val) { + if (isArray$1(val)) { + val.forEach(function (v) { + return setStyle(style, name, v); }); } else { - obj[key] = value; - } + if (name.startsWith('--')) { + // custom property definition + style.setProperty(name, val); + } else { + var prefixed = autoPrefix(style, name); - return obj; + if (importantRE.test(val)) { + // !important + style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important'); + } else { + style[prefixed] = val; + } + } + } } - function ownKeys(object, enumerableOnly) { - var keys = Object.keys(object); + var prefixes = ['Webkit', 'Moz', 'ms']; + var prefixCache = {}; - if (Object.getOwnPropertySymbols) { - var symbols = Object.getOwnPropertySymbols(object); - if (enumerableOnly) symbols = symbols.filter(function (sym) { - return Object.getOwnPropertyDescriptor(object, sym).enumerable; - }); - keys.push.apply(keys, symbols); + function autoPrefix(style, rawName) { + var cached = prefixCache[rawName]; + + if (cached) { + return cached; } - return keys; - } + var name = camelize(rawName); - function _objectSpread2(target) { - for (var i = 1; i < arguments.length; i++) { - var source = arguments[i] != null ? arguments[i] : {}; + if (name !== 'filter' && name in style) { + return prefixCache[rawName] = name; + } - if (i % 2) { - ownKeys(Object(source), true).forEach(function (key) { - _defineProperty(target, key, source[key]); - }); - } else if (Object.getOwnPropertyDescriptors) { - Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); - } else { - ownKeys(Object(source)).forEach(function (key) { - Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); - }); + name = capitalize$1(name); + + for (var i = 0; i < prefixes.length; i++) { + var prefixed = prefixes[i] + name; + + if (prefixed in style) { + return prefixCache[rawName] = prefixed; } } - return target; + return rawName; } - function _unsupportedIterableToArray(o, minLen) { - if (!o) return; - if (typeof o === "string") return _arrayLikeToArray(o, minLen); - var n = Object.prototype.toString.call(o).slice(8, -1); - if (n === "Object" && o.constructor) n = o.constructor.name; - if (n === "Map" || n === "Set") return Array.from(n); - if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); - } + var xlinkNS = 'http://www.w3.org/1999/xlink'; - function _arrayLikeToArray(arr, len) { - if (len == null || len > arr.length) len = arr.length; + function patchAttr(el, key, value, isSVG) { + if (isSVG && key.startsWith('xlink:')) { + if (value == null) { + el.removeAttributeNS(xlinkNS, key.slice(6, key.length)); + } else { + el.setAttributeNS(xlinkNS, key, value); + } + } else { + // note we are only checking boolean attributes that don't have a + // corresponding dom prop of the same name here. + var isBoolean = isSpecialBooleanAttr(key); - for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + if (value == null || isBoolean && value === false) { + el.removeAttribute(key); + } else { + el.setAttribute(key, isBoolean ? '' : value); + } + } + } // __UNSAFE__ + // functions. The user is responsible for using them with only trusted content. - return arr2; - } - function _createForOfIteratorHelper(o) { - if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { - if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { - var i = 0; + function patchDOMProp(el, key, value, // the following args are passed only due to potential innerHTML/textContent + // overriding existing VNodes, in which case the old tree must be properly + // unmounted. + prevChildren, parentComponent, parentSuspense, unmountChildren) { + if (key === 'innerHTML' || key === 'textContent') { + if (prevChildren) { + unmountChildren(prevChildren, parentComponent, parentSuspense); + } - var F = function () {}; + el[key] = value == null ? '' : value; + return; + } - return { - s: F, - n: function () { - if (i >= o.length) return { - done: true - }; - return { - done: false, - value: o[i++] - }; - }, - e: function (e) { - throw e; - }, - f: F - }; + if (key === 'value' && el.tagName !== 'PROGRESS') { + // store value as _value as well since + // non-string values will be stringified. + el._value = value; + var newValue = value == null ? '' : value; + + if (el.value !== newValue) { + el.value = newValue; } - throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + return; } - var it, - normalCompletion = true, - didErr = false, - err; - return { - s: function () { - it = o[Symbol.iterator](); - }, - n: function () { - var step = it.next(); - normalCompletion = step.done; - return step; - }, - e: function (e) { - didErr = true; - err = e; - }, - f: function () { - try { - if (!normalCompletion && it.return != null) it.return(); - } finally { - if (didErr) throw err; - } + if (value === '' || value == null) { + var type = _typeof(el[key]); + + if (value === '' && type === 'boolean') { + // e.g. with + // :true-value & :false-value + // store value as dom properties since non-string values will be + // stringified. + if (key === 'true-value') { + el._trueValue = nextValue; + } else if (key === 'false-value') { + el._falseValue = nextValue; + } + + patchAttr(el, key, nextValue, isSVG); + } + + break; + } + }; + + function shouldSetAsProp(el, key, value, isSVG) { + if (isSVG) { + // most keys must be set as attribute on svg elements to work + // ...except innerHTML + if (key === 'innerHTML') { + return true; + } // or native onclick with function values + + + if (key in el && nativeOnRE.test(key) && isFunction$1(value)) { + return true; + } + + return false; + } // spellcheck and draggable are numerated attrs, however their + // corresponding DOM properties are actually booleans - this leads to + // setting it with a string "false" value leading it to be coerced to + // `true`, so we need to always treat them as attributes. + // Note that `contentEditable` doesn't have this problem: its DOM + // property is also enumerated string values. + + + if (key === 'spellcheck' || key === 'draggable') { + return false; + } // #1787 form as an attribute must be a string, while it accepts an Element as + // a prop + + + if (key === 'form' && typeof value === 'string') { + return false; + } // #1526 must be set as attribute + + + if (key === 'list' && el.tagName === 'INPUT') { + return false; + } // native onclick with string value, must be set as attribute + + + if (nativeOnRE.test(key) && isString$1(value)) { + return false; + } + + return key in el; } + var rendererOptions = extend$1({ + patchProp: patchProp, + forcePatchProp: forcePatchProp + }, nodeOps); + + function initDev$1() { + var target = getGlobalThis$1(); + target.__VUE__ = true; + setDevtoolsHook$1(target.__VUE_DEVTOOLS_GLOBAL_HOOK__); + { + initCustomFormatter$1(); + } + } // This entry exports the runtime only, and is built as + + + process.env.NODE_ENV !== 'production' && initDev$1(); + function processOptions(value) { var options; @@ -331,6 +6817,7 @@ return options; } + function throttle(callback, delay) { var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; var timeout; @@ -351,13 +6838,13 @@ } if ((!timeout || state !== lastState) && leading) { - callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs))); + callback.apply(void 0, [state].concat(_toConsumableArray$1(currentArgs))); } lastState = state; clearTimeout(timeout); timeout = setTimeout(function () { - callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs))); + callback.apply(void 0, [state].concat(_toConsumableArray$1(currentArgs))); timeout = 0; }, delay); }; @@ -369,6 +6856,7 @@ return throttled; } + function deepEqual(val1, val2) { if (val1 === val2) return true; @@ -385,9 +6873,7 @@ return false; } - var VisibilityState = - /*#__PURE__*/ - function () { + var VisibilityState = /*#__PURE__*/function () { function VisibilityState(el, options, vnode) { _classCallCheck(this, VisibilityState); @@ -455,7 +6941,7 @@ } }, this.options.intersection); // Wait for the element to be in document - vnode.context.$nextTick(function () { + nextTick$1(function () { if (_this.observer) { _this.observer.observe(_this.el); } @@ -528,9 +7014,9 @@ } var ObserveVisibility = { - bind: bind, - update: update, - unbind: unbind + beforeMount: bind, + updated: update, + unmounted: unbind }; function install$1(Vue) { @@ -542,12 +7028,12 @@ /* You shouldn't have to modify the code below */ // Plugin + var plugin$1 = { // eslint-disable-next-line no-undef version: "0.4.6", install: install$1 }; - var GlobalVue$1 = null; if (typeof window !== 'undefined') { @@ -650,11 +7136,11 @@ } catch (e) {} } - var uid = 0; - var script = { + var uid$2 = 0; + var script$1 = { name: 'RecycleScroller', components: { - ResizeObserver: ResizeObserver$1 + ResizeObserver: script }, directives: { ObserveVisibility: ObserveVisibility @@ -781,25 +7267,21 @@ _this.ready = true; }); }, - beforeDestroy: function beforeDestroy() { + beforeUnmount: function beforeUnmount() { this.removeListeners(); }, methods: { addView: function addView(pool, index, item, key, type) { - var view = { + var view = vue.shallowReactive({ item: item, - position: 0 - }; - var nonReactive = { - id: uid++, - index: index, - used: true, - key: key, - type: type - }; - Object.defineProperty(view, 'nr', { - configurable: false, - value: nonReactive + position: 0, + nr: { + id: uid$2++, + index: index, + used: true, + key: key, + type: type + } }); pool.push(view); return view; @@ -1176,224 +7658,73 @@ } }; - function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) { - if (typeof shadowMode !== 'boolean') { - createInjectorSSR = createInjector; - createInjector = shadowMode; - shadowMode = false; - } - // Vue.extend constructor export interop. - const options = typeof script === 'function' ? script.options : script; - // render functions - if (template && template.render) { - options.render = template.render; - options.staticRenderFns = template.staticRenderFns; - options._compiled = true; - // functional template - if (isFunctionalTemplate) { - options.functional = true; - } - } - // scopedId - if (scopeId) { - options._scopeId = scopeId; - } - let hook; - if (moduleIdentifier) { - // server build - hook = function (context) { - // 2.3 injection - context = - context || // cached call - (this.$vnode && this.$vnode.ssrContext) || // stateful - (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext); // functional - // 2.2 with runInNewContext: true - if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') { - context = __VUE_SSR_CONTEXT__; - } - // inject component styles - if (style) { - style.call(this, createInjectorSSR(context)); - } - // register component module identifier for async chunk inference - if (context && context._registeredComponents) { - context._registeredComponents.add(moduleIdentifier); - } - }; - // used by ssr in case component is cached and beforeCreate - // never gets called - options._ssrRegister = hook; - } - else if (style) { - hook = shadowMode - ? function (context) { - style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot)); - } - : function (context) { - style.call(this, createInjector(context)); - }; - } - if (hook) { - if (options.functional) { - // register for functional component in vue file - const originalRender = options.render; - options.render = function renderWithStyleInjection(h, context) { - hook.call(context); - return originalRender(h, context); - }; - } - else { - // inject component registration as beforeCreate hook - const existing = options.beforeCreate; - options.beforeCreate = existing ? [].concat(existing, hook) : [hook]; - } - } - return script; - } - - /* script */ - const __vue_script__ = script; - /* template */ - var __vue_render__ = function() { - var _obj, _obj$1; - var _vm = this; - var _h = _vm.$createElement; - var _c = _vm._self._c || _h; - return _c( - "div", - { - directives: [ - { - name: "observe-visibility", - rawName: "v-observe-visibility", - value: _vm.handleVisibilityChange, - expression: "handleVisibilityChange" - } - ], - staticClass: "vue-recycle-scroller", - class: - ((_obj = { - ready: _vm.ready, - "page-mode": _vm.pageMode - }), - (_obj["direction-" + _vm.direction] = true), - _obj), - on: { - "&scroll": function($event) { - return _vm.handleScroll($event) - } - } - }, - [ - _vm.$slots.before - ? _c( - "div", - { staticClass: "vue-recycle-scroller__slot" }, - [_vm._t("before")], - 2 - ) - : _vm._e(), - _vm._v(" "), - _c( - "div", - { - ref: "wrapper", - staticClass: "vue-recycle-scroller__item-wrapper", - style: - ((_obj$1 = {}), - (_obj$1[_vm.direction === "vertical" ? "minHeight" : "minWidth"] = - _vm.totalSize + "px"), - _obj$1) - }, - _vm._l(_vm.pool, function(view) { - return _c( - "div", - { - key: view.nr.id, - staticClass: "vue-recycle-scroller__item-view", - class: { hover: _vm.hoverKey === view.nr.key }, - style: _vm.ready - ? { - transform: - "translate" + - (_vm.direction === "vertical" ? "Y" : "X") + - "(" + - view.position + - "px)" - } - : null, - on: { - mouseenter: function($event) { - _vm.hoverKey = view.nr.key; - }, - mouseleave: function($event) { - _vm.hoverKey = null; - } - } - }, - [ - _vm._t("default", null, { - item: view.item, - index: view.nr.index, - active: view.nr.used - }) - ], - 2 - ) - }), - 0 - ), - _vm._v(" "), - _vm.$slots.after - ? _c( - "div", - { staticClass: "vue-recycle-scroller__slot" }, - [_vm._t("after")], - 2 - ) - : _vm._e(), - _vm._v(" "), - _c("ResizeObserver", { on: { notify: _vm.handleResize } }) - ], - 1 - ) - }; - var __vue_staticRenderFns__ = []; - __vue_render__._withStripped = true; - - /* style */ - const __vue_inject_styles__ = undefined; - /* scoped */ - const __vue_scope_id__ = undefined; - /* module identifier */ - const __vue_module_identifier__ = undefined; - /* functional template */ - const __vue_is_functional_template__ = false; - /* style inject */ - - /* style inject SSR */ - - /* style inject shadow dom */ - - - - const __vue_component__ = normalizeComponent( - { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ }, - __vue_inject_styles__, - __vue_script__, - __vue_scope_id__, - __vue_is_functional_template__, - __vue_module_identifier__, - false, - undefined, - undefined, - undefined - ); + var _hoisted_1$1 = { + key: 0, + class: "vue-recycle-scroller__slot" + }; + var _hoisted_2 = { + key: 1, + class: "vue-recycle-scroller__slot" + }; + function render$1(_ctx, _cache, $props, $setup, $data, $options) { + var _component_ResizeObserver = vue.resolveComponent("ResizeObserver"); + + var _directive_observe_visibility = vue.resolveDirective("observe-visibility"); + + return vue.withDirectives((vue.openBlock(), vue.createBlock("div", { + class: ["vue-recycle-scroller", _defineProperty({ + ready: $data.ready, + 'page-mode': $props.pageMode + }, "direction-".concat(_ctx.direction), true)], + onScrollPassive: _cache[2] || (_cache[2] = function () { + return $options.handleScroll && $options.handleScroll.apply($options, arguments); + }) + }, [_ctx.$slots.before ? (vue.openBlock(), vue.createBlock("div", _hoisted_1$1, [vue.renderSlot(_ctx.$slots, "before")])) : vue.createCommentVNode("v-if", true), vue.createVNode("div", { + ref: "wrapper", + style: _defineProperty({}, _ctx.direction === 'vertical' ? 'minHeight' : 'minWidth', $data.totalSize + 'px'), + class: "vue-recycle-scroller__item-wrapper" + }, [(vue.openBlock(true), vue.createBlock(vue.Fragment, null, vue.renderList($data.pool, function (view) { + return vue.openBlock(), vue.createBlock("div", { + key: view.nr.id, + style: $data.ready ? { + transform: "translate".concat(_ctx.direction === 'vertical' ? 'Y' : 'X', "(").concat(view.position, "px)") + } : null, + class: ["vue-recycle-scroller__item-view", { + hover: $data.hoverKey === view.nr.key + }], + onMouseenter: function onMouseenter($event) { + return $data.hoverKey = view.nr.key; + }, + onMouseleave: _cache[1] || (_cache[1] = function ($event) { + return $data.hoverKey = null; + }) + }, [vue.renderSlot(_ctx.$slots, "default", { + item: view.item, + index: view.nr.index, + active: view.nr.used + })], 46 + /* CLASS, STYLE, PROPS, HYDRATE_EVENTS */ + , ["onMouseenter"]); + }), 128 + /* KEYED_FRAGMENT */ + ))], 4 + /* STYLE */ + ), _ctx.$slots.after ? (vue.openBlock(), vue.createBlock("div", _hoisted_2, [vue.renderSlot(_ctx.$slots, "after")])) : vue.createCommentVNode("v-if", true), vue.createVNode(_component_ResizeObserver, { + onNotify: $options.handleResize + }, null, 8 + /* PROPS */ + , ["onNotify"])], 34 + /* CLASS, HYDRATE_EVENTS */ + )), [[_directive_observe_visibility, $options.handleVisibilityChange]]); + } - var script$1 = { + script$1.render = render$1; + script$1.__file = "src/components/RecycleScroller.vue"; + + var script$2 = { name: 'DynamicScroller', components: { - RecycleScroller: __vue_component__ + RecycleScroller: script$1 }, inheritAttrs: false, provide: function provide() { @@ -1575,98 +7906,48 @@ } }; - /* script */ - const __vue_script__$1 = script$1; - - /* template */ - var __vue_render__$1 = function() { - var _vm = this; - var _h = _vm.$createElement; - var _c = _vm._self._c || _h; - return _c( - "RecycleScroller", - _vm._g( - _vm._b( - { - ref: "scroller", - attrs: { - items: _vm.itemsWithSize, - "min-item-size": _vm.minItemSize, - direction: _vm.direction, - "key-field": "id" - }, - on: { resize: _vm.onScrollerResize, visible: _vm.onScrollerVisible }, - scopedSlots: _vm._u( - [ - { - key: "default", - fn: function(ref) { - var itemWithSize = ref.item; - var index = ref.index; - var active = ref.active; - return [ - _vm._t("default", null, null, { - item: itemWithSize.item, - index: index, - active: active, - itemWithSize: itemWithSize - }) - ] - } - } - ], - null, - true - ) - }, - "RecycleScroller", - _vm.$attrs, - false - ), - _vm.listeners - ), - [ - _vm._v(" "), - _c("template", { slot: "before" }, [_vm._t("before")], 2), - _vm._v(" "), - _c("template", { slot: "after" }, [_vm._t("after")], 2) - ], - 2 - ) - }; - var __vue_staticRenderFns__$1 = []; - __vue_render__$1._withStripped = true; - - /* style */ - const __vue_inject_styles__$1 = undefined; - /* scoped */ - const __vue_scope_id__$1 = undefined; - /* module identifier */ - const __vue_module_identifier__$1 = undefined; - /* functional template */ - const __vue_is_functional_template__$1 = false; - /* style inject */ - - /* style inject SSR */ - - /* style inject shadow dom */ - - - - const __vue_component__$1 = normalizeComponent( - { render: __vue_render__$1, staticRenderFns: __vue_staticRenderFns__$1 }, - __vue_inject_styles__$1, - __vue_script__$1, - __vue_scope_id__$1, - __vue_is_functional_template__$1, - __vue_module_identifier__$1, - false, - undefined, - undefined, - undefined - ); + var _hoisted_1$2 = { + "slot-scope": "{ item: itemWithSize, index, active }" + }; + var _hoisted_2$1 = { + slot: "before" + }; + var _hoisted_3 = { + slot: "after" + }; + function render$2(_ctx, _cache, $props, $setup, $data, $options) { + var _component_RecycleScroller = vue.resolveComponent("RecycleScroller"); + + return vue.openBlock(), vue.createBlock(_component_RecycleScroller, vue.mergeProps({ + ref: "scroller", + items: $options.itemsWithSize, + "min-item-size": $props.minItemSize, + direction: _ctx.direction, + "key-field": "id" + }, _ctx.$attrs, { + onResize: $options.onScrollerResize, + onVisible: $options.onScrollerVisible + }, vue.toHandlers($options.listeners)), { + default: vue.withCtx(function () { + return [vue.createVNode("template", _hoisted_1$2, [vue.renderSlot(_ctx.$slots, "default", { + item: _ctx.itemWithSize.item, + index: _ctx.index, + active: _ctx.active, + itemWithSize: _ctx.itemWithSize + })]), vue.createVNode("template", _hoisted_2$1, [vue.renderSlot(_ctx.$slots, "before")]), vue.createVNode("template", _hoisted_3, [vue.renderSlot(_ctx.$slots, "after")])]; + }), + _: 3 + /* FORWARDED */ + + }, 16 + /* FULL_PROPS */ + , ["items", "min-item-size", "direction", "onResize", "onVisible"]); + } - var script$2 = { + script$2.render = render$2; + script$2.__file = "src/components/DynamicScroller.vue"; + + var script$3 = { name: 'DynamicScrollerItem', inject: ['vscrollData', 'vscrollParent', 'vscrollResizeObserver'], props: { @@ -1679,8 +7960,8 @@ default: false }, - /** - * Indicates if the view is actively used to display an item. + /** + * Indicates if the view is actively used to display an item. */ active: { type: Boolean, @@ -1775,7 +8056,7 @@ this.observeSize(); } }, - beforeDestroy: function beforeDestroy() { + beforeUnmount: function beforeUnmount() { this.vscrollParent.$off('vscroll:update', this.onVscrollUpdate); this.vscrollParent.$off('vscroll:update-size', this.onVscrollUpdateSize); this.unobserveSize(); @@ -1868,43 +8149,12 @@ } }, render: function render(h) { + console.log('render', h); return h(this.tag, this.$slots.default); } }; - /* script */ - const __vue_script__$2 = script$2; - - /* template */ - - /* style */ - const __vue_inject_styles__$2 = undefined; - /* scoped */ - const __vue_scope_id__$2 = undefined; - /* module identifier */ - const __vue_module_identifier__$2 = undefined; - /* functional template */ - const __vue_is_functional_template__$2 = undefined; - /* style inject */ - - /* style inject SSR */ - - /* style inject shadow dom */ - - - - const __vue_component__$2 = normalizeComponent( - {}, - __vue_inject_styles__$2, - __vue_script__$2, - __vue_scope_id__$2, - __vue_is_functional_template__$2, - __vue_module_identifier__$2, - false, - undefined, - undefined, - undefined - ); + script$3.__file = "src/components/DynamicScrollerItem.vue"; function IdState () { var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, @@ -1913,14 +8163,7 @@ return vm.item.id; } : _ref$idProp; - var store = {}; - var vm = new Vue({ - data: function data() { - return { - store: store - }; - } - }); // @vue/component + var store = vue.reactive({}); // @vue/component return { data: function data() { @@ -1959,16 +8202,16 @@ this.$_updateIdState(); }, methods: { - /** - * Initialize an idState - * @param {number|string} id Unique id for the data + /** + * Initialize an idState + * @param {number|string} id Unique id for the data */ $_idStateInit: function $_idStateInit(id) { var factory = this.$options.idState; if (typeof factory === 'function') { var data = factory.call(this, this); - vm.$set(store, id, data); + store[id] = data; this.$_id = id; return data; } else { @@ -1976,8 +8219,8 @@ } }, - /** - * Ensure idState is created and up-to-date + /** + * Ensure idState is created and up-to-date */ $_updateIdState: function $_updateIdState() { var id = this.$_getId(); @@ -1999,12 +8242,12 @@ } function registerComponents(Vue, prefix) { - Vue.component("".concat(prefix, "recycle-scroller"), __vue_component__); - Vue.component("".concat(prefix, "RecycleScroller"), __vue_component__); - Vue.component("".concat(prefix, "dynamic-scroller"), __vue_component__$1); - Vue.component("".concat(prefix, "DynamicScroller"), __vue_component__$1); - Vue.component("".concat(prefix, "dynamic-scroller-item"), __vue_component__$2); - Vue.component("".concat(prefix, "DynamicScrollerItem"), __vue_component__$2); + Vue.component("".concat(prefix, "recycle-scroller"), script$1); + Vue.component("".concat(prefix, "RecycleScroller"), script$1); + Vue.component("".concat(prefix, "dynamic-scroller"), script$2); + Vue.component("".concat(prefix, "DynamicScroller"), script$2); + Vue.component("".concat(prefix, "dynamic-scroller-item"), script$3); + Vue.component("".concat(prefix, "DynamicScrollerItem"), script$3); } var plugin$2 = { @@ -2040,10 +8283,10 @@ GlobalVue$2.use(plugin$2); } - exports.DynamicScroller = __vue_component__$1; - exports.DynamicScrollerItem = __vue_component__$2; + exports.DynamicScroller = script$2; + exports.DynamicScrollerItem = script$3; exports.IdState = IdState; - exports.RecycleScroller = __vue_component__; + exports.RecycleScroller = script$1; exports.default = plugin$2; Object.defineProperty(exports, '__esModule', { value: true }); diff --git a/dist/vue-virtual-scroller.umd.js.map b/dist/vue-virtual-scroller.umd.js.map index 7aca6a78..a883a7fa 100644 --- a/dist/vue-virtual-scroller.umd.js.map +++ b/dist/vue-virtual-scroller.umd.js.map @@ -1 +1 @@ -{"version":3,"file":"vue-virtual-scroller.umd.js","sources":["../src/config.js","../node_modules/vue-resize/dist/vue-resize.esm.js","../node_modules/vue-observe-visibility/dist/vue-observe-visibility.esm.js","../node_modules/scrollparent/scrollparent.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../node_modules/vue-runtime-helpers/dist/normalize-component.mjs","../src/components/DynamicScroller.vue","../src/components/DynamicScrollerItem.vue","../src/mixins/IdState.js","../src/index.js"],"sourcesContent":["export default {\n itemsLimit: 1000,\n}\n","function getInternetExplorerVersion() {\n\tvar ua = window.navigator.userAgent;\n\n\tvar msie = ua.indexOf('MSIE ');\n\tif (msie > 0) {\n\t\t// IE 10 or older => return version number\n\t\treturn parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);\n\t}\n\n\tvar trident = ua.indexOf('Trident/');\n\tif (trident > 0) {\n\t\t// IE 11 => return version number\n\t\tvar rv = ua.indexOf('rv:');\n\t\treturn parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);\n\t}\n\n\tvar edge = ua.indexOf('Edge/');\n\tif (edge > 0) {\n\t\t// Edge (IE 12+) => return version number\n\t\treturn parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);\n\t}\n\n\t// other browser\n\treturn -1;\n}\n\nvar isIE = void 0;\n\nfunction initCompat() {\n\tif (!initCompat.init) {\n\t\tinitCompat.init = true;\n\t\tisIE = getInternetExplorerVersion() !== -1;\n\t}\n}\n\nvar ResizeObserver = { render: function render() {\n\t\tvar _vm = this;var _h = _vm.$createElement;var _c = _vm._self._c || _h;return _c('div', { staticClass: \"resize-observer\", attrs: { \"tabindex\": \"-1\" } });\n\t}, staticRenderFns: [], _scopeId: 'data-v-b329ee4c',\n\tname: 'resize-observer',\n\n\tmethods: {\n\t\tcompareAndNotify: function compareAndNotify() {\n\t\t\tif (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) {\n\t\t\t\tthis._w = this.$el.offsetWidth;\n\t\t\t\tthis._h = this.$el.offsetHeight;\n\t\t\t\tthis.$emit('notify');\n\t\t\t}\n\t\t},\n\t\taddResizeHandlers: function addResizeHandlers() {\n\t\t\tthis._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify);\n\t\t\tthis.compareAndNotify();\n\t\t},\n\t\tremoveResizeHandlers: function removeResizeHandlers() {\n\t\t\tif (this._resizeObject && this._resizeObject.onload) {\n\t\t\t\tif (!isIE && this._resizeObject.contentDocument) {\n\t\t\t\t\tthis._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify);\n\t\t\t\t}\n\t\t\t\tdelete this._resizeObject.onload;\n\t\t\t}\n\t\t}\n\t},\n\n\tmounted: function mounted() {\n\t\tvar _this = this;\n\n\t\tinitCompat();\n\t\tthis.$nextTick(function () {\n\t\t\t_this._w = _this.$el.offsetWidth;\n\t\t\t_this._h = _this.$el.offsetHeight;\n\t\t});\n\t\tvar object = document.createElement('object');\n\t\tthis._resizeObject = object;\n\t\tobject.setAttribute('aria-hidden', 'true');\n\t\tobject.setAttribute('tabindex', -1);\n\t\tobject.onload = this.addResizeHandlers;\n\t\tobject.type = 'text/html';\n\t\tif (isIE) {\n\t\t\tthis.$el.appendChild(object);\n\t\t}\n\t\tobject.data = 'about:blank';\n\t\tif (!isIE) {\n\t\t\tthis.$el.appendChild(object);\n\t\t}\n\t},\n\tbeforeDestroy: function beforeDestroy() {\n\t\tthis.removeResizeHandlers();\n\t}\n};\n\n// Install the components\nfunction install(Vue) {\n\tVue.component('resize-observer', ResizeObserver);\n\tVue.component('ResizeObserver', ResizeObserver);\n}\n\n// Plugin\nvar plugin = {\n\t// eslint-disable-next-line no-undef\n\tversion: \"0.4.5\",\n\tinstall: install\n};\n\n// Auto-install\nvar GlobalVue = null;\nif (typeof window !== 'undefined') {\n\tGlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n\tGlobalVue = global.Vue;\n}\nif (GlobalVue) {\n\tGlobalVue.use(plugin);\n}\n\nexport { install, ResizeObserver };\nexport default plugin;\n","function _typeof(obj) {\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n}\n\nfunction _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n return arr2;\n }\n}\n\nfunction _iterableToArray(iter) {\n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\nfunction processOptions(value) {\n var options;\n\n if (typeof value === 'function') {\n // Simple options (callback-only)\n options = {\n callback: value\n };\n } else {\n // Options object\n options = value;\n }\n\n return options;\n}\nfunction throttle(callback, delay) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var timeout;\n var lastState;\n var currentArgs;\n\n var throttled = function throttled(state) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n currentArgs = args;\n if (timeout && state === lastState) return;\n var leading = options.leading;\n\n if (typeof leading === 'function') {\n leading = leading(state, lastState);\n }\n\n if ((!timeout || state !== lastState) && leading) {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n }\n\n lastState = state;\n clearTimeout(timeout);\n timeout = setTimeout(function () {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n timeout = 0;\n }, delay);\n };\n\n throttled._clear = function () {\n clearTimeout(timeout);\n timeout = null;\n };\n\n return throttled;\n}\nfunction deepEqual(val1, val2) {\n if (val1 === val2) return true;\n\n if (_typeof(val1) === 'object') {\n for (var key in val1) {\n if (!deepEqual(val1[key], val2[key])) {\n return false;\n }\n }\n\n return true;\n }\n\n return false;\n}\n\nvar VisibilityState =\n/*#__PURE__*/\nfunction () {\n function VisibilityState(el, options, vnode) {\n _classCallCheck(this, VisibilityState);\n\n this.el = el;\n this.observer = null;\n this.frozen = false;\n this.createObserver(options, vnode);\n }\n\n _createClass(VisibilityState, [{\n key: \"createObserver\",\n value: function createObserver(options, vnode) {\n var _this = this;\n\n if (this.observer) {\n this.destroyObserver();\n }\n\n if (this.frozen) return;\n this.options = processOptions(options);\n\n this.callback = function (result, entry) {\n _this.options.callback(result, entry);\n\n if (result && _this.options.once) {\n _this.frozen = true;\n\n _this.destroyObserver();\n }\n }; // Throttle\n\n\n if (this.callback && this.options.throttle) {\n var _ref = this.options.throttleOptions || {},\n _leading = _ref.leading;\n\n this.callback = throttle(this.callback, this.options.throttle, {\n leading: function leading(state) {\n return _leading === 'both' || _leading === 'visible' && state || _leading === 'hidden' && !state;\n }\n });\n }\n\n this.oldResult = undefined;\n this.observer = new IntersectionObserver(function (entries) {\n var entry = entries[0];\n\n if (entries.length > 1) {\n var intersectingEntry = entries.find(function (e) {\n return e.isIntersecting;\n });\n\n if (intersectingEntry) {\n entry = intersectingEntry;\n }\n }\n\n if (_this.callback) {\n // Use isIntersecting if possible because browsers can report isIntersecting as true, but intersectionRatio as 0, when something very slowly enters the viewport.\n var result = entry.isIntersecting && entry.intersectionRatio >= _this.threshold;\n if (result === _this.oldResult) return;\n _this.oldResult = result;\n\n _this.callback(result, entry);\n }\n }, this.options.intersection); // Wait for the element to be in document\n\n vnode.context.$nextTick(function () {\n if (_this.observer) {\n _this.observer.observe(_this.el);\n }\n });\n }\n }, {\n key: \"destroyObserver\",\n value: function destroyObserver() {\n if (this.observer) {\n this.observer.disconnect();\n this.observer = null;\n } // Cancel throttled call\n\n\n if (this.callback && this.callback._clear) {\n this.callback._clear();\n\n this.callback = null;\n }\n }\n }, {\n key: \"threshold\",\n get: function get() {\n return this.options.intersection && this.options.intersection.threshold || 0;\n }\n }]);\n\n return VisibilityState;\n}();\n\nfunction bind(el, _ref2, vnode) {\n var value = _ref2.value;\n if (!value) return;\n\n if (typeof IntersectionObserver === 'undefined') {\n console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');\n } else {\n var state = new VisibilityState(el, value, vnode);\n el._vue_visibilityState = state;\n }\n}\n\nfunction update(el, _ref3, vnode) {\n var value = _ref3.value,\n oldValue = _ref3.oldValue;\n if (deepEqual(value, oldValue)) return;\n var state = el._vue_visibilityState;\n\n if (!value) {\n unbind(el);\n return;\n }\n\n if (state) {\n state.createObserver(value, vnode);\n } else {\n bind(el, {\n value: value\n }, vnode);\n }\n}\n\nfunction unbind(el) {\n var state = el._vue_visibilityState;\n\n if (state) {\n state.destroyObserver();\n delete el._vue_visibilityState;\n }\n}\n\nvar ObserveVisibility = {\n bind: bind,\n update: update,\n unbind: unbind\n};\n\nfunction install(Vue) {\n Vue.directive('observe-visibility', ObserveVisibility);\n /* -- Add more components here -- */\n}\n/* -- Plugin definition & Auto-install -- */\n\n/* You shouldn't have to modify the code below */\n// Plugin\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.4.6\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { ObserveVisibility, install };\n","(function (root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define([], factory);\n } else if (typeof module === \"object\" && module.exports) {\n module.exports = factory();\n } else {\n root.Scrollparent = factory();\n }\n}(this, function () {\n var regex = /(auto|scroll)/;\n\n var parents = function (node, ps) {\n if (node.parentNode === null) { return ps; }\n\n return parents(node.parentNode, ps.concat([node]));\n };\n\n var style = function (node, prop) {\n return getComputedStyle(node, null).getPropertyValue(prop);\n };\n\n var overflow = function (node) {\n return style(node, \"overflow\") + style(node, \"overflow-y\") + style(node, \"overflow-x\");\n };\n\n var scroll = function (node) {\n return regex.test(overflow(node));\n };\n\n var scrollParent = function (node) {\n if (!(node instanceof HTMLElement || node instanceof SVGElement)) {\n return ;\n }\n\n var ps = parents(node.parentNode, []);\n\n for (var i = 0; i < ps.length; i += 1) {\n if (scroll(ps[i])) {\n return ps[i];\n }\n }\n\n return document.scrollingElement || document.documentElement;\n };\n\n return scrollParent;\n}));\n","export const props = {\n items: {\n type: Array,\n required: true,\n },\n\n keyField: {\n type: String,\n default: 'id',\n },\n\n direction: {\n type: String,\n default: 'vertical',\n validator: (value) => ['vertical', 'horizontal'].includes(value),\n },\n}\n\nexport function simpleArray () {\n return this.items.length && typeof this.items[0] !== 'object'\n}\n","export let supportsPassive = false\n\nif (typeof window !== 'undefined') {\n supportsPassive = false\n try {\n var opts = Object.defineProperty({}, 'passive', {\n get () {\n supportsPassive = true\n },\n })\n window.addEventListener('test', null, opts)\n } catch (e) {}\n}\n","\n\n\n\n\n","function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {\r\n if (typeof shadowMode !== 'boolean') {\r\n createInjectorSSR = createInjector;\r\n createInjector = shadowMode;\r\n shadowMode = false;\r\n }\r\n // Vue.extend constructor export interop.\r\n const options = typeof script === 'function' ? script.options : script;\r\n // render functions\r\n if (template && template.render) {\r\n options.render = template.render;\r\n options.staticRenderFns = template.staticRenderFns;\r\n options._compiled = true;\r\n // functional template\r\n if (isFunctionalTemplate) {\r\n options.functional = true;\r\n }\r\n }\r\n // scopedId\r\n if (scopeId) {\r\n options._scopeId = scopeId;\r\n }\r\n let hook;\r\n if (moduleIdentifier) {\r\n // server build\r\n hook = function (context) {\r\n // 2.3 injection\r\n context =\r\n context || // cached call\r\n (this.$vnode && this.$vnode.ssrContext) || // stateful\r\n (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext); // functional\r\n // 2.2 with runInNewContext: true\r\n if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\r\n context = __VUE_SSR_CONTEXT__;\r\n }\r\n // inject component styles\r\n if (style) {\r\n style.call(this, createInjectorSSR(context));\r\n }\r\n // register component module identifier for async chunk inference\r\n if (context && context._registeredComponents) {\r\n context._registeredComponents.add(moduleIdentifier);\r\n }\r\n };\r\n // used by ssr in case component is cached and beforeCreate\r\n // never gets called\r\n options._ssrRegister = hook;\r\n }\r\n else if (style) {\r\n hook = shadowMode\r\n ? function (context) {\r\n style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot));\r\n }\r\n : function (context) {\r\n style.call(this, createInjector(context));\r\n };\r\n }\r\n if (hook) {\r\n if (options.functional) {\r\n // register for functional component in vue file\r\n const originalRender = options.render;\r\n options.render = function renderWithStyleInjection(h, context) {\r\n hook.call(context);\r\n return originalRender(h, context);\r\n };\r\n }\r\n else {\r\n // inject component registration as beforeCreate hook\r\n const existing = options.beforeCreate;\r\n options.beforeCreate = existing ? [].concat(existing, hook) : [hook];\r\n }\r\n }\r\n return script;\r\n}\n\nexport default normalizeComponent;\n//# sourceMappingURL=normalize-component.mjs.map\n","\n\n\n","\n","import Vue from 'vue'\n\nexport default function ({\n idProp = vm => vm.item.id,\n} = {}) {\n const store = {}\n const vm = new Vue({\n data () {\n return {\n store,\n }\n },\n })\n\n // @vue/component\n return {\n data () {\n return {\n idState: null,\n }\n },\n\n created () {\n this.$_id = null\n if (typeof idProp === 'function') {\n this.$_getId = () => idProp.call(this, this)\n } else {\n this.$_getId = () => this[idProp]\n }\n this.$watch(this.$_getId, {\n handler (value) {\n this.$nextTick(() => {\n this.$_id = value\n })\n },\n immediate: true,\n })\n this.$_updateIdState()\n },\n\n beforeUpdate () {\n this.$_updateIdState()\n },\n\n methods: {\n /**\n * Initialize an idState\n * @param {number|string} id Unique id for the data\n */\n $_idStateInit (id) {\n const factory = this.$options.idState\n if (typeof factory === 'function') {\n const data = factory.call(this, this)\n vm.$set(store, id, data)\n this.$_id = id\n return data\n } else {\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\n }\n },\n\n /**\n * Ensure idState is created and up-to-date\n */\n $_updateIdState () {\n const id = this.$_getId()\n if (id == null) {\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\n }\n if (id !== this.$_id) {\n if (!store[id]) {\n this.$_idStateInit(id)\n }\n this.idState = store[id]\n }\n },\n },\n }\n}\n","import config from './config'\n\nimport RecycleScroller from './components/RecycleScroller.vue'\nimport DynamicScroller from './components/DynamicScroller.vue'\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\n\nexport { default as IdState } from './mixins/IdState'\n\nexport {\n RecycleScroller,\n DynamicScroller,\n DynamicScrollerItem,\n}\n\nfunction registerComponents (Vue, prefix) {\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\n}\n\nconst plugin = {\n // eslint-disable-next-line no-undef\n version: VERSION,\n install (Vue, options) {\n const finalOptions = Object.assign({}, {\n installComponents: true,\n componentsPrefix: '',\n }, options)\n\n for (const key in finalOptions) {\n if (typeof finalOptions[key] !== 'undefined') {\n config[key] = finalOptions[key]\n }\n }\n\n if (finalOptions.installComponents) {\n registerComponents(Vue, finalOptions.componentsPrefix)\n }\n },\n}\n\nexport default plugin\n\n// Auto-install\nlet GlobalVue = null\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue\n}\nif (GlobalVue) {\n GlobalVue.use(plugin)\n}\n"],"names":["itemsLimit","ResizeObserver","_typeof","install","plugin","GlobalVue","this","props","items","type","Array","required","keyField","String","default","direction","validator","value","includes","simpleArray","length","supportsPassive","window","opts","Object","defineProperty","get","addEventListener","e","idProp","vm","item","id","store","Vue","data","idState","created","$_id","$_getId","call","$watch","handler","$nextTick","immediate","$_updateIdState","beforeUpdate","methods","$_idStateInit","factory","$options","$set","Error","console","warn","registerComponents","prefix","component","RecycleScroller","DynamicScroller","DynamicScrollerItem","version","VERSION","options","finalOptions","assign","installComponents","componentsPrefix","key","config","global","use"],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"vue-virtual-scroller.umd.js","sources":["../src/config.js","../../vue-resize/dist/vue-resize.esm.js","../../vue-observe-visibility/dist/vue-observe-visibility.esm.js","../node_modules/scrollparent/scrollparent.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../src/components/RecycleScroller.vue?vue&type=template&id=093a936d&lang.js","../src/components/DynamicScroller.vue","../src/components/DynamicScroller.vue?vue&type=template&id=76e15f19&lang.js","../src/components/DynamicScrollerItem.vue","../src/mixins/IdState.js","../src/index.js"],"sourcesContent":["export default {\r\n itemsLimit: 1000,\r\n}\r\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction setCurrentRenderingInstance(instance) {\r\n currentRenderingInstance = instance;\r\n}\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n/**\r\n * Wrap a slot function to memoize current rendering instance\r\n * @private\r\n */\r\nfunction withCtx(fn, ctx = currentRenderingInstance) {\r\n if (!ctx)\r\n return fn;\r\n const renderFnWithContext = (...args) => {\r\n // If a user calls a compiled slot inside a template expression (#1745), it\r\n // can mess up block tracking, so by default we need to push a null block to\r\n // avoid that. This isn't necessary if rendering a compiled ``.\r\n if (!isRenderingCompiledSlot) {\r\n openBlock(true /* null block that disables tracking */);\r\n }\r\n const owner = currentRenderingInstance;\r\n setCurrentRenderingInstance(ctx);\r\n const res = fn(...args);\r\n setCurrentRenderingInstance(owner);\r\n if (!isRenderingCompiledSlot) {\r\n closeBlock();\r\n }\r\n return res;\r\n };\r\n renderFnWithContext._c = true;\r\n return renderFnWithContext;\r\n}\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\nconst scopeIdStack = [];\r\n/**\r\n * @private\r\n */\r\nfunction pushScopeId(id) {\r\n scopeIdStack.push((currentScopeId = id));\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction popScopeId() {\r\n scopeIdStack.pop();\r\n currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null;\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction withScopeId(id) {\r\n return ((fn) => withCtx(function () {\r\n pushScopeId(id);\r\n const res = fn.apply(this, arguments);\r\n popScopeId();\r\n return res;\r\n }));\r\n}\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\n// Since v-if and v-for are the two possible ways node structure can dynamically\r\n// change, once we consider v-if branches and each v-for fragment a block, we\r\n// can divide a template into nested blocks, and within each block the node\r\n// structure would be stable. This allows us to skip most children diffing\r\n// and only worry about the dynamic nodes (indicated by patch flags).\r\nconst blockStack = [];\r\nlet currentBlock = null;\r\n/**\r\n * Open a block.\r\n * This must be called before `createBlock`. It cannot be part of `createBlock`\r\n * because the children of the block are evaluated before `createBlock` itself\r\n * is called. The generated code typically looks like this:\r\n *\r\n * ```js\r\n * function render() {\r\n * return (openBlock(),createBlock('div', null, [...]))\r\n * }\r\n * ```\r\n * disableTracking is true when creating a v-for fragment block, since a v-for\r\n * fragment always diffs its children.\r\n *\r\n * @private\r\n */\r\nfunction openBlock(disableTracking = false) {\r\n blockStack.push((currentBlock = disableTracking ? null : []));\r\n}\r\nfunction closeBlock() {\r\n blockStack.pop();\r\n currentBlock = blockStack[blockStack.length - 1] || null;\r\n}\r\n/**\r\n * Create a block root vnode. Takes the same exact arguments as `createVNode`.\r\n * A block root keeps track of dynamic nodes within the block in the\r\n * `dynamicChildren` array.\r\n *\r\n * @private\r\n */\r\nfunction createBlock(type, props, children, patchFlag, dynamicProps) {\r\n const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */);\r\n // save current block children on the block vnode\r\n vnode.dynamicChildren = currentBlock || EMPTY_ARR;\r\n // close block\r\n closeBlock();\r\n // a block is always going to be patched, so track it as a child of its\r\n // parent block\r\n if ( currentBlock) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...( args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction getInternetExplorerVersion() {\n var ua = window.navigator.userAgent;\n var msie = ua.indexOf('MSIE ');\n\n if (msie > 0) {\n // IE 10 or older => return version number\n return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);\n }\n\n var trident = ua.indexOf('Trident/');\n\n if (trident > 0) {\n // IE 11 => return version number\n var rv = ua.indexOf('rv:');\n return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);\n }\n\n var edge = ua.indexOf('Edge/');\n\n if (edge > 0) {\n // Edge (IE 12+) => return version number\n return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);\n } // other browser\n\n\n return -1;\n}\n\nvar isIE;\n\nfunction initCompat() {\n if (!initCompat.init) {\n initCompat.init = true;\n isIE = getInternetExplorerVersion() !== -1;\n }\n}\n\nvar script = {\n name: 'ResizeObserver',\n mounted: function mounted() {\n var _this = this;\n\n initCompat();\n nextTick(function () {\n _this._w = _this.$el.offsetWidth;\n _this._h = _this.$el.offsetHeight;\n });\n var object = document.createElement('object');\n this._resizeObject = object;\n object.setAttribute('aria-hidden', 'true');\n object.setAttribute('tabindex', -1);\n object.onload = this.addResizeHandlers;\n object.type = 'text/html';\n\n if (isIE) {\n this.$el.appendChild(object);\n }\n\n object.data = 'about:blank';\n\n if (!isIE) {\n this.$el.appendChild(object);\n }\n },\n beforeUnmount: function beforeUnmount() {\n this.removeResizeHandlers();\n },\n methods: {\n compareAndNotify: function compareAndNotify() {\n if (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) {\n this._w = this.$el.offsetWidth;\n this._h = this.$el.offsetHeight;\n this.$emit('notify', {\n width: this._w,\n height: this._h\n });\n }\n },\n addResizeHandlers: function addResizeHandlers() {\n this._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify);\n\n this.compareAndNotify();\n },\n removeResizeHandlers: function removeResizeHandlers() {\n if (this._resizeObject && this._resizeObject.onload) {\n if (!isIE && this._resizeObject.contentDocument) {\n this._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify);\n }\n\n this.$el.removeChild(this._resizeObject);\n this._resizeObject.onload = null;\n this._resizeObject = null;\n }\n }\n }\n};\n\nvar _withId = /*#__PURE__*/withScopeId(\"data-v-b329ee4c\");\n\npushScopeId(\"data-v-b329ee4c\");\n\nvar _hoisted_1 = {\n class: \"resize-observer\",\n tabindex: \"-1\"\n};\n\npopScopeId();\n\nvar render = /*#__PURE__*/_withId(function (_ctx, _cache, $props, $setup, $data, $options) {\n return openBlock(), createBlock(\"div\", _hoisted_1);\n});\n\nscript.render = render;\nscript.__scopeId = \"data-v-b329ee4c\";\nscript.__file = \"src/components/ResizeObserver.vue\";\n\nfunction install(Vue) {\n Vue.component('resize-observer', script);\n Vue.component('ResizeObserver', script);\n}\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.5.0\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { script as ResizeObserver, install };\n//# sourceMappingURL=vue-resize.esm.js.map\n","function _typeof(obj) {\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n}\n\nfunction _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n return arr2;\n }\n}\n\nfunction _iterableToArray(iter) {\n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\n/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase());\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\nlet currentBlock = null;\r\n// Whether we should be tracking dynamic child nodes inside a block.\r\n// Only tracks when this value is > 0\r\n// We are not using a simple boolean because this value may need to be\r\n// incremented/decremented by nested usage of v-once (see below)\r\nlet shouldTrack$1 = 1;\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nlet vnodeArgsTransformer;\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...(vnodeArgsTransformer\r\n ? vnodeArgsTransformer(args, currentRenderingInstance)\r\n : args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (shouldTrack$1 > 0 &&\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nconst svgNS = 'http://www.w3.org/2000/svg';\r\nconst doc = (typeof document !== 'undefined' ? document : null);\r\nlet tempContainer;\r\nlet tempSVGContainer;\r\nconst nodeOps = {\r\n insert: (child, parent, anchor) => {\r\n parent.insertBefore(child, anchor || null);\r\n },\r\n remove: child => {\r\n const parent = child.parentNode;\r\n if (parent) {\r\n parent.removeChild(child);\r\n }\r\n },\r\n createElement: (tag, isSVG, is) => isSVG\r\n ? doc.createElementNS(svgNS, tag)\r\n : doc.createElement(tag, is ? { is } : undefined),\r\n createText: text => doc.createTextNode(text),\r\n createComment: text => doc.createComment(text),\r\n setText: (node, text) => {\r\n node.nodeValue = text;\r\n },\r\n setElementText: (el, text) => {\r\n el.textContent = text;\r\n },\r\n parentNode: node => node.parentNode,\r\n nextSibling: node => node.nextSibling,\r\n querySelector: selector => doc.querySelector(selector),\r\n setScopeId(el, id) {\r\n el.setAttribute(id, '');\r\n },\r\n cloneNode(el) {\r\n return el.cloneNode(true);\r\n },\r\n // __UNSAFE__\r\n // Reason: innerHTML.\r\n // Static content here can only come from compiled templates.\r\n // As long as the user only uses trusted templates, this is safe.\r\n insertStaticContent(content, parent, anchor, isSVG) {\r\n const temp = isSVG\r\n ? tempSVGContainer ||\r\n (tempSVGContainer = doc.createElementNS(svgNS, 'svg'))\r\n : tempContainer || (tempContainer = doc.createElement('div'));\r\n temp.innerHTML = content;\r\n const first = temp.firstChild;\r\n let node = first;\r\n let last = node;\r\n while (node) {\r\n last = node;\r\n nodeOps.insert(node, parent, anchor);\r\n node = temp.firstChild;\r\n }\r\n return [first, last];\r\n }\r\n};\n\n// compiler should normalize class + :class bindings on the same element\r\n// into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n if (value == null) {\r\n value = '';\r\n }\r\n if (isSVG) {\r\n el.setAttribute('class', value);\r\n }\r\n else {\r\n // directly setting className should be faster than setAttribute in theory\r\n // if this is an element during a transition, take the temporary transition\r\n // classes into account.\r\n const transitionClasses = el._vtc;\r\n if (transitionClasses) {\r\n value = (value\r\n ? [value, ...transitionClasses]\r\n : [...transitionClasses]).join(' ');\r\n }\r\n el.className = value;\r\n }\r\n}\n\nfunction patchStyle(el, prev, next) {\r\n const style = el.style;\r\n if (!next) {\r\n el.removeAttribute('style');\r\n }\r\n else if (isString(next)) {\r\n if (prev !== next) {\r\n style.cssText = next;\r\n }\r\n }\r\n else {\r\n for (const key in next) {\r\n setStyle(style, key, next[key]);\r\n }\r\n if (prev && !isString(prev)) {\r\n for (const key in prev) {\r\n if (next[key] == null) {\r\n setStyle(style, key, '');\r\n }\r\n }\r\n }\r\n }\r\n}\r\nconst importantRE = /\\s*!important$/;\r\nfunction setStyle(style, name, val) {\r\n if (isArray(val)) {\r\n val.forEach(v => setStyle(style, name, v));\r\n }\r\n else {\r\n if (name.startsWith('--')) {\r\n // custom property definition\r\n style.setProperty(name, val);\r\n }\r\n else {\r\n const prefixed = autoPrefix(style, name);\r\n if (importantRE.test(val)) {\r\n // !important\r\n style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');\r\n }\r\n else {\r\n style[prefixed] = val;\r\n }\r\n }\r\n }\r\n}\r\nconst prefixes = ['Webkit', 'Moz', 'ms'];\r\nconst prefixCache = {};\r\nfunction autoPrefix(style, rawName) {\r\n const cached = prefixCache[rawName];\r\n if (cached) {\r\n return cached;\r\n }\r\n let name = camelize(rawName);\r\n if (name !== 'filter' && name in style) {\r\n return (prefixCache[rawName] = name);\r\n }\r\n name = capitalize(name);\r\n for (let i = 0; i < prefixes.length; i++) {\r\n const prefixed = prefixes[i] + name;\r\n if (prefixed in style) {\r\n return (prefixCache[rawName] = prefixed);\r\n }\r\n }\r\n return rawName;\r\n}\n\nconst xlinkNS = 'http://www.w3.org/1999/xlink';\r\nfunction patchAttr(el, key, value, isSVG) {\r\n if (isSVG && key.startsWith('xlink:')) {\r\n if (value == null) {\r\n el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\r\n }\r\n else {\r\n el.setAttributeNS(xlinkNS, key, value);\r\n }\r\n }\r\n else {\r\n // note we are only checking boolean attributes that don't have a\r\n // corresponding dom prop of the same name here.\r\n const isBoolean = isSpecialBooleanAttr(key);\r\n if (value == null || (isBoolean && value === false)) {\r\n el.removeAttribute(key);\r\n }\r\n else {\r\n el.setAttribute(key, isBoolean ? '' : value);\r\n }\r\n }\r\n}\n\n// __UNSAFE__\r\n// functions. The user is responsible for using them with only trusted content.\r\nfunction patchDOMProp(el, key, value, \r\n// the following args are passed only due to potential innerHTML/textContent\r\n// overriding existing VNodes, in which case the old tree must be properly\r\n// unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n if (key === 'innerHTML' || key === 'textContent') {\r\n if (prevChildren) {\r\n unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n }\r\n el[key] = value == null ? '' : value;\r\n return;\r\n }\r\n if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n // store value as _value as well since\r\n // non-string values will be stringified.\r\n el._value = value;\r\n const newValue = value == null ? '' : value;\r\n if (el.value !== newValue) {\r\n el.value = newValue;\r\n }\r\n return;\r\n }\r\n if (value === '' || value == null) {\r\n const type = typeof el[key];\r\n if (value === '' && type === 'boolean') {\r\n // e.g. with\r\n // :true-value & :false-value\r\n // store value as dom properties since non-string values will be\r\n // stringified.\r\n if (key === 'true-value') {\r\n el._trueValue = nextValue;\r\n }\r\n else if (key === 'false-value') {\r\n el._falseValue = nextValue;\r\n }\r\n patchAttr(el, key, nextValue, isSVG);\r\n }\r\n break;\r\n }\r\n};\r\nfunction shouldSetAsProp(el, key, value, isSVG) {\r\n if (isSVG) {\r\n // most keys must be set as attribute on svg elements to work\r\n // ...except innerHTML\r\n if (key === 'innerHTML') {\r\n return true;\r\n }\r\n // or native onclick with function values\r\n if (key in el && nativeOnRE.test(key) && isFunction(value)) {\r\n return true;\r\n }\r\n return false;\r\n }\r\n // spellcheck and draggable are numerated attrs, however their\r\n // corresponding DOM properties are actually booleans - this leads to\r\n // setting it with a string \"false\" value leading it to be coerced to\r\n // `true`, so we need to always treat them as attributes.\r\n // Note that `contentEditable` doesn't have this problem: its DOM\r\n // property is also enumerated string values.\r\n if (key === 'spellcheck' || key === 'draggable') {\r\n return false;\r\n }\r\n // #1787 form as an attribute must be a string, while it accepts an Element as\r\n // a prop\r\n if (key === 'form' && typeof value === 'string') {\r\n return false;\r\n }\r\n // #1526 must be set as attribute\r\n if (key === 'list' && el.tagName === 'INPUT') {\r\n return false;\r\n }\r\n // native onclick with string value, must be set as attribute\r\n if (nativeOnRE.test(key) && isString(value)) {\r\n return false;\r\n }\r\n return key in el;\r\n}\n\nconst rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps);\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction processOptions(value) {\n var options;\n\n if (typeof value === 'function') {\n // Simple options (callback-only)\n options = {\n callback: value\n };\n } else {\n // Options object\n options = value;\n }\n\n return options;\n}\nfunction throttle(callback, delay) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var timeout;\n var lastState;\n var currentArgs;\n\n var throttled = function throttled(state) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n currentArgs = args;\n if (timeout && state === lastState) return;\n var leading = options.leading;\n\n if (typeof leading === 'function') {\n leading = leading(state, lastState);\n }\n\n if ((!timeout || state !== lastState) && leading) {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n }\n\n lastState = state;\n clearTimeout(timeout);\n timeout = setTimeout(function () {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n timeout = 0;\n }, delay);\n };\n\n throttled._clear = function () {\n clearTimeout(timeout);\n timeout = null;\n };\n\n return throttled;\n}\nfunction deepEqual(val1, val2) {\n if (val1 === val2) return true;\n\n if (_typeof(val1) === 'object') {\n for (var key in val1) {\n if (!deepEqual(val1[key], val2[key])) {\n return false;\n }\n }\n\n return true;\n }\n\n return false;\n}\n\nvar VisibilityState =\n/*#__PURE__*/\nfunction () {\n function VisibilityState(el, options, vnode) {\n _classCallCheck(this, VisibilityState);\n\n this.el = el;\n this.observer = null;\n this.frozen = false;\n this.createObserver(options, vnode);\n }\n\n _createClass(VisibilityState, [{\n key: \"createObserver\",\n value: function createObserver(options, vnode) {\n var _this = this;\n\n if (this.observer) {\n this.destroyObserver();\n }\n\n if (this.frozen) return;\n this.options = processOptions(options);\n\n this.callback = function (result, entry) {\n _this.options.callback(result, entry);\n\n if (result && _this.options.once) {\n _this.frozen = true;\n\n _this.destroyObserver();\n }\n }; // Throttle\n\n\n if (this.callback && this.options.throttle) {\n var _ref = this.options.throttleOptions || {},\n _leading = _ref.leading;\n\n this.callback = throttle(this.callback, this.options.throttle, {\n leading: function leading(state) {\n return _leading === 'both' || _leading === 'visible' && state || _leading === 'hidden' && !state;\n }\n });\n }\n\n this.oldResult = undefined;\n this.observer = new IntersectionObserver(function (entries) {\n var entry = entries[0];\n\n if (entries.length > 1) {\n var intersectingEntry = entries.find(function (e) {\n return e.isIntersecting;\n });\n\n if (intersectingEntry) {\n entry = intersectingEntry;\n }\n }\n\n if (_this.callback) {\n // Use isIntersecting if possible because browsers can report isIntersecting as true, but intersectionRatio as 0, when something very slowly enters the viewport.\n var result = entry.isIntersecting && entry.intersectionRatio >= _this.threshold;\n if (result === _this.oldResult) return;\n _this.oldResult = result;\n\n _this.callback(result, entry);\n }\n }, this.options.intersection); // Wait for the element to be in document\n\n nextTick(function () {\n if (_this.observer) {\n _this.observer.observe(_this.el);\n }\n });\n }\n }, {\n key: \"destroyObserver\",\n value: function destroyObserver() {\n if (this.observer) {\n this.observer.disconnect();\n this.observer = null;\n } // Cancel throttled call\n\n\n if (this.callback && this.callback._clear) {\n this.callback._clear();\n\n this.callback = null;\n }\n }\n }, {\n key: \"threshold\",\n get: function get() {\n return this.options.intersection && this.options.intersection.threshold || 0;\n }\n }]);\n\n return VisibilityState;\n}();\n\nfunction bind(el, _ref2, vnode) {\n var value = _ref2.value;\n if (!value) return;\n\n if (typeof IntersectionObserver === 'undefined') {\n console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');\n } else {\n var state = new VisibilityState(el, value, vnode);\n el._vue_visibilityState = state;\n }\n}\n\nfunction update(el, _ref3, vnode) {\n var value = _ref3.value,\n oldValue = _ref3.oldValue;\n if (deepEqual(value, oldValue)) return;\n var state = el._vue_visibilityState;\n\n if (!value) {\n unbind(el);\n return;\n }\n\n if (state) {\n state.createObserver(value, vnode);\n } else {\n bind(el, {\n value: value\n }, vnode);\n }\n}\n\nfunction unbind(el) {\n var state = el._vue_visibilityState;\n\n if (state) {\n state.destroyObserver();\n delete el._vue_visibilityState;\n }\n}\n\nvar ObserveVisibility = {\n beforeMount: bind,\n updated: update,\n unmounted: unbind\n};\n\nfunction install(Vue) {\n Vue.directive('observe-visibility', ObserveVisibility);\n /* -- Add more components here -- */\n}\n/* -- Plugin definition & Auto-install -- */\n\n/* You shouldn't have to modify the code below */\n// Plugin\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.4.6\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { ObserveVisibility, install };\n","(function (root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define([], factory);\n } else if (typeof module === \"object\" && module.exports) {\n module.exports = factory();\n } else {\n root.Scrollparent = factory();\n }\n}(this, function () {\n var regex = /(auto|scroll)/;\n\n var parents = function (node, ps) {\n if (node.parentNode === null) { return ps; }\n\n return parents(node.parentNode, ps.concat([node]));\n };\n\n var style = function (node, prop) {\n return getComputedStyle(node, null).getPropertyValue(prop);\n };\n\n var overflow = function (node) {\n return style(node, \"overflow\") + style(node, \"overflow-y\") + style(node, \"overflow-x\");\n };\n\n var scroll = function (node) {\n return regex.test(overflow(node));\n };\n\n var scrollParent = function (node) {\n if (!(node instanceof HTMLElement || node instanceof SVGElement)) {\n return ;\n }\n\n var ps = parents(node.parentNode, []);\n\n for (var i = 0; i < ps.length; i += 1) {\n if (scroll(ps[i])) {\n return ps[i];\n }\n }\n\n return document.scrollingElement || document.documentElement;\n };\n\n return scrollParent;\n}));\n","export const props = {\r\n items: {\r\n type: Array,\r\n required: true,\r\n },\r\n\r\n keyField: {\r\n type: String,\r\n default: 'id',\r\n },\r\n\r\n direction: {\r\n type: String,\r\n default: 'vertical',\r\n validator: (value) => ['vertical', 'horizontal'].includes(value),\r\n },\r\n}\r\n\r\nexport function simpleArray () {\r\n return this.items.length && typeof this.items[0] !== 'object'\r\n}\r\n","export let supportsPassive = false\r\n\r\nif (typeof window !== 'undefined') {\r\n supportsPassive = false\r\n try {\r\n var opts = Object.defineProperty({}, 'passive', {\r\n get () {\r\n supportsPassive = true\r\n },\r\n })\r\n window.addEventListener('test', null, opts)\r\n } catch (e) {}\r\n}\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n","import { reactive } from 'vue'\r\n\r\nexport default function ({\r\n idProp = vm => vm.item.id,\r\n} = {}) {\r\n const store = reactive({})\r\n\r\n // @vue/component\r\n return {\r\n data () {\r\n return {\r\n idState: null,\r\n }\r\n },\r\n\r\n created () {\r\n this.$_id = null\r\n if (typeof idProp === 'function') {\r\n this.$_getId = () => idProp.call(this, this)\r\n } else {\r\n this.$_getId = () => this[idProp]\r\n }\r\n this.$watch(this.$_getId, {\r\n handler (value) {\r\n this.$nextTick(() => {\r\n this.$_id = value\r\n })\r\n },\r\n immediate: true,\r\n })\r\n this.$_updateIdState()\r\n },\r\n\r\n beforeUpdate () {\r\n this.$_updateIdState()\r\n },\r\n\r\n methods: {\r\n /**\r\n * Initialize an idState\r\n * @param {number|string} id Unique id for the data\r\n */\r\n $_idStateInit (id) {\r\n const factory = this.$options.idState\r\n if (typeof factory === 'function') {\r\n const data = factory.call(this, this)\r\n store[id] = data\r\n this.$_id = id\r\n return data\r\n } else {\r\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\r\n }\r\n },\r\n\r\n /**\r\n * Ensure idState is created and up-to-date\r\n */\r\n $_updateIdState () {\r\n const id = this.$_getId()\r\n if (id == null) {\r\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\r\n }\r\n if (id !== this.$_id) {\r\n if (!store[id]) {\r\n this.$_idStateInit(id)\r\n }\r\n this.idState = store[id]\r\n }\r\n },\r\n },\r\n }\r\n}\r\n","import config from './config'\r\n\r\nimport RecycleScroller from './components/RecycleScroller.vue'\r\nimport DynamicScroller from './components/DynamicScroller.vue'\r\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\r\n\r\nexport { default as IdState } from './mixins/IdState'\r\n\r\nexport {\r\n RecycleScroller,\r\n DynamicScroller,\r\n DynamicScrollerItem,\r\n}\r\n\r\nfunction registerComponents (Vue, prefix) {\r\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\r\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\r\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\r\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\r\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\r\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\r\n}\r\n\r\nconst plugin = {\r\n // eslint-disable-next-line no-undef\r\n version: VERSION,\r\n install (Vue, options) {\r\n const finalOptions = Object.assign({}, {\r\n installComponents: true,\r\n componentsPrefix: '',\r\n }, options)\r\n\r\n for (const key in finalOptions) {\r\n if (typeof finalOptions[key] !== 'undefined') {\r\n config[key] = finalOptions[key]\r\n }\r\n }\r\n\r\n if (finalOptions.installComponents) {\r\n registerComponents(Vue, finalOptions.componentsPrefix)\r\n }\r\n },\r\n}\r\n\r\nexport default plugin\r\n\r\n// Auto-install\r\nlet GlobalVue = null\r\nif (typeof window !== 'undefined') {\r\n GlobalVue = window.Vue\r\n} else if (typeof global !== 'undefined') {\r\n GlobalVue = global.Vue\r\n}\r\nif (GlobalVue) {\r\n GlobalVue.use(plugin)\r\n}\r\n"],"names":["itemsLimit","_typeof","obj","Symbol","_typeof2","iterator","constructor","prototype","_classCallCheck","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_createClass","protoProps","staticProps","_toConsumableArray","arr","_arrayWithoutHoles","_iterableToArray","_nonIterableSpread","Array","isArray","arr2","iter","toString","call","from","makeMap","str","expectsLowerCase","map","create","list","split","val","toLowerCase","GLOBALS_WHITE_LISTED","isGloballyWhitelisted","specialBooleanAttrs","isSpecialBooleanAttr","normalizeStyle","value","res","item","normalized","isString","parseStringStyle","isObject","listDelimiterRE","propertyDelimiterRE","cssText","ret","forEach","tmp","trim","normalizeClass","name","EMPTY_OBJ","process","env","NODE_ENV","freeze","EMPTY_ARR","NOOP","onRE","isOn","test","isModelListener","startsWith","extend","assign","remove","el","indexOf","splice","hasOwnProperty","hasOwn","isMap","toTypeString","isSet","isFunction","isSymbol","isPromise","then","catch","objectToString","toRawType","slice","isIntegerKey","parseInt","cacheStringFunction","fn","cache","hit","camelizeRE","camelize","replace","_","c","toUpperCase","hyphenateRE","hyphenate","capitalize","charAt","hasChanged","oldValue","_globalThis","getGlobalThis","globalThis","self","window","global","targetMap","WeakMap","effectStack","activeEffect","ITERATE_KEY","MAP_KEY_ITERATE_KEY","isEffect","_isEffect","effect","options","raw","createReactiveEffect","lazy","stop","active","cleanup","onStop","uid","reactiveEffect","scheduler","undefined","includes","enableTracking","push","pop","resetTracking","id","allowRecurse","deps","delete","shouldTrack","trackStack","pauseTracking","last","track","type","depsMap","get","set","Map","dep","Set","has","add","onTrack","trigger","newValue","oldTarget","effects","effectsToAdd","run","onTrigger","builtInSymbols","getOwnPropertyNames","filter","createGetter","shallowGet","readonlyGet","shallowReadonlyGet","arrayInstrumentations","method","toRaw","l","args","apply","isReadonly","shallow","receiver","readonlyMap","reactiveMap","targetIsArray","Reflect","isRef","shouldUnwrap","readonly","reactive","createSetter","shallowSet","hadKey","Number","result","deleteProperty","ownKeys","mutableHandlers","readonlyHandlers","console","warn","String","shallowReactiveHandlers","shallowReadonlyHandlers","toReactive","toReadonly","toShallow","getProto","v","getPrototypeOf","get$1","isShallow","rawTarget","rawKey","wrap","has$1","size","proto","set$1","checkIdentityKeys","deleteEntry","clear","hadItems","createForEach","callback","thisArg","observed","createIterableMethod","targetIsMap","isPair","isKeyOnly","innerIterator","next","done","createReadonlyMethod","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","iteratorMethods","createInstrumentationGetter","instrumentations","mutableCollectionHandlers","readonlyCollectionHandlers","targetTypeMap","rawType","getTargetType","isExtensible","createReactiveObject","shallowReadonly","baseHandlers","collectionHandlers","proxyMap","existingProxy","targetType","proxy","Proxy","isReactive","isProxy","r","Boolean","__v_isRef","stack","pushWarningContext","vnode","popWarningContext","msg","component","appWarnHandler","appContext","config","warnHandler","trace","getComponentTrace","callWithErrorHandling","join","formatComponentName","warnArgs","formatTrace","currentVNode","normalizedStack","recurseCount","parentInstance","parent","logs","entry","formatTraceEntry","postfix","isRoot","open","close","formatProps","keys","formatProp","JSON","stringify","ErrorTypeStrings","err","handleError","callWithAsyncErrorHandling","values","throwInDev","contextVNode","cur","exposedInstance","errorInfo","errorCapturedHooks","ec","appErrorHandler","errorHandler","logError","info","error","isFlushing","isFlushPending","queue","flushIndex","pendingPreFlushCbs","activePreFlushCbs","preFlushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","Promise","resolve","currentFlushPromise","currentPreFlushParentJob","RECURSION_LIMIT","nextTick","p","bind","queueJob","job","queueFlush","flushJobs","queueCb","cb","activeQueue","pendingQueue","index","queuePreFlushCb","queuePostFlushCb","flushPreFlushCbs","seen","parentJob","checkRecursiveUpdates","flushPostFlushCbs","deduped","sort","a","b","getId","Infinity","count","Error","hmrDirtyComponents","globalObject","__VUE_HMR_RUNTIME__","createRecord","tryWrap","rerender","reload","isClassComponent","__vccOpts","instances","newRender","record","render","renderCache","update","newComp","location","arg","e","setDevtoolsHook","hook","currentRenderingInstance","markAttrsAccessed","filterSingleRoot","children","singleRoot","child","isVNode","Comment","isSuspense","__isSuspense","normalizeSuspenseChildren","shapeFlag","content","fallback","normalizeSuspenseSlot","default","normalizeVNode","s","singleChild","queueEffectWithSuspense","suspense","pendingBranch","isRenderingCompiledSlot","setCompiledSlotRendering","n","currentScopeId","INITIAL_WATCHER_VALUE","doWatch","source","immediate","deep","flush","currentInstance","warnInvalidSource","getter","forceTrigger","_shallow","traverse","isUnmounted","onInvalidate","baseGetter","runner","queuePostRenderEffect","isMounted","recordInstanceBoundEffect","instanceWatch","publicThis","isTeleport","__isTeleport","NULL_DYNAMIC_COMPONENT","Fragment","Text","Static","currentBlock","__v_isVNode","createVNodeWithArgsTransform","_createVNode","InternalObjectKey","normalizeKey","normalizeRef","ref","createVNode","patchFlag","dynamicProps","isBlockNode","cloned","cloneVNode","normalizeChildren","klass","class","style","ssContent","ssFallback","extraProps","mergeRef","mergedProps","mergeProps","concat","scopeId","targetAnchor","staticCount","dynamicChildren","dirs","transition","anchor","createTextVNode","text","flag","slot","_c","slotFlag","_ctx","toMerge","existing","incoming","isInBeforeCreate","resolveMergedOptions","__merged","mixins","extendsOptions","extends","globalMixins","m","mergeOptions","to","strats","optionMergeStrategies","getPublicInstance","publicPropertiesMap","$","$el","$data","data","$props","$attrs","attrs","$slots","slots","$refs","refs","$parent","$root","root","$emit","emit","$options","__VUE_OPTIONS_API__","$forceUpdate","$nextTick","$watch","PublicInstanceProxyHandlers","ctx","setupState","accessCache","normalizedProps","propsOptions","publicGetter","cssModule","globalProperties","__cssModules","RuntimeCompiledPublicInstanceProxyHandlers","unscopables","classifyRE","classify","Component","displayName","__file","match","inferFromRegistry","registry","components","ssrContextKey","initCustomFormatter","vueStyle","numberStyle","stringStyle","keywordStyle","formatter","header","__isVue","genRefFlag","formatValue","hasBody","body","formatInstance","blocks","createInstanceBlock","computed","extractKeys","injected","object","asRaw","Comp","extracted","isKeyOfType","opts","some","devtoolsFormatters","svgNS","doc","document","tempContainer","tempSVGContainer","nodeOps","insert","insertBefore","parentNode","removeChild","createElement","tag","isSVG","is","createElementNS","createText","createTextNode","createComment","setText","node","nodeValue","setElementText","textContent","nextSibling","querySelector","selector","setScopeId","setAttribute","cloneNode","insertStaticContent","temp","innerHTML","first","firstChild","patchClass","transitionClasses","_vtc","className","patchStyle","prev","removeAttribute","setStyle","importantRE","setProperty","prefixed","autoPrefix","prefixes","prefixCache","rawName","cached","xlinkNS","patchAttr","removeAttributeNS","setAttributeNS","isBoolean","patchDOMProp","prevChildren","parentComponent","parentSuspense","unmountChildren","tagName","_value","_getNow","Date","now","createEvent","timeStamp","performance","cachedNow","reset","getNow","addEventListener","event","handler","removeEventListener","patchEvent","prevValue","nextValue","invokers","_vei","existingInvoker","parseName","invoker","createInvoker","optionsModifierRE","initialValue","attached","patchStopImmediatePropagation","originalStop","stopImmediatePropagation","_stopped","nativeOnRE","forcePatchProp","patchProp","shouldSetAsProp","_trueValue","_falseValue","rendererOptions","initDev","__VUE__","__VUE_DEVTOOLS_GLOBAL_HOOK__","processOptions","throttle","delay","arguments","timeout","lastState","currentArgs","throttled","state","_len","_key","leading","clearTimeout","setTimeout","_clear","deepEqual","val1","val2","VisibilityState","observer","frozen","createObserver","_this","destroyObserver","once","_ref","throttleOptions","_leading","oldResult","IntersectionObserver","entries","intersectingEntry","find","isIntersecting","intersectionRatio","threshold","intersection","observe","disconnect","_ref2","_vue_visibilityState","_ref3","unbind","ObserveVisibility","beforeMount","updated","unmounted","install","Vue","directive","plugin","version","GlobalVue","use","this","items","required","keyField","direction","validator","simpleArray","supportsPassive","ResizeObserver","directives","itemSize","minItemSize","sizeField","typeField","buffer","pageMode","prerender","emitUpdate","pool","totalSize","ready","hoverKey","sizes","accumulator","field","computedMinSize","current","$_computedMinItemSize","watch","updateVisibleItems","applyPageMode","created","$_startIndex","$_endIndex","$_views","$_unusedViews","$_scrollDirty","$_lastUpdateScrollPosition","$_prerender","mounted","beforeUnmount","removeListeners","methods","addView","view","shallowReactive","position","nr","used","unuseView","fake","unusedViews","unusedPool","handleResize","handleScroll","requestAnimationFrame","continuous","$_refreshTimout","handleVisibilityChange","isVisible","boundingClientRect","width","height","checkItem","checkPositionDiff","views","startIndex","endIndex","scroll","getScroll","positionDiff","start","end","h","oldI","Math","ceil","itemsLimitError","$_continuous","findIndex","unusedIndex","$_sortTimer","sortViews","getListenerTarget","ScrollParent","documentElement","isVertical","scrollState","bounds","getBoundingClientRect","boundsSize","top","left","innerHeight","innerWidth","scrollTop","clientHeight","scrollLeft","clientWidth","addListeners","listenerTarget","passive","scrollToItem","scrollToPosition","log","viewA","viewB","_createBlock","before","_hoisted_1","_renderSlot","onMouseenter","onMouseleave","after","_hoisted_2","onNotify","RecycleScroller","inheritAttrs","provide","$_resizeObserver","CustomEvent","detail","contentRect","dispatchEvent","vscrollData","vscrollParent","vscrollResizeObserver","validSizes","itemsWithSize","$_undefinedMap","listeners","$listeners","forceUpdate","$_updates","$_undefinedSizes","activated","deactivated","onScrollerResize","scroller","onScrollerVisible","force","getItemSize","scrollToBottom","$_scrollingToBottom","scrollHeight","_mergeProps","onResize","onVisible","_toHandlers","_hoisted_3","inject","watchData","sizeDependencies","emitResize","finalActive","onDataUpdate","observeSize","unobserveSize","$_pendingVScrollUpdate","updateSize","$isServer","$_forceNextVScrollUpdate","updateWatchData","k","$on","onVscrollUpdate","onVscrollUpdateSize","$off","$_pendingSizeUpdate","computeSize","$_watchData","offsetWidth","offsetHeight","applySize","round","$set","unobserve","idProp","vm","store","idState","$_id","$_getId","$_updateIdState","beforeUpdate","$_idStateInit","factory","registerComponents","prefix","DynamicScroller","DynamicScrollerItem","VERSION","finalOptions","installComponents","componentsPrefix"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file diff --git a/package.json b/package.json index c83c8b19..e8d18751 100644 --- a/package.json +++ b/package.json @@ -38,7 +38,7 @@ "vue-resize": "^0.4.5" }, "peerDependencies": { - "vue": "^2.6.11" + "vue": "^3.0.0" }, "devDependencies": { "@babel/core": "^7.9.0", @@ -46,6 +46,7 @@ "@rollup/plugin-commonjs": "^11.0.2", "@rollup/plugin-node-resolve": "^7.1.1", "@rollup/plugin-replace": "^2.3.1", + "@vue/compiler-sfc": "^3.0.4", "autoprefixer": "^9.7.5", "babel-eslint": "^10.1.0", "clean-css": "^4.1.8", @@ -64,9 +65,8 @@ "rollup-plugin-css-porter": "^1.0.2", "rollup-plugin-eslint": "^7.0.0", "rollup-plugin-terser": "^5.3.0", - "rollup-plugin-vue": "^5.1.6", - "vue": "^2.5.17", - "vue-template-compiler": "^2.6.11" + "rollup-plugin-vue": "^6.0.0", + "vue": "^3.0.0" }, "browserslist": [ "> 1%", @@ -74,6 +74,6 @@ "not ie <= 8" ], "resolutions": { - "vue": "2.5.22" + "vue": "3.0.4" } } diff --git a/src/components/DynamicScrollerItem.vue b/src/components/DynamicScrollerItem.vue index 3db24018..d2e6e045 100644 --- a/src/components/DynamicScrollerItem.vue +++ b/src/components/DynamicScrollerItem.vue @@ -121,7 +121,7 @@ export default { } }, - beforeDestroy () { + beforeUnmount () { this.vscrollParent.$off('vscroll:update', this.onVscrollUpdate) this.vscrollParent.$off('vscroll:update-size', this.onVscrollUpdateSize) this.unobserveSize() diff --git a/src/components/RecycleScroller.vue b/src/components/RecycleScroller.vue index 236d2ba6..f6b2f3ed 100644 --- a/src/components/RecycleScroller.vue +++ b/src/components/RecycleScroller.vue @@ -54,6 +54,7 @@ \r\n\r\n\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n","import { reactive } from 'vue'\r\n\r\nexport default function ({\r\n idProp = vm => vm.item.id,\r\n} = {}) {\r\n const store = reactive({})\r\n\r\n // @vue/component\r\n return {\r\n data () {\r\n return {\r\n idState: null,\r\n }\r\n },\r\n\r\n created () {\r\n this.$_id = null\r\n if (typeof idProp === 'function') {\r\n this.$_getId = () => idProp.call(this, this)\r\n } else {\r\n this.$_getId = () => this[idProp]\r\n }\r\n this.$watch(this.$_getId, {\r\n handler (value) {\r\n this.$nextTick(() => {\r\n this.$_id = value\r\n })\r\n },\r\n immediate: true,\r\n })\r\n this.$_updateIdState()\r\n },\r\n\r\n beforeUpdate () {\r\n this.$_updateIdState()\r\n },\r\n\r\n methods: {\r\n /**\r\n * Initialize an idState\r\n * @param {number|string} id Unique id for the data\r\n */\r\n $_idStateInit (id) {\r\n const factory = this.$options.idState\r\n if (typeof factory === 'function') {\r\n const data = factory.call(this, this)\r\n store[id] = data\r\n this.$_id = id\r\n return data\r\n } else {\r\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\r\n }\r\n },\r\n\r\n /**\r\n * Ensure idState is created and up-to-date\r\n */\r\n $_updateIdState () {\r\n const id = this.$_getId()\r\n if (id == null) {\r\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\r\n }\r\n if (id !== this.$_id) {\r\n if (!store[id]) {\r\n this.$_idStateInit(id)\r\n }\r\n this.idState = store[id]\r\n }\r\n },\r\n },\r\n }\r\n}\r\n","import config from './config'\r\n\r\nimport RecycleScroller from './components/RecycleScroller.vue'\r\nimport DynamicScroller from './components/DynamicScroller.vue'\r\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\r\n\r\nexport { default as IdState } from './mixins/IdState'\r\n\r\nexport {\r\n RecycleScroller,\r\n DynamicScroller,\r\n DynamicScrollerItem,\r\n}\r\n\r\nfunction registerComponents (Vue, prefix) {\r\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\r\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\r\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\r\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\r\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\r\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\r\n}\r\n\r\nconst plugin = {\r\n // eslint-disable-next-line no-undef\r\n version: VERSION,\r\n install (Vue, options) {\r\n const finalOptions = Object.assign({}, {\r\n installComponents: true,\r\n componentsPrefix: '',\r\n }, options)\r\n\r\n for (const key in finalOptions) {\r\n if (typeof finalOptions[key] !== 'undefined') {\r\n config[key] = finalOptions[key]\r\n }\r\n }\r\n\r\n if (finalOptions.installComponents) {\r\n registerComponents(Vue, finalOptions.componentsPrefix)\r\n }\r\n },\r\n}\r\n\r\nexport default plugin\r\n\r\n// Auto-install\r\nlet GlobalVue = null\r\nif (typeof window !== 'undefined') {\r\n GlobalVue = window.Vue\r\n} else if (typeof global !== 'undefined') {\r\n GlobalVue = global.Vue\r\n}\r\nif (GlobalVue) {\r\n GlobalVue.use(plugin)\r\n}\r\n"],"names":["itemsLimit","props","items","type","Array","required","keyField","String","default","direction","validator","value","includes","simpleArray","length","supportsPassive","window","opts","Object","defineProperty","get","addEventListener","e","uid","name","components","ResizeObserver","directives","ObserveVisibility","itemSize","Number","minItemSize","sizeField","typeField","buffer","pageMode","Boolean","prerender","emitUpdate","data","pool","totalSize","ready","hoverKey","computed","sizes","accumulator","field","computedMinSize","current","i","l","size","$_computedMinItemSize","watch","updateVisibleItems","applyPageMode","handler","deep","created","$_startIndex","$_endIndex","$_views","Map","$_unusedViews","$_scrollDirty","$_lastUpdateScrollPosition","$_prerender","mounted","$nextTick","beforeUnmount","removeListeners","methods","addView","index","item","key","view","shallowReactive","position","nr","id","used","push","unuseView","fake","unusedViews","unusedPool","set","delete","handleResize","$emit","handleScroll","event","requestAnimationFrame","continuous","clearTimeout","$_refreshTimout","setTimeout","handleVisibilityChange","isVisible","entry","boundingClientRect","width","height","checkItem","checkPositionDiff","count","views","startIndex","endIndex","scroll","getScroll","positionDiff","start","end","h","a","b","oldI","Math","ceil","config","itemsLimitError","$_continuous","clear","findIndex","unusedIndex","v","Error","pop","$_sortTimer","sortViews","getListenerTarget","target","ScrollParent","$el","document","documentElement","body","el","isVertical","scrollState","bounds","getBoundingClientRect","boundsSize","top","left","innerHeight","innerWidth","scrollTop","clientHeight","scrollLeft","clientWidth","addListeners","listenerTarget","passive","removeEventListener","scrollToItem","scrollToPosition","console","log","sort","viewA","viewB","class","_createBlock","$options","_ctx","before","_hoisted_1","_renderSlot","_createVNode","ref","style","$data","onMouseenter","onMouseleave","active","after","_hoisted_2","onNotify","RecycleScroller","inheritAttrs","provide","$_resizeObserver","entries","CustomEvent","detail","contentRect","dispatchEvent","vscrollData","vscrollParent","vscrollResizeObserver","validSizes","itemsWithSize","result","$_undefinedMap","listeners","$listeners","forceUpdate","immediate","$_updates","$_undefinedSizes","activated","deactivated","onScrollerResize","scroller","$refs","onScrollerVisible","force","getItemSize","undefined","indexOf","scrollToBottom","$_scrollingToBottom","scrollHeight","cb","slot","_mergeProps","$props","onResize","onVisible","_toHandlers","_hoisted_3","inject","watchData","sizeDependencies","emitResize","tag","finalActive","onDataUpdate","observeSize","unobserveSize","$_pendingVScrollUpdate","updateSize","$isServer","$_forceNextVScrollUpdate","updateWatchData","k","$watch","$on","onVscrollUpdate","onVscrollUpdateSize","$off","$_pendingSizeUpdate","computeSize","$_watchData","offsetWidth","offsetHeight","applySize","round","$set","observe","parentNode","unobserve","render","$slots","idProp","vm","store","reactive","idState","$_id","$_getId","call","$_updateIdState","beforeUpdate","$_idStateInit","factory","warn","registerComponents","Vue","prefix","component","DynamicScroller","DynamicScrollerItem","plugin","version","VERSION","install","options","finalOptions","assign","installComponents","componentsPrefix","GlobalVue","global","use"],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"vue-virtual-scroller.esm.js","sources":["../src/config.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../src/components/RecycleScroller.vue?vue&type=template&id=093a936d&lang.js","../src/components/DynamicScroller.vue","../src/components/DynamicScroller.vue?vue&type=template&id=76e15f19&lang.js","../src/components/DynamicScrollerItem.vue","../src/mixins/IdState.js","../src/index.js"],"sourcesContent":["export default {\r\n itemsLimit: 1000,\r\n}\r\n","export const props = {\r\n items: {\r\n type: Array,\r\n required: true,\r\n },\r\n\r\n keyField: {\r\n type: String,\r\n default: 'id',\r\n },\r\n\r\n direction: {\r\n type: String,\r\n default: 'vertical',\r\n validator: (value) => ['vertical', 'horizontal'].includes(value),\r\n },\r\n}\r\n\r\nexport function simpleArray () {\r\n return this.items.length && typeof this.items[0] !== 'object'\r\n}\r\n","export let supportsPassive = false\r\n\r\nif (typeof window !== 'undefined') {\r\n supportsPassive = false\r\n try {\r\n var opts = Object.defineProperty({}, 'passive', {\r\n get () {\r\n supportsPassive = true\r\n },\r\n })\r\n window.addEventListener('test', null, opts)\r\n } catch (e) {}\r\n}\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n","import { reactive } from 'vue'\r\n\r\nexport default function ({\r\n idProp = vm => vm.item.id,\r\n} = {}) {\r\n const store = reactive({})\r\n\r\n // @vue/component\r\n return {\r\n data () {\r\n return {\r\n idState: null,\r\n }\r\n },\r\n\r\n created () {\r\n this.$_id = null\r\n if (typeof idProp === 'function') {\r\n this.$_getId = () => idProp.call(this, this)\r\n } else {\r\n this.$_getId = () => this[idProp]\r\n }\r\n this.$watch(this.$_getId, {\r\n handler (value) {\r\n this.$nextTick(() => {\r\n this.$_id = value\r\n })\r\n },\r\n immediate: true,\r\n })\r\n this.$_updateIdState()\r\n },\r\n\r\n beforeUpdate () {\r\n this.$_updateIdState()\r\n },\r\n\r\n methods: {\r\n /**\r\n * Initialize an idState\r\n * @param {number|string} id Unique id for the data\r\n */\r\n $_idStateInit (id) {\r\n const factory = this.$options.idState\r\n if (typeof factory === 'function') {\r\n const data = factory.call(this, this)\r\n store[id] = data\r\n this.$_id = id\r\n return data\r\n } else {\r\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\r\n }\r\n },\r\n\r\n /**\r\n * Ensure idState is created and up-to-date\r\n */\r\n $_updateIdState () {\r\n const id = this.$_getId()\r\n if (id == null) {\r\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\r\n }\r\n if (id !== this.$_id) {\r\n if (!store[id]) {\r\n this.$_idStateInit(id)\r\n }\r\n this.idState = store[id]\r\n }\r\n },\r\n },\r\n }\r\n}\r\n","import config from './config'\r\n\r\nimport RecycleScroller from './components/RecycleScroller.vue'\r\nimport DynamicScroller from './components/DynamicScroller.vue'\r\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\r\n\r\nexport { default as IdState } from './mixins/IdState'\r\n\r\nexport {\r\n RecycleScroller,\r\n DynamicScroller,\r\n DynamicScrollerItem,\r\n}\r\n\r\nfunction registerComponents (Vue, prefix) {\r\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\r\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\r\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\r\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\r\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\r\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\r\n}\r\n\r\nconst plugin = {\r\n // eslint-disable-next-line no-undef\r\n version: VERSION,\r\n install (Vue, options) {\r\n const finalOptions = Object.assign({}, {\r\n installComponents: true,\r\n componentsPrefix: '',\r\n }, options)\r\n\r\n for (const key in finalOptions) {\r\n if (typeof finalOptions[key] !== 'undefined') {\r\n config[key] = finalOptions[key]\r\n }\r\n }\r\n\r\n if (finalOptions.installComponents) {\r\n registerComponents(Vue, finalOptions.componentsPrefix)\r\n }\r\n },\r\n}\r\n\r\nexport default plugin\r\n\r\n// Auto-install\r\nlet GlobalVue = null\r\nif (typeof window !== 'undefined') {\r\n GlobalVue = window.Vue\r\n} else if (typeof global !== 'undefined') {\r\n GlobalVue = global.Vue\r\n}\r\nif (GlobalVue) {\r\n GlobalVue.use(plugin)\r\n}\r\n"],"names":["itemsLimit","props","items","type","Array","required","keyField","String","default","direction","validator","value","includes","simpleArray","length","supportsPassive","window","opts","Object","defineProperty","get","addEventListener","e","uid","name","components","ResizeObserver","directives","ObserveVisibility","emits","itemSize","Number","minItemSize","sizeField","typeField","buffer","pageMode","Boolean","prerender","emitUpdate","data","pool","totalSize","ready","hoverKey","computed","sizes","accumulator","field","computedMinSize","current","i","l","size","$_computedMinItemSize","watch","updateVisibleItems","applyPageMode","handler","deep","created","$_startIndex","$_endIndex","$_views","Map","$_unusedViews","$_scrollDirty","$_lastUpdateScrollPosition","$_prerender","mounted","$nextTick","beforeUnmount","removeListeners","methods","addView","index","item","key","view","shallowReactive","position","nr","id","used","push","unuseView","fake","unusedViews","unusedPool","set","delete","handleResize","$emit","handleScroll","event","requestAnimationFrame","continuous","clearTimeout","$_refreshTimout","setTimeout","handleVisibilityChange","isVisible","entry","boundingClientRect","width","height","checkItem","checkPositionDiff","count","views","startIndex","endIndex","scroll","getScroll","positionDiff","start","end","h","a","b","oldI","Math","ceil","config","itemsLimitError","$_continuous","clear","findIndex","unusedIndex","v","Error","pop","$_sortTimer","sortViews","getListenerTarget","target","ScrollParent","$el","document","documentElement","body","el","isVertical","scrollState","bounds","getBoundingClientRect","boundsSize","top","left","innerHeight","innerWidth","scrollTop","clientHeight","scrollLeft","clientWidth","addListeners","listenerTarget","passive","removeEventListener","scrollToItem","scrollToPosition","console","log","sort","viewA","viewB","class","_createBlock","$options","_ctx","before","_hoisted_1","_renderSlot","_createVNode","ref","style","$data","onMouseenter","onMouseleave","active","after","_hoisted_2","onNotify","RecycleScroller","inheritAttrs","provide","$_resizeObserver","entries","CustomEvent","detail","contentRect","dispatchEvent","vscrollData","vscrollParent","vscrollResizeObserver","validSizes","itemsWithSize","result","$_undefinedMap","listeners","$listeners","forceUpdate","immediate","$_updates","$_undefinedSizes","activated","deactivated","onScrollerResize","scroller","$refs","onScrollerVisible","force","getItemSize","undefined","indexOf","scrollToBottom","$_scrollingToBottom","scrollHeight","cb","_mergeProps","$props","onResize","onVisible","_toHandlers","itemWithSize","inject","watchData","sizeDependencies","emitResize","tag","finalActive","onDataUpdate","observeSize","unobserveSize","$_pendingVScrollUpdate","updateSize","$isServer","$_forceNextVScrollUpdate","updateWatchData","k","$watch","$on","onVscrollUpdate","onVscrollUpdateSize","$off","$_pendingSizeUpdate","computeSize","$_watchData","offsetWidth","offsetHeight","applySize","round","$set","observe","parentNode","unobserve","render","$slots","idProp","vm","store","reactive","idState","$_id","$_getId","call","$_updateIdState","beforeUpdate","$_idStateInit","factory","warn","registerComponents","Vue","prefix","component","DynamicScroller","DynamicScrollerItem","plugin","version","VERSION","install","options","finalOptions","assign","installComponents","componentsPrefix","GlobalVue","global","use"],"mappings":"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"} \ No newline at end of file diff --git a/dist/vue-virtual-scroller.min.js b/dist/vue-virtual-scroller.min.js index ece89c69..dfb7d4b5 100644 --- a/dist/vue-virtual-scroller.min.js +++ b/dist/vue-virtual-scroller.min.js @@ -1,2 +1,2 @@ -var VueVirtualScroller=function(e,t){"use strict";var n,r={itemsLimit:1e3};function o(e){return(o="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function i(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function a(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function s(e){for(var t=1;te.length)&&(t=e.length);for(var n=0,r=new Array(t);n1&&(t[n[0].trim()]=n[1].trim())}})),t}function m(e){var t="";if(A(e))t=e;else if(R(e))for(var n=0;n-1&&e.splice(n,1)},D=Object.prototype.hasOwnProperty,z=function(e,t){return D.call(e,t)},R=Array.isArray,C=function(e){return"[object Map]"===U(e)},I=function(e){return"[object Set]"===U(e)},P=function(e){return"function"==typeof e},A=function(e){return"string"==typeof e},j=function(e){return"symbol"===o(e)},T=function(e){return null!==e&&"object"===o(e)},M=Object.prototype.toString,U=function(e){return M.call(e)},F=function(e){return U(e).slice(8,-1)},L=function(e){return A(e)&&"NaN"!==e&&"-"!==e[0]&&""+parseInt(e,10)===e},H=(_=function(e){return e.charAt(0).toUpperCase()+e.slice(1)},b=Object.create(null),function(e){return b[e]||(b[e]=_(e))}),B=function(e,t){return e!==t&&(e==e||t==t)},W=new WeakMap,q=[],K=Symbol("production"!==process.env.NODE_ENV?"iterate":""),J=Symbol("production"!==process.env.NODE_ENV?"Map key iterate":"");function G(e){return e&&!0===e._isEffect}function X(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:N;G(e)&&(e=e.raw);var n=Q(e,t);return t.lazy||n(),n}function Y(e){e.active&&(ee(e),e.options.onStop&&e.options.onStop(),e.active=!1)}var Z=0;function Q(e,t){var n=function(){if(!n.active)return t.scheduler?void 0:e();if(!q.includes(n)){ee(n);try{return ne.push(te),te=!0,q.push(n),E=n,e()}finally{q.pop(),oe(),E=q[q.length-1]}}};return n.id=Z++,n.allowRecurse=!!t.allowRecurse,n._isEffect=!0,n.active=!0,n.raw=e,n.deps=[],n.options=t,n}function ee(e){var t=e.deps;if(t.length){for(var n=0;n=r)&&c(e)}));else switch(void 0!==n&&c(a.get(n)),t){case"add":R(e)?L(n)&&c(a.get("length")):(c(a.get(K)),C(e)&&c(a.get(J)));break;case"delete":R(e)||(c(a.get(K)),C(e)&&c(a.get(J)));break;case"set":C(e)&&c(a.get(K))}s.forEach((function(a){"production"!==process.env.NODE_ENV&&a.options.onTrigger&&a.options.onTrigger({effect:a,target:e,key:n,type:t,newValue:r,oldValue:o,oldTarget:i}),a.options.scheduler?a.options.scheduler(a):a()}))}}var se=new Set(Object.getOwnPropertyNames(Symbol).map((function(e){return Symbol[e]})).filter(j)),ce=pe(),ue=pe(!1,!0),le=pe(!0),fe=pe(!0,!0),de={};function pe(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0],t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return function(n,r,o){if("__v_isReactive"===r)return!e;if("__v_isReadonly"===r)return e;if("__v_raw"===r&&o===(e?Ue:Me).get(n))return n;var i=R(n);if(!e&&i&&z(de,r))return Reflect.get(de,r,o);var a=Reflect.get(n,r,o);return(j(r)?se.has(r):"__proto__"===r||"__v_isRef"===r)?a:(e||ie(n,"get",r),t?a:Ge(a)?!i||!L(r)?a.value:a:T(a)?e?Le(a):Fe(a):a)}}function ve(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0];return function(t,n,r,o){var i=t[n];if(!e&&(r=Je(r),!R(t)&&Ge(i)&&!Ge(r)))return i.value=r,!0;var a=R(t)&&L(n)?Number(n)2&&void 0!==arguments[2]&&arguments[2],r=arguments.length>3&&void 0!==arguments[3]&&arguments[3],o=Je(e=e.__v_raw),i=Je(t);t!==i&&!n&&ie(o,"get",t),!n&&ie(o,"get",i);var a=we(o),s=a.has,c=n?_e:r?be:me;return s.call(o,t)?c(e.get(t)):s.call(o,i)?c(e.get(i)):void 0}function Ne(e){var t=arguments.length>1&&void 0!==arguments[1]&&arguments[1],n=this.__v_raw,r=Je(n),o=Je(e);return e!==o&&!t&&ie(r,"has",e),!t&&ie(r,"has",o),e===o?n.has(e):n.has(e)||n.has(o)}function Se(e){var t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return e=e.__v_raw,!t&&ie(Je(e),"iterate",K),Reflect.get(e,"size",e)}function Oe(e){e=Je(e);var t=Je(this),n=we(t).has.call(t,e);return t.add(e),n||ae(t,"add",e,e),this}function Ve(e,t){t=Je(t);var n=Je(this),r=we(n),o=r.has,i=r.get,a=o.call(n,e);a?"production"!==process.env.NODE_ENV&&Te(n,o,e):(e=Je(e),a=o.call(n,e));var s=i.call(n,e);return n.set(e,t),a?B(t,s)&&ae(n,"set",e,t,s):ae(n,"add",e,t),this}function ke(e){var t=Je(this),n=we(t),r=n.has,o=n.get,i=r.call(t,e);i?"production"!==process.env.NODE_ENV&&Te(t,r,e):(e=Je(e),i=r.call(t,e));var a=o?o.call(t,e):void 0,s=t.delete(e);return i&&ae(t,"delete",e,void 0,a),s}function $e(){var e=Je(this),t=0!==e.size,n="production"!==process.env.NODE_ENV?C(e)?new Map(e):new Set(e):void 0,r=e.clear();return t&&ae(e,"clear",void 0,void 0,n),r}function xe(e,t){return function(n,r){var o=this,i=o.__v_raw,a=Je(i),s=e?_e:t?be:me;return!e&&ie(a,"iterate",K),i.forEach((function(e,t){return n.call(r,s(e),s(t),o)}))}}function De(e,t,n){return function(){var r=this.__v_raw,o=Je(r),a=C(o),s="entries"===e||e===Symbol.iterator&&a,c="keys"===e&&a,u=r[e].apply(r,arguments),l=t?_e:n?be:me;return!t&&ie(o,"iterate",c?J:K),i({next:function(){var e=u.next(),t=e.value,n=e.done;return n?{value:t,done:n}:{value:s?[l(t[0]),l(t[1])]:l(t),done:n}}},Symbol.iterator,(function(){return this}))}}function ze(e){return function(){if("production"!==process.env.NODE_ENV){var t=(arguments.length<=0?void 0:arguments[0])?'on key "'.concat(arguments.length<=0?void 0:arguments[0],'" '):"";console.warn("".concat(H(e)," operation ").concat(t,"failed: target is readonly."),Je(this))}return"delete"!==e&&this}}var Re={get:function(e){return Ee(this,e)},get size(){return Se(this)},has:Ne,add:Oe,set:Ve,delete:ke,clear:$e,forEach:xe(!1,!1)},Ce={get:function(e){return Ee(this,e,!1,!0)},get size(){return Se(this)},has:Ne,add:Oe,set:Ve,delete:ke,clear:$e,forEach:xe(!1,!0)},Ie={get:function(e){return Ee(this,e,!0)},get size(){return Se(this,!0)},has:function(e){return Ne.call(this,e,!0)},add:ze("add"),set:ze("set"),delete:ze("delete"),clear:ze("clear"),forEach:xe(!0,!1)};function Pe(e,t){var n=t?Ce:e?Ie:Re;return function(t,r,o){return"__v_isReactive"===r?!e:"__v_isReadonly"===r?e:"__v_raw"===r?t:Reflect.get(z(n,r)&&r in t?n:t,r,o)}}["keys","values","entries",Symbol.iterator].forEach((function(e){Re[e]=De(e,!1,!1),Ie[e]=De(e,!0,!1),Ce[e]=De(e,!1,!0)}));var Ae={get:Pe(!1,!1)},je={get:Pe(!0,!1)};function Te(e,t,n){var r=Je(n);if(r!==n&&t.call(e,r)){var o=F(e);console.warn("Reactive ".concat(o," contains both the raw and reactive ")+"versions of the same object".concat("Map"===o?" 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.")}}var Me=new WeakMap,Ue=new WeakMap;function Fe(e){return e&&e.__v_isReadonly?e:Be(e,!1,he,Ae)}function Le(e){return Be(e,!0,ye,je)}function He(e){return Be(e,!0,ge,je)}function Be(e,t,n,r){if(!T(e))return"production"!==process.env.NODE_ENV&&console.warn("value cannot be made reactive: ".concat(String(e))),e;if(e.__v_raw&&(!t||!e.__v_isReactive))return e;var o=t?Ue:Me,i=o.get(e);if(i)return i;var a,s=(a=e).__v_skip||!Object.isExtensible(a)?0:function(e){switch(e){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}(F(a));if(0===s)return e;var c=new Proxy(e,2===s?r:n);return o.set(e,c),c}function We(e){return qe(e)?We(e.__v_raw):!(!e||!e.__v_isReactive)}function qe(e){return!(!e||!e.__v_isReadonly)}function Ke(e){return We(e)||qe(e)}function Je(e){return e&&Je(e.__v_raw)||e}function Ge(e){return Boolean(e&&!0===e.__v_isRef)}var Xe=[];function Ye(e){Xe.push(e)}function Ze(){Xe.pop()}function Qe(e){re();for(var t=Xe.length?Xe[Xe.length-1].component:null,n=t&&t.appContext.config.warnHandler,r=et(),o=arguments.length,i=new Array(o>1?o-1:0),a=1;a")})).join("\n"),r]);else{var s,c=["[Vue warn]: ".concat(e)].concat(i);r.length&&c.push.apply(c,["\n"].concat(u(tt(r)))),(s=console).warn.apply(s,u(c))}oe()}function et(){var e=Xe[Xe.length-1];if(!e)return[];for(var t=[];e;){var n=t[0];n&&n.vnode===e?n.recurseCount++:t.push({vnode:e,recurseCount:0});var r=e.component&&e.component.parent;e=r&&r.vnode}return t}function tt(e){var t=[];return e.forEach((function(e,n){var r,o,i,a,s,c,l;t.push.apply(t,u(0===n?[]:["\n"]).concat(u((o=(r=e).vnode,i=r.recurseCount,a=i>0?"... (".concat(i," recursive calls)"):"",s=!!o.component&&null==o.component.parent,c=" at <".concat(wn(o.component,o.type,s)),l=">"+a,o.props?[c].concat(u(function(e){var t=[],n=Object.keys(e);return n.slice(0,3).forEach((function(n){t.push.apply(t,u(function e(t,n,r){return A(n)?(n=JSON.stringify(n),r?n:["".concat(t,"=").concat(n)]):"number"==typeof n||"boolean"==typeof n||null==n?r?n:["".concat(t,"=").concat(n)]:Ge(n)?(n=e(t,Je(n.value),!0),r?n:["".concat(t,"=Ref<"),n,">"]):P(n)?["".concat(t,"=fn").concat(n.name?"<".concat(n.name,">"):"")]:(n=Je(n),r?n:["".concat(t,"="),n])}(n,e[n])))})),n.length>3&&t.push(" ..."),t}(o.props)),[l]):[c+l]))))})),t}var nt=(i(n={},"bc","beforeCreate hook"),i(n,"c","created hook"),i(n,"bm","beforeMount hook"),i(n,"m","mounted hook"),i(n,"bu","beforeUpdate hook"),i(n,"u","updated"),i(n,"bum","beforeUnmount hook"),i(n,"um","unmounted hook"),i(n,"a","activated hook"),i(n,"da","deactivated hook"),i(n,"ec","errorCaptured hook"),i(n,"rtc","renderTracked hook"),i(n,"rtg","renderTriggered hook"),i(n,0,"setup function"),i(n,1,"render function"),i(n,2,"watcher getter"),i(n,3,"watcher callback"),i(n,4,"watcher cleanup function"),i(n,5,"native event handler"),i(n,6,"component event handler"),i(n,7,"vnode hook"),i(n,8,"directive hook"),i(n,9,"transition hook"),i(n,10,"app errorHandler"),i(n,11,"app warnHandler"),i(n,12,"ref function"),i(n,13,"async component loader"),i(n,14,"scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next"),n);function rt(e,t,n,r){var o;try{o=r?e.apply(void 0,u(r)):e()}catch(e){it(e,t,n)}return o}function ot(e,t,n,r){if(P(e)){var o=rt(e,t,n,r);return o&&(T(i=o)&&P(i.then)&&P(i.catch))&&o.catch((function(e){it(e,t,n)})),o}for(var i,a=[],s=0;s3&&void 0!==arguments[3])||arguments[3],o=t?t.vnode:null;if(t){for(var i=t.parent,a=t.proxy,s="production"!==process.env.NODE_ENV?nt[n]:n;i;){var c=i.ec;if(c)for(var u=0;u3&&void 0!==arguments[3])||arguments[3];if("production"!==process.env.NODE_ENV){var o=nt[t];if(n&&Ye(n),Qe("Unhandled error".concat(o?" during execution of ".concat(o):"")),n&&Ze(),r)throw e;console.error(e)}else console.error(e)}var st=!1,ct=!1,ut=[],lt=0,ft=[],dt=null,pt=0,vt=[],ht=null,yt=0,gt=Promise.resolve(),mt=null,_t=null;function bt(e){var t=mt||gt;return e?t.then(this?e.bind(this):e):t}function wt(e){ut.length&&ut.includes(e,st&&e.allowRecurse?lt+1:lt)||e===_t||(ut.push(e),Et())}function Et(){st||ct||(ct=!0,mt=gt.then(kt))}function Nt(e,t,n,r){R(e)?n.push.apply(n,u(e)):t&&t.includes(e,e.allowRecurse?r+1:r)||n.push(e),Et()}function St(e){Nt(e,dt,ft,pt)}function Ot(e){Nt(e,ht,vt,yt)}var Vt=function(e){return null==e.id?1/0:e.id};function kt(e){ct=!1,st=!0,"production"!==process.env.NODE_ENV&&(e=e||new Map),function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(ft.length){for(_t=n,dt=u(new Set(ft)),ft.length=0,"production"!==process.env.NODE_ENV&&(t=t||new Map),pt=0;pt100)throw new Error("Maximum recursive updates exceeded. 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.");e.set(t,n+1)}else e.set(t,1)}var xt=new Set;"production"!==process.env.NODE_ENV&&(("undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{}).__VUE_HMR_RUNTIME__={createRecord:zt((function(e,t){t||(Qe("HMR API usage is out of date.\nPlease upgrade vue-loader/vite/rollup-plugin-vue or other relevant depdendency that handles Vue SFC compilation."),t={});if(Dt.has(e))return!1;return Dt.set(e,{component:En(t)?t.__vccOpts:t,instances:new Set}),!0})),rerender:zt((function(e,t){var n=Dt.get(e);if(!n)return;t&&(n.component.render=t);Array.from(n.instances).forEach((function(e){t&&(e.render=t),e.renderCache=[],e.update()}))})),reload:zt((function(e,t){var n=Dt.get(e);if(!n)return;var r=n.component,o=n.instances;if(!xt.has(r)){for(var i in t=En(t)?t.__vccOpts:t,$(r,t),r)i in t||delete r[i];xt.add(r),Ot((function(){xt.delete(r)}))}Array.from(o).forEach((function(e){e.parent?wt(e.parent.update):e.appContext.reload?e.appContext.reload():"undefined"!=typeof window?window.location.reload():console.warn("[HMR] Root or manually mounted instance modified. Full reload required.")}))}))});var Dt=new Map;function zt(e){return function(t,n){try{return e(t,n)}catch(e){console.error(e),console.warn("[HMR] Something went wrong during Vue component hot-reload. Full reload required.")}}}var Rt=null;function Ct(e){Rt=e}var It=function(e){return e.__isSuspense};function Pt(e){var t,n,r=e.shapeFlag,o=e.children;return 32&r?(t=At(o.default),n=At(o.fallback)):(t=At(o),n=fn(null)),{content:t,fallback:n}}function At(e){if(P(e)&&(e=e()),R(e)){var t=function(e){for(var t,n=0;n slots expect a single root node."),e=t}return fn(e)}var jt=0,Tt=function(e){return jt+=e};var Mt=null,Ut=[];function Ft(e){Ut.push(Mt=e)}function Lt(){Ut.pop(),Mt=Ut[Ut.length-1]||null}function Ht(e){return function(t){return function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Rt;if(!t)return e;var n=function(){jt||tn(!0);var n=Rt;Ct(t);var r=e.apply(void 0,arguments);return Ct(n),jt||nn(),r};return n._c=!0,n}((function(){Ft(e);var n=t.apply(this,arguments);return Lt(),n}))}}var Bt={};function Wt(e,t,n){var r=this.proxy;return function(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:N,r=n.immediate,o=n.deep,i=n.flush,a=n.onTrack,s=n.onTrigger,c=arguments.length>3&&void 0!==arguments[3]?arguments[3]:gn;"production"===process.env.NODE_ENV||t||(void 0!==r&&Qe('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'),void 0!==o&&Qe('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'));var u,l,f=function(e){Qe("Invalid watch source: ",e,"A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.")},d=!1;if(Ge(e)?(u=function(){return e.value},d=!!e._shallow):We(e)?(u=function(){return e},o=!0):R(e)?u=function(){return e.map((function(e){return Ge(e)?e.value:We(e)?qt(e):P(e)?rt(e,c,2):void("production"!==process.env.NODE_ENV&&f(e))}))}:P(e)?u=t?function(){return rt(e,c,2)}:function(){if(!c||!c.isUnmounted)return l&&l(),rt(e,c,3,[v])}:(u=O,"production"!==process.env.NODE_ENV&&f(e)),t&&o){var p=u;u=function(){return qt(p())}}var v=function(e){l=g.options.onStop=function(){rt(e,c,4)}},h=R(e)?[]:Bt,y=function(){if(g.active)if(t){var e=g();(o||d||B(e,h))&&(l&&l(),ot(t,c,3,[e,h===Bt?void 0:h,v]),h=e)}else g()};y.allowRecurse=!!t;var g=X(u,{lazy:!0,onTrack:a,onTrigger:s,scheduler:"sync"===i?y:"post"===i?function(){return Kt(y,c&&c.suspense)}:function(){!c||c.isMounted?St(y):y()}});return mn(g,c),t?r?y():h=g():"post"===i?Kt(g,c&&c.suspense):g(),function(){Y(g),c&&x(c.effects,g)}}(A(e)?function(){return r[e]}:e.bind(r),t.bind(r),n,this)}function qt(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:new Set;if(!T(e)||t.has(e))return e;if(t.add(e),Ge(e))qt(e.value,t);else if(R(e))for(var n=0;n0&&void 0!==arguments[0]&&arguments[0];Qt.push(en=e?null:[])}function nn(){Qt.pop(),en=Qt[Qt.length-1]||null}function rn(e){return!!e&&!0===e.__v_isVNode}var on=function(e){var t=e.key;return null!=t?t:null},an=function(e){var t=e.ref;return null!=t?A(t)||Ge(t)||P(t)?{i:Rt,r:t}:t:null},sn="production"!==process.env.NODE_ENV?function(){return cn.apply(void 0,arguments)}:cn;function cn(e){var t,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,a=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null,s=arguments.length>5&&void 0!==arguments[5]&&arguments[5];if(e&&e!==Gt||("production"===process.env.NODE_ENV||e||Qe("Invalid vnode type when creating vnode: ".concat(e,".")),e=Zt),rn(e)){var c=un(e,n,!0);return r&&dn(c,r),c}if(En(e)&&(e=e.__vccOpts),n){(Ke(n)||"__vInternal"in n)&&(n=$({},n));var u=n,l=u.class,f=u.style;l&&!A(l)&&(n.class=m(l)),T(f)&&(Ke(f)&&!R(f)&&(f=$({},f)),n.style=v(f))}var d=A(e)?1:It(e)?128:Jt(e)?64:T(e)?4:P(e)?2:0;"production"!==process.env.NODE_ENV&&4&d&&Ke(e)&&Qe("Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.","\nComponent that was made reactive: ",e=Je(e));var p=(i(t={__v_isVNode:!0},"__v_skip",!0),i(t,"type",e),i(t,"props",n),i(t,"key",n&&on(n)),i(t,"ref",n&&an(n)),i(t,"scopeId",Mt),i(t,"children",null),i(t,"component",null),i(t,"suspense",null),i(t,"ssContent",null),i(t,"ssFallback",null),i(t,"dirs",null),i(t,"transition",null),i(t,"el",null),i(t,"anchor",null),i(t,"target",null),i(t,"targetAnchor",null),i(t,"staticCount",0),i(t,"shapeFlag",d),i(t,"patchFlag",o),i(t,"dynamicProps",a),i(t,"dynamicChildren",null),i(t,"appContext",null),t);if("production"!==process.env.NODE_ENV&&p.key!=p.key&&Qe("VNode created with invalid key (NaN). VNode type:",p.type),dn(p,r),128&d){var h=Pt(p),y=h.content,g=h.fallback;p.ssContent=y,p.ssFallback=g}return!s&&en&&(o>0||6&d)&&32!==o&&en.push(p),p}function un(e,t){var n,r=arguments.length>2&&void 0!==arguments[2]&&arguments[2],o=e.props,a=e.ref,s=e.patchFlag,c=t?pn(o||{},t):o;return i(n={__v_isVNode:!0},"__v_skip",!0),i(n,"type",e.type),i(n,"props",c),i(n,"key",c&&on(c)),i(n,"ref",t&&t.ref?r&&a?R(a)?a.concat(an(t)):[a,an(t)]:an(t):a),i(n,"scopeId",e.scopeId),i(n,"children",e.children),i(n,"target",e.target),i(n,"targetAnchor",e.targetAnchor),i(n,"staticCount",e.staticCount),i(n,"shapeFlag",e.shapeFlag),i(n,"patchFlag",t&&e.type!==Xt?-1===s?16:16|s:s),i(n,"dynamicProps",e.dynamicProps),i(n,"dynamicChildren",e.dynamicChildren),i(n,"appContext",e.appContext),i(n,"dirs",e.dirs),i(n,"transition",e.transition),i(n,"component",e.component),i(n,"suspense",e.suspense),i(n,"ssContent",e.ssContent&&un(e.ssContent)),i(n,"ssFallback",e.ssFallback&&un(e.ssFallback)),i(n,"el",e.el),i(n,"anchor",e.anchor),n}function ln(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:" ",t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return sn(Yt,null,e,t)}function fn(e){return null==e||"boolean"==typeof e?sn(Zt):R(e)?sn(Xt,null,e):"object"===o(e)?null===e.el?e:un(e):sn(Yt,null,String(e))}function dn(e,t){var n=0,r=e.shapeFlag;if(null==t)t=null;else if(R(t))n=16;else if("object"===o(t)){if(1&r||64&r){var i=t.default;return void(i&&(i._c&&Tt(1),dn(e,i()),i._c&&Tt(-1)))}n=32;var a=t._;a||"__vInternal"in t?3===a&&Rt&&(1024&Rt.vnode.patchFlag?(t._=2,e.patchFlag|=1024):t._=1):t._ctx=Rt}else P(t)?(t={default:t,_ctx:Rt},n=32):(t=String(t),64&r?(n=16,t=[ln(t)]):n=8);e.children=t,e.shapeFlag|=n}function pn(){for(var e=$({},arguments.length<=0?void 0:arguments[0]),t=1;t1&&void 0!==arguments[1]?arguments[1]:gn;t&&(t.effects||(t.effects=[])).push(e)}var _n=/(?:^|[-_])(\w)/g,bn=function(e){return e.replace(_n,(function(e){return e.toUpperCase()})).replace(/[-_]/g,"")};function wn(e,t){var n=arguments.length>2&&void 0!==arguments[2]&&arguments[2],r=P(t)&&t.displayName||t.name;if(!r&&t.__file){var o=t.__file.match(/([^/\\]+)\.\w+$/);o&&(r=o[1])}if(!r&&e&&e.parent){var i=function(e){for(var n in e)if(e[n]===t)return n};r=i(e.components||e.parent.type.components)||i(e.appContext.components)}return r?bn(r):n?"App":"Anonymous"}function En(e){return P(e)&&"__vccOpts"in e}var Nn,Sn;Symbol("production"!==process.env.NODE_ENV?"ssrContext":"");function On(){if("production"!==process.env.NODE_ENV&&"undefined"!=typeof window){var e={style:"color:#3ba776"},t={style:"color:#0b1bc9"},n={style:"color:#b62e24"},r={style:"color:#9d288c"},o={header:function(t){return T(t)?t.__isVue?["div",e,"VueInstance"]:Ge(t)?["div",{},["span",e,l(t)],"<",a(t.value),">"]:We(t)?["div",{},["span",e,"Reactive"],"<",a(t),">".concat(qe(t)?" (readonly)":"")]:qe(t)?["div",{},["span",e,"Readonly"],"<",a(t),">"]:null:null},hasBody:function(e){return e&&e.__isVue},body:function(e){if(e&&e.__isVue)return["div",{}].concat(u(function(e){var t=[];e.type.props&&e.props&&t.push(i("props",Je(e.props)));e.setupState!==N&&t.push(i("setup",e.setupState));e.data!==N&&t.push(i("data",Je(e.data)));var n=s(e,"computed");n&&t.push(i("computed",n));var o=s(e,"inject");o&&t.push(i("injected",o));return t.push(["div",{},["span",{style:r.style+";opacity:0.66"},"$ (internal): "],["object",{object:e}]]),t}(e.$)))}};window.devtoolsFormatters?window.devtoolsFormatters.push(o):window.devtoolsFormatters=[o]}function i(e,t){return t=$({},t),Object.keys(t).length?["div",{style:"line-height:1.25em;margin-bottom:0.6em"},["div",{style:"color:#476582"},e],["div",{style:"padding-left:1.25em"}].concat(u(Object.keys(t).map((function(e){return["div",{},["span",r,e+": "],a(t[e],!1)]}))))]:["span",{}]}function a(e){var o=!(arguments.length>1&&void 0!==arguments[1])||arguments[1];return"number"==typeof e?["span",t,e]:"string"==typeof e?["span",n,JSON.stringify(e)]:"boolean"==typeof e?["span",r,e]:T(e)?["object",{object:o?Je(e):e}]:["span",n,String(e)]}function s(e,t){var n=e.type;if(!P(n)){var r={};for(var o in e.ctx)c(n,o,t)&&(r[o]=e.ctx[o]);return r}}function c(e,t,n){var r=e[n];return!!(R(r)&&r.includes(t)||T(r)&&t in r)||(!(!e.extends||!c(e.extends,t,n))||(!(!e.mixins||!e.mixins.some((function(e){return c(e,t,n)})))||void 0))}function l(e){return e._shallow?"ShallowRef":e.effect?"ComputedRef":"Ref"}}function Vn(){Vn.init||(Vn.init=!0,Sn=-1!==function(){var e=window.navigator.userAgent,t=e.indexOf("MSIE ");if(t>0)return parseInt(e.substring(t+5,e.indexOf(".",t)),10);if(e.indexOf("Trident/")>0){var n=e.indexOf("rv:");return parseInt(e.substring(n+3,e.indexOf(".",n)),10)}var r=e.indexOf("Edge/");return r>0?parseInt(e.substring(r+5,e.indexOf(".",r)),10):-1}())}"production"!==process.env.NODE_ENV&&((Nn=w||(w="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof window?window:"undefined"!=typeof global?global:{})).__VUE__=!0,Nn.__VUE_DEVTOOLS_GLOBAL_HOOK__,On());var kn={name:"ResizeObserver",mounted:function(){var e=this;Vn(),bt((function(){e._w=e.$el.offsetWidth,e._h=e.$el.offsetHeight}));var t=document.createElement("object");this._resizeObject=t,t.setAttribute("aria-hidden","true"),t.setAttribute("tabindex",-1),t.onload=this.addResizeHandlers,t.type="text/html",Sn&&this.$el.appendChild(t),t.data="about:blank",Sn||this.$el.appendChild(t)},beforeUnmount:function(){this.removeResizeHandlers()},methods:{compareAndNotify:function(){this._w===this.$el.offsetWidth&&this._h===this.$el.offsetHeight||(this._w=this.$el.offsetWidth,this._h=this.$el.offsetHeight,this.$emit("notify",{width:this._w,height:this._h}))},addResizeHandlers:function(){this._resizeObject.contentDocument.defaultView.addEventListener("resize",this.compareAndNotify),this.compareAndNotify()},removeResizeHandlers:function(){this._resizeObject&&this._resizeObject.onload&&(!Sn&&this._resizeObject.contentDocument&&this._resizeObject.contentDocument.defaultView.removeEventListener("resize",this.compareAndNotify),this.$el.removeChild(this._resizeObject),this._resizeObject.onload=null,this._resizeObject=null)}}},$n=Ht("data-v-b329ee4c");Ft("data-v-b329ee4c");var xn={class:"resize-observer",tabindex:"-1"};Lt();var Dn=$n((function(e,t,n,r,o,i){return tn(),function(e,t,n,r,o){var i=sn(e,t,n,r,o,!0);return i.dynamicChildren=en||S,nn(),en&&en.push(i),i}("div",xn)}));kn.render=Dn,kn.__scopeId="data-v-b329ee4c",kn.__file="src/components/ResizeObserver.vue";var zn,Rn={version:"0.5.0",install:function(e){e.component("resize-observer",kn),e.component("ResizeObserver",kn)}},Cn=null;function In(e){return(In="function"==typeof Symbol&&"symbol"===o(Symbol.iterator)?function(e){return o(e)}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":o(e)})(e)}function Pn(e,t){for(var n=0;n1&&(t[n[0].trim()]=n[1].trim())}})),t}function Bn(e){var t="";if(ar(e))t=e;else if(nr(e))for(var n=0;n-1&&e.splice(n,1)},er=Object.prototype.hasOwnProperty,tr=function(e,t){return er.call(e,t)},nr=Array.isArray,rr=function(e){return"[object Map]"===lr(e)},or=function(e){return"[object Set]"===lr(e)},ir=function(e){return"function"==typeof e},ar=function(e){return"string"==typeof e},sr=function(e){return"symbol"===o(e)},cr=function(e){return null!==e&&"object"===o(e)},ur=Object.prototype.toString,lr=function(e){return ur.call(e)},fr=function(e){return lr(e).slice(8,-1)},dr=function(e){return ar(e)&&"NaN"!==e&&"-"!==e[0]&&""+parseInt(e,10)===e},pr=function(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}},vr=/-(\w)/g,hr=pr((function(e){return e.replace(vr,(function(e,t){return t?t.toUpperCase():""}))})),yr=/\B([A-Z])/g,gr=pr((function(e){return e.replace(yr,"-$1").toLowerCase()})),mr=pr((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),_r=function(e,t){return e!==t&&(e==e||t==t)},br=new WeakMap,wr=[],Er=Symbol("production"!==process.env.NODE_ENV?"iterate":""),Nr=Symbol("production"!==process.env.NODE_ENV?"Map key iterate":"");function Sr(e){return e&&!0===e._isEffect}function Or(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Kn;Sr(e)&&(e=e.raw);var n=$r(e,t);return t.lazy||n(),n}function Vr(e){e.active&&(xr(e),e.options.onStop&&e.options.onStop(),e.active=!1)}var kr=0;function $r(e,t){var n=function(){if(!n.active)return t.scheduler?void 0:e();if(!wr.includes(n)){xr(n);try{return zr.push(Dr),Dr=!0,wr.push(n),qn=n,e()}finally{wr.pop(),Cr(),qn=wr[wr.length-1]}}};return n.id=kr++,n.allowRecurse=!!t.allowRecurse,n._isEffect=!0,n.active=!0,n.raw=e,n.deps=[],n.options=t,n}function xr(e){var t=e.deps;if(t.length){for(var n=0;n=r)&&c(e)}));else switch(void 0!==n&&c(a.get(n)),t){case"add":nr(e)?dr(n)&&c(a.get("length")):(c(a.get(Er)),rr(e)&&c(a.get(Nr)));break;case"delete":nr(e)||(c(a.get(Er)),rr(e)&&c(a.get(Nr)));break;case"set":rr(e)&&c(a.get(Er))}s.forEach((function(a){"production"!==process.env.NODE_ENV&&a.options.onTrigger&&a.options.onTrigger({effect:a,target:e,key:n,type:t,newValue:r,oldValue:o,oldTarget:i}),a.options.scheduler?a.options.scheduler(a):a()}))}}var Ar=new Set(Object.getOwnPropertyNames(Symbol).map((function(e){return Symbol[e]})).filter(sr)),jr=Lr(),Tr=Lr(!1,!0),Mr=Lr(!0),Ur=Lr(!0,!0),Fr={};function Lr(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0],t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return function(n,r,o){if("__v_isReactive"===r)return!e;if("__v_isReadonly"===r)return e;if("__v_raw"===r&&o===(e?yo:ho).get(n))return n;var i=nr(n);if(!e&&i&&tr(Fr,r))return Reflect.get(Fr,r,o);var a=Reflect.get(n,r,o);return(sr(r)?Ar.has(r):"__proto__"===r||"__v_isRef"===r)?a:(e||Ir(n,"get",r),t?a:Oo(a)?!i||!dr(r)?a.value:a:cr(a)?e?mo(a):go(a):a)}}function Hr(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0];return function(t,n,r,o){var i=t[n];if(!e&&(r=So(r),!nr(t)&&Oo(i)&&!Oo(r)))return i.value=r,!0;var a=nr(t)&&dr(n)?Number(n)2&&void 0!==arguments[2]&&arguments[2],r=arguments.length>3&&void 0!==arguments[3]&&arguments[3],o=So(e=e.__v_raw),i=So(t);t!==i&&!n&&Ir(o,"get",t),!n&&Ir(o,"get",i);var a=Xr(o),s=a.has,c=n?Jr:r?Gr:Kr;return s.call(o,t)?c(e.get(t)):s.call(o,i)?c(e.get(i)):void 0}function Zr(e){var t=arguments.length>1&&void 0!==arguments[1]&&arguments[1],n=this.__v_raw,r=So(n),o=So(e);return e!==o&&!t&&Ir(r,"has",e),!t&&Ir(r,"has",o),e===o?n.has(e):n.has(e)||n.has(o)}function Qr(e){var t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return e=e.__v_raw,!t&&Ir(So(e),"iterate",Er),Reflect.get(e,"size",e)}function eo(e){e=So(e);var t=So(this),n=Xr(t).has.call(t,e);return t.add(e),n||Pr(t,"add",e,e),this}function to(e,t){t=So(t);var n=So(this),r=Xr(n),o=r.has,i=r.get,a=o.call(n,e);a?"production"!==process.env.NODE_ENV&&vo(n,o,e):(e=So(e),a=o.call(n,e));var s=i.call(n,e);return n.set(e,t),a?_r(t,s)&&Pr(n,"set",e,t,s):Pr(n,"add",e,t),this}function no(e){var t=So(this),n=Xr(t),r=n.has,o=n.get,i=r.call(t,e);i?"production"!==process.env.NODE_ENV&&vo(t,r,e):(e=So(e),i=r.call(t,e));var a=o?o.call(t,e):void 0,s=t.delete(e);return i&&Pr(t,"delete",e,void 0,a),s}function ro(){var e=So(this),t=0!==e.size,n="production"!==process.env.NODE_ENV?rr(e)?new Map(e):new Set(e):void 0,r=e.clear();return t&&Pr(e,"clear",void 0,void 0,n),r}function oo(e,t){return function(n,r){var o=this,i=o.__v_raw,a=So(i),s=e?Jr:t?Gr:Kr;return!e&&Ir(a,"iterate",Er),i.forEach((function(e,t){return n.call(r,s(e),s(t),o)}))}}function io(e,t,n){return function(){var r=this.__v_raw,o=So(r),a=rr(o),s="entries"===e||e===Symbol.iterator&&a,c="keys"===e&&a,u=r[e].apply(r,arguments),l=t?Jr:n?Gr:Kr;return!t&&Ir(o,"iterate",c?Nr:Er),i({next:function(){var e=u.next(),t=e.value,n=e.done;return n?{value:t,done:n}:{value:s?[l(t[0]),l(t[1])]:l(t),done:n}}},Symbol.iterator,(function(){return this}))}}function ao(e){return function(){if("production"!==process.env.NODE_ENV){var t=(arguments.length<=0?void 0:arguments[0])?'on key "'.concat(arguments.length<=0?void 0:arguments[0],'" '):"";console.warn("".concat(mr(e)," operation ").concat(t,"failed: target is readonly."),So(this))}return"delete"!==e&&this}}var so={get:function(e){return Yr(this,e)},get size(){return Qr(this)},has:Zr,add:eo,set:to,delete:no,clear:ro,forEach:oo(!1,!1)},co={get:function(e){return Yr(this,e,!1,!0)},get size(){return Qr(this)},has:Zr,add:eo,set:to,delete:no,clear:ro,forEach:oo(!1,!0)},uo={get:function(e){return Yr(this,e,!0)},get size(){return Qr(this,!0)},has:function(e){return Zr.call(this,e,!0)},add:ao("add"),set:ao("set"),delete:ao("delete"),clear:ao("clear"),forEach:oo(!0,!1)};function lo(e,t){var n=t?co:e?uo:so;return function(t,r,o){return"__v_isReactive"===r?!e:"__v_isReadonly"===r?e:"__v_raw"===r?t:Reflect.get(tr(n,r)&&r in t?n:t,r,o)}}["keys","values","entries",Symbol.iterator].forEach((function(e){so[e]=io(e,!1,!1),uo[e]=io(e,!0,!1),co[e]=io(e,!1,!0)}));var fo={get:lo(!1,!1)},po={get:lo(!0,!1)};function vo(e,t,n){var r=So(n);if(r!==n&&t.call(e,r)){var o=fr(e);console.warn("Reactive ".concat(o," contains both the raw and reactive ")+"versions of the same object".concat("Map"===o?" 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.")}}var ho=new WeakMap,yo=new WeakMap;function go(e){return e&&e.__v_isReadonly?e:bo(e,!1,Br,fo)}function mo(e){return bo(e,!0,Wr,po)}function _o(e){return bo(e,!0,qr,po)}function bo(e,t,n,r){if(!cr(e))return"production"!==process.env.NODE_ENV&&console.warn("value cannot be made reactive: ".concat(String(e))),e;if(e.__v_raw&&(!t||!e.__v_isReactive))return e;var o=t?yo:ho,i=o.get(e);if(i)return i;var a,s=(a=e).__v_skip||!Object.isExtensible(a)?0:function(e){switch(e){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}(fr(a));if(0===s)return e;var c=new Proxy(e,2===s?r:n);return o.set(e,c),c}function wo(e){return Eo(e)?wo(e.__v_raw):!(!e||!e.__v_isReactive)}function Eo(e){return!(!e||!e.__v_isReadonly)}function No(e){return wo(e)||Eo(e)}function So(e){return e&&So(e.__v_raw)||e}function Oo(e){return Boolean(e&&!0===e.__v_isRef)}var Vo=[];function ko(e){Vo.push(e)}function $o(){Vo.pop()}function xo(e){Rr();for(var t=Vo.length?Vo[Vo.length-1].component:null,n=t&&t.appContext.config.warnHandler,r=Do(),o=arguments.length,i=new Array(o>1?o-1:0),a=1;a")})).join("\n"),r]);else{var s,c=["[Vue warn]: ".concat(e)].concat(i);r.length&&c.push.apply(c,["\n"].concat(u(zo(r)))),(s=console).warn.apply(s,u(c))}Cr()}function Do(){var e=Vo[Vo.length-1];if(!e)return[];for(var t=[];e;){var n=t[0];n&&n.vnode===e?n.recurseCount++:t.push({vnode:e,recurseCount:0});var r=e.component&&e.component.parent;e=r&&r.vnode}return t}function zo(e){var t=[];return e.forEach((function(e,n){var r,o,i,a,s,c,l;t.push.apply(t,u(0===n?[]:["\n"]).concat(u((o=(r=e).vnode,i=r.recurseCount,a=i>0?"... (".concat(i," recursive calls)"):"",s=!!o.component&&null==o.component.parent,c=" at <".concat(Mi(o.component,o.type,s)),l=">"+a,o.props?[c].concat(u(function(e){var t=[],n=Object.keys(e);return n.slice(0,3).forEach((function(n){t.push.apply(t,u(function e(t,n,r){return ar(n)?(n=JSON.stringify(n),r?n:["".concat(t,"=").concat(n)]):"number"==typeof n||"boolean"==typeof n||null==n?r?n:["".concat(t,"=").concat(n)]:Oo(n)?(n=e(t,So(n.value),!0),r?n:["".concat(t,"=Ref<"),n,">"]):ir(n)?["".concat(t,"=fn").concat(n.name?"<".concat(n.name,">"):"")]:(n=So(n),r?n:["".concat(t,"="),n])}(n,e[n])))})),n.length>3&&t.push(" ..."),t}(o.props)),[l]):[c+l]))))})),t}var Ro=(i(zn={},"bc","beforeCreate hook"),i(zn,"c","created hook"),i(zn,"bm","beforeMount hook"),i(zn,"m","mounted hook"),i(zn,"bu","beforeUpdate hook"),i(zn,"u","updated"),i(zn,"bum","beforeUnmount hook"),i(zn,"um","unmounted hook"),i(zn,"a","activated hook"),i(zn,"da","deactivated hook"),i(zn,"ec","errorCaptured hook"),i(zn,"rtc","renderTracked hook"),i(zn,"rtg","renderTriggered hook"),i(zn,0,"setup function"),i(zn,1,"render function"),i(zn,2,"watcher getter"),i(zn,3,"watcher callback"),i(zn,4,"watcher cleanup function"),i(zn,5,"native event handler"),i(zn,6,"component event handler"),i(zn,7,"vnode hook"),i(zn,8,"directive hook"),i(zn,9,"transition hook"),i(zn,10,"app errorHandler"),i(zn,11,"app warnHandler"),i(zn,12,"ref function"),i(zn,13,"async component loader"),i(zn,14,"scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next"),zn);function Co(e,t,n,r){var o;try{o=r?e.apply(void 0,u(r)):e()}catch(e){Po(e,t,n)}return o}function Io(e,t,n,r){if(ir(e)){var o=Co(e,t,n,r);return o&&(cr(i=o)&&ir(i.then)&&ir(i.catch))&&o.catch((function(e){Po(e,t,n)})),o}for(var i,a=[],s=0;s3&&void 0!==arguments[3])||arguments[3],o=t?t.vnode:null;if(t){for(var i=t.parent,a=t.proxy,s="production"!==process.env.NODE_ENV?Ro[n]:n;i;){var c=i.ec;if(c)for(var u=0;u3&&void 0!==arguments[3])||arguments[3];if("production"!==process.env.NODE_ENV){var o=Ro[t];if(n&&ko(n),xo("Unhandled error".concat(o?" during execution of ".concat(o):"")),n&&$o(),r)throw e;console.error(e)}else console.error(e)}var jo=!1,To=!1,Mo=[],Uo=0,Fo=[],Lo=null,Ho=0,Bo=[],Wo=null,qo=0,Ko=Promise.resolve(),Jo=null,Go=null;function Xo(e){var t=Jo||Ko;return e?t.then(this?e.bind(this):e):t}function Yo(e){Mo.length&&Mo.includes(e,jo&&e.allowRecurse?Uo+1:Uo)||e===Go||(Mo.push(e),Zo())}function Zo(){jo||To||(To=!0,Jo=Ko.then(ri))}function Qo(e,t,n,r){nr(e)?n.push.apply(n,u(e)):t&&t.includes(e,e.allowRecurse?r+1:r)||n.push(e),Zo()}function ei(e){Qo(e,Lo,Fo,Ho)}function ti(e){Qo(e,Wo,Bo,qo)}var ni=function(e){return null==e.id?1/0:e.id};function ri(e){To=!1,jo=!0,"production"!==process.env.NODE_ENV&&(e=e||new Map),function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(Fo.length){for(Go=n,Lo=u(new Set(Fo)),Fo.length=0,"production"!==process.env.NODE_ENV&&(t=t||new Map),Ho=0;Ho100)throw new Error("Maximum recursive updates exceeded. 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.");e.set(t,n+1)}else e.set(t,1)}var ii=new Set;"production"!==process.env.NODE_ENV&&(("undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{}).__VUE_HMR_RUNTIME__={createRecord:si((function(e,t){t||(xo("HMR API usage is out of date.\nPlease upgrade vue-loader/vite/rollup-plugin-vue or other relevant depdendency that handles Vue SFC compilation."),t={});if(ai.has(e))return!1;return ai.set(e,{component:Ui(t)?t.__vccOpts:t,instances:new Set}),!0})),rerender:si((function(e,t){var n=ai.get(e);if(!n)return;t&&(n.component.render=t);Array.from(n.instances).forEach((function(e){t&&(e.render=t),e.renderCache=[],e.update()}))})),reload:si((function(e,t){var n=ai.get(e);if(!n)return;var r=n.component,o=n.instances;if(!ii.has(r)){for(var i in t=Ui(t)?t.__vccOpts:t,Zn(r,t),r)i in t||delete r[i];ii.add(r),ti((function(){ii.delete(r)}))}Array.from(o).forEach((function(e){e.parent?Yo(e.parent.update):e.appContext.reload?e.appContext.reload():"undefined"!=typeof window?window.location.reload():console.warn("[HMR] Root or manually mounted instance modified. Full reload required.")}))}))});var ai=new Map;function si(e){return function(t,n){try{return e(t,n)}catch(e){console.error(e),console.warn("[HMR] Something went wrong during Vue component hot-reload. Full reload required.")}}}var ci=function(e){return e.__isSuspense};function ui(e){var t,n,r=e.shapeFlag,o=e.children;return 32&r?(t=li(o.default),n=li(o.fallback)):(t=li(o),n=xi(null)),{content:t,fallback:n}}function li(e){if(ir(e)&&(e=e()),nr(e)){var t=function(e){for(var t,n=0;n slots expect a single root node."),e=t}return xi(e)}var fi=0,di=function(e){return fi+=e},pi={};function vi(e,t,n){var r=this.proxy;return function(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:Kn,r=n.immediate,o=n.deep,i=n.flush,a=n.onTrack,s=n.onTrigger,c=arguments.length>3&&void 0!==arguments[3]?arguments[3]:Pi;"production"===process.env.NODE_ENV||t||(void 0!==r&&xo('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'),void 0!==o&&xo('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'));var u,l,f=function(e){xo("Invalid watch source: ",e,"A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.")},d=!1;if(Oo(e)?(u=function(){return e.value},d=!!e._shallow):wo(e)?(u=function(){return e},o=!0):nr(e)?u=function(){return e.map((function(e){return Oo(e)?e.value:wo(e)?hi(e):ir(e)?Co(e,c,2):void("production"!==process.env.NODE_ENV&&f(e))}))}:ir(e)?u=t?function(){return Co(e,c,2)}:function(){if(!c||!c.isUnmounted)return l&&l(),Co(e,c,3,[v])}:(u=Jn,"production"!==process.env.NODE_ENV&&f(e)),t&&o){var p=u;u=function(){return hi(p())}}var v=function(e){l=g.options.onStop=function(){Co(e,c,4)}},h=nr(e)?[]:pi,y=function(){if(g.active)if(t){var e=g();(o||d||_r(e,h))&&(l&&l(),Io(t,c,3,[e,h===pi?void 0:h,v]),h=e)}else g()};y.allowRecurse=!!t;var g=Or(u,{lazy:!0,onTrack:a,onTrigger:s,scheduler:"sync"===i?y:"post"===i?function(){return yi(y,c&&c.suspense)}:function(){!c||c.isMounted?ei(y):y()}});return Ai(g,c),t?r?y():h=g():"post"===i?yi(g,c&&c.suspense):g(),function(){Vr(g),c&&Qn(c.effects,g)}}(ar(e)?function(){return r[e]}:e.bind(r),t.bind(r),n,this)}function hi(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:new Set;if(!cr(e)||t.has(e))return e;if(t.add(e),Oo(e))hi(e.value,t);else if(nr(e))for(var n=0;n1&&void 0!==arguments[1]?arguments[1]:null,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,a=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null;arguments.length>5&&void 0!==arguments[5]&&arguments[5];if(e&&e!==mi||("production"===process.env.NODE_ENV||e||xo("Invalid vnode type when creating vnode: ".concat(e,".")),e=wi),Ei(e)){var s=ki(e,n,!0);return r&&Di(s,r),s}if(Ui(e)&&(e=e.__vccOpts),n){(No(n)||"__vInternal"in n)&&(n=Zn({},n));var c=n,u=c.class,l=c.style;u&&!ar(u)&&(n.class=Bn(u)),cr(l)&&(No(l)&&!nr(l)&&(l=Zn({},l)),n.style=Un(l))}var f=ar(e)?1:ci(e)?128:gi(e)?64:cr(e)?4:ir(e)?2:0;"production"!==process.env.NODE_ENV&&4&f&&No(e)&&xo("Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.","\nComponent that was made reactive: ",e=So(e));var d=(i(t={__v_isVNode:!0},"__v_skip",!0),i(t,"type",e),i(t,"props",n),i(t,"key",n&&Ni(n)),i(t,"ref",n&&Si(n)),i(t,"scopeId",null),i(t,"children",null),i(t,"component",null),i(t,"suspense",null),i(t,"ssContent",null),i(t,"ssFallback",null),i(t,"dirs",null),i(t,"transition",null),i(t,"el",null),i(t,"anchor",null),i(t,"target",null),i(t,"targetAnchor",null),i(t,"staticCount",0),i(t,"shapeFlag",f),i(t,"patchFlag",o),i(t,"dynamicProps",a),i(t,"dynamicChildren",null),i(t,"appContext",null),t);if("production"!==process.env.NODE_ENV&&d.key!=d.key&&xo("VNode created with invalid key (NaN). VNode type:",d.type),Di(d,r),128&f){var p=ui(d),v=p.content,h=p.fallback;d.ssContent=v,d.ssFallback=h}return d}function ki(e,t){var n,r=arguments.length>2&&void 0!==arguments[2]&&arguments[2],o=e.props,a=e.ref,s=e.patchFlag,c=t?zi(o||{},t):o;return i(n={__v_isVNode:!0},"__v_skip",!0),i(n,"type",e.type),i(n,"props",c),i(n,"key",c&&Ni(c)),i(n,"ref",t&&t.ref?r&&a?nr(a)?a.concat(Si(t)):[a,Si(t)]:Si(t):a),i(n,"scopeId",e.scopeId),i(n,"children",e.children),i(n,"target",e.target),i(n,"targetAnchor",e.targetAnchor),i(n,"staticCount",e.staticCount),i(n,"shapeFlag",e.shapeFlag),i(n,"patchFlag",t&&e.type!==_i?-1===s?16:16|s:s),i(n,"dynamicProps",e.dynamicProps),i(n,"dynamicChildren",e.dynamicChildren),i(n,"appContext",e.appContext),i(n,"dirs",e.dirs),i(n,"transition",e.transition),i(n,"component",e.component),i(n,"suspense",e.suspense),i(n,"ssContent",e.ssContent&&ki(e.ssContent)),i(n,"ssFallback",e.ssFallback&&ki(e.ssFallback)),i(n,"el",e.el),i(n,"anchor",e.anchor),n}function $i(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:" ",t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return Oi(bi,null,e,t)}function xi(e){return null==e||"boolean"==typeof e?Oi(wi):nr(e)?Oi(_i,null,e):"object"===o(e)?null===e.el?e:ki(e):Oi(bi,null,String(e))}function Di(e,t){var n=0,r=e.shapeFlag;if(null==t)t=null;else if(nr(t))n=16;else if("object"===o(t)){if(1&r||64&r){var i=t.default;return void(i&&(i._c&&di(1),Di(e,i()),i._c&&di(-1)))}n=32;var a=t._;a||"__vInternal"in t||(t._ctx=null)}else ir(t)?(t={default:t,_ctx:null},n=32):(t=String(t),64&r?(n=16,t=[$i(t)]):n=8);e.children=t,e.shapeFlag|=n}function zi(){for(var e=Zn({},arguments.length<=0?void 0:arguments[0]),t=1;t1&&void 0!==arguments[1]?arguments[1]:Pi;t&&(t.effects||(t.effects=[])).push(e)}var ji=/(?:^|[-_])(\w)/g,Ti=function(e){return e.replace(ji,(function(e){return e.toUpperCase()})).replace(/[-_]/g,"")};function Mi(e,t){var n=arguments.length>2&&void 0!==arguments[2]&&arguments[2],r=ir(t)&&t.displayName||t.name;if(!r&&t.__file){var o=t.__file.match(/([^/\\]+)\.\w+$/);o&&(r=o[1])}if(!r&&e&&e.parent){var i=function(e){for(var n in e)if(e[n]===t)return n};r=i(e.components||e.parent.type.components)||i(e.appContext.components)}return r?Ti(r):n?"App":"Anonymous"}function Ui(e){return ir(e)&&"__vccOpts"in e}Symbol("production"!==process.env.NODE_ENV?"ssrContext":"");function Fi(){if("production"!==process.env.NODE_ENV&&"undefined"!=typeof window){var e={style:"color:#3ba776"},t={style:"color:#0b1bc9"},n={style:"color:#b62e24"},r={style:"color:#9d288c"},o={header:function(t){return cr(t)?t.__isVue?["div",e,"VueInstance"]:Oo(t)?["div",{},["span",e,l(t)],"<",a(t.value),">"]:wo(t)?["div",{},["span",e,"Reactive"],"<",a(t),">".concat(Eo(t)?" (readonly)":"")]:Eo(t)?["div",{},["span",e,"Readonly"],"<",a(t),">"]:null:null},hasBody:function(e){return e&&e.__isVue},body:function(e){if(e&&e.__isVue)return["div",{}].concat(u(function(e){var t=[];e.type.props&&e.props&&t.push(i("props",So(e.props)));e.setupState!==Kn&&t.push(i("setup",e.setupState));e.data!==Kn&&t.push(i("data",So(e.data)));var n=s(e,"computed");n&&t.push(i("computed",n));var o=s(e,"inject");o&&t.push(i("injected",o));return t.push(["div",{},["span",{style:r.style+";opacity:0.66"},"$ (internal): "],["object",{object:e}]]),t}(e.$)))}};window.devtoolsFormatters?window.devtoolsFormatters.push(o):window.devtoolsFormatters=[o]}function i(e,t){return t=Zn({},t),Object.keys(t).length?["div",{style:"line-height:1.25em;margin-bottom:0.6em"},["div",{style:"color:#476582"},e],["div",{style:"padding-left:1.25em"}].concat(u(Object.keys(t).map((function(e){return["div",{},["span",r,e+": "],a(t[e],!1)]}))))]:["span",{}]}function a(e){var o=!(arguments.length>1&&void 0!==arguments[1])||arguments[1];return"number"==typeof e?["span",t,e]:"string"==typeof e?["span",n,JSON.stringify(e)]:"boolean"==typeof e?["span",r,e]:cr(e)?["object",{object:o?So(e):e}]:["span",n,String(e)]}function s(e,t){var n=e.type;if(!ir(n)){var r={};for(var o in e.ctx)c(n,o,t)&&(r[o]=e.ctx[o]);return r}}function c(e,t,n){var r=e[n];return!!(nr(r)&&r.includes(t)||cr(r)&&t in r)||(!(!e.extends||!c(e.extends,t,n))||(!(!e.mixins||!e.mixins.some((function(e){return c(e,t,n)})))||void 0))}function l(e){return e._shallow?"ShallowRef":e.effect?"ComputedRef":"Ref"}}var Li,Hi,Bi="http://www.w3.org/2000/svg",Wi="undefined"!=typeof document?document:null,qi={insert:function(e,t,n){t.insertBefore(e,n||null)},remove:function(e){var t=e.parentNode;t&&t.removeChild(e)},createElement:function(e,t,n){return t?Wi.createElementNS(Bi,e):Wi.createElement(e,n?{is:n}:void 0)},createText:function(e){return Wi.createTextNode(e)},createComment:function(e){return Wi.createComment(e)},setText:function(e,t){e.nodeValue=t},setElementText:function(e,t){e.textContent=t},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},querySelector:function(e){return Wi.querySelector(e)},setScopeId:function(e,t){e.setAttribute(t,"")},cloneNode:function(e){return e.cloneNode(!0)},insertStaticContent:function(e,t,n,r){var o=r?Hi||(Hi=Wi.createElementNS(Bi,"svg")):Li||(Li=Wi.createElement("div"));o.innerHTML=e;for(var i=o.firstChild,a=i,s=a;a;)s=a,qi.insert(a,t,n),a=o.firstChild;return[i,s]}};function Ki(e,t,n){if(null==t&&(t=""),n)e.setAttribute("class",t);else{var r=e._vtc;r&&(t=(t?[t].concat(u(r)):u(r)).join(" ")),e.className=t}}function Ji(e,t,n){var r=e.style;if(n)if(ar(n))t!==n&&(r.cssText=n);else{for(var o in n)Xi(r,o,n[o]);if(t&&!ar(t))for(var i in t)null==n[i]&&Xi(r,i,"")}else e.removeAttribute("style")}var Gi=/\s*!important$/;function Xi(e,t,n){if(nr(n))n.forEach((function(n){return Xi(e,t,n)}));else if(t.startsWith("--"))e.setProperty(t,n);else{var r=function(e,t){var n=Zi[t];if(n)return n;var r=hr(t);if("filter"!==r&&r in e)return Zi[t]=r;r=mr(r);for(var o=0;o: ")+"value ".concat(n," is invalid."),r)}}else{e._value=n;var u=null==n?"":n;e.value!==u&&(e.value=u)}}var na=Date.now;"undefined"!=typeof document&&na()>document.createEvent("Event").timeStamp&&(na=function(){return performance.now()});var ra=0,oa=Promise.resolve(),ia=function(){ra=0};function aa(e,t,n,r){e.addEventListener(t,n,r)}function sa(e,t,n,r){e.removeEventListener(t,n,r)}function ca(e,t,n,r){var o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null,i=e._vei||(e._vei={}),a=i[t];if(r&&a)a.value=r;else{var s=la(t),u=c(s,2),l=u[0],f=u[1];if(r){var d=i[t]=fa(r,o);aa(e,l,d,f)}else a&&(sa(e,l,a,f),i[t]=void 0)}}var ua=/(?:Once|Passive|Capture)$/;function la(e){var t,n;if(ua.test(e))for(t={};n=e.match(ua);)e=e.slice(0,e.length-n[0].length),t[n[0].toLowerCase()]=!0;return[e.slice(2).toLowerCase(),t]}function fa(e,t){var n=function e(n){(n.timeStamp||na())>=e.attached-1&&Io(function(e,t){if(nr(t)){var n=e.stopImmediatePropagation;return e.stopImmediatePropagation=function(){n.call(e),e._stopped=!0},t.map((function(e){return function(t){return!t._stopped&&e(t)}}))}return t}(n,e.value),t,5,[n])};return n.value=e,n.attached=ra||(oa.then(ia),ra=na()),n}var da=/^on[a-z]/;function pa(e,t,n,r){return r?"innerHTML"===t||!!(t in e&&da.test(t)&&ir(n)):"spellcheck"!==t&&"draggable"!==t&&(("form"!==t||"string"!=typeof n)&&(("list"!==t||"INPUT"!==e.tagName)&&((!da.test(t)||!ar(n))&&t in e)))}Zn({patchProp:function(e,t,n,r){var o=arguments.length>4&&void 0!==arguments[4]&&arguments[4],i=arguments.length>5?arguments[5]:void 0,a=arguments.length>6?arguments[6]:void 0,s=arguments.length>7?arguments[7]:void 0,c=arguments.length>8?arguments[8]:void 0;switch(t){case"class":Ki(e,r,o);break;case"style":Ji(e,n,r);break;default:Xn(t)?Yn(t)||ca(e,t,n,r,a):pa(e,t,r,o)?ta(e,t,r,i,a,s,c):("true-value"===t?e._trueValue=r:"false-value"===t&&(e._falseValue=r),ea(e,t,r,o))}},forcePatchProp:function(e,t){return"value"===t}},qi);"production"!==process.env.NODE_ENV&&function(){var e=Wn||(Wn="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof window?window:"undefined"!=typeof global?global:{});e.__VUE__=!0,e.__VUE_DEVTOOLS_GLOBAL_HOOK__,Fi()}();var va=function(){function e(t,n,r){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),this.el=t,this.observer=null,this.frozen=!1,this.createObserver(n,r)}var t,n,r;return t=e,(n=[{key:"createObserver",value:function(e,t){var n=this;if(this.observer&&this.destroyObserver(),!this.frozen){var r;if(this.options="function"==typeof(r=e)?{callback:r}:r,this.callback=function(e,t){n.options.callback(e,t),e&&n.options.once&&(n.frozen=!0,n.destroyObserver())},this.callback&&this.options.throttle){var o=(this.options.throttleOptions||{}).leading;this.callback=function(e,t){var n,r,o,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},a=function(a){for(var s=arguments.length,c=new Array(s>1?s-1:0),u=1;u1){var r=e.find((function(e){return e.isIntersecting}));r&&(t=r)}if(n.callback){var o=t.isIntersecting&&t.intersectionRatio>=n.threshold;if(o===n.oldResult)return;n.oldResult=o,n.callback(o,t)}}),this.options.intersection),Xo((function(){n.observer&&n.observer.observe(n.el)}))}}},{key:"destroyObserver",value:function(){this.observer&&(this.observer.disconnect(),this.observer=null),this.callback&&this.callback._clear&&(this.callback._clear(),this.callback=null)}},{key:"threshold",get:function(){return this.options.intersection&&this.options.intersection.threshold||0}}])&&Pn(t.prototype,n),r&&Pn(t,r),e}();function ha(e,t,n){var r=t.value;if(r)if("undefined"==typeof IntersectionObserver)console.warn("[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill");else{var o=new va(e,r,n);e._vue_visibilityState=o}}function ya(e){var t=e._vue_visibilityState;t&&(t.destroyObserver(),delete e._vue_visibilityState)}var ga={beforeMount:ha,updated:function(e,t,n){var r=t.value;if(!function e(t,n){if(t===n)return!0;if("object"===In(t)){for(var r in t)if(!e(t[r],n[r]))return!1;return!0}return!1}(r,t.oldValue)){var o=e._vue_visibilityState;r?o?o.createObserver(r,n):ha(e,{value:r},n):ya(e)}},unmounted:ya};var ma={version:"0.4.6",install:function(e){e.directive("observe-visibility",ga)}},_a=null;"undefined"!=typeof window?_a=window.Vue:"undefined"!=typeof global&&(_a=global.Vue),_a&&_a.use(ma);var ba="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};var wa=function(e,t){return e(t={exports:{}},t.exports),t.exports}((function(e){var t,n;t=ba,n=function(){var e=/(auto|scroll)/,t=function(e,n){return null===e.parentNode?n:t(e.parentNode,n.concat([e]))},n=function(e,t){return getComputedStyle(e,null).getPropertyValue(t)},r=function(t){return e.test(function(e){return n(e,"overflow")+n(e,"overflow-y")+n(e,"overflow-x")}(t))};return function(e){if(e instanceof HTMLElement||e instanceof SVGElement){for(var n=t(e.parentNode,[]),o=0;o1&&void 0!==arguments[1]&&arguments[1],n=this.$_unusedViews,r=e.nr.type,o=n.get(r);o||(o=[],n.set(r,o)),o.push(e),t||(e.nr.used=!1,e.position=-9999,this.$_views.delete(e.nr.key))},handleResize:function(){this.$emit("resize"),this.ready&&this.updateVisibleItems(!1)},handleScroll:function(e){var t=this;this.$_scrollDirty||(this.$_scrollDirty=!0,requestAnimationFrame((function(){t.$_scrollDirty=!1,t.updateVisibleItems(!1,!0).continuous||(clearTimeout(t.$_refreshTimout),t.$_refreshTimout=setTimeout(t.handleScroll,100))})))},handleVisibilityChange:function(e,t){var n=this;this.ready&&(e||0!==t.boundingClientRect.width||0!==t.boundingClientRect.height?(this.$emit("visible"),requestAnimationFrame((function(){n.updateVisibleItems(!1)}))):this.$emit("hidden"))},updateVisibleItems:function(e){var t,n,o,i,a=arguments.length>1&&void 0!==arguments[1]&&arguments[1],s=this.itemSize,c=this.$_computedMinItemSize,u=this.typeField,l=this.simpleArray?null:this.keyField,f=this.items,d=f.length,p=this.sizes,v=this.$_views,h=this.$_unusedViews,y=this.pool;if(d)if(this.$_prerender)t=0,n=this.prerender,o=null;else{var g=this.getScroll();if(a){var m=g.start-this.$_lastUpdateScrollPosition;if(m<0&&(m=-m),null===s&&mg.start&&(E=N),N=~~((w+E)/2)}while(N!==b);for(N<0&&(N=0),t=N,o=p[d-1].accumulator,n=N;nd&&(n=d)}else(t=~~(g.start/s))<0&&(t=0),(n=Math.ceil(g.end/s))>d&&(n=d),o=d*s}else t=n=o=0;n-t>r.itemsLimit&&this.itemsLimitError(),this.totalSize=o;var S=t<=this.$_endIndex&&n>=this.$_startIndex;if(this.$_continuous!==S){if(S){v.clear(),h.clear();for(var O=0,V=y.length;O=n)&&this.unuseView(i));for(var x,D,z,R,C=S?null:new Map,I=t;I=z.length)&&(i=this.addView(y,I,x,P,D),this.unuseView(i,!0),z=h.get(D)),(i=z[R]).item=x,i.nr.used=!0,i.nr.index=I,i.nr.key=P,i.nr.type=D,C.set(D,R+1),R++),v.set(P,i)),i.position=null===s?p[I-1].accumulator:I*s):i&&this.unuseView(i)}return this.$_startIndex=t,this.$_endIndex=n,this.emitUpdate&&this.$emit("update",t,n),clearTimeout(this.$_sortTimer),this.$_sortTimer=setTimeout(this.sortViews,300),{continuous:S}},getListenerTarget:function(){var e=wa(this.$el);return!window.document||e!==window.document.documentElement&&e!==window.document.body||(e=window),e},getScroll:function(){var e,t=this.$el,n="vertical"===this.direction;if(this.pageMode){var r=t.getBoundingClientRect(),o=n?r.height:r.width,i=-(n?r.top:r.left),a=n?window.innerHeight:window.innerWidth;i<0&&(a+=i,i=0),i+a>o&&(a=o-i),e={start:i,end:i+a}}else e=n?{start:t.scrollTop,end:t.scrollTop+t.clientHeight}:{start:t.scrollLeft,end:t.scrollLeft+t.clientWidth};return e},applyPageMode:function(){this.pageMode?this.addListeners():this.removeListeners()},addListeners:function(){this.listenerTarget=this.getListenerTarget(),this.listenerTarget.addEventListener("scroll",this.handleScroll,!!Sa&&{passive:!0}),this.listenerTarget.addEventListener("resize",this.handleResize)},removeListeners:function(){this.listenerTarget&&(this.listenerTarget.removeEventListener("scroll",this.handleScroll),this.listenerTarget.removeEventListener("resize",this.handleResize),this.listenerTarget=null)},scrollToItem:function(e){var t;t=null===this.itemSize?e>0?this.sizes[e-1].accumulator:0:e*this.itemSize,this.scrollToPosition(t)},scrollToPosition:function(e){"vertical"===this.direction?this.$el.scrollTop=e:this.$el.scrollLeft=e},itemsLimitError:function(){var e=this;throw setTimeout((function(){console.log("It seems the scroller element isn't scrolling, so it tries to render all the items at once.","Scroller:",e.$el),console.log("Make sure the scroller has a fixed height (or width) and 'overflow-y' (or 'overflow-x') set to 'auto' so it can scroll correctly and only render the items visible in the scroll viewport.")})),new Error("Rendered items limit reached")},sortViews:function(){this.pool.sort((function(e,t){return e.nr.index-t.nr.index}))}}},$a={key:0,class:"vue-recycle-scroller__slot"},xa={key:1,class:"vue-recycle-scroller__slot"};ka.render=function(e,n,r,o,a,s){var c=t.resolveComponent("ResizeObserver"),u=t.resolveDirective("observe-visibility");return t.withDirectives((t.openBlock(),t.createBlock("div",{class:["vue-recycle-scroller",i({ready:a.ready,"page-mode":r.pageMode},"direction-".concat(e.direction),!0)],onScrollPassive:n[2]||(n[2]=function(){return s.handleScroll&&s.handleScroll.apply(s,arguments)})},[e.$slots.before?(t.openBlock(),t.createBlock("div",$a,[t.renderSlot(e.$slots,"before")])):t.createCommentVNode("v-if",!0),t.createVNode("div",{ref:"wrapper",style:i({},"vertical"===e.direction?"minHeight":"minWidth",a.totalSize+"px"),class:"vue-recycle-scroller__item-wrapper"},[(t.openBlock(!0),t.createBlock(t.Fragment,null,t.renderList(a.pool,(function(r){return t.openBlock(),t.createBlock("div",{key:r.nr.id,style:a.ready?{transform:"translate".concat("vertical"===e.direction?"Y":"X","(").concat(r.position,"px)")}:null,class:["vue-recycle-scroller__item-view",{hover:a.hoverKey===r.nr.key}],onMouseenter:function(e){return a.hoverKey=r.nr.key},onMouseleave:n[1]||(n[1]=function(e){return a.hoverKey=null})},[t.renderSlot(e.$slots,"default",{item:r.item,index:r.nr.index,active:r.nr.used})],46,["onMouseenter"])})),128))],4),e.$slots.after?(t.openBlock(),t.createBlock("div",xa,[t.renderSlot(e.$slots,"after")])):t.createCommentVNode("v-if",!0),t.createVNode(c,{onNotify:s.handleResize},null,8,["onNotify"])],34)),[[u,s.handleVisibilityChange]])},ka.__file="src/components/RecycleScroller.vue";var Da={name:"DynamicScroller",components:{RecycleScroller:ka},inheritAttrs:!1,provide:function(){return"undefined"!=typeof ResizeObserver&&(this.$_resizeObserver=new ResizeObserver((function(e){var t,n=function(e){if("undefined"==typeof Symbol||null==e[Symbol.iterator]){if(Array.isArray(e)||(e=l(e))){var t=0,n=function(){};return{s:n,n:function(){return t>=e.length?{done:!0}:{done:!1,value:e[t++]}},e:function(e){throw e},f:n}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var r,o,i=!0,a=!1;return{s:function(){r=e[Symbol.iterator]()},n:function(){var e=r.next();return i=e.done,e},e:function(e){a=!0,o=e},f:function(){try{i||null==r.return||r.return()}finally{if(a)throw o}}}}(e);try{for(n.s();!(t=n.n()).done;){var r=t.value;if(r.target){var o=new CustomEvent("resize",{detail:{contentRect:r.contentRect}});r.target.dispatchEvent(o)}}}catch(e){n.e(e)}finally{n.f()}}))),{vscrollData:this.vscrollData,vscrollParent:this,vscrollResizeObserver:this.$_resizeObserver}},props:s({},Ea,{minItemSize:{type:[Number,String],required:!0}}),data:function(){return{vscrollData:{active:!0,sizes:{},validSizes:{},keyField:this.keyField,simpleArray:!1}}},computed:{simpleArray:Na,itemsWithSize:function(){for(var e=[],t=this.items,n=this.keyField,r=this.simpleArray,o=this.vscrollData.sizes,i=0;i0&&void 0!==arguments[0])||arguments[0];(e||this.simpleArray)&&(this.vscrollData.validSizes={}),this.$emit("vscroll:update",{force:!0})},scrollToItem:function(e){var t=this.$refs.scroller;t&&t.scrollToItem(e)},getItemSize:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:void 0,n=this.simpleArray?null!=t?t:this.items.indexOf(e):e[this.keyField];return this.vscrollData.sizes[n]||0},scrollToBottom:function(){var e=this;if(!this.$_scrollingToBottom){this.$_scrollingToBottom=!0;var t=this.$el;this.$nextTick((function(){t.scrollTop=t.scrollHeight+5e3;requestAnimationFrame((function n(){t.scrollTop=t.scrollHeight+5e3,requestAnimationFrame((function(){t.scrollTop=t.scrollHeight+5e3,0===e.$_undefinedSizes?e.$_scrollingToBottom=!1:requestAnimationFrame(n)}))}))}))}}}},za={"slot-scope":"{ item: itemWithSize, index, active }"},Ra={slot:"before"},Ca={slot:"after"};Da.render=function(e,n,r,o,i,a){var s=t.resolveComponent("RecycleScroller");return t.openBlock(),t.createBlock(s,t.mergeProps({ref:"scroller",items:a.itemsWithSize,"min-item-size":r.minItemSize,direction:e.direction,"key-field":"id"},e.$attrs,{onResize:a.onScrollerResize,onVisible:a.onScrollerVisible},t.toHandlers(a.listeners)),{default:t.withCtx((function(){return[t.createVNode("template",za,[t.renderSlot(e.$slots,"default",{item:e.itemWithSize.item,index:e.index,active:e.active,itemWithSize:e.itemWithSize})]),t.createVNode("template",Ra,[t.renderSlot(e.$slots,"before")]),t.createVNode("template",Ca,[t.renderSlot(e.$slots,"after")])]})),_:3},16,["items","min-item-size","direction","onResize","onVisible"])},Da.__file="src/components/DynamicScroller.vue";var Ia={name:"DynamicScrollerItem",inject:["vscrollData","vscrollParent","vscrollResizeObserver"],props:{item:{required:!0},watchData:{type:Boolean,default:!1},active:{type:Boolean,required:!0},index:{type:Number,default:void 0},sizeDependencies:{type:[Array,Object],default:null},emitResize:{type:Boolean,default:!1},tag:{type:String,default:"div"}},computed:{id:function(){return this.vscrollData.simpleArray?this.index:this.item[this.vscrollData.keyField]},size:function(){return this.vscrollData.validSizes[this.id]&&this.vscrollData.sizes[this.id]||0},finalActive:function(){return this.active&&this.vscrollData.active}},watch:{watchData:"updateWatchData",id:function(){this.size||this.onDataUpdate()},finalActive:function(e){this.size||(e?this.vscrollParent.$_undefinedMap[this.id]||(this.vscrollParent.$_undefinedSizes++,this.vscrollParent.$_undefinedMap[this.id]=!0):this.vscrollParent.$_undefinedMap[this.id]&&(this.vscrollParent.$_undefinedSizes--,this.vscrollParent.$_undefinedMap[this.id]=!1)),this.vscrollResizeObserver?e?this.observeSize():this.unobserveSize():e&&this.$_pendingVScrollUpdate===this.id&&this.updateSize()}},created:function(){var e=this;if(!this.$isServer&&(this.$_forceNextVScrollUpdate=null,this.updateWatchData(),!this.vscrollResizeObserver)){var t=function(t){e.$watch((function(){return e.sizeDependencies[t]}),e.onDataUpdate)};for(var n in this.sizeDependencies)t(n);this.vscrollParent.$on("vscroll:update",this.onVscrollUpdate),this.vscrollParent.$on("vscroll:update-size",this.onVscrollUpdateSize)}},mounted:function(){this.vscrollData.active&&(this.updateSize(),this.observeSize())},beforeUnmount:function(){this.vscrollParent.$off("vscroll:update",this.onVscrollUpdate),this.vscrollParent.$off("vscroll:update-size",this.onVscrollUpdateSize),this.unobserveSize()},methods:{updateSize:function(){this.finalActive?this.$_pendingSizeUpdate!==this.id&&(this.$_pendingSizeUpdate=this.id,this.$_forceNextVScrollUpdate=null,this.$_pendingVScrollUpdate=null,this.computeSize(this.id)):this.$_forceNextVScrollUpdate=this.id},updateWatchData:function(){var e=this;this.watchData?this.$_watchData=this.$watch("data",(function(){e.onDataUpdate()}),{deep:!0}):this.$_watchData&&(this.$_watchData(),this.$_watchData=null)},onVscrollUpdate:function(e){var t=e.force;!this.finalActive&&t&&(this.$_pendingVScrollUpdate=this.id),this.$_forceNextVScrollUpdate!==this.id&&!t&&this.size||this.updateSize()},onDataUpdate:function(){this.updateSize()},computeSize:function(e){var t=this;this.$nextTick((function(){if(t.id===e){var n=t.$el.offsetWidth,r=t.$el.offsetHeight;t.applySize(n,r)}t.$_pendingSizeUpdate=null}))},applySize:function(e,t){var n=Math.round("vertical"===this.vscrollParent.direction?t:e);n&&this.size!==n&&(this.vscrollParent.$_undefinedMap[this.id]&&(this.vscrollParent.$_undefinedSizes--,this.vscrollParent.$_undefinedMap[this.id]=void 0),this.$set(this.vscrollData.sizes,this.id,n),this.$set(this.vscrollData.validSizes,this.id,!0),this.emitResize&&this.$emit("resize",this.id))},observeSize:function(){this.vscrollResizeObserver&&(this.vscrollResizeObserver.observe(this.$el.parentNode),this.$el.parentNode.addEventListener("resize",this.onResize))},unobserveSize:function(){this.vscrollResizeObserver&&(this.vscrollResizeObserver.unobserve(this.$el.parentNode),this.$el.parentNode.removeEventListener("resize",this.onResize))},onResize:function(e){var t=e.detail.contentRect,n=t.width,r=t.height;this.applySize(n,r)}},render:function(e){return console.log("render",e),e(this.tag,this.$slots.default)}};Ia.__file="src/components/DynamicScrollerItem.vue";var Pa={version:"1.0.10",install:function(e,t){var n=Object.assign({},{installComponents:!0,componentsPrefix:""},t);for(var o in n)void 0!==n[o]&&(r[o]=n[o]);n.installComponents&&function(e,t){e.component("".concat(t,"recycle-scroller"),ka),e.component("".concat(t,"RecycleScroller"),ka),e.component("".concat(t,"dynamic-scroller"),Da),e.component("".concat(t,"DynamicScroller"),Da),e.component("".concat(t,"dynamic-scroller-item"),Ia),e.component("".concat(t,"DynamicScrollerItem"),Ia)}(e,n.componentsPrefix)}},Aa=null;return"undefined"!=typeof window?Aa=window.Vue:"undefined"!=typeof global&&(Aa=global.Vue),Aa&&Aa.use(Pa),e.DynamicScroller=Da,e.DynamicScrollerItem=Ia,e.IdState=function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=e.idProp,r=void 0===n?function(e){return e.item.id}:n,o=t.reactive({});return{data:function(){return{idState:null}},created:function(){var e=this;this.$_id=null,this.$_getId="function"==typeof r?function(){return r.call(e,e)}:function(){return e[r]},this.$watch(this.$_getId,{handler:function(e){var t=this;this.$nextTick((function(){t.$_id=e}))},immediate:!0}),this.$_updateIdState()},beforeUpdate:function(){this.$_updateIdState()},methods:{$_idStateInit:function(e){var t=this.$options.idState;if("function"==typeof t){var n=t.call(this,this);return o[e]=n,this.$_id=e,n}throw new Error("[mixin IdState] Missing `idState` function on component definition.")},$_updateIdState:function(){var e=this.$_getId();null==e&&console.warn("No id found for IdState with idProp: '".concat(r,"'.")),e!==this.$_id&&(o[e]||this.$_idStateInit(e),this.idState=o[e])}}}},e.RecycleScroller=ka,e.default=Pa,e}({},vue); +var VueVirtualScroller=function(e,t){"use strict";var n={itemsLimit:1e3};function o(e){return(o="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function r(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function i(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var o=Object.getOwnPropertySymbols(e);t&&(o=o.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,o)}return n}function s(e){for(var t=1;te.length)&&(t=e.length);for(var n=0,o=new Array(t);n=e.length?{done:!0}:{done:!1,value:e[t++]}},e:function(e){throw e},f:n}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,r,i=!0,s=!1;return{s:function(){o=e[Symbol.iterator]()},n:function(){var e=o.next();return i=e.done,e},e:function(e){s=!0,r=e},f:function(){try{i||null==o.return||o.return()}finally{if(s)throw r}}}}function a(e,t){const n=Object.create(null),o=e.split(",");for(let e=0;e!!n[e.toLowerCase()]:e=>!!n[e]}const u=a("Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl");function d(e){if(S(e)){const t={};for(let n=0;n{if(e){const n=e.split(f);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}function v(e){let t="";if(V(e))t=e;else if(S(e))for(let n=0;n{},g=/^on[^a-z]/,b=e=>g.test(e),w=Object.assign,E=Object.prototype.hasOwnProperty,N=(e,t)=>E.call(e,t),S=Array.isArray,O=e=>"[object Map]"===D(e),$=e=>"function"==typeof e,V=e=>"string"==typeof e,k=e=>"symbol"==typeof e,x=e=>null!==e&&"object"==typeof e,z=Object.prototype.toString,D=e=>z.call(e),R=e=>D(e).slice(8,-1),C=e=>V(e)&&"NaN"!==e&&"-"!==e[0]&&""+parseInt(e,10)===e,P=(e=>{const t=Object.create(null);return n=>t[n]||(t[n]=e(n))})(e=>e.charAt(0).toUpperCase()+e.slice(1)),I=(e,t)=>e!==t&&(e==e||t==t);let j;const T=new WeakMap,A=[];let M;const U=Symbol("production"!==process.env.NODE_ENV?"iterate":""),F=Symbol("production"!==process.env.NODE_ENV?"Map key iterate":"");function L(e,t=m){(function(e){return e&&!0===e._isEffect})(e)&&(e=e.raw);const n=function(e,t){const n=function(){if(!n.active)return t.scheduler?void 0:e();if(!A.includes(n)){W(n);try{return K.push(q),q=!0,A.push(n),M=n,e()}finally{A.pop(),G(),M=A[A.length-1]}}};return n.id=B++,n.allowRecurse=!!t.allowRecurse,n._isEffect=!0,n.active=!0,n.raw=e,n.deps=[],n.options=t,n}(e,t);return t.lazy||n(),n}function H(e){e.active&&(W(e),e.options.onStop&&e.options.onStop(),e.active=!1)}let B=0;function W(e){const{deps:t}=e;if(t.length){for(let n=0;n{e&&e.forEach(e=>{(e!==M||e.allowRecurse)&&c.add(e)})};if("clear"===t)s.forEach(l);else if("length"===n&&S(e))s.forEach((e,t)=>{("length"===t||t>=o)&&l(e)});else switch(void 0!==n&&l(s.get(n)),t){case"add":S(e)?C(n)&&l(s.get("length")):(l(s.get(U)),O(e)&&l(s.get(F)));break;case"delete":S(e)||(l(s.get(U)),O(e)&&l(s.get(F)));break;case"set":O(e)&&l(s.get(U))}c.forEach(s=>{"production"!==process.env.NODE_ENV&&s.options.onTrigger&&s.options.onTrigger({effect:s,target:e,key:n,type:t,newValue:o,oldValue:r,oldTarget:i}),s.options.scheduler?s.options.scheduler(s):s()})}const Z=new Set(Object.getOwnPropertyNames(Symbol).map(e=>Symbol[e]).filter(k)),Q=re(),ee=re(!1,!0),te=re(!0),ne=re(!0,!0),oe={};function re(e=!1,t=!1){return function(n,o,r){if("__v_isReactive"===o)return!e;if("__v_isReadonly"===o)return e;if("__v_raw"===o&&r===(e?De:ze).get(n))return n;const i=S(n);if(!e&&i&&N(oe,o))return Reflect.get(oe,o,r);const s=Reflect.get(n,o,r);if(k(o)?Z.has(o):"__proto__"===o||"__v_isRef"===o)return s;if(e||X(n,"get",o),t)return s;if(Ue(s)){return!i||!C(o)?s.value:s}return x(s)?e?Ce(s):Re(s):s}}function ie(e=!1){return function(t,n,o,r){const i=t[n];if(!e&&(o=Me(o),!S(t)&&Ue(i)&&!Ue(o)))return i.value=o,!0;const s=S(t)&&C(n)?Number(n){const t=Array.prototype[e];oe[e]=function(...e){const n=Me(this);for(let e=0,t=this.length;e{const t=Array.prototype[e];oe[e]=function(...e){J();const n=t.apply(this,e);return G(),n}});const se={get:Q,set:ie(),deleteProperty:function(e,t){const n=N(e,t),o=e[t],r=Reflect.deleteProperty(e,t);return r&&n&&Y(e,"delete",t,void 0,o),r},has:function(e,t){const n=Reflect.has(e,t);return k(t)&&Z.has(t)||X(e,"has",t),n},ownKeys:function(e){return X(e,"iterate",S(e)?"length":U),Reflect.ownKeys(e)}},ce={get:te,set:(e,t)=>("production"!==process.env.NODE_ENV&&console.warn(`Set operation on key "${String(t)}" failed: target is readonly.`,e),!0),deleteProperty:(e,t)=>("production"!==process.env.NODE_ENV&&console.warn(`Delete operation on key "${String(t)}" failed: target is readonly.`,e),!0)},le=(w({},se,{get:ee,set:ie(!0)}),w({},ce,{get:ne})),ae=e=>x(e)?Re(e):e,ue=e=>x(e)?Ce(e):e,de=e=>e,pe=e=>Reflect.getPrototypeOf(e);function fe(e,t,n=!1,o=!1){const r=Me(e=e.__v_raw),i=Me(t);t!==i&&!n&&X(r,"get",t),!n&&X(r,"get",i);const{has:s}=pe(r),c=n?ue:o?de:ae;return s.call(r,t)?c(e.get(t)):s.call(r,i)?c(e.get(i)):void 0}function he(e,t=!1){const n=this.__v_raw,o=Me(n),r=Me(e);return e!==r&&!t&&X(o,"has",e),!t&&X(o,"has",r),e===r?n.has(e):n.has(e)||n.has(r)}function ve(e,t=!1){return e=e.__v_raw,!t&&X(Me(e),"iterate",U),Reflect.get(e,"size",e)}function me(e){e=Me(e);const t=Me(this),n=pe(t).has.call(t,e);return t.add(e),n||Y(t,"add",e,e),this}function ye(e,t){t=Me(t);const n=Me(this),{has:o,get:r}=pe(n);let i=o.call(n,e);i?"production"!==process.env.NODE_ENV&&xe(n,o,e):(e=Me(e),i=o.call(n,e));const s=r.call(n,e);return n.set(e,t),i?I(t,s)&&Y(n,"set",e,t,s):Y(n,"add",e,t),this}function _e(e){const t=Me(this),{has:n,get:o}=pe(t);let r=n.call(t,e);r?"production"!==process.env.NODE_ENV&&xe(t,n,e):(e=Me(e),r=n.call(t,e));const i=o?o.call(t,e):void 0,s=t.delete(e);return r&&Y(t,"delete",e,void 0,i),s}function ge(){const e=Me(this),t=0!==e.size,n="production"!==process.env.NODE_ENV?O(e)?new Map(e):new Set(e):void 0,o=e.clear();return t&&Y(e,"clear",void 0,void 0,n),o}function be(e,t){return function(n,o){const r=this,i=r.__v_raw,s=Me(i),c=e?ue:t?de:ae;return!e&&X(s,"iterate",U),i.forEach((e,t)=>n.call(o,c(e),c(t),r))}}function we(e,t,n){return function(...o){const r=this.__v_raw,i=Me(r),s=O(i),c="entries"===e||e===Symbol.iterator&&s,l="keys"===e&&s,a=r[e](...o),u=t?ue:n?de:ae;return!t&&X(i,"iterate",l?F:U),{next(){const{value:e,done:t}=a.next();return t?{value:e,done:t}:{value:c?[u(e[0]),u(e[1])]:u(e),done:t}},[Symbol.iterator](){return this}}}}function Ee(e){return function(...t){if("production"!==process.env.NODE_ENV){const n=t[0]?`on key "${t[0]}" `:"";console.warn(`${P(e)} operation ${n}failed: target is readonly.`,Me(this))}return"delete"!==e&&this}}const Ne={get(e){return fe(this,e)},get size(){return ve(this)},has:he,add:me,set:ye,delete:_e,clear:ge,forEach:be(!1,!1)},Se={get(e){return fe(this,e,!1,!0)},get size(){return ve(this)},has:he,add:me,set:ye,delete:_e,clear:ge,forEach:be(!1,!0)},Oe={get(e){return fe(this,e,!0)},get size(){return ve(this,!0)},has(e){return he.call(this,e,!0)},add:Ee("add"),set:Ee("set"),delete:Ee("delete"),clear:Ee("clear"),forEach:be(!0,!1)};function $e(e,t){const n=t?Se:e?Oe:Ne;return(t,o,r)=>"__v_isReactive"===o?!e:"__v_isReadonly"===o?e:"__v_raw"===o?t:Reflect.get(N(n,o)&&o in t?n:t,o,r)}["keys","values","entries",Symbol.iterator].forEach(e=>{Ne[e]=we(e,!1,!1),Oe[e]=we(e,!0,!1),Se[e]=we(e,!1,!0)});const Ve={get:$e(!1,!1)},ke={get:$e(!0,!1)};function xe(e,t,n){const o=Me(n);if(o!==n&&t.call(e,o)){const t=R(e);console.warn(`Reactive ${t} contains both the raw and reactive `+`versions of the same object${"Map"===t?" as keys":""}, `+"which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.")}}const ze=new WeakMap,De=new WeakMap;function Re(e){return e&&e.__v_isReadonly?e:Ie(e,!1,se,Ve)}function Ce(e){return Ie(e,!0,ce,ke)}function Pe(e){return Ie(e,!0,le,ke)}function Ie(e,t,n,o){if(!x(e))return"production"!==process.env.NODE_ENV&&console.warn(`value cannot be made reactive: ${String(e)}`),e;if(e.__v_raw&&(!t||!e.__v_isReactive))return e;const r=t?De:ze,i=r.get(e);if(i)return i;const s=(c=e).__v_skip||!Object.isExtensible(c)?0:function(e){switch(e){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}(R(c));var c;if(0===s)return e;const l=new Proxy(e,2===s?o:n);return r.set(e,l),l}function je(e){return Te(e)?je(e.__v_raw):!(!e||!e.__v_isReactive)}function Te(e){return!(!e||!e.__v_isReadonly)}function Ae(e){return je(e)||Te(e)}function Me(e){return e&&Me(e.__v_raw)||e}function Ue(e){return Boolean(e&&!0===e.__v_isRef)}const Fe=[];function Le(e,...t){J();const n=Fe.length?Fe[Fe.length-1].component:null,o=n&&n.appContext.config.warnHandler,r=function(){let e=Fe[Fe.length-1];if(!e)return[];const t=[];for(;e;){const n=t[0];n&&n.vnode===e?n.recurseCount++:t.push({vnode:e,recurseCount:0});const o=e.component&&e.component.parent;e=o&&o.vnode}return t}();if(o)We(o,n,11,[e+t.join(""),n&&n.proxy,r.map(({vnode:e})=>`at <${nn(n,e.type)}>`).join("\n"),r]);else{const n=[`[Vue warn]: ${e}`,...t];r.length&&n.push("\n",...function(e){const t=[];return e.forEach((e,n)=>{t.push(...0===n?[]:["\n"],...function({vnode:e,recurseCount:t}){const n=t>0?`... (${t} recursive calls)`:"",o=!!e.component&&null==e.component.parent,r=` at <${nn(e.component,e.type,o)}`,i=">"+n;return e.props?[r,...He(e.props),i]:[r+i]}(e))}),t}(r)),console.warn(...n)}G()}function He(e){const t=[],n=Object.keys(e);return n.slice(0,3).forEach(n=>{t.push(...function e(t,n,o){return V(n)?(n=JSON.stringify(n),o?n:[`${t}=${n}`]):"number"==typeof n||"boolean"==typeof n||null==n?o?n:[`${t}=${n}`]:Ue(n)?(n=e(t,Me(n.value),!0),o?n:[`${t}=Ref<`,n,">"]):$(n)?[`${t}=fn${n.name?`<${n.name}>`:""}`]:(n=Me(n),o?n:[`${t}=`,n])}(n,e[n]))}),n.length>3&&t.push(" ..."),t}const Be={bc:"beforeCreate hook",c:"created hook",bm:"beforeMount hook",m:"mounted hook",bu:"beforeUpdate hook",u:"updated",bum:"beforeUnmount hook",um:"unmounted hook",a:"activated hook",da:"deactivated hook",ec:"errorCaptured hook",rtc:"renderTracked hook",rtg:"renderTriggered hook",0:"setup function",1:"render function",2:"watcher getter",3:"watcher callback",4:"watcher cleanup function",5:"native event handler",6:"component event handler",7:"vnode hook",8:"directive hook",9:"transition hook",10:"app errorHandler",11:"app warnHandler",12:"ref function",13:"async component loader",14:"scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next"};function We(e,t,n,o){let r;try{r=o?e(...o):e()}catch(e){Ke(e,t,n)}return r}function qe(e,t,n,o){if($(e)){const i=We(e,t,n,o);return i&&(x(r=i)&&$(r.then)&&$(r.catch))&&i.catch(e=>{Ke(e,t,n)}),i}var r;const i=[];for(let r=0;rnull==e.id?1/0:e.id;function ft(e){Ge=!1,Je=!0,"production"!==process.env.NODE_ENV&&(e=e||new Map),function e(t,n=null){if(Ze.length){for(st=n,Qe=[...new Set(Ze)],Ze.length=0,"production"!==process.env.NODE_ENV&&(t=t||new Map),et=0;etpt(e)-pt(t));try{for(Ye=0;Yept(e)-pt(t)),ot=0;ot100)throw new Error("Maximum recursive updates exceeded. 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.");e.set(t,n+1)}else e.set(t,1)}const vt=new Set;if("production"!==process.env.NODE_ENV){("undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{}).__VUE_HMR_RUNTIME__={createRecord:yt((function(e,t){t||(Le("HMR API usage is out of date.\nPlease upgrade vue-loader/vite/rollup-plugin-vue or other relevant depdendency that handles Vue SFC compilation."),t={});if(mt.has(e))return!1;return mt.set(e,{component:on(t)?t.__vccOpts:t,instances:new Set}),!0})),rerender:yt((function(e,t){const n=mt.get(e);if(!n)return;t&&(n.component.render=t);Array.from(n.instances).forEach(e=>{t&&(e.render=t),e.renderCache=[],e.update()})})),reload:yt((function(e,t){const n=mt.get(e);if(!n)return;const{component:o,instances:r}=n;if(!vt.has(o)){t=on(t)?t.__vccOpts:t,w(o,t);for(const e in o)e in t||delete o[e];vt.add(o),dt(()=>{vt.delete(o)})}Array.from(r).forEach(e=>{e.parent?lt(e.parent.update):e.appContext.reload?e.appContext.reload():"undefined"!=typeof window?window.location.reload():console.warn("[HMR] Root or manually mounted instance modified. Full reload required.")})}))}}const mt=new Map;function yt(e){return(t,n)=>{try{return e(t,n)}catch(e){console.error(e),console.warn("[HMR] Something went wrong during Vue component hot-reload. Full reload required.")}}}let _t=null;function gt(e){_t=e}function bt(e){if($(e)&&(e=e()),S(e)){const t=function(e){let t;for(let n=0;n slots expect a single root node."),e=t}return Jt(e)}let wt=0;const Et=e=>wt+=e;let Nt=null;const St=[];function Ot(e){St.push(Nt=e)}function $t(){St.pop(),Nt=St[St.length-1]||null}function Vt(e){return t=>function(e,t=_t){if(!t)return e;const n=(...n)=>{wt||Mt(!0);const o=_t;gt(t);const r=e(...n);return gt(o),wt||Ut(),r};return n._c=!0,n}((function(){Ot(e);const n=t.apply(this,arguments);return $t(),n}))}const kt={};function xt(e,t,{immediate:n,deep:o,flush:r,onTrack:i,onTrigger:s}=m,c=en){"production"===process.env.NODE_ENV||t||(void 0!==n&&Le('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'),void 0!==o&&Le('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'));const l=e=>{Le("Invalid watch source: ",e,"A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.")};let a,u,d=!1;if(Ue(e)?(a=()=>e.value,d=!!e._shallow):je(e)?(a=()=>e,o=!0):S(e)?a=()=>e.map(e=>Ue(e)?e.value:je(e)?Dt(e):$(e)?We(e,c,2):void("production"!==process.env.NODE_ENV&&l(e))):$(e)?a=t?()=>We(e,c,2):()=>{if(!c||!c.isUnmounted)return u&&u(),We(e,c,3,[p])}:(a=_,"production"!==process.env.NODE_ENV&&l(e)),t&&o){const e=a;a=()=>Dt(e())}const p=e=>{u=y.options.onStop=()=>{We(e,c,4)}};let f=S(e)?[]:kt;const h=()=>{if(y.active)if(t){const e=y();(o||d||I(e,f))&&(u&&u(),qe(t,c,3,[e,f===kt?void 0:f,p]),f=e)}else y()};let v;h.allowRecurse=!!t,v="sync"===r?h:"post"===r?()=>Rt(h,c&&c.suspense):()=>{!c||c.isMounted?function(e){ut(e,Qe,Ze,et)}(h):h()};const y=L(a,{lazy:!0,onTrack:i,onTrigger:s,scheduler:v});return function(e,t=en){t&&(t.effects||(t.effects=[])).push(e)}(y,c),t?n?h():f=y():"post"===r?Rt(y,c&&c.suspense):y(),()=>{H(y),c&&((e,t)=>{const n=e.indexOf(t);n>-1&&e.splice(n,1)})(c.effects,y)}}function zt(e,t,n){const o=this.proxy;return xt(V(e)?()=>o[e]:e.bind(o),t.bind(o),n,this)}function Dt(e,t=new Set){if(!x(e)||t.has(e))return e;if(t.add(e),Ue(e))Dt(e.value,t);else if(S(e))for(let n=0;n{Dt(e,t)});else for(const n in e)Dt(e[n],t);return e}const Rt=function(e,t){t&&t.pendingBranch?S(e)?t.effects.push(...e):t.effects.push(e):dt(e)},Ct=Symbol(),Pt=Symbol("production"!==process.env.NODE_ENV?"Fragment":void 0),It=Symbol("production"!==process.env.NODE_ENV?"Text":void 0),jt=Symbol("production"!==process.env.NODE_ENV?"Comment":void 0),Tt=(Symbol("production"!==process.env.NODE_ENV?"Static":void 0),[]);let At=null;function Mt(e=!1){Tt.push(At=e?null:[])}function Ut(){Tt.pop(),At=Tt[Tt.length-1]||null}function Ft(e){return!!e&&!0===e.__v_isVNode}const Lt=({key:e})=>null!=e?e:null,Ht=({ref:e})=>null!=e?V(e)||Ue(e)||$(e)?{i:_t,r:e}:e:null,Bt="production"!==process.env.NODE_ENV?(...e)=>Wt(...e):Wt;function Wt(e,t=null,n=null,o=0,r=null,i=!1){if(e&&e!==Ct||("production"===process.env.NODE_ENV||e||Le(`Invalid vnode type when creating vnode: ${e}.`),e=jt),Ft(e)){const o=qt(e,t,!0);return n&&Gt(o,n),o}if(on(e)&&(e=e.__vccOpts),t){(Ae(t)||"__vInternal"in t)&&(t=w({},t));let{class:e,style:n}=t;e&&!V(e)&&(t.class=v(e)),x(n)&&(Ae(n)&&!S(n)&&(n=w({},n)),t.style=d(n))}const s=V(e)?1:(e=>e.__isSuspense)(e)?128:(e=>e.__isTeleport)(e)?64:x(e)?4:$(e)?2:0;"production"!==process.env.NODE_ENV&&4&s&&Ae(e)&&Le("Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.","\nComponent that was made reactive: ",e=Me(e));const c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&Lt(t),ref:t&&Ht(t),scopeId:Nt,children:null,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetAnchor:null,staticCount:0,shapeFlag:s,patchFlag:o,dynamicProps:r,dynamicChildren:null,appContext:null};if("production"!==process.env.NODE_ENV&&c.key!=c.key&&Le("VNode created with invalid key (NaN). VNode type:",c.type),Gt(c,n),128&s){const{content:e,fallback:t}=function(e){const{shapeFlag:t,children:n}=e;let o,r;return 32&t?(o=bt(n.default),r=bt(n.fallback)):(o=bt(n),r=Jt(null)),{content:o,fallback:r}}(c);c.ssContent=e,c.ssFallback=t}return!i&&At&&(o>0||6&s)&&32!==o&&At.push(c),c}function qt(e,t,n=!1){const{props:o,ref:r,patchFlag:i}=e,s=t?function(...e){const t=w({},e[0]);for(let n=1;nXt(e,t,n));for(const r in t)o&&N(o,r)?e[r]=o[r](e[r],t[r],n.proxy,r):e[r]=t[r]}const Yt=e=>e&&(e.proxy?e.proxy:Yt(e.parent)),Zt=w(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>"production"!==process.env.NODE_ENV?Pe(e.props):e.props,$attrs:e=>"production"!==process.env.NODE_ENV?Pe(e.attrs):e.attrs,$slots:e=>"production"!==process.env.NODE_ENV?Pe(e.slots):e.slots,$refs:e=>"production"!==process.env.NODE_ENV?Pe(e.refs):e.refs,$parent:e=>Yt(e.parent),$root:e=>e.root&&e.root.proxy,$emit:e=>e.emit,$options:e=>__VUE_OPTIONS_API__?function(e){const t=e.type,{__merged:n,mixins:o,extends:r}=t;if(n)return n;const i=e.appContext.mixins;if(!i.length&&!o&&!r)return t;const s={};return i.forEach(t=>Xt(s,t,e)),Xt(s,t,e),t.__merged=s}(e):e.type,$forceUpdate:e=>()=>lt(e.update),$nextTick:e=>ct.bind(e.proxy),$watch:e=>__VUE_OPTIONS_API__?zt.bind(e):_}),Qt={get({_:e},t){const{ctx:n,setupState:o,data:r,props:i,accessCache:s,type:c,appContext:l}=e;if("__v_skip"===t)return!0;if("production"!==process.env.NODE_ENV&&"__isVue"===t)return!0;let a;if("$"!==t[0]){const c=s[t];if(void 0!==c)switch(c){case 0:return o[t];case 1:return r[t];case 3:return n[t];case 2:return i[t]}else{if(o!==m&&N(o,t))return s[t]=0,o[t];if(r!==m&&N(r,t))return s[t]=1,r[t];if((a=e.propsOptions[0])&&N(a,t))return s[t]=2,i[t];if(n!==m&&N(n,t))return s[t]=3,n[t];__VUE_OPTIONS_API__,s[t]=4}}const u=Zt[t];let d,p;return u?("$attrs"===t&&(X(e,"get",t),process.env.NODE_ENV),u(e)):(d=c.__cssModules)&&(d=d[t])?d:n!==m&&N(n,t)?(s[t]=3,n[t]):(p=l.config.globalProperties,N(p,t)?p[t]:void("production"===process.env.NODE_ENV||!_t||V(t)&&0===t.indexOf("__v")||(r===m||"$"!==t[0]&&"_"!==t[0]||!N(r,t)?Le(`Property ${JSON.stringify(t)} was accessed during render `+"but is not defined on instance."):Le(`Property ${JSON.stringify(t)} must be accessed via $data because it starts with a reserved `+'character ("$" or "_") and is not proxied on the render context.'))))},set({_:e},t,n){const{data:o,setupState:r,ctx:i}=e;if(r!==m&&N(r,t))r[t]=n;else if(o!==m&&N(o,t))o[t]=n;else if(t in e.props)return"production"!==process.env.NODE_ENV&&Le(`Attempting to mutate prop "${t}". Props are readonly.`,e),!1;return"$"===t[0]&&t.slice(1)in e?("production"!==process.env.NODE_ENV&&Le(`Attempting to mutate public property "${t}". `+"Properties starting with $ are reserved and readonly.",e),!1):("production"!==process.env.NODE_ENV&&t in e.appContext.config.globalProperties?Object.defineProperty(i,t,{enumerable:!0,configurable:!0,value:n}):i[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:o,appContext:r,propsOptions:i}},s){let c;return void 0!==n[s]||e!==m&&N(e,s)||t!==m&&N(t,s)||(c=i[0])&&N(c,s)||N(o,s)||N(Zt,s)||N(r.config.globalProperties,s)}};"production"!==process.env.NODE_ENV&&(Qt.ownKeys=e=>(Le("Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead."),Reflect.ownKeys(e)));w({},Qt,{get(e,t){if(t!==Symbol.unscopables)return Qt.get(e,t,e)},has(e,t){const n="_"!==t[0]&&!u(t);return"production"!==process.env.NODE_ENV&&!n&&Qt.has(e,t)&&Le(`Property ${JSON.stringify(t)} should not start with _ which is a reserved prefix for Vue internals.`),n}});let en=null;const tn=/(?:^|[-_])(\w)/g;function nn(e,t,n=!1){let o=$(t)&&t.displayName||t.name;if(!o&&t.__file){const e=t.__file.match(/([^/\\]+)\.\w+$/);e&&(o=e[1])}if(!o&&e&&e.parent){const n=e=>{for(const n in e)if(e[n]===t)return n};o=n(e.components||e.parent.type.components)||n(e.appContext.components)}return o?o.replace(tn,e=>e.toUpperCase()).replace(/[-_]/g,""):n?"App":"Anonymous"}function on(e){return $(e)&&"__vccOpts"in e}Symbol("production"!==process.env.NODE_ENV?"ssrContext":"");var rn;function sn(){sn.init||(sn.init=!0,rn=-1!==function(){var e=window.navigator.userAgent,t=e.indexOf("MSIE ");if(t>0)return parseInt(e.substring(t+5,e.indexOf(".",t)),10);if(e.indexOf("Trident/")>0){var n=e.indexOf("rv:");return parseInt(e.substring(n+3,e.indexOf(".",n)),10)}var o=e.indexOf("Edge/");return o>0?parseInt(e.substring(o+5,e.indexOf(".",o)),10):-1}())}"production"!==process.env.NODE_ENV&&function(){const e=j||(j="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof window?window:"undefined"!=typeof global?global:{});e.__VUE__=!0,e.__VUE_DEVTOOLS_GLOBAL_HOOK__,function(){if("production"===process.env.NODE_ENV||"undefined"==typeof window)return;const e={style:"color:#3ba776"},t={style:"color:#0b1bc9"},n={style:"color:#b62e24"},o={style:"color:#9d288c"},r={header:t=>x(t)?t.__isVue?["div",e,"VueInstance"]:Ue(t)?["div",{},["span",e,u(t)],"<",c(t.value),">"]:je(t)?["div",{},["span",e,"Reactive"],"<",c(t),`>${Te(t)?" (readonly)":""}`]:Te(t)?["div",{},["span",e,"Readonly"],"<",c(t),">"]:null:null,hasBody:e=>e&&e.__isVue,body(e){if(e&&e.__isVue)return["div",{},...i(e.$)]}};function i(e){const t=[];e.type.props&&e.props&&t.push(s("props",Me(e.props))),e.setupState!==m&&t.push(s("setup",e.setupState)),e.data!==m&&t.push(s("data",Me(e.data)));const n=l(e,"computed");n&&t.push(s("computed",n));const r=l(e,"inject");return r&&t.push(s("injected",r)),t.push(["div",{},["span",{style:o.style+";opacity:0.66"},"$ (internal): "],["object",{object:e}]]),t}function s(e,t){return t=w({},t),Object.keys(t).length?["div",{style:"line-height:1.25em;margin-bottom:0.6em"},["div",{style:"color:#476582"},e],["div",{style:"padding-left:1.25em"},...Object.keys(t).map(e=>["div",{},["span",o,e+": "],c(t[e],!1)])]]:["span",{}]}function c(e,r=!0){return"number"==typeof e?["span",t,e]:"string"==typeof e?["span",n,JSON.stringify(e)]:"boolean"==typeof e?["span",o,e]:x(e)?["object",{object:r?Me(e):e}]:["span",n,String(e)]}function l(e,t){const n=e.type;if($(n))return;const o={};for(const r in e.ctx)a(n,r,t)&&(o[r]=e.ctx[r]);return o}function a(e,t,n){const o=e[n];return!!(S(o)&&o.includes(t)||x(o)&&t in o)||(!(!e.extends||!a(e.extends,t,n))||(!(!e.mixins||!e.mixins.some(e=>a(e,t,n)))||void 0))}function u(e){return e._shallow?"ShallowRef":e.effect?"ComputedRef":"Ref"}window.devtoolsFormatters?window.devtoolsFormatters.push(r):window.devtoolsFormatters=[r]}()}();var cn={name:"ResizeObserver",mounted:function(){var e=this;sn(),ct((function(){e._w=e.$el.offsetWidth,e._h=e.$el.offsetHeight}));var t=document.createElement("object");this._resizeObject=t,t.setAttribute("aria-hidden","true"),t.setAttribute("tabindex",-1),t.onload=this.addResizeHandlers,t.type="text/html",rn&&this.$el.appendChild(t),t.data="about:blank",rn||this.$el.appendChild(t)},beforeUnmount:function(){this.removeResizeHandlers()},methods:{compareAndNotify:function(){this._w===this.$el.offsetWidth&&this._h===this.$el.offsetHeight||(this._w=this.$el.offsetWidth,this._h=this.$el.offsetHeight,this.$emit("notify",{width:this._w,height:this._h}))},addResizeHandlers:function(){this._resizeObject.contentDocument.defaultView.addEventListener("resize",this.compareAndNotify),this.compareAndNotify()},removeResizeHandlers:function(){this._resizeObject&&this._resizeObject.onload&&(!rn&&this._resizeObject.contentDocument&&this._resizeObject.contentDocument.defaultView.removeEventListener("resize",this.compareAndNotify),this.$el.removeChild(this._resizeObject),this._resizeObject.onload=null,this._resizeObject=null)}}},ln=Vt("data-v-b329ee4c");Ot("data-v-b329ee4c");var an={class:"resize-observer",tabindex:"-1"};$t();var un=ln((function(e,t,n,o,r,i){return Mt(),function(e,t,n,o,r){const i=Bt(e,t,n,o,r,!0);return i.dynamicChildren=At||y,Ut(),At&&At.push(i),i}("div",an)}));cn.render=un,cn.__scopeId="data-v-b329ee4c",cn.__file="src/components/ResizeObserver.vue";var dn={version:"0.9.0-ropez.1",install:function(e){e.component("resize-observer",cn),e.component("ResizeObserver",cn)}},pn=null;function fn(e){return(fn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function hn(e,t){for(var n=0;n!!n[e.toLowerCase()]:e=>!!n[e]}"undefined"!=typeof window?pn=window.Vue:"undefined"!=typeof global&&(pn=global.Vue),pn&&pn.use(dn);const yn=mn("Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl"),_n=mn("itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly");function gn(e){if(Dn(e)){const t={};for(let n=0;n{if(e){const n=e.split(wn);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}function Nn(e){let t="";if(Pn(e))t=e;else if(Dn(e))for(let n=0;n{}),$n=/^on[^a-z]/,Vn=e=>$n.test(e),kn=Object.assign,xn=Object.prototype.hasOwnProperty,zn=(e,t)=>xn.call(e,t),Dn=Array.isArray,Rn=e=>"[object Map]"===An(e),Cn=e=>"function"==typeof e,Pn=e=>"string"==typeof e,In=e=>"symbol"==typeof e,jn=e=>null!==e&&"object"==typeof e,Tn=Object.prototype.toString,An=e=>Tn.call(e),Mn=e=>An(e).slice(8,-1),Un=e=>Pn(e)&&"NaN"!==e&&"-"!==e[0]&&""+parseInt(e,10)===e,Fn=e=>{const t=Object.create(null);return n=>t[n]||(t[n]=e(n))},Ln=/-(\w)/g,Hn=Fn(e=>e.replace(Ln,(e,t)=>t?t.toUpperCase():"")),Bn=/\B([A-Z])/g,Wn=Fn(e=>e.replace(Bn,"-$1").toLowerCase()),qn=Fn(e=>e.charAt(0).toUpperCase()+e.slice(1)),Kn=(e,t)=>e!==t&&(e==e||t==t);let Jn;const Gn=new WeakMap,Xn=[];let Yn;const Zn=Symbol("production"!==process.env.NODE_ENV?"iterate":""),Qn=Symbol("production"!==process.env.NODE_ENV?"Map key iterate":"");function eo(e,t=Sn){(function(e){return e&&!0===e._isEffect})(e)&&(e=e.raw);const n=function(e,t){const n=function(){if(!n.active)return t.scheduler?void 0:e();if(!Xn.includes(n)){no(n);try{return ro.push(oo),oo=!0,Xn.push(n),Yn=n,e()}finally{Xn.pop(),so(),Yn=Xn[Xn.length-1]}}};return n.id=to++,n.allowRecurse=!!t.allowRecurse,n._isEffect=!0,n.active=!0,n.raw=e,n.deps=[],n.options=t,n}(e,t);return t.lazy||n(),n}let to=0;function no(e){const{deps:t}=e;if(t.length){for(let n=0;n{e&&e.forEach(e=>{(e!==Yn||e.allowRecurse)&&c.add(e)})};if("clear"===t)s.forEach(l);else if("length"===n&&Dn(e))s.forEach((e,t)=>{("length"===t||t>=o)&&l(e)});else switch(void 0!==n&&l(s.get(n)),t){case"add":Dn(e)?Un(n)&&l(s.get("length")):(l(s.get(Zn)),Rn(e)&&l(s.get(Qn)));break;case"delete":Dn(e)||(l(s.get(Zn)),Rn(e)&&l(s.get(Qn)));break;case"set":Rn(e)&&l(s.get(Zn))}c.forEach(s=>{"production"!==process.env.NODE_ENV&&s.options.onTrigger&&s.options.onTrigger({effect:s,target:e,key:n,type:t,newValue:o,oldValue:r,oldTarget:i}),s.options.scheduler?s.options.scheduler(s):s()})}const ao=new Set(Object.getOwnPropertyNames(Symbol).map(e=>Symbol[e]).filter(In)),uo=mo(),po=mo(!1,!0),fo=mo(!0),ho=mo(!0,!0),vo={};function mo(e=!1,t=!1){return function(n,o,r){if("__v_isReactive"===o)return!e;if("__v_isReadonly"===o)return e;if("__v_raw"===o&&r===(e?Ho:Lo).get(n))return n;const i=Dn(n);if(!e&&i&&zn(vo,o))return Reflect.get(vo,o,r);const s=Reflect.get(n,o,r);if(In(o)?ao.has(o):"__proto__"===o||"__v_isRef"===o)return s;if(e||co(n,"get",o),t)return s;if(Zo(s)){return!i||!Un(o)?s.value:s}return jn(s)?e?Wo(s):Bo(s):s}}function yo(e=!1){return function(t,n,o,r){const i=t[n];if(!e&&(o=Yo(o),!Dn(t)&&Zo(i)&&!Zo(o)))return i.value=o,!0;const s=Dn(t)&&Un(n)?Number(n){const t=Array.prototype[e];vo[e]=function(...e){const n=Yo(this);for(let e=0,t=this.length;e{const t=Array.prototype[e];vo[e]=function(...e){io();const n=t.apply(this,e);return so(),n}});const _o={get:uo,set:yo(),deleteProperty:function(e,t){const n=zn(e,t),o=e[t],r=Reflect.deleteProperty(e,t);return r&&n&&lo(e,"delete",t,void 0,o),r},has:function(e,t){const n=Reflect.has(e,t);return In(t)&&ao.has(t)||co(e,"has",t),n},ownKeys:function(e){return co(e,"iterate",Dn(e)?"length":Zn),Reflect.ownKeys(e)}},go={get:fo,set:(e,t)=>("production"!==process.env.NODE_ENV&&console.warn(`Set operation on key "${String(t)}" failed: target is readonly.`,e),!0),deleteProperty:(e,t)=>("production"!==process.env.NODE_ENV&&console.warn(`Delete operation on key "${String(t)}" failed: target is readonly.`,e),!0)},bo=(kn({},_o,{get:po,set:yo(!0)}),kn({},go,{get:ho})),wo=e=>jn(e)?Bo(e):e,Eo=e=>jn(e)?Wo(e):e,No=e=>e,So=e=>Reflect.getPrototypeOf(e);function Oo(e,t,n=!1,o=!1){const r=Yo(e=e.__v_raw),i=Yo(t);t!==i&&!n&&co(r,"get",t),!n&&co(r,"get",i);const{has:s}=So(r),c=n?Eo:o?No:wo;return s.call(r,t)?c(e.get(t)):s.call(r,i)?c(e.get(i)):void 0}function $o(e,t=!1){const n=this.__v_raw,o=Yo(n),r=Yo(e);return e!==r&&!t&&co(o,"has",e),!t&&co(o,"has",r),e===r?n.has(e):n.has(e)||n.has(r)}function Vo(e,t=!1){return e=e.__v_raw,!t&&co(Yo(e),"iterate",Zn),Reflect.get(e,"size",e)}function ko(e){e=Yo(e);const t=Yo(this),n=So(t).has.call(t,e);return t.add(e),n||lo(t,"add",e,e),this}function xo(e,t){t=Yo(t);const n=Yo(this),{has:o,get:r}=So(n);let i=o.call(n,e);i?"production"!==process.env.NODE_ENV&&Fo(n,o,e):(e=Yo(e),i=o.call(n,e));const s=r.call(n,e);return n.set(e,t),i?Kn(t,s)&&lo(n,"set",e,t,s):lo(n,"add",e,t),this}function zo(e){const t=Yo(this),{has:n,get:o}=So(t);let r=n.call(t,e);r?"production"!==process.env.NODE_ENV&&Fo(t,n,e):(e=Yo(e),r=n.call(t,e));const i=o?o.call(t,e):void 0,s=t.delete(e);return r&&lo(t,"delete",e,void 0,i),s}function Do(){const e=Yo(this),t=0!==e.size,n="production"!==process.env.NODE_ENV?Rn(e)?new Map(e):new Set(e):void 0,o=e.clear();return t&&lo(e,"clear",void 0,void 0,n),o}function Ro(e,t){return function(n,o){const r=this,i=r.__v_raw,s=Yo(i),c=e?Eo:t?No:wo;return!e&&co(s,"iterate",Zn),i.forEach((e,t)=>n.call(o,c(e),c(t),r))}}function Co(e,t,n){return function(...o){const r=this.__v_raw,i=Yo(r),s=Rn(i),c="entries"===e||e===Symbol.iterator&&s,l="keys"===e&&s,a=r[e](...o),u=t?Eo:n?No:wo;return!t&&co(i,"iterate",l?Qn:Zn),{next(){const{value:e,done:t}=a.next();return t?{value:e,done:t}:{value:c?[u(e[0]),u(e[1])]:u(e),done:t}},[Symbol.iterator](){return this}}}}function Po(e){return function(...t){if("production"!==process.env.NODE_ENV){const n=t[0]?`on key "${t[0]}" `:"";console.warn(`${qn(e)} operation ${n}failed: target is readonly.`,Yo(this))}return"delete"!==e&&this}}const Io={get(e){return Oo(this,e)},get size(){return Vo(this)},has:$o,add:ko,set:xo,delete:zo,clear:Do,forEach:Ro(!1,!1)},jo={get(e){return Oo(this,e,!1,!0)},get size(){return Vo(this)},has:$o,add:ko,set:xo,delete:zo,clear:Do,forEach:Ro(!1,!0)},To={get(e){return Oo(this,e,!0)},get size(){return Vo(this,!0)},has(e){return $o.call(this,e,!0)},add:Po("add"),set:Po("set"),delete:Po("delete"),clear:Po("clear"),forEach:Ro(!0,!1)};function Ao(e,t){const n=t?jo:e?To:Io;return(t,o,r)=>"__v_isReactive"===o?!e:"__v_isReadonly"===o?e:"__v_raw"===o?t:Reflect.get(zn(n,o)&&o in t?n:t,o,r)}["keys","values","entries",Symbol.iterator].forEach(e=>{Io[e]=Co(e,!1,!1),To[e]=Co(e,!0,!1),jo[e]=Co(e,!1,!0)});const Mo={get:Ao(!1,!1)},Uo={get:Ao(!0,!1)};function Fo(e,t,n){const o=Yo(n);if(o!==n&&t.call(e,o)){const t=Mn(e);console.warn(`Reactive ${t} contains both the raw and reactive `+`versions of the same object${"Map"===t?" as keys":""}, `+"which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.")}}const Lo=new WeakMap,Ho=new WeakMap;function Bo(e){return e&&e.__v_isReadonly?e:Ko(e,!1,_o,Mo)}function Wo(e){return Ko(e,!0,go,Uo)}function qo(e){return Ko(e,!0,bo,Uo)}function Ko(e,t,n,o){if(!jn(e))return"production"!==process.env.NODE_ENV&&console.warn(`value cannot be made reactive: ${String(e)}`),e;if(e.__v_raw&&(!t||!e.__v_isReactive))return e;const r=t?Ho:Lo,i=r.get(e);if(i)return i;const s=(c=e).__v_skip||!Object.isExtensible(c)?0:function(e){switch(e){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}(Mn(c));var c;if(0===s)return e;const l=new Proxy(e,2===s?o:n);return r.set(e,l),l}function Jo(e){return Go(e)?Jo(e.__v_raw):!(!e||!e.__v_isReactive)}function Go(e){return!(!e||!e.__v_isReadonly)}function Xo(e){return Jo(e)||Go(e)}function Yo(e){return e&&Yo(e.__v_raw)||e}function Zo(e){return Boolean(e&&!0===e.__v_isRef)}const Qo=[];function er(e,...t){io();const n=Qo.length?Qo[Qo.length-1].component:null,o=n&&n.appContext.config.warnHandler,r=function(){let e=Qo[Qo.length-1];if(!e)return[];const t=[];for(;e;){const n=t[0];n&&n.vnode===e?n.recurseCount++:t.push({vnode:e,recurseCount:0});const o=e.component&&e.component.parent;e=o&&o.vnode}return t}();if(o)or(o,n,11,[e+t.join(""),n&&n.proxy,r.map(({vnode:e})=>`at <${oi(n,e.type)}>`).join("\n"),r]);else{const n=[`[Vue warn]: ${e}`,...t];r.length&&n.push("\n",...function(e){const t=[];return e.forEach((e,n)=>{t.push(...0===n?[]:["\n"],...function({vnode:e,recurseCount:t}){const n=t>0?`... (${t} recursive calls)`:"",o=!!e.component&&null==e.component.parent,r=` at <${oi(e.component,e.type,o)}`,i=">"+n;return e.props?[r,...tr(e.props),i]:[r+i]}(e))}),t}(r)),console.warn(...n)}so()}function tr(e){const t=[],n=Object.keys(e);return n.slice(0,3).forEach(n=>{t.push(...function e(t,n,o){return Pn(n)?(n=JSON.stringify(n),o?n:[`${t}=${n}`]):"number"==typeof n||"boolean"==typeof n||null==n?o?n:[`${t}=${n}`]:Zo(n)?(n=e(t,Yo(n.value),!0),o?n:[`${t}=Ref<`,n,">"]):Cn(n)?[`${t}=fn${n.name?`<${n.name}>`:""}`]:(n=Yo(n),o?n:[`${t}=`,n])}(n,e[n]))}),n.length>3&&t.push(" ..."),t}const nr={bc:"beforeCreate hook",c:"created hook",bm:"beforeMount hook",m:"mounted hook",bu:"beforeUpdate hook",u:"updated",bum:"beforeUnmount hook",um:"unmounted hook",a:"activated hook",da:"deactivated hook",ec:"errorCaptured hook",rtc:"renderTracked hook",rtg:"renderTriggered hook",0:"setup function",1:"render function",2:"watcher getter",3:"watcher callback",4:"watcher cleanup function",5:"native event handler",6:"component event handler",7:"vnode hook",8:"directive hook",9:"transition hook",10:"app errorHandler",11:"app warnHandler",12:"ref function",13:"async component loader",14:"scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next"};function or(e,t,n,o){let r;try{r=o?e(...o):e()}catch(e){ir(e,t,n)}return r}function rr(e,t,n,o){if(Cn(e)){const i=or(e,t,n,o);return i&&(jn(r=i)&&Cn(r.then)&&Cn(r.catch))&&i.catch(e=>{ir(e,t,n)}),i}var r;const i=[];for(let r=0;rnull==e.id?1/0:e.id;function Or(e){cr=!1,sr=!0,"production"!==process.env.NODE_ENV&&(e=e||new Map),function e(t,n=null){if(ur.length){for(_r=n,dr=[...new Set(ur)],ur.length=0,"production"!==process.env.NODE_ENV&&(t=t||new Map),pr=0;prSr(e)-Sr(t));try{for(ar=0;arSr(e)-Sr(t)),vr=0;vr100)throw new Error("Maximum recursive updates exceeded. 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.");e.set(t,n+1)}else e.set(t,1)}const Vr=new Set;if("production"!==process.env.NODE_ENV){("undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{}).__VUE_HMR_RUNTIME__={createRecord:xr((function(e,t){t||(er("HMR API usage is out of date.\nPlease upgrade vue-loader/vite/rollup-plugin-vue or other relevant depdendency that handles Vue SFC compilation."),t={});if(kr.has(e))return!1;return kr.set(e,{component:ri(t)?t.__vccOpts:t,instances:new Set}),!0})),rerender:xr((function(e,t){const n=kr.get(e);if(!n)return;t&&(n.component.render=t);Array.from(n.instances).forEach(e=>{t&&(e.render=t),e.renderCache=[],e.update()})})),reload:xr((function(e,t){const n=kr.get(e);if(!n)return;const{component:o,instances:r}=n;if(!Vr.has(o)){t=ri(t)?t.__vccOpts:t,kn(o,t);for(const e in o)e in t||delete o[e];Vr.add(o),Nr(()=>{Vr.delete(o)})}Array.from(r).forEach(e=>{e.parent?br(e.parent.update):e.appContext.reload?e.appContext.reload():"undefined"!=typeof window?window.location.reload():console.warn("[HMR] Root or manually mounted instance modified. Full reload required.")})}))}}const kr=new Map;function xr(e){return(t,n)=>{try{return e(t,n)}catch(e){console.error(e),console.warn("[HMR] Something went wrong during Vue component hot-reload. Full reload required.")}}}function zr(e){if(Cn(e)&&(e=e()),Dn(e)){const t=function(e){let t;for(let n=0;n slots expect a single root node."),e=t}return Gr(e)}let Dr=0;const Rr=e=>Dr+=e;const Cr={};function Pr(e,t,{immediate:n,deep:o,flush:r,onTrack:i,onTrigger:s}=Sn,c=ti){"production"===process.env.NODE_ENV||t||(void 0!==n&&er('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'),void 0!==o&&er('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'));const l=e=>{er("Invalid watch source: ",e,"A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.")};let a,u,d=!1;if(Zo(e)?(a=()=>e.value,d=!!e._shallow):Jo(e)?(a=()=>e,o=!0):Dn(e)?a=()=>e.map(e=>Zo(e)?e.value:Jo(e)?jr(e):Cn(e)?or(e,c,2):void("production"!==process.env.NODE_ENV&&l(e))):Cn(e)?a=t?()=>or(e,c,2):()=>{if(!c||!c.isUnmounted)return u&&u(),or(e,c,3,[p])}:(a=On,"production"!==process.env.NODE_ENV&&l(e)),t&&o){const e=a;a=()=>jr(e())}const p=e=>{u=m.options.onStop=()=>{or(e,c,4)}};let f=Dn(e)?[]:Cr;const h=()=>{if(m.active)if(t){const e=m();(o||d||Kn(e,f))&&(u&&u(),rr(t,c,3,[e,f===Cr?void 0:f,p]),f=e)}else m()};let v;h.allowRecurse=!!t,v="sync"===r?h:"post"===r?()=>Tr(h,c&&c.suspense):()=>{!c||c.isMounted?function(e){Er(e,dr,ur,pr)}(h):h()};const m=eo(a,{lazy:!0,onTrack:i,onTrigger:s,scheduler:v});return function(e,t=ti){t&&(t.effects||(t.effects=[])).push(e)}(m,c),t?n?h():f=m():"post"===r?Tr(m,c&&c.suspense):m(),()=>{!function(e){e.active&&(no(e),e.options.onStop&&e.options.onStop(),e.active=!1)}(m),c&&((e,t)=>{const n=e.indexOf(t);n>-1&&e.splice(n,1)})(c.effects,m)}}function Ir(e,t,n){const o=this.proxy;return Pr(Pn(e)?()=>o[e]:e.bind(o),t.bind(o),n,this)}function jr(e,t=new Set){if(!jn(e)||t.has(e))return e;if(t.add(e),Zo(e))jr(e.value,t);else if(Dn(e))for(let n=0;n{jr(e,t)});else for(const n in e)jr(e[n],t);return e}const Tr=function(e,t){t&&t.pendingBranch?Dn(e)?t.effects.push(...e):t.effects.push(e):Nr(e)},Ar=Symbol(),Mr=Symbol("production"!==process.env.NODE_ENV?"Fragment":void 0),Ur=Symbol("production"!==process.env.NODE_ENV?"Text":void 0),Fr=Symbol("production"!==process.env.NODE_ENV?"Comment":void 0);Symbol("production"!==process.env.NODE_ENV?"Static":void 0);function Lr(e){return!!e&&!0===e.__v_isVNode}const Hr=({key:e})=>null!=e?e:null,Br=({ref:e})=>null!=e?Pn(e)||Zo(e)||Cn(e)?{i:null,r:e}:e:null,Wr="production"!==process.env.NODE_ENV?(...e)=>qr(...e):qr;function qr(e,t=null,n=null,o=0,r=null,i=!1){if(e&&e!==Ar||("production"===process.env.NODE_ENV||e||er(`Invalid vnode type when creating vnode: ${e}.`),e=Fr),Lr(e)){const o=Kr(e,t,!0);return n&&Xr(o,n),o}if(ri(e)&&(e=e.__vccOpts),t){(Xo(t)||"__vInternal"in t)&&(t=kn({},t));let{class:e,style:n}=t;e&&!Pn(e)&&(t.class=Nn(e)),jn(n)&&(Xo(n)&&!Dn(n)&&(n=kn({},n)),t.style=gn(n))}const s=Pn(e)?1:(e=>e.__isSuspense)(e)?128:(e=>e.__isTeleport)(e)?64:jn(e)?4:Cn(e)?2:0;"production"!==process.env.NODE_ENV&&4&s&&Xo(e)&&er("Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.","\nComponent that was made reactive: ",e=Yo(e));const c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&Hr(t),ref:t&&Br(t),scopeId:null,children:null,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetAnchor:null,staticCount:0,shapeFlag:s,patchFlag:o,dynamicProps:r,dynamicChildren:null,appContext:null};if("production"!==process.env.NODE_ENV&&c.key!=c.key&&er("VNode created with invalid key (NaN). VNode type:",c.type),Xr(c,n),128&s){const{content:e,fallback:t}=function(e){const{shapeFlag:t,children:n}=e;let o,r;return 32&t?(o=zr(n.default),r=zr(n.fallback)):(o=zr(n),r=Gr(null)),{content:o,fallback:r}}(c);c.ssContent=e,c.ssFallback=t}return c}function Kr(e,t,n=!1){const{props:o,ref:r,patchFlag:i}=e,s=t?function(...e){const t=kn({},e[0]);for(let n=1;nYr(e,t,n));for(const r in t)o&&zn(o,r)?e[r]=o[r](e[r],t[r],n.proxy,r):e[r]=t[r]}const Zr=e=>e&&(e.proxy?e.proxy:Zr(e.parent)),Qr=kn(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>"production"!==process.env.NODE_ENV?qo(e.props):e.props,$attrs:e=>"production"!==process.env.NODE_ENV?qo(e.attrs):e.attrs,$slots:e=>"production"!==process.env.NODE_ENV?qo(e.slots):e.slots,$refs:e=>"production"!==process.env.NODE_ENV?qo(e.refs):e.refs,$parent:e=>Zr(e.parent),$root:e=>e.root&&e.root.proxy,$emit:e=>e.emit,$options:e=>__VUE_OPTIONS_API__?function(e){const t=e.type,{__merged:n,mixins:o,extends:r}=t;if(n)return n;const i=e.appContext.mixins;if(!i.length&&!o&&!r)return t;const s={};return i.forEach(t=>Yr(s,t,e)),Yr(s,t,e),t.__merged=s}(e):e.type,$forceUpdate:e=>()=>br(e.update),$nextTick:e=>gr.bind(e.proxy),$watch:e=>__VUE_OPTIONS_API__?Ir.bind(e):On}),ei={get({_:e},t){const{ctx:n,setupState:o,data:r,props:i,accessCache:s,type:c,appContext:l}=e;if("__v_skip"===t)return!0;if("production"!==process.env.NODE_ENV&&"__isVue"===t)return!0;let a;if("$"!==t[0]){const c=s[t];if(void 0!==c)switch(c){case 0:return o[t];case 1:return r[t];case 3:return n[t];case 2:return i[t]}else{if(o!==Sn&&zn(o,t))return s[t]=0,o[t];if(r!==Sn&&zn(r,t))return s[t]=1,r[t];if((a=e.propsOptions[0])&&zn(a,t))return s[t]=2,i[t];if(n!==Sn&&zn(n,t))return s[t]=3,n[t];__VUE_OPTIONS_API__,s[t]=4}}const u=Qr[t];let d,p;return u?("$attrs"===t&&(co(e,"get",t),process.env.NODE_ENV),u(e)):(d=c.__cssModules)&&(d=d[t])?d:n!==Sn&&zn(n,t)?(s[t]=3,n[t]):(p=l.config.globalProperties,zn(p,t)?p[t]:void process.env.NODE_ENV)},set({_:e},t,n){const{data:o,setupState:r,ctx:i}=e;if(r!==Sn&&zn(r,t))r[t]=n;else if(o!==Sn&&zn(o,t))o[t]=n;else if(t in e.props)return"production"!==process.env.NODE_ENV&&er(`Attempting to mutate prop "${t}". Props are readonly.`,e),!1;return"$"===t[0]&&t.slice(1)in e?("production"!==process.env.NODE_ENV&&er(`Attempting to mutate public property "${t}". `+"Properties starting with $ are reserved and readonly.",e),!1):("production"!==process.env.NODE_ENV&&t in e.appContext.config.globalProperties?Object.defineProperty(i,t,{enumerable:!0,configurable:!0,value:n}):i[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:o,appContext:r,propsOptions:i}},s){let c;return void 0!==n[s]||e!==Sn&&zn(e,s)||t!==Sn&&zn(t,s)||(c=i[0])&&zn(c,s)||zn(o,s)||zn(Qr,s)||zn(r.config.globalProperties,s)}};"production"!==process.env.NODE_ENV&&(ei.ownKeys=e=>(er("Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead."),Reflect.ownKeys(e)));kn({},ei,{get(e,t){if(t!==Symbol.unscopables)return ei.get(e,t,e)},has(e,t){const n="_"!==t[0]&&!yn(t);return"production"!==process.env.NODE_ENV&&!n&&ei.has(e,t)&&er(`Property ${JSON.stringify(t)} should not start with _ which is a reserved prefix for Vue internals.`),n}});let ti=null;const ni=/(?:^|[-_])(\w)/g;function oi(e,t,n=!1){let o=Cn(t)&&t.displayName||t.name;if(!o&&t.__file){const e=t.__file.match(/([^/\\]+)\.\w+$/);e&&(o=e[1])}if(!o&&e&&e.parent){const n=e=>{for(const n in e)if(e[n]===t)return n};o=n(e.components||e.parent.type.components)||n(e.appContext.components)}return o?o.replace(ni,e=>e.toUpperCase()).replace(/[-_]/g,""):n?"App":"Anonymous"}function ri(e){return Cn(e)&&"__vccOpts"in e}Symbol("production"!==process.env.NODE_ENV?"ssrContext":"");const ii="http://www.w3.org/2000/svg",si="undefined"!=typeof document?document:null;let ci,li;const ai={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{const t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n)=>t?si.createElementNS(ii,e):si.createElement(e,n?{is:n}:void 0),createText:e=>si.createTextNode(e),createComment:e=>si.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>si.querySelector(e),setScopeId(e,t){e.setAttribute(t,"")},cloneNode:e=>e.cloneNode(!0),insertStaticContent(e,t,n,o){const r=o?li||(li=si.createElementNS(ii,"svg")):ci||(ci=si.createElement("div"));r.innerHTML=e;const i=r.firstChild;let s=i,c=s;for(;s;)c=s,ai.insert(s,t,n),s=r.firstChild;return[i,c]}};const ui=/\s*!important$/;function di(e,t,n){if(Dn(n))n.forEach(n=>di(e,t,n));else if(t.startsWith("--"))e.setProperty(t,n);else{const o=function(e,t){const n=fi[t];if(n)return n;let o=Hn(t);if("filter"!==o&&o in e)return fi[t]=o;o=qn(o);for(let n=0;ndocument.createEvent("Event").timeStamp&&(vi=()=>performance.now());let mi=0;const yi=Promise.resolve(),_i=()=>{mi=0};function gi(e,t,n,o,r=null){const i=e._vei||(e._vei={}),s=i[t];if(o&&s)s.value=o;else{const[n,c]=function(e){let t;if(bi.test(e)){let n;for(t={};n=e.match(bi);)e=e.slice(0,e.length-n[0].length),t[n[0].toLowerCase()]=!0}return[e.slice(2).toLowerCase(),t]}(t);if(o){!function(e,t,n,o){e.addEventListener(t,n,o)}(e,n,i[t]=function(e,t){const n=e=>{(e.timeStamp||vi())>=n.attached-1&&rr(function(e,t){if(Dn(t)){const n=e.stopImmediatePropagation;return e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0},t.map(e=>t=>!t._stopped&&e(t))}return t}(e,n.value),t,5,[e])};return n.value=e,n.attached=(()=>mi||(yi.then(_i),mi=vi()))(),n}(o,r),c)}else s&&(!function(e,t,n,o){e.removeEventListener(t,n,o)}(e,n,s,c),i[t]=void 0)}}const bi=/(?:Once|Passive|Capture)$/;const wi=/^on[a-z]/;kn({patchProp:(e,t,n,o,r=!1,i,s,c,l)=>{switch(t){case"class":!function(e,t,n){if(null==t&&(t=""),n)e.setAttribute("class",t);else{const n=e._vtc;n&&(t=(t?[t,...n]:[...n]).join(" ")),e.className=t}}(e,o,r);break;case"style":!function(e,t,n){const o=e.style;if(n)if(Pn(n))t!==n&&(o.cssText=n);else{for(const e in n)di(o,e,n[e]);if(t&&!Pn(t))for(const e in t)null==n[e]&&di(o,e,"")}else e.removeAttribute("style")}(e,n,o);break;default:Vn(t)?(e=>e.startsWith("onUpdate:"))(t)||gi(e,t,0,o,s):function(e,t,n,o){if(o)return"innerHTML"===t||!!(t in e&&wi.test(t)&&Cn(n));if("spellcheck"===t||"draggable"===t)return!1;if("form"===t&&"string"==typeof n)return!1;if("list"===t&&"INPUT"===e.tagName)return!1;if(wi.test(t)&&Pn(n))return!1;return t in e}(e,t,o,r)?function(e,t,n,o,r,i,s){if("innerHTML"===t||"textContent"===t)return o&&s(o,r,i),void(e[t]=null==n?"":n);if("value"!==t||"PROGRESS"===e.tagName){if(""===n||null==n){const o=typeof e[t];if(""===n&&"boolean"===o)return void(e[t]=!0);if(null==n&&"string"===o)return e[t]="",void e.removeAttribute(t);if("number"===o)return e[t]=0,void e.removeAttribute(t)}try{e[t]=n}catch(o){"production"!==process.env.NODE_ENV&&er(`Failed setting prop "${t}" on <${e.tagName.toLowerCase()}>: `+`value ${n} is invalid.`,o)}}else{e._value=n;const t=null==n?"":n;e.value!==t&&(e.value=t)}}(e,t,o,i,s,c,l):("true-value"===t?e._trueValue=o:"false-value"===t&&(e._falseValue=o),function(e,t,n,o){if(o&&t.startsWith("xlink:"))null==n?e.removeAttributeNS(hi,t.slice(6,t.length)):e.setAttributeNS(hi,t,n);else{const o=_n(t);null==n||o&&!1===n?e.removeAttribute(t):e.setAttribute(t,o?"":n)}}(e,t,o,r))}},forcePatchProp:(e,t)=>"value"===t},ai);"production"!==process.env.NODE_ENV&&function(){const e=Jn||(Jn="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof window?window:"undefined"!=typeof global?global:{});e.__VUE__=!0,e.__VUE_DEVTOOLS_GLOBAL_HOOK__,function(){if("production"===process.env.NODE_ENV||"undefined"==typeof window)return;const e={style:"color:#3ba776"},t={style:"color:#0b1bc9"},n={style:"color:#b62e24"},o={style:"color:#9d288c"},r={header:t=>jn(t)?t.__isVue?["div",e,"VueInstance"]:Zo(t)?["div",{},["span",e,u(t)],"<",c(t.value),">"]:Jo(t)?["div",{},["span",e,"Reactive"],"<",c(t),`>${Go(t)?" (readonly)":""}`]:Go(t)?["div",{},["span",e,"Readonly"],"<",c(t),">"]:null:null,hasBody:e=>e&&e.__isVue,body(e){if(e&&e.__isVue)return["div",{},...i(e.$)]}};function i(e){const t=[];e.type.props&&e.props&&t.push(s("props",Yo(e.props))),e.setupState!==Sn&&t.push(s("setup",e.setupState)),e.data!==Sn&&t.push(s("data",Yo(e.data)));const n=l(e,"computed");n&&t.push(s("computed",n));const r=l(e,"inject");return r&&t.push(s("injected",r)),t.push(["div",{},["span",{style:o.style+";opacity:0.66"},"$ (internal): "],["object",{object:e}]]),t}function s(e,t){return t=kn({},t),Object.keys(t).length?["div",{style:"line-height:1.25em;margin-bottom:0.6em"},["div",{style:"color:#476582"},e],["div",{style:"padding-left:1.25em"},...Object.keys(t).map(e=>["div",{},["span",o,e+": "],c(t[e],!1)])]]:["span",{}]}function c(e,r=!0){return"number"==typeof e?["span",t,e]:"string"==typeof e?["span",n,JSON.stringify(e)]:"boolean"==typeof e?["span",o,e]:jn(e)?["object",{object:r?Yo(e):e}]:["span",n,String(e)]}function l(e,t){const n=e.type;if(Cn(n))return;const o={};for(const r in e.ctx)a(n,r,t)&&(o[r]=e.ctx[r]);return o}function a(e,t,n){const o=e[n];return!!(Dn(o)&&o.includes(t)||jn(o)&&t in o)||(!(!e.extends||!a(e.extends,t,n))||(!(!e.mixins||!e.mixins.some(e=>a(e,t,n)))||void 0))}function u(e){return e._shallow?"ShallowRef":e.effect?"ComputedRef":"Ref"}window.devtoolsFormatters?window.devtoolsFormatters.push(r):window.devtoolsFormatters=[r]}()}();var Ei=function(){function e(t,n,o){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),this.el=t,this.observer=null,this.frozen=!1,this.createObserver(n,o)}var t,n,o;return t=e,(n=[{key:"createObserver",value:function(e,t){var n=this;if(this.observer&&this.destroyObserver(),!this.frozen){var o;if(this.options="function"==typeof(o=e)?{callback:o}:o,this.callback=function(e,t){n.options.callback(e,t),e&&n.options.once&&(n.frozen=!0,n.destroyObserver())},this.callback&&this.options.throttle){var r=(this.options.throttleOptions||{}).leading;this.callback=function(e,t){var n,o,r,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},s=function(s){for(var c=arguments.length,l=new Array(c>1?c-1:0),a=1;a1){var o=e.find((function(e){return e.isIntersecting}));o&&(t=o)}if(n.callback){var r=t.isIntersecting&&t.intersectionRatio>=n.threshold;if(r===n.oldResult)return;n.oldResult=r,n.callback(r,t)}}),this.options.intersection),gr((function(){n.observer&&n.observer.observe(n.el)}))}}},{key:"destroyObserver",value:function(){this.observer&&(this.observer.disconnect(),this.observer=null),this.callback&&this.callback._clear&&(this.callback._clear(),this.callback=null)}},{key:"threshold",get:function(){return this.options.intersection&&this.options.intersection.threshold||0}}])&&hn(t.prototype,n),o&&hn(t,o),e}();function Ni(e,t,n){var o=t.value;if(o)if("undefined"==typeof IntersectionObserver)console.warn("[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill");else{var r=new Ei(e,o,n);e._vue_visibilityState=r}}function Si(e){var t=e._vue_visibilityState;t&&(t.destroyObserver(),delete e._vue_visibilityState)}var Oi={beforeMount:Ni,updated:function(e,t,n){var o=t.value;if(!function e(t,n){if(t===n)return!0;if("object"===fn(t)){for(var o in t)if(!e(t[o],n[o]))return!1;return!0}return!1}(o,t.oldValue)){var r=e._vue_visibilityState;o?r?r.createObserver(o,n):Ni(e,{value:o},n):Si(e)}},unmounted:Si};var $i={version:"0.9.0-ropez.1",install:function(e){e.directive("observe-visibility",Oi)}},Vi=null;"undefined"!=typeof window?Vi=window.Vue:"undefined"!=typeof global&&(Vi=global.Vue),Vi&&Vi.use($i);var ki="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};var xi=function(e,t){return e(t={exports:{}},t.exports),t.exports}((function(e){var t,n;t=ki,n=function(){var e=/(auto|scroll)/,t=function(e,n){return null===e.parentNode?n:t(e.parentNode,n.concat([e]))},n=function(e,t){return getComputedStyle(e,null).getPropertyValue(t)},o=function(t){return e.test(function(e){return n(e,"overflow")+n(e,"overflow-y")+n(e,"overflow-x")}(t))};return function(e){if(e instanceof HTMLElement||e instanceof SVGElement){for(var n=t(e.parentNode,[]),r=0;r1&&void 0!==arguments[1]&&arguments[1],n=this.$_unusedViews,o=e.nr.type,r=n.get(o);r||(r=[],n.set(o,r)),r.push(e),t||(e.nr.used=!1,e.position=-9999,this.$_views.delete(e.nr.key))},handleResize:function(){this.$emit("resize"),this.ready&&this.updateVisibleItems(!1)},handleScroll:function(e){var t=this;this.$_scrollDirty||(this.$_scrollDirty=!0,requestAnimationFrame((function(){t.$_scrollDirty=!1,t.updateVisibleItems(!1,!0).continuous||(clearTimeout(t.$_refreshTimout),t.$_refreshTimout=setTimeout(t.handleScroll,100))})))},handleVisibilityChange:function(e,t){var n=this;this.ready&&(e||0!==t.boundingClientRect.width||0!==t.boundingClientRect.height?(this.$emit("visible"),requestAnimationFrame((function(){n.updateVisibleItems(!1)}))):this.$emit("hidden"))},updateVisibleItems:function(e){var t,o,r,i,s=arguments.length>1&&void 0!==arguments[1]&&arguments[1],c=this.itemSize,l=this.$_computedMinItemSize,a=this.typeField,u=this.simpleArray?null:this.keyField,d=this.items,p=d.length,f=this.sizes,h=this.$_views,v=this.$_unusedViews,m=this.pool;if(p)if(this.$_prerender)t=0,o=this.prerender,r=null;else{var y=this.getScroll();if(s){var _=y.start-this.$_lastUpdateScrollPosition;if(_<0&&(_=-_),null===c&&_y.start&&(E=N),N=~~((w+E)/2)}while(N!==b);for(N<0&&(N=0),t=N,r=f[p-1].accumulator,o=N;op&&(o=p)}else(t=~~(y.start/c))<0&&(t=0),(o=Math.ceil(y.end/c))>p&&(o=p),r=p*c}else t=o=r=0;o-t>n.itemsLimit&&this.itemsLimitError(),this.totalSize=r;var S=t<=this.$_endIndex&&o>=this.$_startIndex;if(this.$_continuous!==S){if(S){h.clear(),v.clear();for(var O=0,$=m.length;O<$;O++)i=m[O],this.unuseView(i)}this.$_continuous=S}else if(S)for(var V=0,k=m.length;V=o)&&this.unuseView(i));for(var x,z,D,R,C=S?null:new Map,P=t;P=D.length)&&(i=this.addView(m,P,x,I,z),this.unuseView(i,!0),D=v.get(z)),(i=D[R]).item=x,i.nr.used=!0,i.nr.index=P,i.nr.key=I,i.nr.type=z,C.set(z,R+1),R++),h.set(I,i)),i.position=null===c?f[P-1].accumulator:P*c):i&&this.unuseView(i)}return this.$_startIndex=t,this.$_endIndex=o,this.emitUpdate&&this.$emit("update",t,o),clearTimeout(this.$_sortTimer),this.$_sortTimer=setTimeout(this.sortViews,300),{continuous:S}},getListenerTarget:function(){var e=xi(this.$el);return!window.document||e!==window.document.documentElement&&e!==window.document.body||(e=window),e},getScroll:function(){var e,t=this.$el,n="vertical"===this.direction;if(this.pageMode){var o=t.getBoundingClientRect(),r=n?o.height:o.width,i=-(n?o.top:o.left),s=n?window.innerHeight:window.innerWidth;i<0&&(s+=i,i=0),i+s>r&&(s=r-i),e={start:i,end:i+s}}else e=n?{start:t.scrollTop,end:t.scrollTop+t.clientHeight}:{start:t.scrollLeft,end:t.scrollLeft+t.clientWidth};return e},applyPageMode:function(){this.pageMode?this.addListeners():this.removeListeners()},addListeners:function(){this.listenerTarget=this.getListenerTarget(),this.listenerTarget.addEventListener("scroll",this.handleScroll,!!Ri&&{passive:!0}),this.listenerTarget.addEventListener("resize",this.handleResize)},removeListeners:function(){this.listenerTarget&&(this.listenerTarget.removeEventListener("scroll",this.handleScroll),this.listenerTarget.removeEventListener("resize",this.handleResize),this.listenerTarget=null)},scrollToItem:function(e){var t;t=null===this.itemSize?e>0?this.sizes[e-1].accumulator:0:e*this.itemSize,this.scrollToPosition(t)},scrollToPosition:function(e){"vertical"===this.direction?this.$el.scrollTop=e:this.$el.scrollLeft=e},itemsLimitError:function(){var e=this;throw setTimeout((function(){console.log("It seems the scroller element isn't scrolling, so it tries to render all the items at once.","Scroller:",e.$el),console.log("Make sure the scroller has a fixed height (or width) and 'overflow-y' (or 'overflow-x') set to 'auto' so it can scroll correctly and only render the items visible in the scroll viewport.")})),new Error("Rendered items limit reached")},sortViews:function(){this.pool.sort((function(e,t){return e.nr.index-t.nr.index}))}}},ji={key:0,class:"vue-recycle-scroller__slot"},Ti={key:1,class:"vue-recycle-scroller__slot"};Ii.render=function(e,n,o,i,s,c){var l=t.resolveComponent("ResizeObserver"),a=t.resolveDirective("observe-visibility");return t.withDirectives((t.openBlock(),t.createBlock("div",{class:["vue-recycle-scroller",r({ready:s.ready,"page-mode":o.pageMode},"direction-".concat(e.direction),!0)],onScrollPassive:n[2]||(n[2]=function(){return c.handleScroll&&c.handleScroll.apply(c,arguments)})},[e.$slots.before?(t.openBlock(),t.createBlock("div",ji,[t.renderSlot(e.$slots,"before")])):t.createCommentVNode("v-if",!0),t.createVNode("div",{ref:"wrapper",style:r({},"vertical"===e.direction?"minHeight":"minWidth",s.totalSize+"px"),class:"vue-recycle-scroller__item-wrapper"},[(t.openBlock(!0),t.createBlock(t.Fragment,null,t.renderList(s.pool,(function(o){return t.openBlock(),t.createBlock("div",{key:o.nr.id,style:s.ready?{transform:"translate".concat("vertical"===e.direction?"Y":"X","(").concat(o.position,"px)")}:null,class:["vue-recycle-scroller__item-view",{hover:s.hoverKey===o.nr.key}],onMouseenter:function(e){return s.hoverKey=o.nr.key},onMouseleave:n[1]||(n[1]=function(e){return s.hoverKey=null})},[t.renderSlot(e.$slots,"default",{item:o.item,index:o.nr.index,active:o.nr.used})],46,["onMouseenter"])})),128))],4),e.$slots.after?(t.openBlock(),t.createBlock("div",Ti,[t.renderSlot(e.$slots,"after")])):t.createCommentVNode("v-if",!0),t.createVNode(l,{onNotify:c.handleResize},null,8,["onNotify"])],34)),[[a,c.handleVisibilityChange]])},Ii.__file="src/components/RecycleScroller.vue";var Ai={name:"DynamicScroller",components:{RecycleScroller:Ii},inheritAttrs:!1,provide:function(){return"undefined"!=typeof ResizeObserver&&(this.$_resizeObserver=new ResizeObserver((function(e){var t,n=l(e);try{for(n.s();!(t=n.n()).done;){var o=t.value;if(o.target){var r=new CustomEvent("resize",{detail:{contentRect:o.contentRect}});o.target.dispatchEvent(r)}}}catch(e){n.e(e)}finally{n.f()}}))),{vscrollData:this.vscrollData,vscrollParent:this,vscrollResizeObserver:this.$_resizeObserver}},emits:["resize","visible","vscroll:update"],props:s({},zi,{minItemSize:{type:[Number,String],required:!0}}),data:function(){return{vscrollData:{active:!0,sizes:{},validSizes:{},keyField:this.keyField,simpleArray:!1}}},computed:{simpleArray:Di,itemsWithSize:function(){for(var e=[],t=this.items,n=this.keyField,o=this.simpleArray,r=this.vscrollData.sizes,i=0;i0&&void 0!==arguments[0])||arguments[0];(e||this.simpleArray)&&(this.vscrollData.validSizes={}),this.$emit("vscroll:update",{force:!0})},scrollToItem:function(e){var t=this.$refs.scroller;t&&t.scrollToItem(e)},getItemSize:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:void 0,n=this.simpleArray?null!=t?t:this.items.indexOf(e):e[this.keyField];return this.vscrollData.sizes[n]||0},scrollToBottom:function(){var e=this;if(!this.$_scrollingToBottom){this.$_scrollingToBottom=!0;var t=this.$el;this.$nextTick((function(){t.scrollTop=t.scrollHeight+5e3;requestAnimationFrame((function n(){t.scrollTop=t.scrollHeight+5e3,requestAnimationFrame((function(){t.scrollTop=t.scrollHeight+5e3,0===e.$_undefinedSizes?e.$_scrollingToBottom=!1:requestAnimationFrame(n)}))}))}))}}}};Ai.render=function(e,n,o,r,i,s){var c=t.resolveComponent("RecycleScroller");return t.openBlock(),t.createBlock(c,t.mergeProps({ref:"scroller",items:s.itemsWithSize,"min-item-size":o.minItemSize,direction:e.direction,"key-field":"id"},e.$attrs,{onResize:s.onScrollerResize,onVisible:s.onScrollerVisible},t.toHandlers(s.listeners)),{default:t.withCtx((function(n){var o=n.item,r=n.index,i=n.active;return[t.renderSlot(e.$slots,"default",{item:o.item,index:r,active:i,itemWithSize:o})]})),before:t.withCtx((function(){return[t.renderSlot(e.$slots,"before")]})),after:t.withCtx((function(){return[t.renderSlot(e.$slots,"after")]})),_:1},16,["items","min-item-size","direction","onResize","onVisible"])},Ai.__file="src/components/DynamicScroller.vue";var Mi={name:"DynamicScrollerItem",inject:["vscrollData","vscrollParent","vscrollResizeObserver"],props:{item:{required:!0},watchData:{type:Boolean,default:!1},active:{type:Boolean,required:!0},index:{type:Number,default:void 0},sizeDependencies:{type:[Array,Object],default:null},emitResize:{type:Boolean,default:!1},tag:{type:String,default:"div"}},computed:{id:function(){return this.vscrollData.simpleArray?this.index:this.item[this.vscrollData.keyField]},size:function(){return this.vscrollData.validSizes[this.id]&&this.vscrollData.sizes[this.id]||0},finalActive:function(){return this.active&&this.vscrollData.active}},watch:{watchData:"updateWatchData",id:function(){this.size||this.onDataUpdate()},finalActive:function(e){this.size||(e?this.vscrollParent.$_undefinedMap[this.id]||(this.vscrollParent.$_undefinedSizes++,this.vscrollParent.$_undefinedMap[this.id]=!0):this.vscrollParent.$_undefinedMap[this.id]&&(this.vscrollParent.$_undefinedSizes--,this.vscrollParent.$_undefinedMap[this.id]=!1)),this.vscrollResizeObserver?e?this.observeSize():this.unobserveSize():e&&this.$_pendingVScrollUpdate===this.id&&this.updateSize()}},created:function(){var e=this;if(!this.$isServer&&(this.$_forceNextVScrollUpdate=null,this.updateWatchData(),!this.vscrollResizeObserver)){var t=function(t){e.$watch((function(){return e.sizeDependencies[t]}),e.onDataUpdate)};for(var n in this.sizeDependencies)t(n);this.vscrollParent.$on("vscroll:update",this.onVscrollUpdate),this.vscrollParent.$on("vscroll:update-size",this.onVscrollUpdateSize)}},mounted:function(){this.vscrollData.active&&(this.updateSize(),this.observeSize())},beforeUnmount:function(){this.vscrollParent.$off("vscroll:update",this.onVscrollUpdate),this.vscrollParent.$off("vscroll:update-size",this.onVscrollUpdateSize),this.unobserveSize()},methods:{updateSize:function(){this.finalActive?this.$_pendingSizeUpdate!==this.id&&(this.$_pendingSizeUpdate=this.id,this.$_forceNextVScrollUpdate=null,this.$_pendingVScrollUpdate=null,this.computeSize(this.id)):this.$_forceNextVScrollUpdate=this.id},updateWatchData:function(){var e=this;this.watchData?this.$_watchData=this.$watch("data",(function(){e.onDataUpdate()}),{deep:!0}):this.$_watchData&&(this.$_watchData(),this.$_watchData=null)},onVscrollUpdate:function(e){var t=e.force;!this.finalActive&&t&&(this.$_pendingVScrollUpdate=this.id),this.$_forceNextVScrollUpdate!==this.id&&!t&&this.size||this.updateSize()},onDataUpdate:function(){this.updateSize()},computeSize:function(e){var t=this;this.$nextTick((function(){if(t.id===e){var n=t.$el.offsetWidth,o=t.$el.offsetHeight;t.applySize(n,o)}t.$_pendingSizeUpdate=null}))},applySize:function(e,t){var n=Math.round("vertical"===this.vscrollParent.direction?t:e);n&&this.size!==n&&(this.vscrollParent.$_undefinedMap[this.id]&&(this.vscrollParent.$_undefinedSizes--,this.vscrollParent.$_undefinedMap[this.id]=void 0),this.$set(this.vscrollData.sizes,this.id,n),this.$set(this.vscrollData.validSizes,this.id,!0),this.emitResize&&this.$emit("resize",this.id))},observeSize:function(){this.vscrollResizeObserver&&(this.vscrollResizeObserver.observe(this.$el.parentNode),this.$el.parentNode.addEventListener("resize",this.onResize))},unobserveSize:function(){this.vscrollResizeObserver&&(this.vscrollResizeObserver.unobserve(this.$el.parentNode),this.$el.parentNode.removeEventListener("resize",this.onResize))},onResize:function(e){var t=e.detail.contentRect,n=t.width,o=t.height;this.applySize(n,o)}},render:function(e){return e(this.tag,this.$slots.default)}};Mi.__file="src/components/DynamicScrollerItem.vue";var Ui={version:"1.0.99-ropez.2",install:function(e,t){var o=Object.assign({},{installComponents:!0,componentsPrefix:""},t);for(var r in o)void 0!==o[r]&&(n[r]=o[r]);o.installComponents&&function(e,t){e.component("".concat(t,"recycle-scroller"),Ii),e.component("".concat(t,"RecycleScroller"),Ii),e.component("".concat(t,"dynamic-scroller"),Ai),e.component("".concat(t,"DynamicScroller"),Ai),e.component("".concat(t,"dynamic-scroller-item"),Mi),e.component("".concat(t,"DynamicScrollerItem"),Mi)}(e,o.componentsPrefix)}},Fi=null;return"undefined"!=typeof window?Fi=window.Vue:"undefined"!=typeof global&&(Fi=global.Vue),Fi&&Fi.use(Ui),e.DynamicScroller=Ai,e.DynamicScrollerItem=Mi,e.IdState=function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=e.idProp,o=void 0===n?function(e){return e.item.id}:n,r=t.reactive({});return{data:function(){return{idState:null}},created:function(){var e=this;this.$_id=null,this.$_getId="function"==typeof o?function(){return o.call(e,e)}:function(){return e[o]},this.$watch(this.$_getId,{handler:function(e){var t=this;this.$nextTick((function(){t.$_id=e}))},immediate:!0}),this.$_updateIdState()},beforeUpdate:function(){this.$_updateIdState()},methods:{$_idStateInit:function(e){var t=this.$options.idState;if("function"==typeof t){var n=t.call(this,this);return r[e]=n,this.$_id=e,n}throw new Error("[mixin IdState] Missing `idState` function on component definition.")},$_updateIdState:function(){var e=this.$_getId();null==e&&console.warn("No id found for IdState with idProp: '".concat(o,"'.")),e!==this.$_id&&(r[e]||this.$_idStateInit(e),this.idState=r[e])}}}},e.RecycleScroller=Ii,e.default=Ui,e}({},vue); //# sourceMappingURL=vue-virtual-scroller.min.js.map diff --git a/dist/vue-virtual-scroller.min.js.map b/dist/vue-virtual-scroller.min.js.map index f3693c43..80757ce4 100644 --- a/dist/vue-virtual-scroller.min.js.map +++ b/dist/vue-virtual-scroller.min.js.map @@ -1 +1 @@ -{"version":3,"file":"vue-virtual-scroller.min.js","sources":["../src/config.js","../../vue-resize/dist/vue-resize.esm.js","../../vue-observe-visibility/dist/vue-observe-visibility.esm.js","../node_modules/scrollparent/scrollparent.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../src/components/RecycleScroller.vue?vue&type=template&id=093a936d&lang.js","../src/components/DynamicScroller.vue","../src/components/DynamicScroller.vue?vue&type=template&id=76e15f19&lang.js","../src/components/DynamicScrollerItem.vue","../src/index.js","../src/mixins/IdState.js"],"sourcesContent":["export default {\r\n itemsLimit: 1000,\r\n}\r\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction setCurrentRenderingInstance(instance) {\r\n currentRenderingInstance = instance;\r\n}\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n/**\r\n * Wrap a slot function to memoize current rendering instance\r\n * @private\r\n */\r\nfunction withCtx(fn, ctx = currentRenderingInstance) {\r\n if (!ctx)\r\n return fn;\r\n const renderFnWithContext = (...args) => {\r\n // If a user calls a compiled slot inside a template expression (#1745), it\r\n // can mess up block tracking, so by default we need to push a null block to\r\n // avoid that. This isn't necessary if rendering a compiled ``.\r\n if (!isRenderingCompiledSlot) {\r\n openBlock(true /* null block that disables tracking */);\r\n }\r\n const owner = currentRenderingInstance;\r\n setCurrentRenderingInstance(ctx);\r\n const res = fn(...args);\r\n setCurrentRenderingInstance(owner);\r\n if (!isRenderingCompiledSlot) {\r\n closeBlock();\r\n }\r\n return res;\r\n };\r\n renderFnWithContext._c = true;\r\n return renderFnWithContext;\r\n}\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\nconst scopeIdStack = [];\r\n/**\r\n * @private\r\n */\r\nfunction pushScopeId(id) {\r\n scopeIdStack.push((currentScopeId = id));\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction popScopeId() {\r\n scopeIdStack.pop();\r\n currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null;\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction withScopeId(id) {\r\n return ((fn) => withCtx(function () {\r\n pushScopeId(id);\r\n const res = fn.apply(this, arguments);\r\n popScopeId();\r\n return res;\r\n }));\r\n}\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\n// Since v-if and v-for are the two possible ways node structure can dynamically\r\n// change, once we consider v-if branches and each v-for fragment a block, we\r\n// can divide a template into nested blocks, and within each block the node\r\n// structure would be stable. This allows us to skip most children diffing\r\n// and only worry about the dynamic nodes (indicated by patch flags).\r\nconst blockStack = [];\r\nlet currentBlock = null;\r\n/**\r\n * Open a block.\r\n * This must be called before `createBlock`. It cannot be part of `createBlock`\r\n * because the children of the block are evaluated before `createBlock` itself\r\n * is called. The generated code typically looks like this:\r\n *\r\n * ```js\r\n * function render() {\r\n * return (openBlock(),createBlock('div', null, [...]))\r\n * }\r\n * ```\r\n * disableTracking is true when creating a v-for fragment block, since a v-for\r\n * fragment always diffs its children.\r\n *\r\n * @private\r\n */\r\nfunction openBlock(disableTracking = false) {\r\n blockStack.push((currentBlock = disableTracking ? null : []));\r\n}\r\nfunction closeBlock() {\r\n blockStack.pop();\r\n currentBlock = blockStack[blockStack.length - 1] || null;\r\n}\r\n/**\r\n * Create a block root vnode. Takes the same exact arguments as `createVNode`.\r\n * A block root keeps track of dynamic nodes within the block in the\r\n * `dynamicChildren` array.\r\n *\r\n * @private\r\n */\r\nfunction createBlock(type, props, children, patchFlag, dynamicProps) {\r\n const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */);\r\n // save current block children on the block vnode\r\n vnode.dynamicChildren = currentBlock || EMPTY_ARR;\r\n // close block\r\n closeBlock();\r\n // a block is always going to be patched, so track it as a child of its\r\n // parent block\r\n if ( currentBlock) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...( args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction getInternetExplorerVersion() {\n var ua = window.navigator.userAgent;\n var msie = ua.indexOf('MSIE ');\n\n if (msie > 0) {\n // IE 10 or older => return version number\n return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);\n }\n\n var trident = ua.indexOf('Trident/');\n\n if (trident > 0) {\n // IE 11 => return version number\n var rv = ua.indexOf('rv:');\n return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);\n }\n\n var edge = ua.indexOf('Edge/');\n\n if (edge > 0) {\n // Edge (IE 12+) => return version number\n return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);\n } // other browser\n\n\n return -1;\n}\n\nvar isIE;\n\nfunction initCompat() {\n if (!initCompat.init) {\n initCompat.init = true;\n isIE = getInternetExplorerVersion() !== -1;\n }\n}\n\nvar script = {\n name: 'ResizeObserver',\n mounted: function mounted() {\n var _this = this;\n\n initCompat();\n nextTick(function () {\n _this._w = _this.$el.offsetWidth;\n _this._h = _this.$el.offsetHeight;\n });\n var object = document.createElement('object');\n this._resizeObject = object;\n object.setAttribute('aria-hidden', 'true');\n object.setAttribute('tabindex', -1);\n object.onload = this.addResizeHandlers;\n object.type = 'text/html';\n\n if (isIE) {\n this.$el.appendChild(object);\n }\n\n object.data = 'about:blank';\n\n if (!isIE) {\n this.$el.appendChild(object);\n }\n },\n beforeUnmount: function beforeUnmount() {\n this.removeResizeHandlers();\n },\n methods: {\n compareAndNotify: function compareAndNotify() {\n if (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) {\n this._w = this.$el.offsetWidth;\n this._h = this.$el.offsetHeight;\n this.$emit('notify', {\n width: this._w,\n height: this._h\n });\n }\n },\n addResizeHandlers: function addResizeHandlers() {\n this._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify);\n\n this.compareAndNotify();\n },\n removeResizeHandlers: function removeResizeHandlers() {\n if (this._resizeObject && this._resizeObject.onload) {\n if (!isIE && this._resizeObject.contentDocument) {\n this._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify);\n }\n\n this.$el.removeChild(this._resizeObject);\n this._resizeObject.onload = null;\n this._resizeObject = null;\n }\n }\n }\n};\n\nvar _withId = /*#__PURE__*/withScopeId(\"data-v-b329ee4c\");\n\npushScopeId(\"data-v-b329ee4c\");\n\nvar _hoisted_1 = {\n class: \"resize-observer\",\n tabindex: \"-1\"\n};\n\npopScopeId();\n\nvar render = /*#__PURE__*/_withId(function (_ctx, _cache, $props, $setup, $data, $options) {\n return openBlock(), createBlock(\"div\", _hoisted_1);\n});\n\nscript.render = render;\nscript.__scopeId = \"data-v-b329ee4c\";\nscript.__file = \"src/components/ResizeObserver.vue\";\n\nfunction install(Vue) {\n Vue.component('resize-observer', script);\n Vue.component('ResizeObserver', script);\n}\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.5.0\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { script as ResizeObserver, install };\n//# sourceMappingURL=vue-resize.esm.js.map\n","function _typeof(obj) {\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n}\n\nfunction _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n return arr2;\n }\n}\n\nfunction _iterableToArray(iter) {\n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\n/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase());\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\nlet currentBlock = null;\r\n// Whether we should be tracking dynamic child nodes inside a block.\r\n// Only tracks when this value is > 0\r\n// We are not using a simple boolean because this value may need to be\r\n// incremented/decremented by nested usage of v-once (see below)\r\nlet shouldTrack$1 = 1;\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nlet vnodeArgsTransformer;\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...(vnodeArgsTransformer\r\n ? vnodeArgsTransformer(args, currentRenderingInstance)\r\n : args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (shouldTrack$1 > 0 &&\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nconst svgNS = 'http://www.w3.org/2000/svg';\r\nconst doc = (typeof document !== 'undefined' ? document : null);\r\nlet tempContainer;\r\nlet tempSVGContainer;\r\nconst nodeOps = {\r\n insert: (child, parent, anchor) => {\r\n parent.insertBefore(child, anchor || null);\r\n },\r\n remove: child => {\r\n const parent = child.parentNode;\r\n if (parent) {\r\n parent.removeChild(child);\r\n }\r\n },\r\n createElement: (tag, isSVG, is) => isSVG\r\n ? doc.createElementNS(svgNS, tag)\r\n : doc.createElement(tag, is ? { is } : undefined),\r\n createText: text => doc.createTextNode(text),\r\n createComment: text => doc.createComment(text),\r\n setText: (node, text) => {\r\n node.nodeValue = text;\r\n },\r\n setElementText: (el, text) => {\r\n el.textContent = text;\r\n },\r\n parentNode: node => node.parentNode,\r\n nextSibling: node => node.nextSibling,\r\n querySelector: selector => doc.querySelector(selector),\r\n setScopeId(el, id) {\r\n el.setAttribute(id, '');\r\n },\r\n cloneNode(el) {\r\n return el.cloneNode(true);\r\n },\r\n // __UNSAFE__\r\n // Reason: innerHTML.\r\n // Static content here can only come from compiled templates.\r\n // As long as the user only uses trusted templates, this is safe.\r\n insertStaticContent(content, parent, anchor, isSVG) {\r\n const temp = isSVG\r\n ? tempSVGContainer ||\r\n (tempSVGContainer = doc.createElementNS(svgNS, 'svg'))\r\n : tempContainer || (tempContainer = doc.createElement('div'));\r\n temp.innerHTML = content;\r\n const first = temp.firstChild;\r\n let node = first;\r\n let last = node;\r\n while (node) {\r\n last = node;\r\n nodeOps.insert(node, parent, anchor);\r\n node = temp.firstChild;\r\n }\r\n return [first, last];\r\n }\r\n};\n\n// compiler should normalize class + :class bindings on the same element\r\n// into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n if (value == null) {\r\n value = '';\r\n }\r\n if (isSVG) {\r\n el.setAttribute('class', value);\r\n }\r\n else {\r\n // directly setting className should be faster than setAttribute in theory\r\n // if this is an element during a transition, take the temporary transition\r\n // classes into account.\r\n const transitionClasses = el._vtc;\r\n if (transitionClasses) {\r\n value = (value\r\n ? [value, ...transitionClasses]\r\n : [...transitionClasses]).join(' ');\r\n }\r\n el.className = value;\r\n }\r\n}\n\nfunction patchStyle(el, prev, next) {\r\n const style = el.style;\r\n if (!next) {\r\n el.removeAttribute('style');\r\n }\r\n else if (isString(next)) {\r\n if (prev !== next) {\r\n style.cssText = next;\r\n }\r\n }\r\n else {\r\n for (const key in next) {\r\n setStyle(style, key, next[key]);\r\n }\r\n if (prev && !isString(prev)) {\r\n for (const key in prev) {\r\n if (next[key] == null) {\r\n setStyle(style, key, '');\r\n }\r\n }\r\n }\r\n }\r\n}\r\nconst importantRE = /\\s*!important$/;\r\nfunction setStyle(style, name, val) {\r\n if (isArray(val)) {\r\n val.forEach(v => setStyle(style, name, v));\r\n }\r\n else {\r\n if (name.startsWith('--')) {\r\n // custom property definition\r\n style.setProperty(name, val);\r\n }\r\n else {\r\n const prefixed = autoPrefix(style, name);\r\n if (importantRE.test(val)) {\r\n // !important\r\n style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');\r\n }\r\n else {\r\n style[prefixed] = val;\r\n }\r\n }\r\n }\r\n}\r\nconst prefixes = ['Webkit', 'Moz', 'ms'];\r\nconst prefixCache = {};\r\nfunction autoPrefix(style, rawName) {\r\n const cached = prefixCache[rawName];\r\n if (cached) {\r\n return cached;\r\n }\r\n let name = camelize(rawName);\r\n if (name !== 'filter' && name in style) {\r\n return (prefixCache[rawName] = name);\r\n }\r\n name = capitalize(name);\r\n for (let i = 0; i < prefixes.length; i++) {\r\n const prefixed = prefixes[i] + name;\r\n if (prefixed in style) {\r\n return (prefixCache[rawName] = prefixed);\r\n }\r\n }\r\n return rawName;\r\n}\n\nconst xlinkNS = 'http://www.w3.org/1999/xlink';\r\nfunction patchAttr(el, key, value, isSVG) {\r\n if (isSVG && key.startsWith('xlink:')) {\r\n if (value == null) {\r\n el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\r\n }\r\n else {\r\n el.setAttributeNS(xlinkNS, key, value);\r\n }\r\n }\r\n else {\r\n // note we are only checking boolean attributes that don't have a\r\n // corresponding dom prop of the same name here.\r\n const isBoolean = isSpecialBooleanAttr(key);\r\n if (value == null || (isBoolean && value === false)) {\r\n el.removeAttribute(key);\r\n }\r\n else {\r\n el.setAttribute(key, isBoolean ? '' : value);\r\n }\r\n }\r\n}\n\n// __UNSAFE__\r\n// functions. The user is responsible for using them with only trusted content.\r\nfunction patchDOMProp(el, key, value, \r\n// the following args are passed only due to potential innerHTML/textContent\r\n// overriding existing VNodes, in which case the old tree must be properly\r\n// unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n if (key === 'innerHTML' || key === 'textContent') {\r\n if (prevChildren) {\r\n unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n }\r\n el[key] = value == null ? '' : value;\r\n return;\r\n }\r\n if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n // store value as _value as well since\r\n // non-string values will be stringified.\r\n el._value = value;\r\n const newValue = value == null ? '' : value;\r\n if (el.value !== newValue) {\r\n el.value = newValue;\r\n }\r\n return;\r\n }\r\n if (value === '' || value == null) {\r\n const type = typeof el[key];\r\n if (value === '' && type === 'boolean') {\r\n // e.g. with\r\n // :true-value & :false-value\r\n // store value as dom properties since non-string values will be\r\n // stringified.\r\n if (key === 'true-value') {\r\n el._trueValue = nextValue;\r\n }\r\n else if (key === 'false-value') {\r\n el._falseValue = nextValue;\r\n }\r\n patchAttr(el, key, nextValue, isSVG);\r\n }\r\n break;\r\n }\r\n};\r\nfunction shouldSetAsProp(el, key, value, isSVG) {\r\n if (isSVG) {\r\n // most keys must be set as attribute on svg elements to work\r\n // ...except innerHTML\r\n if (key === 'innerHTML') {\r\n return true;\r\n }\r\n // or native onclick with function values\r\n if (key in el && nativeOnRE.test(key) && isFunction(value)) {\r\n return true;\r\n }\r\n return false;\r\n }\r\n // spellcheck and draggable are numerated attrs, however their\r\n // corresponding DOM properties are actually booleans - this leads to\r\n // setting it with a string \"false\" value leading it to be coerced to\r\n // `true`, so we need to always treat them as attributes.\r\n // Note that `contentEditable` doesn't have this problem: its DOM\r\n // property is also enumerated string values.\r\n if (key === 'spellcheck' || key === 'draggable') {\r\n return false;\r\n }\r\n // #1787 form as an attribute must be a string, while it accepts an Element as\r\n // a prop\r\n if (key === 'form' && typeof value === 'string') {\r\n return false;\r\n }\r\n // #1526 must be set as attribute\r\n if (key === 'list' && el.tagName === 'INPUT') {\r\n return false;\r\n }\r\n // native onclick with string value, must be set as attribute\r\n if (nativeOnRE.test(key) && isString(value)) {\r\n return false;\r\n }\r\n return key in el;\r\n}\n\nconst rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps);\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction processOptions(value) {\n var options;\n\n if (typeof value === 'function') {\n // Simple options (callback-only)\n options = {\n callback: value\n };\n } else {\n // Options object\n options = value;\n }\n\n return options;\n}\nfunction throttle(callback, delay) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var timeout;\n var lastState;\n var currentArgs;\n\n var throttled = function throttled(state) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n currentArgs = args;\n if (timeout && state === lastState) return;\n var leading = options.leading;\n\n if (typeof leading === 'function') {\n leading = leading(state, lastState);\n }\n\n if ((!timeout || state !== lastState) && leading) {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n }\n\n lastState = state;\n clearTimeout(timeout);\n timeout = setTimeout(function () {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n timeout = 0;\n }, delay);\n };\n\n throttled._clear = function () {\n clearTimeout(timeout);\n timeout = null;\n };\n\n return throttled;\n}\nfunction deepEqual(val1, val2) {\n if (val1 === val2) return true;\n\n if (_typeof(val1) === 'object') {\n for (var key in val1) {\n if (!deepEqual(val1[key], val2[key])) {\n return false;\n }\n }\n\n return true;\n }\n\n return false;\n}\n\nvar VisibilityState =\n/*#__PURE__*/\nfunction () {\n function VisibilityState(el, options, vnode) {\n _classCallCheck(this, VisibilityState);\n\n this.el = el;\n this.observer = null;\n this.frozen = false;\n this.createObserver(options, vnode);\n }\n\n _createClass(VisibilityState, [{\n key: \"createObserver\",\n value: function createObserver(options, vnode) {\n var _this = this;\n\n if (this.observer) {\n this.destroyObserver();\n }\n\n if (this.frozen) return;\n this.options = processOptions(options);\n\n this.callback = function (result, entry) {\n _this.options.callback(result, entry);\n\n if (result && _this.options.once) {\n _this.frozen = true;\n\n _this.destroyObserver();\n }\n }; // Throttle\n\n\n if (this.callback && this.options.throttle) {\n var _ref = this.options.throttleOptions || {},\n _leading = _ref.leading;\n\n this.callback = throttle(this.callback, this.options.throttle, {\n leading: function leading(state) {\n return _leading === 'both' || _leading === 'visible' && state || _leading === 'hidden' && !state;\n }\n });\n }\n\n this.oldResult = undefined;\n this.observer = new IntersectionObserver(function (entries) {\n var entry = entries[0];\n\n if (entries.length > 1) {\n var intersectingEntry = entries.find(function (e) {\n return e.isIntersecting;\n });\n\n if (intersectingEntry) {\n entry = intersectingEntry;\n }\n }\n\n if (_this.callback) {\n // Use isIntersecting if possible because browsers can report isIntersecting as true, but intersectionRatio as 0, when something very slowly enters the viewport.\n var result = entry.isIntersecting && entry.intersectionRatio >= _this.threshold;\n if (result === _this.oldResult) return;\n _this.oldResult = result;\n\n _this.callback(result, entry);\n }\n }, this.options.intersection); // Wait for the element to be in document\n\n nextTick(function () {\n if (_this.observer) {\n _this.observer.observe(_this.el);\n }\n });\n }\n }, {\n key: \"destroyObserver\",\n value: function destroyObserver() {\n if (this.observer) {\n this.observer.disconnect();\n this.observer = null;\n } // Cancel throttled call\n\n\n if (this.callback && this.callback._clear) {\n this.callback._clear();\n\n this.callback = null;\n }\n }\n }, {\n key: \"threshold\",\n get: function get() {\n return this.options.intersection && this.options.intersection.threshold || 0;\n }\n }]);\n\n return VisibilityState;\n}();\n\nfunction bind(el, _ref2, vnode) {\n var value = _ref2.value;\n if (!value) return;\n\n if (typeof IntersectionObserver === 'undefined') {\n console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');\n } else {\n var state = new VisibilityState(el, value, vnode);\n el._vue_visibilityState = state;\n }\n}\n\nfunction update(el, _ref3, vnode) {\n var value = _ref3.value,\n oldValue = _ref3.oldValue;\n if (deepEqual(value, oldValue)) return;\n var state = el._vue_visibilityState;\n\n if (!value) {\n unbind(el);\n return;\n }\n\n if (state) {\n state.createObserver(value, vnode);\n } else {\n bind(el, {\n value: value\n }, vnode);\n }\n}\n\nfunction unbind(el) {\n var state = el._vue_visibilityState;\n\n if (state) {\n state.destroyObserver();\n delete el._vue_visibilityState;\n }\n}\n\nvar ObserveVisibility = {\n beforeMount: bind,\n updated: update,\n unmounted: unbind\n};\n\nfunction install(Vue) {\n Vue.directive('observe-visibility', ObserveVisibility);\n /* -- Add more components here -- */\n}\n/* -- Plugin definition & Auto-install -- */\n\n/* You shouldn't have to modify the code below */\n// Plugin\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.4.6\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { ObserveVisibility, install };\n","(function (root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define([], factory);\n } else if (typeof module === \"object\" && module.exports) {\n module.exports = factory();\n } else {\n root.Scrollparent = factory();\n }\n}(this, function () {\n var regex = /(auto|scroll)/;\n\n var parents = function (node, ps) {\n if (node.parentNode === null) { return ps; }\n\n return parents(node.parentNode, ps.concat([node]));\n };\n\n var style = function (node, prop) {\n return getComputedStyle(node, null).getPropertyValue(prop);\n };\n\n var overflow = function (node) {\n return style(node, \"overflow\") + style(node, \"overflow-y\") + style(node, \"overflow-x\");\n };\n\n var scroll = function (node) {\n return regex.test(overflow(node));\n };\n\n var scrollParent = function (node) {\n if (!(node instanceof HTMLElement || node instanceof SVGElement)) {\n return ;\n }\n\n var ps = parents(node.parentNode, []);\n\n for (var i = 0; i < ps.length; i += 1) {\n if (scroll(ps[i])) {\n return ps[i];\n }\n }\n\n return document.scrollingElement || document.documentElement;\n };\n\n return scrollParent;\n}));\n","export const props = {\r\n items: {\r\n type: Array,\r\n required: true,\r\n },\r\n\r\n keyField: {\r\n type: String,\r\n default: 'id',\r\n },\r\n\r\n direction: {\r\n type: String,\r\n default: 'vertical',\r\n validator: (value) => ['vertical', 'horizontal'].includes(value),\r\n },\r\n}\r\n\r\nexport function simpleArray () {\r\n return this.items.length && typeof this.items[0] !== 'object'\r\n}\r\n","export let supportsPassive = false\r\n\r\nif (typeof window !== 'undefined') {\r\n supportsPassive = false\r\n try {\r\n var opts = Object.defineProperty({}, 'passive', {\r\n get () {\r\n supportsPassive = true\r\n },\r\n })\r\n window.addEventListener('test', null, opts)\r\n } catch (e) {}\r\n}\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n","import config from './config'\r\n\r\nimport RecycleScroller from './components/RecycleScroller.vue'\r\nimport DynamicScroller from './components/DynamicScroller.vue'\r\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\r\n\r\nexport { default as IdState } from './mixins/IdState'\r\n\r\nexport {\r\n RecycleScroller,\r\n DynamicScroller,\r\n DynamicScrollerItem,\r\n}\r\n\r\nfunction registerComponents (Vue, prefix) {\r\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\r\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\r\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\r\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\r\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\r\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\r\n}\r\n\r\nconst plugin = {\r\n // eslint-disable-next-line no-undef\r\n version: VERSION,\r\n install (Vue, options) {\r\n const finalOptions = Object.assign({}, {\r\n installComponents: true,\r\n componentsPrefix: '',\r\n }, options)\r\n\r\n for (const key in finalOptions) {\r\n if (typeof finalOptions[key] !== 'undefined') {\r\n config[key] = finalOptions[key]\r\n }\r\n }\r\n\r\n if (finalOptions.installComponents) {\r\n registerComponents(Vue, finalOptions.componentsPrefix)\r\n }\r\n },\r\n}\r\n\r\nexport default plugin\r\n\r\n// Auto-install\r\nlet GlobalVue = null\r\nif (typeof window !== 'undefined') {\r\n GlobalVue = window.Vue\r\n} else if (typeof global !== 'undefined') {\r\n GlobalVue = global.Vue\r\n}\r\nif (GlobalVue) {\r\n GlobalVue.use(plugin)\r\n}\r\n","import { reactive } from 'vue'\r\n\r\nexport default function ({\r\n idProp = vm => vm.item.id,\r\n} = {}) {\r\n const store = reactive({})\r\n\r\n // @vue/component\r\n return {\r\n data () {\r\n return {\r\n idState: null,\r\n }\r\n },\r\n\r\n created () {\r\n this.$_id = null\r\n if (typeof idProp === 'function') {\r\n this.$_getId = () => idProp.call(this, this)\r\n } else {\r\n this.$_getId = () => this[idProp]\r\n }\r\n this.$watch(this.$_getId, {\r\n handler (value) {\r\n this.$nextTick(() => {\r\n this.$_id = value\r\n })\r\n },\r\n immediate: true,\r\n })\r\n this.$_updateIdState()\r\n },\r\n\r\n beforeUpdate () {\r\n this.$_updateIdState()\r\n },\r\n\r\n methods: {\r\n /**\r\n * Initialize an idState\r\n * @param {number|string} id Unique id for the data\r\n */\r\n $_idStateInit (id) {\r\n const factory = this.$options.idState\r\n if (typeof factory === 'function') {\r\n const data = factory.call(this, this)\r\n store[id] = data\r\n this.$_id = id\r\n return data\r\n } else {\r\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\r\n }\r\n },\r\n\r\n /**\r\n * Ensure idState is created and up-to-date\r\n */\r\n $_updateIdState () {\r\n const id = this.$_getId()\r\n if (id == null) {\r\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\r\n }\r\n if (id !== this.$_id) {\r\n if (!store[id]) {\r\n this.$_idStateInit(id)\r\n }\r\n this.idState = store[id]\r\n }\r\n },\r\n },\r\n }\r\n}\r\n"],"names":["itemsLimit","makeMap","str","expectsLowerCase","map","Object","create","list","split","i","length","val","toLowerCase","isGloballyWhitelisted","normalizeStyle","value","isArray","res","item","normalized","isString","parseStringStyle","key","isObject","listDelimiterRE","propertyDelimiterRE","cssText","ret","forEach","tmp","trim","normalizeClass","name","fn","cache","_globalThis","EMPTY_OBJ","process","env","NODE_ENV","freeze","EMPTY_ARR","NOOP","onRE","isOn","test","extend","assign","remove","arr","el","indexOf","splice","hasOwnProperty","prototype","hasOwn","call","Array","isMap","toTypeString","isSet","isFunction","isSymbol","_typeof","objectToString","toString","toRawType","slice","isIntegerKey","parseInt","capitalize","charAt","toUpperCase","hasChanged","oldValue","then","catch","globalThis","self","window","global","obj","Symbol","_typeof2","iterator","constructor","_defineProperties","target","props","descriptor","enumerable","configurable","writable","defineProperty","_toConsumableArray","arr2","_arrayWithoutHoles","iter","from","_iterableToArray","TypeError","_nonIterableSpread","isSpecialBooleanAttr","activeEffect","isModelListener","startsWith","cacheStringFunction","camelizeRE","camelize","replace","_","c","hyphenateRE","hyphenate","targetMap","WeakMap","effectStack","ITERATE_KEY","MAP_KEY_ITERATE_KEY","isEffect","_isEffect","effect","options","raw","createReactiveEffect","lazy","stop","active","cleanup","onStop","uid","scheduler","undefined","includes","trackStack","push","shouldTrack","pop","resetTracking","id","allowRecurse","deps","delete","pauseTracking","last","track","type","depsMap","get","set","Map","dep","Set","has","add","onTrack","trigger","newValue","oldTarget","effects","effectsToAdd","onTrigger","builtInSymbols","getOwnPropertyNames","filter","createGetter","shallowGet","readonlyGet","shallowReadonlyGet","arrayInstrumentations","isReadonly","shallow","receiver","readonlyMap","reactiveMap","targetIsArray","Reflect","isRef","readonly","reactive","createSetter","toRaw","hadKey","Number","result","method","this","l","args","apply","mutableHandlers","deleteProperty","ownKeys","readonlyHandlers","console","warn","String","shallowReadonlyHandlers","toReactive","toReadonly","toShallow","getProto","v","getPrototypeOf","get$1","isShallow","rawTarget","rawKey","wrap","has$1","size","set$1","checkIdentityKeys","deleteEntry","clear","hadItems","createForEach","callback","thisArg","observed","createIterableMethod","targetIsMap","isPair","isKeyOnly","innerIterator","next","done","createReadonlyMethod","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","createInstrumentationGetter","instrumentations","mutableCollectionHandlers","readonlyCollectionHandlers","createReactiveObject","shallowReadonly","baseHandlers","collectionHandlers","proxyMap","existingProxy","targetType","isExtensible","rawType","targetTypeMap","proxy","Proxy","isReactive","isProxy","r","Boolean","__v_isRef","stack","pushWarningContext","vnode","popWarningContext","msg","instance","component","appWarnHandler","appContext","config","warnHandler","trace","getComponentTrace","callWithErrorHandling","join","formatComponentName","warnArgs","formatTrace","currentVNode","normalizedStack","recurseCount","parentInstance","parent","logs","entry","postfix","isRoot","open","close","keys","formatProp","JSON","stringify","formatProps","ErrorTypeStrings","err","handleError","callWithAsyncErrorHandling","values","throwInDev","contextVNode","cur","exposedInstance","errorInfo","errorCapturedHooks","ec","appErrorHandler","errorHandler","logError","info","error","isFlushing","isFlushPending","queue","flushIndex","pendingPreFlushCbs","activePreFlushCbs","preFlushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","Promise","resolve","currentFlushPromise","currentPreFlushParentJob","nextTick","p","bind","queueJob","job","queueFlush","flushJobs","queueCb","cb","activeQueue","pendingQueue","index","queuePreFlushCb","queuePostFlushCb","getId","Infinity","seen","flushPreFlushCbs","parentJob","checkRecursiveUpdates","sort","a","b","deduped","flushPostFlushCbs","count","Error","hmrDirtyComponents","__VUE_HMR_RUNTIME__","createRecord","tryWrap","isClassComponent","__vccOpts","instances","rerender","newRender","record","render","renderCache","update","reload","newComp","location","arg","e","isSuspense","__isSuspense","normalizeSuspenseChildren","content","fallback","shapeFlag","children","normalizeSuspenseSlot","default","normalizeVNode","s","singleChild","singleRoot","child","isVNode","Comment","filterSingleRoot","isRenderingCompiledSlot","setCompiledSlotRendering","n","INITIAL_WATCHER_VALUE","instanceWatch","source","publicThis","immediate","deep","flush","currentInstance","getter","warnInvalidSource","forceTrigger","_shallow","traverse","isUnmounted","onInvalidate","baseGetter","runner","queuePostRenderEffect","suspense","isMounted","recordInstanceBoundEffect","doWatch","pendingBranch","isTeleport","__isTeleport","NULL_DYNAMIC_COMPONENT","Fragment","Text","__v_isVNode","normalizeKey","normalizeRef","ref","createVNode","_createVNode","patchFlag","dynamicProps","cloned","cloneVNode","normalizeChildren","klass","class","style","ssContent","ssFallback","extraProps","mergeRef","mergedProps","mergeProps","concat","scopeId","targetAnchor","staticCount","dynamicChildren","dirs","transition","anchor","createTextVNode","text","flag","slot","_c","slotFlag","_ctx","arguments","toMerge","existing","incoming","mergeOptions","to","strats","optionMergeStrategies","mixins","extendsOptions","extends","m","publicPropertiesMap","$","$el","$data","data","$props","$attrs","attrs","$slots","slots","$refs","refs","$parent","getPublicInstance","$root","root","$emit","emit","$options","__VUE_OPTIONS_API__","__merged","globalMixins","resolveMergedOptions","$forceUpdate","$nextTick","$watch","PublicInstanceProxyHandlers","normalizedProps","ctx","setupState","accessCache","propsOptions","cssModule","globalProperties","publicGetter","__cssModules","unscopables","classifyRE","classify","Component","displayName","__file","match","inferFromRegistry","registry","components","initCustomFormatter","vueStyle","numberStyle","stringStyle","keywordStyle","formatter","header","__isVue","genRefFlag","formatValue","hasBody","body","blocks","createInstanceBlock","computed","extractKeys","injected","object","formatInstance","devtoolsFormatters","asRaw","Comp","extracted","isKeyOfType","opts","some","tempContainer","tempSVGContainer","svgNS","doc","document","nodeOps","insert","insertBefore","parentNode","removeChild","createElement","tag","isSVG","is","createElementNS","createText","createTextNode","createComment","setText","node","nodeValue","setElementText","textContent","nextSibling","querySelector","selector","setScopeId","setAttribute","cloneNode","insertStaticContent","temp","innerHTML","first","firstChild","patchClass","transitionClasses","_vtc","className","patchStyle","prev","setStyle","removeAttribute","importantRE","setProperty","prefixed","rawName","cached","prefixCache","prefixes","autoPrefix","xlinkNS","patchAttr","removeAttributeNS","setAttributeNS","isBoolean","patchDOMProp","prevChildren","parentComponent","parentSuspense","unmountChildren","tagName","_value","_getNow","Date","now","createEvent","timeStamp","performance","cachedNow","reset","addEventListener","event","handler","removeEventListener","patchEvent","prevValue","nextValue","invokers","_vei","existingInvoker","parseName","invoker","createInvoker","optionsModifierRE","initialValue","attached","originalStop","stopImmediatePropagation","_stopped","patchStopImmediatePropagation","nativeOnRE","shouldSetAsProp","patchProp","_trueValue","_falseValue","forcePatchProp","__VUE__","__VUE_DEVTOOLS_GLOBAL_HOOK__","initDev","VisibilityState","Constructor","_classCallCheck","observer","frozen","createObserver","protoProps","staticProps","_this","destroyObserver","once","throttle","_leading","throttleOptions","leading","delay","timeout","lastState","currentArgs","throttled","state","_len","_key","clearTimeout","setTimeout","_clear","oldResult","IntersectionObserver","entries","intersectingEntry","find","isIntersecting","intersectionRatio","threshold","intersection","observe","disconnect","_ref2","_vue_visibilityState","unbind","ObserveVisibility","beforeMount","updated","_ref3","deepEqual","val1","val2","unmounted","plugin","version","install","Vue","directive","GlobalVue","use","factory","regex","parents","ps","prop","getComputedStyle","getPropertyValue","scroll","overflow","HTMLElement","SVGElement","scrollingElement","documentElement","module","exports","Scrollparent","items","required","keyField","direction","validator","simpleArray","supportsPassive","ResizeObserver","directives","itemSize","minItemSize","sizeField","typeField","buffer","pageMode","prerender","emitUpdate","pool","totalSize","ready","hoverKey","sizes","current","accumulator","field","computedMinSize","$_computedMinItemSize","watch","updateVisibleItems","applyPageMode","created","$_startIndex","$_endIndex","$_views","$_unusedViews","$_scrollDirty","$_lastUpdateScrollPosition","$_prerender","mounted","beforeUnmount","removeListeners","methods","addView","view","shallowReactive","position","nr","used","unuseView","fake","unusedViews","unusedPool","handleResize","handleScroll","requestAnimationFrame","_this2","continuous","$_refreshTimout","handleVisibilityChange","isVisible","boundingClientRect","width","height","_this3","checkItem","startIndex","endIndex","checkPositionDiff","views","getScroll","positionDiff","start","end","oldI","Math","ceil","itemsLimitError","$_continuous","findIndex","unusedIndex","$_sortTimer","sortViews","getListenerTarget","ScrollParent","scrollState","isVertical","bounds","getBoundingClientRect","boundsSize","top","left","innerHeight","innerWidth","scrollTop","clientHeight","scrollLeft","clientWidth","addListeners","listenerTarget","passive","scrollToItem","scrollToPosition","log","_this4","viewA","viewB","_createBlock","before","_hoisted_1","_renderSlot","onMouseenter","onMouseleave","after","_hoisted_2","onNotify","RecycleScroller","inheritAttrs","provide","$_resizeObserver","CustomEvent","detail","contentRect","dispatchEvent","vscrollData","vscrollParent","vscrollResizeObserver","validSizes","itemsWithSize","$_undefinedMap","listeners","$listeners","forceUpdate","$_updates","$_undefinedSizes","activated","deactivated","onScrollerResize","scroller","onScrollerVisible","force","getItemSize","scrollToBottom","$_scrollingToBottom","scrollHeight","_mergeProps","onResize","onVisible","_toHandlers","_hoisted_3","inject","watchData","sizeDependencies","emitResize","finalActive","onDataUpdate","observeSize","unobserveSize","$_pendingVScrollUpdate","updateSize","$isServer","$_forceNextVScrollUpdate","updateWatchData","k","$on","onVscrollUpdate","onVscrollUpdateSize","$off","$_pendingSizeUpdate","computeSize","$_watchData","offsetWidth","offsetHeight","applySize","round","$set","unobserve","h","VERSION","finalOptions","installComponents","componentsPrefix","prefix","DynamicScroller","DynamicScrollerItem","registerComponents","idProp","vm","store","idState","$_id","$_getId","$_updateIdState","beforeUpdate","$_idStateInit"],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"vue-virtual-scroller.min.js","sources":["../src/config.js","../node_modules/vue-resize/dist/vue-resize.esm.js","../node_modules/vue-observe-visibility/dist/vue-observe-visibility.esm.js","../node_modules/scrollparent/scrollparent.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../src/components/RecycleScroller.vue?vue&type=template&id=093a936d&lang.js","../src/components/DynamicScroller.vue","../src/components/DynamicScroller.vue?vue&type=template&id=76e15f19&lang.js","../src/components/DynamicScrollerItem.vue","../src/index.js","../src/mixins/IdState.js"],"sourcesContent":["export default {\r\n itemsLimit: 1000,\r\n}\r\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction setCurrentRenderingInstance(instance) {\r\n currentRenderingInstance = instance;\r\n}\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n/**\r\n * Wrap a slot function to memoize current rendering instance\r\n * @private\r\n */\r\nfunction withCtx(fn, ctx = currentRenderingInstance) {\r\n if (!ctx)\r\n return fn;\r\n const renderFnWithContext = (...args) => {\r\n // If a user calls a compiled slot inside a template expression (#1745), it\r\n // can mess up block tracking, so by default we need to push a null block to\r\n // avoid that. This isn't necessary if rendering a compiled ``.\r\n if (!isRenderingCompiledSlot) {\r\n openBlock(true /* null block that disables tracking */);\r\n }\r\n const owner = currentRenderingInstance;\r\n setCurrentRenderingInstance(ctx);\r\n const res = fn(...args);\r\n setCurrentRenderingInstance(owner);\r\n if (!isRenderingCompiledSlot) {\r\n closeBlock();\r\n }\r\n return res;\r\n };\r\n renderFnWithContext._c = true;\r\n return renderFnWithContext;\r\n}\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\nconst scopeIdStack = [];\r\n/**\r\n * @private\r\n */\r\nfunction pushScopeId(id) {\r\n scopeIdStack.push((currentScopeId = id));\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction popScopeId() {\r\n scopeIdStack.pop();\r\n currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null;\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction withScopeId(id) {\r\n return ((fn) => withCtx(function () {\r\n pushScopeId(id);\r\n const res = fn.apply(this, arguments);\r\n popScopeId();\r\n return res;\r\n }));\r\n}\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\n// Since v-if and v-for are the two possible ways node structure can dynamically\r\n// change, once we consider v-if branches and each v-for fragment a block, we\r\n// can divide a template into nested blocks, and within each block the node\r\n// structure would be stable. This allows us to skip most children diffing\r\n// and only worry about the dynamic nodes (indicated by patch flags).\r\nconst blockStack = [];\r\nlet currentBlock = null;\r\n/**\r\n * Open a block.\r\n * This must be called before `createBlock`. It cannot be part of `createBlock`\r\n * because the children of the block are evaluated before `createBlock` itself\r\n * is called. The generated code typically looks like this:\r\n *\r\n * ```js\r\n * function render() {\r\n * return (openBlock(),createBlock('div', null, [...]))\r\n * }\r\n * ```\r\n * disableTracking is true when creating a v-for fragment block, since a v-for\r\n * fragment always diffs its children.\r\n *\r\n * @private\r\n */\r\nfunction openBlock(disableTracking = false) {\r\n blockStack.push((currentBlock = disableTracking ? null : []));\r\n}\r\nfunction closeBlock() {\r\n blockStack.pop();\r\n currentBlock = blockStack[blockStack.length - 1] || null;\r\n}\r\n/**\r\n * Create a block root vnode. Takes the same exact arguments as `createVNode`.\r\n * A block root keeps track of dynamic nodes within the block in the\r\n * `dynamicChildren` array.\r\n *\r\n * @private\r\n */\r\nfunction createBlock(type, props, children, patchFlag, dynamicProps) {\r\n const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */);\r\n // save current block children on the block vnode\r\n vnode.dynamicChildren = currentBlock || EMPTY_ARR;\r\n // close block\r\n closeBlock();\r\n // a block is always going to be patched, so track it as a child of its\r\n // parent block\r\n if ( currentBlock) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...( args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction getInternetExplorerVersion() {\n var ua = window.navigator.userAgent;\n var msie = ua.indexOf('MSIE ');\n\n if (msie > 0) {\n // IE 10 or older => return version number\n return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);\n }\n\n var trident = ua.indexOf('Trident/');\n\n if (trident > 0) {\n // IE 11 => return version number\n var rv = ua.indexOf('rv:');\n return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);\n }\n\n var edge = ua.indexOf('Edge/');\n\n if (edge > 0) {\n // Edge (IE 12+) => return version number\n return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);\n } // other browser\n\n\n return -1;\n}\n\nvar isIE;\n\nfunction initCompat() {\n if (!initCompat.init) {\n initCompat.init = true;\n isIE = getInternetExplorerVersion() !== -1;\n }\n}\n\nvar script = {\n name: 'ResizeObserver',\n mounted: function mounted() {\n var _this = this;\n\n initCompat();\n nextTick(function () {\n _this._w = _this.$el.offsetWidth;\n _this._h = _this.$el.offsetHeight;\n });\n var object = document.createElement('object');\n this._resizeObject = object;\n object.setAttribute('aria-hidden', 'true');\n object.setAttribute('tabindex', -1);\n object.onload = this.addResizeHandlers;\n object.type = 'text/html';\n\n if (isIE) {\n this.$el.appendChild(object);\n }\n\n object.data = 'about:blank';\n\n if (!isIE) {\n this.$el.appendChild(object);\n }\n },\n beforeUnmount: function beforeUnmount() {\n this.removeResizeHandlers();\n },\n methods: {\n compareAndNotify: function compareAndNotify() {\n if (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) {\n this._w = this.$el.offsetWidth;\n this._h = this.$el.offsetHeight;\n this.$emit('notify', {\n width: this._w,\n height: this._h\n });\n }\n },\n addResizeHandlers: function addResizeHandlers() {\n this._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify);\n\n this.compareAndNotify();\n },\n removeResizeHandlers: function removeResizeHandlers() {\n if (this._resizeObject && this._resizeObject.onload) {\n if (!isIE && this._resizeObject.contentDocument) {\n this._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify);\n }\n\n this.$el.removeChild(this._resizeObject);\n this._resizeObject.onload = null;\n this._resizeObject = null;\n }\n }\n }\n};\n\nvar _withId = /*#__PURE__*/withScopeId(\"data-v-b329ee4c\");\n\npushScopeId(\"data-v-b329ee4c\");\n\nvar _hoisted_1 = {\n class: \"resize-observer\",\n tabindex: \"-1\"\n};\n\npopScopeId();\n\nvar render = /*#__PURE__*/_withId(function (_ctx, _cache, $props, $setup, $data, $options) {\n return openBlock(), createBlock(\"div\", _hoisted_1);\n});\n\nscript.render = render;\nscript.__scopeId = \"data-v-b329ee4c\";\nscript.__file = \"src/components/ResizeObserver.vue\";\n\nfunction install(Vue) {\n Vue.component('resize-observer', script);\n Vue.component('ResizeObserver', script);\n}\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.9.0-ropez.1\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { script as ResizeObserver, install };\n//# sourceMappingURL=vue-resize.esm.js.map\n","function _typeof(obj) {\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n}\n\nfunction _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n return arr2;\n }\n}\n\nfunction _iterableToArray(iter) {\n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\n/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase());\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\nlet currentBlock = null;\r\n// Whether we should be tracking dynamic child nodes inside a block.\r\n// Only tracks when this value is > 0\r\n// We are not using a simple boolean because this value may need to be\r\n// incremented/decremented by nested usage of v-once (see below)\r\nlet shouldTrack$1 = 1;\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nlet vnodeArgsTransformer;\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...(vnodeArgsTransformer\r\n ? vnodeArgsTransformer(args, currentRenderingInstance)\r\n : args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (shouldTrack$1 > 0 &&\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nconst svgNS = 'http://www.w3.org/2000/svg';\r\nconst doc = (typeof document !== 'undefined' ? document : null);\r\nlet tempContainer;\r\nlet tempSVGContainer;\r\nconst nodeOps = {\r\n insert: (child, parent, anchor) => {\r\n parent.insertBefore(child, anchor || null);\r\n },\r\n remove: child => {\r\n const parent = child.parentNode;\r\n if (parent) {\r\n parent.removeChild(child);\r\n }\r\n },\r\n createElement: (tag, isSVG, is) => isSVG\r\n ? doc.createElementNS(svgNS, tag)\r\n : doc.createElement(tag, is ? { is } : undefined),\r\n createText: text => doc.createTextNode(text),\r\n createComment: text => doc.createComment(text),\r\n setText: (node, text) => {\r\n node.nodeValue = text;\r\n },\r\n setElementText: (el, text) => {\r\n el.textContent = text;\r\n },\r\n parentNode: node => node.parentNode,\r\n nextSibling: node => node.nextSibling,\r\n querySelector: selector => doc.querySelector(selector),\r\n setScopeId(el, id) {\r\n el.setAttribute(id, '');\r\n },\r\n cloneNode(el) {\r\n return el.cloneNode(true);\r\n },\r\n // __UNSAFE__\r\n // Reason: innerHTML.\r\n // Static content here can only come from compiled templates.\r\n // As long as the user only uses trusted templates, this is safe.\r\n insertStaticContent(content, parent, anchor, isSVG) {\r\n const temp = isSVG\r\n ? tempSVGContainer ||\r\n (tempSVGContainer = doc.createElementNS(svgNS, 'svg'))\r\n : tempContainer || (tempContainer = doc.createElement('div'));\r\n temp.innerHTML = content;\r\n const first = temp.firstChild;\r\n let node = first;\r\n let last = node;\r\n while (node) {\r\n last = node;\r\n nodeOps.insert(node, parent, anchor);\r\n node = temp.firstChild;\r\n }\r\n return [first, last];\r\n }\r\n};\n\n// compiler should normalize class + :class bindings on the same element\r\n// into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n if (value == null) {\r\n value = '';\r\n }\r\n if (isSVG) {\r\n el.setAttribute('class', value);\r\n }\r\n else {\r\n // directly setting className should be faster than setAttribute in theory\r\n // if this is an element during a transition, take the temporary transition\r\n // classes into account.\r\n const transitionClasses = el._vtc;\r\n if (transitionClasses) {\r\n value = (value\r\n ? [value, ...transitionClasses]\r\n : [...transitionClasses]).join(' ');\r\n }\r\n el.className = value;\r\n }\r\n}\n\nfunction patchStyle(el, prev, next) {\r\n const style = el.style;\r\n if (!next) {\r\n el.removeAttribute('style');\r\n }\r\n else if (isString(next)) {\r\n if (prev !== next) {\r\n style.cssText = next;\r\n }\r\n }\r\n else {\r\n for (const key in next) {\r\n setStyle(style, key, next[key]);\r\n }\r\n if (prev && !isString(prev)) {\r\n for (const key in prev) {\r\n if (next[key] == null) {\r\n setStyle(style, key, '');\r\n }\r\n }\r\n }\r\n }\r\n}\r\nconst importantRE = /\\s*!important$/;\r\nfunction setStyle(style, name, val) {\r\n if (isArray(val)) {\r\n val.forEach(v => setStyle(style, name, v));\r\n }\r\n else {\r\n if (name.startsWith('--')) {\r\n // custom property definition\r\n style.setProperty(name, val);\r\n }\r\n else {\r\n const prefixed = autoPrefix(style, name);\r\n if (importantRE.test(val)) {\r\n // !important\r\n style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');\r\n }\r\n else {\r\n style[prefixed] = val;\r\n }\r\n }\r\n }\r\n}\r\nconst prefixes = ['Webkit', 'Moz', 'ms'];\r\nconst prefixCache = {};\r\nfunction autoPrefix(style, rawName) {\r\n const cached = prefixCache[rawName];\r\n if (cached) {\r\n return cached;\r\n }\r\n let name = camelize(rawName);\r\n if (name !== 'filter' && name in style) {\r\n return (prefixCache[rawName] = name);\r\n }\r\n name = capitalize(name);\r\n for (let i = 0; i < prefixes.length; i++) {\r\n const prefixed = prefixes[i] + name;\r\n if (prefixed in style) {\r\n return (prefixCache[rawName] = prefixed);\r\n }\r\n }\r\n return rawName;\r\n}\n\nconst xlinkNS = 'http://www.w3.org/1999/xlink';\r\nfunction patchAttr(el, key, value, isSVG) {\r\n if (isSVG && key.startsWith('xlink:')) {\r\n if (value == null) {\r\n el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\r\n }\r\n else {\r\n el.setAttributeNS(xlinkNS, key, value);\r\n }\r\n }\r\n else {\r\n // note we are only checking boolean attributes that don't have a\r\n // corresponding dom prop of the same name here.\r\n const isBoolean = isSpecialBooleanAttr(key);\r\n if (value == null || (isBoolean && value === false)) {\r\n el.removeAttribute(key);\r\n }\r\n else {\r\n el.setAttribute(key, isBoolean ? '' : value);\r\n }\r\n }\r\n}\n\n// __UNSAFE__\r\n// functions. The user is responsible for using them with only trusted content.\r\nfunction patchDOMProp(el, key, value, \r\n// the following args are passed only due to potential innerHTML/textContent\r\n// overriding existing VNodes, in which case the old tree must be properly\r\n// unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n if (key === 'innerHTML' || key === 'textContent') {\r\n if (prevChildren) {\r\n unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n }\r\n el[key] = value == null ? '' : value;\r\n return;\r\n }\r\n if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n // store value as _value as well since\r\n // non-string values will be stringified.\r\n el._value = value;\r\n const newValue = value == null ? '' : value;\r\n if (el.value !== newValue) {\r\n el.value = newValue;\r\n }\r\n return;\r\n }\r\n if (value === '' || value == null) {\r\n const type = typeof el[key];\r\n if (value === '' && type === 'boolean') {\r\n // e.g. with\r\n // :true-value & :false-value\r\n // store value as dom properties since non-string values will be\r\n // stringified.\r\n if (key === 'true-value') {\r\n el._trueValue = nextValue;\r\n }\r\n else if (key === 'false-value') {\r\n el._falseValue = nextValue;\r\n }\r\n patchAttr(el, key, nextValue, isSVG);\r\n }\r\n break;\r\n }\r\n};\r\nfunction shouldSetAsProp(el, key, value, isSVG) {\r\n if (isSVG) {\r\n // most keys must be set as attribute on svg elements to work\r\n // ...except innerHTML\r\n if (key === 'innerHTML') {\r\n return true;\r\n }\r\n // or native onclick with function values\r\n if (key in el && nativeOnRE.test(key) && isFunction(value)) {\r\n return true;\r\n }\r\n return false;\r\n }\r\n // spellcheck and draggable are numerated attrs, however their\r\n // corresponding DOM properties are actually booleans - this leads to\r\n // setting it with a string \"false\" value leading it to be coerced to\r\n // `true`, so we need to always treat them as attributes.\r\n // Note that `contentEditable` doesn't have this problem: its DOM\r\n // property is also enumerated string values.\r\n if (key === 'spellcheck' || key === 'draggable') {\r\n return false;\r\n }\r\n // #1787 form as an attribute must be a string, while it accepts an Element as\r\n // a prop\r\n if (key === 'form' && typeof value === 'string') {\r\n return false;\r\n }\r\n // #1526 must be set as attribute\r\n if (key === 'list' && el.tagName === 'INPUT') {\r\n return false;\r\n }\r\n // native onclick with string value, must be set as attribute\r\n if (nativeOnRE.test(key) && isString(value)) {\r\n return false;\r\n }\r\n return key in el;\r\n}\n\nconst rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps);\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction processOptions(value) {\n var options;\n\n if (typeof value === 'function') {\n // Simple options (callback-only)\n options = {\n callback: value\n };\n } else {\n // Options object\n options = value;\n }\n\n return options;\n}\nfunction throttle(callback, delay) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var timeout;\n var lastState;\n var currentArgs;\n\n var throttled = function throttled(state) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n currentArgs = args;\n if (timeout && state === lastState) return;\n var leading = options.leading;\n\n if (typeof leading === 'function') {\n leading = leading(state, lastState);\n }\n\n if ((!timeout || state !== lastState) && leading) {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n }\n\n lastState = state;\n clearTimeout(timeout);\n timeout = setTimeout(function () {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n timeout = 0;\n }, delay);\n };\n\n throttled._clear = function () {\n clearTimeout(timeout);\n timeout = null;\n };\n\n return throttled;\n}\nfunction deepEqual(val1, val2) {\n if (val1 === val2) return true;\n\n if (_typeof(val1) === 'object') {\n for (var key in val1) {\n if (!deepEqual(val1[key], val2[key])) {\n return false;\n }\n }\n\n return true;\n }\n\n return false;\n}\n\nvar VisibilityState =\n/*#__PURE__*/\nfunction () {\n function VisibilityState(el, options, vnode) {\n _classCallCheck(this, VisibilityState);\n\n this.el = el;\n this.observer = null;\n this.frozen = false;\n this.createObserver(options, vnode);\n }\n\n _createClass(VisibilityState, [{\n key: \"createObserver\",\n value: function createObserver(options, vnode) {\n var _this = this;\n\n if (this.observer) {\n this.destroyObserver();\n }\n\n if (this.frozen) return;\n this.options = processOptions(options);\n\n this.callback = function (result, entry) {\n _this.options.callback(result, entry);\n\n if (result && _this.options.once) {\n _this.frozen = true;\n\n _this.destroyObserver();\n }\n }; // Throttle\n\n\n if (this.callback && this.options.throttle) {\n var _ref = this.options.throttleOptions || {},\n _leading = _ref.leading;\n\n this.callback = throttle(this.callback, this.options.throttle, {\n leading: function leading(state) {\n return _leading === 'both' || _leading === 'visible' && state || _leading === 'hidden' && !state;\n }\n });\n }\n\n this.oldResult = undefined;\n this.observer = new IntersectionObserver(function (entries) {\n var entry = entries[0];\n\n if (entries.length > 1) {\n var intersectingEntry = entries.find(function (e) {\n return e.isIntersecting;\n });\n\n if (intersectingEntry) {\n entry = intersectingEntry;\n }\n }\n\n if (_this.callback) {\n // Use isIntersecting if possible because browsers can report isIntersecting as true, but intersectionRatio as 0, when something very slowly enters the viewport.\n var result = entry.isIntersecting && entry.intersectionRatio >= _this.threshold;\n if (result === _this.oldResult) return;\n _this.oldResult = result;\n\n _this.callback(result, entry);\n }\n }, this.options.intersection); // Wait for the element to be in document\n\n nextTick(function () {\n if (_this.observer) {\n _this.observer.observe(_this.el);\n }\n });\n }\n }, {\n key: \"destroyObserver\",\n value: function destroyObserver() {\n if (this.observer) {\n this.observer.disconnect();\n this.observer = null;\n } // Cancel throttled call\n\n\n if (this.callback && this.callback._clear) {\n this.callback._clear();\n\n this.callback = null;\n }\n }\n }, {\n key: \"threshold\",\n get: function get() {\n return this.options.intersection && this.options.intersection.threshold || 0;\n }\n }]);\n\n return VisibilityState;\n}();\n\nfunction bind(el, _ref2, vnode) {\n var value = _ref2.value;\n if (!value) return;\n\n if (typeof IntersectionObserver === 'undefined') {\n console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');\n } else {\n var state = new VisibilityState(el, value, vnode);\n el._vue_visibilityState = state;\n }\n}\n\nfunction update(el, _ref3, vnode) {\n var value = _ref3.value,\n oldValue = _ref3.oldValue;\n if (deepEqual(value, oldValue)) return;\n var state = el._vue_visibilityState;\n\n if (!value) {\n unbind(el);\n return;\n }\n\n if (state) {\n state.createObserver(value, vnode);\n } else {\n bind(el, {\n value: value\n }, vnode);\n }\n}\n\nfunction unbind(el) {\n var state = el._vue_visibilityState;\n\n if (state) {\n state.destroyObserver();\n delete el._vue_visibilityState;\n }\n}\n\nvar ObserveVisibility = {\n beforeMount: bind,\n updated: update,\n unmounted: unbind\n};\n\nfunction install(Vue) {\n Vue.directive('observe-visibility', ObserveVisibility);\n /* -- Add more components here -- */\n}\n/* -- Plugin definition & Auto-install -- */\n\n/* You shouldn't have to modify the code below */\n// Plugin\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.9.0-ropez.1\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { ObserveVisibility, install };\n","(function (root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define([], factory);\n } else if (typeof module === \"object\" && module.exports) {\n module.exports = factory();\n } else {\n root.Scrollparent = factory();\n }\n}(this, function () {\n var regex = /(auto|scroll)/;\n\n var parents = function (node, ps) {\n if (node.parentNode === null) { return ps; }\n\n return parents(node.parentNode, ps.concat([node]));\n };\n\n var style = function (node, prop) {\n return getComputedStyle(node, null).getPropertyValue(prop);\n };\n\n var overflow = function (node) {\n return style(node, \"overflow\") + style(node, \"overflow-y\") + style(node, \"overflow-x\");\n };\n\n var scroll = function (node) {\n return regex.test(overflow(node));\n };\n\n var scrollParent = function (node) {\n if (!(node instanceof HTMLElement || node instanceof SVGElement)) {\n return ;\n }\n\n var ps = parents(node.parentNode, []);\n\n for (var i = 0; i < ps.length; i += 1) {\n if (scroll(ps[i])) {\n return ps[i];\n }\n }\n\n return document.scrollingElement || document.documentElement;\n };\n\n return scrollParent;\n}));\n","export const props = {\r\n items: {\r\n type: Array,\r\n required: true,\r\n },\r\n\r\n keyField: {\r\n type: String,\r\n default: 'id',\r\n },\r\n\r\n direction: {\r\n type: String,\r\n default: 'vertical',\r\n validator: (value) => ['vertical', 'horizontal'].includes(value),\r\n },\r\n}\r\n\r\nexport function simpleArray () {\r\n return this.items.length && typeof this.items[0] !== 'object'\r\n}\r\n","export let supportsPassive = false\r\n\r\nif (typeof window !== 'undefined') {\r\n supportsPassive = false\r\n try {\r\n var opts = Object.defineProperty({}, 'passive', {\r\n get () {\r\n supportsPassive = true\r\n },\r\n })\r\n window.addEventListener('test', null, opts)\r\n } catch (e) {}\r\n}\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n","import config from './config'\r\n\r\nimport RecycleScroller from './components/RecycleScroller.vue'\r\nimport DynamicScroller from './components/DynamicScroller.vue'\r\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\r\n\r\nexport { default as IdState } from './mixins/IdState'\r\n\r\nexport {\r\n RecycleScroller,\r\n DynamicScroller,\r\n DynamicScrollerItem,\r\n}\r\n\r\nfunction registerComponents (Vue, prefix) {\r\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\r\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\r\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\r\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\r\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\r\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\r\n}\r\n\r\nconst plugin = {\r\n // eslint-disable-next-line no-undef\r\n version: VERSION,\r\n install (Vue, options) {\r\n const finalOptions = Object.assign({}, {\r\n installComponents: true,\r\n componentsPrefix: '',\r\n }, options)\r\n\r\n for (const key in finalOptions) {\r\n if (typeof finalOptions[key] !== 'undefined') {\r\n config[key] = finalOptions[key]\r\n }\r\n }\r\n\r\n if (finalOptions.installComponents) {\r\n registerComponents(Vue, finalOptions.componentsPrefix)\r\n }\r\n },\r\n}\r\n\r\nexport default plugin\r\n\r\n// Auto-install\r\nlet GlobalVue = null\r\nif (typeof window !== 'undefined') {\r\n GlobalVue = window.Vue\r\n} else if (typeof global !== 'undefined') {\r\n GlobalVue = global.Vue\r\n}\r\nif (GlobalVue) {\r\n GlobalVue.use(plugin)\r\n}\r\n","import { reactive } from 'vue'\r\n\r\nexport default function ({\r\n idProp = vm => vm.item.id,\r\n} = {}) {\r\n const store = reactive({})\r\n\r\n // @vue/component\r\n return {\r\n data () {\r\n return {\r\n idState: null,\r\n }\r\n },\r\n\r\n created () {\r\n this.$_id = null\r\n if (typeof idProp === 'function') {\r\n this.$_getId = () => idProp.call(this, this)\r\n } else {\r\n this.$_getId = () => this[idProp]\r\n }\r\n this.$watch(this.$_getId, {\r\n handler (value) {\r\n this.$nextTick(() => {\r\n this.$_id = value\r\n })\r\n },\r\n immediate: true,\r\n })\r\n this.$_updateIdState()\r\n },\r\n\r\n beforeUpdate () {\r\n this.$_updateIdState()\r\n },\r\n\r\n methods: {\r\n /**\r\n * Initialize an idState\r\n * @param {number|string} id Unique id for the data\r\n */\r\n $_idStateInit (id) {\r\n const factory = this.$options.idState\r\n if (typeof factory === 'function') {\r\n const data = factory.call(this, this)\r\n store[id] = data\r\n this.$_id = id\r\n return data\r\n } else {\r\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\r\n }\r\n },\r\n\r\n /**\r\n * Ensure idState is created and up-to-date\r\n */\r\n $_updateIdState () {\r\n const id = this.$_getId()\r\n if (id == null) {\r\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\r\n }\r\n if (id !== this.$_id) {\r\n if (!store[id]) {\r\n this.$_idStateInit(id)\r\n }\r\n this.idState = store[id]\r\n }\r\n },\r\n },\r\n }\r\n}\r\n"],"names":["itemsLimit","makeMap","str","expectsLowerCase","map","Object","create","list","split","i","length","val","toLowerCase","isGloballyWhitelisted","normalizeStyle","value","isArray","res","item","normalized","isString","parseStringStyle","key","isObject","listDelimiterRE","propertyDelimiterRE","cssText","ret","forEach","tmp","trim","normalizeClass","name","EMPTY_OBJ","process","env","NODE_ENV","freeze","EMPTY_ARR","NOOP","onRE","isOn","test","extend","assign","hasOwnProperty","prototype","hasOwn","call","Array","isMap","toTypeString","isFunction","isSymbol","objectToString","toString","toRawType","slice","isIntegerKey","parseInt","capitalize","fn","cache","cacheStringFunction","charAt","toUpperCase","hasChanged","oldValue","_globalThis","targetMap","WeakMap","effectStack","activeEffect","ITERATE_KEY","Symbol","MAP_KEY_ITERATE_KEY","effect","options","_isEffect","isEffect","raw","active","scheduler","undefined","includes","cleanup","trackStack","push","shouldTrack","pop","resetTracking","id","uid","allowRecurse","deps","createReactiveEffect","lazy","stop","onStop","delete","pauseTracking","last","track","target","type","depsMap","get","set","Map","dep","Set","has","add","onTrack","trigger","newValue","oldTarget","effects","effectsToAdd","onTrigger","builtInSymbols","getOwnPropertyNames","filter","createGetter","shallowGet","readonlyGet","shallowReadonlyGet","arrayInstrumentations","isReadonly","shallow","receiver","readonlyMap","reactiveMap","targetIsArray","Reflect","isRef","readonly","reactive","createSetter","toRaw","hadKey","Number","result","method","args","arr","this","l","apply","mutableHandlers","deleteProperty","ownKeys","readonlyHandlers","console","warn","String","shallowReadonlyHandlers","toReactive","toReadonly","toShallow","getProto","v","getPrototypeOf","get$1","isShallow","rawTarget","rawKey","wrap","has$1","size","set$1","checkIdentityKeys","deleteEntry","clear","hadItems","createForEach","callback","thisArg","observed","createIterableMethod","targetIsMap","isPair","iterator","isKeyOnly","innerIterator","[object Object]","done","next","createReadonlyMethod","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","createInstrumentationGetter","instrumentations","mutableCollectionHandlers","readonlyCollectionHandlers","createReactiveObject","shallowReadonly","baseHandlers","collectionHandlers","proxyMap","existingProxy","targetType","isExtensible","rawType","targetTypeMap","proxy","Proxy","isReactive","isProxy","r","Boolean","__v_isRef","stack","msg","instance","component","appWarnHandler","appContext","config","warnHandler","trace","currentVNode","normalizedStack","vnode","recurseCount","parentInstance","parent","getComponentTrace","callWithErrorHandling","join","formatComponentName","warnArgs","logs","entry","postfix","isRoot","open","close","props","formatProps","formatTraceEntry","formatTrace","keys","formatProp","JSON","stringify","ErrorTypeStrings","bc","c","bm","m","bu","u","bum","um","a","da","ec","rtc","rtg","0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","err","handleError","callWithAsyncErrorHandling","then","catch","values","throwInDev","contextVNode","cur","exposedInstance","errorInfo","errorCapturedHooks","appErrorHandler","errorHandler","info","error","logError","isFlushing","isFlushPending","queue","flushIndex","pendingPreFlushCbs","activePreFlushCbs","preFlushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","Promise","resolve","currentFlushPromise","currentPreFlushParentJob","nextTick","p","bind","queueJob","job","queueFlush","flushJobs","queueCb","cb","activeQueue","pendingQueue","index","queuePostFlushCb","getId","Infinity","seen","flushPreFlushCbs","parentJob","checkRecursiveUpdates","sort","b","deduped","flushPostFlushCbs","count","Error","hmrDirtyComponents","global","self","window","__VUE_HMR_RUNTIME__","createRecord","tryWrap","isClassComponent","__vccOpts","instances","rerender","newRender","record","render","from","renderCache","update","reload","newComp","location","arg","e","currentRenderingInstance","setCurrentRenderingInstance","normalizeSuspenseSlot","s","singleChild","children","singleRoot","child","isVNode","Comment","filterSingleRoot","normalizeVNode","isRenderingCompiledSlot","setCompiledSlotRendering","n","currentScopeId","scopeIdStack","pushScopeId","popScopeId","withScopeId","ctx","renderFnWithContext","openBlock","owner","closeBlock","_c","withCtx","arguments","INITIAL_WATCHER_VALUE","doWatch","source","immediate","deep","flush","currentInstance","warnInvalidSource","getter","forceTrigger","_shallow","traverse","isUnmounted","onInvalidate","baseGetter","runner","queuePostRenderEffect","suspense","isMounted","queuePreFlushCb","recordInstanceBoundEffect","el","indexOf","splice","remove","instanceWatch","publicThis","pendingBranch","NULL_DYNAMIC_COMPONENT","Fragment","Text","blockStack","currentBlock","disableTracking","__v_isVNode","normalizeKey","normalizeRef","ref","createVNode","_createVNode","patchFlag","dynamicProps","isBlockNode","cloned","cloneVNode","normalizeChildren","class","klass","style","shapeFlag","__isSuspense","isSuspense","__isTeleport","isTeleport","__v_skip","scopeId","ssContent","ssFallback","dirs","transition","anchor","targetAnchor","staticCount","dynamicChildren","content","fallback","default","normalizeSuspenseChildren","extraProps","mergeRef","mergedProps","toMerge","existing","incoming","concat","mergeProps","createTextVNode","text","flag","slot","slotFlag","_","_ctx","mergeOptions","to","strats","optionMergeStrategies","mixins","extends","extendsOptions","getPublicInstance","publicPropertiesMap","$","$el","$data","data","$props","$attrs","attrs","$slots","slots","$refs","refs","$parent","$root","root","$emit","emit","$options","__VUE_OPTIONS_API__","__merged","globalMixins","resolveMergedOptions","$forceUpdate","$nextTick","$watch","PublicInstanceProxyHandlers","setupState","accessCache","normalizedProps","propsOptions","publicGetter","cssModule","globalProperties","__cssModules","defineProperty","enumerable","configurable","unscopables","classifyRE","Component","displayName","__file","match","inferFromRegistry","registry","components","replace","isIE","initCompat","init","ua","navigator","userAgent","msie","substring","rv","edge","getInternetExplorerVersion","globalThis","__VUE__","__VUE_DEVTOOLS_GLOBAL_HOOK__","vueStyle","numberStyle","stringStyle","keywordStyle","formatter","header","obj","__isVue","genRefFlag","formatValue","hasBody","formatInstance","blocks","createInstanceBlock","computed","extractKeys","injected","object","asRaw","Comp","extracted","isKeyOfType","opts","some","devtoolsFormatters","initCustomFormatter","initDev","script","mounted","_this","_w","offsetWidth","_h","offsetHeight","document","createElement","_resizeObject","setAttribute","onload","addResizeHandlers","appendChild","beforeUnmount","removeResizeHandlers","methods","compareAndNotify","width","height","contentDocument","defaultView","addEventListener","removeEventListener","removeChild","_withId","_hoisted_1","tabindex","_cache","$setup","createBlock","__scopeId","plugin","version","install","Vue","GlobalVue","_typeof","constructor","_defineProperties","descriptor","writable","_toConsumableArray","arr2","_arrayWithoutHoles","iter","_iterableToArray","TypeError","_nonIterableSpread","use","isSpecialBooleanAttr","camelizeRE","camelize","hyphenateRE","hyphenate","svgNS","doc","tempContainer","tempSVGContainer","nodeOps","insert","insertBefore","parentNode","tag","isSVG","is","createElementNS","createText","createTextNode","createComment","setText","node","nodeValue","setElementText","textContent","nextSibling","querySelector","selector","cloneNode","temp","innerHTML","first","firstChild","importantRE","setStyle","startsWith","setProperty","prefixed","rawName","cached","prefixCache","prefixes","autoPrefix","xlinkNS","_getNow","Date","now","createEvent","timeStamp","performance","cachedNow","reset","patchEvent","prevValue","nextValue","invokers","_vei","existingInvoker","optionsModifierRE","parseName","event","handler","initialValue","invoker","attached","originalStop","stopImmediatePropagation","_stopped","patchStopImmediatePropagation","getNow","createInvoker","nativeOnRE","patchProp","prevChildren","parentComponent","parentSuspense","unmountChildren","transitionClasses","_vtc","className","patchClass","prev","removeAttribute","patchStyle","isModelListener","tagName","shouldSetAsProp","_value","patchDOMProp","_trueValue","_falseValue","removeAttributeNS","setAttributeNS","isBoolean","patchAttr","forcePatchProp","VisibilityState","Constructor","_classCallCheck","observer","frozen","createObserver","protoProps","staticProps","destroyObserver","once","throttle","_leading","throttleOptions","leading","delay","timeout","lastState","currentArgs","throttled","state","_len","_key","clearTimeout","setTimeout","_clear","oldResult","IntersectionObserver","entries","intersectingEntry","find","isIntersecting","intersectionRatio","threshold","intersection","observe","disconnect","_ref2","_vue_visibilityState","unbind","ObserveVisibility","beforeMount","updated","_ref3","deepEqual","val1","val2","unmounted","directive","factory","regex","parents","ps","prop","getComputedStyle","getPropertyValue","scroll","overflow","HTMLElement","SVGElement","scrollingElement","documentElement","module","exports","Scrollparent","items","required","keyField","direction","validator","simpleArray","supportsPassive","ResizeObserver","directives","emits","itemSize","minItemSize","sizeField","typeField","buffer","pageMode","prerender","emitUpdate","pool","totalSize","ready","hoverKey","sizes","current","accumulator","field","computedMinSize","$_computedMinItemSize","watch","updateVisibleItems","applyPageMode","created","$_startIndex","$_endIndex","$_views","$_unusedViews","$_scrollDirty","$_lastUpdateScrollPosition","$_prerender","removeListeners","addView","view","shallowReactive","position","nr","used","unuseView","fake","unusedViews","unusedPool","handleResize","handleScroll","requestAnimationFrame","_this2","continuous","$_refreshTimout","handleVisibilityChange","isVisible","boundingClientRect","_this3","checkItem","startIndex","endIndex","checkPositionDiff","views","getScroll","positionDiff","start","end","oldI","Math","ceil","itemsLimitError","$_continuous","findIndex","unusedIndex","$_sortTimer","sortViews","getListenerTarget","ScrollParent","body","scrollState","isVertical","bounds","getBoundingClientRect","boundsSize","top","left","innerHeight","innerWidth","scrollTop","clientHeight","scrollLeft","clientWidth","addListeners","listenerTarget","passive","scrollToItem","scrollToPosition","log","_this4","viewA","viewB","_createBlock","before","_renderSlot","onMouseenter","onMouseleave","after","_hoisted_2","onNotify","RecycleScroller","inheritAttrs","provide","$_resizeObserver","CustomEvent","detail","contentRect","dispatchEvent","vscrollData","vscrollParent","vscrollResizeObserver","validSizes","itemsWithSize","$_undefinedMap","listeners","$listeners","forceUpdate","$_updates","$_undefinedSizes","activated","deactivated","onScrollerResize","scroller","onScrollerVisible","force","getItemSize","scrollToBottom","$_scrollingToBottom","scrollHeight","_mergeProps","onResize","onVisible","_toHandlers","itemWithSize","inject","watchData","sizeDependencies","emitResize","finalActive","onDataUpdate","observeSize","unobserveSize","$_pendingVScrollUpdate","updateSize","$isServer","$_forceNextVScrollUpdate","updateWatchData","k","$on","onVscrollUpdate","onVscrollUpdateSize","$off","$_pendingSizeUpdate","computeSize","$_watchData","applySize","round","$set","unobserve","h","VERSION","finalOptions","installComponents","componentsPrefix","prefix","DynamicScroller","DynamicScrollerItem","registerComponents","idProp","vm","store","idState","$_id","$_getId","$_updateIdState","beforeUpdate","$_idStateInit"],"mappings":"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"} \ No newline at end of file diff --git a/dist/vue-virtual-scroller.umd.js b/dist/vue-virtual-scroller.umd.js index 76b639c1..732b5dbc 100644 --- a/dist/vue-virtual-scroller.umd.js +++ b/dist/vue-virtual-scroller.umd.js @@ -73,53 +73,6 @@ return target; } - function _slicedToArray(arr, i) { - return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); - } - - function _toConsumableArray(arr) { - return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); - } - - function _arrayWithoutHoles(arr) { - if (Array.isArray(arr)) return _arrayLikeToArray(arr); - } - - function _arrayWithHoles(arr) { - if (Array.isArray(arr)) return arr; - } - - function _iterableToArray(iter) { - if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); - } - - function _iterableToArrayLimit(arr, i) { - if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; - var _arr = []; - var _n = true; - var _d = false; - var _e = undefined; - - try { - for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { - _arr.push(_s.value); - - if (i && _arr.length === i) break; - } - } catch (err) { - _d = true; - _e = err; - } finally { - try { - if (!_n && _i["return"] != null) _i["return"](); - } finally { - if (_d) throw _e; - } - } - - return _arr; - } - function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); @@ -137,14 +90,6 @@ return arr2; } - function _nonIterableSpread() { - throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); - } - - function _nonIterableRest() { - throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); - } - function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { @@ -200,6607 +145,5441 @@ }; } - var _ErrorTypeStrings; - /** * Make a map and return a function for checking if a key * is in that map. * IMPORTANT: all calls of this function must be prefixed with * \/\*#\_\_PURE\_\_\*\/ * So that rollup can tree-shake them if necessary. - */ - function makeMap(str, expectsLowerCase) { - var map = Object.create(null); - var list = str.split(','); - - for (var i = 0; i < list.length; i++) { - map[list[i]] = true; - } - - return expectsLowerCase ? function (val) { - return !!map[val.toLowerCase()]; - } : function (val) { - return !!map[val]; - }; - } - - var GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl'; - var isGloballyWhitelisted = /*#__PURE__*/makeMap(GLOBALS_WHITE_LISTED); - - function normalizeStyle(value) { - if (isArray(value)) { - var res = {}; - - for (var i = 0; i < value.length; i++) { - var item = value[i]; - var normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item); - - if (normalized) { - for (var key in normalized) { - res[key] = normalized[key]; - } - } - } - - return res; - } else if (isObject(value)) { - return value; - } - } - - var listDelimiterRE = /;(?![^(]*\))/g; - var propertyDelimiterRE = /:(.+)/; - - function parseStringStyle(cssText) { - var ret = {}; - cssText.split(listDelimiterRE).forEach(function (item) { - if (item) { - var tmp = item.split(propertyDelimiterRE); - tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); - } - }); - return ret; - } - - function normalizeClass(value) { - var res = ''; - - if (isString(value)) { - res = value; - } else if (isArray(value)) { - for (var i = 0; i < value.length; i++) { - res += normalizeClass(value[i]) + ' '; - } - } else if (isObject(value)) { - for (var name in value) { - if (value[name]) { - res += name + ' '; - } - } - } - - return res.trim(); - } - - var EMPTY_OBJ = process.env.NODE_ENV !== 'production' ? Object.freeze({}) : {}; - var EMPTY_ARR = process.env.NODE_ENV !== 'production' ? Object.freeze([]) : []; - - var NOOP = function NOOP() {}; - - var onRE = /^on[^a-z]/; - - var isOn = function isOn(key) { - return onRE.test(key); - }; - - var extend = Object.assign; - - var remove = function remove(arr, el) { - var i = arr.indexOf(el); - - if (i > -1) { - arr.splice(i, 1); - } - }; - - var hasOwnProperty = Object.prototype.hasOwnProperty; - - var hasOwn = function hasOwn(val, key) { - return hasOwnProperty.call(val, key); - }; - - var isArray = Array.isArray; - - var isMap = function isMap(val) { - return toTypeString(val) === '[object Map]'; - }; - - var isSet = function isSet(val) { - return toTypeString(val) === '[object Set]'; - }; - - var isFunction = function isFunction(val) { - return typeof val === 'function'; - }; - - var isString = function isString(val) { - return typeof val === 'string'; - }; - - var isSymbol = function isSymbol(val) { - return _typeof(val) === 'symbol'; - }; - - var isObject = function isObject(val) { - return val !== null && _typeof(val) === 'object'; - }; - - var isPromise = function isPromise(val) { - return isObject(val) && isFunction(val.then) && isFunction(val.catch); - }; - - var objectToString = Object.prototype.toString; - - var toTypeString = function toTypeString(value) { - return objectToString.call(value); - }; - - var toRawType = function toRawType(value) { - // extract "RawType" from strings like "[object RawType]" - return toTypeString(value).slice(8, -1); - }; - - var isIntegerKey = function isIntegerKey(key) { - return isString(key) && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key; - }; - - var cacheStringFunction = function cacheStringFunction(fn) { - var cache = Object.create(null); - return function (str) { - var hit = cache[str]; - return hit || (cache[str] = fn(str)); - }; - }; + */ + function makeMap(str, expectsLowerCase) { + const map = Object.create(null); + const list = str.split(','); + for (let i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val]; + } + + const GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + + 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + + 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl'; + const isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED); + + function normalizeStyle(value) { + if (isArray(value)) { + const res = {}; + for (let i = 0; i < value.length; i++) { + const item = value[i]; + const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item); + if (normalized) { + for (const key in normalized) { + res[key] = normalized[key]; + } + } + } + return res; + } + else if (isObject(value)) { + return value; + } + } + const listDelimiterRE = /;(?![^(]*\))/g; + const propertyDelimiterRE = /:(.+)/; + function parseStringStyle(cssText) { + const ret = {}; + cssText.split(listDelimiterRE).forEach(item => { + if (item) { + const tmp = item.split(propertyDelimiterRE); + tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); + } + }); + return ret; + } + function normalizeClass(value) { + let res = ''; + if (isString(value)) { + res = value; + } + else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + res += normalizeClass(value[i]) + ' '; + } + } + else if (isObject(value)) { + for (const name in value) { + if (value[name]) { + res += name + ' '; + } + } + } + return res.trim(); + } + const EMPTY_OBJ = (process.env.NODE_ENV !== 'production') + ? Object.freeze({}) + : {}; + const EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : []; + const NOOP = () => { }; + const onRE = /^on[^a-z]/; + const isOn = (key) => onRE.test(key); + 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 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.then) && isFunction(val.catch); + }; + const objectToString = Object.prototype.toString; + const toTypeString = (value) => objectToString.call(value); + const toRawType = (value) => { + // extract "RawType" from strings like "[object RawType]" + return toTypeString(value).slice(8, -1); + }; + const isIntegerKey = (key) => isString(key) && + key !== 'NaN' && + key[0] !== '-' && + '' + parseInt(key, 10) === key; + const cacheStringFunction = (fn) => { + const cache = Object.create(null); + return ((str) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }); + }; /** * @private - */ - - - var capitalize = cacheStringFunction(function (str) { - return str.charAt(0).toUpperCase() + str.slice(1); - }); // compare whether a value has changed, accounting for NaN. - - var hasChanged = function hasChanged(value, oldValue) { - return value !== oldValue && (value === value || oldValue === oldValue); + */ + const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1)); + // compare whether a value has changed, accounting for NaN. + const hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue); + let _globalThis; + const getGlobalThis = () => { + return (_globalThis || + (_globalThis = + typeof globalThis !== 'undefined' + ? globalThis + : typeof self !== 'undefined' + ? self + : typeof window !== 'undefined' + ? window + : typeof global !== 'undefined' + ? global + : {})); }; - var _globalThis; - - var getGlobalThis = function getGlobalThis() { - return _globalThis || (_globalThis = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {}); - }; - - var targetMap = new WeakMap(); - var effectStack = []; - var activeEffect; - var ITERATE_KEY = Symbol(process.env.NODE_ENV !== 'production' ? 'iterate' : ''); - var MAP_KEY_ITERATE_KEY = Symbol(process.env.NODE_ENV !== 'production' ? 'Map key iterate' : ''); - - function isEffect(fn) { - return fn && fn._isEffect === true; - } - - function effect(fn) { - var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_OBJ; - - if (isEffect(fn)) { - fn = fn.raw; - } - - var effect = createReactiveEffect(fn, options); - - if (!options.lazy) { - effect(); - } - - return effect; - } - - function stop(effect) { - if (effect.active) { - cleanup(effect); - - if (effect.options.onStop) { - effect.options.onStop(); - } - - effect.active = false; - } - } - - var uid = 0; - - function createReactiveEffect(fn, options) { - var effect = function reactiveEffect() { - if (!effect.active) { - return options.scheduler ? undefined : fn(); - } - - if (!effectStack.includes(effect)) { - cleanup(effect); - - try { - enableTracking(); - effectStack.push(effect); - activeEffect = effect; - return fn(); - } finally { - effectStack.pop(); - resetTracking(); - activeEffect = effectStack[effectStack.length - 1]; - } - } - }; - - effect.id = uid++; - effect.allowRecurse = !!options.allowRecurse; - effect._isEffect = true; - effect.active = true; - effect.raw = fn; - effect.deps = []; - effect.options = options; - return effect; - } - - function cleanup(effect) { - var deps = effect.deps; - - if (deps.length) { - for (var i = 0; i < deps.length; i++) { - deps[i].delete(effect); - } - - deps.length = 0; - } - } - - var shouldTrack = true; - var trackStack = []; - - function pauseTracking() { - trackStack.push(shouldTrack); - shouldTrack = false; - } - - function enableTracking() { - trackStack.push(shouldTrack); - shouldTrack = true; - } - - function resetTracking() { - var last = trackStack.pop(); - shouldTrack = last === undefined ? true : last; - } - - function track(target, type, key) { - if (!shouldTrack || activeEffect === undefined) { - return; - } - - var depsMap = targetMap.get(target); - - if (!depsMap) { - targetMap.set(target, depsMap = new Map()); - } - - var dep = depsMap.get(key); - - if (!dep) { - depsMap.set(key, dep = new Set()); - } - - if (!dep.has(activeEffect)) { - dep.add(activeEffect); - activeEffect.deps.push(dep); - - if (process.env.NODE_ENV !== 'production' && activeEffect.options.onTrack) { - activeEffect.options.onTrack({ - effect: activeEffect, - target: target, - type: type, - key: key - }); - } - } - } - - function trigger(target, type, key, newValue, oldValue, oldTarget) { - var depsMap = targetMap.get(target); - - if (!depsMap) { - // never been tracked - return; - } - - var effects = new Set(); - - var add = function add(effectsToAdd) { - if (effectsToAdd) { - effectsToAdd.forEach(function (effect) { - if (effect !== activeEffect || effect.allowRecurse) { - effects.add(effect); - } - }); - } - }; - - if (type === "clear" - /* CLEAR */ - ) { - // collection being cleared - // trigger all effects for target - depsMap.forEach(add); - } else if (key === 'length' && isArray(target)) { - depsMap.forEach(function (dep, key) { - if (key === 'length' || key >= newValue) { - add(dep); - } - }); - } else { - // schedule runs for SET | ADD | DELETE - if (key !== void 0) { - add(depsMap.get(key)); - } // also run for iteration key on ADD | DELETE | Map.SET - - - switch (type) { - case "add" - /* ADD */ - : - if (!isArray(target)) { - add(depsMap.get(ITERATE_KEY)); - - if (isMap(target)) { - add(depsMap.get(MAP_KEY_ITERATE_KEY)); - } - } else if (isIntegerKey(key)) { - // new index added to array -> length changes - add(depsMap.get('length')); - } - - break; - - case "delete" - /* DELETE */ - : - if (!isArray(target)) { - add(depsMap.get(ITERATE_KEY)); - - if (isMap(target)) { - add(depsMap.get(MAP_KEY_ITERATE_KEY)); - } - } - - break; - - case "set" - /* SET */ - : - if (isMap(target)) { - add(depsMap.get(ITERATE_KEY)); - } - - break; - } - } - - var run = function run(effect) { - if (process.env.NODE_ENV !== 'production' && effect.options.onTrigger) { - effect.options.onTrigger({ - effect: effect, - target: target, - key: key, - type: type, - newValue: newValue, - oldValue: oldValue, - oldTarget: oldTarget - }); - } - - if (effect.options.scheduler) { - effect.options.scheduler(effect); - } else { - effect(); - } - }; - - effects.forEach(run); - } - - var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map(function (key) { - return Symbol[key]; - }).filter(isSymbol)); - var get = /*#__PURE__*/createGetter(); - var shallowGet = /*#__PURE__*/createGetter(false, true); - var readonlyGet = /*#__PURE__*/createGetter(true); - var shallowReadonlyGet = /*#__PURE__*/createGetter(true, true); - var arrayInstrumentations = {}; - ['includes', 'indexOf', 'lastIndexOf'].forEach(function (key) { - var method = Array.prototype[key]; - - arrayInstrumentations[key] = function () { - var arr = toRaw(this); - - for (var i = 0, l = this.length; i < l; i++) { - track(arr, "get" - /* GET */ - , i + ''); - } // we run the method using the original args first (which may be reactive) - - - for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - var res = method.apply(arr, args); - - if (res === -1 || res === false) { - // if that didn't work, run it again using raw values. - return method.apply(arr, args.map(toRaw)); - } else { - return res; - } - }; - }); - ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(function (key) { - var method = Array.prototype[key]; - - arrayInstrumentations[key] = function () { - pauseTracking(); - - for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - var res = method.apply(this, args); - resetTracking(); - return res; - }; + const targetMap = new WeakMap(); + const effectStack = []; + let activeEffect; + const ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : ''); + const MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : ''); + function isEffect(fn) { + return fn && fn._isEffect === true; + } + function effect(fn, options = EMPTY_OBJ) { + if (isEffect(fn)) { + fn = fn.raw; + } + const effect = createReactiveEffect(fn, options); + if (!options.lazy) { + effect(); + } + return effect; + } + function stop(effect) { + if (effect.active) { + cleanup(effect); + if (effect.options.onStop) { + effect.options.onStop(); + } + effect.active = false; + } + } + let uid = 0; + function createReactiveEffect(fn, options) { + const effect = function reactiveEffect() { + if (!effect.active) { + return options.scheduler ? undefined : fn(); + } + if (!effectStack.includes(effect)) { + cleanup(effect); + try { + enableTracking(); + effectStack.push(effect); + activeEffect = effect; + return fn(); + } + finally { + effectStack.pop(); + resetTracking(); + activeEffect = effectStack[effectStack.length - 1]; + } + } + }; + effect.id = uid++; + effect.allowRecurse = !!options.allowRecurse; + effect._isEffect = true; + effect.active = true; + effect.raw = fn; + effect.deps = []; + effect.options = options; + return effect; + } + function cleanup(effect) { + const { deps } = effect; + if (deps.length) { + for (let i = 0; i < deps.length; i++) { + deps[i].delete(effect); + } + deps.length = 0; + } + } + 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 === undefined ? true : last; + } + function track(target, type, key) { + if (!shouldTrack || activeEffect === undefined) { + return; + } + let depsMap = targetMap.get(target); + if (!depsMap) { + targetMap.set(target, (depsMap = new Map())); + } + let dep = depsMap.get(key); + if (!dep) { + depsMap.set(key, (dep = new Set())); + } + if (!dep.has(activeEffect)) { + dep.add(activeEffect); + activeEffect.deps.push(dep); + if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) { + activeEffect.options.onTrack({ + effect: activeEffect, + target, + type, + key + }); + } + } + } + function trigger(target, type, key, newValue, oldValue, oldTarget) { + const depsMap = targetMap.get(target); + if (!depsMap) { + // never been tracked + return; + } + const effects = new Set(); + const add = (effectsToAdd) => { + if (effectsToAdd) { + effectsToAdd.forEach(effect => { + if (effect !== activeEffect || effect.allowRecurse) { + effects.add(effect); + } + }); + } + }; + if (type === "clear" /* CLEAR */) { + // collection being cleared + // trigger all effects for target + depsMap.forEach(add); + } + else if (key === 'length' && isArray(target)) { + depsMap.forEach((dep, key) => { + if (key === 'length' || key >= newValue) { + add(dep); + } + }); + } + else { + // schedule runs for SET | ADD | DELETE + if (key !== void 0) { + add(depsMap.get(key)); + } + // also run for iteration key on ADD | DELETE | Map.SET + switch (type) { + case "add" /* ADD */: + if (!isArray(target)) { + add(depsMap.get(ITERATE_KEY)); + if (isMap(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + else if (isIntegerKey(key)) { + // new index added to array -> length changes + add(depsMap.get('length')); + } + break; + case "delete" /* DELETE */: + if (!isArray(target)) { + add(depsMap.get(ITERATE_KEY)); + if (isMap(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + break; + case "set" /* SET */: + if (isMap(target)) { + add(depsMap.get(ITERATE_KEY)); + } + break; + } + } + const run = (effect) => { + if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) { + effect.options.onTrigger({ + effect, + target, + key, + type, + newValue, + oldValue, + oldTarget + }); + } + if (effect.options.scheduler) { + effect.options.scheduler(effect); + } + else { + effect(); + } + }; + effects.forEach(run); + } + + const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol) + .map(key => Symbol[key]) + .filter(isSymbol)); + const get = /*#__PURE__*/ createGetter(); + const shallowGet = /*#__PURE__*/ createGetter(false, true); + const readonlyGet = /*#__PURE__*/ createGetter(true); + const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true); + const arrayInstrumentations = {}; + ['includes', 'indexOf', 'lastIndexOf'].forEach(key => { + const method = Array.prototype[key]; + arrayInstrumentations[key] = function (...args) { + const arr = toRaw(this); + for (let i = 0, l = this.length; i < l; i++) { + track(arr, "get" /* GET */, i + ''); + } + // we run the method using the original args first (which may be reactive) + const res = method.apply(arr, args); + if (res === -1 || res === false) { + // if that didn't work, run it again using raw values. + return method.apply(arr, args.map(toRaw)); + } + else { + return res; + } + }; + }); + ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => { + const method = Array.prototype[key]; + arrayInstrumentations[key] = function (...args) { + pauseTracking(); + const res = method.apply(this, args); + resetTracking(); + return res; + }; + }); + function createGetter(isReadonly = false, shallow = false) { + return function get(target, key, receiver) { + if (key === "__v_isReactive" /* IS_REACTIVE */) { + return !isReadonly; + } + else if (key === "__v_isReadonly" /* IS_READONLY */) { + return isReadonly; + } + else if (key === "__v_raw" /* RAW */ && + receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) { + return target; + } + const targetIsArray = isArray(target); + if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver); + } + const res = Reflect.get(target, key, receiver); + if (isSymbol(key) + ? builtInSymbols.has(key) + : key === `__proto__` || key === `__v_isRef`) { + return res; + } + if (!isReadonly) { + track(target, "get" /* GET */, key); + } + if (shallow) { + return res; + } + if (isRef(res)) { + // ref unwrapping - does not apply for Array + integer key. + const shouldUnwrap = !targetIsArray || !isIntegerKey(key); + return shouldUnwrap ? res.value : res; + } + if (isObject(res)) { + // Convert returned value into a proxy as well. we do the isObject check + // here to avoid invalid value warning. Also need to lazy access readonly + // and reactive here to avoid circular dependency. + return isReadonly ? readonly(res) : reactive(res); + } + return res; + }; + } + const set = /*#__PURE__*/ createSetter(); + const shallowSet = /*#__PURE__*/ createSetter(true); + function createSetter(shallow = false) { + return function set(target, key, value, receiver) { + const oldValue = target[key]; + if (!shallow) { + value = toRaw(value); + if (!isArray(target) && isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } + } + const hadKey = isArray(target) && isIntegerKey(key) + ? Number(key) < target.length + : hasOwn(target, key); + const result = Reflect.set(target, key, value, receiver); + // don't trigger if target is something up in the prototype chain of original + if (target === toRaw(receiver)) { + if (!hadKey) { + trigger(target, "add" /* ADD */, key, value); + } + else if (hasChanged(value, oldValue)) { + trigger(target, "set" /* SET */, key, value, oldValue); + } + } + return result; + }; + } + function deleteProperty(target, key) { + const hadKey = hasOwn(target, key); + const oldValue = target[key]; + const result = Reflect.deleteProperty(target, key); + if (result && hadKey) { + trigger(target, "delete" /* DELETE */, key, undefined, oldValue); + } + return result; + } + function has(target, key) { + const result = Reflect.has(target, key); + if (!isSymbol(key) || !builtInSymbols.has(key)) { + track(target, "has" /* HAS */, key); + } + return result; + } + function ownKeys$1(target) { + track(target, "iterate" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY); + return Reflect.ownKeys(target); + } + const mutableHandlers = { + get, + set, + deleteProperty, + has, + ownKeys: ownKeys$1 + }; + const readonlyHandlers = { + get: readonlyGet, + set(target, key) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + }, + deleteProperty(target, key) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + } + }; + const shallowReactiveHandlers = extend({}, mutableHandlers, { + get: shallowGet, + set: shallowSet + }); + // Props handlers are special in the sense that it should not unwrap top-level + // refs (in order to allow refs to be explicitly passed down), but should + // retain the reactivity of the normal readonly object. + const shallowReadonlyHandlers = extend({}, readonlyHandlers, { + get: shallowReadonlyGet }); - function createGetter() { - var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - var shallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; - return function get(target, key, receiver) { - if (key === "__v_isReactive" - /* IS_REACTIVE */ - ) { - return !isReadonly; - } else if (key === "__v_isReadonly" - /* IS_READONLY */ - ) { - return isReadonly; - } else if (key === "__v_raw" - /* RAW */ - && receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) { - return target; - } - - var targetIsArray = isArray(target); - - if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) { - return Reflect.get(arrayInstrumentations, key, receiver); - } - - var res = Reflect.get(target, key, receiver); - - if (isSymbol(key) ? builtInSymbols.has(key) : key === "__proto__" || key === "__v_isRef") { - return res; - } - - if (!isReadonly) { - track(target, "get" - /* GET */ - , key); - } - - if (shallow) { - return res; - } - - if (isRef(res)) { - // ref unwrapping - does not apply for Array + integer key. - var shouldUnwrap = !targetIsArray || !isIntegerKey(key); - return shouldUnwrap ? res.value : res; - } - - if (isObject(res)) { - // Convert returned value into a proxy as well. we do the isObject check - // here to avoid invalid value warning. Also need to lazy access readonly - // and reactive here to avoid circular dependency. - return isReadonly ? readonly(res) : reactive(res); - } - - return res; - }; - } - - var set = /*#__PURE__*/createSetter(); - var shallowSet = /*#__PURE__*/createSetter(true); - - function createSetter() { - var shallow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - return function set(target, key, value, receiver) { - var oldValue = target[key]; - - if (!shallow) { - value = toRaw(value); - - if (!isArray(target) && isRef(oldValue) && !isRef(value)) { - oldValue.value = value; - return true; - } - } - - var hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key); - var result = Reflect.set(target, key, value, receiver); // don't trigger if target is something up in the prototype chain of original - - if (target === toRaw(receiver)) { - if (!hadKey) { - trigger(target, "add" - /* ADD */ - , key, value); - } else if (hasChanged(value, oldValue)) { - trigger(target, "set" - /* SET */ - , key, value, oldValue); - } - } - - return result; - }; - } - - function deleteProperty(target, key) { - var hadKey = hasOwn(target, key); - var oldValue = target[key]; - var result = Reflect.deleteProperty(target, key); - - if (result && hadKey) { - trigger(target, "delete" - /* DELETE */ - , key, undefined, oldValue); - } - - return result; - } - - function has(target, key) { - var result = Reflect.has(target, key); + const toReactive = (value) => isObject(value) ? reactive(value) : value; + const toReadonly = (value) => isObject(value) ? readonly(value) : value; + const toShallow = (value) => value; + const getProto = (v) => Reflect.getPrototypeOf(v); + function get$1(target, key, isReadonly = false, isShallow = false) { + // #1772: readonly(reactive(Map)) should return readonly + reactive version + // of the value + target = target["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly && track(rawTarget, "get" /* GET */, key); + } + !isReadonly && track(rawTarget, "get" /* GET */, rawKey); + const { has } = getProto(rawTarget); + const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; + if (has.call(rawTarget, key)) { + return wrap(target.get(key)); + } + else if (has.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } + } + function has$1(key, isReadonly = false) { + const target = this["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly && track(rawTarget, "has" /* HAS */, key); + } + !isReadonly && track(rawTarget, "has" /* HAS */, rawKey); + return key === rawKey + ? target.has(key) + : target.has(key) || target.has(rawKey); + } + function size(target, isReadonly = false) { + target = target["__v_raw" /* RAW */]; + !isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY); + return Reflect.get(target, 'size', target); + } + function add(value) { + value = toRaw(value); + const target = toRaw(this); + const proto = getProto(target); + const hadKey = proto.has.call(target, value); + target.add(value); + if (!hadKey) { + trigger(target, "add" /* ADD */, value, value); + } + return this; + } + function set$1(key, 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 ((process.env.NODE_ENV !== 'production')) { + checkIdentityKeys(target, has, key); + } + const oldValue = get.call(target, key); + target.set(key, value); + if (!hadKey) { + trigger(target, "add" /* ADD */, key, value); + } + else if (hasChanged(value, oldValue)) { + trigger(target, "set" /* SET */, key, value, oldValue); + } + return this; + } + function deleteEntry(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 ((process.env.NODE_ENV !== 'production')) { + checkIdentityKeys(target, has, key); + } + const oldValue = get ? get.call(target, key) : undefined; + // forward the operation before queueing reactions + const result = target.delete(key); + if (hadKey) { + trigger(target, "delete" /* DELETE */, key, undefined, oldValue); + } + return result; + } + function clear() { + const target = toRaw(this); + const hadItems = target.size !== 0; + const oldTarget = (process.env.NODE_ENV !== 'production') + ? isMap(target) + ? new Map(target) + : new Set(target) + : undefined; + // forward the operation before queueing reactions + const result = target.clear(); + if (hadItems) { + trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget); + } + return result; + } + function createForEach(isReadonly, isShallow) { + return function forEach(callback, thisArg) { + const observed = this; + const target = observed["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; + !isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY); + return target.forEach((value, key) => { + // important: make sure the callback is + // 1. invoked with the reactive map as `this` and 3rd arg + // 2. the value received should be a corresponding reactive/readonly. + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; + } + function createIterableMethod(method, isReadonly, isShallow) { + return function (...args) { + const target = this["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const targetIsMap = isMap(rawTarget); + const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap); + const isKeyOnly = method === 'keys' && targetIsMap; + const innerIterator = target[method](...args); + const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; + !isReadonly && + track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); + // return a wrapped iterator which returns observed versions of the + // values emitted from the real iterator + 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 ((process.env.NODE_ENV !== 'production')) { + const key = args[0] ? `on key "${args[0]}" ` : ``; + console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this)); + } + return type === "delete" /* DELETE */ ? false : this; + }; + } + const mutableInstrumentations = { + get(key) { + return get$1(this, key); + }, + get size() { + return size(this); + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, false) + }; + const shallowInstrumentations = { + get(key) { + return get$1(this, key, false, true); + }, + get size() { + return size(this); + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, true) + }; + const readonlyInstrumentations = { + get(key) { + return get$1(this, key, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod("add" /* ADD */), + set: createReadonlyMethod("set" /* SET */), + delete: createReadonlyMethod("delete" /* DELETE */), + clear: createReadonlyMethod("clear" /* CLEAR */), + forEach: createForEach(true, false) + }; + const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]; + iteratorMethods.forEach(method => { + mutableInstrumentations[method] = createIterableMethod(method, false, false); + readonlyInstrumentations[method] = createIterableMethod(method, true, false); + shallowInstrumentations[method] = createIterableMethod(method, false, true); + }); + function createInstrumentationGetter(isReadonly, shallow) { + const instrumentations = shallow + ? shallowInstrumentations + : isReadonly + ? readonlyInstrumentations + : mutableInstrumentations; + return (target, key, receiver) => { + if (key === "__v_isReactive" /* IS_REACTIVE */) { + return !isReadonly; + } + else if (key === "__v_isReadonly" /* IS_READONLY */) { + return isReadonly; + } + else if (key === "__v_raw" /* RAW */) { + return target; + } + return Reflect.get(hasOwn(instrumentations, key) && key in target + ? instrumentations + : target, key, receiver); + }; + } + const mutableCollectionHandlers = { + get: createInstrumentationGetter(false, false) + }; + const readonlyCollectionHandlers = { + get: createInstrumentationGetter(true, false) + }; + function checkIdentityKeys(target, has, key) { + const rawKey = toRaw(key); + if (rawKey !== key && has.call(target, rawKey)) { + const type = toRawType(target); + console.warn(`Reactive ${type} contains both the raw and reactive ` + + `versions of the same object${type === `Map` ? ` as keys` : ``}, ` + + `which can lead to inconsistencies. ` + + `Avoid differentiating between the raw and reactive versions ` + + `of an object and only use the reactive version if possible.`); + } + } + + const reactiveMap = new WeakMap(); + const readonlyMap = 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" /* SKIP */] || !Object.isExtensible(value) + ? 0 /* INVALID */ + : targetTypeMap(toRawType(value)); + } + function reactive(target) { + // if trying to observe a readonly proxy, return the readonly version. + if (target && target["__v_isReadonly" /* IS_READONLY */]) { + return target; + } + return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers); + } + /** + * Creates a readonly copy of the original object. Note the returned copy is not + * made reactive, but `readonly` can be called on an already reactive object. + */ + function readonly(target) { + return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers); + } + /** + * Returns a reactive-copy of the original object, where only the root level + * properties are readonly, and does NOT unwrap refs nor recursively convert + * returned properties. + * This is used for creating the props proxy object for stateful components. + */ + function shallowReadonly(target) { + return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers); + } + function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) { + if (!isObject(target)) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`value cannot be made reactive: ${String(target)}`); + } + return target; + } + // target is already a Proxy, return it. + // exception: calling readonly() on a reactive object + if (target["__v_raw" /* RAW */] && + !(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) { + return target; + } + // target already has corresponding Proxy + const proxyMap = isReadonly ? readonlyMap : reactiveMap; + const existingProxy = proxyMap.get(target); + if (existingProxy) { + return existingProxy; + } + // only a whitelist of value types can be observed. + 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" /* RAW */]); + } + return !!(value && value["__v_isReactive" /* IS_REACTIVE */]); + } + function isReadonly(value) { + return !!(value && value["__v_isReadonly" /* IS_READONLY */]); + } + function isProxy(value) { + return isReactive(value) || isReadonly(value); + } + function toRaw(observed) { + return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed); + } + function isRef(r) { + return Boolean(r && r.__v_isRef === true); + } + + const stack = []; + function pushWarningContext(vnode) { + stack.push(vnode); + } + function popWarningContext() { + stack.pop(); + } + function warn(msg, ...args) { + // avoid props formatting or warn handler tracking deps that might be mutated + // during patch, leading to infinite recursion. + 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 /* APP_WARN_HANDLER */, [ + msg + args.join(''), + instance && instance.proxy, + trace + .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`) + .join('\n'), + trace + ]); + } + else { + const warnArgs = [`[Vue warn]: ${msg}`, ...args]; + /* istanbul ignore if */ + if (trace.length && + // avoid spamming console during tests + !false) { + warnArgs.push(`\n`, ...formatTrace(trace)); + } + console.warn(...warnArgs); + } + resetTracking(); + } + function getComponentTrace() { + let currentVNode = stack[stack.length - 1]; + if (!currentVNode) { + return []; + } + // we can't just use the stack because it will be incomplete during updates + // that did not start from the root. Re-construct the parent chain using + // instance parent pointers. + 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; + } + /* istanbul ignore next */ + function formatTrace(trace) { + const logs = []; + trace.forEach((entry, i) => { + logs.push(...(i === 0 ? [] : [`\n`]), ...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]; + } + /* istanbul ignore next */ + 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; + } + /* istanbul ignore next */ + 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]; + } + } + + const ErrorTypeStrings = { + ["bc" /* BEFORE_CREATE */]: 'beforeCreate hook', + ["c" /* CREATED */]: 'created hook', + ["bm" /* BEFORE_MOUNT */]: 'beforeMount hook', + ["m" /* MOUNTED */]: 'mounted hook', + ["bu" /* BEFORE_UPDATE */]: 'beforeUpdate hook', + ["u" /* UPDATED */]: 'updated', + ["bum" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook', + ["um" /* UNMOUNTED */]: 'unmounted hook', + ["a" /* ACTIVATED */]: 'activated hook', + ["da" /* DEACTIVATED */]: 'deactivated hook', + ["ec" /* ERROR_CAPTURED */]: 'errorCaptured hook', + ["rtc" /* RENDER_TRACKED */]: 'renderTracked hook', + ["rtg" /* RENDER_TRIGGERED */]: 'renderTriggered hook', + [0 /* SETUP_FUNCTION */]: 'setup function', + [1 /* RENDER_FUNCTION */]: 'render function', + [2 /* WATCH_GETTER */]: 'watcher getter', + [3 /* WATCH_CALLBACK */]: 'watcher callback', + [4 /* WATCH_CLEANUP */]: 'watcher cleanup function', + [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler', + [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler', + [7 /* VNODE_HOOK */]: 'vnode hook', + [8 /* DIRECTIVE_HOOK */]: 'directive hook', + [9 /* TRANSITION_HOOK */]: 'transition hook', + [10 /* APP_ERROR_HANDLER */]: 'app errorHandler', + [11 /* APP_WARN_HANDLER */]: 'app warnHandler', + [12 /* FUNCTION_REF */]: 'ref function', + [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader', + [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' + + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next' + }; + function callWithErrorHandling(fn, instance, type, args) { + let res; + try { + res = args ? fn(...args) : fn(); + } + catch (err) { + handleError(err, instance, type); + } + return res; + } + function callWithAsyncErrorHandling(fn, instance, type, args) { + if (isFunction(fn)) { + const res = callWithErrorHandling(fn, instance, type, args); + if (res && isPromise(res)) { + res.catch(err => { + handleError(err, instance, type); + }); + } + return res; + } + const values = []; + for (let i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); + } + return values; + } + function handleError(err, instance, type, throwInDev = true) { + const contextVNode = instance ? instance.vnode : null; + if (instance) { + let cur = instance.parent; + // the exposed instance is the render proxy to keep it consistent with 2.x + const exposedInstance = instance.proxy; + // in production the hook receives only the error code + const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type; + while (cur) { + const errorCapturedHooks = cur.ec; + if (errorCapturedHooks) { + for (let i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { + return; + } + } + } + cur = cur.parent; + } + // app-level handling + const appErrorHandler = instance.appContext.config.errorHandler; + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]); + return; + } + } + logError(err, type, contextVNode, throwInDev); + } + function logError(err, type, contextVNode, throwInDev = true) { + if ((process.env.NODE_ENV !== 'production')) { + const info = ErrorTypeStrings[type]; + if (contextVNode) { + pushWarningContext(contextVNode); + } + warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`); + if (contextVNode) { + popWarningContext(); + } + // crash in dev by default so it's more noticeable + if (throwInDev) { + throw err; + } + else { + console.error(err); + } + } + else { + // recover in prod to reduce the impact on end-user + console.error(err); + } + } + + let isFlushing = false; + let isFlushPending = false; + const queue = []; + let flushIndex = 0; + const pendingPreFlushCbs = []; + let activePreFlushCbs = null; + let preFlushIndex = 0; + const pendingPostFlushCbs = []; + let activePostFlushCbs = null; + let postFlushIndex = 0; + const resolvedPromise = Promise.resolve(); + let currentFlushPromise = null; + let currentPreFlushParentJob = null; + const RECURSION_LIMIT = 100; + function nextTick(fn) { + const p = currentFlushPromise || resolvedPromise; + return fn ? p.then(this ? fn.bind(this) : fn) : p; + } + function queueJob(job) { + // the dedupe search uses the startIndex argument of Array.includes() + // by default the search index includes the current job that is being run + // so it cannot recursively trigger itself again. + // if the job is a watch() callback, the search will start with a +1 index to + // allow it recursively trigger itself - it is the user's responsibility to + // ensure it doesn't end up in an infinite loop. + if ((!queue.length || + !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && + job !== currentPreFlushParentJob) { + queue.push(job); + queueFlush(); + } + } + function queueFlush() { + if (!isFlushing && !isFlushPending) { + isFlushPending = true; + currentFlushPromise = resolvedPromise.then(flushJobs); + } + } + function queueCb(cb, activeQueue, pendingQueue, index) { + if (!isArray(cb)) { + if (!activeQueue || + !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { + pendingQueue.push(cb); + } + } + else { + // if cb is an array, it is a component lifecycle hook which can only be + // triggered by a job, which is already deduped in the main queue, so + // we can skip duplicate check here to improve perf + pendingQueue.push(...cb); + } + queueFlush(); + } + function queuePreFlushCb(cb) { + queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); + } + function queuePostFlushCb(cb) { + queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); + } + function flushPreFlushCbs(seen, parentJob = null) { + if (pendingPreFlushCbs.length) { + currentPreFlushParentJob = parentJob; + activePreFlushCbs = [...new Set(pendingPreFlushCbs)]; + pendingPreFlushCbs.length = 0; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { + if ((process.env.NODE_ENV !== 'production')) { + checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]); + } + activePreFlushCbs[preFlushIndex](); + } + activePreFlushCbs = null; + preFlushIndex = 0; + currentPreFlushParentJob = null; + // recursively flush until it drains + flushPreFlushCbs(seen, parentJob); + } + } + function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + const deduped = [...new Set(pendingPostFlushCbs)]; + pendingPostFlushCbs.length = 0; + // #1947 already has active queue, nested flushPostFlushCbs call + if (activePostFlushCbs) { + activePostFlushCbs.push(...deduped); + return; + } + activePostFlushCbs = deduped; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + if ((process.env.NODE_ENV !== 'production')) { + checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]); + } + activePostFlushCbs[postFlushIndex](); + } + activePostFlushCbs = null; + postFlushIndex = 0; + } + } + const getId = (job) => job.id == null ? Infinity : job.id; + function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + flushPreFlushCbs(seen); + // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child so its render effect will have smaller + // priority number) + // 2. If a component is unmounted during a parent component's update, + // its update can be skipped. + queue.sort((a, b) => getId(a) - getId(b)); + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex]; + if (job) { + if ((process.env.NODE_ENV !== 'production')) { + checkRecursiveUpdates(seen, job); + } + callWithErrorHandling(job, null, 14 /* SCHEDULER */); + } + } + } + finally { + flushIndex = 0; + queue.length = 0; + flushPostFlushCbs(seen); + isFlushing = false; + currentFlushPromise = null; + // some postFlushCb queued jobs! + // keep flushing until it drains. + if (queue.length || pendingPostFlushCbs.length) { + flushJobs(seen); + } + } + } + function checkRecursiveUpdates(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } + else { + const count = seen.get(fn); + if (count > RECURSION_LIMIT) { + throw new Error(`Maximum recursive updates exceeded. ` + + `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.`); + } + else { + seen.set(fn, count + 1); + } + } + } + const hmrDirtyComponents = new Set(); + // Expose the HMR runtime on the global object + // This makes it entirely tree-shakable without polluting the exports and makes + // it easier to be used in toolings like vue-loader + // Note: for a component to be eligible for HMR it also needs the __hmrId option + // to be set so that its instances can be registered / removed. + if ((process.env.NODE_ENV !== 'production')) { + const globalObject = typeof global !== 'undefined' + ? global + : typeof self !== 'undefined' + ? self + : typeof window !== 'undefined' + ? window + : {}; + globalObject.__VUE_HMR_RUNTIME__ = { + createRecord: tryWrap(createRecord), + rerender: tryWrap(rerender), + reload: tryWrap(reload) + }; + } + const map = new Map(); + function createRecord(id, component) { + if (!component) { + warn(`HMR API usage is out of date.\n` + + `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` + + `depdendency that handles Vue SFC compilation.`); + component = {}; + } + if (map.has(id)) { + return false; + } + map.set(id, { + component: isClassComponent(component) ? component.__vccOpts : component, + instances: new Set() + }); + return true; + } + function rerender(id, newRender) { + const record = map.get(id); + if (!record) + return; + if (newRender) + record.component.render = newRender; + // Array.from creates a snapshot which avoids the set being mutated during + // updates + Array.from(record.instances).forEach(instance => { + if (newRender) { + instance.render = newRender; + } + instance.renderCache = []; + instance.update(); + }); + } + function reload(id, newComp) { + const record = map.get(id); + if (!record) + return; + // Array.from creates a snapshot which avoids the set being mutated during + // updates + const { component, instances } = record; + if (!hmrDirtyComponents.has(component)) { + // 1. Update existing comp definition to match new one + newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp; + extend(component, newComp); + for (const key in component) { + if (!(key in newComp)) { + delete component[key]; + } + } + // 2. Mark component dirty. This forces the renderer to replace the component + // on patch. + hmrDirtyComponents.add(component); + // 3. Make sure to unmark the component after the reload. + queuePostFlushCb(() => { + hmrDirtyComponents.delete(component); + }); + } + Array.from(instances).forEach(instance => { + if (instance.parent) { + // 4. Force the parent instance to re-render. This will cause all updated + // components to be unmounted and re-mounted. Queue the update so that we + // don't end up forcing the same parent to re-render multiple times. + queueJob(instance.parent.update); + } + else if (instance.appContext.reload) { + // root instance mounted via createApp() has a reload method + instance.appContext.reload(); + } + else if (typeof window !== 'undefined') { + // root instance inside tree created via raw render(). Force reload. + window.location.reload(); + } + else { + console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); + } + }); + } + 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.`); + } + }; + } + function setDevtoolsHook(hook) { + } - if (!isSymbol(key) || !builtInSymbols.has(key)) { - track(target, "has" - /* HAS */ - , key); - } + /** + * mark the current rendering instance for asset resolution (e.g. + * resolveComponent, resolveDirective) during render + */ + let currentRenderingInstance = null; + function setCurrentRenderingInstance(instance) { + currentRenderingInstance = instance; + } + function markAttrsAccessed() { + } + function filterSingleRoot(children) { + let singleRoot; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (isVNode(child)) { + // ignore user comment + if (child.type !== Comment || child.children === 'v-if') { + if (singleRoot) { + // has more than 1 non-comment child, return now + return; + } + else { + singleRoot = child; + } + } + } + else { + return; + } + } + return singleRoot; + } + + const isSuspense = (type) => type.__isSuspense; + function normalizeSuspenseChildren(vnode) { + const { shapeFlag, children } = vnode; + let content; + let fallback; + if (shapeFlag & 32 /* SLOTS_CHILDREN */) { + content = normalizeSuspenseSlot(children.default); + fallback = normalizeSuspenseSlot(children.fallback); + } + else { + content = normalizeSuspenseSlot(children); + fallback = normalizeVNode(null); + } + return { + content, + fallback + }; + } + function normalizeSuspenseSlot(s) { + if (isFunction(s)) { + s = s(); + } + if (isArray(s)) { + const singleChild = filterSingleRoot(s); + if ((process.env.NODE_ENV !== 'production') && !singleChild) { + warn(` slots expect a single root node.`); + } + s = singleChild; + } + return normalizeVNode(s); + } + function queueEffectWithSuspense(fn, suspense) { + if (suspense && suspense.pendingBranch) { + if (isArray(fn)) { + suspense.effects.push(...fn); + } + else { + suspense.effects.push(fn); + } + } + else { + queuePostFlushCb(fn); + } + } + + let isRenderingCompiledSlot = 0; + const setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n); - return result; - } - - function ownKeys$1(target) { - track(target, "iterate" - /* ITERATE */ - , isArray(target) ? 'length' : ITERATE_KEY); - return Reflect.ownKeys(target); - } - - var mutableHandlers = { - get: get, - set: set, - deleteProperty: deleteProperty, - has: has, - ownKeys: ownKeys$1 - }; - var readonlyHandlers = { - get: readonlyGet, - set: function set(target, key) { - if (process.env.NODE_ENV !== 'production') { - console.warn("Set operation on key \"".concat(String(key), "\" failed: target is readonly."), target); - } - - return true; - }, - deleteProperty: function deleteProperty(target, key) { - if (process.env.NODE_ENV !== 'production') { - console.warn("Delete operation on key \"".concat(String(key), "\" failed: target is readonly."), target); - } - - return true; - } - }; - var shallowReactiveHandlers = extend({}, mutableHandlers, { - get: shallowGet, - set: shallowSet - }); // Props handlers are special in the sense that it should not unwrap top-level - // refs (in order to allow refs to be explicitly passed down), but should - // retain the reactivity of the normal readonly object. - - var shallowReadonlyHandlers = extend({}, readonlyHandlers, { - get: shallowReadonlyGet - }); - - var toReactive = function toReactive(value) { - return isObject(value) ? reactive(value) : value; - }; - - var toReadonly = function toReadonly(value) { - return isObject(value) ? readonly(value) : value; - }; - - var toShallow = function toShallow(value) { - return value; - }; - - var getProto = function getProto(v) { - return Reflect.getPrototypeOf(v); - }; - - function get$1(target, key) { - var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var isShallow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; - // #1772: readonly(reactive(Map)) should return readonly + reactive version - // of the value - target = target["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw(target); - var rawKey = toRaw(key); - - if (key !== rawKey) { - !isReadonly && track(rawTarget, "get" - /* GET */ - , key); - } - - !isReadonly && track(rawTarget, "get" - /* GET */ - , rawKey); - - var _getProto = getProto(rawTarget), - has = _getProto.has; - - var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; - - if (has.call(rawTarget, key)) { - return wrap(target.get(key)); - } else if (has.call(rawTarget, rawKey)) { - return wrap(target.get(rawKey)); - } - } - - function has$1(key) { - var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; - var target = this["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw(target); - var rawKey = toRaw(key); - - if (key !== rawKey) { - !isReadonly && track(rawTarget, "has" - /* HAS */ - , key); - } - - !isReadonly && track(rawTarget, "has" - /* HAS */ - , rawKey); - return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); - } - - function size(target) { - var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; - target = target["__v_raw" - /* RAW */ - ]; - !isReadonly && track(toRaw(target), "iterate" - /* ITERATE */ - , ITERATE_KEY); - return Reflect.get(target, 'size', target); - } - - function add(value) { - value = toRaw(value); - var target = toRaw(this); - var proto = getProto(target); - var hadKey = proto.has.call(target, value); - target.add(value); - - if (!hadKey) { - trigger(target, "add" - /* ADD */ - , value, value); - } - - return this; - } - - function set$1(key, value) { - value = toRaw(value); - var target = toRaw(this); - - var _getProto2 = getProto(target), - has = _getProto2.has, - get = _getProto2.get; - - var hadKey = has.call(target, key); - - if (!hadKey) { - key = toRaw(key); - hadKey = has.call(target, key); - } else if (process.env.NODE_ENV !== 'production') { - checkIdentityKeys(target, has, key); - } - - var oldValue = get.call(target, key); - target.set(key, value); - - if (!hadKey) { - trigger(target, "add" - /* ADD */ - , key, value); - } else if (hasChanged(value, oldValue)) { - trigger(target, "set" - /* SET */ - , key, value, oldValue); - } - - return this; - } - - function deleteEntry(key) { - var target = toRaw(this); - - var _getProto3 = getProto(target), - has = _getProto3.has, - get = _getProto3.get; - - var hadKey = has.call(target, key); - - if (!hadKey) { - key = toRaw(key); - hadKey = has.call(target, key); - } else if (process.env.NODE_ENV !== 'production') { - checkIdentityKeys(target, has, key); - } - - var oldValue = get ? get.call(target, key) : undefined; // forward the operation before queueing reactions - - var result = target.delete(key); - - if (hadKey) { - trigger(target, "delete" - /* DELETE */ - , key, undefined, oldValue); - } - - return result; - } - - function clear() { - var target = toRaw(this); - var hadItems = target.size !== 0; - var oldTarget = process.env.NODE_ENV !== 'production' ? isMap(target) ? new Map(target) : new Set(target) : undefined; // forward the operation before queueing reactions - - var result = target.clear(); - - if (hadItems) { - trigger(target, "clear" - /* CLEAR */ - , undefined, undefined, oldTarget); - } - - return result; - } - - function createForEach(isReadonly, isShallow) { - return function forEach(callback, thisArg) { - var observed = this; - var target = observed["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw(target); - var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; - !isReadonly && track(rawTarget, "iterate" - /* ITERATE */ - , ITERATE_KEY); - return target.forEach(function (value, key) { - // important: make sure the callback is - // 1. invoked with the reactive map as `this` and 3rd arg - // 2. the value received should be a corresponding reactive/readonly. - return callback.call(thisArg, wrap(value), wrap(key), observed); - }); - }; - } - - function createIterableMethod(method, isReadonly, isShallow) { - return function () { - var target = this["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw(target); - var targetIsMap = isMap(rawTarget); - var isPair = method === 'entries' || method === Symbol.iterator && targetIsMap; - var isKeyOnly = method === 'keys' && targetIsMap; - var innerIterator = target[method].apply(target, arguments); - var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; - !isReadonly && track(rawTarget, "iterate" - /* ITERATE */ - , isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); // return a wrapped iterator which returns observed versions of the - // values emitted from the real iterator - - return _defineProperty({ - // iterator protocol - next: function next() { - var _innerIterator$next = innerIterator.next(), - value = _innerIterator$next.value, - done = _innerIterator$next.done; - - return done ? { - value: value, - done: done - } : { - value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), - done: done - }; - } - }, Symbol.iterator, function () { - return this; - }); - }; - } - - function createReadonlyMethod(type) { - return function () { - if (process.env.NODE_ENV !== 'production') { - var key = (arguments.length <= 0 ? undefined : arguments[0]) ? "on key \"".concat(arguments.length <= 0 ? undefined : arguments[0], "\" ") : ""; - console.warn("".concat(capitalize(type), " operation ").concat(key, "failed: target is readonly."), toRaw(this)); - } - - return type === "delete" - /* DELETE */ - ? false : this; - }; - } - - var mutableInstrumentations = { - get: function get(key) { - return get$1(this, key); - }, - - get size() { - return size(this); - }, - - has: has$1, - add: add, - set: set$1, - delete: deleteEntry, - clear: clear, - forEach: createForEach(false, false) - }; - var shallowInstrumentations = { - get: function get(key) { - return get$1(this, key, false, true); - }, - - get size() { - return size(this); - }, - - has: has$1, - add: add, - set: set$1, - delete: deleteEntry, - clear: clear, - forEach: createForEach(false, true) - }; - var readonlyInstrumentations = { - get: function get(key) { - return get$1(this, key, true); - }, - - get size() { - return size(this, true); - }, - - has: function has(key) { - return has$1.call(this, key, true); - }, - add: createReadonlyMethod("add" - /* ADD */ - ), - set: createReadonlyMethod("set" - /* SET */ - ), - delete: createReadonlyMethod("delete" - /* DELETE */ - ), - clear: createReadonlyMethod("clear" - /* CLEAR */ - ), - forEach: createForEach(true, false) - }; - var iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]; - iteratorMethods.forEach(function (method) { - mutableInstrumentations[method] = createIterableMethod(method, false, false); - readonlyInstrumentations[method] = createIterableMethod(method, true, false); - shallowInstrumentations[method] = createIterableMethod(method, false, true); - }); - - function createInstrumentationGetter(isReadonly, shallow) { - var instrumentations = shallow ? shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations; - return function (target, key, receiver) { - if (key === "__v_isReactive" - /* IS_REACTIVE */ - ) { - return !isReadonly; - } else if (key === "__v_isReadonly" - /* IS_READONLY */ - ) { - return isReadonly; - } else if (key === "__v_raw" - /* RAW */ - ) { - return target; - } - - return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver); - }; - } - - var mutableCollectionHandlers = { - get: createInstrumentationGetter(false, false) - }; - var readonlyCollectionHandlers = { - get: createInstrumentationGetter(true, false) - }; - - function checkIdentityKeys(target, has, key) { - var rawKey = toRaw(key); - - if (rawKey !== key && has.call(target, rawKey)) { - var type = toRawType(target); - console.warn("Reactive ".concat(type, " contains both the raw and reactive ") + "versions of the same object".concat(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."); - } - } - - var reactiveMap = new WeakMap(); - var readonlyMap = 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" - /* SKIP */ - ] || !Object.isExtensible(value) ? 0 - /* INVALID */ - : targetTypeMap(toRawType(value)); - } - - function reactive(target) { - // if trying to observe a readonly proxy, return the readonly version. - if (target && target["__v_isReadonly" - /* IS_READONLY */ - ]) { - return target; - } - - return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers); - } - /** - * Creates a readonly copy of the original object. Note the returned copy is not - * made reactive, but `readonly` can be called on an already reactive object. - */ - - - function readonly(target) { - return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers); - } - /** - * Returns a reactive-copy of the original object, where only the root level - * properties are readonly, and does NOT unwrap refs nor recursively convert - * returned properties. - * This is used for creating the props proxy object for stateful components. - */ - - - function shallowReadonly(target) { - return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers); - } - - function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) { - if (!isObject(target)) { - if (process.env.NODE_ENV !== 'production') { - console.warn("value cannot be made reactive: ".concat(String(target))); - } - - return target; - } // target is already a Proxy, return it. - // exception: calling readonly() on a reactive object - - - if (target["__v_raw" - /* RAW */ - ] && !(isReadonly && target["__v_isReactive" - /* IS_REACTIVE */ - ])) { - return target; - } // target already has corresponding Proxy - - - var proxyMap = isReadonly ? readonlyMap : reactiveMap; - var existingProxy = proxyMap.get(target); - - if (existingProxy) { - return existingProxy; - } // only a whitelist of value types can be observed. - - - var targetType = getTargetType(target); - - if (targetType === 0 - /* INVALID */ - ) { - return target; - } - - var 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" - /* RAW */ - ]); - } - - return !!(value && value["__v_isReactive" - /* IS_REACTIVE */ - ]); - } - - function isReadonly(value) { - return !!(value && value["__v_isReadonly" - /* IS_READONLY */ - ]); - } - - function isProxy(value) { - return isReactive(value) || isReadonly(value); - } - - function toRaw(observed) { - return observed && toRaw(observed["__v_raw" - /* RAW */ - ]) || observed; - } - - function isRef(r) { - return Boolean(r && r.__v_isRef === true); - } - - var stack = []; - - function pushWarningContext(vnode) { - stack.push(vnode); - } - - function popWarningContext() { - stack.pop(); - } - - function warn(msg) { - // avoid props formatting or warn handler tracking deps that might be mutated - // during patch, leading to infinite recursion. - pauseTracking(); - var instance = stack.length ? stack[stack.length - 1].component : null; - var appWarnHandler = instance && instance.appContext.config.warnHandler; - var trace = getComponentTrace(); - - for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) { - args[_key3 - 1] = arguments[_key3]; - } - - if (appWarnHandler) { - callWithErrorHandling(appWarnHandler, instance, 11 - /* APP_WARN_HANDLER */ - , [msg + args.join(''), instance && instance.proxy, trace.map(function (_ref2) { - var vnode = _ref2.vnode; - return "at <".concat(formatComponentName(instance, vnode.type), ">"); - }).join('\n'), trace]); - } else { - var _console; - - var warnArgs = ["[Vue warn]: ".concat(msg)].concat(args); - /* istanbul ignore if */ - - if (trace.length && // avoid spamming console during tests - !false) { - warnArgs.push.apply(warnArgs, ["\n"].concat(_toConsumableArray(formatTrace(trace)))); - } - - (_console = console).warn.apply(_console, _toConsumableArray(warnArgs)); - } - - resetTracking(); - } - - function getComponentTrace() { - var currentVNode = stack[stack.length - 1]; - - if (!currentVNode) { - return []; - } // we can't just use the stack because it will be incomplete during updates - // that did not start from the root. Re-construct the parent chain using - // instance parent pointers. - - - var normalizedStack = []; - - while (currentVNode) { - var last = normalizedStack[0]; - - if (last && last.vnode === currentVNode) { - last.recurseCount++; - } else { - normalizedStack.push({ - vnode: currentVNode, - recurseCount: 0 - }); - } - - var parentInstance = currentVNode.component && currentVNode.component.parent; - currentVNode = parentInstance && parentInstance.vnode; - } - - return normalizedStack; - } - /* istanbul ignore next */ - - - function formatTrace(trace) { - var logs = []; - trace.forEach(function (entry, i) { - logs.push.apply(logs, _toConsumableArray(i === 0 ? [] : ["\n"]).concat(_toConsumableArray(formatTraceEntry(entry)))); - }); - return logs; - } - - function formatTraceEntry(_ref3) { - var vnode = _ref3.vnode, - recurseCount = _ref3.recurseCount; - var postfix = recurseCount > 0 ? "... (".concat(recurseCount, " recursive calls)") : ""; - var isRoot = vnode.component ? vnode.component.parent == null : false; - var open = " at <".concat(formatComponentName(vnode.component, vnode.type, isRoot)); - var close = ">" + postfix; - return vnode.props ? [open].concat(_toConsumableArray(formatProps(vnode.props)), [close]) : [open + close]; - } - /* istanbul ignore next */ - - - function formatProps(props) { - var res = []; - var keys = Object.keys(props); - keys.slice(0, 3).forEach(function (key) { - res.push.apply(res, _toConsumableArray(formatProp(key, props[key]))); - }); - - if (keys.length > 3) { - res.push(" ..."); - } - - return res; - } - /* istanbul ignore next */ - - - function formatProp(key, value, raw) { - if (isString(value)) { - value = JSON.stringify(value); - return raw ? value : ["".concat(key, "=").concat(value)]; - } else if (typeof value === 'number' || typeof value === 'boolean' || value == null) { - return raw ? value : ["".concat(key, "=").concat(value)]; - } else if (isRef(value)) { - value = formatProp(key, toRaw(value.value), true); - return raw ? value : ["".concat(key, "=Ref<"), value, ">"]; - } else if (isFunction(value)) { - return ["".concat(key, "=fn").concat(value.name ? "<".concat(value.name, ">") : "")]; - } else { - value = toRaw(value); - return raw ? value : ["".concat(key, "="), value]; - } - } - - var ErrorTypeStrings = (_ErrorTypeStrings = {}, _defineProperty(_ErrorTypeStrings, "bc" - /* BEFORE_CREATE */ - , 'beforeCreate hook'), _defineProperty(_ErrorTypeStrings, "c" - /* CREATED */ - , 'created hook'), _defineProperty(_ErrorTypeStrings, "bm" - /* BEFORE_MOUNT */ - , 'beforeMount hook'), _defineProperty(_ErrorTypeStrings, "m" - /* MOUNTED */ - , 'mounted hook'), _defineProperty(_ErrorTypeStrings, "bu" - /* BEFORE_UPDATE */ - , 'beforeUpdate hook'), _defineProperty(_ErrorTypeStrings, "u" - /* UPDATED */ - , 'updated'), _defineProperty(_ErrorTypeStrings, "bum" - /* BEFORE_UNMOUNT */ - , 'beforeUnmount hook'), _defineProperty(_ErrorTypeStrings, "um" - /* UNMOUNTED */ - , 'unmounted hook'), _defineProperty(_ErrorTypeStrings, "a" - /* ACTIVATED */ - , 'activated hook'), _defineProperty(_ErrorTypeStrings, "da" - /* DEACTIVATED */ - , 'deactivated hook'), _defineProperty(_ErrorTypeStrings, "ec" - /* ERROR_CAPTURED */ - , 'errorCaptured hook'), _defineProperty(_ErrorTypeStrings, "rtc" - /* RENDER_TRACKED */ - , 'renderTracked hook'), _defineProperty(_ErrorTypeStrings, "rtg" - /* RENDER_TRIGGERED */ - , 'renderTriggered hook'), _defineProperty(_ErrorTypeStrings, 0 - /* SETUP_FUNCTION */ - , 'setup function'), _defineProperty(_ErrorTypeStrings, 1 - /* RENDER_FUNCTION */ - , 'render function'), _defineProperty(_ErrorTypeStrings, 2 - /* WATCH_GETTER */ - , 'watcher getter'), _defineProperty(_ErrorTypeStrings, 3 - /* WATCH_CALLBACK */ - , 'watcher callback'), _defineProperty(_ErrorTypeStrings, 4 - /* WATCH_CLEANUP */ - , 'watcher cleanup function'), _defineProperty(_ErrorTypeStrings, 5 - /* NATIVE_EVENT_HANDLER */ - , 'native event handler'), _defineProperty(_ErrorTypeStrings, 6 - /* COMPONENT_EVENT_HANDLER */ - , 'component event handler'), _defineProperty(_ErrorTypeStrings, 7 - /* VNODE_HOOK */ - , 'vnode hook'), _defineProperty(_ErrorTypeStrings, 8 - /* DIRECTIVE_HOOK */ - , 'directive hook'), _defineProperty(_ErrorTypeStrings, 9 - /* TRANSITION_HOOK */ - , 'transition hook'), _defineProperty(_ErrorTypeStrings, 10 - /* APP_ERROR_HANDLER */ - , 'app errorHandler'), _defineProperty(_ErrorTypeStrings, 11 - /* APP_WARN_HANDLER */ - , 'app warnHandler'), _defineProperty(_ErrorTypeStrings, 12 - /* FUNCTION_REF */ - , 'ref function'), _defineProperty(_ErrorTypeStrings, 13 - /* ASYNC_COMPONENT_LOADER */ - , 'async component loader'), _defineProperty(_ErrorTypeStrings, 14 - /* SCHEDULER */ - , 'scheduler flush. This is likely a Vue internals bug. ' + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'), _ErrorTypeStrings); - - function callWithErrorHandling(fn, instance, type, args) { - var res; - - try { - res = args ? fn.apply(void 0, _toConsumableArray(args)) : fn(); - } catch (err) { - handleError(err, instance, type); - } - - return res; - } - - function callWithAsyncErrorHandling(fn, instance, type, args) { - if (isFunction(fn)) { - var res = callWithErrorHandling(fn, instance, type, args); - - if (res && isPromise(res)) { - res.catch(function (err) { - handleError(err, instance, type); - }); - } - - return res; - } - - var values = []; - - for (var i = 0; i < fn.length; i++) { - values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); - } - - return values; - } - - function handleError(err, instance, type) { - var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; - var contextVNode = instance ? instance.vnode : null; - - if (instance) { - var cur = instance.parent; // the exposed instance is the render proxy to keep it consistent with 2.x - - var exposedInstance = instance.proxy; // in production the hook receives only the error code - - var errorInfo = process.env.NODE_ENV !== 'production' ? ErrorTypeStrings[type] : type; - - while (cur) { - var errorCapturedHooks = cur.ec; - - if (errorCapturedHooks) { - for (var i = 0; i < errorCapturedHooks.length; i++) { - if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { - return; - } - } - } - - cur = cur.parent; - } // app-level handling - - - var appErrorHandler = instance.appContext.config.errorHandler; - - if (appErrorHandler) { - callWithErrorHandling(appErrorHandler, null, 10 - /* APP_ERROR_HANDLER */ - , [err, exposedInstance, errorInfo]); - return; - } - } - - logError(err, type, contextVNode, throwInDev); - } - - function logError(err, type, contextVNode) { - var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; - - if (process.env.NODE_ENV !== 'production') { - var info = ErrorTypeStrings[type]; - - if (contextVNode) { - pushWarningContext(contextVNode); - } - - warn("Unhandled error".concat(info ? " during execution of ".concat(info) : "")); - - if (contextVNode) { - popWarningContext(); - } // crash in dev by default so it's more noticeable - - - if (throwInDev) { - throw err; - } else { - console.error(err); - } - } else { - // recover in prod to reduce the impact on end-user - console.error(err); - } - } - - var isFlushing = false; - var isFlushPending = false; - var queue = []; - var flushIndex = 0; - var pendingPreFlushCbs = []; - var activePreFlushCbs = null; - var preFlushIndex = 0; - var pendingPostFlushCbs = []; - var activePostFlushCbs = null; - var postFlushIndex = 0; - var resolvedPromise = Promise.resolve(); - var currentFlushPromise = null; - var currentPreFlushParentJob = null; - var RECURSION_LIMIT = 100; - - function nextTick(fn) { - var p = currentFlushPromise || resolvedPromise; - return fn ? p.then(this ? fn.bind(this) : fn) : p; - } - - function queueJob(job) { - // the dedupe search uses the startIndex argument of Array.includes() - // by default the search index includes the current job that is being run - // so it cannot recursively trigger itself again. - // if the job is a watch() callback, the search will start with a +1 index to - // allow it recursively trigger itself - it is the user's responsibility to - // ensure it doesn't end up in an infinite loop. - if ((!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && job !== currentPreFlushParentJob) { - queue.push(job); - queueFlush(); - } - } - - function queueFlush() { - if (!isFlushing && !isFlushPending) { - isFlushPending = true; - currentFlushPromise = resolvedPromise.then(flushJobs); - } - } - - function queueCb(cb, activeQueue, pendingQueue, index) { - if (!isArray(cb)) { - if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { - pendingQueue.push(cb); - } - } else { - // if cb is an array, it is a component lifecycle hook which can only be - // triggered by a job, which is already deduped in the main queue, so - // we can skip duplicate check here to improve perf - pendingQueue.push.apply(pendingQueue, _toConsumableArray(cb)); - } - - queueFlush(); - } - - function queuePreFlushCb(cb) { - queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); - } - - function queuePostFlushCb(cb) { - queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); - } - - function flushPreFlushCbs(seen) { - var parentJob = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; - - if (pendingPreFlushCbs.length) { - currentPreFlushParentJob = parentJob; - activePreFlushCbs = _toConsumableArray(new Set(pendingPreFlushCbs)); - pendingPreFlushCbs.length = 0; - - if (process.env.NODE_ENV !== 'production') { - seen = seen || new Map(); - } - - for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { - if (process.env.NODE_ENV !== 'production') { - checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]); - } - - activePreFlushCbs[preFlushIndex](); - } - - activePreFlushCbs = null; - preFlushIndex = 0; - currentPreFlushParentJob = null; // recursively flush until it drains - - flushPreFlushCbs(seen, parentJob); - } - } - - function flushPostFlushCbs(seen) { - if (pendingPostFlushCbs.length) { - var deduped = _toConsumableArray(new Set(pendingPostFlushCbs)); - - pendingPostFlushCbs.length = 0; // #1947 already has active queue, nested flushPostFlushCbs call - - if (activePostFlushCbs) { - var _activePostFlushCbs; - - (_activePostFlushCbs = activePostFlushCbs).push.apply(_activePostFlushCbs, _toConsumableArray(deduped)); - - return; - } - - activePostFlushCbs = deduped; - - if (process.env.NODE_ENV !== 'production') { - seen = seen || new Map(); - } - - activePostFlushCbs.sort(function (a, b) { - return getId(a) - getId(b); - }); - - for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { - if (process.env.NODE_ENV !== 'production') { - checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]); - } - - activePostFlushCbs[postFlushIndex](); - } - - activePostFlushCbs = null; - postFlushIndex = 0; - } - } - - var getId = function getId(job) { - return job.id == null ? Infinity : job.id; - }; - - function flushJobs(seen) { - isFlushPending = false; - isFlushing = true; - - if (process.env.NODE_ENV !== 'production') { - seen = seen || new Map(); - } - - flushPreFlushCbs(seen); // Sort queue before flush. - // This ensures that: - // 1. Components are updated from parent to child. (because parent is always - // created before the child so its render effect will have smaller - // priority number) - // 2. If a component is unmounted during a parent component's update, - // its update can be skipped. - - queue.sort(function (a, b) { - return getId(a) - getId(b); - }); - - try { - for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { - var job = queue[flushIndex]; - - if (job) { - if (process.env.NODE_ENV !== 'production') { - checkRecursiveUpdates(seen, job); - } - - callWithErrorHandling(job, null, 14 - /* SCHEDULER */ - ); - } - } - } finally { - flushIndex = 0; - queue.length = 0; - flushPostFlushCbs(seen); - isFlushing = false; - currentFlushPromise = null; // some postFlushCb queued jobs! - // keep flushing until it drains. - - if (queue.length || pendingPostFlushCbs.length) { - flushJobs(seen); - } - } - } - - function checkRecursiveUpdates(seen, fn) { - if (!seen.has(fn)) { - seen.set(fn, 1); - } else { - var count = seen.get(fn); - - if (count > RECURSION_LIMIT) { - throw new Error("Maximum recursive updates exceeded. " + "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."); - } else { - seen.set(fn, count + 1); - } - } - } - - var hmrDirtyComponents = new Set(); // Expose the HMR runtime on the global object - // This makes it entirely tree-shakable without polluting the exports and makes - // it easier to be used in toolings like vue-loader - // Note: for a component to be eligible for HMR it also needs the __hmrId option - // to be set so that its instances can be registered / removed. - - if (process.env.NODE_ENV !== 'production') { - var globalObject = typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {}; - globalObject.__VUE_HMR_RUNTIME__ = { - createRecord: tryWrap(createRecord), - rerender: tryWrap(rerender), - reload: tryWrap(reload) - }; - } - - var map = new Map(); - - function createRecord(id, component) { - if (!component) { - warn("HMR API usage is out of date.\n" + "Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant " + "depdendency that handles Vue SFC compilation."); - component = {}; - } - - if (map.has(id)) { - return false; - } - - map.set(id, { - component: isClassComponent(component) ? component.__vccOpts : component, - instances: new Set() - }); - return true; - } - - function rerender(id, newRender) { - var record = map.get(id); - if (!record) return; - if (newRender) record.component.render = newRender; // Array.from creates a snapshot which avoids the set being mutated during - // updates - - Array.from(record.instances).forEach(function (instance) { - if (newRender) { - instance.render = newRender; - } - - instance.renderCache = []; - instance.update(); - }); - } - - function reload(id, newComp) { - var record = map.get(id); - if (!record) return; // Array.from creates a snapshot which avoids the set being mutated during - // updates - - var component = record.component, - instances = record.instances; - - if (!hmrDirtyComponents.has(component)) { - // 1. Update existing comp definition to match new one - newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp; - extend(component, newComp); - - for (var key in component) { - if (!(key in newComp)) { - delete component[key]; - } - } // 2. Mark component dirty. This forces the renderer to replace the component - // on patch. - - - hmrDirtyComponents.add(component); // 3. Make sure to unmark the component after the reload. - - queuePostFlushCb(function () { - hmrDirtyComponents.delete(component); - }); - } - - Array.from(instances).forEach(function (instance) { - if (instance.parent) { - // 4. Force the parent instance to re-render. This will cause all updated - // components to be unmounted and re-mounted. Queue the update so that we - // don't end up forcing the same parent to re-render multiple times. - queueJob(instance.parent.update); - } else if (instance.appContext.reload) { - // root instance mounted via createApp() has a reload method - instance.appContext.reload(); - } else if (typeof window !== 'undefined') { - // root instance inside tree created via raw render(). Force reload. - window.location.reload(); - } else { - console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); - } - }); - } - - function tryWrap(fn) { - return function (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."); - } - }; - } - - function setDevtoolsHook(hook) {} - /** - * mark the current rendering instance for asset resolution (e.g. - * resolveComponent, resolveDirective) during render - */ - - - var currentRenderingInstance = null; - - function setCurrentRenderingInstance(instance) { - currentRenderingInstance = instance; - } - - function markAttrsAccessed() {} - - function filterSingleRoot(children) { - var singleRoot; - - for (var i = 0; i < children.length; i++) { - var child = children[i]; - - if (isVNode(child)) { - // ignore user comment - if (child.type !== Comment || child.children === 'v-if') { - if (singleRoot) { - // has more than 1 non-comment child, return now - return; - } else { - singleRoot = child; - } - } - } else { - return; - } - } - - return singleRoot; - } - - var isSuspense = function isSuspense(type) { - return type.__isSuspense; - }; - - function normalizeSuspenseChildren(vnode) { - var shapeFlag = vnode.shapeFlag, - children = vnode.children; - var content; - var fallback; - - if (shapeFlag & 32 - /* SLOTS_CHILDREN */ - ) { - content = normalizeSuspenseSlot(children.default); - fallback = normalizeSuspenseSlot(children.fallback); - } else { - content = normalizeSuspenseSlot(children); - fallback = normalizeVNode(null); - } - - return { - content: content, - fallback: fallback - }; - } - - function normalizeSuspenseSlot(s) { - if (isFunction(s)) { - s = s(); - } - - if (isArray(s)) { - var singleChild = filterSingleRoot(s); - - if (process.env.NODE_ENV !== 'production' && !singleChild) { - warn(" slots expect a single root node."); - } - - s = singleChild; - } - - return normalizeVNode(s); - } - - function queueEffectWithSuspense(fn, suspense) { - if (suspense && suspense.pendingBranch) { - if (isArray(fn)) { - var _suspense$effects; - - (_suspense$effects = suspense.effects).push.apply(_suspense$effects, _toConsumableArray(fn)); - } else { - suspense.effects.push(fn); - } - } else { - queuePostFlushCb(fn); - } - } - - var isRenderingCompiledSlot = 0; - - var setCompiledSlotRendering = function setCompiledSlotRendering(n) { - return isRenderingCompiledSlot += n; - }; - /** - * Wrap a slot function to memoize current rendering instance - * @private - */ - - - function withCtx(fn) { - var ctx = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentRenderingInstance; - if (!ctx) return fn; - - var renderFnWithContext = function renderFnWithContext() { - // If a user calls a compiled slot inside a template expression (#1745), it - // can mess up block tracking, so by default we need to push a null block to - // avoid that. This isn't necessary if rendering a compiled ``. - if (!isRenderingCompiledSlot) { - openBlock(true - /* null block that disables tracking */ - ); - } - - var owner = currentRenderingInstance; - setCurrentRenderingInstance(ctx); - var res = fn.apply(void 0, arguments); - setCurrentRenderingInstance(owner); - - if (!isRenderingCompiledSlot) { - closeBlock(); - } - - return res; - }; - - renderFnWithContext._c = true; - return renderFnWithContext; - } // SFC scoped style ID management. - - - var currentScopeId = null; - var scopeIdStack = []; - /** - * @private - */ - - function pushScopeId(id) { - scopeIdStack.push(currentScopeId = id); - } - /** - * @private - */ - - - function popScopeId() { - scopeIdStack.pop(); - currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null; - } - /** - * @private - */ - - - function withScopeId(id) { - return function (fn) { - return withCtx(function () { - pushScopeId(id); - var res = fn.apply(this, arguments); - popScopeId(); - return res; - }); - }; - } // initial value for watchers to trigger on undefined initial values - - - var INITIAL_WATCHER_VALUE = {}; - - function doWatch(source, cb) { - var _ref4 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_OBJ, - immediate = _ref4.immediate, - deep = _ref4.deep, - flush = _ref4.flush, - onTrack = _ref4.onTrack, - onTrigger = _ref4.onTrigger; - - var instance = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : currentInstance; - - if (process.env.NODE_ENV !== 'production' && !cb) { - if (immediate !== undefined) { - warn("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature."); - } - - if (deep !== undefined) { - warn("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature."); - } - } - - var warnInvalidSource = function warnInvalidSource(s) { - 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."); - }; - - var getter; - var forceTrigger = false; - - if (isRef(source)) { - getter = function getter() { - return source.value; - }; - - forceTrigger = !!source._shallow; - } else if (isReactive(source)) { - getter = function getter() { - return source; - }; - - deep = true; - } else if (isArray(source)) { - getter = function getter() { - return source.map(function (s) { - if (isRef(s)) { - return s.value; - } else if (isReactive(s)) { - return traverse(s); - } else if (isFunction(s)) { - return callWithErrorHandling(s, instance, 2 - /* WATCH_GETTER */ - ); - } else { - process.env.NODE_ENV !== 'production' && warnInvalidSource(s); - } - }); - }; - } else if (isFunction(source)) { - if (cb) { - // getter with cb - getter = function getter() { - return callWithErrorHandling(source, instance, 2 - /* WATCH_GETTER */ - ); - }; - } else { - // no cb -> simple effect - getter = function getter() { - if (instance && instance.isUnmounted) { - return; - } - - if (cleanup) { - cleanup(); - } - - return callWithErrorHandling(source, instance, 3 - /* WATCH_CALLBACK */ - , [onInvalidate]); - }; - } - } else { - getter = NOOP; - process.env.NODE_ENV !== 'production' && warnInvalidSource(source); - } - - if (cb && deep) { - var baseGetter = getter; - - getter = function getter() { - return traverse(baseGetter()); - }; - } - - var cleanup; - - var onInvalidate = function onInvalidate(fn) { - cleanup = runner.options.onStop = function () { - callWithErrorHandling(fn, instance, 4 - /* WATCH_CLEANUP */ - ); - }; - }; - - var oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE; - - var job = function job() { - if (!runner.active) { - return; - } - - if (cb) { - // watch(source, cb) - var newValue = runner(); - - if (deep || forceTrigger || hasChanged(newValue, oldValue)) { - // cleanup before running cb again - if (cleanup) { - cleanup(); - } - - callWithAsyncErrorHandling(cb, instance, 3 - /* WATCH_CALLBACK */ - , [newValue, // pass undefined as the old value when it's changed for the first time - oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, onInvalidate]); - oldValue = newValue; - } - } else { - // watchEffect - runner(); - } - }; // important: mark the job as a watcher callback so that scheduler knows - // it is allowed to self-trigger (#1727) - - - job.allowRecurse = !!cb; - var scheduler; - - if (flush === 'sync') { - scheduler = job; - } else if (flush === 'post') { - scheduler = function scheduler() { - return queuePostRenderEffect(job, instance && instance.suspense); - }; - } else { - // default: 'pre' - scheduler = function scheduler() { - if (!instance || instance.isMounted) { - queuePreFlushCb(job); - } else { - // with 'pre' option, the first call must happen before - // the component is mounted so it is called synchronously. - job(); - } - }; - } - - var runner = effect(getter, { - lazy: true, - onTrack: onTrack, - onTrigger: onTrigger, - scheduler: scheduler - }); - recordInstanceBoundEffect(runner, instance); // initial run - - if (cb) { - if (immediate) { - job(); - } else { - oldValue = runner(); - } - } else if (flush === 'post') { - queuePostRenderEffect(runner, instance && instance.suspense); - } else { - runner(); - } - - return function () { - stop(runner); - - if (instance) { - remove(instance.effects, runner); - } - }; - } // this.$watch - - - function instanceWatch(source, cb, options) { - var publicThis = this.proxy; - var getter = isString(source) ? function () { - return publicThis[source]; - } : source.bind(publicThis); - return doWatch(getter, cb.bind(publicThis), options, this); - } - - function traverse(value) { - var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set(); - - if (!isObject(value) || seen.has(value)) { - return value; - } - - seen.add(value); - - if (isRef(value)) { - traverse(value.value, seen); - } else if (isArray(value)) { - for (var i = 0; i < value.length; i++) { - traverse(value[i], seen); - } - } else if (isSet(value) || isMap(value)) { - value.forEach(function (v) { - traverse(v, seen); - }); - } else { - for (var key in value) { - traverse(value[key], seen); - } - } - - return value; - } - - var queuePostRenderEffect = queueEffectWithSuspense; - - var isTeleport = function isTeleport(type) { - return type.__isTeleport; - }; - - var NULL_DYNAMIC_COMPONENT = Symbol(); - var Fragment = Symbol(process.env.NODE_ENV !== 'production' ? 'Fragment' : undefined); - var Text = Symbol(process.env.NODE_ENV !== 'production' ? 'Text' : undefined); - var Comment = Symbol(process.env.NODE_ENV !== 'production' ? 'Comment' : undefined); - var Static = Symbol(process.env.NODE_ENV !== 'production' ? 'Static' : undefined); // Since v-if and v-for are the two possible ways node structure can dynamically - // change, once we consider v-if branches and each v-for fragment a block, we - // can divide a template into nested blocks, and within each block the node - // structure would be stable. This allows us to skip most children diffing - // and only worry about the dynamic nodes (indicated by patch flags). - - var blockStack = []; - var currentBlock = null; - /** - * Open a block. - * This must be called before `createBlock`. It cannot be part of `createBlock` - * because the children of the block are evaluated before `createBlock` itself - * is called. The generated code typically looks like this: - * - * ```js - * function render() { - * return (openBlock(),createBlock('div', null, [...])) - * } - * ``` - * disableTracking is true when creating a v-for fragment block, since a v-for - * fragment always diffs its children. - * - * @private - */ - - function openBlock() { - var disableTracking = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - blockStack.push(currentBlock = disableTracking ? null : []); - } - - function closeBlock() { - blockStack.pop(); - currentBlock = blockStack[blockStack.length - 1] || null; - } - /** - * Create a block root vnode. Takes the same exact arguments as `createVNode`. - * A block root keeps track of dynamic nodes within the block in the - * `dynamicChildren` array. - * - * @private - */ - - - function createBlock(type, props, children, patchFlag, dynamicProps) { - var vnode = createVNode(type, props, children, patchFlag, dynamicProps, true - /* isBlock: prevent a block from tracking itself */ - ); // save current block children on the block vnode - - vnode.dynamicChildren = currentBlock || EMPTY_ARR; // close block - - closeBlock(); // a block is always going to be patched, so track it as a child of its - // parent block - - if (currentBlock) { - currentBlock.push(vnode); - } - - return vnode; - } - - function isVNode(value) { - return value ? value.__v_isVNode === true : false; - } - - var createVNodeWithArgsTransform = function createVNodeWithArgsTransform() { - return _createVNode.apply(void 0, arguments); - }; - - var InternalObjectKey = "__vInternal"; - - var normalizeKey = function normalizeKey(_ref5) { - var key = _ref5.key; - return key != null ? key : null; - }; - - var normalizeRef = function normalizeRef(_ref6) { - var ref = _ref6.ref; - return ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? { - i: currentRenderingInstance, - r: ref - } : ref : null; - }; - - var createVNode = process.env.NODE_ENV !== 'production' ? createVNodeWithArgsTransform : _createVNode; - - function _createVNode(type) { - var _vnode; - - var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; - var children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; - var patchFlag = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0; - var dynamicProps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null; - var isBlockNode = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false; - - if (!type || type === NULL_DYNAMIC_COMPONENT) { - if (process.env.NODE_ENV !== 'production' && !type) { - warn("Invalid vnode type when creating vnode: ".concat(type, ".")); - } - - type = Comment; - } - - if (isVNode(type)) { - // createVNode receiving an existing vnode. This happens in cases like - // - // #2078 make sure to merge refs during the clone instead of overwriting it - var cloned = cloneVNode(type, props, true - /* mergeRef: true */ - ); - - if (children) { - normalizeChildren(cloned, children); - } - - return cloned; - } // class component normalization. - - - if (isClassComponent(type)) { - type = type.__vccOpts; - } // class & style normalization. - - - if (props) { - // for reactive or proxy objects, we need to clone it to enable mutation. - if (isProxy(props) || InternalObjectKey in props) { - props = extend({}, props); - } - - var _props = props, - klass = _props.class, - style = _props.style; - - if (klass && !isString(klass)) { - props.class = normalizeClass(klass); - } - - if (isObject(style)) { - // reactive state objects need to be cloned since they are likely to be - // mutated - if (isProxy(style) && !isArray(style)) { - style = extend({}, style); - } - - props.style = normalizeStyle(style); - } - } // encode the vnode type information into a bitmap - - - var shapeFlag = isString(type) ? 1 - /* ELEMENT */ - : isSuspense(type) ? 128 - /* SUSPENSE */ - : isTeleport(type) ? 64 - /* TELEPORT */ - : isObject(type) ? 4 - /* STATEFUL_COMPONENT */ - : isFunction(type) ? 2 - /* FUNCTIONAL_COMPONENT */ - : 0; - - if (process.env.NODE_ENV !== 'production' && shapeFlag & 4 - /* STATEFUL_COMPONENT */ - && isProxy(type)) { - type = toRaw(type); - warn("Vue received a Component which was made a reactive object. This can " + "lead to unnecessary performance overhead, and should be avoided by " + "marking the component with `markRaw` or using `shallowRef` " + "instead of `ref`.", "\nComponent that was made reactive: ", type); - } - - var vnode = (_vnode = { - __v_isVNode: true - }, _defineProperty(_vnode, "__v_skip" - /* SKIP */ - , true), _defineProperty(_vnode, "type", type), _defineProperty(_vnode, "props", props), _defineProperty(_vnode, "key", props && normalizeKey(props)), _defineProperty(_vnode, "ref", props && normalizeRef(props)), _defineProperty(_vnode, "scopeId", currentScopeId), _defineProperty(_vnode, "children", null), _defineProperty(_vnode, "component", null), _defineProperty(_vnode, "suspense", null), _defineProperty(_vnode, "ssContent", null), _defineProperty(_vnode, "ssFallback", null), _defineProperty(_vnode, "dirs", null), _defineProperty(_vnode, "transition", null), _defineProperty(_vnode, "el", null), _defineProperty(_vnode, "anchor", null), _defineProperty(_vnode, "target", null), _defineProperty(_vnode, "targetAnchor", null), _defineProperty(_vnode, "staticCount", 0), _defineProperty(_vnode, "shapeFlag", shapeFlag), _defineProperty(_vnode, "patchFlag", patchFlag), _defineProperty(_vnode, "dynamicProps", dynamicProps), _defineProperty(_vnode, "dynamicChildren", null), _defineProperty(_vnode, "appContext", null), _vnode); // validate key - - if (process.env.NODE_ENV !== 'production' && vnode.key !== vnode.key) { - warn("VNode created with invalid key (NaN). VNode type:", vnode.type); - } - - normalizeChildren(vnode, children); // normalize suspense children - - if (shapeFlag & 128 - /* SUSPENSE */ - ) { - var _normalizeSuspenseChi = normalizeSuspenseChildren(vnode), - content = _normalizeSuspenseChi.content, - fallback = _normalizeSuspenseChi.fallback; - - vnode.ssContent = content; - vnode.ssFallback = fallback; - } - - if ( // avoid a block node from tracking itself - !isBlockNode && // has current parent block - currentBlock && ( // presence of a patch flag indicates this node needs patching on updates. - // component nodes also should always be patched, because even if the - // component doesn't need to update, it needs to persist the instance on to - // the next vnode so that it can be properly unmounted later. - patchFlag > 0 || shapeFlag & 6 - /* COMPONENT */ - ) && // the EVENTS flag is only for hydration and if it is the only flag, the - // vnode should not be considered dynamic due to handler caching. - patchFlag !== 32 - /* HYDRATE_EVENTS */ - ) { - currentBlock.push(vnode); - } - - return vnode; - } - - function cloneVNode(vnode, extraProps) { - var _ref7; - - var mergeRef = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - // This is intentionally NOT using spread or extend to avoid the runtime - // key enumeration cost. - var props = vnode.props, - ref = vnode.ref, - patchFlag = vnode.patchFlag; - var mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props; - return _ref7 = { - __v_isVNode: true - }, _defineProperty(_ref7, "__v_skip" - /* SKIP */ - , true), _defineProperty(_ref7, "type", vnode.type), _defineProperty(_ref7, "props", mergedProps), _defineProperty(_ref7, "key", mergedProps && normalizeKey(mergedProps)), _defineProperty(_ref7, "ref", extraProps && extraProps.ref ? // #2078 in the case of - // if the vnode itself already has a ref, cloneVNode will need to merge - // the refs so the single vnode can be set on multiple refs - mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref), _defineProperty(_ref7, "scopeId", vnode.scopeId), _defineProperty(_ref7, "children", vnode.children), _defineProperty(_ref7, "target", vnode.target), _defineProperty(_ref7, "targetAnchor", vnode.targetAnchor), _defineProperty(_ref7, "staticCount", vnode.staticCount), _defineProperty(_ref7, "shapeFlag", vnode.shapeFlag), _defineProperty(_ref7, "patchFlag", extraProps && vnode.type !== Fragment ? patchFlag === -1 // hoisted node - ? 16 - /* FULL_PROPS */ - : patchFlag | 16 - /* FULL_PROPS */ - : patchFlag), _defineProperty(_ref7, "dynamicProps", vnode.dynamicProps), _defineProperty(_ref7, "dynamicChildren", vnode.dynamicChildren), _defineProperty(_ref7, "appContext", vnode.appContext), _defineProperty(_ref7, "dirs", vnode.dirs), _defineProperty(_ref7, "transition", vnode.transition), _defineProperty(_ref7, "component", vnode.component), _defineProperty(_ref7, "suspense", vnode.suspense), _defineProperty(_ref7, "ssContent", vnode.ssContent && cloneVNode(vnode.ssContent)), _defineProperty(_ref7, "ssFallback", vnode.ssFallback && cloneVNode(vnode.ssFallback)), _defineProperty(_ref7, "el", vnode.el), _defineProperty(_ref7, "anchor", vnode.anchor), _ref7; - } - /** - * @private - */ - - - function createTextVNode() { - var text = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ' '; - var flag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; - return createVNode(Text, null, text, flag); - } - - function normalizeVNode(child) { - if (child == null || typeof child === 'boolean') { - // empty placeholder - return createVNode(Comment); - } else if (isArray(child)) { - // fragment - return createVNode(Fragment, null, child); - } else if (_typeof(child) === 'object') { - // already vnode, this should be the most common since compiled templates - // always produce all-vnode children arrays - return child.el === null ? child : cloneVNode(child); - } else { - // strings and numbers - return createVNode(Text, null, String(child)); - } - } - - function normalizeChildren(vnode, children) { - var type = 0; - var shapeFlag = vnode.shapeFlag; - - if (children == null) { - children = null; - } else if (isArray(children)) { - type = 16 - /* ARRAY_CHILDREN */ - ; - } else if (_typeof(children) === 'object') { - if (shapeFlag & 1 - /* ELEMENT */ - || shapeFlag & 64 - /* TELEPORT */ - ) { - // Normalize slot to plain children for plain element and Teleport - var slot = children.default; - - if (slot) { - // _c marker is added by withCtx() indicating this is a compiled slot - slot._c && setCompiledSlotRendering(1); - normalizeChildren(vnode, slot()); - slot._c && setCompiledSlotRendering(-1); - } - - return; - } else { - type = 32 - /* SLOTS_CHILDREN */ - ; - var slotFlag = children._; - - if (!slotFlag && !(InternalObjectKey in children)) { - children._ctx = currentRenderingInstance; - } else if (slotFlag === 3 - /* FORWARDED */ - && currentRenderingInstance) { - // a child component receives forwarded slots from the parent. - // its slot type is determined by its parent's slot type. - if (currentRenderingInstance.vnode.patchFlag & 1024 - /* DYNAMIC_SLOTS */ - ) { - children._ = 2 - /* DYNAMIC */ - ; - vnode.patchFlag |= 1024 - /* DYNAMIC_SLOTS */ - ; - } else { - children._ = 1 - /* STABLE */ - ; - } - } - } - } else if (isFunction(children)) { - children = { - default: children, - _ctx: currentRenderingInstance - }; - type = 32 - /* SLOTS_CHILDREN */ - ; - } else { - children = String(children); // force teleport children to array so it can be moved around - - if (shapeFlag & 64 - /* TELEPORT */ - ) { - type = 16 - /* ARRAY_CHILDREN */ - ; - children = [createTextVNode(children)]; - } else { - type = 8 - /* TEXT_CHILDREN */ - ; - } - } - - vnode.children = children; - vnode.shapeFlag |= type; - } - - function mergeProps() { - var ret = extend({}, arguments.length <= 0 ? undefined : arguments[0]); - - for (var i = 1; i < arguments.length; i++) { - var toMerge = i < 0 || arguments.length <= i ? undefined : arguments[i]; - - for (var key in toMerge) { - if (key === 'class') { - if (ret.class !== toMerge.class) { - ret.class = normalizeClass([ret.class, toMerge.class]); - } - } else if (key === 'style') { - ret.style = normalizeStyle([ret.style, toMerge.style]); - } else if (isOn(key)) { - var existing = ret[key]; - var incoming = toMerge[key]; - - if (existing !== incoming) { - ret[key] = existing ? [].concat(existing, toMerge[key]) : incoming; - } - } else if (key !== '') { - ret[key] = toMerge[key]; - } - } - } - - return ret; - } - - var isInBeforeCreate = false; - - function resolveMergedOptions(instance) { - var raw = instance.type; - var __merged = raw.__merged, - mixins = raw.mixins, - extendsOptions = raw.extends; - if (__merged) return __merged; - var globalMixins = instance.appContext.mixins; - if (!globalMixins.length && !mixins && !extendsOptions) return raw; - var options = {}; - globalMixins.forEach(function (m) { - return mergeOptions(options, m, instance); - }); - mergeOptions(options, raw, instance); - return raw.__merged = options; - } - - function mergeOptions(to, from, instance) { - var strats = instance.appContext.config.optionMergeStrategies; - var mixins = from.mixins, - extendsOptions = from.extends; - extendsOptions && mergeOptions(to, extendsOptions, instance); - mixins && mixins.forEach(function (m) { - return mergeOptions(to, m, instance); - }); - - for (var key in from) { - if (strats && hasOwn(strats, key)) { - to[key] = strats[key](to[key], from[key], instance.proxy, key); - } else { - to[key] = from[key]; - } - } - } - /** - * #2437 In Vue 3, functional components do not have a public instance proxy but - * they exist in the internal parent chain. For code that relies on traversing - * public $parent chains, skip functional ones and go to the parent instead. - */ - - - var getPublicInstance = function getPublicInstance(i) { - return i && (i.proxy ? i.proxy : getPublicInstance(i.parent)); - }; - - var publicPropertiesMap = extend(Object.create(null), { - $: function $(i) { - return i; - }, - $el: function $el(i) { - return i.vnode.el; - }, - $data: function $data(i) { - return i.data; - }, - $props: function $props(i) { - return process.env.NODE_ENV !== 'production' ? shallowReadonly(i.props) : i.props; - }, - $attrs: function $attrs(i) { - return process.env.NODE_ENV !== 'production' ? shallowReadonly(i.attrs) : i.attrs; - }, - $slots: function $slots(i) { - return process.env.NODE_ENV !== 'production' ? shallowReadonly(i.slots) : i.slots; - }, - $refs: function $refs(i) { - return process.env.NODE_ENV !== 'production' ? shallowReadonly(i.refs) : i.refs; - }, - $parent: function $parent(i) { - return getPublicInstance(i.parent); - }, - $root: function $root(i) { - return i.root && i.root.proxy; - }, - $emit: function $emit(i) { - return i.emit; - }, - $options: function $options(i) { - return __VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type; - }, - $forceUpdate: function $forceUpdate(i) { - return function () { - return queueJob(i.update); - }; - }, - $nextTick: function $nextTick(i) { - return nextTick.bind(i.proxy); - }, - $watch: function $watch(i) { - return __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP; - } - }); - var PublicInstanceProxyHandlers = { - get: function get(_ref8, key) { - var instance = _ref8._; - var ctx = instance.ctx, - setupState = instance.setupState, - data = instance.data, - props = instance.props, - accessCache = instance.accessCache, - type = instance.type, - appContext = instance.appContext; // let @vue/reactivity know it should never observe Vue public instances. - - if (key === "__v_skip" - /* SKIP */ - ) { - return true; - } // for internal formatters to know that this is a Vue instance - - - if (process.env.NODE_ENV !== 'production' && key === '__isVue') { - return true; - } // data / props / ctx - // This getter gets called for every property access on the render context - // during render and is a major hotspot. The most expensive part of this - // is the multiple hasOwn() calls. It's much faster to do a simple property - // access on a plain object, so we use an accessCache object (with null - // prototype) to memoize what access type a key corresponds to. - - - var normalizedProps; - - if (key[0] !== '$') { - var n = accessCache[key]; - - if (n !== undefined) { - switch (n) { - case 0 - /* SETUP */ - : - return setupState[key]; - - case 1 - /* DATA */ - : - return data[key]; - - case 3 - /* CONTEXT */ - : - return ctx[key]; - - case 2 - /* PROPS */ - : - return props[key]; - // default: just fallthrough - } - } else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { - accessCache[key] = 0 - /* SETUP */ - ; - return setupState[key]; - } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { - accessCache[key] = 1 - /* DATA */ - ; - return data[key]; - } else if ( // only cache other properties when instance has declared (thus stable) - // props - (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)) { - accessCache[key] = 2 - /* PROPS */ - ; - return props[key]; - } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { - accessCache[key] = 3 - /* CONTEXT */ - ; - return ctx[key]; - } else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) { - accessCache[key] = 4 - /* OTHER */ - ; - } - } - - var publicGetter = publicPropertiesMap[key]; - var cssModule, globalProperties; // public $xxx properties - - if (publicGetter) { - if (key === '$attrs') { - track(instance, "get" - /* GET */ - , key); - process.env.NODE_ENV !== 'production' && markAttrsAccessed(); - } - - return publicGetter(instance); - } else if ( // css module (injected by vue-loader) - (cssModule = type.__cssModules) && (cssModule = cssModule[key])) { - return cssModule; - } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { - // user may set custom properties to `this` that start with `$` - accessCache[key] = 3 - /* CONTEXT */ - ; - return ctx[key]; - } else if ( // global properties - globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) { - return globalProperties[key]; - } else if (process.env.NODE_ENV !== 'production' && currentRenderingInstance && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading - // to infinite warning loop - key.indexOf('__v') !== 0)) { - if (data !== EMPTY_OBJ && (key[0] === '$' || key[0] === '_') && hasOwn(data, key)) { - warn("Property ".concat(JSON.stringify(key), " must be accessed via $data because it starts with a reserved ") + "character (\"$\" or \"_\") and is not proxied on the render context."); - } else { - warn("Property ".concat(JSON.stringify(key), " was accessed during render ") + "but is not defined on instance."); - } - } - }, - set: function set(_ref9, key, value) { - var instance = _ref9._; - var data = instance.data, - setupState = instance.setupState, - ctx = instance.ctx; - - if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { - setupState[key] = value; - } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { - data[key] = value; - } else if (key in instance.props) { - process.env.NODE_ENV !== 'production' && warn("Attempting to mutate prop \"".concat(key, "\". Props are readonly."), instance); - return false; - } - - if (key[0] === '$' && key.slice(1) in instance) { - process.env.NODE_ENV !== 'production' && warn("Attempting to mutate public property \"".concat(key, "\". ") + "Properties starting with $ are reserved and readonly.", instance); - return false; - } else { - if (process.env.NODE_ENV !== 'production' && key in instance.appContext.config.globalProperties) { - Object.defineProperty(ctx, key, { - enumerable: true, - configurable: true, - value: value - }); - } else { - ctx[key] = value; - } - } - - return true; - }, - has: function has(_ref10, key) { - var _ref10$_ = _ref10._, - data = _ref10$_.data, - setupState = _ref10$_.setupState, - accessCache = _ref10$_.accessCache, - ctx = _ref10$_.ctx, - appContext = _ref10$_.appContext, - propsOptions = _ref10$_.propsOptions; - var normalizedProps; - return accessCache[key] !== undefined || data !== EMPTY_OBJ && hasOwn(data, key) || setupState !== EMPTY_OBJ && hasOwn(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key); - } - }; - - if (process.env.NODE_ENV !== 'production' && !false) { - PublicInstanceProxyHandlers.ownKeys = function (target) { - warn("Avoid app logic that relies on enumerating keys on a component instance. " + "The keys will be empty in production mode to avoid performance overhead."); - return Reflect.ownKeys(target); - }; - } - - var RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, { - get: function get(target, key) { - // fast path for unscopables when using `with` block - if (key === Symbol.unscopables) { - return; - } - - return PublicInstanceProxyHandlers.get(target, key, target); - }, - has: function has(_, key) { - var has = key[0] !== '_' && !isGloballyWhitelisted(key); - - if (process.env.NODE_ENV !== 'production' && !has && PublicInstanceProxyHandlers.has(_, key)) { - warn("Property ".concat(JSON.stringify(key), " should not start with _ which is a reserved prefix for Vue internals.")); - } - - return has; - } - }); - var currentInstance = null; // record effects created during a component's setup() so that they can be - // stopped when the component unmounts - - function recordInstanceBoundEffect(effect) { - var instance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance; - - if (instance) { - (instance.effects || (instance.effects = [])).push(effect); - } - } - - var classifyRE = /(?:^|[-_])(\w)/g; - - var classify = function classify(str) { - return str.replace(classifyRE, function (c) { - return c.toUpperCase(); - }).replace(/[-_]/g, ''); - }; - /* istanbul ignore next */ - - - function formatComponentName(instance, Component) { - var isRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var name = isFunction(Component) ? Component.displayName || Component.name : Component.name; - - if (!name && Component.__file) { - var match = Component.__file.match(/([^/\\]+)\.\w+$/); - - if (match) { - name = match[1]; - } - } - - if (!name && instance && instance.parent) { - // try to infer the name based on reverse resolution - var inferFromRegistry = function inferFromRegistry(registry) { - for (var key in registry) { - if (registry[key] === Component) { - return key; - } - } - }; - - name = inferFromRegistry(instance.components || instance.parent.type.components) || inferFromRegistry(instance.appContext.components); - } - - return name ? classify(name) : isRoot ? "App" : "Anonymous"; - } - - function isClassComponent(value) { - return isFunction(value) && '__vccOpts' in value; - } - - var ssrContextKey = Symbol(process.env.NODE_ENV !== 'production' ? "ssrContext" : ""); - - function initCustomFormatter() { - /* eslint-disable no-restricted-globals */ - if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') { - return; - } - - var vueStyle = { - style: 'color:#3ba776' - }; - var numberStyle = { - style: 'color:#0b1bc9' - }; - var stringStyle = { - style: 'color:#b62e24' - }; - var keywordStyle = { - style: 'color:#9d288c' - }; // custom formatter for Chrome - // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html - - var formatter = { - header: function header(obj) { - // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup - if (!isObject(obj)) { - return null; - } - - if (obj.__isVue) { - return ['div', vueStyle, "VueInstance"]; - } else if (isRef(obj)) { - return ['div', {}, ['span', vueStyle, genRefFlag(obj)], '<', formatValue(obj.value), ">"]; - } else if (isReactive(obj)) { - return ['div', {}, ['span', vueStyle, 'Reactive'], '<', formatValue(obj), ">".concat(isReadonly(obj) ? " (readonly)" : "")]; - } else if (isReadonly(obj)) { - return ['div', {}, ['span', vueStyle, 'Readonly'], '<', formatValue(obj), '>']; - } - - return null; - }, - hasBody: function hasBody(obj) { - return obj && obj.__isVue; - }, - body: function body(obj) { - if (obj && obj.__isVue) { - return ['div', {}].concat(_toConsumableArray(formatInstance(obj.$))); - } - } - }; - - function formatInstance(instance) { - var blocks = []; - - if (instance.type.props && instance.props) { - blocks.push(createInstanceBlock('props', toRaw(instance.props))); - } - - if (instance.setupState !== EMPTY_OBJ) { - blocks.push(createInstanceBlock('setup', instance.setupState)); - } - - if (instance.data !== EMPTY_OBJ) { - blocks.push(createInstanceBlock('data', toRaw(instance.data))); - } - - var computed = extractKeys(instance, 'computed'); - - if (computed) { - blocks.push(createInstanceBlock('computed', computed)); - } - - var injected = extractKeys(instance, 'inject'); - - if (injected) { - blocks.push(createInstanceBlock('injected', injected)); - } - - blocks.push(['div', {}, ['span', { - style: keywordStyle.style + ';opacity:0.66' - }, '$ (internal): '], ['object', { - object: instance - }]]); - return blocks; - } - - function createInstanceBlock(type, target) { - target = extend({}, target); - - if (!Object.keys(target).length) { - return ['span', {}]; - } - - return ['div', { - style: 'line-height:1.25em;margin-bottom:0.6em' - }, ['div', { - style: 'color:#476582' - }, type], ['div', { - style: 'padding-left:1.25em' - }].concat(_toConsumableArray(Object.keys(target).map(function (key) { - return ['div', {}, ['span', keywordStyle, key + ': '], formatValue(target[key], false)]; - })))]; - } - - function formatValue(v) { - var asRaw = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; - - if (typeof v === 'number') { - return ['span', numberStyle, v]; - } else if (typeof v === 'string') { - return ['span', stringStyle, JSON.stringify(v)]; - } else if (typeof v === 'boolean') { - return ['span', keywordStyle, v]; - } else if (isObject(v)) { - return ['object', { - object: asRaw ? toRaw(v) : v - }]; - } else { - return ['span', stringStyle, String(v)]; - } - } - - function extractKeys(instance, type) { - var Comp = instance.type; - - if (isFunction(Comp)) { - return; - } - - var extracted = {}; - - for (var key in instance.ctx) { - if (isKeyOfType(Comp, key, type)) { - extracted[key] = instance.ctx[key]; - } - } - - return extracted; - } - - function isKeyOfType(Comp, key, type) { - var opts = Comp[type]; - - if (isArray(opts) && opts.includes(key) || isObject(opts) && key in opts) { - return true; - } - - if (Comp.extends && isKeyOfType(Comp.extends, key, type)) { - return true; - } - - if (Comp.mixins && Comp.mixins.some(function (m) { - return isKeyOfType(m, key, type); - })) { - return true; - } - } - - function genRefFlag(v) { - if (v._shallow) { - return "ShallowRef"; - } - - if (v.effect) { - return "ComputedRef"; - } - - return "Ref"; - } - - if (window.devtoolsFormatters) { - window.devtoolsFormatters.push(formatter); - } else { - window.devtoolsFormatters = [formatter]; - } - } - - function initDev() { - var target = getGlobalThis(); - target.__VUE__ = true; - setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__); - { - initCustomFormatter(); - } - } // This entry exports the runtime only, and is built as - - - process.env.NODE_ENV !== 'production' && initDev(); - - function getInternetExplorerVersion() { - var ua = window.navigator.userAgent; - var msie = ua.indexOf('MSIE '); - - if (msie > 0) { - // IE 10 or older => return version number - return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10); - } - - var trident = ua.indexOf('Trident/'); - - if (trident > 0) { - // IE 11 => return version number - var rv = ua.indexOf('rv:'); - return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10); - } - - var edge = ua.indexOf('Edge/'); - - if (edge > 0) { - // Edge (IE 12+) => return version number - return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10); - } // other browser - - - return -1; - } - - var isIE; - - function initCompat() { - if (!initCompat.init) { - initCompat.init = true; - isIE = getInternetExplorerVersion() !== -1; - } - } - - var script = { - name: 'ResizeObserver', - mounted: function mounted() { - var _this = this; - - initCompat(); - nextTick(function () { - _this._w = _this.$el.offsetWidth; - _this._h = _this.$el.offsetHeight; - }); - var object = document.createElement('object'); - this._resizeObject = object; - object.setAttribute('aria-hidden', 'true'); - object.setAttribute('tabindex', -1); - object.onload = this.addResizeHandlers; - object.type = 'text/html'; - - if (isIE) { - this.$el.appendChild(object); - } - - object.data = 'about:blank'; - - if (!isIE) { - this.$el.appendChild(object); - } - }, - beforeUnmount: function beforeUnmount() { - this.removeResizeHandlers(); - }, - methods: { - compareAndNotify: function compareAndNotify() { - if (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) { - this._w = this.$el.offsetWidth; - this._h = this.$el.offsetHeight; - this.$emit('notify', { - width: this._w, - height: this._h - }); - } - }, - addResizeHandlers: function addResizeHandlers() { - this._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify); - - this.compareAndNotify(); - }, - removeResizeHandlers: function removeResizeHandlers() { - if (this._resizeObject && this._resizeObject.onload) { - if (!isIE && this._resizeObject.contentDocument) { - this._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify); - } - - this.$el.removeChild(this._resizeObject); - this._resizeObject.onload = null; - this._resizeObject = null; - } - } - } - }; - - var _withId = /*#__PURE__*/withScopeId("data-v-b329ee4c"); - - pushScopeId("data-v-b329ee4c"); - var _hoisted_1 = { - class: "resize-observer", - tabindex: "-1" - }; - popScopeId(); - - var render = /*#__PURE__*/_withId(function (_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("div", _hoisted_1); - }); - - script.render = render; - script.__scopeId = "data-v-b329ee4c"; - script.__file = "src/components/ResizeObserver.vue"; - - function install(Vue) { - Vue.component('resize-observer', script); - Vue.component('ResizeObserver', script); - } - - var plugin = { - // eslint-disable-next-line no-undef - version: "0.5.0", - install: install - }; - var GlobalVue = null; - - if (typeof window !== 'undefined') { - GlobalVue = window.Vue; - } else if (typeof global !== 'undefined') { - GlobalVue = global.Vue; - } - - if (GlobalVue) { - GlobalVue.use(plugin); - } - - var _ErrorTypeStrings$1; - - function _typeof$1(obj) { - if (typeof Symbol === "function" && _typeof(Symbol.iterator) === "symbol") { - _typeof$1 = function _typeof$1(obj) { - return _typeof(obj); - }; - } else { - _typeof$1 = function _typeof$1(obj) { - return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof(obj); - }; - } - - return _typeof$1(obj); - } - - function _classCallCheck(instance, Constructor) { - if (!(instance instanceof Constructor)) { - throw new TypeError("Cannot call a class as a function"); - } - } - - function _defineProperties(target, props) { - for (var i = 0; i < props.length; i++) { - var descriptor = props[i]; - descriptor.enumerable = descriptor.enumerable || false; - descriptor.configurable = true; - if ("value" in descriptor) descriptor.writable = true; - Object.defineProperty(target, descriptor.key, descriptor); - } - } - - function _createClass(Constructor, protoProps, staticProps) { - if (protoProps) _defineProperties(Constructor.prototype, protoProps); - if (staticProps) _defineProperties(Constructor, staticProps); - return Constructor; - } - - function _toConsumableArray$1(arr) { - return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _nonIterableSpread$1(); - } - - function _arrayWithoutHoles$1(arr) { - if (Array.isArray(arr)) { - for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { - arr2[i] = arr[i]; - } - - return arr2; - } - } - - function _iterableToArray$1(iter) { - if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); - } - - function _nonIterableSpread$1() { - throw new TypeError("Invalid attempt to spread non-iterable instance"); - } - /** - * Make a map and return a function for checking if a key - * is in that map. - * IMPORTANT: all calls of this function must be prefixed with - * \/\*#\_\_PURE\_\_\*\/ - * So that rollup can tree-shake them if necessary. - */ - - - function makeMap$1(str, expectsLowerCase) { - var map = Object.create(null); - var list = str.split(','); - - for (var i = 0; i < list.length; i++) { - map[list[i]] = true; - } - - return expectsLowerCase ? function (val) { - return !!map[val.toLowerCase()]; - } : function (val) { - return !!map[val]; - }; - } - - var GLOBALS_WHITE_LISTED$1 = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl'; - var isGloballyWhitelisted$1 = /*#__PURE__*/makeMap$1(GLOBALS_WHITE_LISTED$1); - /** - * On the client we only need to offer special cases for boolean attributes that - * have different names from their corresponding dom properties: - * - itemscope -> N/A - * - allowfullscreen -> allowFullscreen - * - formnovalidate -> formNoValidate - * - ismap -> isMap - * - nomodule -> noModule - * - novalidate -> noValidate - * - readonly -> readOnly - */ - - var specialBooleanAttrs = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly"; - var isSpecialBooleanAttr = /*#__PURE__*/makeMap$1(specialBooleanAttrs); - - function normalizeStyle$1(value) { - if (isArray$1(value)) { - var res = {}; - - for (var i = 0; i < value.length; i++) { - var item = value[i]; - var normalized = normalizeStyle$1(isString$1(item) ? parseStringStyle$1(item) : item); - - if (normalized) { - for (var key in normalized) { - res[key] = normalized[key]; - } - } - } - - return res; - } else if (isObject$1(value)) { - return value; - } - } - - var listDelimiterRE$1 = /;(?![^(]*\))/g; - var propertyDelimiterRE$1 = /:(.+)/; - - function parseStringStyle$1(cssText) { - var ret = {}; - cssText.split(listDelimiterRE$1).forEach(function (item) { - if (item) { - var tmp = item.split(propertyDelimiterRE$1); - tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); - } - }); - return ret; - } - - function normalizeClass$1(value) { - var res = ''; - - if (isString$1(value)) { - res = value; - } else if (isArray$1(value)) { - for (var i = 0; i < value.length; i++) { - res += normalizeClass$1(value[i]) + ' '; - } - } else if (isObject$1(value)) { - for (var name in value) { - if (value[name]) { - res += name + ' '; - } - } - } - - return res.trim(); - } - - var EMPTY_OBJ$1 = process.env.NODE_ENV !== 'production' ? Object.freeze({}) : {}; - var EMPTY_ARR$1 = process.env.NODE_ENV !== 'production' ? Object.freeze([]) : []; - - var NOOP$1 = function NOOP() {}; - - var onRE$1 = /^on[^a-z]/; - - var isOn$1 = function isOn(key) { - return onRE$1.test(key); - }; - - var isModelListener = function isModelListener(key) { - return key.startsWith('onUpdate:'); - }; - - var extend$1 = Object.assign; - - var remove$1 = function remove(arr, el) { - var i = arr.indexOf(el); - - if (i > -1) { - arr.splice(i, 1); - } - }; - - var hasOwnProperty$1 = Object.prototype.hasOwnProperty; - - var hasOwn$1 = function hasOwn(val, key) { - return hasOwnProperty$1.call(val, key); - }; - - var isArray$1 = Array.isArray; - - var isMap$1 = function isMap(val) { - return toTypeString$1(val) === '[object Map]'; - }; - - var isSet$1 = function isSet(val) { - return toTypeString$1(val) === '[object Set]'; - }; - - var isFunction$1 = function isFunction(val) { - return typeof val === 'function'; - }; - - var isString$1 = function isString(val) { - return typeof val === 'string'; - }; - - var isSymbol$1 = function isSymbol(val) { - return _typeof(val) === 'symbol'; - }; - - var isObject$1 = function isObject(val) { - return val !== null && _typeof(val) === 'object'; - }; - - var isPromise$1 = function isPromise(val) { - return isObject$1(val) && isFunction$1(val.then) && isFunction$1(val.catch); - }; - - var objectToString$1 = Object.prototype.toString; - - var toTypeString$1 = function toTypeString(value) { - return objectToString$1.call(value); - }; - - var toRawType$1 = function toRawType(value) { - // extract "RawType" from strings like "[object RawType]" - return toTypeString$1(value).slice(8, -1); - }; - - var isIntegerKey$1 = function isIntegerKey(key) { - return isString$1(key) && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key; - }; - - var cacheStringFunction$1 = function cacheStringFunction(fn) { - var cache = Object.create(null); - return function (str) { - var hit = cache[str]; - return hit || (cache[str] = fn(str)); - }; - }; - - var camelizeRE = /-(\w)/g; - /** - * @private - */ - - var camelize = cacheStringFunction$1(function (str) { - return str.replace(camelizeRE, function (_, c) { - return c ? c.toUpperCase() : ''; - }); - }); - var hyphenateRE = /\B([A-Z])/g; - /** - * @private - */ - - var hyphenate = cacheStringFunction$1(function (str) { - return str.replace(hyphenateRE, '-$1').toLowerCase(); - }); - /** - * @private - */ - - var capitalize$1 = cacheStringFunction$1(function (str) { - return str.charAt(0).toUpperCase() + str.slice(1); - }); // compare whether a value has changed, accounting for NaN. - - var hasChanged$1 = function hasChanged(value, oldValue) { - return value !== oldValue && (value === value || oldValue === oldValue); - }; - - var _globalThis$1; - - var getGlobalThis$1 = function getGlobalThis() { - return _globalThis$1 || (_globalThis$1 = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {}); - }; - - var targetMap$1 = new WeakMap(); - var effectStack$1 = []; - var activeEffect$1; - var ITERATE_KEY$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'iterate' : ''); - var MAP_KEY_ITERATE_KEY$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'Map key iterate' : ''); - - function isEffect$1(fn) { - return fn && fn._isEffect === true; - } - - function effect$1(fn) { - var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_OBJ$1; - - if (isEffect$1(fn)) { - fn = fn.raw; - } - - var effect = createReactiveEffect$1(fn, options); - - if (!options.lazy) { - effect(); - } - - return effect; - } - - function stop$1(effect) { - if (effect.active) { - cleanup$1(effect); - - if (effect.options.onStop) { - effect.options.onStop(); - } - - effect.active = false; - } - } - - var uid$1 = 0; - - function createReactiveEffect$1(fn, options) { - var effect = function reactiveEffect() { - if (!effect.active) { - return options.scheduler ? undefined : fn(); - } - - if (!effectStack$1.includes(effect)) { - cleanup$1(effect); - - try { - enableTracking$1(); - effectStack$1.push(effect); - activeEffect$1 = effect; - return fn(); - } finally { - effectStack$1.pop(); - resetTracking$1(); - activeEffect$1 = effectStack$1[effectStack$1.length - 1]; - } - } - }; - - effect.id = uid$1++; - effect.allowRecurse = !!options.allowRecurse; - effect._isEffect = true; - effect.active = true; - effect.raw = fn; - effect.deps = []; - effect.options = options; - return effect; - } - - function cleanup$1(effect) { - var deps = effect.deps; - - if (deps.length) { - for (var i = 0; i < deps.length; i++) { - deps[i].delete(effect); - } - - deps.length = 0; - } - } - - var shouldTrack$1 = true; - var trackStack$1 = []; - - function pauseTracking$1() { - trackStack$1.push(shouldTrack$1); - shouldTrack$1 = false; - } - - function enableTracking$1() { - trackStack$1.push(shouldTrack$1); - shouldTrack$1 = true; - } - - function resetTracking$1() { - var last = trackStack$1.pop(); - shouldTrack$1 = last === undefined ? true : last; - } - - function track$1(target, type, key) { - if (!shouldTrack$1 || activeEffect$1 === undefined) { - return; - } - - var depsMap = targetMap$1.get(target); - - if (!depsMap) { - targetMap$1.set(target, depsMap = new Map()); - } - - var dep = depsMap.get(key); - - if (!dep) { - depsMap.set(key, dep = new Set()); - } - - if (!dep.has(activeEffect$1)) { - dep.add(activeEffect$1); - activeEffect$1.deps.push(dep); - - if (process.env.NODE_ENV !== 'production' && activeEffect$1.options.onTrack) { - activeEffect$1.options.onTrack({ - effect: activeEffect$1, - target: target, - type: type, - key: key - }); - } - } - } - - function trigger$1(target, type, key, newValue, oldValue, oldTarget) { - var depsMap = targetMap$1.get(target); - - if (!depsMap) { - // never been tracked - return; - } - - var effects = new Set(); - - var add = function add(effectsToAdd) { - if (effectsToAdd) { - effectsToAdd.forEach(function (effect) { - if (effect !== activeEffect$1 || effect.allowRecurse) { - effects.add(effect); - } - }); - } - }; - - if (type === "clear" - /* CLEAR */ - ) { - // collection being cleared - // trigger all effects for target - depsMap.forEach(add); - } else if (key === 'length' && isArray$1(target)) { - depsMap.forEach(function (dep, key) { - if (key === 'length' || key >= newValue) { - add(dep); - } - }); - } else { - // schedule runs for SET | ADD | DELETE - if (key !== void 0) { - add(depsMap.get(key)); - } // also run for iteration key on ADD | DELETE | Map.SET - - - switch (type) { - case "add" - /* ADD */ - : - if (!isArray$1(target)) { - add(depsMap.get(ITERATE_KEY$1)); - - if (isMap$1(target)) { - add(depsMap.get(MAP_KEY_ITERATE_KEY$1)); - } - } else if (isIntegerKey$1(key)) { - // new index added to array -> length changes - add(depsMap.get('length')); - } - - break; - - case "delete" - /* DELETE */ - : - if (!isArray$1(target)) { - add(depsMap.get(ITERATE_KEY$1)); - - if (isMap$1(target)) { - add(depsMap.get(MAP_KEY_ITERATE_KEY$1)); - } - } - - break; - - case "set" - /* SET */ - : - if (isMap$1(target)) { - add(depsMap.get(ITERATE_KEY$1)); - } - - break; - } - } - - var run = function run(effect) { - if (process.env.NODE_ENV !== 'production' && effect.options.onTrigger) { - effect.options.onTrigger({ - effect: effect, - target: target, - key: key, - type: type, - newValue: newValue, - oldValue: oldValue, - oldTarget: oldTarget - }); - } - - if (effect.options.scheduler) { - effect.options.scheduler(effect); - } else { - effect(); - } - }; - - effects.forEach(run); - } - - var builtInSymbols$1 = new Set(Object.getOwnPropertyNames(Symbol).map(function (key) { - return Symbol[key]; - }).filter(isSymbol$1)); - var get$2 = /*#__PURE__*/createGetter$1(); - var shallowGet$1 = /*#__PURE__*/createGetter$1(false, true); - var readonlyGet$1 = /*#__PURE__*/createGetter$1(true); - var shallowReadonlyGet$1 = /*#__PURE__*/createGetter$1(true, true); - var arrayInstrumentations$1 = {}; - ['includes', 'indexOf', 'lastIndexOf'].forEach(function (key) { - var method = Array.prototype[key]; - - arrayInstrumentations$1[key] = function () { - var arr = toRaw$1(this); - - for (var i = 0, l = this.length; i < l; i++) { - track$1(arr, "get" - /* GET */ - , i + ''); - } // we run the method using the original args first (which may be reactive) - - - for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - var res = method.apply(arr, args); - - if (res === -1 || res === false) { - // if that didn't work, run it again using raw values. - return method.apply(arr, args.map(toRaw$1)); - } else { - return res; - } - }; - }); - ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(function (key) { - var method = Array.prototype[key]; - - arrayInstrumentations$1[key] = function () { - pauseTracking$1(); - - for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { - args[_key3] = arguments[_key3]; - } - - var res = method.apply(this, args); - resetTracking$1(); - return res; - }; - }); - - function createGetter$1() { - var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - var shallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; - return function get(target, key, receiver) { - if (key === "__v_isReactive" - /* IS_REACTIVE */ - ) { - return !isReadonly; - } else if (key === "__v_isReadonly" - /* IS_READONLY */ - ) { - return isReadonly; - } else if (key === "__v_raw" - /* RAW */ - && receiver === (isReadonly ? readonlyMap$1 : reactiveMap$1).get(target)) { - return target; - } - - var targetIsArray = isArray$1(target); - - if (!isReadonly && targetIsArray && hasOwn$1(arrayInstrumentations$1, key)) { - return Reflect.get(arrayInstrumentations$1, key, receiver); - } - - var res = Reflect.get(target, key, receiver); - - if (isSymbol$1(key) ? builtInSymbols$1.has(key) : key === "__proto__" || key === "__v_isRef") { - return res; - } - - if (!isReadonly) { - track$1(target, "get" - /* GET */ - , key); - } - - if (shallow) { - return res; - } - - if (isRef$1(res)) { - // ref unwrapping - does not apply for Array + integer key. - var shouldUnwrap = !targetIsArray || !isIntegerKey$1(key); - return shouldUnwrap ? res.value : res; - } - - if (isObject$1(res)) { - // Convert returned value into a proxy as well. we do the isObject check - // here to avoid invalid value warning. Also need to lazy access readonly - // and reactive here to avoid circular dependency. - return isReadonly ? readonly$1(res) : reactive$1(res); - } - - return res; - }; - } - - var set$2 = /*#__PURE__*/createSetter$1(); - var shallowSet$1 = /*#__PURE__*/createSetter$1(true); - - function createSetter$1() { - var shallow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - return function set(target, key, value, receiver) { - var oldValue = target[key]; - - if (!shallow) { - value = toRaw$1(value); - - if (!isArray$1(target) && isRef$1(oldValue) && !isRef$1(value)) { - oldValue.value = value; - return true; - } - } - - var hadKey = isArray$1(target) && isIntegerKey$1(key) ? Number(key) < target.length : hasOwn$1(target, key); - var result = Reflect.set(target, key, value, receiver); // don't trigger if target is something up in the prototype chain of original - - if (target === toRaw$1(receiver)) { - if (!hadKey) { - trigger$1(target, "add" - /* ADD */ - , key, value); - } else if (hasChanged$1(value, oldValue)) { - trigger$1(target, "set" - /* SET */ - , key, value, oldValue); - } - } - - return result; - }; - } - - function deleteProperty$1(target, key) { - var hadKey = hasOwn$1(target, key); - var oldValue = target[key]; - var result = Reflect.deleteProperty(target, key); - - if (result && hadKey) { - trigger$1(target, "delete" - /* DELETE */ - , key, undefined, oldValue); - } - - return result; - } - - function has$2(target, key) { - var result = Reflect.has(target, key); - - if (!isSymbol$1(key) || !builtInSymbols$1.has(key)) { - track$1(target, "has" - /* HAS */ - , key); - } - - return result; - } - - function ownKeys$2(target) { - track$1(target, "iterate" - /* ITERATE */ - , isArray$1(target) ? 'length' : ITERATE_KEY$1); - return Reflect.ownKeys(target); - } - - var mutableHandlers$1 = { - get: get$2, - set: set$2, - deleteProperty: deleteProperty$1, - has: has$2, - ownKeys: ownKeys$2 - }; - var readonlyHandlers$1 = { - get: readonlyGet$1, - set: function set(target, key) { - if (process.env.NODE_ENV !== 'production') { - console.warn("Set operation on key \"".concat(String(key), "\" failed: target is readonly."), target); - } - - return true; - }, - deleteProperty: function deleteProperty(target, key) { - if (process.env.NODE_ENV !== 'production') { - console.warn("Delete operation on key \"".concat(String(key), "\" failed: target is readonly."), target); - } - - return true; - } - }; - var shallowReactiveHandlers$1 = extend$1({}, mutableHandlers$1, { - get: shallowGet$1, - set: shallowSet$1 - }); // Props handlers are special in the sense that it should not unwrap top-level - // refs (in order to allow refs to be explicitly passed down), but should - // retain the reactivity of the normal readonly object. - - var shallowReadonlyHandlers$1 = extend$1({}, readonlyHandlers$1, { - get: shallowReadonlyGet$1 - }); - - var toReactive$1 = function toReactive(value) { - return isObject$1(value) ? reactive$1(value) : value; - }; - - var toReadonly$1 = function toReadonly(value) { - return isObject$1(value) ? readonly$1(value) : value; - }; - - var toShallow$1 = function toShallow(value) { - return value; - }; - - var getProto$1 = function getProto(v) { - return Reflect.getPrototypeOf(v); - }; - - function get$1$1(target, key) { - var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var isShallow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; - // #1772: readonly(reactive(Map)) should return readonly + reactive version - // of the value - target = target["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw$1(target); - var rawKey = toRaw$1(key); - - if (key !== rawKey) { - !isReadonly && track$1(rawTarget, "get" - /* GET */ - , key); - } - - !isReadonly && track$1(rawTarget, "get" - /* GET */ - , rawKey); - - var _getProto = getProto$1(rawTarget), - has = _getProto.has; - - var wrap = isReadonly ? toReadonly$1 : isShallow ? toShallow$1 : toReactive$1; - - if (has.call(rawTarget, key)) { - return wrap(target.get(key)); - } else if (has.call(rawTarget, rawKey)) { - return wrap(target.get(rawKey)); - } - } - - function has$1$1(key) { - var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; - var target = this["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw$1(target); - var rawKey = toRaw$1(key); - - if (key !== rawKey) { - !isReadonly && track$1(rawTarget, "has" - /* HAS */ - , key); - } - - !isReadonly && track$1(rawTarget, "has" - /* HAS */ - , rawKey); - return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); - } - - function size$1(target) { - var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; - target = target["__v_raw" - /* RAW */ - ]; - !isReadonly && track$1(toRaw$1(target), "iterate" - /* ITERATE */ - , ITERATE_KEY$1); - return Reflect.get(target, 'size', target); - } - - function add$1(value) { - value = toRaw$1(value); - var target = toRaw$1(this); - var proto = getProto$1(target); - var hadKey = proto.has.call(target, value); - target.add(value); - - if (!hadKey) { - trigger$1(target, "add" - /* ADD */ - , value, value); - } - - return this; - } - - function set$1$1(key, value) { - value = toRaw$1(value); - var target = toRaw$1(this); - - var _getProto2 = getProto$1(target), - has = _getProto2.has, - get = _getProto2.get; - - var hadKey = has.call(target, key); - - if (!hadKey) { - key = toRaw$1(key); - hadKey = has.call(target, key); - } else if (process.env.NODE_ENV !== 'production') { - checkIdentityKeys$1(target, has, key); - } - - var oldValue = get.call(target, key); - target.set(key, value); - - if (!hadKey) { - trigger$1(target, "add" - /* ADD */ - , key, value); - } else if (hasChanged$1(value, oldValue)) { - trigger$1(target, "set" - /* SET */ - , key, value, oldValue); - } - - return this; - } - - function deleteEntry$1(key) { - var target = toRaw$1(this); - - var _getProto3 = getProto$1(target), - has = _getProto3.has, - get = _getProto3.get; - - var hadKey = has.call(target, key); - - if (!hadKey) { - key = toRaw$1(key); - hadKey = has.call(target, key); - } else if (process.env.NODE_ENV !== 'production') { - checkIdentityKeys$1(target, has, key); - } - - var oldValue = get ? get.call(target, key) : undefined; // forward the operation before queueing reactions - - var result = target.delete(key); - - if (hadKey) { - trigger$1(target, "delete" - /* DELETE */ - , key, undefined, oldValue); - } - - return result; - } - - function clear$1() { - var target = toRaw$1(this); - var hadItems = target.size !== 0; - var oldTarget = process.env.NODE_ENV !== 'production' ? isMap$1(target) ? new Map(target) : new Set(target) : undefined; // forward the operation before queueing reactions - - var result = target.clear(); - - if (hadItems) { - trigger$1(target, "clear" - /* CLEAR */ - , undefined, undefined, oldTarget); - } - - return result; - } - - function createForEach$1(isReadonly, isShallow) { - return function forEach(callback, thisArg) { - var observed = this; - var target = observed["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw$1(target); - var wrap = isReadonly ? toReadonly$1 : isShallow ? toShallow$1 : toReactive$1; - !isReadonly && track$1(rawTarget, "iterate" - /* ITERATE */ - , ITERATE_KEY$1); - return target.forEach(function (value, key) { - // important: make sure the callback is - // 1. invoked with the reactive map as `this` and 3rd arg - // 2. the value received should be a corresponding reactive/readonly. - return callback.call(thisArg, wrap(value), wrap(key), observed); - }); - }; - } - - function createIterableMethod$1(method, isReadonly, isShallow) { - return function () { - var target = this["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw$1(target); - var targetIsMap = isMap$1(rawTarget); - var isPair = method === 'entries' || method === Symbol.iterator && targetIsMap; - var isKeyOnly = method === 'keys' && targetIsMap; - var innerIterator = target[method].apply(target, arguments); - var wrap = isReadonly ? toReadonly$1 : isShallow ? toShallow$1 : toReactive$1; - !isReadonly && track$1(rawTarget, "iterate" - /* ITERATE */ - , isKeyOnly ? MAP_KEY_ITERATE_KEY$1 : ITERATE_KEY$1); // return a wrapped iterator which returns observed versions of the - // values emitted from the real iterator - - return _defineProperty({ - // iterator protocol - next: function next() { - var _innerIterator$next = innerIterator.next(), - value = _innerIterator$next.value, - done = _innerIterator$next.done; - - return done ? { - value: value, - done: done - } : { - value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), - done: done - }; - } - }, Symbol.iterator, function () { - return this; - }); - }; - } - - function createReadonlyMethod$1(type) { - return function () { - if (process.env.NODE_ENV !== 'production') { - var key = (arguments.length <= 0 ? undefined : arguments[0]) ? "on key \"".concat(arguments.length <= 0 ? undefined : arguments[0], "\" ") : ""; - console.warn("".concat(capitalize$1(type), " operation ").concat(key, "failed: target is readonly."), toRaw$1(this)); - } - - return type === "delete" - /* DELETE */ - ? false : this; - }; - } - - var mutableInstrumentations$1 = { - get: function get(key) { - return get$1$1(this, key); - }, - - get size() { - return size$1(this); - }, - - has: has$1$1, - add: add$1, - set: set$1$1, - delete: deleteEntry$1, - clear: clear$1, - forEach: createForEach$1(false, false) - }; - var shallowInstrumentations$1 = { - get: function get(key) { - return get$1$1(this, key, false, true); - }, - - get size() { - return size$1(this); - }, - - has: has$1$1, - add: add$1, - set: set$1$1, - delete: deleteEntry$1, - clear: clear$1, - forEach: createForEach$1(false, true) - }; - var readonlyInstrumentations$1 = { - get: function get(key) { - return get$1$1(this, key, true); - }, - - get size() { - return size$1(this, true); - }, - - has: function has(key) { - return has$1$1.call(this, key, true); - }, - add: createReadonlyMethod$1("add" - /* ADD */ - ), - set: createReadonlyMethod$1("set" - /* SET */ - ), - delete: createReadonlyMethod$1("delete" - /* DELETE */ - ), - clear: createReadonlyMethod$1("clear" - /* CLEAR */ - ), - forEach: createForEach$1(true, false) - }; - var iteratorMethods$1 = ['keys', 'values', 'entries', Symbol.iterator]; - iteratorMethods$1.forEach(function (method) { - mutableInstrumentations$1[method] = createIterableMethod$1(method, false, false); - readonlyInstrumentations$1[method] = createIterableMethod$1(method, true, false); - shallowInstrumentations$1[method] = createIterableMethod$1(method, false, true); - }); - - function createInstrumentationGetter$1(isReadonly, shallow) { - var instrumentations = shallow ? shallowInstrumentations$1 : isReadonly ? readonlyInstrumentations$1 : mutableInstrumentations$1; - return function (target, key, receiver) { - if (key === "__v_isReactive" - /* IS_REACTIVE */ - ) { - return !isReadonly; - } else if (key === "__v_isReadonly" - /* IS_READONLY */ - ) { - return isReadonly; - } else if (key === "__v_raw" - /* RAW */ - ) { - return target; - } - - return Reflect.get(hasOwn$1(instrumentations, key) && key in target ? instrumentations : target, key, receiver); - }; - } - - var mutableCollectionHandlers$1 = { - get: createInstrumentationGetter$1(false, false) - }; - var readonlyCollectionHandlers$1 = { - get: createInstrumentationGetter$1(true, false) - }; - - function checkIdentityKeys$1(target, has, key) { - var rawKey = toRaw$1(key); - - if (rawKey !== key && has.call(target, rawKey)) { - var type = toRawType$1(target); - console.warn("Reactive ".concat(type, " contains both the raw and reactive ") + "versions of the same object".concat(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."); - } - } - - var reactiveMap$1 = new WeakMap(); - var readonlyMap$1 = new WeakMap(); - - function targetTypeMap$1(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$1(value) { - return value["__v_skip" - /* SKIP */ - ] || !Object.isExtensible(value) ? 0 - /* INVALID */ - : targetTypeMap$1(toRawType$1(value)); - } - - function reactive$1(target) { - // if trying to observe a readonly proxy, return the readonly version. - if (target && target["__v_isReadonly" - /* IS_READONLY */ - ]) { - return target; - } - - return createReactiveObject$1(target, false, mutableHandlers$1, mutableCollectionHandlers$1); - } - /** - * Creates a readonly copy of the original object. Note the returned copy is not - * made reactive, but `readonly` can be called on an already reactive object. - */ - - - function readonly$1(target) { - return createReactiveObject$1(target, true, readonlyHandlers$1, readonlyCollectionHandlers$1); - } - /** - * Returns a reactive-copy of the original object, where only the root level - * properties are readonly, and does NOT unwrap refs nor recursively convert - * returned properties. - * This is used for creating the props proxy object for stateful components. - */ - - - function shallowReadonly$1(target) { - return createReactiveObject$1(target, true, shallowReadonlyHandlers$1, readonlyCollectionHandlers$1); - } - - function createReactiveObject$1(target, isReadonly, baseHandlers, collectionHandlers) { - if (!isObject$1(target)) { - if (process.env.NODE_ENV !== 'production') { - console.warn("value cannot be made reactive: ".concat(String(target))); - } - - return target; - } // target is already a Proxy, return it. - // exception: calling readonly() on a reactive object - - - if (target["__v_raw" - /* RAW */ - ] && !(isReadonly && target["__v_isReactive" - /* IS_REACTIVE */ - ])) { - return target; - } // target already has corresponding Proxy - - - var proxyMap = isReadonly ? readonlyMap$1 : reactiveMap$1; - var existingProxy = proxyMap.get(target); - - if (existingProxy) { - return existingProxy; - } // only a whitelist of value types can be observed. - - - var targetType = getTargetType$1(target); - - if (targetType === 0 - /* INVALID */ - ) { - return target; - } - - var proxy = new Proxy(target, targetType === 2 - /* COLLECTION */ - ? collectionHandlers : baseHandlers); - proxyMap.set(target, proxy); - return proxy; - } - - function isReactive$1(value) { - if (isReadonly$1(value)) { - return isReactive$1(value["__v_raw" - /* RAW */ - ]); - } - - return !!(value && value["__v_isReactive" - /* IS_REACTIVE */ - ]); - } - - function isReadonly$1(value) { - return !!(value && value["__v_isReadonly" - /* IS_READONLY */ - ]); - } - - function isProxy$1(value) { - return isReactive$1(value) || isReadonly$1(value); - } - - function toRaw$1(observed) { - return observed && toRaw$1(observed["__v_raw" - /* RAW */ - ]) || observed; - } - - function isRef$1(r) { - return Boolean(r && r.__v_isRef === true); - } - - var stack$1 = []; - - function pushWarningContext$1(vnode) { - stack$1.push(vnode); - } - - function popWarningContext$1() { - stack$1.pop(); - } - - function warn$1(msg) { - // avoid props formatting or warn handler tracking deps that might be mutated - // during patch, leading to infinite recursion. - pauseTracking$1(); - var instance = stack$1.length ? stack$1[stack$1.length - 1].component : null; - var appWarnHandler = instance && instance.appContext.config.warnHandler; - var trace = getComponentTrace$1(); - - for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) { - args[_key4 - 1] = arguments[_key4]; - } - - if (appWarnHandler) { - callWithErrorHandling$1(appWarnHandler, instance, 11 - /* APP_WARN_HANDLER */ - , [msg + args.join(''), instance && instance.proxy, trace.map(function (_ref5) { - var vnode = _ref5.vnode; - return "at <".concat(formatComponentName$1(instance, vnode.type), ">"); - }).join('\n'), trace]); - } else { - var _console; - - var warnArgs = ["[Vue warn]: ".concat(msg)].concat(args); - /* istanbul ignore if */ - - if (trace.length && // avoid spamming console during tests - !false) { - warnArgs.push.apply(warnArgs, ["\n"].concat(_toConsumableArray(formatTrace$1(trace)))); - } - - (_console = console).warn.apply(_console, _toConsumableArray(warnArgs)); - } - - resetTracking$1(); - } - - function getComponentTrace$1() { - var currentVNode = stack$1[stack$1.length - 1]; - - if (!currentVNode) { - return []; - } // we can't just use the stack because it will be incomplete during updates - // that did not start from the root. Re-construct the parent chain using - // instance parent pointers. - - - var normalizedStack = []; - - while (currentVNode) { - var last = normalizedStack[0]; - - if (last && last.vnode === currentVNode) { - last.recurseCount++; - } else { - normalizedStack.push({ - vnode: currentVNode, - recurseCount: 0 - }); - } - - var parentInstance = currentVNode.component && currentVNode.component.parent; - currentVNode = parentInstance && parentInstance.vnode; - } - - return normalizedStack; - } - /* istanbul ignore next */ - - - function formatTrace$1(trace) { - var logs = []; - trace.forEach(function (entry, i) { - logs.push.apply(logs, _toConsumableArray(i === 0 ? [] : ["\n"]).concat(_toConsumableArray(formatTraceEntry$1(entry)))); - }); - return logs; - } - - function formatTraceEntry$1(_ref6) { - var vnode = _ref6.vnode, - recurseCount = _ref6.recurseCount; - var postfix = recurseCount > 0 ? "... (".concat(recurseCount, " recursive calls)") : ""; - var isRoot = vnode.component ? vnode.component.parent == null : false; - var open = " at <".concat(formatComponentName$1(vnode.component, vnode.type, isRoot)); - var close = ">" + postfix; - return vnode.props ? [open].concat(_toConsumableArray(formatProps$1(vnode.props)), [close]) : [open + close]; - } - /* istanbul ignore next */ - - - function formatProps$1(props) { - var res = []; - var keys = Object.keys(props); - keys.slice(0, 3).forEach(function (key) { - res.push.apply(res, _toConsumableArray(formatProp$1(key, props[key]))); - }); - - if (keys.length > 3) { - res.push(" ..."); - } - - return res; - } - /* istanbul ignore next */ - - - function formatProp$1(key, value, raw) { - if (isString$1(value)) { - value = JSON.stringify(value); - return raw ? value : ["".concat(key, "=").concat(value)]; - } else if (typeof value === 'number' || typeof value === 'boolean' || value == null) { - return raw ? value : ["".concat(key, "=").concat(value)]; - } else if (isRef$1(value)) { - value = formatProp$1(key, toRaw$1(value.value), true); - return raw ? value : ["".concat(key, "=Ref<"), value, ">"]; - } else if (isFunction$1(value)) { - return ["".concat(key, "=fn").concat(value.name ? "<".concat(value.name, ">") : "")]; - } else { - value = toRaw$1(value); - return raw ? value : ["".concat(key, "="), value]; - } - } - - var ErrorTypeStrings$1 = (_ErrorTypeStrings$1 = {}, _defineProperty(_ErrorTypeStrings$1, "bc" - /* BEFORE_CREATE */ - , 'beforeCreate hook'), _defineProperty(_ErrorTypeStrings$1, "c" - /* CREATED */ - , 'created hook'), _defineProperty(_ErrorTypeStrings$1, "bm" - /* BEFORE_MOUNT */ - , 'beforeMount hook'), _defineProperty(_ErrorTypeStrings$1, "m" - /* MOUNTED */ - , 'mounted hook'), _defineProperty(_ErrorTypeStrings$1, "bu" - /* BEFORE_UPDATE */ - , 'beforeUpdate hook'), _defineProperty(_ErrorTypeStrings$1, "u" - /* UPDATED */ - , 'updated'), _defineProperty(_ErrorTypeStrings$1, "bum" - /* BEFORE_UNMOUNT */ - , 'beforeUnmount hook'), _defineProperty(_ErrorTypeStrings$1, "um" - /* UNMOUNTED */ - , 'unmounted hook'), _defineProperty(_ErrorTypeStrings$1, "a" - /* ACTIVATED */ - , 'activated hook'), _defineProperty(_ErrorTypeStrings$1, "da" - /* DEACTIVATED */ - , 'deactivated hook'), _defineProperty(_ErrorTypeStrings$1, "ec" - /* ERROR_CAPTURED */ - , 'errorCaptured hook'), _defineProperty(_ErrorTypeStrings$1, "rtc" - /* RENDER_TRACKED */ - , 'renderTracked hook'), _defineProperty(_ErrorTypeStrings$1, "rtg" - /* RENDER_TRIGGERED */ - , 'renderTriggered hook'), _defineProperty(_ErrorTypeStrings$1, 0 - /* SETUP_FUNCTION */ - , 'setup function'), _defineProperty(_ErrorTypeStrings$1, 1 - /* RENDER_FUNCTION */ - , 'render function'), _defineProperty(_ErrorTypeStrings$1, 2 - /* WATCH_GETTER */ - , 'watcher getter'), _defineProperty(_ErrorTypeStrings$1, 3 - /* WATCH_CALLBACK */ - , 'watcher callback'), _defineProperty(_ErrorTypeStrings$1, 4 - /* WATCH_CLEANUP */ - , 'watcher cleanup function'), _defineProperty(_ErrorTypeStrings$1, 5 - /* NATIVE_EVENT_HANDLER */ - , 'native event handler'), _defineProperty(_ErrorTypeStrings$1, 6 - /* COMPONENT_EVENT_HANDLER */ - , 'component event handler'), _defineProperty(_ErrorTypeStrings$1, 7 - /* VNODE_HOOK */ - , 'vnode hook'), _defineProperty(_ErrorTypeStrings$1, 8 - /* DIRECTIVE_HOOK */ - , 'directive hook'), _defineProperty(_ErrorTypeStrings$1, 9 - /* TRANSITION_HOOK */ - , 'transition hook'), _defineProperty(_ErrorTypeStrings$1, 10 - /* APP_ERROR_HANDLER */ - , 'app errorHandler'), _defineProperty(_ErrorTypeStrings$1, 11 - /* APP_WARN_HANDLER */ - , 'app warnHandler'), _defineProperty(_ErrorTypeStrings$1, 12 - /* FUNCTION_REF */ - , 'ref function'), _defineProperty(_ErrorTypeStrings$1, 13 - /* ASYNC_COMPONENT_LOADER */ - , 'async component loader'), _defineProperty(_ErrorTypeStrings$1, 14 - /* SCHEDULER */ - , 'scheduler flush. This is likely a Vue internals bug. ' + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'), _ErrorTypeStrings$1); - - function callWithErrorHandling$1(fn, instance, type, args) { - var res; - - try { - res = args ? fn.apply(void 0, _toConsumableArray(args)) : fn(); - } catch (err) { - handleError$1(err, instance, type); - } - - return res; - } - - function callWithAsyncErrorHandling$1(fn, instance, type, args) { - if (isFunction$1(fn)) { - var res = callWithErrorHandling$1(fn, instance, type, args); - - if (res && isPromise$1(res)) { - res.catch(function (err) { - handleError$1(err, instance, type); - }); - } - - return res; - } - - var values = []; - - for (var i = 0; i < fn.length; i++) { - values.push(callWithAsyncErrorHandling$1(fn[i], instance, type, args)); - } - - return values; - } - - function handleError$1(err, instance, type) { - var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; - var contextVNode = instance ? instance.vnode : null; - - if (instance) { - var cur = instance.parent; // the exposed instance is the render proxy to keep it consistent with 2.x - - var exposedInstance = instance.proxy; // in production the hook receives only the error code - - var errorInfo = process.env.NODE_ENV !== 'production' ? ErrorTypeStrings$1[type] : type; - - while (cur) { - var errorCapturedHooks = cur.ec; - - if (errorCapturedHooks) { - for (var i = 0; i < errorCapturedHooks.length; i++) { - if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { - return; - } - } - } - - cur = cur.parent; - } // app-level handling - - - var appErrorHandler = instance.appContext.config.errorHandler; - - if (appErrorHandler) { - callWithErrorHandling$1(appErrorHandler, null, 10 - /* APP_ERROR_HANDLER */ - , [err, exposedInstance, errorInfo]); - return; - } - } - - logError$1(err, type, contextVNode, throwInDev); - } - - function logError$1(err, type, contextVNode) { - var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; - - if (process.env.NODE_ENV !== 'production') { - var info = ErrorTypeStrings$1[type]; - - if (contextVNode) { - pushWarningContext$1(contextVNode); - } - - warn$1("Unhandled error".concat(info ? " during execution of ".concat(info) : "")); - - if (contextVNode) { - popWarningContext$1(); - } // crash in dev by default so it's more noticeable - - - if (throwInDev) { - throw err; - } else { - console.error(err); - } - } else { - // recover in prod to reduce the impact on end-user - console.error(err); - } - } - - var isFlushing$1 = false; - var isFlushPending$1 = false; - var queue$1 = []; - var flushIndex$1 = 0; - var pendingPreFlushCbs$1 = []; - var activePreFlushCbs$1 = null; - var preFlushIndex$1 = 0; - var pendingPostFlushCbs$1 = []; - var activePostFlushCbs$1 = null; - var postFlushIndex$1 = 0; - var resolvedPromise$1 = Promise.resolve(); - var currentFlushPromise$1 = null; - var currentPreFlushParentJob$1 = null; - var RECURSION_LIMIT$1 = 100; - - function nextTick$1(fn) { - var p = currentFlushPromise$1 || resolvedPromise$1; - return fn ? p.then(this ? fn.bind(this) : fn) : p; - } - - function queueJob$1(job) { - // the dedupe search uses the startIndex argument of Array.includes() - // by default the search index includes the current job that is being run - // so it cannot recursively trigger itself again. - // if the job is a watch() callback, the search will start with a +1 index to - // allow it recursively trigger itself - it is the user's responsibility to - // ensure it doesn't end up in an infinite loop. - if ((!queue$1.length || !queue$1.includes(job, isFlushing$1 && job.allowRecurse ? flushIndex$1 + 1 : flushIndex$1)) && job !== currentPreFlushParentJob$1) { - queue$1.push(job); - queueFlush$1(); - } - } - - function queueFlush$1() { - if (!isFlushing$1 && !isFlushPending$1) { - isFlushPending$1 = true; - currentFlushPromise$1 = resolvedPromise$1.then(flushJobs$1); - } - } - - function queueCb$1(cb, activeQueue, pendingQueue, index) { - if (!isArray$1(cb)) { - if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { - pendingQueue.push(cb); - } - } else { - // if cb is an array, it is a component lifecycle hook which can only be - // triggered by a job, which is already deduped in the main queue, so - // we can skip duplicate check here to improve perf - pendingQueue.push.apply(pendingQueue, _toConsumableArray(cb)); - } - - queueFlush$1(); - } - - function queuePreFlushCb$1(cb) { - queueCb$1(cb, activePreFlushCbs$1, pendingPreFlushCbs$1, preFlushIndex$1); - } - - function queuePostFlushCb$1(cb) { - queueCb$1(cb, activePostFlushCbs$1, pendingPostFlushCbs$1, postFlushIndex$1); - } - - function flushPreFlushCbs$1(seen) { - var parentJob = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; - - if (pendingPreFlushCbs$1.length) { - currentPreFlushParentJob$1 = parentJob; - activePreFlushCbs$1 = _toConsumableArray(new Set(pendingPreFlushCbs$1)); - pendingPreFlushCbs$1.length = 0; - - if (process.env.NODE_ENV !== 'production') { - seen = seen || new Map(); - } - - for (preFlushIndex$1 = 0; preFlushIndex$1 < activePreFlushCbs$1.length; preFlushIndex$1++) { - if (process.env.NODE_ENV !== 'production') { - checkRecursiveUpdates$1(seen, activePreFlushCbs$1[preFlushIndex$1]); - } - - activePreFlushCbs$1[preFlushIndex$1](); - } - - activePreFlushCbs$1 = null; - preFlushIndex$1 = 0; - currentPreFlushParentJob$1 = null; // recursively flush until it drains - - flushPreFlushCbs$1(seen, parentJob); - } - } - - function flushPostFlushCbs$1(seen) { - if (pendingPostFlushCbs$1.length) { - var deduped = _toConsumableArray(new Set(pendingPostFlushCbs$1)); - - pendingPostFlushCbs$1.length = 0; // #1947 already has active queue, nested flushPostFlushCbs call - - if (activePostFlushCbs$1) { - var _activePostFlushCbs; - - (_activePostFlushCbs = activePostFlushCbs$1).push.apply(_activePostFlushCbs, _toConsumableArray(deduped)); - - return; - } - - activePostFlushCbs$1 = deduped; - - if (process.env.NODE_ENV !== 'production') { - seen = seen || new Map(); - } - - activePostFlushCbs$1.sort(function (a, b) { - return getId$1(a) - getId$1(b); - }); - - for (postFlushIndex$1 = 0; postFlushIndex$1 < activePostFlushCbs$1.length; postFlushIndex$1++) { - if (process.env.NODE_ENV !== 'production') { - checkRecursiveUpdates$1(seen, activePostFlushCbs$1[postFlushIndex$1]); - } - - activePostFlushCbs$1[postFlushIndex$1](); - } - - activePostFlushCbs$1 = null; - postFlushIndex$1 = 0; - } - } - - var getId$1 = function getId(job) { - return job.id == null ? Infinity : job.id; - }; - - function flushJobs$1(seen) { - isFlushPending$1 = false; - isFlushing$1 = true; - - if (process.env.NODE_ENV !== 'production') { - seen = seen || new Map(); - } - - flushPreFlushCbs$1(seen); // Sort queue before flush. - // This ensures that: - // 1. Components are updated from parent to child. (because parent is always - // created before the child so its render effect will have smaller - // priority number) - // 2. If a component is unmounted during a parent component's update, - // its update can be skipped. - - queue$1.sort(function (a, b) { - return getId$1(a) - getId$1(b); - }); - - try { - for (flushIndex$1 = 0; flushIndex$1 < queue$1.length; flushIndex$1++) { - var job = queue$1[flushIndex$1]; - - if (job) { - if (process.env.NODE_ENV !== 'production') { - checkRecursiveUpdates$1(seen, job); - } - - callWithErrorHandling$1(job, null, 14 - /* SCHEDULER */ - ); - } - } - } finally { - flushIndex$1 = 0; - queue$1.length = 0; - flushPostFlushCbs$1(seen); - isFlushing$1 = false; - currentFlushPromise$1 = null; // some postFlushCb queued jobs! - // keep flushing until it drains. - - if (queue$1.length || pendingPostFlushCbs$1.length) { - flushJobs$1(seen); - } - } - } - - function checkRecursiveUpdates$1(seen, fn) { - if (!seen.has(fn)) { - seen.set(fn, 1); - } else { - var count = seen.get(fn); - - if (count > RECURSION_LIMIT$1) { - throw new Error("Maximum recursive updates exceeded. " + "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."); - } else { - seen.set(fn, count + 1); - } - } - } - - var hmrDirtyComponents$1 = new Set(); // Expose the HMR runtime on the global object - // This makes it entirely tree-shakable without polluting the exports and makes - // it easier to be used in toolings like vue-loader - // Note: for a component to be eligible for HMR it also needs the __hmrId option - // to be set so that its instances can be registered / removed. - - if (process.env.NODE_ENV !== 'production') { - var globalObject$1 = typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {}; - globalObject$1.__VUE_HMR_RUNTIME__ = { - createRecord: tryWrap$1(createRecord$1), - rerender: tryWrap$1(rerender$1), - reload: tryWrap$1(reload$1) - }; - } - - var map$1 = new Map(); - - function createRecord$1(id, component) { - if (!component) { - warn$1("HMR API usage is out of date.\n" + "Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant " + "depdendency that handles Vue SFC compilation."); - component = {}; - } - - if (map$1.has(id)) { - return false; - } - - map$1.set(id, { - component: isClassComponent$1(component) ? component.__vccOpts : component, - instances: new Set() - }); - return true; - } - - function rerender$1(id, newRender) { - var record = map$1.get(id); - if (!record) return; - if (newRender) record.component.render = newRender; // Array.from creates a snapshot which avoids the set being mutated during - // updates - - Array.from(record.instances).forEach(function (instance) { - if (newRender) { - instance.render = newRender; - } - - instance.renderCache = []; - instance.update(); - }); - } - - function reload$1(id, newComp) { - var record = map$1.get(id); - if (!record) return; // Array.from creates a snapshot which avoids the set being mutated during - // updates - - var component = record.component, - instances = record.instances; - - if (!hmrDirtyComponents$1.has(component)) { - // 1. Update existing comp definition to match new one - newComp = isClassComponent$1(newComp) ? newComp.__vccOpts : newComp; - extend$1(component, newComp); - - for (var key in component) { - if (!(key in newComp)) { - delete component[key]; - } - } // 2. Mark component dirty. This forces the renderer to replace the component - // on patch. - - - hmrDirtyComponents$1.add(component); // 3. Make sure to unmark the component after the reload. - - queuePostFlushCb$1(function () { - hmrDirtyComponents$1.delete(component); - }); - } - - Array.from(instances).forEach(function (instance) { - if (instance.parent) { - // 4. Force the parent instance to re-render. This will cause all updated - // components to be unmounted and re-mounted. Queue the update so that we - // don't end up forcing the same parent to re-render multiple times. - queueJob$1(instance.parent.update); - } else if (instance.appContext.reload) { - // root instance mounted via createApp() has a reload method - instance.appContext.reload(); - } else if (typeof window !== 'undefined') { - // root instance inside tree created via raw render(). Force reload. - window.location.reload(); - } else { - console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); - } - }); - } - - function tryWrap$1(fn) { - return function (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."); - } - }; - } - - function setDevtoolsHook$1(hook) {} - /** - * mark the current rendering instance for asset resolution (e.g. - * resolveComponent, resolveDirective) during render - */ - - - var currentRenderingInstance$1 = null; - - function markAttrsAccessed$1() {} - - function filterSingleRoot$1(children) { - var singleRoot; - - for (var i = 0; i < children.length; i++) { - var child = children[i]; - - if (isVNode$1(child)) { - // ignore user comment - if (child.type !== Comment$1 || child.children === 'v-if') { - if (singleRoot) { - // has more than 1 non-comment child, return now - return; - } else { - singleRoot = child; - } - } - } else { - return; - } - } - - return singleRoot; - } - - var isSuspense$1 = function isSuspense(type) { - return type.__isSuspense; - }; - - function normalizeSuspenseChildren$1(vnode) { - var shapeFlag = vnode.shapeFlag, - children = vnode.children; - var content; - var fallback; - - if (shapeFlag & 32 - /* SLOTS_CHILDREN */ - ) { - content = normalizeSuspenseSlot$1(children.default); - fallback = normalizeSuspenseSlot$1(children.fallback); - } else { - content = normalizeSuspenseSlot$1(children); - fallback = normalizeVNode$1(null); - } - - return { - content: content, - fallback: fallback - }; - } - - function normalizeSuspenseSlot$1(s) { - if (isFunction$1(s)) { - s = s(); - } - - if (isArray$1(s)) { - var singleChild = filterSingleRoot$1(s); - - if (process.env.NODE_ENV !== 'production' && !singleChild) { - warn$1(" slots expect a single root node."); - } - - s = singleChild; - } - - return normalizeVNode$1(s); - } - - function queueEffectWithSuspense$1(fn, suspense) { - if (suspense && suspense.pendingBranch) { - if (isArray$1(fn)) { - var _suspense$effects; - - (_suspense$effects = suspense.effects).push.apply(_suspense$effects, _toConsumableArray(fn)); - } else { - suspense.effects.push(fn); - } - } else { - queuePostFlushCb$1(fn); - } - } - - var isRenderingCompiledSlot$1 = 0; - - var setCompiledSlotRendering$1 = function setCompiledSlotRendering(n) { - return isRenderingCompiledSlot$1 += n; - }; // SFC scoped style ID management. - - - var currentScopeId$1 = null; // initial value for watchers to trigger on undefined initial values - - var INITIAL_WATCHER_VALUE$1 = {}; - - function doWatch$1(source, cb) { - var _ref7 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_OBJ$1, - immediate = _ref7.immediate, - deep = _ref7.deep, - flush = _ref7.flush, - onTrack = _ref7.onTrack, - onTrigger = _ref7.onTrigger; - - var instance = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : currentInstance$1; - - if (process.env.NODE_ENV !== 'production' && !cb) { - if (immediate !== undefined) { - warn$1("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature."); - } - - if (deep !== undefined) { - warn$1("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature."); - } - } - - var warnInvalidSource = function warnInvalidSource(s) { - warn$1("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."); - }; - - var getter; - var forceTrigger = false; - - if (isRef$1(source)) { - getter = function getter() { - return source.value; - }; - - forceTrigger = !!source._shallow; - } else if (isReactive$1(source)) { - getter = function getter() { - return source; - }; - - deep = true; - } else if (isArray$1(source)) { - getter = function getter() { - return source.map(function (s) { - if (isRef$1(s)) { - return s.value; - } else if (isReactive$1(s)) { - return traverse$1(s); - } else if (isFunction$1(s)) { - return callWithErrorHandling$1(s, instance, 2 - /* WATCH_GETTER */ - ); - } else { - process.env.NODE_ENV !== 'production' && warnInvalidSource(s); - } - }); - }; - } else if (isFunction$1(source)) { - if (cb) { - // getter with cb - getter = function getter() { - return callWithErrorHandling$1(source, instance, 2 - /* WATCH_GETTER */ - ); - }; - } else { - // no cb -> simple effect - getter = function getter() { - if (instance && instance.isUnmounted) { - return; - } - - if (cleanup) { - cleanup(); - } - - return callWithErrorHandling$1(source, instance, 3 - /* WATCH_CALLBACK */ - , [onInvalidate]); - }; - } - } else { - getter = NOOP$1; - process.env.NODE_ENV !== 'production' && warnInvalidSource(source); - } - - if (cb && deep) { - var baseGetter = getter; - - getter = function getter() { - return traverse$1(baseGetter()); - }; - } - - var cleanup; - - var onInvalidate = function onInvalidate(fn) { - cleanup = runner.options.onStop = function () { - callWithErrorHandling$1(fn, instance, 4 - /* WATCH_CLEANUP */ - ); - }; - }; - - var oldValue = isArray$1(source) ? [] : INITIAL_WATCHER_VALUE$1; - - var job = function job() { - if (!runner.active) { - return; - } - - if (cb) { - // watch(source, cb) - var newValue = runner(); - - if (deep || forceTrigger || hasChanged$1(newValue, oldValue)) { - // cleanup before running cb again - if (cleanup) { - cleanup(); - } - - callWithAsyncErrorHandling$1(cb, instance, 3 - /* WATCH_CALLBACK */ - , [newValue, // pass undefined as the old value when it's changed for the first time - oldValue === INITIAL_WATCHER_VALUE$1 ? undefined : oldValue, onInvalidate]); - oldValue = newValue; - } - } else { - // watchEffect - runner(); - } - }; // important: mark the job as a watcher callback so that scheduler knows - // it is allowed to self-trigger (#1727) - - - job.allowRecurse = !!cb; - var scheduler; - - if (flush === 'sync') { - scheduler = job; - } else if (flush === 'post') { - scheduler = function scheduler() { - return queuePostRenderEffect$1(job, instance && instance.suspense); - }; - } else { - // default: 'pre' - scheduler = function scheduler() { - if (!instance || instance.isMounted) { - queuePreFlushCb$1(job); - } else { - // with 'pre' option, the first call must happen before - // the component is mounted so it is called synchronously. - job(); - } - }; - } - - var runner = effect$1(getter, { - lazy: true, - onTrack: onTrack, - onTrigger: onTrigger, - scheduler: scheduler - }); - recordInstanceBoundEffect$1(runner, instance); // initial run - - if (cb) { - if (immediate) { - job(); - } else { - oldValue = runner(); - } - } else if (flush === 'post') { - queuePostRenderEffect$1(runner, instance && instance.suspense); - } else { - runner(); - } - - return function () { - stop$1(runner); - - if (instance) { - remove$1(instance.effects, runner); - } - }; - } // this.$watch - - - function instanceWatch$1(source, cb, options) { - var publicThis = this.proxy; - var getter = isString$1(source) ? function () { - return publicThis[source]; - } : source.bind(publicThis); - return doWatch$1(getter, cb.bind(publicThis), options, this); - } - - function traverse$1(value) { - var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set(); - - if (!isObject$1(value) || seen.has(value)) { - return value; - } - - seen.add(value); - - if (isRef$1(value)) { - traverse$1(value.value, seen); - } else if (isArray$1(value)) { - for (var i = 0; i < value.length; i++) { - traverse$1(value[i], seen); - } - } else if (isSet$1(value) || isMap$1(value)) { - value.forEach(function (v) { - traverse$1(v, seen); - }); - } else { - for (var key in value) { - traverse$1(value[key], seen); - } - } - - return value; - } - - var queuePostRenderEffect$1 = queueEffectWithSuspense$1; - - var isTeleport$1 = function isTeleport(type) { - return type.__isTeleport; - }; - - var NULL_DYNAMIC_COMPONENT$1 = Symbol(); - var Fragment$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'Fragment' : undefined); - var Text$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'Text' : undefined); - var Comment$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'Comment' : undefined); - var Static$1 = Symbol(process.env.NODE_ENV !== 'production' ? 'Static' : undefined); - var currentBlock$1 = null; // Whether we should be tracking dynamic child nodes inside a block. - - function isVNode$1(value) { - return value ? value.__v_isVNode === true : false; - } - - var createVNodeWithArgsTransform$1 = function createVNodeWithArgsTransform() { - for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { - args[_key5] = arguments[_key5]; - } - - return _createVNode$1.apply(void 0, _toConsumableArray( args)); - }; - - var InternalObjectKey$1 = "__vInternal"; - - var normalizeKey$1 = function normalizeKey(_ref8) { - var key = _ref8.key; - return key != null ? key : null; - }; - - var normalizeRef$1 = function normalizeRef(_ref9) { - var ref = _ref9.ref; - return ref != null ? isString$1(ref) || isRef$1(ref) || isFunction$1(ref) ? { - i: currentRenderingInstance$1, - r: ref - } : ref : null; - }; - - var createVNode$1 = process.env.NODE_ENV !== 'production' ? createVNodeWithArgsTransform$1 : _createVNode$1; - - function _createVNode$1(type) { - var _vnode; - - var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; - var children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; - var patchFlag = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0; - var dynamicProps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null; - var isBlockNode = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false; - - if (!type || type === NULL_DYNAMIC_COMPONENT$1) { - if (process.env.NODE_ENV !== 'production' && !type) { - warn$1("Invalid vnode type when creating vnode: ".concat(type, ".")); - } - - type = Comment$1; - } - - if (isVNode$1(type)) { - // createVNode receiving an existing vnode. This happens in cases like - // - // #2078 make sure to merge refs during the clone instead of overwriting it - var cloned = cloneVNode$1(type, props, true - /* mergeRef: true */ - ); - - if (children) { - normalizeChildren$1(cloned, children); - } - - return cloned; - } // class component normalization. - - - if (isClassComponent$1(type)) { - type = type.__vccOpts; - } // class & style normalization. - - - if (props) { - // for reactive or proxy objects, we need to clone it to enable mutation. - if (isProxy$1(props) || InternalObjectKey$1 in props) { - props = extend$1({}, props); - } - - var _props = props, - klass = _props.class, - style = _props.style; - - if (klass && !isString$1(klass)) { - props.class = normalizeClass$1(klass); - } - - if (isObject$1(style)) { - // reactive state objects need to be cloned since they are likely to be - // mutated - if (isProxy$1(style) && !isArray$1(style)) { - style = extend$1({}, style); - } - - props.style = normalizeStyle$1(style); - } - } // encode the vnode type information into a bitmap - - - var shapeFlag = isString$1(type) ? 1 - /* ELEMENT */ - : isSuspense$1(type) ? 128 - /* SUSPENSE */ - : isTeleport$1(type) ? 64 - /* TELEPORT */ - : isObject$1(type) ? 4 - /* STATEFUL_COMPONENT */ - : isFunction$1(type) ? 2 - /* FUNCTIONAL_COMPONENT */ - : 0; - - if (process.env.NODE_ENV !== 'production' && shapeFlag & 4 - /* STATEFUL_COMPONENT */ - && isProxy$1(type)) { - type = toRaw$1(type); - warn$1("Vue received a Component which was made a reactive object. This can " + "lead to unnecessary performance overhead, and should be avoided by " + "marking the component with `markRaw` or using `shallowRef` " + "instead of `ref`.", "\nComponent that was made reactive: ", type); - } - - var vnode = (_vnode = { - __v_isVNode: true - }, _defineProperty(_vnode, "__v_skip" - /* SKIP */ - , true), _defineProperty(_vnode, "type", type), _defineProperty(_vnode, "props", props), _defineProperty(_vnode, "key", props && normalizeKey$1(props)), _defineProperty(_vnode, "ref", props && normalizeRef$1(props)), _defineProperty(_vnode, "scopeId", currentScopeId$1), _defineProperty(_vnode, "children", null), _defineProperty(_vnode, "component", null), _defineProperty(_vnode, "suspense", null), _defineProperty(_vnode, "ssContent", null), _defineProperty(_vnode, "ssFallback", null), _defineProperty(_vnode, "dirs", null), _defineProperty(_vnode, "transition", null), _defineProperty(_vnode, "el", null), _defineProperty(_vnode, "anchor", null), _defineProperty(_vnode, "target", null), _defineProperty(_vnode, "targetAnchor", null), _defineProperty(_vnode, "staticCount", 0), _defineProperty(_vnode, "shapeFlag", shapeFlag), _defineProperty(_vnode, "patchFlag", patchFlag), _defineProperty(_vnode, "dynamicProps", dynamicProps), _defineProperty(_vnode, "dynamicChildren", null), _defineProperty(_vnode, "appContext", null), _vnode); // validate key - - if (process.env.NODE_ENV !== 'production' && vnode.key !== vnode.key) { - warn$1("VNode created with invalid key (NaN). VNode type:", vnode.type); - } - - normalizeChildren$1(vnode, children); // normalize suspense children - - if (shapeFlag & 128 - /* SUSPENSE */ - ) { - var _normalizeSuspenseChi = normalizeSuspenseChildren$1(vnode), - content = _normalizeSuspenseChi.content, - fallback = _normalizeSuspenseChi.fallback; - - vnode.ssContent = content; - vnode.ssFallback = fallback; - } - - if ( // avoid a block node from tracking itself - !isBlockNode && // has current parent block - currentBlock$1 && ( // presence of a patch flag indicates this node needs patching on updates. - // component nodes also should always be patched, because even if the - // component doesn't need to update, it needs to persist the instance on to - // the next vnode so that it can be properly unmounted later. - patchFlag > 0 || shapeFlag & 6 - /* COMPONENT */ - ) && // the EVENTS flag is only for hydration and if it is the only flag, the - // vnode should not be considered dynamic due to handler caching. - patchFlag !== 32 - /* HYDRATE_EVENTS */ - ) { - currentBlock$1.push(vnode); - } - - return vnode; - } - - function cloneVNode$1(vnode, extraProps) { - var _ref10; - - var mergeRef = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - // This is intentionally NOT using spread or extend to avoid the runtime - // key enumeration cost. - var props = vnode.props, - ref = vnode.ref, - patchFlag = vnode.patchFlag; - var mergedProps = extraProps ? mergeProps$1(props || {}, extraProps) : props; - return _ref10 = { - __v_isVNode: true - }, _defineProperty(_ref10, "__v_skip" - /* SKIP */ - , true), _defineProperty(_ref10, "type", vnode.type), _defineProperty(_ref10, "props", mergedProps), _defineProperty(_ref10, "key", mergedProps && normalizeKey$1(mergedProps)), _defineProperty(_ref10, "ref", extraProps && extraProps.ref ? // #2078 in the case of - // if the vnode itself already has a ref, cloneVNode will need to merge - // the refs so the single vnode can be set on multiple refs - mergeRef && ref ? isArray$1(ref) ? ref.concat(normalizeRef$1(extraProps)) : [ref, normalizeRef$1(extraProps)] : normalizeRef$1(extraProps) : ref), _defineProperty(_ref10, "scopeId", vnode.scopeId), _defineProperty(_ref10, "children", vnode.children), _defineProperty(_ref10, "target", vnode.target), _defineProperty(_ref10, "targetAnchor", vnode.targetAnchor), _defineProperty(_ref10, "staticCount", vnode.staticCount), _defineProperty(_ref10, "shapeFlag", vnode.shapeFlag), _defineProperty(_ref10, "patchFlag", extraProps && vnode.type !== Fragment$1 ? patchFlag === -1 // hoisted node - ? 16 - /* FULL_PROPS */ - : patchFlag | 16 - /* FULL_PROPS */ - : patchFlag), _defineProperty(_ref10, "dynamicProps", vnode.dynamicProps), _defineProperty(_ref10, "dynamicChildren", vnode.dynamicChildren), _defineProperty(_ref10, "appContext", vnode.appContext), _defineProperty(_ref10, "dirs", vnode.dirs), _defineProperty(_ref10, "transition", vnode.transition), _defineProperty(_ref10, "component", vnode.component), _defineProperty(_ref10, "suspense", vnode.suspense), _defineProperty(_ref10, "ssContent", vnode.ssContent && cloneVNode$1(vnode.ssContent)), _defineProperty(_ref10, "ssFallback", vnode.ssFallback && cloneVNode$1(vnode.ssFallback)), _defineProperty(_ref10, "el", vnode.el), _defineProperty(_ref10, "anchor", vnode.anchor), _ref10; - } /** + * Wrap a slot function to memoize current rendering instance * @private - */ - - - function createTextVNode$1() { - var text = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ' '; - var flag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; - return createVNode$1(Text$1, null, text, flag); - } - - function normalizeVNode$1(child) { - if (child == null || typeof child === 'boolean') { - // empty placeholder - return createVNode$1(Comment$1); - } else if (isArray$1(child)) { - // fragment - return createVNode$1(Fragment$1, null, child); - } else if (_typeof(child) === 'object') { - // already vnode, this should be the most common since compiled templates - // always produce all-vnode children arrays - return child.el === null ? child : cloneVNode$1(child); - } else { - // strings and numbers - return createVNode$1(Text$1, null, String(child)); - } - } - - function normalizeChildren$1(vnode, children) { - var type = 0; - var shapeFlag = vnode.shapeFlag; - - if (children == null) { - children = null; - } else if (isArray$1(children)) { - type = 16 - /* ARRAY_CHILDREN */ - ; - } else if (_typeof(children) === 'object') { - if (shapeFlag & 1 - /* ELEMENT */ - || shapeFlag & 64 - /* TELEPORT */ - ) { - // Normalize slot to plain children for plain element and Teleport - var slot = children.default; - - if (slot) { - // _c marker is added by withCtx() indicating this is a compiled slot - slot._c && setCompiledSlotRendering$1(1); - normalizeChildren$1(vnode, slot()); - slot._c && setCompiledSlotRendering$1(-1); - } - - return; - } else { - type = 32 - /* SLOTS_CHILDREN */ - ; - var slotFlag = children._; - - if (!slotFlag && !(InternalObjectKey$1 in children)) { - children._ctx = currentRenderingInstance$1; - } else if (slotFlag === 3 - /* FORWARDED */ - && currentRenderingInstance$1) { - // a child component receives forwarded slots from the parent. - // its slot type is determined by its parent's slot type. - if (currentRenderingInstance$1.vnode.patchFlag & 1024 - /* DYNAMIC_SLOTS */ - ) { - children._ = 2 - /* DYNAMIC */ - ; - vnode.patchFlag |= 1024 - /* DYNAMIC_SLOTS */ - ; - } else { - children._ = 1 - /* STABLE */ - ; - } - } - } - } else if (isFunction$1(children)) { - children = { - default: children, - _ctx: currentRenderingInstance$1 - }; - type = 32 - /* SLOTS_CHILDREN */ - ; - } else { - children = String(children); // force teleport children to array so it can be moved around - - if (shapeFlag & 64 - /* TELEPORT */ - ) { - type = 16 - /* ARRAY_CHILDREN */ - ; - children = [createTextVNode$1(children)]; - } else { - type = 8 - /* TEXT_CHILDREN */ - ; - } - } - - vnode.children = children; - vnode.shapeFlag |= type; - } - - function mergeProps$1() { - var ret = extend$1({}, arguments.length <= 0 ? undefined : arguments[0]); - - for (var i = 1; i < arguments.length; i++) { - var toMerge = i < 0 || arguments.length <= i ? undefined : arguments[i]; - - for (var key in toMerge) { - if (key === 'class') { - if (ret.class !== toMerge.class) { - ret.class = normalizeClass$1([ret.class, toMerge.class]); - } - } else if (key === 'style') { - ret.style = normalizeStyle$1([ret.style, toMerge.style]); - } else if (isOn$1(key)) { - var existing = ret[key]; - var incoming = toMerge[key]; - - if (existing !== incoming) { - ret[key] = existing ? [].concat(existing, toMerge[key]) : incoming; - } - } else if (key !== '') { - ret[key] = toMerge[key]; - } - } - } - - return ret; - } - - var isInBeforeCreate$1 = false; - - function resolveMergedOptions$1(instance) { - var raw = instance.type; - var __merged = raw.__merged, - mixins = raw.mixins, - extendsOptions = raw.extends; - if (__merged) return __merged; - var globalMixins = instance.appContext.mixins; - if (!globalMixins.length && !mixins && !extendsOptions) return raw; - var options = {}; - globalMixins.forEach(function (m) { - return mergeOptions$1(options, m, instance); - }); - mergeOptions$1(options, raw, instance); - return raw.__merged = options; - } - - function mergeOptions$1(to, from, instance) { - var strats = instance.appContext.config.optionMergeStrategies; - var mixins = from.mixins, - extendsOptions = from.extends; - extendsOptions && mergeOptions$1(to, extendsOptions, instance); - mixins && mixins.forEach(function (m) { - return mergeOptions$1(to, m, instance); - }); - - for (var key in from) { - if (strats && hasOwn$1(strats, key)) { - to[key] = strats[key](to[key], from[key], instance.proxy, key); - } else { - to[key] = from[key]; - } - } - } + */ + function withCtx(fn, ctx = currentRenderingInstance) { + if (!ctx) + return fn; + const renderFnWithContext = (...args) => { + // If a user calls a compiled slot inside a template expression (#1745), it + // can mess up block tracking, so by default we need to push a null block to + // avoid that. This isn't necessary if rendering a compiled ``. + if (!isRenderingCompiledSlot) { + openBlock(true /* null block that disables tracking */); + } + const owner = currentRenderingInstance; + setCurrentRenderingInstance(ctx); + const res = fn(...args); + setCurrentRenderingInstance(owner); + if (!isRenderingCompiledSlot) { + closeBlock(); + } + return res; + }; + renderFnWithContext._c = true; + return renderFnWithContext; + } + + // SFC scoped style ID management. + let currentScopeId = null; + const scopeIdStack = []; /** - * #2437 In Vue 3, functional components do not have a public instance proxy but - * they exist in the internal parent chain. For code that relies on traversing - * public $parent chains, skip functional ones and go to the parent instead. - */ - - - var getPublicInstance$1 = function getPublicInstance(i) { - return i && (i.proxy ? i.proxy : getPublicInstance(i.parent)); - }; - - var publicPropertiesMap$1 = extend$1(Object.create(null), { - $: function $(i) { - return i; - }, - $el: function $el(i) { - return i.vnode.el; - }, - $data: function $data(i) { - return i.data; - }, - $props: function $props(i) { - return process.env.NODE_ENV !== 'production' ? shallowReadonly$1(i.props) : i.props; - }, - $attrs: function $attrs(i) { - return process.env.NODE_ENV !== 'production' ? shallowReadonly$1(i.attrs) : i.attrs; - }, - $slots: function $slots(i) { - return process.env.NODE_ENV !== 'production' ? shallowReadonly$1(i.slots) : i.slots; - }, - $refs: function $refs(i) { - return process.env.NODE_ENV !== 'production' ? shallowReadonly$1(i.refs) : i.refs; - }, - $parent: function $parent(i) { - return getPublicInstance$1(i.parent); - }, - $root: function $root(i) { - return i.root && i.root.proxy; - }, - $emit: function $emit(i) { - return i.emit; - }, - $options: function $options(i) { - return __VUE_OPTIONS_API__ ? resolveMergedOptions$1(i) : i.type; - }, - $forceUpdate: function $forceUpdate(i) { - return function () { - return queueJob$1(i.update); - }; - }, - $nextTick: function $nextTick(i) { - return nextTick$1.bind(i.proxy); - }, - $watch: function $watch(i) { - return __VUE_OPTIONS_API__ ? instanceWatch$1.bind(i) : NOOP$1; - } - }); - var PublicInstanceProxyHandlers$1 = { - get: function get(_ref11, key) { - var instance = _ref11._; - var ctx = instance.ctx, - setupState = instance.setupState, - data = instance.data, - props = instance.props, - accessCache = instance.accessCache, - type = instance.type, - appContext = instance.appContext; // let @vue/reactivity know it should never observe Vue public instances. - - if (key === "__v_skip" - /* SKIP */ - ) { - return true; - } // for internal formatters to know that this is a Vue instance - - - if (process.env.NODE_ENV !== 'production' && key === '__isVue') { - return true; - } // data / props / ctx - // This getter gets called for every property access on the render context - // during render and is a major hotspot. The most expensive part of this - // is the multiple hasOwn() calls. It's much faster to do a simple property - // access on a plain object, so we use an accessCache object (with null - // prototype) to memoize what access type a key corresponds to. - - - var normalizedProps; - - if (key[0] !== '$') { - var n = accessCache[key]; - - if (n !== undefined) { - switch (n) { - case 0 - /* SETUP */ - : - return setupState[key]; - - case 1 - /* DATA */ - : - return data[key]; - - case 3 - /* CONTEXT */ - : - return ctx[key]; - - case 2 - /* PROPS */ - : - return props[key]; - // default: just fallthrough - } - } else if (setupState !== EMPTY_OBJ$1 && hasOwn$1(setupState, key)) { - accessCache[key] = 0 - /* SETUP */ - ; - return setupState[key]; - } else if (data !== EMPTY_OBJ$1 && hasOwn$1(data, key)) { - accessCache[key] = 1 - /* DATA */ - ; - return data[key]; - } else if ( // only cache other properties when instance has declared (thus stable) - // props - (normalizedProps = instance.propsOptions[0]) && hasOwn$1(normalizedProps, key)) { - accessCache[key] = 2 - /* PROPS */ - ; - return props[key]; - } else if (ctx !== EMPTY_OBJ$1 && hasOwn$1(ctx, key)) { - accessCache[key] = 3 - /* CONTEXT */ - ; - return ctx[key]; - } else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate$1) { - accessCache[key] = 4 - /* OTHER */ - ; - } - } - - var publicGetter = publicPropertiesMap$1[key]; - var cssModule, globalProperties; // public $xxx properties - - if (publicGetter) { - if (key === '$attrs') { - track$1(instance, "get" - /* GET */ - , key); - process.env.NODE_ENV !== 'production' && markAttrsAccessed$1(); - } - - return publicGetter(instance); - } else if ( // css module (injected by vue-loader) - (cssModule = type.__cssModules) && (cssModule = cssModule[key])) { - return cssModule; - } else if (ctx !== EMPTY_OBJ$1 && hasOwn$1(ctx, key)) { - // user may set custom properties to `this` that start with `$` - accessCache[key] = 3 - /* CONTEXT */ - ; - return ctx[key]; - } else if ( // global properties - globalProperties = appContext.config.globalProperties, hasOwn$1(globalProperties, key)) { - return globalProperties[key]; - } else if (process.env.NODE_ENV !== 'production' && currentRenderingInstance$1 && (!isString$1(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading - // to infinite warning loop - key.indexOf('__v') !== 0)) { - if (data !== EMPTY_OBJ$1 && (key[0] === '$' || key[0] === '_') && hasOwn$1(data, key)) { - warn$1("Property ".concat(JSON.stringify(key), " must be accessed via $data because it starts with a reserved ") + "character (\"$\" or \"_\") and is not proxied on the render context."); - } else { - warn$1("Property ".concat(JSON.stringify(key), " was accessed during render ") + "but is not defined on instance."); - } - } - }, - set: function set(_ref12, key, value) { - var instance = _ref12._; - var data = instance.data, - setupState = instance.setupState, - ctx = instance.ctx; - - if (setupState !== EMPTY_OBJ$1 && hasOwn$1(setupState, key)) { - setupState[key] = value; - } else if (data !== EMPTY_OBJ$1 && hasOwn$1(data, key)) { - data[key] = value; - } else if (key in instance.props) { - process.env.NODE_ENV !== 'production' && warn$1("Attempting to mutate prop \"".concat(key, "\". Props are readonly."), instance); - return false; - } - - if (key[0] === '$' && key.slice(1) in instance) { - process.env.NODE_ENV !== 'production' && warn$1("Attempting to mutate public property \"".concat(key, "\". ") + "Properties starting with $ are reserved and readonly.", instance); - return false; - } else { - if (process.env.NODE_ENV !== 'production' && key in instance.appContext.config.globalProperties) { - Object.defineProperty(ctx, key, { - enumerable: true, - configurable: true, - value: value - }); - } else { - ctx[key] = value; - } - } - - return true; - }, - has: function has(_ref13, key) { - var _ref13$_ = _ref13._, - data = _ref13$_.data, - setupState = _ref13$_.setupState, - accessCache = _ref13$_.accessCache, - ctx = _ref13$_.ctx, - appContext = _ref13$_.appContext, - propsOptions = _ref13$_.propsOptions; - var normalizedProps; - return accessCache[key] !== undefined || data !== EMPTY_OBJ$1 && hasOwn$1(data, key) || setupState !== EMPTY_OBJ$1 && hasOwn$1(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn$1(normalizedProps, key) || hasOwn$1(ctx, key) || hasOwn$1(publicPropertiesMap$1, key) || hasOwn$1(appContext.config.globalProperties, key); - } - }; - - if (process.env.NODE_ENV !== 'production' && !false) { - PublicInstanceProxyHandlers$1.ownKeys = function (target) { - warn$1("Avoid app logic that relies on enumerating keys on a component instance. " + "The keys will be empty in production mode to avoid performance overhead."); - return Reflect.ownKeys(target); - }; - } - - var RuntimeCompiledPublicInstanceProxyHandlers$1 = extend$1({}, PublicInstanceProxyHandlers$1, { - get: function get(target, key) { - // fast path for unscopables when using `with` block - if (key === Symbol.unscopables) { - return; - } - - return PublicInstanceProxyHandlers$1.get(target, key, target); - }, - has: function has(_, key) { - var has = key[0] !== '_' && !isGloballyWhitelisted$1(key); - - if (process.env.NODE_ENV !== 'production' && !has && PublicInstanceProxyHandlers$1.has(_, key)) { - warn$1("Property ".concat(JSON.stringify(key), " should not start with _ which is a reserved prefix for Vue internals.")); - } - - return has; - } - }); - var currentInstance$1 = null; // record effects created during a component's setup() so that they can be - // stopped when the component unmounts - - function recordInstanceBoundEffect$1(effect) { - var instance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance$1; - - if (instance) { - (instance.effects || (instance.effects = [])).push(effect); - } - } - - var classifyRE$1 = /(?:^|[-_])(\w)/g; - - var classify$1 = function classify(str) { - return str.replace(classifyRE$1, function (c) { - return c.toUpperCase(); - }).replace(/[-_]/g, ''); - }; - /* istanbul ignore next */ - - - function formatComponentName$1(instance, Component) { - var isRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var name = isFunction$1(Component) ? Component.displayName || Component.name : Component.name; - - if (!name && Component.__file) { - var match = Component.__file.match(/([^/\\]+)\.\w+$/); - - if (match) { - name = match[1]; - } - } - - if (!name && instance && instance.parent) { - // try to infer the name based on reverse resolution - var inferFromRegistry = function inferFromRegistry(registry) { - for (var key in registry) { - if (registry[key] === Component) { - return key; - } - } - }; - - name = inferFromRegistry(instance.components || instance.parent.type.components) || inferFromRegistry(instance.appContext.components); - } - - return name ? classify$1(name) : isRoot ? "App" : "Anonymous"; - } - - function isClassComponent$1(value) { - return isFunction$1(value) && '__vccOpts' in value; - } - - var ssrContextKey$1 = Symbol(process.env.NODE_ENV !== 'production' ? "ssrContext" : ""); - - function initCustomFormatter$1() { - /* eslint-disable no-restricted-globals */ - if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') { - return; - } - - var vueStyle = { - style: 'color:#3ba776' - }; - var numberStyle = { - style: 'color:#0b1bc9' - }; - var stringStyle = { - style: 'color:#b62e24' - }; - var keywordStyle = { - style: 'color:#9d288c' - }; // custom formatter for Chrome - // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html - - var formatter = { - header: function header(obj) { - // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup - if (!isObject$1(obj)) { - return null; - } - - if (obj.__isVue) { - return ['div', vueStyle, "VueInstance"]; - } else if (isRef$1(obj)) { - return ['div', {}, ['span', vueStyle, genRefFlag(obj)], '<', formatValue(obj.value), ">"]; - } else if (isReactive$1(obj)) { - return ['div', {}, ['span', vueStyle, 'Reactive'], '<', formatValue(obj), ">".concat(isReadonly$1(obj) ? " (readonly)" : "")]; - } else if (isReadonly$1(obj)) { - return ['div', {}, ['span', vueStyle, 'Readonly'], '<', formatValue(obj), '>']; - } - - return null; - }, - hasBody: function hasBody(obj) { - return obj && obj.__isVue; - }, - body: function body(obj) { - if (obj && obj.__isVue) { - return ['div', {}].concat(_toConsumableArray(formatInstance(obj.$))); - } - } - }; - - function formatInstance(instance) { - var blocks = []; - - if (instance.type.props && instance.props) { - blocks.push(createInstanceBlock('props', toRaw$1(instance.props))); - } - - if (instance.setupState !== EMPTY_OBJ$1) { - blocks.push(createInstanceBlock('setup', instance.setupState)); - } - - if (instance.data !== EMPTY_OBJ$1) { - blocks.push(createInstanceBlock('data', toRaw$1(instance.data))); - } - - var computed = extractKeys(instance, 'computed'); - - if (computed) { - blocks.push(createInstanceBlock('computed', computed)); - } - - var injected = extractKeys(instance, 'inject'); - - if (injected) { - blocks.push(createInstanceBlock('injected', injected)); - } - - blocks.push(['div', {}, ['span', { - style: keywordStyle.style + ';opacity:0.66' - }, '$ (internal): '], ['object', { - object: instance - }]]); - return blocks; - } - - function createInstanceBlock(type, target) { - target = extend$1({}, target); - - if (!Object.keys(target).length) { - return ['span', {}]; - } - - return ['div', { - style: 'line-height:1.25em;margin-bottom:0.6em' - }, ['div', { - style: 'color:#476582' - }, type], ['div', { - style: 'padding-left:1.25em' - }].concat(_toConsumableArray(Object.keys(target).map(function (key) { - return ['div', {}, ['span', keywordStyle, key + ': '], formatValue(target[key], false)]; - })))]; - } - - function formatValue(v) { - var asRaw = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; - - if (typeof v === 'number') { - return ['span', numberStyle, v]; - } else if (typeof v === 'string') { - return ['span', stringStyle, JSON.stringify(v)]; - } else if (typeof v === 'boolean') { - return ['span', keywordStyle, v]; - } else if (isObject$1(v)) { - return ['object', { - object: asRaw ? toRaw$1(v) : v - }]; - } else { - return ['span', stringStyle, String(v)]; - } - } - - function extractKeys(instance, type) { - var Comp = instance.type; - - if (isFunction$1(Comp)) { - return; - } - - var extracted = {}; - - for (var key in instance.ctx) { - if (isKeyOfType(Comp, key, type)) { - extracted[key] = instance.ctx[key]; - } - } - - return extracted; - } - - function isKeyOfType(Comp, key, type) { - var opts = Comp[type]; - - if (isArray$1(opts) && opts.includes(key) || isObject$1(opts) && key in opts) { - return true; - } - - if (Comp.extends && isKeyOfType(Comp.extends, key, type)) { - return true; - } - - if (Comp.mixins && Comp.mixins.some(function (m) { - return isKeyOfType(m, key, type); - })) { - return true; - } - } - - function genRefFlag(v) { - if (v._shallow) { - return "ShallowRef"; - } - - if (v.effect) { - return "ComputedRef"; - } - - return "Ref"; - } - - if (window.devtoolsFormatters) { - window.devtoolsFormatters.push(formatter); - } else { - window.devtoolsFormatters = [formatter]; - } - } - - var svgNS = 'http://www.w3.org/2000/svg'; - var doc = typeof document !== 'undefined' ? document : null; - var tempContainer; - var tempSVGContainer; - var nodeOps = { - insert: function insert(child, parent, anchor) { - parent.insertBefore(child, anchor || null); - }, - remove: function remove(child) { - var parent = child.parentNode; - - if (parent) { - parent.removeChild(child); - } - }, - createElement: function createElement(tag, isSVG, is) { - return isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? { - is: is - } : undefined); - }, - createText: function createText(text) { - return doc.createTextNode(text); - }, - createComment: function createComment(text) { - return doc.createComment(text); - }, - setText: function setText(node, text) { - node.nodeValue = text; - }, - setElementText: function setElementText(el, text) { - el.textContent = text; - }, - parentNode: function parentNode(node) { - return node.parentNode; - }, - nextSibling: function nextSibling(node) { - return node.nextSibling; - }, - querySelector: function querySelector(selector) { - return doc.querySelector(selector); - }, - setScopeId: function setScopeId(el, id) { - el.setAttribute(id, ''); - }, - cloneNode: function cloneNode(el) { - return el.cloneNode(true); - }, - // __UNSAFE__ - // Reason: innerHTML. - // Static content here can only come from compiled templates. - // As long as the user only uses trusted templates, this is safe. - insertStaticContent: function insertStaticContent(content, parent, anchor, isSVG) { - var temp = isSVG ? tempSVGContainer || (tempSVGContainer = doc.createElementNS(svgNS, 'svg')) : tempContainer || (tempContainer = doc.createElement('div')); - temp.innerHTML = content; - var first = temp.firstChild; - var node = first; - var last = node; - - while (node) { - last = node; - nodeOps.insert(node, parent, anchor); - node = temp.firstChild; - } - - return [first, last]; - } - }; // compiler should normalize class + :class bindings on the same element - // into a single binding ['staticClass', dynamic] - - function patchClass(el, value, isSVG) { - if (value == null) { - value = ''; - } - - if (isSVG) { - el.setAttribute('class', value); - } else { - // directly setting className should be faster than setAttribute in theory - // if this is an element during a transition, take the temporary transition - // classes into account. - var transitionClasses = el._vtc; - - if (transitionClasses) { - value = (value ? [value].concat(_toConsumableArray(transitionClasses)) : _toConsumableArray(transitionClasses)).join(' '); - } - - el.className = value; - } - } - - function patchStyle(el, prev, next) { - var style = el.style; - - if (!next) { - el.removeAttribute('style'); - } else if (isString$1(next)) { - if (prev !== next) { - style.cssText = next; - } - } else { - for (var key in next) { - setStyle(style, key, next[key]); - } - - if (prev && !isString$1(prev)) { - for (var _key6 in prev) { - if (next[_key6] == null) { - setStyle(style, _key6, ''); - } - } - } - } + * @private + */ + function pushScopeId(id) { + scopeIdStack.push((currentScopeId = id)); + } + /** + * @private + */ + function popScopeId() { + scopeIdStack.pop(); + currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null; + } + /** + * @private + */ + function withScopeId(id) { + return ((fn) => withCtx(function () { + pushScopeId(id); + const res = fn.apply(this, arguments); + popScopeId(); + return res; + })); + } + // initial value for watchers to trigger on undefined initial values + const INITIAL_WATCHER_VALUE = {}; + function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) { + if ((process.env.NODE_ENV !== 'production') && !cb) { + if (immediate !== undefined) { + warn(`watch() "immediate" option is only respected when using the ` + + `watch(source, callback, options?) signature.`); + } + if (deep !== undefined) { + warn(`watch() "deep" option is only respected when using the ` + + `watch(source, callback, options?) signature.`); + } + } + const warnInvalidSource = (s) => { + 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.`); + }; + let getter; + let forceTrigger = false; + if (isRef(source)) { + getter = () => source.value; + forceTrigger = !!source._shallow; + } + else if (isReactive(source)) { + getter = () => source; + deep = true; + } + else if (isArray(source)) { + getter = () => source.map(s => { + if (isRef(s)) { + return s.value; + } + else if (isReactive(s)) { + return traverse(s); + } + else if (isFunction(s)) { + return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */); + } + else { + (process.env.NODE_ENV !== 'production') && warnInvalidSource(s); + } + }); + } + else if (isFunction(source)) { + if (cb) { + // getter with cb + getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */); + } + else { + // no cb -> simple effect + getter = () => { + if (instance && instance.isUnmounted) { + return; + } + if (cleanup) { + cleanup(); + } + return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]); + }; + } + } + else { + getter = NOOP; + (process.env.NODE_ENV !== 'production') && warnInvalidSource(source); + } + if (cb && deep) { + const baseGetter = getter; + getter = () => traverse(baseGetter()); + } + let cleanup; + const onInvalidate = (fn) => { + cleanup = runner.options.onStop = () => { + callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */); + }; + }; + let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE; + const job = () => { + if (!runner.active) { + return; + } + if (cb) { + // watch(source, cb) + const newValue = runner(); + if (deep || forceTrigger || hasChanged(newValue, oldValue)) { + // cleanup before running cb again + if (cleanup) { + cleanup(); + } + callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, + onInvalidate + ]); + oldValue = newValue; + } + } + else { + // watchEffect + runner(); + } + }; + // important: mark the job as a watcher callback so that scheduler knows + // it is allowed to self-trigger (#1727) + job.allowRecurse = !!cb; + let scheduler; + if (flush === 'sync') { + scheduler = job; + } + else if (flush === 'post') { + scheduler = () => queuePostRenderEffect(job, instance && instance.suspense); + } + else { + // default: 'pre' + scheduler = () => { + if (!instance || instance.isMounted) { + queuePreFlushCb(job); + } + else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job(); + } + }; + } + const runner = effect(getter, { + lazy: true, + onTrack, + onTrigger, + scheduler + }); + recordInstanceBoundEffect(runner, instance); + // initial run + if (cb) { + if (immediate) { + job(); + } + else { + oldValue = runner(); + } + } + else if (flush === 'post') { + queuePostRenderEffect(runner, instance && instance.suspense); + } + else { + runner(); + } + return () => { + stop(runner); + if (instance) { + remove(instance.effects, runner); + } + }; + } + // this.$watch + function instanceWatch(source, cb, options) { + const publicThis = this.proxy; + const getter = isString(source) + ? () => publicThis[source] + : source.bind(publicThis); + return doWatch(getter, cb.bind(publicThis), options, this); + } + function traverse(value, seen = new Set()) { + if (!isObject(value) || seen.has(value)) { + return value; + } + seen.add(value); + if (isRef(value)) { + traverse(value.value, seen); + } + else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + traverse(value[i], seen); + } + } + else if (isSet(value) || isMap(value)) { + value.forEach((v) => { + traverse(v, seen); + }); + } + else { + for (const key in value) { + traverse(value[key], seen); + } + } + return value; + } + const queuePostRenderEffect = queueEffectWithSuspense + ; + + const isTeleport = (type) => type.__isTeleport; + const NULL_DYNAMIC_COMPONENT = Symbol(); + + const Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined); + const Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined); + const Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined); + const Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined); + // Since v-if and v-for are the two possible ways node structure can dynamically + // change, once we consider v-if branches and each v-for fragment a block, we + // can divide a template into nested blocks, and within each block the node + // structure would be stable. This allows us to skip most children diffing + // and only worry about the dynamic nodes (indicated by patch flags). + const blockStack = []; + let currentBlock = null; + /** + * Open a block. + * This must be called before `createBlock`. It cannot be part of `createBlock` + * because the children of the block are evaluated before `createBlock` itself + * is called. The generated code typically looks like this: + * + * ```js + * function render() { + * return (openBlock(),createBlock('div', null, [...])) + * } + * ``` + * disableTracking is true when creating a v-for fragment block, since a v-for + * fragment always diffs its children. + * + * @private + */ + function openBlock(disableTracking = false) { + blockStack.push((currentBlock = disableTracking ? null : [])); + } + function closeBlock() { + blockStack.pop(); + currentBlock = blockStack[blockStack.length - 1] || null; + } + /** + * Create a block root vnode. Takes the same exact arguments as `createVNode`. + * A block root keeps track of dynamic nodes within the block in the + * `dynamicChildren` array. + * + * @private + */ + function createBlock(type, props, children, patchFlag, dynamicProps) { + const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */); + // save current block children on the block vnode + vnode.dynamicChildren = currentBlock || EMPTY_ARR; + // close block + closeBlock(); + // a block is always going to be patched, so track it as a child of its + // parent block + if ( currentBlock) { + currentBlock.push(vnode); + } + return vnode; + } + function isVNode(value) { + return value ? value.__v_isVNode === true : false; + } + const createVNodeWithArgsTransform = (...args) => { + return _createVNode(...( args)); + }; + const InternalObjectKey = `__vInternal`; + const normalizeKey = ({ key }) => key != null ? key : null; + const normalizeRef = ({ ref }) => { + return (ref != null + ? isString(ref) || isRef(ref) || isFunction(ref) + ? { i: currentRenderingInstance, r: ref } + : ref + : null); + }; + const createVNode = ((process.env.NODE_ENV !== 'production') + ? createVNodeWithArgsTransform + : _createVNode); + function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) { + if (!type || type === NULL_DYNAMIC_COMPONENT) { + if ((process.env.NODE_ENV !== 'production') && !type) { + warn(`Invalid vnode type when creating vnode: ${type}.`); + } + type = Comment; + } + if (isVNode(type)) { + // createVNode receiving an existing vnode. This happens in cases like + // + // #2078 make sure to merge refs during the clone instead of overwriting it + const cloned = cloneVNode(type, props, true /* mergeRef: true */); + if (children) { + normalizeChildren(cloned, children); + } + return cloned; + } + // class component normalization. + if (isClassComponent(type)) { + type = type.__vccOpts; + } + // class & style normalization. + if (props) { + // for reactive or proxy objects, we need to clone it to enable mutation. + if (isProxy(props) || InternalObjectKey in props) { + props = extend({}, props); + } + let { class: klass, style } = props; + if (klass && !isString(klass)) { + props.class = normalizeClass(klass); + } + if (isObject(style)) { + // reactive state objects need to be cloned since they are likely to be + // mutated + if (isProxy(style) && !isArray(style)) { + style = extend({}, style); + } + props.style = normalizeStyle(style); + } + } + // encode the vnode type information into a bitmap + const shapeFlag = isString(type) + ? 1 /* ELEMENT */ + : isSuspense(type) + ? 128 /* SUSPENSE */ + : isTeleport(type) + ? 64 /* TELEPORT */ + : isObject(type) + ? 4 /* STATEFUL_COMPONENT */ + : isFunction(type) + ? 2 /* FUNCTIONAL_COMPONENT */ + : 0; + if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) { + type = toRaw(type); + warn(`Vue received a Component which was made a reactive object. This can ` + + `lead to unnecessary performance overhead, and should be avoided by ` + + `marking the component with \`markRaw\` or using \`shallowRef\` ` + + `instead of \`ref\`.`, `\nComponent that was made reactive: `, type); + } + const vnode = { + __v_isVNode: true, + ["__v_skip" /* SKIP */]: true, + type, + props, + key: props && normalizeKey(props), + ref: props && normalizeRef(props), + scopeId: currentScopeId, + children: null, + component: null, + suspense: null, + ssContent: null, + ssFallback: null, + dirs: null, + transition: null, + el: null, + anchor: null, + target: null, + targetAnchor: null, + staticCount: 0, + shapeFlag, + patchFlag, + dynamicProps, + dynamicChildren: null, + appContext: null + }; + // validate key + if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) { + warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type); + } + normalizeChildren(vnode, children); + // normalize suspense children + if ( shapeFlag & 128 /* SUSPENSE */) { + const { content, fallback } = normalizeSuspenseChildren(vnode); + vnode.ssContent = content; + vnode.ssFallback = fallback; + } + if ( + // avoid a block node from tracking itself + !isBlockNode && + // has current parent block + currentBlock && + // presence of a patch flag indicates this node needs patching on updates. + // component nodes also should always be patched, because even if the + // component doesn't need to update, it needs to persist the instance on to + // the next vnode so that it can be properly unmounted later. + (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) && + // the EVENTS flag is only for hydration and if it is the only flag, the + // vnode should not be considered dynamic due to handler caching. + patchFlag !== 32 /* HYDRATE_EVENTS */) { + currentBlock.push(vnode); + } + return vnode; + } + function cloneVNode(vnode, extraProps, mergeRef = false) { + // This is intentionally NOT using spread or extend to avoid the runtime + // key enumeration cost. + const { props, ref, patchFlag } = vnode; + const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props; + return { + __v_isVNode: true, + ["__v_skip" /* SKIP */]: true, + type: vnode.type, + props: mergedProps, + key: mergedProps && normalizeKey(mergedProps), + ref: extraProps && extraProps.ref + ? // #2078 in the case of + // if the vnode itself already has a ref, cloneVNode will need to merge + // the refs so the single vnode can be set on multiple refs + mergeRef && ref + ? isArray(ref) + ? ref.concat(normalizeRef(extraProps)) + : [ref, normalizeRef(extraProps)] + : normalizeRef(extraProps) + : ref, + scopeId: vnode.scopeId, + children: vnode.children, + target: vnode.target, + targetAnchor: vnode.targetAnchor, + staticCount: vnode.staticCount, + shapeFlag: vnode.shapeFlag, + // if the vnode is cloned with extra props, we can no longer assume its + // existing patch flag to be reliable and need to add the FULL_PROPS flag. + // note: perserve flag for fragments since they use the flag for children + // fast paths only. + patchFlag: extraProps && vnode.type !== Fragment + ? patchFlag === -1 // hoisted node + ? 16 /* FULL_PROPS */ + : patchFlag | 16 /* FULL_PROPS */ + : patchFlag, + dynamicProps: vnode.dynamicProps, + dynamicChildren: vnode.dynamicChildren, + appContext: vnode.appContext, + dirs: vnode.dirs, + transition: vnode.transition, + // These should technically only be non-null on mounted VNodes. However, + // they *should* be copied for kept-alive vnodes. So we just always copy + // them since them being non-null during a mount doesn't affect the logic as + // they will simply be overwritten. + component: vnode.component, + suspense: vnode.suspense, + ssContent: vnode.ssContent && cloneVNode(vnode.ssContent), + ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback), + el: vnode.el, + anchor: vnode.anchor + }; + } + /** + * @private + */ + function createTextVNode(text = ' ', flag = 0) { + return createVNode(Text, null, text, flag); + } + function normalizeVNode(child) { + if (child == null || typeof child === 'boolean') { + // empty placeholder + return createVNode(Comment); + } + else if (isArray(child)) { + // fragment + return createVNode(Fragment, null, child); + } + else if (typeof child === 'object') { + // already vnode, this should be the most common since compiled templates + // always produce all-vnode children arrays + return child.el === null ? child : cloneVNode(child); + } + else { + // strings and numbers + return createVNode(Text, null, String(child)); + } + } + function normalizeChildren(vnode, children) { + let type = 0; + const { shapeFlag } = vnode; + if (children == null) { + children = null; + } + else if (isArray(children)) { + type = 16 /* ARRAY_CHILDREN */; + } + else if (typeof children === 'object') { + if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) { + // Normalize slot to plain children for plain element and Teleport + const slot = children.default; + if (slot) { + // _c marker is added by withCtx() indicating this is a compiled slot + slot._c && setCompiledSlotRendering(1); + normalizeChildren(vnode, slot()); + slot._c && setCompiledSlotRendering(-1); + } + return; + } + else { + type = 32 /* SLOTS_CHILDREN */; + const slotFlag = children._; + if (!slotFlag && !(InternalObjectKey in children)) { + children._ctx = currentRenderingInstance; + } + else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) { + // a child component receives forwarded slots from the parent. + // its slot type is determined by its parent's slot type. + if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) { + children._ = 2 /* DYNAMIC */; + vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */; + } + else { + children._ = 1 /* STABLE */; + } + } + } + } + else if (isFunction(children)) { + children = { default: children, _ctx: currentRenderingInstance }; + type = 32 /* SLOTS_CHILDREN */; + } + else { + children = String(children); + // force teleport children to array so it can be moved around + if (shapeFlag & 64 /* TELEPORT */) { + type = 16 /* ARRAY_CHILDREN */; + children = [createTextVNode(children)]; + } + else { + type = 8 /* TEXT_CHILDREN */; + } + } + vnode.children = children; + vnode.shapeFlag |= type; + } + function mergeProps(...args) { + const ret = extend({}, args[0]); + for (let i = 1; i < args.length; i++) { + const toMerge = args[i]; + for (const key in toMerge) { + if (key === 'class') { + if (ret.class !== toMerge.class) { + ret.class = normalizeClass([ret.class, toMerge.class]); + } + } + else if (key === 'style') { + ret.style = normalizeStyle([ret.style, toMerge.style]); + } + else if (isOn(key)) { + const existing = ret[key]; + const incoming = toMerge[key]; + if (existing !== incoming) { + ret[key] = existing + ? [].concat(existing, toMerge[key]) + : incoming; + } + } + else if (key !== '') { + ret[key] = toMerge[key]; + } + } + } + return ret; + } + let isInBeforeCreate = false; + function resolveMergedOptions(instance) { + const raw = instance.type; + const { __merged, mixins, extends: extendsOptions } = raw; + if (__merged) + return __merged; + const globalMixins = instance.appContext.mixins; + if (!globalMixins.length && !mixins && !extendsOptions) + return raw; + const options = {}; + globalMixins.forEach(m => mergeOptions(options, m, instance)); + mergeOptions(options, raw, instance); + return (raw.__merged = options); + } + function mergeOptions(to, from, instance) { + const strats = instance.appContext.config.optionMergeStrategies; + const { mixins, extends: extendsOptions } = from; + extendsOptions && mergeOptions(to, extendsOptions, instance); + mixins && + mixins.forEach((m) => mergeOptions(to, m, instance)); + for (const key in from) { + if (strats && hasOwn(strats, key)) { + to[key] = strats[key](to[key], from[key], instance.proxy, key); + } + else { + to[key] = from[key]; + } + } } - var importantRE = /\s*!important$/; + /** + * #2437 In Vue 3, functional components do not have a public instance proxy but + * they exist in the internal parent chain. For code that relies on traversing + * public $parent chains, skip functional ones and go to the parent instead. + */ + const getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent)); + const publicPropertiesMap = extend(Object.create(null), { + $: i => i, + $el: i => i.vnode.el, + $data: i => i.data, + $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props), + $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs), + $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots), + $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs), + $parent: i => getPublicInstance(i.parent), + $root: i => i.root && i.root.proxy, + $emit: i => i.emit, + $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type), + $forceUpdate: i => () => queueJob(i.update), + $nextTick: i => nextTick.bind(i.proxy), + $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP) + }); + const PublicInstanceProxyHandlers = { + get({ _: instance }, key) { + const { ctx, setupState, data, props, accessCache, type, appContext } = instance; + // let @vue/reactivity know it should never observe Vue public instances. + if (key === "__v_skip" /* SKIP */) { + return true; + } + // for internal formatters to know that this is a Vue instance + if ((process.env.NODE_ENV !== 'production') && key === '__isVue') { + return true; + } + // data / props / ctx + // This getter gets called for every property access on the render context + // during render and is a major hotspot. The most expensive part of this + // is the multiple hasOwn() calls. It's much faster to do a simple property + // access on a plain object, so we use an accessCache object (with null + // prototype) to memoize what access type a key corresponds to. + let normalizedProps; + if (key[0] !== '$') { + const n = accessCache[key]; + if (n !== undefined) { + switch (n) { + case 0 /* SETUP */: + return setupState[key]; + case 1 /* DATA */: + return data[key]; + case 3 /* CONTEXT */: + return ctx[key]; + case 2 /* PROPS */: + return props[key]; + // default: just fallthrough + } + } + else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + accessCache[key] = 0 /* SETUP */; + return setupState[key]; + } + else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + accessCache[key] = 1 /* DATA */; + return data[key]; + } + else if ( + // only cache other properties when instance has declared (thus stable) + // props + (normalizedProps = instance.propsOptions[0]) && + hasOwn(normalizedProps, key)) { + accessCache[key] = 2 /* PROPS */; + return props[key]; + } + else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 3 /* CONTEXT */; + return ctx[key]; + } + else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) { + accessCache[key] = 4 /* OTHER */; + } + } + const publicGetter = publicPropertiesMap[key]; + let cssModule, globalProperties; + // public $xxx properties + if (publicGetter) { + if (key === '$attrs') { + track(instance, "get" /* GET */, key); + (process.env.NODE_ENV !== 'production') && markAttrsAccessed(); + } + return publicGetter(instance); + } + else if ( + // css module (injected by vue-loader) + (cssModule = type.__cssModules) && + (cssModule = cssModule[key])) { + return cssModule; + } + else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + // user may set custom properties to `this` that start with `$` + accessCache[key] = 3 /* CONTEXT */; + return ctx[key]; + } + else if ( + // global properties + ((globalProperties = appContext.config.globalProperties), + hasOwn(globalProperties, key))) { + return globalProperties[key]; + } + else if ((process.env.NODE_ENV !== 'production') && + currentRenderingInstance && + (!isString(key) || + // #1091 avoid internal isRef/isVNode checks on component instance leading + // to infinite warning loop + key.indexOf('__v') !== 0)) { + if (data !== EMPTY_OBJ && + (key[0] === '$' || key[0] === '_') && + hasOwn(data, key)) { + warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` + + `character ("$" or "_") and is not proxied on the render context.`); + } + else { + warn(`Property ${JSON.stringify(key)} was accessed during render ` + + `but is not defined on instance.`); + } + } + }, + set({ _: instance }, key, value) { + const { data, setupState, ctx } = instance; + if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + setupState[key] = value; + } + else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + data[key] = value; + } + else if (key in instance.props) { + (process.env.NODE_ENV !== 'production') && + warn(`Attempting to mutate prop "${key}". Props are readonly.`, instance); + return false; + } + if (key[0] === '$' && key.slice(1) in instance) { + (process.env.NODE_ENV !== 'production') && + warn(`Attempting to mutate public property "${key}". ` + + `Properties starting with $ are reserved and readonly.`, instance); + return false; + } + else { + if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + value + }); + } + else { + ctx[key] = value; + } + } + return true; + }, + has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) { + let normalizedProps; + return (accessCache[key] !== undefined || + (data !== EMPTY_OBJ && hasOwn(data, key)) || + (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) || + ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) || + hasOwn(ctx, key) || + hasOwn(publicPropertiesMap, key) || + hasOwn(appContext.config.globalProperties, key)); + } + }; + if ((process.env.NODE_ENV !== 'production') && !false) { + PublicInstanceProxyHandlers.ownKeys = (target) => { + warn(`Avoid app logic that relies on enumerating keys on a component instance. ` + + `The keys will be empty in production mode to avoid performance overhead.`); + return Reflect.ownKeys(target); + }; + } + const RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, { + get(target, key) { + // fast path for unscopables when using `with` block + if (key === Symbol.unscopables) { + return; + } + return PublicInstanceProxyHandlers.get(target, key, target); + }, + has(_, key) { + const has = key[0] !== '_' && !isGloballyWhitelisted(key); + if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) { + warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`); + } + return has; + } + }); + let currentInstance = null; + // record effects created during a component's setup() so that they can be + // stopped when the component unmounts + function recordInstanceBoundEffect(effect, instance = currentInstance) { + if (instance) { + (instance.effects || (instance.effects = [])).push(effect); + } + } + const classifyRE = /(?:^|[-_])(\w)/g; + const classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, ''); + /* istanbul ignore next */ + function formatComponentName(instance, Component, isRoot = false) { + let name = isFunction(Component) + ? Component.displayName || Component.name + : Component.name; + if (!name && Component.__file) { + const match = Component.__file.match(/([^/\\]+)\.\w+$/); + if (match) { + name = match[1]; + } + } + if (!name && instance && instance.parent) { + // try to infer the name based on reverse resolution + const inferFromRegistry = (registry) => { + for (const key in registry) { + if (registry[key] === Component) { + return key; + } + } + }; + name = + inferFromRegistry(instance.components || + instance.parent.type.components) || inferFromRegistry(instance.appContext.components); + } + return name ? classify(name) : isRoot ? `App` : `Anonymous`; + } + function isClassComponent(value) { + return isFunction(value) && '__vccOpts' in value; + } + + const ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``); + + function initCustomFormatter() { + /* eslint-disable no-restricted-globals */ + if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') { + return; + } + const vueStyle = { style: 'color:#3ba776' }; + const numberStyle = { style: 'color:#0b1bc9' }; + const stringStyle = { style: 'color:#b62e24' }; + const keywordStyle = { style: 'color:#9d288c' }; + // custom formatter for Chrome + // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html + const formatter = { + header(obj) { + // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup + if (!isObject(obj)) { + return null; + } + if (obj.__isVue) { + return ['div', vueStyle, `VueInstance`]; + } + else if (isRef(obj)) { + return [ + 'div', + {}, + ['span', vueStyle, genRefFlag(obj)], + '<', + formatValue(obj.value), + `>` + ]; + } + else if (isReactive(obj)) { + return [ + 'div', + {}, + ['span', vueStyle, 'Reactive'], + '<', + formatValue(obj), + `>${isReadonly(obj) ? ` (readonly)` : ``}` + ]; + } + else if (isReadonly(obj)) { + return [ + 'div', + {}, + ['span', vueStyle, 'Readonly'], + '<', + formatValue(obj), + '>' + ]; + } + return null; + }, + hasBody(obj) { + return obj && obj.__isVue; + }, + body(obj) { + if (obj && obj.__isVue) { + return [ + 'div', + {}, + ...formatInstance(obj.$) + ]; + } + } + }; + function formatInstance(instance) { + const blocks = []; + if (instance.type.props && instance.props) { + blocks.push(createInstanceBlock('props', toRaw(instance.props))); + } + if (instance.setupState !== EMPTY_OBJ) { + blocks.push(createInstanceBlock('setup', instance.setupState)); + } + if (instance.data !== EMPTY_OBJ) { + blocks.push(createInstanceBlock('data', toRaw(instance.data))); + } + const computed = extractKeys(instance, 'computed'); + if (computed) { + blocks.push(createInstanceBlock('computed', computed)); + } + const injected = extractKeys(instance, 'inject'); + if (injected) { + blocks.push(createInstanceBlock('injected', injected)); + } + blocks.push([ + 'div', + {}, + [ + 'span', + { + style: keywordStyle.style + ';opacity:0.66' + }, + '$ (internal): ' + ], + ['object', { object: instance }] + ]); + return blocks; + } + function createInstanceBlock(type, target) { + target = extend({}, target); + if (!Object.keys(target).length) { + return ['span', {}]; + } + return [ + 'div', + { style: 'line-height:1.25em;margin-bottom:0.6em' }, + [ + 'div', + { + style: 'color:#476582' + }, + type + ], + [ + 'div', + { + style: 'padding-left:1.25em' + }, + ...Object.keys(target).map(key => { + return [ + 'div', + {}, + ['span', keywordStyle, key + ': '], + formatValue(target[key], false) + ]; + }) + ] + ]; + } + function formatValue(v, asRaw = true) { + if (typeof v === 'number') { + return ['span', numberStyle, v]; + } + else if (typeof v === 'string') { + return ['span', stringStyle, JSON.stringify(v)]; + } + else if (typeof v === 'boolean') { + return ['span', keywordStyle, v]; + } + else if (isObject(v)) { + return ['object', { object: asRaw ? toRaw(v) : v }]; + } + else { + return ['span', stringStyle, String(v)]; + } + } + function extractKeys(instance, type) { + const Comp = instance.type; + if (isFunction(Comp)) { + return; + } + const extracted = {}; + for (const key in instance.ctx) { + if (isKeyOfType(Comp, key, type)) { + extracted[key] = instance.ctx[key]; + } + } + return extracted; + } + function isKeyOfType(Comp, key, type) { + const opts = Comp[type]; + if ((isArray(opts) && opts.includes(key)) || + (isObject(opts) && key in opts)) { + return true; + } + if (Comp.extends && isKeyOfType(Comp.extends, key, type)) { + return true; + } + if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) { + return true; + } + } + function genRefFlag(v) { + if (v._shallow) { + return `ShallowRef`; + } + if (v.effect) { + return `ComputedRef`; + } + return `Ref`; + } + if (window.devtoolsFormatters) { + window.devtoolsFormatters.push(formatter); + } + else { + window.devtoolsFormatters = [formatter]; + } + } + + function initDev() { + const target = getGlobalThis(); + target.__VUE__ = true; + setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__); + { + initCustomFormatter(); + } + } + + // This entry exports the runtime only, and is built as + (process.env.NODE_ENV !== 'production') && initDev(); - function setStyle(style, name, val) { - if (isArray$1(val)) { - val.forEach(function (v) { - return setStyle(style, name, v); - }); - } else { - if (name.startsWith('--')) { - // custom property definition - style.setProperty(name, val); - } else { - var prefixed = autoPrefix(style, name); + function getInternetExplorerVersion() { + var ua = window.navigator.userAgent; + var msie = ua.indexOf('MSIE '); - if (importantRE.test(val)) { - // !important - style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important'); - } else { - style[prefixed] = val; - } - } + if (msie > 0) { + // IE 10 or older => return version number + return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10); } - } - - var prefixes = ['Webkit', 'Moz', 'ms']; - var prefixCache = {}; - function autoPrefix(style, rawName) { - var cached = prefixCache[rawName]; + var trident = ua.indexOf('Trident/'); - if (cached) { - return cached; + if (trident > 0) { + // IE 11 => return version number + var rv = ua.indexOf('rv:'); + return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10); } - var name = camelize(rawName); + var edge = ua.indexOf('Edge/'); - if (name !== 'filter' && name in style) { - return prefixCache[rawName] = name; - } + if (edge > 0) { + // Edge (IE 12+) => return version number + return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10); + } // other browser - name = capitalize$1(name); - for (var i = 0; i < prefixes.length; i++) { - var prefixed = prefixes[i] + name; + return -1; + } - if (prefixed in style) { - return prefixCache[rawName] = prefixed; - } - } + var isIE; - return rawName; + function initCompat() { + if (!initCompat.init) { + initCompat.init = true; + isIE = getInternetExplorerVersion() !== -1; + } } - var xlinkNS = 'http://www.w3.org/1999/xlink'; + var script = { + name: 'ResizeObserver', + mounted: function mounted() { + var _this = this; - function patchAttr(el, key, value, isSVG) { - if (isSVG && key.startsWith('xlink:')) { - if (value == null) { - el.removeAttributeNS(xlinkNS, key.slice(6, key.length)); - } else { - el.setAttributeNS(xlinkNS, key, value); - } - } else { - // note we are only checking boolean attributes that don't have a - // corresponding dom prop of the same name here. - var isBoolean = isSpecialBooleanAttr(key); + initCompat(); + nextTick(function () { + _this._w = _this.$el.offsetWidth; + _this._h = _this.$el.offsetHeight; + }); + var object = document.createElement('object'); + this._resizeObject = object; + object.setAttribute('aria-hidden', 'true'); + object.setAttribute('tabindex', -1); + object.onload = this.addResizeHandlers; + object.type = 'text/html'; - if (value == null || isBoolean && value === false) { - el.removeAttribute(key); - } else { - el.setAttribute(key, isBoolean ? '' : value); + if (isIE) { + this.$el.appendChild(object); } - } - } // __UNSAFE__ - // functions. The user is responsible for using them with only trusted content. + object.data = 'about:blank'; - function patchDOMProp(el, key, value, // the following args are passed only due to potential innerHTML/textContent - // overriding existing VNodes, in which case the old tree must be properly - // unmounted. - prevChildren, parentComponent, parentSuspense, unmountChildren) { - if (key === 'innerHTML' || key === 'textContent') { - if (prevChildren) { - unmountChildren(prevChildren, parentComponent, parentSuspense); + if (!isIE) { + this.$el.appendChild(object); } + }, + beforeUnmount: function beforeUnmount() { + this.removeResizeHandlers(); + }, + methods: { + compareAndNotify: function compareAndNotify() { + if (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) { + this._w = this.$el.offsetWidth; + this._h = this.$el.offsetHeight; + this.$emit('notify', { + width: this._w, + height: this._h + }); + } + }, + addResizeHandlers: function addResizeHandlers() { + this._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify); - el[key] = value == null ? '' : value; - return; - } - - if (key === 'value' && el.tagName !== 'PROGRESS') { - // store value as _value as well since - // non-string values will be stringified. - el._value = value; - var newValue = value == null ? '' : value; + this.compareAndNotify(); + }, + removeResizeHandlers: function removeResizeHandlers() { + if (this._resizeObject && this._resizeObject.onload) { + if (!isIE && this._resizeObject.contentDocument) { + this._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify); + } - if (el.value !== newValue) { - el.value = newValue; + this.$el.removeChild(this._resizeObject); + this._resizeObject.onload = null; + this._resizeObject = null; + } } - - return; } + }; - if (value === '' || value == null) { - var type = _typeof(el[key]); - - if (value === '' && type === 'boolean') { - // e.g. with - // :true-value & :false-value - // store value as dom properties since non-string values will be - // stringified. - if (key === 'true-value') { - el._trueValue = nextValue; - } else if (key === 'false-value') { - el._falseValue = nextValue; - } + /** + * Make a map and return a function for checking if a key + * is in that map. + * IMPORTANT: all calls of this function must be prefixed with + * \/\*#\_\_PURE\_\_\*\/ + * So that rollup can tree-shake them if necessary. + */ + function makeMap$1(str, expectsLowerCase) { + const map = Object.create(null); + const list = str.split(','); + for (let i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val]; + } - patchAttr(el, key, nextValue, isSVG); - } + const GLOBALS_WHITE_LISTED$1 = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + + 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + + 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl'; + const isGloballyWhitelisted$1 = /*#__PURE__*/ makeMap$1(GLOBALS_WHITE_LISTED$1); - break; - } + /** + * On the client we only need to offer special cases for boolean attributes that + * have different names from their corresponding dom properties: + * - itemscope -> N/A + * - allowfullscreen -> allowFullscreen + * - formnovalidate -> formNoValidate + * - ismap -> isMap + * - nomodule -> noModule + * - novalidate -> noValidate + * - readonly -> readOnly + */ + const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`; + const isSpecialBooleanAttr = /*#__PURE__*/ makeMap$1(specialBooleanAttrs); + + function normalizeStyle$1(value) { + if (isArray$1(value)) { + const res = {}; + for (let i = 0; i < value.length; i++) { + const item = value[i]; + const normalized = normalizeStyle$1(isString$1(item) ? parseStringStyle$1(item) : item); + if (normalized) { + for (const key in normalized) { + res[key] = normalized[key]; + } + } + } + return res; + } + else if (isObject$1(value)) { + return value; + } + } + const listDelimiterRE$1 = /;(?![^(]*\))/g; + const propertyDelimiterRE$1 = /:(.+)/; + function parseStringStyle$1(cssText) { + const ret = {}; + cssText.split(listDelimiterRE$1).forEach(item => { + if (item) { + const tmp = item.split(propertyDelimiterRE$1); + tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); + } + }); + return ret; + } + function normalizeClass$1(value) { + let res = ''; + if (isString$1(value)) { + res = value; + } + else if (isArray$1(value)) { + for (let i = 0; i < value.length; i++) { + res += normalizeClass$1(value[i]) + ' '; + } + } + else if (isObject$1(value)) { + for (const name in value) { + if (value[name]) { + res += name + ' '; + } + } + } + return res.trim(); + } + const EMPTY_OBJ$1 = (process.env.NODE_ENV !== 'production') + ? Object.freeze({}) + : {}; + const EMPTY_ARR$1 = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : []; + const NOOP$1 = () => { }; + const onRE$1 = /^on[^a-z]/; + const isOn$1 = (key) => onRE$1.test(key); + const isModelListener = (key) => key.startsWith('onUpdate:'); + const extend$1 = Object.assign; + const remove$1 = (arr, el) => { + const i = arr.indexOf(el); + if (i > -1) { + arr.splice(i, 1); + } + }; + const hasOwnProperty$1 = Object.prototype.hasOwnProperty; + const hasOwn$1 = (val, key) => hasOwnProperty$1.call(val, key); + const isArray$1 = Array.isArray; + const isMap$1 = (val) => toTypeString$1(val) === '[object Map]'; + const isSet$1 = (val) => toTypeString$1(val) === '[object Set]'; + const isFunction$1 = (val) => typeof val === 'function'; + const isString$1 = (val) => typeof val === 'string'; + const isSymbol$1 = (val) => typeof val === 'symbol'; + const isObject$1 = (val) => val !== null && typeof val === 'object'; + const isPromise$1 = (val) => { + return isObject$1(val) && isFunction$1(val.then) && isFunction$1(val.catch); + }; + const objectToString$1 = Object.prototype.toString; + const toTypeString$1 = (value) => objectToString$1.call(value); + const toRawType$1 = (value) => { + // extract "RawType" from strings like "[object RawType]" + return toTypeString$1(value).slice(8, -1); + }; + const isIntegerKey$1 = (key) => isString$1(key) && + key !== 'NaN' && + key[0] !== '-' && + '' + parseInt(key, 10) === key; + const cacheStringFunction$1 = (fn) => { + const cache = Object.create(null); + return ((str) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }); + }; + const camelizeRE = /-(\w)/g; + /** + * @private + */ + const camelize = cacheStringFunction$1((str) => { + return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : '')); + }); + const hyphenateRE = /\B([A-Z])/g; + /** + * @private + */ + const hyphenate = cacheStringFunction$1((str) => str.replace(hyphenateRE, '-$1').toLowerCase()); + /** + * @private + */ + const capitalize$1 = cacheStringFunction$1((str) => str.charAt(0).toUpperCase() + str.slice(1)); + // compare whether a value has changed, accounting for NaN. + const hasChanged$1 = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue); + let _globalThis$1; + const getGlobalThis$1 = () => { + return (_globalThis$1 || + (_globalThis$1 = + typeof globalThis !== 'undefined' + ? globalThis + : typeof self !== 'undefined' + ? self + : typeof window !== 'undefined' + ? window + : typeof global !== 'undefined' + ? global + : {})); }; - function shouldSetAsProp(el, key, value, isSVG) { - if (isSVG) { - // most keys must be set as attribute on svg elements to work - // ...except innerHTML - if (key === 'innerHTML') { - return true; - } // or native onclick with function values - - - if (key in el && nativeOnRE.test(key) && isFunction$1(value)) { - return true; - } - - return false; - } // spellcheck and draggable are numerated attrs, however their - // corresponding DOM properties are actually booleans - this leads to - // setting it with a string "false" value leading it to be coerced to - // `true`, so we need to always treat them as attributes. - // Note that `contentEditable` doesn't have this problem: its DOM - // property is also enumerated string values. - - - if (key === 'spellcheck' || key === 'draggable') { - return false; - } // #1787 form as an attribute must be a string, while it accepts an Element as - // a prop - - - if (key === 'form' && typeof value === 'string') { - return false; - } // #1526 must be set as attribute - - - if (key === 'list' && el.tagName === 'INPUT') { - return false; - } // native onclick with string value, must be set as attribute - + const targetMap$1 = new WeakMap(); + const effectStack$1 = []; + let activeEffect$1; + const ITERATE_KEY$1 = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : ''); + const MAP_KEY_ITERATE_KEY$1 = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : ''); + function isEffect$1(fn) { + return fn && fn._isEffect === true; + } + function effect$1(fn, options = EMPTY_OBJ$1) { + if (isEffect$1(fn)) { + fn = fn.raw; + } + const effect = createReactiveEffect$1(fn, options); + if (!options.lazy) { + effect(); + } + return effect; + } + function stop$1(effect) { + if (effect.active) { + cleanup$1(effect); + if (effect.options.onStop) { + effect.options.onStop(); + } + effect.active = false; + } + } + let uid$1 = 0; + function createReactiveEffect$1(fn, options) { + const effect = function reactiveEffect() { + if (!effect.active) { + return options.scheduler ? undefined : fn(); + } + if (!effectStack$1.includes(effect)) { + cleanup$1(effect); + try { + enableTracking$1(); + effectStack$1.push(effect); + activeEffect$1 = effect; + return fn(); + } + finally { + effectStack$1.pop(); + resetTracking$1(); + activeEffect$1 = effectStack$1[effectStack$1.length - 1]; + } + } + }; + effect.id = uid$1++; + effect.allowRecurse = !!options.allowRecurse; + effect._isEffect = true; + effect.active = true; + effect.raw = fn; + effect.deps = []; + effect.options = options; + return effect; + } + function cleanup$1(effect) { + const { deps } = effect; + if (deps.length) { + for (let i = 0; i < deps.length; i++) { + deps[i].delete(effect); + } + deps.length = 0; + } + } + let shouldTrack$1 = true; + const trackStack$1 = []; + function pauseTracking$1() { + trackStack$1.push(shouldTrack$1); + shouldTrack$1 = false; + } + function enableTracking$1() { + trackStack$1.push(shouldTrack$1); + shouldTrack$1 = true; + } + function resetTracking$1() { + const last = trackStack$1.pop(); + shouldTrack$1 = last === undefined ? true : last; + } + function track$1(target, type, key) { + if (!shouldTrack$1 || activeEffect$1 === undefined) { + return; + } + let depsMap = targetMap$1.get(target); + if (!depsMap) { + targetMap$1.set(target, (depsMap = new Map())); + } + let dep = depsMap.get(key); + if (!dep) { + depsMap.set(key, (dep = new Set())); + } + if (!dep.has(activeEffect$1)) { + dep.add(activeEffect$1); + activeEffect$1.deps.push(dep); + if ((process.env.NODE_ENV !== 'production') && activeEffect$1.options.onTrack) { + activeEffect$1.options.onTrack({ + effect: activeEffect$1, + target, + type, + key + }); + } + } + } + function trigger$1(target, type, key, newValue, oldValue, oldTarget) { + const depsMap = targetMap$1.get(target); + if (!depsMap) { + // never been tracked + return; + } + const effects = new Set(); + const add = (effectsToAdd) => { + if (effectsToAdd) { + effectsToAdd.forEach(effect => { + if (effect !== activeEffect$1 || effect.allowRecurse) { + effects.add(effect); + } + }); + } + }; + if (type === "clear" /* CLEAR */) { + // collection being cleared + // trigger all effects for target + depsMap.forEach(add); + } + else if (key === 'length' && isArray$1(target)) { + depsMap.forEach((dep, key) => { + if (key === 'length' || key >= newValue) { + add(dep); + } + }); + } + else { + // schedule runs for SET | ADD | DELETE + if (key !== void 0) { + add(depsMap.get(key)); + } + // also run for iteration key on ADD | DELETE | Map.SET + switch (type) { + case "add" /* ADD */: + if (!isArray$1(target)) { + add(depsMap.get(ITERATE_KEY$1)); + if (isMap$1(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY$1)); + } + } + else if (isIntegerKey$1(key)) { + // new index added to array -> length changes + add(depsMap.get('length')); + } + break; + case "delete" /* DELETE */: + if (!isArray$1(target)) { + add(depsMap.get(ITERATE_KEY$1)); + if (isMap$1(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY$1)); + } + } + break; + case "set" /* SET */: + if (isMap$1(target)) { + add(depsMap.get(ITERATE_KEY$1)); + } + break; + } + } + const run = (effect) => { + if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) { + effect.options.onTrigger({ + effect, + target, + key, + type, + newValue, + oldValue, + oldTarget + }); + } + if (effect.options.scheduler) { + effect.options.scheduler(effect); + } + else { + effect(); + } + }; + effects.forEach(run); + } + + const builtInSymbols$1 = new Set(Object.getOwnPropertyNames(Symbol) + .map(key => Symbol[key]) + .filter(isSymbol$1)); + const get$2 = /*#__PURE__*/ createGetter$1(); + const shallowGet$1 = /*#__PURE__*/ createGetter$1(false, true); + const readonlyGet$1 = /*#__PURE__*/ createGetter$1(true); + const shallowReadonlyGet$1 = /*#__PURE__*/ createGetter$1(true, true); + const arrayInstrumentations$1 = {}; + ['includes', 'indexOf', 'lastIndexOf'].forEach(key => { + const method = Array.prototype[key]; + arrayInstrumentations$1[key] = function (...args) { + const arr = toRaw$1(this); + for (let i = 0, l = this.length; i < l; i++) { + track$1(arr, "get" /* GET */, i + ''); + } + // we run the method using the original args first (which may be reactive) + const res = method.apply(arr, args); + if (res === -1 || res === false) { + // if that didn't work, run it again using raw values. + return method.apply(arr, args.map(toRaw$1)); + } + else { + return res; + } + }; + }); + ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => { + const method = Array.prototype[key]; + arrayInstrumentations$1[key] = function (...args) { + pauseTracking$1(); + const res = method.apply(this, args); + resetTracking$1(); + return res; + }; + }); + function createGetter$1(isReadonly = false, shallow = false) { + return function get(target, key, receiver) { + if (key === "__v_isReactive" /* IS_REACTIVE */) { + return !isReadonly; + } + else if (key === "__v_isReadonly" /* IS_READONLY */) { + return isReadonly; + } + else if (key === "__v_raw" /* RAW */ && + receiver === (isReadonly ? readonlyMap$1 : reactiveMap$1).get(target)) { + return target; + } + const targetIsArray = isArray$1(target); + if (!isReadonly && targetIsArray && hasOwn$1(arrayInstrumentations$1, key)) { + return Reflect.get(arrayInstrumentations$1, key, receiver); + } + const res = Reflect.get(target, key, receiver); + if (isSymbol$1(key) + ? builtInSymbols$1.has(key) + : key === `__proto__` || key === `__v_isRef`) { + return res; + } + if (!isReadonly) { + track$1(target, "get" /* GET */, key); + } + if (shallow) { + return res; + } + if (isRef$1(res)) { + // ref unwrapping - does not apply for Array + integer key. + const shouldUnwrap = !targetIsArray || !isIntegerKey$1(key); + return shouldUnwrap ? res.value : res; + } + if (isObject$1(res)) { + // Convert returned value into a proxy as well. we do the isObject check + // here to avoid invalid value warning. Also need to lazy access readonly + // and reactive here to avoid circular dependency. + return isReadonly ? readonly$1(res) : reactive$1(res); + } + return res; + }; + } + const set$2 = /*#__PURE__*/ createSetter$1(); + const shallowSet$1 = /*#__PURE__*/ createSetter$1(true); + function createSetter$1(shallow = false) { + return function set(target, key, value, receiver) { + const oldValue = target[key]; + if (!shallow) { + value = toRaw$1(value); + if (!isArray$1(target) && isRef$1(oldValue) && !isRef$1(value)) { + oldValue.value = value; + return true; + } + } + const hadKey = isArray$1(target) && isIntegerKey$1(key) + ? Number(key) < target.length + : hasOwn$1(target, key); + const result = Reflect.set(target, key, value, receiver); + // don't trigger if target is something up in the prototype chain of original + if (target === toRaw$1(receiver)) { + if (!hadKey) { + trigger$1(target, "add" /* ADD */, key, value); + } + else if (hasChanged$1(value, oldValue)) { + trigger$1(target, "set" /* SET */, key, value, oldValue); + } + } + return result; + }; + } + function deleteProperty$1(target, key) { + const hadKey = hasOwn$1(target, key); + const oldValue = target[key]; + const result = Reflect.deleteProperty(target, key); + if (result && hadKey) { + trigger$1(target, "delete" /* DELETE */, key, undefined, oldValue); + } + return result; + } + function has$2(target, key) { + const result = Reflect.has(target, key); + if (!isSymbol$1(key) || !builtInSymbols$1.has(key)) { + track$1(target, "has" /* HAS */, key); + } + return result; + } + function ownKeys$2(target) { + track$1(target, "iterate" /* ITERATE */, isArray$1(target) ? 'length' : ITERATE_KEY$1); + return Reflect.ownKeys(target); + } + const mutableHandlers$1 = { + get: get$2, + set: set$2, + deleteProperty: deleteProperty$1, + has: has$2, + ownKeys: ownKeys$2 + }; + const readonlyHandlers$1 = { + get: readonlyGet$1, + set(target, key) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + }, + deleteProperty(target, key) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + } + }; + const shallowReactiveHandlers$1 = extend$1({}, mutableHandlers$1, { + get: shallowGet$1, + set: shallowSet$1 + }); + // Props handlers are special in the sense that it should not unwrap top-level + // refs (in order to allow refs to be explicitly passed down), but should + // retain the reactivity of the normal readonly object. + const shallowReadonlyHandlers$1 = extend$1({}, readonlyHandlers$1, { + get: shallowReadonlyGet$1 + }); - if (nativeOnRE.test(key) && isString$1(value)) { - return false; - } + const toReactive$1 = (value) => isObject$1(value) ? reactive$1(value) : value; + const toReadonly$1 = (value) => isObject$1(value) ? readonly$1(value) : value; + const toShallow$1 = (value) => value; + const getProto$1 = (v) => Reflect.getPrototypeOf(v); + function get$1$1(target, key, isReadonly = false, isShallow = false) { + // #1772: readonly(reactive(Map)) should return readonly + reactive version + // of the value + target = target["__v_raw" /* RAW */]; + const rawTarget = toRaw$1(target); + const rawKey = toRaw$1(key); + if (key !== rawKey) { + !isReadonly && track$1(rawTarget, "get" /* GET */, key); + } + !isReadonly && track$1(rawTarget, "get" /* GET */, rawKey); + const { has } = getProto$1(rawTarget); + const wrap = isReadonly ? toReadonly$1 : isShallow ? toShallow$1 : toReactive$1; + if (has.call(rawTarget, key)) { + return wrap(target.get(key)); + } + else if (has.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } + } + function has$1$1(key, isReadonly = false) { + const target = this["__v_raw" /* RAW */]; + const rawTarget = toRaw$1(target); + const rawKey = toRaw$1(key); + if (key !== rawKey) { + !isReadonly && track$1(rawTarget, "has" /* HAS */, key); + } + !isReadonly && track$1(rawTarget, "has" /* HAS */, rawKey); + return key === rawKey + ? target.has(key) + : target.has(key) || target.has(rawKey); + } + function size$1(target, isReadonly = false) { + target = target["__v_raw" /* RAW */]; + !isReadonly && track$1(toRaw$1(target), "iterate" /* ITERATE */, ITERATE_KEY$1); + return Reflect.get(target, 'size', target); + } + function add$1(value) { + value = toRaw$1(value); + const target = toRaw$1(this); + const proto = getProto$1(target); + const hadKey = proto.has.call(target, value); + target.add(value); + if (!hadKey) { + trigger$1(target, "add" /* ADD */, value, value); + } + return this; + } + function set$1$1(key, value) { + value = toRaw$1(value); + const target = toRaw$1(this); + const { has, get } = getProto$1(target); + let hadKey = has.call(target, key); + if (!hadKey) { + key = toRaw$1(key); + hadKey = has.call(target, key); + } + else if ((process.env.NODE_ENV !== 'production')) { + checkIdentityKeys$1(target, has, key); + } + const oldValue = get.call(target, key); + target.set(key, value); + if (!hadKey) { + trigger$1(target, "add" /* ADD */, key, value); + } + else if (hasChanged$1(value, oldValue)) { + trigger$1(target, "set" /* SET */, key, value, oldValue); + } + return this; + } + function deleteEntry$1(key) { + const target = toRaw$1(this); + const { has, get } = getProto$1(target); + let hadKey = has.call(target, key); + if (!hadKey) { + key = toRaw$1(key); + hadKey = has.call(target, key); + } + else if ((process.env.NODE_ENV !== 'production')) { + checkIdentityKeys$1(target, has, key); + } + const oldValue = get ? get.call(target, key) : undefined; + // forward the operation before queueing reactions + const result = target.delete(key); + if (hadKey) { + trigger$1(target, "delete" /* DELETE */, key, undefined, oldValue); + } + return result; + } + function clear$1() { + const target = toRaw$1(this); + const hadItems = target.size !== 0; + const oldTarget = (process.env.NODE_ENV !== 'production') + ? isMap$1(target) + ? new Map(target) + : new Set(target) + : undefined; + // forward the operation before queueing reactions + const result = target.clear(); + if (hadItems) { + trigger$1(target, "clear" /* CLEAR */, undefined, undefined, oldTarget); + } + return result; + } + function createForEach$1(isReadonly, isShallow) { + return function forEach(callback, thisArg) { + const observed = this; + const target = observed["__v_raw" /* RAW */]; + const rawTarget = toRaw$1(target); + const wrap = isReadonly ? toReadonly$1 : isShallow ? toShallow$1 : toReactive$1; + !isReadonly && track$1(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY$1); + return target.forEach((value, key) => { + // important: make sure the callback is + // 1. invoked with the reactive map as `this` and 3rd arg + // 2. the value received should be a corresponding reactive/readonly. + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; + } + function createIterableMethod$1(method, isReadonly, isShallow) { + return function (...args) { + const target = this["__v_raw" /* RAW */]; + const rawTarget = toRaw$1(target); + const targetIsMap = isMap$1(rawTarget); + const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap); + const isKeyOnly = method === 'keys' && targetIsMap; + const innerIterator = target[method](...args); + const wrap = isReadonly ? toReadonly$1 : isShallow ? toShallow$1 : toReactive$1; + !isReadonly && + track$1(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY$1 : ITERATE_KEY$1); + // return a wrapped iterator which returns observed versions of the + // values emitted from the real iterator + 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$1(type) { + return function (...args) { + if ((process.env.NODE_ENV !== 'production')) { + const key = args[0] ? `on key "${args[0]}" ` : ``; + console.warn(`${capitalize$1(type)} operation ${key}failed: target is readonly.`, toRaw$1(this)); + } + return type === "delete" /* DELETE */ ? false : this; + }; + } + const mutableInstrumentations$1 = { + get(key) { + return get$1$1(this, key); + }, + get size() { + return size$1(this); + }, + has: has$1$1, + add: add$1, + set: set$1$1, + delete: deleteEntry$1, + clear: clear$1, + forEach: createForEach$1(false, false) + }; + const shallowInstrumentations$1 = { + get(key) { + return get$1$1(this, key, false, true); + }, + get size() { + return size$1(this); + }, + has: has$1$1, + add: add$1, + set: set$1$1, + delete: deleteEntry$1, + clear: clear$1, + forEach: createForEach$1(false, true) + }; + const readonlyInstrumentations$1 = { + get(key) { + return get$1$1(this, key, true); + }, + get size() { + return size$1(this, true); + }, + has(key) { + return has$1$1.call(this, key, true); + }, + add: createReadonlyMethod$1("add" /* ADD */), + set: createReadonlyMethod$1("set" /* SET */), + delete: createReadonlyMethod$1("delete" /* DELETE */), + clear: createReadonlyMethod$1("clear" /* CLEAR */), + forEach: createForEach$1(true, false) + }; + const iteratorMethods$1 = ['keys', 'values', 'entries', Symbol.iterator]; + iteratorMethods$1.forEach(method => { + mutableInstrumentations$1[method] = createIterableMethod$1(method, false, false); + readonlyInstrumentations$1[method] = createIterableMethod$1(method, true, false); + shallowInstrumentations$1[method] = createIterableMethod$1(method, false, true); + }); + function createInstrumentationGetter$1(isReadonly, shallow) { + const instrumentations = shallow + ? shallowInstrumentations$1 + : isReadonly + ? readonlyInstrumentations$1 + : mutableInstrumentations$1; + return (target, key, receiver) => { + if (key === "__v_isReactive" /* IS_REACTIVE */) { + return !isReadonly; + } + else if (key === "__v_isReadonly" /* IS_READONLY */) { + return isReadonly; + } + else if (key === "__v_raw" /* RAW */) { + return target; + } + return Reflect.get(hasOwn$1(instrumentations, key) && key in target + ? instrumentations + : target, key, receiver); + }; + } + const mutableCollectionHandlers$1 = { + get: createInstrumentationGetter$1(false, false) + }; + const readonlyCollectionHandlers$1 = { + get: createInstrumentationGetter$1(true, false) + }; + function checkIdentityKeys$1(target, has, key) { + const rawKey = toRaw$1(key); + if (rawKey !== key && has.call(target, rawKey)) { + const type = toRawType$1(target); + console.warn(`Reactive ${type} contains both the raw and reactive ` + + `versions of the same object${type === `Map` ? ` as keys` : ``}, ` + + `which can lead to inconsistencies. ` + + `Avoid differentiating between the raw and reactive versions ` + + `of an object and only use the reactive version if possible.`); + } + } + + const reactiveMap$1 = new WeakMap(); + const readonlyMap$1 = new WeakMap(); + function targetTypeMap$1(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$1(value) { + return value["__v_skip" /* SKIP */] || !Object.isExtensible(value) + ? 0 /* INVALID */ + : targetTypeMap$1(toRawType$1(value)); + } + function reactive$1(target) { + // if trying to observe a readonly proxy, return the readonly version. + if (target && target["__v_isReadonly" /* IS_READONLY */]) { + return target; + } + return createReactiveObject$1(target, false, mutableHandlers$1, mutableCollectionHandlers$1); + } + /** + * Creates a readonly copy of the original object. Note the returned copy is not + * made reactive, but `readonly` can be called on an already reactive object. + */ + function readonly$1(target) { + return createReactiveObject$1(target, true, readonlyHandlers$1, readonlyCollectionHandlers$1); + } + /** + * Returns a reactive-copy of the original object, where only the root level + * properties are readonly, and does NOT unwrap refs nor recursively convert + * returned properties. + * This is used for creating the props proxy object for stateful components. + */ + function shallowReadonly$1(target) { + return createReactiveObject$1(target, true, shallowReadonlyHandlers$1, readonlyCollectionHandlers$1); + } + function createReactiveObject$1(target, isReadonly, baseHandlers, collectionHandlers) { + if (!isObject$1(target)) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`value cannot be made reactive: ${String(target)}`); + } + return target; + } + // target is already a Proxy, return it. + // exception: calling readonly() on a reactive object + if (target["__v_raw" /* RAW */] && + !(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) { + return target; + } + // target already has corresponding Proxy + const proxyMap = isReadonly ? readonlyMap$1 : reactiveMap$1; + const existingProxy = proxyMap.get(target); + if (existingProxy) { + return existingProxy; + } + // only a whitelist of value types can be observed. + const targetType = getTargetType$1(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$1(value) { + if (isReadonly$1(value)) { + return isReactive$1(value["__v_raw" /* RAW */]); + } + return !!(value && value["__v_isReactive" /* IS_REACTIVE */]); + } + function isReadonly$1(value) { + return !!(value && value["__v_isReadonly" /* IS_READONLY */]); + } + function isProxy$1(value) { + return isReactive$1(value) || isReadonly$1(value); + } + function toRaw$1(observed) { + return ((observed && toRaw$1(observed["__v_raw" /* RAW */])) || observed); + } + function isRef$1(r) { + return Boolean(r && r.__v_isRef === true); + } + + const stack$1 = []; + function pushWarningContext$1(vnode) { + stack$1.push(vnode); + } + function popWarningContext$1() { + stack$1.pop(); + } + function warn$1(msg, ...args) { + // avoid props formatting or warn handler tracking deps that might be mutated + // during patch, leading to infinite recursion. + pauseTracking$1(); + const instance = stack$1.length ? stack$1[stack$1.length - 1].component : null; + const appWarnHandler = instance && instance.appContext.config.warnHandler; + const trace = getComponentTrace$1(); + if (appWarnHandler) { + callWithErrorHandling$1(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [ + msg + args.join(''), + instance && instance.proxy, + trace + .map(({ vnode }) => `at <${formatComponentName$1(instance, vnode.type)}>`) + .join('\n'), + trace + ]); + } + else { + const warnArgs = [`[Vue warn]: ${msg}`, ...args]; + /* istanbul ignore if */ + if (trace.length && + // avoid spamming console during tests + !false) { + warnArgs.push(`\n`, ...formatTrace$1(trace)); + } + console.warn(...warnArgs); + } + resetTracking$1(); + } + function getComponentTrace$1() { + let currentVNode = stack$1[stack$1.length - 1]; + if (!currentVNode) { + return []; + } + // we can't just use the stack because it will be incomplete during updates + // that did not start from the root. Re-construct the parent chain using + // instance parent pointers. + 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; + } + /* istanbul ignore next */ + function formatTrace$1(trace) { + const logs = []; + trace.forEach((entry, i) => { + logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry$1(entry)); + }); + return logs; + } + function formatTraceEntry$1({ vnode, recurseCount }) { + const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; + const isRoot = vnode.component ? vnode.component.parent == null : false; + const open = ` at <${formatComponentName$1(vnode.component, vnode.type, isRoot)}`; + const close = `>` + postfix; + return vnode.props + ? [open, ...formatProps$1(vnode.props), close] + : [open + close]; + } + /* istanbul ignore next */ + function formatProps$1(props) { + const res = []; + const keys = Object.keys(props); + keys.slice(0, 3).forEach(key => { + res.push(...formatProp$1(key, props[key])); + }); + if (keys.length > 3) { + res.push(` ...`); + } + return res; + } + /* istanbul ignore next */ + function formatProp$1(key, value, raw) { + if (isString$1(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$1(value)) { + value = formatProp$1(key, toRaw$1(value.value), true); + return raw ? value : [`${key}=Ref<`, value, `>`]; + } + else if (isFunction$1(value)) { + return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; + } + else { + value = toRaw$1(value); + return raw ? value : [`${key}=`, value]; + } + } + + const ErrorTypeStrings$1 = { + ["bc" /* BEFORE_CREATE */]: 'beforeCreate hook', + ["c" /* CREATED */]: 'created hook', + ["bm" /* BEFORE_MOUNT */]: 'beforeMount hook', + ["m" /* MOUNTED */]: 'mounted hook', + ["bu" /* BEFORE_UPDATE */]: 'beforeUpdate hook', + ["u" /* UPDATED */]: 'updated', + ["bum" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook', + ["um" /* UNMOUNTED */]: 'unmounted hook', + ["a" /* ACTIVATED */]: 'activated hook', + ["da" /* DEACTIVATED */]: 'deactivated hook', + ["ec" /* ERROR_CAPTURED */]: 'errorCaptured hook', + ["rtc" /* RENDER_TRACKED */]: 'renderTracked hook', + ["rtg" /* RENDER_TRIGGERED */]: 'renderTriggered hook', + [0 /* SETUP_FUNCTION */]: 'setup function', + [1 /* RENDER_FUNCTION */]: 'render function', + [2 /* WATCH_GETTER */]: 'watcher getter', + [3 /* WATCH_CALLBACK */]: 'watcher callback', + [4 /* WATCH_CLEANUP */]: 'watcher cleanup function', + [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler', + [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler', + [7 /* VNODE_HOOK */]: 'vnode hook', + [8 /* DIRECTIVE_HOOK */]: 'directive hook', + [9 /* TRANSITION_HOOK */]: 'transition hook', + [10 /* APP_ERROR_HANDLER */]: 'app errorHandler', + [11 /* APP_WARN_HANDLER */]: 'app warnHandler', + [12 /* FUNCTION_REF */]: 'ref function', + [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader', + [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' + + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next' + }; + function callWithErrorHandling$1(fn, instance, type, args) { + let res; + try { + res = args ? fn(...args) : fn(); + } + catch (err) { + handleError$1(err, instance, type); + } + return res; + } + function callWithAsyncErrorHandling$1(fn, instance, type, args) { + if (isFunction$1(fn)) { + const res = callWithErrorHandling$1(fn, instance, type, args); + if (res && isPromise$1(res)) { + res.catch(err => { + handleError$1(err, instance, type); + }); + } + return res; + } + const values = []; + for (let i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling$1(fn[i], instance, type, args)); + } + return values; + } + function handleError$1(err, instance, type, throwInDev = true) { + const contextVNode = instance ? instance.vnode : null; + if (instance) { + let cur = instance.parent; + // the exposed instance is the render proxy to keep it consistent with 2.x + const exposedInstance = instance.proxy; + // in production the hook receives only the error code + const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings$1[type] : type; + while (cur) { + const errorCapturedHooks = cur.ec; + if (errorCapturedHooks) { + for (let i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { + return; + } + } + } + cur = cur.parent; + } + // app-level handling + const appErrorHandler = instance.appContext.config.errorHandler; + if (appErrorHandler) { + callWithErrorHandling$1(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]); + return; + } + } + logError$1(err, type, contextVNode, throwInDev); + } + function logError$1(err, type, contextVNode, throwInDev = true) { + if ((process.env.NODE_ENV !== 'production')) { + const info = ErrorTypeStrings$1[type]; + if (contextVNode) { + pushWarningContext$1(contextVNode); + } + warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`); + if (contextVNode) { + popWarningContext$1(); + } + // crash in dev by default so it's more noticeable + if (throwInDev) { + throw err; + } + else { + console.error(err); + } + } + else { + // recover in prod to reduce the impact on end-user + console.error(err); + } + } + + let isFlushing$1 = false; + let isFlushPending$1 = false; + const queue$1 = []; + let flushIndex$1 = 0; + const pendingPreFlushCbs$1 = []; + let activePreFlushCbs$1 = null; + let preFlushIndex$1 = 0; + const pendingPostFlushCbs$1 = []; + let activePostFlushCbs$1 = null; + let postFlushIndex$1 = 0; + const resolvedPromise$1 = Promise.resolve(); + let currentFlushPromise$1 = null; + let currentPreFlushParentJob$1 = null; + const RECURSION_LIMIT$1 = 100; + function nextTick$1(fn) { + const p = currentFlushPromise$1 || resolvedPromise$1; + return fn ? p.then(this ? fn.bind(this) : fn) : p; + } + function queueJob$1(job) { + // the dedupe search uses the startIndex argument of Array.includes() + // by default the search index includes the current job that is being run + // so it cannot recursively trigger itself again. + // if the job is a watch() callback, the search will start with a +1 index to + // allow it recursively trigger itself - it is the user's responsibility to + // ensure it doesn't end up in an infinite loop. + if ((!queue$1.length || + !queue$1.includes(job, isFlushing$1 && job.allowRecurse ? flushIndex$1 + 1 : flushIndex$1)) && + job !== currentPreFlushParentJob$1) { + queue$1.push(job); + queueFlush$1(); + } + } + function queueFlush$1() { + if (!isFlushing$1 && !isFlushPending$1) { + isFlushPending$1 = true; + currentFlushPromise$1 = resolvedPromise$1.then(flushJobs$1); + } + } + function queueCb$1(cb, activeQueue, pendingQueue, index) { + if (!isArray$1(cb)) { + if (!activeQueue || + !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { + pendingQueue.push(cb); + } + } + else { + // if cb is an array, it is a component lifecycle hook which can only be + // triggered by a job, which is already deduped in the main queue, so + // we can skip duplicate check here to improve perf + pendingQueue.push(...cb); + } + queueFlush$1(); + } + function queuePreFlushCb$1(cb) { + queueCb$1(cb, activePreFlushCbs$1, pendingPreFlushCbs$1, preFlushIndex$1); + } + function queuePostFlushCb$1(cb) { + queueCb$1(cb, activePostFlushCbs$1, pendingPostFlushCbs$1, postFlushIndex$1); + } + function flushPreFlushCbs$1(seen, parentJob = null) { + if (pendingPreFlushCbs$1.length) { + currentPreFlushParentJob$1 = parentJob; + activePreFlushCbs$1 = [...new Set(pendingPreFlushCbs$1)]; + pendingPreFlushCbs$1.length = 0; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + for (preFlushIndex$1 = 0; preFlushIndex$1 < activePreFlushCbs$1.length; preFlushIndex$1++) { + if ((process.env.NODE_ENV !== 'production')) { + checkRecursiveUpdates$1(seen, activePreFlushCbs$1[preFlushIndex$1]); + } + activePreFlushCbs$1[preFlushIndex$1](); + } + activePreFlushCbs$1 = null; + preFlushIndex$1 = 0; + currentPreFlushParentJob$1 = null; + // recursively flush until it drains + flushPreFlushCbs$1(seen, parentJob); + } + } + function flushPostFlushCbs$1(seen) { + if (pendingPostFlushCbs$1.length) { + const deduped = [...new Set(pendingPostFlushCbs$1)]; + pendingPostFlushCbs$1.length = 0; + // #1947 already has active queue, nested flushPostFlushCbs call + if (activePostFlushCbs$1) { + activePostFlushCbs$1.push(...deduped); + return; + } + activePostFlushCbs$1 = deduped; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + activePostFlushCbs$1.sort((a, b) => getId$1(a) - getId$1(b)); + for (postFlushIndex$1 = 0; postFlushIndex$1 < activePostFlushCbs$1.length; postFlushIndex$1++) { + if ((process.env.NODE_ENV !== 'production')) { + checkRecursiveUpdates$1(seen, activePostFlushCbs$1[postFlushIndex$1]); + } + activePostFlushCbs$1[postFlushIndex$1](); + } + activePostFlushCbs$1 = null; + postFlushIndex$1 = 0; + } + } + const getId$1 = (job) => job.id == null ? Infinity : job.id; + function flushJobs$1(seen) { + isFlushPending$1 = false; + isFlushing$1 = true; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + flushPreFlushCbs$1(seen); + // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child so its render effect will have smaller + // priority number) + // 2. If a component is unmounted during a parent component's update, + // its update can be skipped. + queue$1.sort((a, b) => getId$1(a) - getId$1(b)); + try { + for (flushIndex$1 = 0; flushIndex$1 < queue$1.length; flushIndex$1++) { + const job = queue$1[flushIndex$1]; + if (job) { + if ((process.env.NODE_ENV !== 'production')) { + checkRecursiveUpdates$1(seen, job); + } + callWithErrorHandling$1(job, null, 14 /* SCHEDULER */); + } + } + } + finally { + flushIndex$1 = 0; + queue$1.length = 0; + flushPostFlushCbs$1(seen); + isFlushing$1 = false; + currentFlushPromise$1 = null; + // some postFlushCb queued jobs! + // keep flushing until it drains. + if (queue$1.length || pendingPostFlushCbs$1.length) { + flushJobs$1(seen); + } + } + } + function checkRecursiveUpdates$1(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } + else { + const count = seen.get(fn); + if (count > RECURSION_LIMIT$1) { + throw new Error(`Maximum recursive updates exceeded. ` + + `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.`); + } + else { + seen.set(fn, count + 1); + } + } + } + const hmrDirtyComponents$1 = new Set(); + // Expose the HMR runtime on the global object + // This makes it entirely tree-shakable without polluting the exports and makes + // it easier to be used in toolings like vue-loader + // Note: for a component to be eligible for HMR it also needs the __hmrId option + // to be set so that its instances can be registered / removed. + if ((process.env.NODE_ENV !== 'production')) { + const globalObject = typeof global !== 'undefined' + ? global + : typeof self !== 'undefined' + ? self + : typeof window !== 'undefined' + ? window + : {}; + globalObject.__VUE_HMR_RUNTIME__ = { + createRecord: tryWrap$1(createRecord$1), + rerender: tryWrap$1(rerender$1), + reload: tryWrap$1(reload$1) + }; + } + const map$1 = new Map(); + function createRecord$1(id, component) { + if (!component) { + warn$1(`HMR API usage is out of date.\n` + + `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` + + `depdendency that handles Vue SFC compilation.`); + component = {}; + } + if (map$1.has(id)) { + return false; + } + map$1.set(id, { + component: isClassComponent$1(component) ? component.__vccOpts : component, + instances: new Set() + }); + return true; + } + function rerender$1(id, newRender) { + const record = map$1.get(id); + if (!record) + return; + if (newRender) + record.component.render = newRender; + // Array.from creates a snapshot which avoids the set being mutated during + // updates + Array.from(record.instances).forEach(instance => { + if (newRender) { + instance.render = newRender; + } + instance.renderCache = []; + instance.update(); + }); + } + function reload$1(id, newComp) { + const record = map$1.get(id); + if (!record) + return; + // Array.from creates a snapshot which avoids the set being mutated during + // updates + const { component, instances } = record; + if (!hmrDirtyComponents$1.has(component)) { + // 1. Update existing comp definition to match new one + newComp = isClassComponent$1(newComp) ? newComp.__vccOpts : newComp; + extend$1(component, newComp); + for (const key in component) { + if (!(key in newComp)) { + delete component[key]; + } + } + // 2. Mark component dirty. This forces the renderer to replace the component + // on patch. + hmrDirtyComponents$1.add(component); + // 3. Make sure to unmark the component after the reload. + queuePostFlushCb$1(() => { + hmrDirtyComponents$1.delete(component); + }); + } + Array.from(instances).forEach(instance => { + if (instance.parent) { + // 4. Force the parent instance to re-render. This will cause all updated + // components to be unmounted and re-mounted. Queue the update so that we + // don't end up forcing the same parent to re-render multiple times. + queueJob$1(instance.parent.update); + } + else if (instance.appContext.reload) { + // root instance mounted via createApp() has a reload method + instance.appContext.reload(); + } + else if (typeof window !== 'undefined') { + // root instance inside tree created via raw render(). Force reload. + window.location.reload(); + } + else { + console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); + } + }); + } + function tryWrap$1(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.`); + } + }; + } + function setDevtoolsHook$1(hook) { + } - return key in el; + /** + * mark the current rendering instance for asset resolution (e.g. + * resolveComponent, resolveDirective) during render + */ + let currentRenderingInstance$1 = null; + function markAttrsAccessed$1() { + } + function filterSingleRoot$1(children) { + let singleRoot; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (isVNode$1(child)) { + // ignore user comment + if (child.type !== Comment$1 || child.children === 'v-if') { + if (singleRoot) { + // has more than 1 non-comment child, return now + return; + } + else { + singleRoot = child; + } + } + } + else { + return; + } + } + return singleRoot; + } + + const isSuspense$1 = (type) => type.__isSuspense; + function normalizeSuspenseChildren$1(vnode) { + const { shapeFlag, children } = vnode; + let content; + let fallback; + if (shapeFlag & 32 /* SLOTS_CHILDREN */) { + content = normalizeSuspenseSlot$1(children.default); + fallback = normalizeSuspenseSlot$1(children.fallback); + } + else { + content = normalizeSuspenseSlot$1(children); + fallback = normalizeVNode$1(null); + } + return { + content, + fallback + }; + } + function normalizeSuspenseSlot$1(s) { + if (isFunction$1(s)) { + s = s(); + } + if (isArray$1(s)) { + const singleChild = filterSingleRoot$1(s); + if ((process.env.NODE_ENV !== 'production') && !singleChild) { + warn$1(` slots expect a single root node.`); + } + s = singleChild; + } + return normalizeVNode$1(s); + } + function queueEffectWithSuspense$1(fn, suspense) { + if (suspense && suspense.pendingBranch) { + if (isArray$1(fn)) { + suspense.effects.push(...fn); + } + else { + suspense.effects.push(fn); + } + } + else { + queuePostFlushCb$1(fn); + } + } + + let isRenderingCompiledSlot$1 = 0; + const setCompiledSlotRendering$1 = (n) => (isRenderingCompiledSlot$1 += n); + + // SFC scoped style ID management. + let currentScopeId$1 = null; + // initial value for watchers to trigger on undefined initial values + const INITIAL_WATCHER_VALUE$1 = {}; + function doWatch$1(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ$1, instance = currentInstance$1) { + if ((process.env.NODE_ENV !== 'production') && !cb) { + if (immediate !== undefined) { + warn$1(`watch() "immediate" option is only respected when using the ` + + `watch(source, callback, options?) signature.`); + } + if (deep !== undefined) { + warn$1(`watch() "deep" option is only respected when using the ` + + `watch(source, callback, options?) signature.`); + } + } + const warnInvalidSource = (s) => { + warn$1(`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.`); + }; + let getter; + let forceTrigger = false; + if (isRef$1(source)) { + getter = () => source.value; + forceTrigger = !!source._shallow; + } + else if (isReactive$1(source)) { + getter = () => source; + deep = true; + } + else if (isArray$1(source)) { + getter = () => source.map(s => { + if (isRef$1(s)) { + return s.value; + } + else if (isReactive$1(s)) { + return traverse$1(s); + } + else if (isFunction$1(s)) { + return callWithErrorHandling$1(s, instance, 2 /* WATCH_GETTER */); + } + else { + (process.env.NODE_ENV !== 'production') && warnInvalidSource(s); + } + }); + } + else if (isFunction$1(source)) { + if (cb) { + // getter with cb + getter = () => callWithErrorHandling$1(source, instance, 2 /* WATCH_GETTER */); + } + else { + // no cb -> simple effect + getter = () => { + if (instance && instance.isUnmounted) { + return; + } + if (cleanup) { + cleanup(); + } + return callWithErrorHandling$1(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]); + }; + } + } + else { + getter = NOOP$1; + (process.env.NODE_ENV !== 'production') && warnInvalidSource(source); + } + if (cb && deep) { + const baseGetter = getter; + getter = () => traverse$1(baseGetter()); + } + let cleanup; + const onInvalidate = (fn) => { + cleanup = runner.options.onStop = () => { + callWithErrorHandling$1(fn, instance, 4 /* WATCH_CLEANUP */); + }; + }; + let oldValue = isArray$1(source) ? [] : INITIAL_WATCHER_VALUE$1; + const job = () => { + if (!runner.active) { + return; + } + if (cb) { + // watch(source, cb) + const newValue = runner(); + if (deep || forceTrigger || hasChanged$1(newValue, oldValue)) { + // cleanup before running cb again + if (cleanup) { + cleanup(); + } + callWithAsyncErrorHandling$1(cb, instance, 3 /* WATCH_CALLBACK */, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE$1 ? undefined : oldValue, + onInvalidate + ]); + oldValue = newValue; + } + } + else { + // watchEffect + runner(); + } + }; + // important: mark the job as a watcher callback so that scheduler knows + // it is allowed to self-trigger (#1727) + job.allowRecurse = !!cb; + let scheduler; + if (flush === 'sync') { + scheduler = job; + } + else if (flush === 'post') { + scheduler = () => queuePostRenderEffect$1(job, instance && instance.suspense); + } + else { + // default: 'pre' + scheduler = () => { + if (!instance || instance.isMounted) { + queuePreFlushCb$1(job); + } + else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job(); + } + }; + } + const runner = effect$1(getter, { + lazy: true, + onTrack, + onTrigger, + scheduler + }); + recordInstanceBoundEffect$1(runner, instance); + // initial run + if (cb) { + if (immediate) { + job(); + } + else { + oldValue = runner(); + } + } + else if (flush === 'post') { + queuePostRenderEffect$1(runner, instance && instance.suspense); + } + else { + runner(); + } + return () => { + stop$1(runner); + if (instance) { + remove$1(instance.effects, runner); + } + }; + } + // this.$watch + function instanceWatch$1(source, cb, options) { + const publicThis = this.proxy; + const getter = isString$1(source) + ? () => publicThis[source] + : source.bind(publicThis); + return doWatch$1(getter, cb.bind(publicThis), options, this); + } + function traverse$1(value, seen = new Set()) { + if (!isObject$1(value) || seen.has(value)) { + return value; + } + seen.add(value); + if (isRef$1(value)) { + traverse$1(value.value, seen); + } + else if (isArray$1(value)) { + for (let i = 0; i < value.length; i++) { + traverse$1(value[i], seen); + } + } + else if (isSet$1(value) || isMap$1(value)) { + value.forEach((v) => { + traverse$1(v, seen); + }); + } + else { + for (const key in value) { + traverse$1(value[key], seen); + } + } + return value; + } + const queuePostRenderEffect$1 = queueEffectWithSuspense$1 + ; + + const isTeleport$1 = (type) => type.__isTeleport; + const NULL_DYNAMIC_COMPONENT$1 = Symbol(); + + const Fragment$1 = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined); + const Text$1 = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined); + const Comment$1 = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined); + const Static$1 = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined); + let currentBlock$1 = null; + function isVNode$1(value) { + return value ? value.__v_isVNode === true : false; + } + const createVNodeWithArgsTransform$1 = (...args) => { + return _createVNode$1(...( args)); + }; + const InternalObjectKey$1 = `__vInternal`; + const normalizeKey$1 = ({ key }) => key != null ? key : null; + const normalizeRef$1 = ({ ref }) => { + return (ref != null + ? isString$1(ref) || isRef$1(ref) || isFunction$1(ref) + ? { i: currentRenderingInstance$1, r: ref } + : ref + : null); + }; + const createVNode$1 = ((process.env.NODE_ENV !== 'production') + ? createVNodeWithArgsTransform$1 + : _createVNode$1); + function _createVNode$1(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) { + if (!type || type === NULL_DYNAMIC_COMPONENT$1) { + if ((process.env.NODE_ENV !== 'production') && !type) { + warn$1(`Invalid vnode type when creating vnode: ${type}.`); + } + type = Comment$1; + } + if (isVNode$1(type)) { + // createVNode receiving an existing vnode. This happens in cases like + // + // #2078 make sure to merge refs during the clone instead of overwriting it + const cloned = cloneVNode$1(type, props, true /* mergeRef: true */); + if (children) { + normalizeChildren$1(cloned, children); + } + return cloned; + } + // class component normalization. + if (isClassComponent$1(type)) { + type = type.__vccOpts; + } + // class & style normalization. + if (props) { + // for reactive or proxy objects, we need to clone it to enable mutation. + if (isProxy$1(props) || InternalObjectKey$1 in props) { + props = extend$1({}, props); + } + let { class: klass, style } = props; + if (klass && !isString$1(klass)) { + props.class = normalizeClass$1(klass); + } + if (isObject$1(style)) { + // reactive state objects need to be cloned since they are likely to be + // mutated + if (isProxy$1(style) && !isArray$1(style)) { + style = extend$1({}, style); + } + props.style = normalizeStyle$1(style); + } + } + // encode the vnode type information into a bitmap + const shapeFlag = isString$1(type) + ? 1 /* ELEMENT */ + : isSuspense$1(type) + ? 128 /* SUSPENSE */ + : isTeleport$1(type) + ? 64 /* TELEPORT */ + : isObject$1(type) + ? 4 /* STATEFUL_COMPONENT */ + : isFunction$1(type) + ? 2 /* FUNCTIONAL_COMPONENT */ + : 0; + if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy$1(type)) { + type = toRaw$1(type); + warn$1(`Vue received a Component which was made a reactive object. This can ` + + `lead to unnecessary performance overhead, and should be avoided by ` + + `marking the component with \`markRaw\` or using \`shallowRef\` ` + + `instead of \`ref\`.`, `\nComponent that was made reactive: `, type); + } + const vnode = { + __v_isVNode: true, + ["__v_skip" /* SKIP */]: true, + type, + props, + key: props && normalizeKey$1(props), + ref: props && normalizeRef$1(props), + scopeId: currentScopeId$1, + children: null, + component: null, + suspense: null, + ssContent: null, + ssFallback: null, + dirs: null, + transition: null, + el: null, + anchor: null, + target: null, + targetAnchor: null, + staticCount: 0, + shapeFlag, + patchFlag, + dynamicProps, + dynamicChildren: null, + appContext: null + }; + // validate key + if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) { + warn$1(`VNode created with invalid key (NaN). VNode type:`, vnode.type); + } + normalizeChildren$1(vnode, children); + // normalize suspense children + if ( shapeFlag & 128 /* SUSPENSE */) { + const { content, fallback } = normalizeSuspenseChildren$1(vnode); + vnode.ssContent = content; + vnode.ssFallback = fallback; + } + if ( + // avoid a block node from tracking itself + !isBlockNode && + // has current parent block + currentBlock$1 && + // presence of a patch flag indicates this node needs patching on updates. + // component nodes also should always be patched, because even if the + // component doesn't need to update, it needs to persist the instance on to + // the next vnode so that it can be properly unmounted later. + (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) && + // the EVENTS flag is only for hydration and if it is the only flag, the + // vnode should not be considered dynamic due to handler caching. + patchFlag !== 32 /* HYDRATE_EVENTS */) { + currentBlock$1.push(vnode); + } + return vnode; + } + function cloneVNode$1(vnode, extraProps, mergeRef = false) { + // This is intentionally NOT using spread or extend to avoid the runtime + // key enumeration cost. + const { props, ref, patchFlag } = vnode; + const mergedProps = extraProps ? mergeProps$1(props || {}, extraProps) : props; + return { + __v_isVNode: true, + ["__v_skip" /* SKIP */]: true, + type: vnode.type, + props: mergedProps, + key: mergedProps && normalizeKey$1(mergedProps), + ref: extraProps && extraProps.ref + ? // #2078 in the case of + // if the vnode itself already has a ref, cloneVNode will need to merge + // the refs so the single vnode can be set on multiple refs + mergeRef && ref + ? isArray$1(ref) + ? ref.concat(normalizeRef$1(extraProps)) + : [ref, normalizeRef$1(extraProps)] + : normalizeRef$1(extraProps) + : ref, + scopeId: vnode.scopeId, + children: vnode.children, + target: vnode.target, + targetAnchor: vnode.targetAnchor, + staticCount: vnode.staticCount, + shapeFlag: vnode.shapeFlag, + // if the vnode is cloned with extra props, we can no longer assume its + // existing patch flag to be reliable and need to add the FULL_PROPS flag. + // note: perserve flag for fragments since they use the flag for children + // fast paths only. + patchFlag: extraProps && vnode.type !== Fragment$1 + ? patchFlag === -1 // hoisted node + ? 16 /* FULL_PROPS */ + : patchFlag | 16 /* FULL_PROPS */ + : patchFlag, + dynamicProps: vnode.dynamicProps, + dynamicChildren: vnode.dynamicChildren, + appContext: vnode.appContext, + dirs: vnode.dirs, + transition: vnode.transition, + // These should technically only be non-null on mounted VNodes. However, + // they *should* be copied for kept-alive vnodes. So we just always copy + // them since them being non-null during a mount doesn't affect the logic as + // they will simply be overwritten. + component: vnode.component, + suspense: vnode.suspense, + ssContent: vnode.ssContent && cloneVNode$1(vnode.ssContent), + ssFallback: vnode.ssFallback && cloneVNode$1(vnode.ssFallback), + el: vnode.el, + anchor: vnode.anchor + }; + } + /** + * @private + */ + function createTextVNode$1(text = ' ', flag = 0) { + return createVNode$1(Text$1, null, text, flag); + } + function normalizeVNode$1(child) { + if (child == null || typeof child === 'boolean') { + // empty placeholder + return createVNode$1(Comment$1); + } + else if (isArray$1(child)) { + // fragment + return createVNode$1(Fragment$1, null, child); + } + else if (typeof child === 'object') { + // already vnode, this should be the most common since compiled templates + // always produce all-vnode children arrays + return child.el === null ? child : cloneVNode$1(child); + } + else { + // strings and numbers + return createVNode$1(Text$1, null, String(child)); + } + } + function normalizeChildren$1(vnode, children) { + let type = 0; + const { shapeFlag } = vnode; + if (children == null) { + children = null; + } + else if (isArray$1(children)) { + type = 16 /* ARRAY_CHILDREN */; + } + else if (typeof children === 'object') { + if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) { + // Normalize slot to plain children for plain element and Teleport + const slot = children.default; + if (slot) { + // _c marker is added by withCtx() indicating this is a compiled slot + slot._c && setCompiledSlotRendering$1(1); + normalizeChildren$1(vnode, slot()); + slot._c && setCompiledSlotRendering$1(-1); + } + return; + } + else { + type = 32 /* SLOTS_CHILDREN */; + const slotFlag = children._; + if (!slotFlag && !(InternalObjectKey$1 in children)) { + children._ctx = currentRenderingInstance$1; + } + else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance$1) { + // a child component receives forwarded slots from the parent. + // its slot type is determined by its parent's slot type. + if (currentRenderingInstance$1.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) { + children._ = 2 /* DYNAMIC */; + vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */; + } + else { + children._ = 1 /* STABLE */; + } + } + } + } + else if (isFunction$1(children)) { + children = { default: children, _ctx: currentRenderingInstance$1 }; + type = 32 /* SLOTS_CHILDREN */; + } + else { + children = String(children); + // force teleport children to array so it can be moved around + if (shapeFlag & 64 /* TELEPORT */) { + type = 16 /* ARRAY_CHILDREN */; + children = [createTextVNode$1(children)]; + } + else { + type = 8 /* TEXT_CHILDREN */; + } + } + vnode.children = children; + vnode.shapeFlag |= type; + } + function mergeProps$1(...args) { + const ret = extend$1({}, args[0]); + for (let i = 1; i < args.length; i++) { + const toMerge = args[i]; + for (const key in toMerge) { + if (key === 'class') { + if (ret.class !== toMerge.class) { + ret.class = normalizeClass$1([ret.class, toMerge.class]); + } + } + else if (key === 'style') { + ret.style = normalizeStyle$1([ret.style, toMerge.style]); + } + else if (isOn$1(key)) { + const existing = ret[key]; + const incoming = toMerge[key]; + if (existing !== incoming) { + ret[key] = existing + ? [].concat(existing, toMerge[key]) + : incoming; + } + } + else if (key !== '') { + ret[key] = toMerge[key]; + } + } + } + return ret; + } + let isInBeforeCreate$1 = false; + function resolveMergedOptions$1(instance) { + const raw = instance.type; + const { __merged, mixins, extends: extendsOptions } = raw; + if (__merged) + return __merged; + const globalMixins = instance.appContext.mixins; + if (!globalMixins.length && !mixins && !extendsOptions) + return raw; + const options = {}; + globalMixins.forEach(m => mergeOptions$1(options, m, instance)); + mergeOptions$1(options, raw, instance); + return (raw.__merged = options); + } + function mergeOptions$1(to, from, instance) { + const strats = instance.appContext.config.optionMergeStrategies; + const { mixins, extends: extendsOptions } = from; + extendsOptions && mergeOptions$1(to, extendsOptions, instance); + mixins && + mixins.forEach((m) => mergeOptions$1(to, m, instance)); + for (const key in from) { + if (strats && hasOwn$1(strats, key)) { + to[key] = strats[key](to[key], from[key], instance.proxy, key); + } + else { + to[key] = from[key]; + } + } } - var rendererOptions = extend$1({ - patchProp: patchProp, - forcePatchProp: forcePatchProp - }, nodeOps); - - function initDev$1() { - var target = getGlobalThis$1(); - target.__VUE__ = true; - setDevtoolsHook$1(target.__VUE_DEVTOOLS_GLOBAL_HOOK__); - { - initCustomFormatter$1(); - } - } // This entry exports the runtime only, and is built as - + /** + * #2437 In Vue 3, functional components do not have a public instance proxy but + * they exist in the internal parent chain. For code that relies on traversing + * public $parent chains, skip functional ones and go to the parent instead. + */ + const getPublicInstance$1 = (i) => i && (i.proxy ? i.proxy : getPublicInstance$1(i.parent)); + const publicPropertiesMap$1 = extend$1(Object.create(null), { + $: i => i, + $el: i => i.vnode.el, + $data: i => i.data, + $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly$1(i.props) : i.props), + $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly$1(i.attrs) : i.attrs), + $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly$1(i.slots) : i.slots), + $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly$1(i.refs) : i.refs), + $parent: i => getPublicInstance$1(i.parent), + $root: i => i.root && i.root.proxy, + $emit: i => i.emit, + $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions$1(i) : i.type), + $forceUpdate: i => () => queueJob$1(i.update), + $nextTick: i => nextTick$1.bind(i.proxy), + $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch$1.bind(i) : NOOP$1) + }); + const PublicInstanceProxyHandlers$1 = { + get({ _: instance }, key) { + const { ctx, setupState, data, props, accessCache, type, appContext } = instance; + // let @vue/reactivity know it should never observe Vue public instances. + if (key === "__v_skip" /* SKIP */) { + return true; + } + // for internal formatters to know that this is a Vue instance + if ((process.env.NODE_ENV !== 'production') && key === '__isVue') { + return true; + } + // data / props / ctx + // This getter gets called for every property access on the render context + // during render and is a major hotspot. The most expensive part of this + // is the multiple hasOwn() calls. It's much faster to do a simple property + // access on a plain object, so we use an accessCache object (with null + // prototype) to memoize what access type a key corresponds to. + let normalizedProps; + if (key[0] !== '$') { + const n = accessCache[key]; + if (n !== undefined) { + switch (n) { + case 0 /* SETUP */: + return setupState[key]; + case 1 /* DATA */: + return data[key]; + case 3 /* CONTEXT */: + return ctx[key]; + case 2 /* PROPS */: + return props[key]; + // default: just fallthrough + } + } + else if (setupState !== EMPTY_OBJ$1 && hasOwn$1(setupState, key)) { + accessCache[key] = 0 /* SETUP */; + return setupState[key]; + } + else if (data !== EMPTY_OBJ$1 && hasOwn$1(data, key)) { + accessCache[key] = 1 /* DATA */; + return data[key]; + } + else if ( + // only cache other properties when instance has declared (thus stable) + // props + (normalizedProps = instance.propsOptions[0]) && + hasOwn$1(normalizedProps, key)) { + accessCache[key] = 2 /* PROPS */; + return props[key]; + } + else if (ctx !== EMPTY_OBJ$1 && hasOwn$1(ctx, key)) { + accessCache[key] = 3 /* CONTEXT */; + return ctx[key]; + } + else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate$1) { + accessCache[key] = 4 /* OTHER */; + } + } + const publicGetter = publicPropertiesMap$1[key]; + let cssModule, globalProperties; + // public $xxx properties + if (publicGetter) { + if (key === '$attrs') { + track$1(instance, "get" /* GET */, key); + (process.env.NODE_ENV !== 'production') && markAttrsAccessed$1(); + } + return publicGetter(instance); + } + else if ( + // css module (injected by vue-loader) + (cssModule = type.__cssModules) && + (cssModule = cssModule[key])) { + return cssModule; + } + else if (ctx !== EMPTY_OBJ$1 && hasOwn$1(ctx, key)) { + // user may set custom properties to `this` that start with `$` + accessCache[key] = 3 /* CONTEXT */; + return ctx[key]; + } + else if ( + // global properties + ((globalProperties = appContext.config.globalProperties), + hasOwn$1(globalProperties, key))) { + return globalProperties[key]; + } + else if ((process.env.NODE_ENV !== 'production') && + currentRenderingInstance$1 && + (!isString$1(key) || + // #1091 avoid internal isRef/isVNode checks on component instance leading + // to infinite warning loop + key.indexOf('__v') !== 0)) { + if (data !== EMPTY_OBJ$1 && + (key[0] === '$' || key[0] === '_') && + hasOwn$1(data, key)) { + warn$1(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` + + `character ("$" or "_") and is not proxied on the render context.`); + } + else { + warn$1(`Property ${JSON.stringify(key)} was accessed during render ` + + `but is not defined on instance.`); + } + } + }, + set({ _: instance }, key, value) { + const { data, setupState, ctx } = instance; + if (setupState !== EMPTY_OBJ$1 && hasOwn$1(setupState, key)) { + setupState[key] = value; + } + else if (data !== EMPTY_OBJ$1 && hasOwn$1(data, key)) { + data[key] = value; + } + else if (key in instance.props) { + (process.env.NODE_ENV !== 'production') && + warn$1(`Attempting to mutate prop "${key}". Props are readonly.`, instance); + return false; + } + if (key[0] === '$' && key.slice(1) in instance) { + (process.env.NODE_ENV !== 'production') && + warn$1(`Attempting to mutate public property "${key}". ` + + `Properties starting with $ are reserved and readonly.`, instance); + return false; + } + else { + if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + value + }); + } + else { + ctx[key] = value; + } + } + return true; + }, + has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) { + let normalizedProps; + return (accessCache[key] !== undefined || + (data !== EMPTY_OBJ$1 && hasOwn$1(data, key)) || + (setupState !== EMPTY_OBJ$1 && hasOwn$1(setupState, key)) || + ((normalizedProps = propsOptions[0]) && hasOwn$1(normalizedProps, key)) || + hasOwn$1(ctx, key) || + hasOwn$1(publicPropertiesMap$1, key) || + hasOwn$1(appContext.config.globalProperties, key)); + } + }; + if ((process.env.NODE_ENV !== 'production') && !false) { + PublicInstanceProxyHandlers$1.ownKeys = (target) => { + warn$1(`Avoid app logic that relies on enumerating keys on a component instance. ` + + `The keys will be empty in production mode to avoid performance overhead.`); + return Reflect.ownKeys(target); + }; + } + const RuntimeCompiledPublicInstanceProxyHandlers$1 = extend$1({}, PublicInstanceProxyHandlers$1, { + get(target, key) { + // fast path for unscopables when using `with` block + if (key === Symbol.unscopables) { + return; + } + return PublicInstanceProxyHandlers$1.get(target, key, target); + }, + has(_, key) { + const has = key[0] !== '_' && !isGloballyWhitelisted$1(key); + if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers$1.has(_, key)) { + warn$1(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`); + } + return has; + } + }); + let currentInstance$1 = null; + // record effects created during a component's setup() so that they can be + // stopped when the component unmounts + function recordInstanceBoundEffect$1(effect, instance = currentInstance$1) { + if (instance) { + (instance.effects || (instance.effects = [])).push(effect); + } + } + const classifyRE$1 = /(?:^|[-_])(\w)/g; + const classify$1 = (str) => str.replace(classifyRE$1, c => c.toUpperCase()).replace(/[-_]/g, ''); + /* istanbul ignore next */ + function formatComponentName$1(instance, Component, isRoot = false) { + let name = isFunction$1(Component) + ? Component.displayName || Component.name + : Component.name; + if (!name && Component.__file) { + const match = Component.__file.match(/([^/\\]+)\.\w+$/); + if (match) { + name = match[1]; + } + } + if (!name && instance && instance.parent) { + // try to infer the name based on reverse resolution + const inferFromRegistry = (registry) => { + for (const key in registry) { + if (registry[key] === Component) { + return key; + } + } + }; + name = + inferFromRegistry(instance.components || + instance.parent.type.components) || inferFromRegistry(instance.appContext.components); + } + return name ? classify$1(name) : isRoot ? `App` : `Anonymous`; + } + function isClassComponent$1(value) { + return isFunction$1(value) && '__vccOpts' in value; + } + + const ssrContextKey$1 = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``); + + function initCustomFormatter$1() { + /* eslint-disable no-restricted-globals */ + if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') { + return; + } + const vueStyle = { style: 'color:#3ba776' }; + const numberStyle = { style: 'color:#0b1bc9' }; + const stringStyle = { style: 'color:#b62e24' }; + const keywordStyle = { style: 'color:#9d288c' }; + // custom formatter for Chrome + // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html + const formatter = { + header(obj) { + // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup + if (!isObject$1(obj)) { + return null; + } + if (obj.__isVue) { + return ['div', vueStyle, `VueInstance`]; + } + else if (isRef$1(obj)) { + return [ + 'div', + {}, + ['span', vueStyle, genRefFlag(obj)], + '<', + formatValue(obj.value), + `>` + ]; + } + else if (isReactive$1(obj)) { + return [ + 'div', + {}, + ['span', vueStyle, 'Reactive'], + '<', + formatValue(obj), + `>${isReadonly$1(obj) ? ` (readonly)` : ``}` + ]; + } + else if (isReadonly$1(obj)) { + return [ + 'div', + {}, + ['span', vueStyle, 'Readonly'], + '<', + formatValue(obj), + '>' + ]; + } + return null; + }, + hasBody(obj) { + return obj && obj.__isVue; + }, + body(obj) { + if (obj && obj.__isVue) { + return [ + 'div', + {}, + ...formatInstance(obj.$) + ]; + } + } + }; + function formatInstance(instance) { + const blocks = []; + if (instance.type.props && instance.props) { + blocks.push(createInstanceBlock('props', toRaw$1(instance.props))); + } + if (instance.setupState !== EMPTY_OBJ$1) { + blocks.push(createInstanceBlock('setup', instance.setupState)); + } + if (instance.data !== EMPTY_OBJ$1) { + blocks.push(createInstanceBlock('data', toRaw$1(instance.data))); + } + const computed = extractKeys(instance, 'computed'); + if (computed) { + blocks.push(createInstanceBlock('computed', computed)); + } + const injected = extractKeys(instance, 'inject'); + if (injected) { + blocks.push(createInstanceBlock('injected', injected)); + } + blocks.push([ + 'div', + {}, + [ + 'span', + { + style: keywordStyle.style + ';opacity:0.66' + }, + '$ (internal): ' + ], + ['object', { object: instance }] + ]); + return blocks; + } + function createInstanceBlock(type, target) { + target = extend$1({}, target); + if (!Object.keys(target).length) { + return ['span', {}]; + } + return [ + 'div', + { style: 'line-height:1.25em;margin-bottom:0.6em' }, + [ + 'div', + { + style: 'color:#476582' + }, + type + ], + [ + 'div', + { + style: 'padding-left:1.25em' + }, + ...Object.keys(target).map(key => { + return [ + 'div', + {}, + ['span', keywordStyle, key + ': '], + formatValue(target[key], false) + ]; + }) + ] + ]; + } + function formatValue(v, asRaw = true) { + if (typeof v === 'number') { + return ['span', numberStyle, v]; + } + else if (typeof v === 'string') { + return ['span', stringStyle, JSON.stringify(v)]; + } + else if (typeof v === 'boolean') { + return ['span', keywordStyle, v]; + } + else if (isObject$1(v)) { + return ['object', { object: asRaw ? toRaw$1(v) : v }]; + } + else { + return ['span', stringStyle, String(v)]; + } + } + function extractKeys(instance, type) { + const Comp = instance.type; + if (isFunction$1(Comp)) { + return; + } + const extracted = {}; + for (const key in instance.ctx) { + if (isKeyOfType(Comp, key, type)) { + extracted[key] = instance.ctx[key]; + } + } + return extracted; + } + function isKeyOfType(Comp, key, type) { + const opts = Comp[type]; + if ((isArray$1(opts) && opts.includes(key)) || + (isObject$1(opts) && key in opts)) { + return true; + } + if (Comp.extends && isKeyOfType(Comp.extends, key, type)) { + return true; + } + if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) { + return true; + } + } + function genRefFlag(v) { + if (v._shallow) { + return `ShallowRef`; + } + if (v.effect) { + return `ComputedRef`; + } + return `Ref`; + } + if (window.devtoolsFormatters) { + window.devtoolsFormatters.push(formatter); + } + else { + window.devtoolsFormatters = [formatter]; + } + } + + const svgNS = 'http://www.w3.org/2000/svg'; + const doc = (typeof document !== 'undefined' ? document : null); + let tempContainer; + let tempSVGContainer; + const nodeOps = { + insert: (child, parent, anchor) => { + parent.insertBefore(child, anchor || null); + }, + remove: child => { + const parent = child.parentNode; + if (parent) { + parent.removeChild(child); + } + }, + createElement: (tag, isSVG, is) => isSVG + ? doc.createElementNS(svgNS, tag) + : doc.createElement(tag, is ? { is } : undefined), + createText: text => doc.createTextNode(text), + createComment: text => doc.createComment(text), + setText: (node, text) => { + node.nodeValue = text; + }, + setElementText: (el, text) => { + el.textContent = text; + }, + parentNode: node => node.parentNode, + nextSibling: node => node.nextSibling, + querySelector: selector => doc.querySelector(selector), + setScopeId(el, id) { + el.setAttribute(id, ''); + }, + cloneNode(el) { + return el.cloneNode(true); + }, + // __UNSAFE__ + // Reason: innerHTML. + // Static content here can only come from compiled templates. + // As long as the user only uses trusted templates, this is safe. + insertStaticContent(content, parent, anchor, isSVG) { + const temp = isSVG + ? tempSVGContainer || + (tempSVGContainer = doc.createElementNS(svgNS, 'svg')) + : tempContainer || (tempContainer = doc.createElement('div')); + temp.innerHTML = content; + const first = temp.firstChild; + let node = first; + let last = node; + while (node) { + last = node; + nodeOps.insert(node, parent, anchor); + node = temp.firstChild; + } + return [first, last]; + } + }; - process.env.NODE_ENV !== 'production' && initDev$1(); + // compiler should normalize class + :class bindings on the same element + // into a single binding ['staticClass', dynamic] + function patchClass(el, value, isSVG) { + if (value == null) { + value = ''; + } + if (isSVG) { + el.setAttribute('class', value); + } + else { + // directly setting className should be faster than setAttribute in theory + // if this is an element during a transition, take the temporary transition + // classes into account. + const transitionClasses = el._vtc; + if (transitionClasses) { + value = (value + ? [value, ...transitionClasses] + : [...transitionClasses]).join(' '); + } + el.className = value; + } + } + + function patchStyle(el, prev, next) { + const style = el.style; + if (!next) { + el.removeAttribute('style'); + } + else if (isString$1(next)) { + if (prev !== next) { + style.cssText = next; + } + } + else { + for (const key in next) { + setStyle(style, key, next[key]); + } + if (prev && !isString$1(prev)) { + for (const key in prev) { + if (next[key] == null) { + setStyle(style, key, ''); + } + } + } + } + } + const importantRE = /\s*!important$/; + function setStyle(style, name, val) { + if (isArray$1(val)) { + val.forEach(v => setStyle(style, name, v)); + } + else { + if (name.startsWith('--')) { + // custom property definition + style.setProperty(name, val); + } + else { + const prefixed = autoPrefix(style, name); + if (importantRE.test(val)) { + // !important + style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important'); + } + else { + style[prefixed] = val; + } + } + } + } + const prefixes = ['Webkit', 'Moz', 'ms']; + const prefixCache = {}; + function autoPrefix(style, rawName) { + const cached = prefixCache[rawName]; + if (cached) { + return cached; + } + let name = camelize(rawName); + if (name !== 'filter' && name in style) { + return (prefixCache[rawName] = name); + } + name = capitalize$1(name); + for (let i = 0; i < prefixes.length; i++) { + const prefixed = prefixes[i] + name; + if (prefixed in style) { + return (prefixCache[rawName] = prefixed); + } + } + return rawName; + } + + const xlinkNS = 'http://www.w3.org/1999/xlink'; + function patchAttr(el, key, value, isSVG) { + if (isSVG && key.startsWith('xlink:')) { + if (value == null) { + el.removeAttributeNS(xlinkNS, key.slice(6, key.length)); + } + else { + el.setAttributeNS(xlinkNS, key, value); + } + } + else { + // note we are only checking boolean attributes that don't have a + // corresponding dom prop of the same name here. + const isBoolean = isSpecialBooleanAttr(key); + if (value == null || (isBoolean && value === false)) { + el.removeAttribute(key); + } + else { + el.setAttribute(key, isBoolean ? '' : value); + } + } + } + + // __UNSAFE__ + // functions. The user is responsible for using them with only trusted content. + function patchDOMProp(el, key, value, + // the following args are passed only due to potential innerHTML/textContent + // overriding existing VNodes, in which case the old tree must be properly + // unmounted. + prevChildren, parentComponent, parentSuspense, unmountChildren) { + if (key === 'innerHTML' || key === 'textContent') { + if (prevChildren) { + unmountChildren(prevChildren, parentComponent, parentSuspense); + } + el[key] = value == null ? '' : value; + return; + } + if (key === 'value' && el.tagName !== 'PROGRESS') { + // store value as _value as well since + // non-string values will be stringified. + el._value = value; + const newValue = value == null ? '' : value; + if (el.value !== newValue) { + el.value = newValue; + } + return; + } + if (value === '' || value == null) { + const type = typeof el[key]; + if (value === '' && type === 'boolean') { + // e.g. with + // :true-value & :false-value + // store value as dom properties since non-string values will be + // stringified. + if (key === 'true-value') { + el._trueValue = nextValue; + } + else if (key === 'false-value') { + el._falseValue = nextValue; + } + patchAttr(el, key, nextValue, isSVG); + } + break; + } + }; + function shouldSetAsProp(el, key, value, isSVG) { + if (isSVG) { + // most keys must be set as attribute on svg elements to work + // ...except innerHTML + if (key === 'innerHTML') { + return true; + } + // or native onclick with function values + if (key in el && nativeOnRE.test(key) && isFunction$1(value)) { + return true; + } + return false; + } + // spellcheck and draggable are numerated attrs, however their + // corresponding DOM properties are actually booleans - this leads to + // setting it with a string "false" value leading it to be coerced to + // `true`, so we need to always treat them as attributes. + // Note that `contentEditable` doesn't have this problem: its DOM + // property is also enumerated string values. + if (key === 'spellcheck' || key === 'draggable') { + return false; + } + // #1787 form as an attribute must be a string, while it accepts an Element as + // a prop + if (key === 'form' && typeof value === 'string') { + return false; + } + // #1526 must be set as attribute + if (key === 'list' && el.tagName === 'INPUT') { + return false; + } + // native onclick with string value, must be set as attribute + if (nativeOnRE.test(key) && isString$1(value)) { + return false; + } + return key in el; + } + + const rendererOptions = extend$1({ patchProp, forcePatchProp }, nodeOps); + + function initDev$1() { + const target = getGlobalThis$1(); + target.__VUE__ = true; + setDevtoolsHook$1(target.__VUE_DEVTOOLS_GLOBAL_HOOK__); + { + initCustomFormatter$1(); + } + } + + // This entry exports the runtime only, and is built as + (process.env.NODE_ENV !== 'production') && initDev$1(); function processOptions(value) { var options; @@ -6817,7 +5596,6 @@ return options; } - function throttle(callback, delay) { var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; var timeout; @@ -6838,13 +5616,13 @@ } if ((!timeout || state !== lastState) && leading) { - callback.apply(void 0, [state].concat(_toConsumableArray$1(currentArgs))); + callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs))); } lastState = state; clearTimeout(timeout); timeout = setTimeout(function () { - callback.apply(void 0, [state].concat(_toConsumableArray$1(currentArgs))); + callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs))); timeout = 0; }, delay); }; @@ -6856,7 +5634,6 @@ return throttled; } - function deepEqual(val1, val2) { if (val1 === val2) return true; @@ -6873,7 +5650,9 @@ return false; } - var VisibilityState = /*#__PURE__*/function () { + var VisibilityState = + /*#__PURE__*/ + function () { function VisibilityState(el, options, vnode) { _classCallCheck(this, VisibilityState); @@ -7028,12 +5807,12 @@ /* You shouldn't have to modify the code below */ // Plugin - var plugin$1 = { // eslint-disable-next-line no-undef - version: "0.4.6", + version: "0.9.0-ropez.1", install: install$1 }; + var GlobalVue$1 = null; if (typeof window !== 'undefined') { @@ -7145,6 +5924,7 @@ directives: { ObserveVisibility: ObserveVisibility }, + emits: ['update', 'resize', 'visible', 'hidden'], props: _objectSpread2({}, props, { itemSize: { type: Number, @@ -7760,6 +6540,7 @@ vscrollResizeObserver: this.$_resizeObserver }; }, + emits: ['resize', 'visible', 'vscroll:update'], props: _objectSpread2({}, props, { minItemSize: { type: [Number, String], @@ -7906,15 +6687,6 @@ } }; - var _hoisted_1$2 = { - "slot-scope": "{ item: itemWithSize, index, active }" - }; - var _hoisted_2$1 = { - slot: "before" - }; - var _hoisted_3 = { - slot: "after" - }; function render$2(_ctx, _cache, $props, $setup, $data, $options) { var _component_RecycleScroller = vue.resolveComponent("RecycleScroller"); @@ -7928,16 +6700,25 @@ onResize: $options.onScrollerResize, onVisible: $options.onScrollerVisible }, vue.toHandlers($options.listeners)), { - default: vue.withCtx(function () { - return [vue.createVNode("template", _hoisted_1$2, [vue.renderSlot(_ctx.$slots, "default", { - item: _ctx.itemWithSize.item, - index: _ctx.index, - active: _ctx.active, - itemWithSize: _ctx.itemWithSize - })]), vue.createVNode("template", _hoisted_2$1, [vue.renderSlot(_ctx.$slots, "before")]), vue.createVNode("template", _hoisted_3, [vue.renderSlot(_ctx.$slots, "after")])]; + default: vue.withCtx(function (_ref) { + var itemWithSize = _ref.item, + index = _ref.index, + active = _ref.active; + return [vue.renderSlot(_ctx.$slots, "default", { + item: itemWithSize.item, + index: index, + active: active, + itemWithSize: itemWithSize + })]; + }), + before: vue.withCtx(function () { + return [vue.renderSlot(_ctx.$slots, "before")]; + }), + after: vue.withCtx(function () { + return [vue.renderSlot(_ctx.$slots, "after")]; }), - _: 3 - /* FORWARDED */ + _: 1 + /* STABLE */ }, 16 /* FULL_PROPS */ @@ -8149,7 +6930,6 @@ } }, render: function render(h) { - console.log('render', h); return h(this.tag, this.$slots.default); } }; @@ -8252,7 +7032,7 @@ var plugin$2 = { // eslint-disable-next-line no-undef - version: "1.0.10", + version: "1.0.99-ropez.2", install: function install(Vue, options) { var finalOptions = Object.assign({}, { installComponents: true, diff --git a/dist/vue-virtual-scroller.umd.js.map b/dist/vue-virtual-scroller.umd.js.map index a883a7fa..eec889e6 100644 --- a/dist/vue-virtual-scroller.umd.js.map +++ b/dist/vue-virtual-scroller.umd.js.map @@ -1 +1 @@ -{"version":3,"file":"vue-virtual-scroller.umd.js","sources":["../src/config.js","../../vue-resize/dist/vue-resize.esm.js","../../vue-observe-visibility/dist/vue-observe-visibility.esm.js","../node_modules/scrollparent/scrollparent.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../src/components/RecycleScroller.vue?vue&type=template&id=093a936d&lang.js","../src/components/DynamicScroller.vue","../src/components/DynamicScroller.vue?vue&type=template&id=76e15f19&lang.js","../src/components/DynamicScrollerItem.vue","../src/mixins/IdState.js","../src/index.js"],"sourcesContent":["export default {\r\n itemsLimit: 1000,\r\n}\r\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction setCurrentRenderingInstance(instance) {\r\n currentRenderingInstance = instance;\r\n}\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n/**\r\n * Wrap a slot function to memoize current rendering instance\r\n * @private\r\n */\r\nfunction withCtx(fn, ctx = currentRenderingInstance) {\r\n if (!ctx)\r\n return fn;\r\n const renderFnWithContext = (...args) => {\r\n // If a user calls a compiled slot inside a template expression (#1745), it\r\n // can mess up block tracking, so by default we need to push a null block to\r\n // avoid that. This isn't necessary if rendering a compiled ``.\r\n if (!isRenderingCompiledSlot) {\r\n openBlock(true /* null block that disables tracking */);\r\n }\r\n const owner = currentRenderingInstance;\r\n setCurrentRenderingInstance(ctx);\r\n const res = fn(...args);\r\n setCurrentRenderingInstance(owner);\r\n if (!isRenderingCompiledSlot) {\r\n closeBlock();\r\n }\r\n return res;\r\n };\r\n renderFnWithContext._c = true;\r\n return renderFnWithContext;\r\n}\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\nconst scopeIdStack = [];\r\n/**\r\n * @private\r\n */\r\nfunction pushScopeId(id) {\r\n scopeIdStack.push((currentScopeId = id));\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction popScopeId() {\r\n scopeIdStack.pop();\r\n currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null;\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction withScopeId(id) {\r\n return ((fn) => withCtx(function () {\r\n pushScopeId(id);\r\n const res = fn.apply(this, arguments);\r\n popScopeId();\r\n return res;\r\n }));\r\n}\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\n// Since v-if and v-for are the two possible ways node structure can dynamically\r\n// change, once we consider v-if branches and each v-for fragment a block, we\r\n// can divide a template into nested blocks, and within each block the node\r\n// structure would be stable. This allows us to skip most children diffing\r\n// and only worry about the dynamic nodes (indicated by patch flags).\r\nconst blockStack = [];\r\nlet currentBlock = null;\r\n/**\r\n * Open a block.\r\n * This must be called before `createBlock`. It cannot be part of `createBlock`\r\n * because the children of the block are evaluated before `createBlock` itself\r\n * is called. The generated code typically looks like this:\r\n *\r\n * ```js\r\n * function render() {\r\n * return (openBlock(),createBlock('div', null, [...]))\r\n * }\r\n * ```\r\n * disableTracking is true when creating a v-for fragment block, since a v-for\r\n * fragment always diffs its children.\r\n *\r\n * @private\r\n */\r\nfunction openBlock(disableTracking = false) {\r\n blockStack.push((currentBlock = disableTracking ? null : []));\r\n}\r\nfunction closeBlock() {\r\n blockStack.pop();\r\n currentBlock = blockStack[blockStack.length - 1] || null;\r\n}\r\n/**\r\n * Create a block root vnode. Takes the same exact arguments as `createVNode`.\r\n * A block root keeps track of dynamic nodes within the block in the\r\n * `dynamicChildren` array.\r\n *\r\n * @private\r\n */\r\nfunction createBlock(type, props, children, patchFlag, dynamicProps) {\r\n const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */);\r\n // save current block children on the block vnode\r\n vnode.dynamicChildren = currentBlock || EMPTY_ARR;\r\n // close block\r\n closeBlock();\r\n // a block is always going to be patched, so track it as a child of its\r\n // parent block\r\n if ( currentBlock) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...( args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction getInternetExplorerVersion() {\n var ua = window.navigator.userAgent;\n var msie = ua.indexOf('MSIE ');\n\n if (msie > 0) {\n // IE 10 or older => return version number\n return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);\n }\n\n var trident = ua.indexOf('Trident/');\n\n if (trident > 0) {\n // IE 11 => return version number\n var rv = ua.indexOf('rv:');\n return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);\n }\n\n var edge = ua.indexOf('Edge/');\n\n if (edge > 0) {\n // Edge (IE 12+) => return version number\n return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);\n } // other browser\n\n\n return -1;\n}\n\nvar isIE;\n\nfunction initCompat() {\n if (!initCompat.init) {\n initCompat.init = true;\n isIE = getInternetExplorerVersion() !== -1;\n }\n}\n\nvar script = {\n name: 'ResizeObserver',\n mounted: function mounted() {\n var _this = this;\n\n initCompat();\n nextTick(function () {\n _this._w = _this.$el.offsetWidth;\n _this._h = _this.$el.offsetHeight;\n });\n var object = document.createElement('object');\n this._resizeObject = object;\n object.setAttribute('aria-hidden', 'true');\n object.setAttribute('tabindex', -1);\n object.onload = this.addResizeHandlers;\n object.type = 'text/html';\n\n if (isIE) {\n this.$el.appendChild(object);\n }\n\n object.data = 'about:blank';\n\n if (!isIE) {\n this.$el.appendChild(object);\n }\n },\n beforeUnmount: function beforeUnmount() {\n this.removeResizeHandlers();\n },\n methods: {\n compareAndNotify: function compareAndNotify() {\n if (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) {\n this._w = this.$el.offsetWidth;\n this._h = this.$el.offsetHeight;\n this.$emit('notify', {\n width: this._w,\n height: this._h\n });\n }\n },\n addResizeHandlers: function addResizeHandlers() {\n this._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify);\n\n this.compareAndNotify();\n },\n removeResizeHandlers: function removeResizeHandlers() {\n if (this._resizeObject && this._resizeObject.onload) {\n if (!isIE && this._resizeObject.contentDocument) {\n this._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify);\n }\n\n this.$el.removeChild(this._resizeObject);\n this._resizeObject.onload = null;\n this._resizeObject = null;\n }\n }\n }\n};\n\nvar _withId = /*#__PURE__*/withScopeId(\"data-v-b329ee4c\");\n\npushScopeId(\"data-v-b329ee4c\");\n\nvar _hoisted_1 = {\n class: \"resize-observer\",\n tabindex: \"-1\"\n};\n\npopScopeId();\n\nvar render = /*#__PURE__*/_withId(function (_ctx, _cache, $props, $setup, $data, $options) {\n return openBlock(), createBlock(\"div\", _hoisted_1);\n});\n\nscript.render = render;\nscript.__scopeId = \"data-v-b329ee4c\";\nscript.__file = \"src/components/ResizeObserver.vue\";\n\nfunction install(Vue) {\n Vue.component('resize-observer', script);\n Vue.component('ResizeObserver', script);\n}\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.5.0\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { script as ResizeObserver, install };\n//# sourceMappingURL=vue-resize.esm.js.map\n","function _typeof(obj) {\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n}\n\nfunction _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n return arr2;\n }\n}\n\nfunction _iterableToArray(iter) {\n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\n/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase());\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\nlet currentBlock = null;\r\n// Whether we should be tracking dynamic child nodes inside a block.\r\n// Only tracks when this value is > 0\r\n// We are not using a simple boolean because this value may need to be\r\n// incremented/decremented by nested usage of v-once (see below)\r\nlet shouldTrack$1 = 1;\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nlet vnodeArgsTransformer;\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...(vnodeArgsTransformer\r\n ? vnodeArgsTransformer(args, currentRenderingInstance)\r\n : args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (shouldTrack$1 > 0 &&\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nconst svgNS = 'http://www.w3.org/2000/svg';\r\nconst doc = (typeof document !== 'undefined' ? document : null);\r\nlet tempContainer;\r\nlet tempSVGContainer;\r\nconst nodeOps = {\r\n insert: (child, parent, anchor) => {\r\n parent.insertBefore(child, anchor || null);\r\n },\r\n remove: child => {\r\n const parent = child.parentNode;\r\n if (parent) {\r\n parent.removeChild(child);\r\n }\r\n },\r\n createElement: (tag, isSVG, is) => isSVG\r\n ? doc.createElementNS(svgNS, tag)\r\n : doc.createElement(tag, is ? { is } : undefined),\r\n createText: text => doc.createTextNode(text),\r\n createComment: text => doc.createComment(text),\r\n setText: (node, text) => {\r\n node.nodeValue = text;\r\n },\r\n setElementText: (el, text) => {\r\n el.textContent = text;\r\n },\r\n parentNode: node => node.parentNode,\r\n nextSibling: node => node.nextSibling,\r\n querySelector: selector => doc.querySelector(selector),\r\n setScopeId(el, id) {\r\n el.setAttribute(id, '');\r\n },\r\n cloneNode(el) {\r\n return el.cloneNode(true);\r\n },\r\n // __UNSAFE__\r\n // Reason: innerHTML.\r\n // Static content here can only come from compiled templates.\r\n // As long as the user only uses trusted templates, this is safe.\r\n insertStaticContent(content, parent, anchor, isSVG) {\r\n const temp = isSVG\r\n ? tempSVGContainer ||\r\n (tempSVGContainer = doc.createElementNS(svgNS, 'svg'))\r\n : tempContainer || (tempContainer = doc.createElement('div'));\r\n temp.innerHTML = content;\r\n const first = temp.firstChild;\r\n let node = first;\r\n let last = node;\r\n while (node) {\r\n last = node;\r\n nodeOps.insert(node, parent, anchor);\r\n node = temp.firstChild;\r\n }\r\n return [first, last];\r\n }\r\n};\n\n// compiler should normalize class + :class bindings on the same element\r\n// into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n if (value == null) {\r\n value = '';\r\n }\r\n if (isSVG) {\r\n el.setAttribute('class', value);\r\n }\r\n else {\r\n // directly setting className should be faster than setAttribute in theory\r\n // if this is an element during a transition, take the temporary transition\r\n // classes into account.\r\n const transitionClasses = el._vtc;\r\n if (transitionClasses) {\r\n value = (value\r\n ? [value, ...transitionClasses]\r\n : [...transitionClasses]).join(' ');\r\n }\r\n el.className = value;\r\n }\r\n}\n\nfunction patchStyle(el, prev, next) {\r\n const style = el.style;\r\n if (!next) {\r\n el.removeAttribute('style');\r\n }\r\n else if (isString(next)) {\r\n if (prev !== next) {\r\n style.cssText = next;\r\n }\r\n }\r\n else {\r\n for (const key in next) {\r\n setStyle(style, key, next[key]);\r\n }\r\n if (prev && !isString(prev)) {\r\n for (const key in prev) {\r\n if (next[key] == null) {\r\n setStyle(style, key, '');\r\n }\r\n }\r\n }\r\n }\r\n}\r\nconst importantRE = /\\s*!important$/;\r\nfunction setStyle(style, name, val) {\r\n if (isArray(val)) {\r\n val.forEach(v => setStyle(style, name, v));\r\n }\r\n else {\r\n if (name.startsWith('--')) {\r\n // custom property definition\r\n style.setProperty(name, val);\r\n }\r\n else {\r\n const prefixed = autoPrefix(style, name);\r\n if (importantRE.test(val)) {\r\n // !important\r\n style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');\r\n }\r\n else {\r\n style[prefixed] = val;\r\n }\r\n }\r\n }\r\n}\r\nconst prefixes = ['Webkit', 'Moz', 'ms'];\r\nconst prefixCache = {};\r\nfunction autoPrefix(style, rawName) {\r\n const cached = prefixCache[rawName];\r\n if (cached) {\r\n return cached;\r\n }\r\n let name = camelize(rawName);\r\n if (name !== 'filter' && name in style) {\r\n return (prefixCache[rawName] = name);\r\n }\r\n name = capitalize(name);\r\n for (let i = 0; i < prefixes.length; i++) {\r\n const prefixed = prefixes[i] + name;\r\n if (prefixed in style) {\r\n return (prefixCache[rawName] = prefixed);\r\n }\r\n }\r\n return rawName;\r\n}\n\nconst xlinkNS = 'http://www.w3.org/1999/xlink';\r\nfunction patchAttr(el, key, value, isSVG) {\r\n if (isSVG && key.startsWith('xlink:')) {\r\n if (value == null) {\r\n el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\r\n }\r\n else {\r\n el.setAttributeNS(xlinkNS, key, value);\r\n }\r\n }\r\n else {\r\n // note we are only checking boolean attributes that don't have a\r\n // corresponding dom prop of the same name here.\r\n const isBoolean = isSpecialBooleanAttr(key);\r\n if (value == null || (isBoolean && value === false)) {\r\n el.removeAttribute(key);\r\n }\r\n else {\r\n el.setAttribute(key, isBoolean ? '' : value);\r\n }\r\n }\r\n}\n\n// __UNSAFE__\r\n// functions. The user is responsible for using them with only trusted content.\r\nfunction patchDOMProp(el, key, value, \r\n// the following args are passed only due to potential innerHTML/textContent\r\n// overriding existing VNodes, in which case the old tree must be properly\r\n// unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n if (key === 'innerHTML' || key === 'textContent') {\r\n if (prevChildren) {\r\n unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n }\r\n el[key] = value == null ? '' : value;\r\n return;\r\n }\r\n if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n // store value as _value as well since\r\n // non-string values will be stringified.\r\n el._value = value;\r\n const newValue = value == null ? '' : value;\r\n if (el.value !== newValue) {\r\n el.value = newValue;\r\n }\r\n return;\r\n }\r\n if (value === '' || value == null) {\r\n const type = typeof el[key];\r\n if (value === '' && type === 'boolean') {\r\n // e.g. with\r\n // :true-value & :false-value\r\n // store value as dom properties since non-string values will be\r\n // stringified.\r\n if (key === 'true-value') {\r\n el._trueValue = nextValue;\r\n }\r\n else if (key === 'false-value') {\r\n el._falseValue = nextValue;\r\n }\r\n patchAttr(el, key, nextValue, isSVG);\r\n }\r\n break;\r\n }\r\n};\r\nfunction shouldSetAsProp(el, key, value, isSVG) {\r\n if (isSVG) {\r\n // most keys must be set as attribute on svg elements to work\r\n // ...except innerHTML\r\n if (key === 'innerHTML') {\r\n return true;\r\n }\r\n // or native onclick with function values\r\n if (key in el && nativeOnRE.test(key) && isFunction(value)) {\r\n return true;\r\n }\r\n return false;\r\n }\r\n // spellcheck and draggable are numerated attrs, however their\r\n // corresponding DOM properties are actually booleans - this leads to\r\n // setting it with a string \"false\" value leading it to be coerced to\r\n // `true`, so we need to always treat them as attributes.\r\n // Note that `contentEditable` doesn't have this problem: its DOM\r\n // property is also enumerated string values.\r\n if (key === 'spellcheck' || key === 'draggable') {\r\n return false;\r\n }\r\n // #1787 form as an attribute must be a string, while it accepts an Element as\r\n // a prop\r\n if (key === 'form' && typeof value === 'string') {\r\n return false;\r\n }\r\n // #1526 must be set as attribute\r\n if (key === 'list' && el.tagName === 'INPUT') {\r\n return false;\r\n }\r\n // native onclick with string value, must be set as attribute\r\n if (nativeOnRE.test(key) && isString(value)) {\r\n return false;\r\n }\r\n return key in el;\r\n}\n\nconst rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps);\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction processOptions(value) {\n var options;\n\n if (typeof value === 'function') {\n // Simple options (callback-only)\n options = {\n callback: value\n };\n } else {\n // Options object\n options = value;\n }\n\n return options;\n}\nfunction throttle(callback, delay) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var timeout;\n var lastState;\n var currentArgs;\n\n var throttled = function throttled(state) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n currentArgs = args;\n if (timeout && state === lastState) return;\n var leading = options.leading;\n\n if (typeof leading === 'function') {\n leading = leading(state, lastState);\n }\n\n if ((!timeout || state !== lastState) && leading) {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n }\n\n lastState = state;\n clearTimeout(timeout);\n timeout = setTimeout(function () {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n timeout = 0;\n }, delay);\n };\n\n throttled._clear = function () {\n clearTimeout(timeout);\n timeout = null;\n };\n\n return throttled;\n}\nfunction deepEqual(val1, val2) {\n if (val1 === val2) return true;\n\n if (_typeof(val1) === 'object') {\n for (var key in val1) {\n if (!deepEqual(val1[key], val2[key])) {\n return false;\n }\n }\n\n return true;\n }\n\n return false;\n}\n\nvar VisibilityState =\n/*#__PURE__*/\nfunction () {\n function VisibilityState(el, options, vnode) {\n _classCallCheck(this, VisibilityState);\n\n this.el = el;\n this.observer = null;\n this.frozen = false;\n this.createObserver(options, vnode);\n }\n\n _createClass(VisibilityState, [{\n key: \"createObserver\",\n value: function createObserver(options, vnode) {\n var _this = this;\n\n if (this.observer) {\n this.destroyObserver();\n }\n\n if (this.frozen) return;\n this.options = processOptions(options);\n\n this.callback = function (result, entry) {\n _this.options.callback(result, entry);\n\n if (result && _this.options.once) {\n _this.frozen = true;\n\n _this.destroyObserver();\n }\n }; // Throttle\n\n\n if (this.callback && this.options.throttle) {\n var _ref = this.options.throttleOptions || {},\n _leading = _ref.leading;\n\n this.callback = throttle(this.callback, this.options.throttle, {\n leading: function leading(state) {\n return _leading === 'both' || _leading === 'visible' && state || _leading === 'hidden' && !state;\n }\n });\n }\n\n this.oldResult = undefined;\n this.observer = new IntersectionObserver(function (entries) {\n var entry = entries[0];\n\n if (entries.length > 1) {\n var intersectingEntry = entries.find(function (e) {\n return e.isIntersecting;\n });\n\n if (intersectingEntry) {\n entry = intersectingEntry;\n }\n }\n\n if (_this.callback) {\n // Use isIntersecting if possible because browsers can report isIntersecting as true, but intersectionRatio as 0, when something very slowly enters the viewport.\n var result = entry.isIntersecting && entry.intersectionRatio >= _this.threshold;\n if (result === _this.oldResult) return;\n _this.oldResult = result;\n\n _this.callback(result, entry);\n }\n }, this.options.intersection); // Wait for the element to be in document\n\n nextTick(function () {\n if (_this.observer) {\n _this.observer.observe(_this.el);\n }\n });\n }\n }, {\n key: \"destroyObserver\",\n value: function destroyObserver() {\n if (this.observer) {\n this.observer.disconnect();\n this.observer = null;\n } // Cancel throttled call\n\n\n if (this.callback && this.callback._clear) {\n this.callback._clear();\n\n this.callback = null;\n }\n }\n }, {\n key: \"threshold\",\n get: function get() {\n return this.options.intersection && this.options.intersection.threshold || 0;\n }\n }]);\n\n return VisibilityState;\n}();\n\nfunction bind(el, _ref2, vnode) {\n var value = _ref2.value;\n if (!value) return;\n\n if (typeof IntersectionObserver === 'undefined') {\n console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');\n } else {\n var state = new VisibilityState(el, value, vnode);\n el._vue_visibilityState = state;\n }\n}\n\nfunction update(el, _ref3, vnode) {\n var value = _ref3.value,\n oldValue = _ref3.oldValue;\n if (deepEqual(value, oldValue)) return;\n var state = el._vue_visibilityState;\n\n if (!value) {\n unbind(el);\n return;\n }\n\n if (state) {\n state.createObserver(value, vnode);\n } else {\n bind(el, {\n value: value\n }, vnode);\n }\n}\n\nfunction unbind(el) {\n var state = el._vue_visibilityState;\n\n if (state) {\n state.destroyObserver();\n delete el._vue_visibilityState;\n }\n}\n\nvar ObserveVisibility = {\n beforeMount: bind,\n updated: update,\n unmounted: unbind\n};\n\nfunction install(Vue) {\n Vue.directive('observe-visibility', ObserveVisibility);\n /* -- Add more components here -- */\n}\n/* -- Plugin definition & Auto-install -- */\n\n/* You shouldn't have to modify the code below */\n// Plugin\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.4.6\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { ObserveVisibility, install };\n","(function (root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define([], factory);\n } else if (typeof module === \"object\" && module.exports) {\n module.exports = factory();\n } else {\n root.Scrollparent = factory();\n }\n}(this, function () {\n var regex = /(auto|scroll)/;\n\n var parents = function (node, ps) {\n if (node.parentNode === null) { return ps; }\n\n return parents(node.parentNode, ps.concat([node]));\n };\n\n var style = function (node, prop) {\n return getComputedStyle(node, null).getPropertyValue(prop);\n };\n\n var overflow = function (node) {\n return style(node, \"overflow\") + style(node, \"overflow-y\") + style(node, \"overflow-x\");\n };\n\n var scroll = function (node) {\n return regex.test(overflow(node));\n };\n\n var scrollParent = function (node) {\n if (!(node instanceof HTMLElement || node instanceof SVGElement)) {\n return ;\n }\n\n var ps = parents(node.parentNode, []);\n\n for (var i = 0; i < ps.length; i += 1) {\n if (scroll(ps[i])) {\n return ps[i];\n }\n }\n\n return document.scrollingElement || document.documentElement;\n };\n\n return scrollParent;\n}));\n","export const props = {\r\n items: {\r\n type: Array,\r\n required: true,\r\n },\r\n\r\n keyField: {\r\n type: String,\r\n default: 'id',\r\n },\r\n\r\n direction: {\r\n type: String,\r\n default: 'vertical',\r\n validator: (value) => ['vertical', 'horizontal'].includes(value),\r\n },\r\n}\r\n\r\nexport function simpleArray () {\r\n return this.items.length && typeof this.items[0] !== 'object'\r\n}\r\n","export let supportsPassive = false\r\n\r\nif (typeof window !== 'undefined') {\r\n supportsPassive = false\r\n try {\r\n var opts = Object.defineProperty({}, 'passive', {\r\n get () {\r\n supportsPassive = true\r\n },\r\n })\r\n window.addEventListener('test', null, opts)\r\n } catch (e) {}\r\n}\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n","import { reactive } from 'vue'\r\n\r\nexport default function ({\r\n idProp = vm => vm.item.id,\r\n} = {}) {\r\n const store = reactive({})\r\n\r\n // @vue/component\r\n return {\r\n data () {\r\n return {\r\n idState: null,\r\n }\r\n },\r\n\r\n created () {\r\n this.$_id = null\r\n if (typeof idProp === 'function') {\r\n this.$_getId = () => idProp.call(this, this)\r\n } else {\r\n this.$_getId = () => this[idProp]\r\n }\r\n this.$watch(this.$_getId, {\r\n handler (value) {\r\n this.$nextTick(() => {\r\n this.$_id = value\r\n })\r\n },\r\n immediate: true,\r\n })\r\n this.$_updateIdState()\r\n },\r\n\r\n beforeUpdate () {\r\n this.$_updateIdState()\r\n },\r\n\r\n methods: {\r\n /**\r\n * Initialize an idState\r\n * @param {number|string} id Unique id for the data\r\n */\r\n $_idStateInit (id) {\r\n const factory = this.$options.idState\r\n if (typeof factory === 'function') {\r\n const data = factory.call(this, this)\r\n store[id] = data\r\n this.$_id = id\r\n return data\r\n } else {\r\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\r\n }\r\n },\r\n\r\n /**\r\n * Ensure idState is created and up-to-date\r\n */\r\n $_updateIdState () {\r\n const id = this.$_getId()\r\n if (id == null) {\r\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\r\n }\r\n if (id !== this.$_id) {\r\n if (!store[id]) {\r\n this.$_idStateInit(id)\r\n }\r\n this.idState = store[id]\r\n }\r\n },\r\n },\r\n }\r\n}\r\n","import config from './config'\r\n\r\nimport RecycleScroller from './components/RecycleScroller.vue'\r\nimport DynamicScroller from './components/DynamicScroller.vue'\r\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\r\n\r\nexport { default as IdState } from './mixins/IdState'\r\n\r\nexport {\r\n RecycleScroller,\r\n DynamicScroller,\r\n DynamicScrollerItem,\r\n}\r\n\r\nfunction registerComponents (Vue, prefix) {\r\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\r\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\r\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\r\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\r\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\r\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\r\n}\r\n\r\nconst plugin = {\r\n // eslint-disable-next-line no-undef\r\n version: VERSION,\r\n install (Vue, options) {\r\n const finalOptions = Object.assign({}, {\r\n installComponents: true,\r\n componentsPrefix: '',\r\n }, options)\r\n\r\n for (const key in finalOptions) {\r\n if (typeof finalOptions[key] !== 'undefined') {\r\n config[key] = finalOptions[key]\r\n }\r\n }\r\n\r\n if (finalOptions.installComponents) {\r\n registerComponents(Vue, finalOptions.componentsPrefix)\r\n }\r\n },\r\n}\r\n\r\nexport default plugin\r\n\r\n// Auto-install\r\nlet GlobalVue = null\r\nif (typeof window !== 'undefined') {\r\n GlobalVue = window.Vue\r\n} else if (typeof global !== 'undefined') {\r\n GlobalVue = global.Vue\r\n}\r\nif (GlobalVue) {\r\n GlobalVue.use(plugin)\r\n}\r\n"],"names":["itemsLimit","_typeof","obj","Symbol","_typeof2","iterator","constructor","prototype","_classCallCheck","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_createClass","protoProps","staticProps","_toConsumableArray","arr","_arrayWithoutHoles","_iterableToArray","_nonIterableSpread","Array","isArray","arr2","iter","toString","call","from","makeMap","str","expectsLowerCase","map","create","list","split","val","toLowerCase","GLOBALS_WHITE_LISTED","isGloballyWhitelisted","specialBooleanAttrs","isSpecialBooleanAttr","normalizeStyle","value","res","item","normalized","isString","parseStringStyle","isObject","listDelimiterRE","propertyDelimiterRE","cssText","ret","forEach","tmp","trim","normalizeClass","name","EMPTY_OBJ","process","env","NODE_ENV","freeze","EMPTY_ARR","NOOP","onRE","isOn","test","isModelListener","startsWith","extend","assign","remove","el","indexOf","splice","hasOwnProperty","hasOwn","isMap","toTypeString","isSet","isFunction","isSymbol","isPromise","then","catch","objectToString","toRawType","slice","isIntegerKey","parseInt","cacheStringFunction","fn","cache","hit","camelizeRE","camelize","replace","_","c","toUpperCase","hyphenateRE","hyphenate","capitalize","charAt","hasChanged","oldValue","_globalThis","getGlobalThis","globalThis","self","window","global","targetMap","WeakMap","effectStack","activeEffect","ITERATE_KEY","MAP_KEY_ITERATE_KEY","isEffect","_isEffect","effect","options","raw","createReactiveEffect","lazy","stop","active","cleanup","onStop","uid","reactiveEffect","scheduler","undefined","includes","enableTracking","push","pop","resetTracking","id","allowRecurse","deps","delete","shouldTrack","trackStack","pauseTracking","last","track","type","depsMap","get","set","Map","dep","Set","has","add","onTrack","trigger","newValue","oldTarget","effects","effectsToAdd","run","onTrigger","builtInSymbols","getOwnPropertyNames","filter","createGetter","shallowGet","readonlyGet","shallowReadonlyGet","arrayInstrumentations","method","toRaw","l","args","apply","isReadonly","shallow","receiver","readonlyMap","reactiveMap","targetIsArray","Reflect","isRef","shouldUnwrap","readonly","reactive","createSetter","shallowSet","hadKey","Number","result","deleteProperty","ownKeys","mutableHandlers","readonlyHandlers","console","warn","String","shallowReactiveHandlers","shallowReadonlyHandlers","toReactive","toReadonly","toShallow","getProto","v","getPrototypeOf","get$1","isShallow","rawTarget","rawKey","wrap","has$1","size","proto","set$1","checkIdentityKeys","deleteEntry","clear","hadItems","createForEach","callback","thisArg","observed","createIterableMethod","targetIsMap","isPair","isKeyOnly","innerIterator","next","done","createReadonlyMethod","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","iteratorMethods","createInstrumentationGetter","instrumentations","mutableCollectionHandlers","readonlyCollectionHandlers","targetTypeMap","rawType","getTargetType","isExtensible","createReactiveObject","shallowReadonly","baseHandlers","collectionHandlers","proxyMap","existingProxy","targetType","proxy","Proxy","isReactive","isProxy","r","Boolean","__v_isRef","stack","pushWarningContext","vnode","popWarningContext","msg","component","appWarnHandler","appContext","config","warnHandler","trace","getComponentTrace","callWithErrorHandling","join","formatComponentName","warnArgs","formatTrace","currentVNode","normalizedStack","recurseCount","parentInstance","parent","logs","entry","formatTraceEntry","postfix","isRoot","open","close","formatProps","keys","formatProp","JSON","stringify","ErrorTypeStrings","err","handleError","callWithAsyncErrorHandling","values","throwInDev","contextVNode","cur","exposedInstance","errorInfo","errorCapturedHooks","ec","appErrorHandler","errorHandler","logError","info","error","isFlushing","isFlushPending","queue","flushIndex","pendingPreFlushCbs","activePreFlushCbs","preFlushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","Promise","resolve","currentFlushPromise","currentPreFlushParentJob","RECURSION_LIMIT","nextTick","p","bind","queueJob","job","queueFlush","flushJobs","queueCb","cb","activeQueue","pendingQueue","index","queuePreFlushCb","queuePostFlushCb","flushPreFlushCbs","seen","parentJob","checkRecursiveUpdates","flushPostFlushCbs","deduped","sort","a","b","getId","Infinity","count","Error","hmrDirtyComponents","globalObject","__VUE_HMR_RUNTIME__","createRecord","tryWrap","rerender","reload","isClassComponent","__vccOpts","instances","newRender","record","render","renderCache","update","newComp","location","arg","e","setDevtoolsHook","hook","currentRenderingInstance","markAttrsAccessed","filterSingleRoot","children","singleRoot","child","isVNode","Comment","isSuspense","__isSuspense","normalizeSuspenseChildren","shapeFlag","content","fallback","normalizeSuspenseSlot","default","normalizeVNode","s","singleChild","queueEffectWithSuspense","suspense","pendingBranch","isRenderingCompiledSlot","setCompiledSlotRendering","n","currentScopeId","INITIAL_WATCHER_VALUE","doWatch","source","immediate","deep","flush","currentInstance","warnInvalidSource","getter","forceTrigger","_shallow","traverse","isUnmounted","onInvalidate","baseGetter","runner","queuePostRenderEffect","isMounted","recordInstanceBoundEffect","instanceWatch","publicThis","isTeleport","__isTeleport","NULL_DYNAMIC_COMPONENT","Fragment","Text","Static","currentBlock","__v_isVNode","createVNodeWithArgsTransform","_createVNode","InternalObjectKey","normalizeKey","normalizeRef","ref","createVNode","patchFlag","dynamicProps","isBlockNode","cloned","cloneVNode","normalizeChildren","klass","class","style","ssContent","ssFallback","extraProps","mergeRef","mergedProps","mergeProps","concat","scopeId","targetAnchor","staticCount","dynamicChildren","dirs","transition","anchor","createTextVNode","text","flag","slot","_c","slotFlag","_ctx","toMerge","existing","incoming","isInBeforeCreate","resolveMergedOptions","__merged","mixins","extendsOptions","extends","globalMixins","m","mergeOptions","to","strats","optionMergeStrategies","getPublicInstance","publicPropertiesMap","$","$el","$data","data","$props","$attrs","attrs","$slots","slots","$refs","refs","$parent","$root","root","$emit","emit","$options","__VUE_OPTIONS_API__","$forceUpdate","$nextTick","$watch","PublicInstanceProxyHandlers","ctx","setupState","accessCache","normalizedProps","propsOptions","publicGetter","cssModule","globalProperties","__cssModules","RuntimeCompiledPublicInstanceProxyHandlers","unscopables","classifyRE","classify","Component","displayName","__file","match","inferFromRegistry","registry","components","ssrContextKey","initCustomFormatter","vueStyle","numberStyle","stringStyle","keywordStyle","formatter","header","__isVue","genRefFlag","formatValue","hasBody","body","formatInstance","blocks","createInstanceBlock","computed","extractKeys","injected","object","asRaw","Comp","extracted","isKeyOfType","opts","some","devtoolsFormatters","svgNS","doc","document","tempContainer","tempSVGContainer","nodeOps","insert","insertBefore","parentNode","removeChild","createElement","tag","isSVG","is","createElementNS","createText","createTextNode","createComment","setText","node","nodeValue","setElementText","textContent","nextSibling","querySelector","selector","setScopeId","setAttribute","cloneNode","insertStaticContent","temp","innerHTML","first","firstChild","patchClass","transitionClasses","_vtc","className","patchStyle","prev","removeAttribute","setStyle","importantRE","setProperty","prefixed","autoPrefix","prefixes","prefixCache","rawName","cached","xlinkNS","patchAttr","removeAttributeNS","setAttributeNS","isBoolean","patchDOMProp","prevChildren","parentComponent","parentSuspense","unmountChildren","tagName","_value","_getNow","Date","now","createEvent","timeStamp","performance","cachedNow","reset","getNow","addEventListener","event","handler","removeEventListener","patchEvent","prevValue","nextValue","invokers","_vei","existingInvoker","parseName","invoker","createInvoker","optionsModifierRE","initialValue","attached","patchStopImmediatePropagation","originalStop","stopImmediatePropagation","_stopped","nativeOnRE","forcePatchProp","patchProp","shouldSetAsProp","_trueValue","_falseValue","rendererOptions","initDev","__VUE__","__VUE_DEVTOOLS_GLOBAL_HOOK__","processOptions","throttle","delay","arguments","timeout","lastState","currentArgs","throttled","state","_len","_key","leading","clearTimeout","setTimeout","_clear","deepEqual","val1","val2","VisibilityState","observer","frozen","createObserver","_this","destroyObserver","once","_ref","throttleOptions","_leading","oldResult","IntersectionObserver","entries","intersectingEntry","find","isIntersecting","intersectionRatio","threshold","intersection","observe","disconnect","_ref2","_vue_visibilityState","_ref3","unbind","ObserveVisibility","beforeMount","updated","unmounted","install","Vue","directive","plugin","version","GlobalVue","use","this","items","required","keyField","direction","validator","simpleArray","supportsPassive","ResizeObserver","directives","itemSize","minItemSize","sizeField","typeField","buffer","pageMode","prerender","emitUpdate","pool","totalSize","ready","hoverKey","sizes","accumulator","field","computedMinSize","current","$_computedMinItemSize","watch","updateVisibleItems","applyPageMode","created","$_startIndex","$_endIndex","$_views","$_unusedViews","$_scrollDirty","$_lastUpdateScrollPosition","$_prerender","mounted","beforeUnmount","removeListeners","methods","addView","view","shallowReactive","position","nr","used","unuseView","fake","unusedViews","unusedPool","handleResize","handleScroll","requestAnimationFrame","continuous","$_refreshTimout","handleVisibilityChange","isVisible","boundingClientRect","width","height","checkItem","checkPositionDiff","views","startIndex","endIndex","scroll","getScroll","positionDiff","start","end","h","oldI","Math","ceil","itemsLimitError","$_continuous","findIndex","unusedIndex","$_sortTimer","sortViews","getListenerTarget","ScrollParent","documentElement","isVertical","scrollState","bounds","getBoundingClientRect","boundsSize","top","left","innerHeight","innerWidth","scrollTop","clientHeight","scrollLeft","clientWidth","addListeners","listenerTarget","passive","scrollToItem","scrollToPosition","log","viewA","viewB","_createBlock","before","_hoisted_1","_renderSlot","onMouseenter","onMouseleave","after","_hoisted_2","onNotify","RecycleScroller","inheritAttrs","provide","$_resizeObserver","CustomEvent","detail","contentRect","dispatchEvent","vscrollData","vscrollParent","vscrollResizeObserver","validSizes","itemsWithSize","$_undefinedMap","listeners","$listeners","forceUpdate","$_updates","$_undefinedSizes","activated","deactivated","onScrollerResize","scroller","onScrollerVisible","force","getItemSize","scrollToBottom","$_scrollingToBottom","scrollHeight","_mergeProps","onResize","onVisible","_toHandlers","_hoisted_3","inject","watchData","sizeDependencies","emitResize","finalActive","onDataUpdate","observeSize","unobserveSize","$_pendingVScrollUpdate","updateSize","$isServer","$_forceNextVScrollUpdate","updateWatchData","k","$on","onVscrollUpdate","onVscrollUpdateSize","$off","$_pendingSizeUpdate","computeSize","$_watchData","offsetWidth","offsetHeight","applySize","round","$set","unobserve","idProp","vm","store","idState","$_id","$_getId","$_updateIdState","beforeUpdate","$_idStateInit","factory","registerComponents","prefix","DynamicScroller","DynamicScrollerItem","VERSION","finalOptions","installComponents","componentsPrefix"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file +{"version":3,"file":"vue-virtual-scroller.umd.js","sources":["../src/config.js","../node_modules/vue-resize/dist/vue-resize.esm.js","../node_modules/vue-observe-visibility/dist/vue-observe-visibility.esm.js","../node_modules/scrollparent/scrollparent.js","../src/components/common.js","../src/utils.js","../src/components/RecycleScroller.vue","../src/components/RecycleScroller.vue?vue&type=template&id=093a936d&lang.js","../src/components/DynamicScroller.vue","../src/components/DynamicScroller.vue?vue&type=template&id=76e15f19&lang.js","../src/components/DynamicScrollerItem.vue","../src/mixins/IdState.js","../src/index.js"],"sourcesContent":["export default {\r\n itemsLimit: 1000,\r\n}\r\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction setCurrentRenderingInstance(instance) {\r\n currentRenderingInstance = instance;\r\n}\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n/**\r\n * Wrap a slot function to memoize current rendering instance\r\n * @private\r\n */\r\nfunction withCtx(fn, ctx = currentRenderingInstance) {\r\n if (!ctx)\r\n return fn;\r\n const renderFnWithContext = (...args) => {\r\n // If a user calls a compiled slot inside a template expression (#1745), it\r\n // can mess up block tracking, so by default we need to push a null block to\r\n // avoid that. This isn't necessary if rendering a compiled ``.\r\n if (!isRenderingCompiledSlot) {\r\n openBlock(true /* null block that disables tracking */);\r\n }\r\n const owner = currentRenderingInstance;\r\n setCurrentRenderingInstance(ctx);\r\n const res = fn(...args);\r\n setCurrentRenderingInstance(owner);\r\n if (!isRenderingCompiledSlot) {\r\n closeBlock();\r\n }\r\n return res;\r\n };\r\n renderFnWithContext._c = true;\r\n return renderFnWithContext;\r\n}\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\nconst scopeIdStack = [];\r\n/**\r\n * @private\r\n */\r\nfunction pushScopeId(id) {\r\n scopeIdStack.push((currentScopeId = id));\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction popScopeId() {\r\n scopeIdStack.pop();\r\n currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null;\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction withScopeId(id) {\r\n return ((fn) => withCtx(function () {\r\n pushScopeId(id);\r\n const res = fn.apply(this, arguments);\r\n popScopeId();\r\n return res;\r\n }));\r\n}\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\n// Since v-if and v-for are the two possible ways node structure can dynamically\r\n// change, once we consider v-if branches and each v-for fragment a block, we\r\n// can divide a template into nested blocks, and within each block the node\r\n// structure would be stable. This allows us to skip most children diffing\r\n// and only worry about the dynamic nodes (indicated by patch flags).\r\nconst blockStack = [];\r\nlet currentBlock = null;\r\n/**\r\n * Open a block.\r\n * This must be called before `createBlock`. It cannot be part of `createBlock`\r\n * because the children of the block are evaluated before `createBlock` itself\r\n * is called. The generated code typically looks like this:\r\n *\r\n * ```js\r\n * function render() {\r\n * return (openBlock(),createBlock('div', null, [...]))\r\n * }\r\n * ```\r\n * disableTracking is true when creating a v-for fragment block, since a v-for\r\n * fragment always diffs its children.\r\n *\r\n * @private\r\n */\r\nfunction openBlock(disableTracking = false) {\r\n blockStack.push((currentBlock = disableTracking ? null : []));\r\n}\r\nfunction closeBlock() {\r\n blockStack.pop();\r\n currentBlock = blockStack[blockStack.length - 1] || null;\r\n}\r\n/**\r\n * Create a block root vnode. Takes the same exact arguments as `createVNode`.\r\n * A block root keeps track of dynamic nodes within the block in the\r\n * `dynamicChildren` array.\r\n *\r\n * @private\r\n */\r\nfunction createBlock(type, props, children, patchFlag, dynamicProps) {\r\n const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */);\r\n // save current block children on the block vnode\r\n vnode.dynamicChildren = currentBlock || EMPTY_ARR;\r\n // close block\r\n closeBlock();\r\n // a block is always going to be patched, so track it as a child of its\r\n // parent block\r\n if ( currentBlock) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...( args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction getInternetExplorerVersion() {\n var ua = window.navigator.userAgent;\n var msie = ua.indexOf('MSIE ');\n\n if (msie > 0) {\n // IE 10 or older => return version number\n return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);\n }\n\n var trident = ua.indexOf('Trident/');\n\n if (trident > 0) {\n // IE 11 => return version number\n var rv = ua.indexOf('rv:');\n return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);\n }\n\n var edge = ua.indexOf('Edge/');\n\n if (edge > 0) {\n // Edge (IE 12+) => return version number\n return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);\n } // other browser\n\n\n return -1;\n}\n\nvar isIE;\n\nfunction initCompat() {\n if (!initCompat.init) {\n initCompat.init = true;\n isIE = getInternetExplorerVersion() !== -1;\n }\n}\n\nvar script = {\n name: 'ResizeObserver',\n mounted: function mounted() {\n var _this = this;\n\n initCompat();\n nextTick(function () {\n _this._w = _this.$el.offsetWidth;\n _this._h = _this.$el.offsetHeight;\n });\n var object = document.createElement('object');\n this._resizeObject = object;\n object.setAttribute('aria-hidden', 'true');\n object.setAttribute('tabindex', -1);\n object.onload = this.addResizeHandlers;\n object.type = 'text/html';\n\n if (isIE) {\n this.$el.appendChild(object);\n }\n\n object.data = 'about:blank';\n\n if (!isIE) {\n this.$el.appendChild(object);\n }\n },\n beforeUnmount: function beforeUnmount() {\n this.removeResizeHandlers();\n },\n methods: {\n compareAndNotify: function compareAndNotify() {\n if (this._w !== this.$el.offsetWidth || this._h !== this.$el.offsetHeight) {\n this._w = this.$el.offsetWidth;\n this._h = this.$el.offsetHeight;\n this.$emit('notify', {\n width: this._w,\n height: this._h\n });\n }\n },\n addResizeHandlers: function addResizeHandlers() {\n this._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify);\n\n this.compareAndNotify();\n },\n removeResizeHandlers: function removeResizeHandlers() {\n if (this._resizeObject && this._resizeObject.onload) {\n if (!isIE && this._resizeObject.contentDocument) {\n this._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify);\n }\n\n this.$el.removeChild(this._resizeObject);\n this._resizeObject.onload = null;\n this._resizeObject = null;\n }\n }\n }\n};\n\nvar _withId = /*#__PURE__*/withScopeId(\"data-v-b329ee4c\");\n\npushScopeId(\"data-v-b329ee4c\");\n\nvar _hoisted_1 = {\n class: \"resize-observer\",\n tabindex: \"-1\"\n};\n\npopScopeId();\n\nvar render = /*#__PURE__*/_withId(function (_ctx, _cache, $props, $setup, $data, $options) {\n return openBlock(), createBlock(\"div\", _hoisted_1);\n});\n\nscript.render = render;\nscript.__scopeId = \"data-v-b329ee4c\";\nscript.__file = \"src/components/ResizeObserver.vue\";\n\nfunction install(Vue) {\n Vue.component('resize-observer', script);\n Vue.component('ResizeObserver', script);\n}\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.9.0-ropez.1\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { script as ResizeObserver, install };\n//# sourceMappingURL=vue-resize.esm.js.map\n","function _typeof(obj) {\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n}\n\nfunction _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n return arr2;\n }\n}\n\nfunction _iterableToArray(iter) {\n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\n/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n const map = Object.create(null);\r\n const list = str.split(',');\r\n for (let i = 0; i < list.length; i++) {\r\n map[list[i]] = true;\r\n }\r\n return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n }\r\n else if (isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.split(listDelimiterRE).forEach(item => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = '';\r\n if (isString(value)) {\r\n res = value;\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n res += normalizeClass(value[i]) + ' ';\r\n }\r\n }\r\n else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + ' ';\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n ? Object.freeze({})\r\n : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n // extract \"RawType\" from strings like \"[object RawType]\"\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isIntegerKey = (key) => isString(key) &&\r\n key !== 'NaN' &&\r\n key[0] !== '-' &&\r\n '' + parseInt(key, 10) === key;\r\nconst cacheStringFunction = (fn) => {\r\n const cache = Object.create(null);\r\n return ((str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase());\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return (_globalThis ||\r\n (_globalThis =\r\n typeof globalThis !== 'undefined'\r\n ? globalThis\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : typeof global !== 'undefined'\r\n ? global\r\n : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n if (isEffect(fn)) {\r\n fn = fn.raw;\r\n }\r\n const effect = createReactiveEffect(fn, options);\r\n if (!options.lazy) {\r\n effect();\r\n }\r\n return effect;\r\n}\r\nfunction stop(effect) {\r\n if (effect.active) {\r\n cleanup(effect);\r\n if (effect.options.onStop) {\r\n effect.options.onStop();\r\n }\r\n effect.active = false;\r\n }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n const effect = function reactiveEffect() {\r\n if (!effect.active) {\r\n return options.scheduler ? undefined : fn();\r\n }\r\n if (!effectStack.includes(effect)) {\r\n cleanup(effect);\r\n try {\r\n enableTracking();\r\n effectStack.push(effect);\r\n activeEffect = effect;\r\n return fn();\r\n }\r\n finally {\r\n effectStack.pop();\r\n resetTracking();\r\n activeEffect = effectStack[effectStack.length - 1];\r\n }\r\n }\r\n };\r\n effect.id = uid++;\r\n effect.allowRecurse = !!options.allowRecurse;\r\n effect._isEffect = true;\r\n effect.active = true;\r\n effect.raw = fn;\r\n effect.deps = [];\r\n effect.options = options;\r\n return effect;\r\n}\r\nfunction cleanup(effect) {\r\n const { deps } = effect;\r\n if (deps.length) {\r\n for (let i = 0; i < deps.length; i++) {\r\n deps[i].delete(effect);\r\n }\r\n deps.length = 0;\r\n }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n if (!shouldTrack || activeEffect === undefined) {\r\n return;\r\n }\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, (depsMap = new Map()));\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, (dep = new Set()));\r\n }\r\n if (!dep.has(activeEffect)) {\r\n dep.add(activeEffect);\r\n activeEffect.deps.push(dep);\r\n if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n activeEffect.options.onTrack({\r\n effect: activeEffect,\r\n target,\r\n type,\r\n key\r\n });\r\n }\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n // never been tracked\r\n return;\r\n }\r\n const effects = new Set();\r\n const add = (effectsToAdd) => {\r\n if (effectsToAdd) {\r\n effectsToAdd.forEach(effect => {\r\n if (effect !== activeEffect || effect.allowRecurse) {\r\n effects.add(effect);\r\n }\r\n });\r\n }\r\n };\r\n if (type === \"clear\" /* CLEAR */) {\r\n // collection being cleared\r\n // trigger all effects for target\r\n depsMap.forEach(add);\r\n }\r\n else if (key === 'length' && isArray(target)) {\r\n depsMap.forEach((dep, key) => {\r\n if (key === 'length' || key >= newValue) {\r\n add(dep);\r\n }\r\n });\r\n }\r\n else {\r\n // schedule runs for SET | ADD | DELETE\r\n if (key !== void 0) {\r\n add(depsMap.get(key));\r\n }\r\n // also run for iteration key on ADD | DELETE | Map.SET\r\n switch (type) {\r\n case \"add\" /* ADD */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n else if (isIntegerKey(key)) {\r\n // new index added to array -> length changes\r\n add(depsMap.get('length'));\r\n }\r\n break;\r\n case \"delete\" /* DELETE */:\r\n if (!isArray(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\" /* SET */:\r\n if (isMap(target)) {\r\n add(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n const run = (effect) => {\r\n if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n effect.options.onTrigger({\r\n effect,\r\n target,\r\n key,\r\n type,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n });\r\n }\r\n if (effect.options.scheduler) {\r\n effect.options.scheduler(effect);\r\n }\r\n else {\r\n effect();\r\n }\r\n };\r\n effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n .map(key => Symbol[key])\r\n .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\" /* GET */, i + '');\r\n }\r\n // we run the method using the original args first (which may be reactive)\r\n const res = method.apply(arr, args);\r\n if (res === -1 || res === false) {\r\n // if that didn't work, run it again using raw values.\r\n return method.apply(arr, args.map(toRaw));\r\n }\r\n else {\r\n return res;\r\n }\r\n };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n const method = Array.prototype[key];\r\n arrayInstrumentations[key] = function (...args) {\r\n pauseTracking();\r\n const res = method.apply(this, args);\r\n resetTracking();\r\n return res;\r\n };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n return function get(target, key, receiver) {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */ &&\r\n receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {\r\n return target;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key)\r\n ? builtInSymbols.has(key)\r\n : key === `__proto__` || key === `__v_isRef`) {\r\n return res;\r\n }\r\n if (!isReadonly) {\r\n track(target, \"get\" /* GET */, key);\r\n }\r\n if (shallow) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n // ref unwrapping - does not apply for Array + integer key.\r\n const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n return shouldUnwrap ? res.value : res;\r\n }\r\n if (isObject(res)) {\r\n // Convert returned value into a proxy as well. we do the isObject check\r\n // here to avoid invalid value warning. Also need to lazy access readonly\r\n // and reactive here to avoid circular dependency.\r\n return isReadonly ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n return function set(target, key, value, receiver) {\r\n const oldValue = target[key];\r\n if (!shallow) {\r\n value = toRaw(value);\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key)\r\n ? Number(key) < target.length\r\n : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n // don't trigger if target is something up in the prototype chain of original\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n };\r\n}\r\nfunction deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\" /* HAS */, key);\r\n }\r\n return result;\r\n}\r\nfunction ownKeys(target) {\r\n track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n get,\r\n set,\r\n deleteProperty,\r\n has,\r\n ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n get: readonlyGet,\r\n set(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n },\r\n deleteProperty(target, key) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n }\r\n return true;\r\n }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n get: shallowGet,\r\n set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n // of the value\r\n target = target[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n const { has } = getProto(rawTarget);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n if (has.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n }\r\n else if (has.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (key !== rawKey) {\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n }\r\n !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n return key === rawKey\r\n ? target.has(key)\r\n : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n target = target[\"__v_raw\" /* RAW */];\r\n !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n target.add(value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, value, value);\r\n }\r\n return this;\r\n}\r\nfunction set$1(key, value) {\r\n value = toRaw(value);\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\" /* ADD */, key, value);\r\n }\r\n else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has, get } = getProto(target);\r\n let hadKey = has.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has.call(target, key);\r\n }\r\n else if ((process.env.NODE_ENV !== 'production')) {\r\n checkIdentityKeys(target, has, key);\r\n }\r\n const oldValue = get ? get.call(target, key) : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = (process.env.NODE_ENV !== 'production')\r\n ? isMap(target)\r\n ? new Map(target)\r\n : new Set(target)\r\n : undefined;\r\n // forward the operation before queueing reactions\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n // important: make sure the callback is\r\n // 1. invoked with the reactive map as `this` and 3rd arg\r\n // 2. the value received should be a corresponding reactive/readonly.\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n return function (...args) {\r\n const target = this[\"__v_raw\" /* RAW */];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n const isKeyOnly = method === 'keys' && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n !isReadonly &&\r\n track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n // return a wrapped iterator which returns observed versions of the\r\n // values emitted from the real iterator\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done\r\n ? { value, done }\r\n : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function (...args) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n }\r\n return type === \"delete\" /* DELETE */ ? false : this;\r\n };\r\n}\r\nconst mutableInstrumentations = {\r\n get(key) {\r\n return get$1(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has: has$1,\r\n add,\r\n set: set$1,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n get(key) {\r\n return get$1(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has$1.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\" /* ADD */),\r\n set: createReadonlyMethod(\"set\" /* SET */),\r\n delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n const instrumentations = shallow\r\n ? shallowInstrumentations\r\n : isReadonly\r\n ? readonlyInstrumentations\r\n : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n return !isReadonly;\r\n }\r\n else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n return isReadonly;\r\n }\r\n else if (key === \"__v_raw\" /* RAW */) {\r\n return target;\r\n }\r\n return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n ? instrumentations\r\n : target, key, receiver);\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n `which can lead to inconsistencies. ` +\r\n `Avoid differentiating between the raw and reactive versions ` +\r\n `of an object and only use the reactive version if possible.`);\r\n }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case 'Object':\r\n case 'Array':\r\n return 1 /* COMMON */;\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n ? 0 /* INVALID */\r\n : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n // if trying to observe a readonly proxy, return the readonly version.\r\n if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n return target;\r\n }\r\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n if (!isObject(target)) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n console.warn(`value cannot be made reactive: ${String(target)}`);\r\n }\r\n return target;\r\n }\r\n // target is already a Proxy, return it.\r\n // exception: calling readonly() on a reactive object\r\n if (target[\"__v_raw\" /* RAW */] &&\r\n !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n return target;\r\n }\r\n // target already has corresponding Proxy\r\n const proxyMap = isReadonly ? readonlyMap : reactiveMap;\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n // only a whitelist of value types can be observed.\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\" /* RAW */]);\r\n }\r\n return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n return Boolean(r && r.__v_isRef === true);\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n // avoid props formatting or warn handler tracking deps that might be mutated\r\n // during patch, leading to infinite recursion.\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n msg + args.join(''),\r\n instance && instance.proxy,\r\n trace\r\n .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n .join('\\n'),\r\n trace\r\n ]);\r\n }\r\n else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n /* istanbul ignore if */\r\n if (trace.length &&\r\n // avoid spamming console during tests\r\n !false) {\r\n warnArgs.push(`\\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n // we can't just use the stack because it will be incomplete during updates\r\n // that did not start from the root. Re-construct the parent chain using\r\n // instance parent pointers.\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n }\r\n else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n const close = `>` + postfix;\r\n return vnode.props\r\n ? [open, ...formatProps(vnode.props), close]\r\n : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach(key => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (typeof value === 'number' ||\r\n typeof value === 'boolean' ||\r\n value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n }\r\n else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n }\r\n else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n }\r\n else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\n\nconst ErrorTypeStrings = {\r\n [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n [\"c\" /* CREATED */]: 'created hook',\r\n [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n [\"m\" /* MOUNTED */]: 'mounted hook',\r\n [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n [\"u\" /* UPDATED */]: 'updated',\r\n [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n [\"a\" /* ACTIVATED */]: 'activated hook',\r\n [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n [0 /* SETUP_FUNCTION */]: 'setup function',\r\n [1 /* RENDER_FUNCTION */]: 'render function',\r\n [2 /* WATCH_GETTER */]: 'watcher getter',\r\n [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n [7 /* VNODE_HOOK */]: 'vnode hook',\r\n [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n [12 /* FUNCTION_REF */]: 'ref function',\r\n [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n let res;\r\n try {\r\n res = args ? fn(...args) : fn();\r\n }\r\n catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch(err => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n // the exposed instance is the render proxy to keep it consistent with 2.x\r\n const exposedInstance = instance.proxy;\r\n // in production the hook receives only the error code\r\n const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n // app-level handling\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n const info = ErrorTypeStrings[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n // crash in dev by default so it's more noticeable\r\n if (throwInDev) {\r\n throw err;\r\n }\r\n else {\r\n console.error(err);\r\n }\r\n }\r\n else {\r\n // recover in prod to reduce the impact on end-user\r\n console.error(err);\r\n }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n // the dedupe search uses the startIndex argument of Array.includes()\r\n // by default the search index includes the current job that is being run\r\n // so it cannot recursively trigger itself again.\r\n // if the job is a watch() callback, the search will start with a +1 index to\r\n // allow it recursively trigger itself - it is the user's responsibility to\r\n // ensure it doesn't end up in an infinite loop.\r\n if ((!queue.length ||\r\n !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n job !== currentPreFlushParentJob) {\r\n queue.push(job);\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n if (!isArray(cb)) {\r\n if (!activeQueue ||\r\n !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n pendingQueue.push(cb);\r\n }\r\n }\r\n else {\r\n // if cb is an array, it is a component lifecycle hook which can only be\r\n // triggered by a job, which is already deduped in the main queue, so\r\n // we can skip duplicate check here to improve perf\r\n pendingQueue.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n if (pendingPreFlushCbs.length) {\r\n currentPreFlushParentJob = parentJob;\r\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n pendingPreFlushCbs.length = 0;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n }\r\n activePreFlushCbs[preFlushIndex]();\r\n }\r\n activePreFlushCbs = null;\r\n preFlushIndex = 0;\r\n currentPreFlushParentJob = null;\r\n // recursively flush until it drains\r\n flushPreFlushCbs(seen, parentJob);\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)];\r\n pendingPostFlushCbs.length = 0;\r\n // #1947 already has active queue, nested flushPostFlushCbs call\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n }\r\n activePostFlushCbs[postFlushIndex]();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n seen = seen || new Map();\r\n }\r\n flushPreFlushCbs(seen);\r\n // Sort queue before flush.\r\n // This ensures that:\r\n // 1. Components are updated from parent to child. (because parent is always\r\n // created before the child so its render effect will have smaller\r\n // priority number)\r\n // 2. If a component is unmounted during a parent component's update,\r\n // its update can be skipped.\r\n queue.sort((a, b) => getId(a) - getId(b));\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job) {\r\n if ((process.env.NODE_ENV !== 'production')) {\r\n checkRecursiveUpdates(seen, job);\r\n }\r\n callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n }\r\n }\r\n }\r\n finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n // some postFlushCb queued jobs!\r\n // keep flushing until it drains.\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n }\r\n else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n throw new Error(`Maximum recursive updates exceeded. ` +\r\n `This means you have a reactive effect that is mutating its own ` +\r\n `dependencies and thus recursively triggering itself. Possible sources ` +\r\n `include component template, render function, updated hook or ` +\r\n `watcher source function.`);\r\n }\r\n else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n const globalObject = typeof global !== 'undefined'\r\n ? global\r\n : typeof self !== 'undefined'\r\n ? self\r\n : typeof window !== 'undefined'\r\n ? window\r\n : {};\r\n globalObject.__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id, component) {\r\n if (!component) {\r\n warn(`HMR API usage is out of date.\\n` +\r\n `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n `depdendency that handles Vue SFC compilation.`);\r\n component = {};\r\n }\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n component: isClassComponent(component) ? component.__vccOpts : component,\r\n instances: new Set()\r\n });\r\n return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n if (newRender)\r\n record.component.render = newRender;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n Array.from(record.instances).forEach(instance => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n }\r\n instance.renderCache = [];\r\n instance.update();\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record)\r\n return;\r\n // Array.from creates a snapshot which avoids the set being mutated during\r\n // updates\r\n const { component, instances } = record;\r\n if (!hmrDirtyComponents.has(component)) {\r\n // 1. Update existing comp definition to match new one\r\n newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n extend(component, newComp);\r\n for (const key in component) {\r\n if (!(key in newComp)) {\r\n delete component[key];\r\n }\r\n }\r\n // 2. Mark component dirty. This forces the renderer to replace the component\r\n // on patch.\r\n hmrDirtyComponents.add(component);\r\n // 3. Make sure to unmark the component after the reload.\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.delete(component);\r\n });\r\n }\r\n Array.from(instances).forEach(instance => {\r\n if (instance.parent) {\r\n // 4. Force the parent instance to re-render. This will cause all updated\r\n // components to be unmounted and re-mounted. Queue the update so that we\r\n // don't end up forcing the same parent to re-render multiple times.\r\n queueJob(instance.parent.update);\r\n }\r\n else if (instance.appContext.reload) {\r\n // root instance mounted via createApp() has a reload method\r\n instance.appContext.reload();\r\n }\r\n else if (typeof window !== 'undefined') {\r\n // root instance inside tree created via raw render(). Force reload.\r\n window.location.reload();\r\n }\r\n else {\r\n console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n }\r\n });\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n }\r\n catch (e) {\r\n console.error(e);\r\n console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n `Full reload required.`);\r\n }\r\n };\r\n}\nfunction setDevtoolsHook(hook) {\r\n}\r\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nfunction markAttrsAccessed() {\r\n}\r\nfunction filterSingleRoot(children) {\r\n let singleRoot;\r\n for (let i = 0; i < children.length; i++) {\r\n const child = children[i];\r\n if (isVNode(child)) {\r\n // ignore user comment\r\n if (child.type !== Comment || child.children === 'v-if') {\r\n if (singleRoot) {\r\n // has more than 1 non-comment child, return now\r\n return;\r\n }\r\n else {\r\n singleRoot = child;\r\n }\r\n }\r\n }\r\n else {\r\n return;\r\n }\r\n }\r\n return singleRoot;\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n let content;\r\n let fallback;\r\n if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n content = normalizeSuspenseSlot(children.default);\r\n fallback = normalizeSuspenseSlot(children.fallback);\r\n }\r\n else {\r\n content = normalizeSuspenseSlot(children);\r\n fallback = normalizeVNode(null);\r\n }\r\n return {\r\n content,\r\n fallback\r\n };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n if (isFunction(s)) {\r\n s = s();\r\n }\r\n if (isArray(s)) {\r\n const singleChild = filterSingleRoot(s);\r\n if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n warn(` slots expect a single root node.`);\r\n }\r\n s = singleChild;\r\n }\r\n return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense && suspense.pendingBranch) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n if (immediate !== undefined) {\r\n warn(`watch() \"immediate\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n if (deep !== undefined) {\r\n warn(`watch() \"deep\" option is only respected when using the ` +\r\n `watch(source, callback, options?) signature.`);\r\n }\r\n }\r\n const warnInvalidSource = (s) => {\r\n warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n `a reactive object, or an array of these types.`);\r\n };\r\n let getter;\r\n let forceTrigger = false;\r\n if (isRef(source)) {\r\n getter = () => source.value;\r\n forceTrigger = !!source._shallow;\r\n }\r\n else if (isReactive(source)) {\r\n getter = () => source;\r\n deep = true;\r\n }\r\n else if (isArray(source)) {\r\n getter = () => source.map(s => {\r\n if (isRef(s)) {\r\n return s.value;\r\n }\r\n else if (isReactive(s)) {\r\n return traverse(s);\r\n }\r\n else if (isFunction(s)) {\r\n return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n }\r\n });\r\n }\r\n else if (isFunction(source)) {\r\n if (cb) {\r\n // getter with cb\r\n getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n }\r\n else {\r\n // no cb -> simple effect\r\n getter = () => {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n };\r\n }\r\n }\r\n else {\r\n getter = NOOP;\r\n (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n }\r\n if (cb && deep) {\r\n const baseGetter = getter;\r\n getter = () => traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const onInvalidate = (fn) => {\r\n cleanup = runner.options.onStop = () => {\r\n callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n const job = () => {\r\n if (!runner.active) {\r\n return;\r\n }\r\n if (cb) {\r\n // watch(source, cb)\r\n const newValue = runner();\r\n if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n // cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n newValue,\r\n // pass undefined as the old value when it's changed for the first time\r\n oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n onInvalidate\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n else {\r\n // watchEffect\r\n runner();\r\n }\r\n };\r\n // important: mark the job as a watcher callback so that scheduler knows\r\n // it is allowed to self-trigger (#1727)\r\n job.allowRecurse = !!cb;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = job;\r\n }\r\n else if (flush === 'post') {\r\n scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n }\r\n else {\r\n // default: 'pre'\r\n scheduler = () => {\r\n if (!instance || instance.isMounted) {\r\n queuePreFlushCb(job);\r\n }\r\n else {\r\n // with 'pre' option, the first call must happen before\r\n // the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler\r\n });\r\n recordInstanceBoundEffect(runner, instance);\r\n // initial run\r\n if (cb) {\r\n if (immediate) {\r\n job();\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n }\r\n else if (flush === 'post') {\r\n queuePostRenderEffect(runner, instance && instance.suspense);\r\n }\r\n else {\r\n runner();\r\n }\r\n return () => {\r\n stop(runner);\r\n if (instance) {\r\n remove(instance.effects, runner);\r\n }\r\n };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const publicThis = this.proxy;\r\n const getter = isString(source)\r\n ? () => publicThis[source]\r\n : source.bind(publicThis);\r\n return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return value;\r\n }\r\n seen.add(value);\r\n if (isRef(value)) {\r\n traverse(value.value, seen);\r\n }\r\n else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (isSet(value) || isMap(value)) {\r\n value.forEach((v) => {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\nlet currentBlock = null;\r\n// Whether we should be tracking dynamic child nodes inside a block.\r\n// Only tracks when this value is > 0\r\n// We are not using a simple boolean because this value may need to be\r\n// incremented/decremented by nested usage of v-once (see below)\r\nlet shouldTrack$1 = 1;\r\nfunction isVNode(value) {\r\n return value ? value.__v_isVNode === true : false;\r\n}\r\nlet vnodeArgsTransformer;\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n return _createVNode(...(vnodeArgsTransformer\r\n ? vnodeArgsTransformer(args, currentRenderingInstance)\r\n : args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n return (ref != null\r\n ? isString(ref) || isRef(ref) || isFunction(ref)\r\n ? { i: currentRenderingInstance, r: ref }\r\n : ref\r\n : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n ? createVNodeWithArgsTransform\r\n : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n if ((process.env.NODE_ENV !== 'production') && !type) {\r\n warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n }\r\n type = Comment;\r\n }\r\n if (isVNode(type)) {\r\n // createVNode receiving an existing vnode. This happens in cases like\r\n // \r\n // #2078 make sure to merge refs during the clone instead of overwriting it\r\n const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n if (children) {\r\n normalizeChildren(cloned, children);\r\n }\r\n return cloned;\r\n }\r\n // class component normalization.\r\n if (isClassComponent(type)) {\r\n type = type.__vccOpts;\r\n }\r\n // class & style normalization.\r\n if (props) {\r\n // for reactive or proxy objects, we need to clone it to enable mutation.\r\n if (isProxy(props) || InternalObjectKey in props) {\r\n props = extend({}, props);\r\n }\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (isObject(style)) {\r\n // reactive state objects need to be cloned since they are likely to be\r\n // mutated\r\n if (isProxy(style) && !isArray(style)) {\r\n style = extend({}, style);\r\n }\r\n props.style = normalizeStyle(style);\r\n }\r\n }\r\n // encode the vnode type information into a bitmap\r\n const shapeFlag = isString(type)\r\n ? 1 /* ELEMENT */\r\n : isSuspense(type)\r\n ? 128 /* SUSPENSE */\r\n : isTeleport(type)\r\n ? 64 /* TELEPORT */\r\n : isObject(type)\r\n ? 4 /* STATEFUL_COMPONENT */\r\n : isFunction(type)\r\n ? 2 /* FUNCTIONAL_COMPONENT */\r\n : 0;\r\n if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n type = toRaw(type);\r\n warn(`Vue received a Component which was made a reactive object. This can ` +\r\n `lead to unnecessary performance overhead, and should be avoided by ` +\r\n `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n }\r\n const vnode = {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type,\r\n props,\r\n key: props && normalizeKey(props),\r\n ref: props && normalizeRef(props),\r\n scopeId: currentScopeId,\r\n children: null,\r\n component: null,\r\n suspense: null,\r\n ssContent: null,\r\n ssFallback: null,\r\n dirs: null,\r\n transition: null,\r\n el: null,\r\n anchor: null,\r\n target: null,\r\n targetAnchor: null,\r\n staticCount: 0,\r\n shapeFlag,\r\n patchFlag,\r\n dynamicProps,\r\n dynamicChildren: null,\r\n appContext: null\r\n };\r\n // validate key\r\n if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n }\r\n normalizeChildren(vnode, children);\r\n // normalize suspense children\r\n if ( shapeFlag & 128 /* SUSPENSE */) {\r\n const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n vnode.ssContent = content;\r\n vnode.ssFallback = fallback;\r\n }\r\n if (shouldTrack$1 > 0 &&\r\n // avoid a block node from tracking itself\r\n !isBlockNode &&\r\n // has current parent block\r\n currentBlock &&\r\n // presence of a patch flag indicates this node needs patching on updates.\r\n // component nodes also should always be patched, because even if the\r\n // component doesn't need to update, it needs to persist the instance on to\r\n // the next vnode so that it can be properly unmounted later.\r\n (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n // the EVENTS flag is only for hydration and if it is the only flag, the\r\n // vnode should not be considered dynamic due to handler caching.\r\n patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n currentBlock.push(vnode);\r\n }\r\n return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n // This is intentionally NOT using spread or extend to avoid the runtime\r\n // key enumeration cost.\r\n const { props, ref, patchFlag } = vnode;\r\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n return {\r\n __v_isVNode: true,\r\n [\"__v_skip\" /* SKIP */]: true,\r\n type: vnode.type,\r\n props: mergedProps,\r\n key: mergedProps && normalizeKey(mergedProps),\r\n ref: extraProps && extraProps.ref\r\n ? // #2078 in the case of \r\n // if the vnode itself already has a ref, cloneVNode will need to merge\r\n // the refs so the single vnode can be set on multiple refs\r\n mergeRef && ref\r\n ? isArray(ref)\r\n ? ref.concat(normalizeRef(extraProps))\r\n : [ref, normalizeRef(extraProps)]\r\n : normalizeRef(extraProps)\r\n : ref,\r\n scopeId: vnode.scopeId,\r\n children: vnode.children,\r\n target: vnode.target,\r\n targetAnchor: vnode.targetAnchor,\r\n staticCount: vnode.staticCount,\r\n shapeFlag: vnode.shapeFlag,\r\n // if the vnode is cloned with extra props, we can no longer assume its\r\n // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n // note: perserve flag for fragments since they use the flag for children\r\n // fast paths only.\r\n patchFlag: extraProps && vnode.type !== Fragment\r\n ? patchFlag === -1 // hoisted node\r\n ? 16 /* FULL_PROPS */\r\n : patchFlag | 16 /* FULL_PROPS */\r\n : patchFlag,\r\n dynamicProps: vnode.dynamicProps,\r\n dynamicChildren: vnode.dynamicChildren,\r\n appContext: vnode.appContext,\r\n dirs: vnode.dirs,\r\n transition: vnode.transition,\r\n // These should technically only be non-null on mounted VNodes. However,\r\n // they *should* be copied for kept-alive vnodes. So we just always copy\r\n // them since them being non-null during a mount doesn't affect the logic as\r\n // they will simply be overwritten.\r\n component: vnode.component,\r\n suspense: vnode.suspense,\r\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n el: vnode.el,\r\n anchor: vnode.anchor\r\n };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n return createVNode(Text, null, text, flag);\r\n}\r\nfunction normalizeVNode(child) {\r\n if (child == null || typeof child === 'boolean') {\r\n // empty placeholder\r\n return createVNode(Comment);\r\n }\r\n else if (isArray(child)) {\r\n // fragment\r\n return createVNode(Fragment, null, child);\r\n }\r\n else if (typeof child === 'object') {\r\n // already vnode, this should be the most common since compiled templates\r\n // always produce all-vnode children arrays\r\n return child.el === null ? child : cloneVNode(child);\r\n }\r\n else {\r\n // strings and numbers\r\n return createVNode(Text, null, String(child));\r\n }\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n let type = 0;\r\n const { shapeFlag } = vnode;\r\n if (children == null) {\r\n children = null;\r\n }\r\n else if (isArray(children)) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n }\r\n else if (typeof children === 'object') {\r\n if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n // Normalize slot to plain children for plain element and Teleport\r\n const slot = children.default;\r\n if (slot) {\r\n // _c marker is added by withCtx() indicating this is a compiled slot\r\n slot._c && setCompiledSlotRendering(1);\r\n normalizeChildren(vnode, slot());\r\n slot._c && setCompiledSlotRendering(-1);\r\n }\r\n return;\r\n }\r\n else {\r\n type = 32 /* SLOTS_CHILDREN */;\r\n const slotFlag = children._;\r\n if (!slotFlag && !(InternalObjectKey in children)) {\r\n children._ctx = currentRenderingInstance;\r\n }\r\n else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n // a child component receives forwarded slots from the parent.\r\n // its slot type is determined by its parent's slot type.\r\n if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n children._ = 2 /* DYNAMIC */;\r\n vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n }\r\n else {\r\n children._ = 1 /* STABLE */;\r\n }\r\n }\r\n }\r\n }\r\n else if (isFunction(children)) {\r\n children = { default: children, _ctx: currentRenderingInstance };\r\n type = 32 /* SLOTS_CHILDREN */;\r\n }\r\n else {\r\n children = String(children);\r\n // force teleport children to array so it can be moved around\r\n if (shapeFlag & 64 /* TELEPORT */) {\r\n type = 16 /* ARRAY_CHILDREN */;\r\n children = [createTextVNode(children)];\r\n }\r\n else {\r\n type = 8 /* TEXT_CHILDREN */;\r\n }\r\n }\r\n vnode.children = children;\r\n vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n const ret = extend({}, args[0]);\r\n for (let i = 1; i < args.length; i++) {\r\n const toMerge = args[i];\r\n for (const key in toMerge) {\r\n if (key === 'class') {\r\n if (ret.class !== toMerge.class) {\r\n ret.class = normalizeClass([ret.class, toMerge.class]);\r\n }\r\n }\r\n else if (key === 'style') {\r\n ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n }\r\n else if (isOn(key)) {\r\n const existing = ret[key];\r\n const incoming = toMerge[key];\r\n if (existing !== incoming) {\r\n ret[key] = existing\r\n ? [].concat(existing, toMerge[key])\r\n : incoming;\r\n }\r\n }\r\n else if (key !== '') {\r\n ret[key] = toMerge[key];\r\n }\r\n }\r\n }\r\n return ret;\r\n}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n const raw = instance.type;\r\n const { __merged, mixins, extends: extendsOptions } = raw;\r\n if (__merged)\r\n return __merged;\r\n const globalMixins = instance.appContext.mixins;\r\n if (!globalMixins.length && !mixins && !extendsOptions)\r\n return raw;\r\n const options = {};\r\n globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n mergeOptions(options, raw, instance);\r\n return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n const strats = instance.appContext.config.optionMergeStrategies;\r\n const { mixins, extends: extendsOptions } = from;\r\n extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n mixins &&\r\n mixins.forEach((m) => mergeOptions(to, m, instance));\r\n for (const key in from) {\r\n if (strats && hasOwn(strats, key)) {\r\n to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n }\r\n else {\r\n to[key] = from[key];\r\n }\r\n }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => i && (i.proxy ? i.proxy : getPublicInstance(i.parent));\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n $: i => i,\r\n $el: i => i.vnode.el,\r\n $data: i => i.data,\r\n $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n $parent: i => getPublicInstance(i.parent),\r\n $root: i => i.root && i.root.proxy,\r\n $emit: i => i.emit,\r\n $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n $forceUpdate: i => () => queueJob(i.update),\r\n $nextTick: i => nextTick.bind(i.proxy),\r\n $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n // let @vue/reactivity know it should never observe Vue public instances.\r\n if (key === \"__v_skip\" /* SKIP */) {\r\n return true;\r\n }\r\n // for internal formatters to know that this is a Vue instance\r\n if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n return true;\r\n }\r\n // data / props / ctx\r\n // This getter gets called for every property access on the render context\r\n // during render and is a major hotspot. The most expensive part of this\r\n // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n // access on a plain object, so we use an accessCache object (with null\r\n // prototype) to memoize what access type a key corresponds to.\r\n let normalizedProps;\r\n if (key[0] !== '$') {\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 /* SETUP */:\r\n return setupState[key];\r\n case 1 /* DATA */:\r\n return data[key];\r\n case 3 /* CONTEXT */:\r\n return ctx[key];\r\n case 2 /* PROPS */:\r\n return props[key];\r\n // default: just fallthrough\r\n }\r\n }\r\n else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n accessCache[key] = 0 /* SETUP */;\r\n return setupState[key];\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 1 /* DATA */;\r\n return data[key];\r\n }\r\n else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) &&\r\n hasOwn(normalizedProps, key)) {\r\n accessCache[key] = 2 /* PROPS */;\r\n return props[key];\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n accessCache[key] = 4 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n // public $xxx properties\r\n if (publicGetter) {\r\n if (key === '$attrs') {\r\n track(instance, \"get\" /* GET */, key);\r\n (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n }\r\n return publicGetter(instance);\r\n }\r\n else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) &&\r\n (cssModule = cssModule[key])) {\r\n return cssModule;\r\n }\r\n else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n // user may set custom properties to `this` that start with `$`\r\n accessCache[key] = 3 /* CONTEXT */;\r\n return ctx[key];\r\n }\r\n else if (\r\n // global properties\r\n ((globalProperties = appContext.config.globalProperties),\r\n hasOwn(globalProperties, key))) {\r\n return globalProperties[key];\r\n }\r\n else if ((process.env.NODE_ENV !== 'production') &&\r\n currentRenderingInstance &&\r\n (!isString(key) ||\r\n // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf('__v') !== 0)) {\r\n if (data !== EMPTY_OBJ &&\r\n (key[0] === '$' || key[0] === '_') &&\r\n hasOwn(data, key)) {\r\n warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n }\r\n else {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n setupState[key] = value;\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (key in instance.props) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n return false;\r\n }\r\n if (key[0] === '$' && key.slice(1) in instance) {\r\n (process.env.NODE_ENV !== 'production') &&\r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, instance);\r\n return false;\r\n }\r\n else {\r\n if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n Object.defineProperty(ctx, key, {\r\n enumerable: true,\r\n configurable: true,\r\n value\r\n });\r\n }\r\n else {\r\n ctx[key] = value;\r\n }\r\n }\r\n return true;\r\n },\r\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n let normalizedProps;\r\n return (accessCache[key] !== undefined ||\r\n (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n hasOwn(ctx, key) ||\r\n hasOwn(publicPropertiesMap, key) ||\r\n hasOwn(appContext.config.globalProperties, key));\r\n }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n `The keys will be empty in production mode to avoid performance overhead.`);\r\n return Reflect.ownKeys(target);\r\n };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n get(target, key) {\r\n // fast path for unscopables when using `with` block\r\n if (key === Symbol.unscopables) {\r\n return;\r\n }\r\n return PublicInstanceProxyHandlers.get(target, key, target);\r\n },\r\n has(_, key) {\r\n const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n }\r\n return has;\r\n }\r\n});\r\nlet currentInstance = null;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect, instance = currentInstance) {\r\n if (instance) {\r\n (instance.effects || (instance.effects = [])).push(effect);\r\n }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n let name = isFunction(Component)\r\n ? Component.displayName || Component.name\r\n : Component.name;\r\n if (!name && Component.__file) {\r\n const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n if (match) {\r\n name = match[1];\r\n }\r\n }\r\n if (!name && instance && instance.parent) {\r\n // try to infer the name based on reverse resolution\r\n const inferFromRegistry = (registry) => {\r\n for (const key in registry) {\r\n if (registry[key] === Component) {\r\n return key;\r\n }\r\n }\r\n };\r\n name =\r\n inferFromRegistry(instance.components ||\r\n instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n }\r\n return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n return isFunction(value) && '__vccOpts' in value;\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\n\nfunction initCustomFormatter() {\r\n /* eslint-disable no-restricted-globals */\r\n if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n return;\r\n }\r\n const vueStyle = { style: 'color:#3ba776' };\r\n const numberStyle = { style: 'color:#0b1bc9' };\r\n const stringStyle = { style: 'color:#b62e24' };\r\n const keywordStyle = { style: 'color:#9d288c' };\r\n // custom formatter for Chrome\r\n // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n const formatter = {\r\n header(obj) {\r\n // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n if (!isObject(obj)) {\r\n return null;\r\n }\r\n if (obj.__isVue) {\r\n return ['div', vueStyle, `VueInstance`];\r\n }\r\n else if (isRef(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, genRefFlag(obj)],\r\n '<',\r\n formatValue(obj.value),\r\n `>`\r\n ];\r\n }\r\n else if (isReactive(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Reactive'],\r\n '<',\r\n formatValue(obj),\r\n `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n ];\r\n }\r\n else if (isReadonly(obj)) {\r\n return [\r\n 'div',\r\n {},\r\n ['span', vueStyle, 'Readonly'],\r\n '<',\r\n formatValue(obj),\r\n '>'\r\n ];\r\n }\r\n return null;\r\n },\r\n hasBody(obj) {\r\n return obj && obj.__isVue;\r\n },\r\n body(obj) {\r\n if (obj && obj.__isVue) {\r\n return [\r\n 'div',\r\n {},\r\n ...formatInstance(obj.$)\r\n ];\r\n }\r\n }\r\n };\r\n function formatInstance(instance) {\r\n const blocks = [];\r\n if (instance.type.props && instance.props) {\r\n blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n }\r\n if (instance.setupState !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('setup', instance.setupState));\r\n }\r\n if (instance.data !== EMPTY_OBJ) {\r\n blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n }\r\n const computed = extractKeys(instance, 'computed');\r\n if (computed) {\r\n blocks.push(createInstanceBlock('computed', computed));\r\n }\r\n const injected = extractKeys(instance, 'inject');\r\n if (injected) {\r\n blocks.push(createInstanceBlock('injected', injected));\r\n }\r\n blocks.push([\r\n 'div',\r\n {},\r\n [\r\n 'span',\r\n {\r\n style: keywordStyle.style + ';opacity:0.66'\r\n },\r\n '$ (internal): '\r\n ],\r\n ['object', { object: instance }]\r\n ]);\r\n return blocks;\r\n }\r\n function createInstanceBlock(type, target) {\r\n target = extend({}, target);\r\n if (!Object.keys(target).length) {\r\n return ['span', {}];\r\n }\r\n return [\r\n 'div',\r\n { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n [\r\n 'div',\r\n {\r\n style: 'color:#476582'\r\n },\r\n type\r\n ],\r\n [\r\n 'div',\r\n {\r\n style: 'padding-left:1.25em'\r\n },\r\n ...Object.keys(target).map(key => {\r\n return [\r\n 'div',\r\n {},\r\n ['span', keywordStyle, key + ': '],\r\n formatValue(target[key], false)\r\n ];\r\n })\r\n ]\r\n ];\r\n }\r\n function formatValue(v, asRaw = true) {\r\n if (typeof v === 'number') {\r\n return ['span', numberStyle, v];\r\n }\r\n else if (typeof v === 'string') {\r\n return ['span', stringStyle, JSON.stringify(v)];\r\n }\r\n else if (typeof v === 'boolean') {\r\n return ['span', keywordStyle, v];\r\n }\r\n else if (isObject(v)) {\r\n return ['object', { object: asRaw ? toRaw(v) : v }];\r\n }\r\n else {\r\n return ['span', stringStyle, String(v)];\r\n }\r\n }\r\n function extractKeys(instance, type) {\r\n const Comp = instance.type;\r\n if (isFunction(Comp)) {\r\n return;\r\n }\r\n const extracted = {};\r\n for (const key in instance.ctx) {\r\n if (isKeyOfType(Comp, key, type)) {\r\n extracted[key] = instance.ctx[key];\r\n }\r\n }\r\n return extracted;\r\n }\r\n function isKeyOfType(Comp, key, type) {\r\n const opts = Comp[type];\r\n if ((isArray(opts) && opts.includes(key)) ||\r\n (isObject(opts) && key in opts)) {\r\n return true;\r\n }\r\n if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n return true;\r\n }\r\n if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n return true;\r\n }\r\n }\r\n function genRefFlag(v) {\r\n if (v._shallow) {\r\n return `ShallowRef`;\r\n }\r\n if (v.effect) {\r\n return `ComputedRef`;\r\n }\r\n return `Ref`;\r\n }\r\n if (window.devtoolsFormatters) {\r\n window.devtoolsFormatters.push(formatter);\r\n }\r\n else {\r\n window.devtoolsFormatters = [formatter];\r\n }\r\n}\n\nconst svgNS = 'http://www.w3.org/2000/svg';\r\nconst doc = (typeof document !== 'undefined' ? document : null);\r\nlet tempContainer;\r\nlet tempSVGContainer;\r\nconst nodeOps = {\r\n insert: (child, parent, anchor) => {\r\n parent.insertBefore(child, anchor || null);\r\n },\r\n remove: child => {\r\n const parent = child.parentNode;\r\n if (parent) {\r\n parent.removeChild(child);\r\n }\r\n },\r\n createElement: (tag, isSVG, is) => isSVG\r\n ? doc.createElementNS(svgNS, tag)\r\n : doc.createElement(tag, is ? { is } : undefined),\r\n createText: text => doc.createTextNode(text),\r\n createComment: text => doc.createComment(text),\r\n setText: (node, text) => {\r\n node.nodeValue = text;\r\n },\r\n setElementText: (el, text) => {\r\n el.textContent = text;\r\n },\r\n parentNode: node => node.parentNode,\r\n nextSibling: node => node.nextSibling,\r\n querySelector: selector => doc.querySelector(selector),\r\n setScopeId(el, id) {\r\n el.setAttribute(id, '');\r\n },\r\n cloneNode(el) {\r\n return el.cloneNode(true);\r\n },\r\n // __UNSAFE__\r\n // Reason: innerHTML.\r\n // Static content here can only come from compiled templates.\r\n // As long as the user only uses trusted templates, this is safe.\r\n insertStaticContent(content, parent, anchor, isSVG) {\r\n const temp = isSVG\r\n ? tempSVGContainer ||\r\n (tempSVGContainer = doc.createElementNS(svgNS, 'svg'))\r\n : tempContainer || (tempContainer = doc.createElement('div'));\r\n temp.innerHTML = content;\r\n const first = temp.firstChild;\r\n let node = first;\r\n let last = node;\r\n while (node) {\r\n last = node;\r\n nodeOps.insert(node, parent, anchor);\r\n node = temp.firstChild;\r\n }\r\n return [first, last];\r\n }\r\n};\n\n// compiler should normalize class + :class bindings on the same element\r\n// into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n if (value == null) {\r\n value = '';\r\n }\r\n if (isSVG) {\r\n el.setAttribute('class', value);\r\n }\r\n else {\r\n // directly setting className should be faster than setAttribute in theory\r\n // if this is an element during a transition, take the temporary transition\r\n // classes into account.\r\n const transitionClasses = el._vtc;\r\n if (transitionClasses) {\r\n value = (value\r\n ? [value, ...transitionClasses]\r\n : [...transitionClasses]).join(' ');\r\n }\r\n el.className = value;\r\n }\r\n}\n\nfunction patchStyle(el, prev, next) {\r\n const style = el.style;\r\n if (!next) {\r\n el.removeAttribute('style');\r\n }\r\n else if (isString(next)) {\r\n if (prev !== next) {\r\n style.cssText = next;\r\n }\r\n }\r\n else {\r\n for (const key in next) {\r\n setStyle(style, key, next[key]);\r\n }\r\n if (prev && !isString(prev)) {\r\n for (const key in prev) {\r\n if (next[key] == null) {\r\n setStyle(style, key, '');\r\n }\r\n }\r\n }\r\n }\r\n}\r\nconst importantRE = /\\s*!important$/;\r\nfunction setStyle(style, name, val) {\r\n if (isArray(val)) {\r\n val.forEach(v => setStyle(style, name, v));\r\n }\r\n else {\r\n if (name.startsWith('--')) {\r\n // custom property definition\r\n style.setProperty(name, val);\r\n }\r\n else {\r\n const prefixed = autoPrefix(style, name);\r\n if (importantRE.test(val)) {\r\n // !important\r\n style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');\r\n }\r\n else {\r\n style[prefixed] = val;\r\n }\r\n }\r\n }\r\n}\r\nconst prefixes = ['Webkit', 'Moz', 'ms'];\r\nconst prefixCache = {};\r\nfunction autoPrefix(style, rawName) {\r\n const cached = prefixCache[rawName];\r\n if (cached) {\r\n return cached;\r\n }\r\n let name = camelize(rawName);\r\n if (name !== 'filter' && name in style) {\r\n return (prefixCache[rawName] = name);\r\n }\r\n name = capitalize(name);\r\n for (let i = 0; i < prefixes.length; i++) {\r\n const prefixed = prefixes[i] + name;\r\n if (prefixed in style) {\r\n return (prefixCache[rawName] = prefixed);\r\n }\r\n }\r\n return rawName;\r\n}\n\nconst xlinkNS = 'http://www.w3.org/1999/xlink';\r\nfunction patchAttr(el, key, value, isSVG) {\r\n if (isSVG && key.startsWith('xlink:')) {\r\n if (value == null) {\r\n el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\r\n }\r\n else {\r\n el.setAttributeNS(xlinkNS, key, value);\r\n }\r\n }\r\n else {\r\n // note we are only checking boolean attributes that don't have a\r\n // corresponding dom prop of the same name here.\r\n const isBoolean = isSpecialBooleanAttr(key);\r\n if (value == null || (isBoolean && value === false)) {\r\n el.removeAttribute(key);\r\n }\r\n else {\r\n el.setAttribute(key, isBoolean ? '' : value);\r\n }\r\n }\r\n}\n\n// __UNSAFE__\r\n// functions. The user is responsible for using them with only trusted content.\r\nfunction patchDOMProp(el, key, value, \r\n// the following args are passed only due to potential innerHTML/textContent\r\n// overriding existing VNodes, in which case the old tree must be properly\r\n// unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n if (key === 'innerHTML' || key === 'textContent') {\r\n if (prevChildren) {\r\n unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n }\r\n el[key] = value == null ? '' : value;\r\n return;\r\n }\r\n if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n // store value as _value as well since\r\n // non-string values will be stringified.\r\n el._value = value;\r\n const newValue = value == null ? '' : value;\r\n if (el.value !== newValue) {\r\n el.value = newValue;\r\n }\r\n return;\r\n }\r\n if (value === '' || value == null) {\r\n const type = typeof el[key];\r\n if (value === '' && type === 'boolean') {\r\n // e.g. with\r\n // :true-value & :false-value\r\n // store value as dom properties since non-string values will be\r\n // stringified.\r\n if (key === 'true-value') {\r\n el._trueValue = nextValue;\r\n }\r\n else if (key === 'false-value') {\r\n el._falseValue = nextValue;\r\n }\r\n patchAttr(el, key, nextValue, isSVG);\r\n }\r\n break;\r\n }\r\n};\r\nfunction shouldSetAsProp(el, key, value, isSVG) {\r\n if (isSVG) {\r\n // most keys must be set as attribute on svg elements to work\r\n // ...except innerHTML\r\n if (key === 'innerHTML') {\r\n return true;\r\n }\r\n // or native onclick with function values\r\n if (key in el && nativeOnRE.test(key) && isFunction(value)) {\r\n return true;\r\n }\r\n return false;\r\n }\r\n // spellcheck and draggable are numerated attrs, however their\r\n // corresponding DOM properties are actually booleans - this leads to\r\n // setting it with a string \"false\" value leading it to be coerced to\r\n // `true`, so we need to always treat them as attributes.\r\n // Note that `contentEditable` doesn't have this problem: its DOM\r\n // property is also enumerated string values.\r\n if (key === 'spellcheck' || key === 'draggable') {\r\n return false;\r\n }\r\n // #1787 form as an attribute must be a string, while it accepts an Element as\r\n // a prop\r\n if (key === 'form' && typeof value === 'string') {\r\n return false;\r\n }\r\n // #1526 must be set as attribute\r\n if (key === 'list' && el.tagName === 'INPUT') {\r\n return false;\r\n }\r\n // native onclick with string value, must be set as attribute\r\n if (nativeOnRE.test(key) && isString(value)) {\r\n return false;\r\n }\r\n return key in el;\r\n}\n\nconst rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps);\n\nfunction initDev() {\r\n const target = getGlobalThis();\r\n target.__VUE__ = true;\r\n setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n {\r\n initCustomFormatter();\r\n }\r\n}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nfunction processOptions(value) {\n var options;\n\n if (typeof value === 'function') {\n // Simple options (callback-only)\n options = {\n callback: value\n };\n } else {\n // Options object\n options = value;\n }\n\n return options;\n}\nfunction throttle(callback, delay) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var timeout;\n var lastState;\n var currentArgs;\n\n var throttled = function throttled(state) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n currentArgs = args;\n if (timeout && state === lastState) return;\n var leading = options.leading;\n\n if (typeof leading === 'function') {\n leading = leading(state, lastState);\n }\n\n if ((!timeout || state !== lastState) && leading) {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n }\n\n lastState = state;\n clearTimeout(timeout);\n timeout = setTimeout(function () {\n callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));\n timeout = 0;\n }, delay);\n };\n\n throttled._clear = function () {\n clearTimeout(timeout);\n timeout = null;\n };\n\n return throttled;\n}\nfunction deepEqual(val1, val2) {\n if (val1 === val2) return true;\n\n if (_typeof(val1) === 'object') {\n for (var key in val1) {\n if (!deepEqual(val1[key], val2[key])) {\n return false;\n }\n }\n\n return true;\n }\n\n return false;\n}\n\nvar VisibilityState =\n/*#__PURE__*/\nfunction () {\n function VisibilityState(el, options, vnode) {\n _classCallCheck(this, VisibilityState);\n\n this.el = el;\n this.observer = null;\n this.frozen = false;\n this.createObserver(options, vnode);\n }\n\n _createClass(VisibilityState, [{\n key: \"createObserver\",\n value: function createObserver(options, vnode) {\n var _this = this;\n\n if (this.observer) {\n this.destroyObserver();\n }\n\n if (this.frozen) return;\n this.options = processOptions(options);\n\n this.callback = function (result, entry) {\n _this.options.callback(result, entry);\n\n if (result && _this.options.once) {\n _this.frozen = true;\n\n _this.destroyObserver();\n }\n }; // Throttle\n\n\n if (this.callback && this.options.throttle) {\n var _ref = this.options.throttleOptions || {},\n _leading = _ref.leading;\n\n this.callback = throttle(this.callback, this.options.throttle, {\n leading: function leading(state) {\n return _leading === 'both' || _leading === 'visible' && state || _leading === 'hidden' && !state;\n }\n });\n }\n\n this.oldResult = undefined;\n this.observer = new IntersectionObserver(function (entries) {\n var entry = entries[0];\n\n if (entries.length > 1) {\n var intersectingEntry = entries.find(function (e) {\n return e.isIntersecting;\n });\n\n if (intersectingEntry) {\n entry = intersectingEntry;\n }\n }\n\n if (_this.callback) {\n // Use isIntersecting if possible because browsers can report isIntersecting as true, but intersectionRatio as 0, when something very slowly enters the viewport.\n var result = entry.isIntersecting && entry.intersectionRatio >= _this.threshold;\n if (result === _this.oldResult) return;\n _this.oldResult = result;\n\n _this.callback(result, entry);\n }\n }, this.options.intersection); // Wait for the element to be in document\n\n nextTick(function () {\n if (_this.observer) {\n _this.observer.observe(_this.el);\n }\n });\n }\n }, {\n key: \"destroyObserver\",\n value: function destroyObserver() {\n if (this.observer) {\n this.observer.disconnect();\n this.observer = null;\n } // Cancel throttled call\n\n\n if (this.callback && this.callback._clear) {\n this.callback._clear();\n\n this.callback = null;\n }\n }\n }, {\n key: \"threshold\",\n get: function get() {\n return this.options.intersection && this.options.intersection.threshold || 0;\n }\n }]);\n\n return VisibilityState;\n}();\n\nfunction bind(el, _ref2, vnode) {\n var value = _ref2.value;\n if (!value) return;\n\n if (typeof IntersectionObserver === 'undefined') {\n console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');\n } else {\n var state = new VisibilityState(el, value, vnode);\n el._vue_visibilityState = state;\n }\n}\n\nfunction update(el, _ref3, vnode) {\n var value = _ref3.value,\n oldValue = _ref3.oldValue;\n if (deepEqual(value, oldValue)) return;\n var state = el._vue_visibilityState;\n\n if (!value) {\n unbind(el);\n return;\n }\n\n if (state) {\n state.createObserver(value, vnode);\n } else {\n bind(el, {\n value: value\n }, vnode);\n }\n}\n\nfunction unbind(el) {\n var state = el._vue_visibilityState;\n\n if (state) {\n state.destroyObserver();\n delete el._vue_visibilityState;\n }\n}\n\nvar ObserveVisibility = {\n beforeMount: bind,\n updated: update,\n unmounted: unbind\n};\n\nfunction install(Vue) {\n Vue.directive('observe-visibility', ObserveVisibility);\n /* -- Add more components here -- */\n}\n/* -- Plugin definition & Auto-install -- */\n\n/* You shouldn't have to modify the code below */\n// Plugin\n\nvar plugin = {\n // eslint-disable-next-line no-undef\n version: \"0.9.0-ropez.1\",\n install: install\n};\n\nvar GlobalVue = null;\n\nif (typeof window !== 'undefined') {\n GlobalVue = window.Vue;\n} else if (typeof global !== 'undefined') {\n GlobalVue = global.Vue;\n}\n\nif (GlobalVue) {\n GlobalVue.use(plugin);\n}\n\nexport default plugin;\nexport { ObserveVisibility, install };\n","(function (root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define([], factory);\n } else if (typeof module === \"object\" && module.exports) {\n module.exports = factory();\n } else {\n root.Scrollparent = factory();\n }\n}(this, function () {\n var regex = /(auto|scroll)/;\n\n var parents = function (node, ps) {\n if (node.parentNode === null) { return ps; }\n\n return parents(node.parentNode, ps.concat([node]));\n };\n\n var style = function (node, prop) {\n return getComputedStyle(node, null).getPropertyValue(prop);\n };\n\n var overflow = function (node) {\n return style(node, \"overflow\") + style(node, \"overflow-y\") + style(node, \"overflow-x\");\n };\n\n var scroll = function (node) {\n return regex.test(overflow(node));\n };\n\n var scrollParent = function (node) {\n if (!(node instanceof HTMLElement || node instanceof SVGElement)) {\n return ;\n }\n\n var ps = parents(node.parentNode, []);\n\n for (var i = 0; i < ps.length; i += 1) {\n if (scroll(ps[i])) {\n return ps[i];\n }\n }\n\n return document.scrollingElement || document.documentElement;\n };\n\n return scrollParent;\n}));\n","export const props = {\r\n items: {\r\n type: Array,\r\n required: true,\r\n },\r\n\r\n keyField: {\r\n type: String,\r\n default: 'id',\r\n },\r\n\r\n direction: {\r\n type: String,\r\n default: 'vertical',\r\n validator: (value) => ['vertical', 'horizontal'].includes(value),\r\n },\r\n}\r\n\r\nexport function simpleArray () {\r\n return this.items.length && typeof this.items[0] !== 'object'\r\n}\r\n","export let supportsPassive = false\r\n\r\nif (typeof window !== 'undefined') {\r\n supportsPassive = false\r\n try {\r\n var opts = Object.defineProperty({}, 'passive', {\r\n get () {\r\n supportsPassive = true\r\n },\r\n })\r\n window.addEventListener('test', null, opts)\r\n } catch (e) {}\r\n}\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n\r\n\r\n","\r\n","import { reactive } from 'vue'\r\n\r\nexport default function ({\r\n idProp = vm => vm.item.id,\r\n} = {}) {\r\n const store = reactive({})\r\n\r\n // @vue/component\r\n return {\r\n data () {\r\n return {\r\n idState: null,\r\n }\r\n },\r\n\r\n created () {\r\n this.$_id = null\r\n if (typeof idProp === 'function') {\r\n this.$_getId = () => idProp.call(this, this)\r\n } else {\r\n this.$_getId = () => this[idProp]\r\n }\r\n this.$watch(this.$_getId, {\r\n handler (value) {\r\n this.$nextTick(() => {\r\n this.$_id = value\r\n })\r\n },\r\n immediate: true,\r\n })\r\n this.$_updateIdState()\r\n },\r\n\r\n beforeUpdate () {\r\n this.$_updateIdState()\r\n },\r\n\r\n methods: {\r\n /**\r\n * Initialize an idState\r\n * @param {number|string} id Unique id for the data\r\n */\r\n $_idStateInit (id) {\r\n const factory = this.$options.idState\r\n if (typeof factory === 'function') {\r\n const data = factory.call(this, this)\r\n store[id] = data\r\n this.$_id = id\r\n return data\r\n } else {\r\n throw new Error('[mixin IdState] Missing `idState` function on component definition.')\r\n }\r\n },\r\n\r\n /**\r\n * Ensure idState is created and up-to-date\r\n */\r\n $_updateIdState () {\r\n const id = this.$_getId()\r\n if (id == null) {\r\n console.warn(`No id found for IdState with idProp: '${idProp}'.`)\r\n }\r\n if (id !== this.$_id) {\r\n if (!store[id]) {\r\n this.$_idStateInit(id)\r\n }\r\n this.idState = store[id]\r\n }\r\n },\r\n },\r\n }\r\n}\r\n","import config from './config'\r\n\r\nimport RecycleScroller from './components/RecycleScroller.vue'\r\nimport DynamicScroller from './components/DynamicScroller.vue'\r\nimport DynamicScrollerItem from './components/DynamicScrollerItem.vue'\r\n\r\nexport { default as IdState } from './mixins/IdState'\r\n\r\nexport {\r\n RecycleScroller,\r\n DynamicScroller,\r\n DynamicScrollerItem,\r\n}\r\n\r\nfunction registerComponents (Vue, prefix) {\r\n Vue.component(`${prefix}recycle-scroller`, RecycleScroller)\r\n Vue.component(`${prefix}RecycleScroller`, RecycleScroller)\r\n Vue.component(`${prefix}dynamic-scroller`, DynamicScroller)\r\n Vue.component(`${prefix}DynamicScroller`, DynamicScroller)\r\n Vue.component(`${prefix}dynamic-scroller-item`, DynamicScrollerItem)\r\n Vue.component(`${prefix}DynamicScrollerItem`, DynamicScrollerItem)\r\n}\r\n\r\nconst plugin = {\r\n // eslint-disable-next-line no-undef\r\n version: VERSION,\r\n install (Vue, options) {\r\n const finalOptions = Object.assign({}, {\r\n installComponents: true,\r\n componentsPrefix: '',\r\n }, options)\r\n\r\n for (const key in finalOptions) {\r\n if (typeof finalOptions[key] !== 'undefined') {\r\n config[key] = finalOptions[key]\r\n }\r\n }\r\n\r\n if (finalOptions.installComponents) {\r\n registerComponents(Vue, finalOptions.componentsPrefix)\r\n }\r\n },\r\n}\r\n\r\nexport default plugin\r\n\r\n// Auto-install\r\nlet GlobalVue = null\r\nif (typeof window !== 'undefined') {\r\n GlobalVue = window.Vue\r\n} else if (typeof global !== 'undefined') {\r\n GlobalVue = global.Vue\r\n}\r\nif (GlobalVue) {\r\n GlobalVue.use(plugin)\r\n}\r\n"],"names":["itemsLimit","ownKeys","_typeof","makeMap","GLOBALS_WHITE_LISTED","isGloballyWhitelisted","normalizeStyle","isArray","isString","parseStringStyle","isObject","listDelimiterRE","propertyDelimiterRE","normalizeClass","EMPTY_OBJ","EMPTY_ARR","NOOP","onRE","isOn","extend","remove","hasOwnProperty","hasOwn","isMap","toTypeString","isSet","isFunction","isSymbol","isPromise","objectToString","toRawType","isIntegerKey","cacheStringFunction","capitalize","hasChanged","_globalThis","getGlobalThis","targetMap","effectStack","activeEffect","ITERATE_KEY","MAP_KEY_ITERATE_KEY","isEffect","effect","createReactiveEffect","stop","cleanup","uid","enableTracking","resetTracking","shouldTrack","trackStack","pauseTracking","track","trigger","builtInSymbols","get","createGetter","shallowGet","readonlyGet","shallowReadonlyGet","arrayInstrumentations","toRaw","readonlyMap","reactiveMap","isRef","readonly","reactive","set","createSetter","shallowSet","deleteProperty","has","mutableHandlers","readonlyHandlers","shallowReactiveHandlers","shallowReadonlyHandlers","toReactive","toReadonly","toShallow","getProto","get$1","has$1","size","add","set$1","checkIdentityKeys","deleteEntry","clear","createForEach","createIterableMethod","createReadonlyMethod","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","iteratorMethods","createInstrumentationGetter","mutableCollectionHandlers","readonlyCollectionHandlers","targetTypeMap","getTargetType","createReactiveObject","shallowReadonly","isReactive","isReadonly","isProxy","stack","pushWarningContext","popWarningContext","warn","getComponentTrace","callWithErrorHandling","formatComponentName","formatTrace","formatTraceEntry","formatProps","formatProp","ErrorTypeStrings","handleError","callWithAsyncErrorHandling","logError","isFlushing","isFlushPending","queue","flushIndex","pendingPreFlushCbs","activePreFlushCbs","preFlushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","currentFlushPromise","currentPreFlushParentJob","RECURSION_LIMIT","nextTick","queueJob","queueFlush","flushJobs","queueCb","queuePreFlushCb","queuePostFlushCb","flushPreFlushCbs","checkRecursiveUpdates","flushPostFlushCbs","getId","hmrDirtyComponents","tryWrap","createRecord","rerender","reload","map","isClassComponent","setDevtoolsHook","currentRenderingInstance","markAttrsAccessed","filterSingleRoot","isVNode","Comment","isSuspense","normalizeSuspenseChildren","normalizeSuspenseSlot","normalizeVNode","queueEffectWithSuspense","isRenderingCompiledSlot","setCompiledSlotRendering","currentScopeId","INITIAL_WATCHER_VALUE","doWatch","currentInstance","traverse","queuePostRenderEffect","recordInstanceBoundEffect","instanceWatch","isTeleport","NULL_DYNAMIC_COMPONENT","Fragment","Text","Static","currentBlock","createVNodeWithArgsTransform","_createVNode","InternalObjectKey","normalizeKey","normalizeRef","createVNode","cloneVNode","normalizeChildren","mergeProps","createTextVNode","isInBeforeCreate","resolveMergedOptions","mergeOptions","getPublicInstance","publicPropertiesMap","PublicInstanceProxyHandlers","RuntimeCompiledPublicInstanceProxyHandlers","classifyRE","classify","ssrContextKey","initCustomFormatter","initDev","install","plugin","GlobalVue","this","props","items","type","Array","required","keyField","String","default","direction","validator","value","includes","simpleArray","length","supportsPassive","window","opts","Object","defineProperty","addEventListener","e","name","components","ResizeObserver","directives","ObserveVisibility","emits","itemSize","Number","minItemSize","sizeField","typeField","buffer","pageMode","Boolean","prerender","emitUpdate","data","pool","totalSize","ready","hoverKey","computed","sizes","accumulator","field","computedMinSize","current","i","l","$_computedMinItemSize","watch","updateVisibleItems","applyPageMode","handler","deep","created","$_startIndex","$_endIndex","$_views","Map","$_unusedViews","$_scrollDirty","$_lastUpdateScrollPosition","$_prerender","mounted","$nextTick","beforeUnmount","removeListeners","methods","addView","index","item","key","view","shallowReactive","position","nr","id","used","push","unuseView","fake","unusedViews","unusedPool","delete","handleResize","$emit","handleScroll","event","requestAnimationFrame","continuous","clearTimeout","$_refreshTimout","setTimeout","handleVisibilityChange","isVisible","entry","boundingClientRect","width","height","checkItem","checkPositionDiff","count","views","startIndex","endIndex","scroll","getScroll","positionDiff","start","end","h","a","b","oldI","Math","ceil","config","itemsLimitError","$_continuous","findIndex","unusedIndex","v","Error","pop","$_sortTimer","sortViews","getListenerTarget","target","ScrollParent","$el","document","documentElement","body","el","isVertical","scrollState","bounds","getBoundingClientRect","boundsSize","top","left","innerHeight","innerWidth","scrollTop","clientHeight","scrollLeft","clientWidth","addListeners","listenerTarget","passive","removeEventListener","scrollToItem","scrollToPosition","console","log","sort","viewA","viewB","class","_createBlock","$options","_ctx","before","_hoisted_1","_renderSlot","ref","style","$data","onMouseenter","onMouseleave","active","after","_hoisted_2","onNotify","RecycleScroller","inheritAttrs","provide","$_resizeObserver","entries","CustomEvent","detail","contentRect","dispatchEvent","vscrollData","vscrollParent","vscrollResizeObserver","validSizes","itemsWithSize","result","$_undefinedMap","listeners","$listeners","forceUpdate","immediate","$_updates","$_undefinedSizes","activated","deactivated","onScrollerResize","scroller","$refs","onScrollerVisible","force","getItemSize","undefined","indexOf","scrollToBottom","$_scrollingToBottom","scrollHeight","cb","_mergeProps","$props","onResize","onVisible","_toHandlers","itemWithSize","inject","watchData","sizeDependencies","emitResize","tag","finalActive","onDataUpdate","observeSize","unobserveSize","$_pendingVScrollUpdate","updateSize","$isServer","$_forceNextVScrollUpdate","updateWatchData","k","$watch","$on","onVscrollUpdate","onVscrollUpdateSize","$off","$_pendingSizeUpdate","computeSize","$_watchData","offsetWidth","offsetHeight","applySize","round","$set","observe","parentNode","unobserve","render","$slots","idProp","vm","store","idState","$_id","$_getId","call","$_updateIdState","beforeUpdate","$_idStateInit","factory","registerComponents","Vue","prefix","component","DynamicScroller","DynamicScrollerItem","version","VERSION","options","finalOptions","assign","installComponents","componentsPrefix","global","use"],"mappings":"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"} \ No newline at end of file