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..0c6704ba 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 @@ -189,6 +189,7 @@ var script = { directives: { ObserveVisibility: ObserveVisibility }, + emits: ['update', 'resize', 'visible', 'hidden'], props: _objectSpread2({}, props, { itemSize: { type: Number, @@ -311,25 +312,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 +703,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() { @@ -959,6 +805,7 @@ var script$1 = { vscrollResizeObserver: this.$_resizeObserver }; }, + emits: ['resize', 'visible', 'vscroll:update'], props: _objectSpread2({}, props, { minItemSize: { type: [Number, String], @@ -1105,96 +952,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 __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 - ); +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 (_ref) { + var itemWithSize = _ref.item, + index = _ref.index, + active = _ref.active; + return [renderSlot(_ctx.$slots, "default", { + item: itemWithSize.item, + index: index, + active: active, + itemWithSize: itemWithSize + })]; + }), + before: withCtx(function () { + return [renderSlot(_ctx.$slots, "before")]; + }), + after: withCtx(function () { + return [renderSlot(_ctx.$slots, "after")]; + }), + _: 1 + /* STABLE */ + + }, 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 +1006,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 +1102,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(); @@ -1402,39 +1199,7 @@ var script$2 = { } }; -/* 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 +1208,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 +1247,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 +1264,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,17 +1287,17 @@ 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 = { // 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, @@ -1571,5 +1329,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..eb88453b 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","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 ba5df9d2..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";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={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 9060c89b..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","../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":"2HAAe,CACbA,WAAY,q3DCyBd,IAAIC,OAAO,EAEX,SAASC,IACHA,EAAWC,OACfD,EAAWC,MAAO,EAClBF,GAAyC,IA/B3C,WACC,IAAIG,EAAKC,OAAOC,UAAUC,UAEtBC,EAAOJ,EAAGK,QAAQ,SACtB,GAAID,EAAO,EAEV,OAAOE,SAASN,EAAGO,UAAUH,EAAO,EAAGJ,EAAGK,QAAQ,IAAKD,IAAQ,IAIhE,GADcJ,EAAGK,QAAQ,YACX,EAAG,CAEhB,IAAIG,EAAKR,EAAGK,QAAQ,OACpB,OAAOC,SAASN,EAAGO,UAAUC,EAAK,EAAGR,EAAGK,QAAQ,IAAKG,IAAM,IAG5D,IAAIC,EAAOT,EAAGK,QAAQ,SACtB,OAAII,EAAO,EAEHH,SAASN,EAAGO,UAAUE,EAAO,EAAGT,EAAGK,QAAQ,IAAKI,IAAQ,KAIxD,EAQAC,IAIT,IAAIC,EAAiB,CAAEC,OAAQ,WAC7B,IAAmBC,EAATC,KAAkBC,eAA2C,OAA7DD,KAA8CE,MAAMC,IAAMJ,GAAa,MAAO,CAAEK,YAAa,kBAAmBC,MAAO,CAAEC,SAAY,SAC7IC,gBAAiB,GAAIC,SAAU,kBAClCC,KAAM,kBAENC,QAAS,CACRC,iBAAkB,WACbX,KAAKY,KAAOZ,KAAKa,IAAIC,aAAed,KAAKD,KAAOC,KAAKa,IAAIE,eAC5Df,KAAKY,GAAKZ,KAAKa,IAAIC,YACnBd,KAAKD,GAAKC,KAAKa,IAAIE,aACnBf,KAAKgB,MAAM,YAGbC,kBAAmB,WAClBjB,KAAKkB,cAAcC,gBAAgBC,YAAYC,iBAAiB,SAAUrB,KAAKW,kBAC/EX,KAAKW,oBAENW,qBAAsB,WACjBtB,KAAKkB,eAAiBlB,KAAKkB,cAAcK,UACvCxC,GAAQiB,KAAKkB,cAAcC,iBAC/BnB,KAAKkB,cAAcC,gBAAgBC,YAAYI,oBAAoB,SAAUxB,KAAKW,yBAE5EX,KAAKkB,cAAcK,UAK7BE,QAAS,WACR,IAAIC,EAAQ1B,KAEZhB,IACAgB,KAAK2B,WAAU,WACdD,EAAMd,GAAKc,EAAMb,IAAIC,YACrBY,EAAM3B,GAAK2B,EAAMb,IAAIE,gBAEtB,IAAIa,EAASC,SAASC,cAAc,UACpC9B,KAAKkB,cAAgBU,EACrBA,EAAOG,aAAa,cAAe,QACnCH,EAAOG,aAAa,YAAa,GACjCH,EAAOL,OAASvB,KAAKiB,kBACrBW,EAAOI,KAAO,YACVjD,GACHiB,KAAKa,IAAIoB,YAAYL,GAEtBA,EAAOM,KAAO,cACTnD,GACJiB,KAAKa,IAAIoB,YAAYL,IAGvBO,cAAe,WACdnC,KAAKsB,yBAWP,IAAIc,EAAS,CAEZC,QAAS,QACTC,QATD,SAAiBC,GAChBA,EAAIC,UAAU,kBAAmB3C,GACjC0C,EAAIC,UAAU,iBAAkB3C,KAW7B4C,EAAY,KCvGhB,SAASC,EAAQC,GAWf,OATED,EADoB,mBAAXE,QAAoD,iBAApBA,OAAOC,SACtC,SAAUF,GAClB,cAAcA,GAGN,SAAUA,GAClB,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAOG,UAAY,gBAAkBJ,IAI9GA,GASjB,SAASK,EAAkBC,EAAQC,GACjC,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAME,OAAQD,IAAK,CACrC,IAAIE,EAAaH,EAAMC,GACvBE,EAAWC,WAAaD,EAAWC,aAAc,EACjDD,EAAWE,cAAe,EACtB,UAAWF,IAAYA,EAAWG,UAAW,GACjDC,OAAOC,eAAeT,EAAQI,EAAWM,IAAKN,IAUlD,SAASO,EAAmBC,GAC1B,OAGF,SAA4BA,GAC1B,GAAIC,MAAMC,QAAQF,GAAM,CACtB,IAAK,IAAIV,EAAI,EAAGa,EAAO,IAAIF,MAAMD,EAAIT,QAASD,EAAIU,EAAIT,OAAQD,IAAKa,EAAKb,GAAKU,EAAIV,GAEjF,OAAOa,GAPFC,CAAmBJ,IAW5B,SAA0BK,GACxB,GAAItB,OAAOC,YAAYY,OAAOS,IAAkD,uBAAzCT,OAAOV,UAAUoB,SAASC,KAAKF,GAAgC,OAAOJ,MAAMO,KAAKH,GAZtFI,CAAiBT,IAerD,WACE,MAAM,IAAIU,UAAU,mDAhBuCC,GDmEvC,oBAAXrF,OACVsD,EAAYtD,OAAOoD,IACS,oBAAXkC,SACjBhC,EAAYgC,OAAOlC,KAEhBE,GACHA,EAAUiC,IAAItC,GCef,IAAIuC,EAEJ,WACE,SAASA,EAAgBC,EAAIC,EAASC,IAlHxC,SAAyBC,EAAUC,GACjC,KAAMD,aAAoBC,GACxB,MAAM,IAAIT,UAAU,qCAiHpBU,CAAgBjF,KAAM2E,GAEtB3E,KAAK4E,GAAKA,EACV5E,KAAKkF,SAAW,KAChBlF,KAAKmF,QAAS,EACdnF,KAAKoF,eAAeP,EAASC,GAxGjC,IAAsBE,EAAaK,EAAYC,EAiM7C,OAjMoBN,EA2GPL,GA3GoBU,EA2GH,CAAC,CAC7B1B,IAAK,iBACL4B,MAAO,SAAwBV,EAASC,GACtC,IAAIpD,EAAQ1B,KAMZ,GAJIA,KAAKkF,UACPlF,KAAKwF,mBAGHxF,KAAKmF,OAAT,CA1FN,IAAwBI,EAwGlB,GAbAvF,KAAK6E,QAxFY,mBAHCU,EA2FYV,GAtFtB,CACRY,SAAUF,GAIFA,EAmFRvF,KAAKyF,SAAW,SAAUC,EAAQC,GAChCjE,EAAMmD,QAAQY,SAASC,EAAQC,GAE3BD,GAAUhE,EAAMmD,QAAQe,OAC1BlE,EAAMyD,QAAS,EAEfzD,EAAM8D,oBAKNxF,KAAKyF,UAAYzF,KAAK6E,QAAQgB,SAAU,CAC1C,IACIC,GADO9F,KAAK6E,QAAQkB,iBAAmB,IACvBC,QAEpBhG,KAAKyF,SA7Fb,SAAkBA,EAAUQ,GAC1B,IACIC,EACAC,EACAC,EAHAvB,EAAUwB,UAAUjD,OAAS,QAAsBkD,IAAjBD,UAAU,GAAmBA,UAAU,GAAK,GAK9EE,EAAY,SAAmBC,GACjC,IAAK,IAAIC,EAAOJ,UAAUjD,OAAQsD,EAAO,IAAI5C,MAAM2C,EAAO,EAAIA,EAAO,EAAI,GAAIE,EAAO,EAAGA,EAAOF,EAAME,IAClGD,EAAKC,EAAO,GAAKN,UAAUM,GAI7B,GADAP,EAAcM,GACVR,GAAWM,IAAUL,EAAzB,CACA,IAAIH,EAAUnB,EAAQmB,QAEC,mBAAZA,IACTA,EAAUA,EAAQQ,EAAOL,IAGrBD,GAAWM,IAAUL,IAAcH,GACvCP,EAASmB,WAAM,EAAQ,CAACJ,GAAOK,OAAOjD,EAAmBwC,KAG3DD,EAAYK,EACZM,aAAaZ,GACbA,EAAUa,YAAW,WACnBtB,EAASmB,WAAM,EAAQ,CAACJ,GAAOK,OAAOjD,EAAmBwC,KACzDF,EAAU,IACTD,KAQL,OALAM,EAAUS,OAAS,WACjBF,aAAaZ,GACbA,EAAU,MAGLK,EAyDeV,CAAS7F,KAAKyF,SAAUzF,KAAK6E,QAAQgB,SAAU,CAC7DG,QAAS,SAAiBQ,GACxB,MAAoB,SAAbV,GAAoC,YAAbA,GAA0BU,GAAsB,WAAbV,IAA0BU,KAKjGxG,KAAKiH,eAAYX,EACjBtG,KAAKkF,SAAW,IAAIgC,sBAAqB,SAAUC,GACjD,IAAIxB,EAAQwB,EAAQ,GAEpB,GAAIA,EAAQ/D,OAAS,EAAG,CACtB,IAAIgE,EAAoBD,EAAQE,MAAK,SAAUC,GAC7C,OAAOA,EAAEC,kBAGPH,IACFzB,EAAQyB,GAIZ,GAAI1F,EAAM+D,SAAU,CAElB,IAAIC,EAASC,EAAM4B,gBAAkB5B,EAAM6B,mBAAqB9F,EAAM+F,UACtE,GAAI/B,IAAWhE,EAAMuF,UAAW,OAChCvF,EAAMuF,UAAYvB,EAElBhE,EAAM+D,SAASC,EAAQC,MAExB3F,KAAK6E,QAAQ6C,cAEhB5C,EAAM6C,QAAQhG,WAAU,WAClBD,EAAMwD,UACRxD,EAAMwD,SAAS0C,QAAQlG,EAAMkD,UAIlC,CACDjB,IAAK,kBACL4B,MAAO,WACDvF,KAAKkF,WACPlF,KAAKkF,SAAS2C,aACd7H,KAAKkF,SAAW,MAIdlF,KAAKyF,UAAYzF,KAAKyF,SAASuB,SACjChH,KAAKyF,SAASuB,SAEdhH,KAAKyF,SAAW,QAGnB,CACD9B,IAAK,YACLmE,IAAK,WACH,OAAO9H,KAAK6E,QAAQ6C,cAAgB1H,KAAK6E,QAAQ6C,aAAaD,WAAa,OA5L/DzE,EAAkBgC,EAAYjC,UAAWsC,GACrDC,GAAatC,EAAkBgC,EAAaM,GA+LzCX,EAhGT,GAmGA,SAASoD,EAAKnD,EAAIoD,EAAOlD,GACvB,IAAIS,EAAQyC,EAAMzC,MAClB,GAAKA,EAEL,GAAoC,oBAAzB2B,qBACTe,QAAQC,KAAK,0LACR,CACL,IAAI1B,EAAQ,IAAI7B,EAAgBC,EAAIW,EAAOT,GAC3CF,EAAGuD,qBAAuB3B,GAwB9B,SAAS4B,EAAOxD,GACd,IAAI4B,EAAQ5B,EAAGuD,qBAEX3B,IACFA,EAAMhB,yBACCZ,EAAGuD,sBAId,IAAIE,EAAoB,CACtBN,KAAMA,EACNO,OA/BF,SAAgB1D,EAAI2D,EAAOzD,GACzB,IAAIS,EAAQgD,EAAMhD,MAElB,IApIF,SAASiD,EAAUC,EAAMC,GACvB,GAAID,IAASC,EAAM,OAAO,EAE1B,GAAsB,WAAlBhG,EAAQ+F,GAAoB,CAC9B,IAAK,IAAI9E,KAAO8E,EACd,IAAKD,EAAUC,EAAK9E,GAAM+E,EAAK/E,IAC7B,OAAO,EAIX,OAAO,EAGT,OAAO,EAuHH6E,CAAUjD,EADCgD,EAAMI,UACrB,CACA,IAAInC,EAAQ5B,EAAGuD,qBAEV5C,EAKDiB,EACFA,EAAMpB,eAAeG,EAAOT,GAE5BiD,EAAKnD,EAAI,CACPW,MAAOA,GACNT,GATHsD,EAAOxD,KAyBTwD,OAAQA,GAYV,IAAIhG,EAAS,CAEXC,QAAS,QACTC,QAZF,SAAiBC,GACfA,EAAIqG,UAAU,qBAAsBP,KAclC5F,EAAY,KAEM,oBAAXtD,OACTsD,EAAYtD,OAAOoD,IACQ,oBAAXkC,SAChBhC,EAAYgC,OAAOlC,KAGjBE,GACFA,EAAUiC,IAAItC,uOCzSf,IAAUyG,EAAMC,EAAND,EAQT7I,EARe8I,EAQT,WACN,IAAIC,EAAQ,gBAERC,EAAU,SAAUC,EAAMC,GAC5B,OAAwB,OAApBD,EAAKE,WAA8BD,EAEhCF,EAAQC,EAAKE,WAAYD,EAAGrC,OAAO,CAACoC,MAGzCG,EAAQ,SAAUH,EAAMI,GAC1B,OAAOC,iBAAiBL,EAAM,MAAMM,iBAAiBF,IAOnDG,EAAS,SAAUP,GACtB,OAAOF,EAAMU,KALC,SAAUR,GACvB,OAAOG,EAAMH,EAAM,YAAcG,EAAMH,EAAM,cAAgBG,EAAMH,EAAM,cAIxDS,CAAST,KAmB5B,OAhBmB,SAAUA,GAC3B,GAAMA,aAAgBU,aAAeV,aAAgBW,WAArD,CAMA,IAFA,IAAIV,EAAKF,EAAQC,EAAKE,WAAY,IAEzBhG,EAAI,EAAGA,EAAI+F,EAAG9F,OAAQD,GAAK,EAClC,GAAIqG,EAAON,EAAG/F,IACZ,OAAO+F,EAAG/F,GAId,OAAOtB,SAASgI,kBAAoBhI,SAASiI,mBAvCNC,EAAOC,QAC9CD,UAAiBjB,IAEjBD,EAAKoB,aAAenB,OCNX5F,EAAQ,CACnBgH,MAAO,CACLlI,KAAM8B,MACNqG,UAAU,GAGZC,SAAU,CACRpI,KAAMqI,OACNC,QAAS,MAGXC,UAAW,CACTvI,KAAMqI,OACNC,QAAS,WACTE,UAAW,SAACjF,SAAU,CAAC,WAAY,cAAckF,SAASlF,MAIvD,SAASmF,WACP1K,KAAKkK,MAAM9G,QAAmC,WAAzBV,EAAO1C,KAAKkK,MAAM,ICnBzC,IAAIS,GAAkB,EAE7B,GAAsB,oBAAXxL,OAAwB,CACjCwL,GAAkB,UAEZC,EAAOnH,OAAOC,eAAe,GAAI,UAAW,CAC9CoE,eACE6C,GAAkB,KAGtBxL,OAAOkC,iBAAiB,OAAQ,KAAMuJ,GACtC,MAAOtD,KCoDX,QC/DA,SAASuD,EAAmBC,EAAU1B,EAAO2B,EAAQC,EAASC,EAAsBC,EAAoCC,EAAYC,EAAgBC,EAAmBC,GACzI,kBAAfH,IACPE,EAAoBD,EACpBA,EAAiBD,EACjBA,GAAa,GAGjB,MAAMtG,EAA4B,mBAAXkG,EAAwBA,EAAOlG,QAAUkG,EAehE,IAAIQ,EAmCJ,GAhDIT,GAAYA,EAAShL,SACrB+E,EAAQ/E,OAASgL,EAAShL,OAC1B+E,EAAQtE,gBAAkBuK,EAASvK,gBACnCsE,EAAQ2G,WAAY,EAEhBP,IACApG,EAAQ4G,YAAa,IAIzBT,IACAnG,EAAQrE,SAAWwK,GAGnBE,GAEAK,EAAO,SAAU5D,IAEbA,EACIA,GACK3H,KAAK0L,QAAU1L,KAAK0L,OAAOC,YAC3B3L,KAAK4L,QAAU5L,KAAK4L,OAAOF,QAAU1L,KAAK4L,OAAOF,OAAOC,aAElB,oBAAxBE,sBACnBlE,EAAUkE,qBAGVzC,GACAA,EAAMhF,KAAKpE,KAAMqL,EAAkB1D,IAGnCA,GAAWA,EAAQmE,uBACnBnE,EAAQmE,sBAAsBC,IAAIb,IAK1CrG,EAAQmH,aAAeT,GAElBnC,IACLmC,EAAOJ,EACD,SAAUxD,GACRyB,EAAMhF,KAAKpE,KAAMsL,EAAqB3D,EAAS3H,KAAKiM,MAAMC,SAASC,cAErE,SAAUxE,GACRyB,EAAMhF,KAAKpE,KAAMoL,EAAezD,MAGxC4D,EACA,GAAI1G,EAAQ4G,WAAY,CAEpB,MAAMW,EAAiBvH,EAAQ/E,OAC/B+E,EAAQ/E,OAAS,SAAkCuM,EAAG1E,GAElD,OADA4D,EAAKnH,KAAKuD,GACHyE,EAAeC,EAAG1E,QAG5B,CAED,MAAM2E,EAAWzH,EAAQ0H,aACzB1H,EAAQ0H,aAAeD,EAAW,GAAGzF,OAAOyF,EAAUf,GAAQ,CAACA,GAGvE,OAAOR,EDtEX,+5OEAA,imGCAA,2/GCqBA,IAAM3I,EAAS,CAEbC,QAASmK,SACTlK,iBAASC,EAAKsC,OACN4H,EAAehJ,OAAOiJ,OAAO,GAAI,CACrCC,mBAAmB,EACnBC,iBAAkB,IACjB/H,OAEE,IAAMlB,KAAO8I,OACiB,IAAtBA,EAAa9I,KACtBkJ,EAAOlJ,GAAO8I,EAAa9I,IAI3B8I,EAAaE,mBAxBrB,SAA6BpK,EAAKuK,GAChCvK,EAAIC,oBAAasK,sBAA0BC,GAC3CxK,EAAIC,oBAAasK,qBAAyBC,GAC1CxK,EAAIC,oBAAasK,sBAA0BE,GAC3CzK,EAAIC,oBAAasK,qBAAyBE,GAC1CzK,EAAIC,oBAAasK,2BAA+BG,GAChD1K,EAAIC,oBAAasK,yBAA6BG,GAmB1CC,CAAmB3K,EAAKkK,EAAaG,oBAQvCnK,EAAY,WACM,oBAAXtD,OACTsD,EAAYtD,OAAOoD,IACQ,oBAAXkC,SAChBhC,EAAYgC,OAAOlC,KAEjBE,GACFA,EAAUiC,IAAItC,yDCpDD,wEAEX,OADF+K,OAAAA,aAAS,SAAAC,UAAMA,EAAGC,KAAKC,MAEjBC,EAAQ,GACRH,EAAK,IAAI7K,EAAI,CACjBL,sBACS,CACLqL,MAAAA,YAMC,CACLrL,sBACS,CACLsL,QAAS,OAIbC,mCACOC,KAAO,UAELC,QADe,mBAAXR,EACM,kBAAMA,EAAO/I,KAAK1C,EAAMA,IAExB,kBAAMA,EAAKyL,SAEvBS,OAAO5N,KAAK2N,QAAS,CACxBE,iBAAStI,mBACF5D,WAAU,WACbmM,EAAKJ,KAAOnI,MAGhBwI,WAAW,SAERC,mBAGPC,6BACOD,mBAGPtN,QAAS,CAKPwN,uBAAeZ,OACPxE,EAAU9I,KAAKkM,SAASsB,WACP,mBAAZ1E,EAAwB,KAC3B5G,EAAO4G,EAAQ1E,KAAKpE,KAAMA,aAChCoN,EAAGe,KAAKZ,EAAOD,EAAIpL,QACdwL,KAAOJ,EACLpL,QAED,IAAIkM,MAAM,wEAOpBJ,+BACQV,EAAKtN,KAAK2N,UACN,MAANL,GACFrF,QAAQC,qDAA8CiF,SAEpDG,IAAOtN,KAAK0N,OACTH,EAAMD,SACJY,cAAcZ,QAEhBE,QAAUD,EAAMD"} \ 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 1853f791..732b5dbc 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 @@ -146,175 +144,5442 @@ } }; } - - 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; + + /** + * 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) { + 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 + */ + 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 + : {})); + }; + + 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 + }); + + 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) { + } + + /** + * 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); + + /** + * Wrap a slot function to memoize current rendering instance + * @private + */ + 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 = []; + /** + * @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]; + } + } + } + + /** + * #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 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.9.0-ropez.1", + 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); + } + + function _typeof$1(obj) { + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof$1 = function (obj) { + return typeof obj; + }; + } else { + _typeof$1 = function (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(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); + } + + function _arrayWithoutHoles(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(iter) { + if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); + } + + function _nonIterableSpread() { + 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) { + 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$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); + + /** + * 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 + : {})); + }; + + 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 + }); + + 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) { + } + + /** + * 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 isIE = void 0; + /** + * #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; + } - function initCompat() { - if (!initCompat.init) { - initCompat.init = true; - isIE = getInternetExplorerVersion() !== -1; - } - } - - var ResizeObserver$1 = { render: function render() { - var _vm = this;var _h = _vm.$createElement;var _c = _vm._self._c || _h;return _c('div', { staticClass: "resize-observer", attrs: { "tabindex": "-1" } }); - }, staticRenderFns: [], _scopeId: 'data-v-b329ee4c', - name: 'resize-observer', - - 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'); - } - }, - 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); - } - delete this._resizeObject.onload; - } - } - }, - - mounted: function mounted() { - var _this = this; - - initCompat(); - this.$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); - } - }, - beforeDestroy: function beforeDestroy() { - this.removeResizeHandlers(); - } - }; + const ssrContextKey$1 = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``); - // Install the components - function install(Vue) { - Vue.component('resize-observer', ResizeObserver$1); - Vue.component('ResizeObserver', ResizeObserver$1); + 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]; + } } - // Plugin - var plugin = { - // eslint-disable-next-line no-undef - version: "0.4.5", - install: install + 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]; + } }; - // Auto-install - var GlobalVue = null; - if (typeof window !== 'undefined') { - GlobalVue = window.Vue; - } else if (typeof global !== 'undefined') { - GlobalVue = global.Vue; - } - if (GlobalVue) { - GlobalVue.use(plugin); + // 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 _typeof$1(obj) { - if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { - _typeof$1 = function (obj) { - return typeof obj; - }; - } else { - _typeof$1 = function (obj) { - return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; - }; - } - - return _typeof$1(obj); + 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; } - function _classCallCheck(instance, Constructor) { - if (!(instance instanceof Constructor)) { - throw new TypeError("Cannot call a class as a function"); - } + 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); + } + } } - 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); - } + // __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; } - function _arrayWithoutHoles(arr) { - if (Array.isArray(arr)) { - for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; - - return arr2; - } - } + const rendererOptions = extend$1({ patchProp, forcePatchProp }, nodeOps); - function _iterableToArray(iter) { - if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); + function initDev$1() { + const target = getGlobalThis$1(); + target.__VUE__ = true; + setDevtoolsHook$1(target.__VUE_DEVTOOLS_GLOBAL_HOOK__); + { + initCustomFormatter$1(); + } } - function _nonIterableSpread() { - throw new TypeError("Invalid attempt to spread non-iterable instance"); - } + // This entry exports the runtime only, and is built as + (process.env.NODE_ENV !== 'production') && initDev$1(); function processOptions(value) { var options; @@ -455,7 +5720,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 +5793,9 @@ } var ObserveVisibility = { - bind: bind, - update: update, - unbind: unbind + beforeMount: bind, + updated: update, + unmounted: unbind }; function install$1(Vue) { @@ -544,7 +5809,7 @@ var plugin$1 = { // eslint-disable-next-line no-undef - version: "0.4.6", + version: "0.9.0-ropez.1", install: install$1 }; @@ -650,15 +5915,16 @@ } 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 }, + emits: ['update', 'resize', 'visible', 'hidden'], props: _objectSpread2({}, props, { itemSize: { type: Number, @@ -781,25 +6047,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 +6438,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 _hoisted_1$1 = { + key: 0, + class: "vue-recycle-scroller__slot" + }; + var _hoisted_2 = { + key: 1, + class: "vue-recycle-scroller__slot" }; - 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 - ); + 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() { @@ -1429,6 +6540,7 @@ vscrollResizeObserver: this.$_resizeObserver }; }, + emits: ['resize', 'visible', 'vscroll:update'], props: _objectSpread2({}, props, { minItemSize: { type: [Number, String], @@ -1575,98 +6687,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 - ); + 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 (_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")]; + }), + _: 1 + /* STABLE */ + + }, 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 +6741,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 +6837,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(); @@ -1872,39 +6934,7 @@ } }; - /* 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 +6943,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 +6982,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 +6999,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,17 +7022,17 @@ } 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 = { // 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, @@ -2040,10 +7063,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..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","../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","../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 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/DynamicScroller.vue b/src/components/DynamicScroller.vue index e9f3acea..3d9460eb 100644 --- a/src/components/DynamicScroller.vue +++ b/src/components/DynamicScroller.vue @@ -10,7 +10,7 @@ @visible="onScrollerVisible" v-on="listeners" > -