diff --git a/packages/uni-app-plus/__tests__/service/dom/dom.spec.ts b/packages/uni-app-plus/__tests__/service/dom/dom.spec.ts index 1daaf537efc5bc2594288615a6ad3c1c004ab1d2..302269e4847c0e4d9a60d01d0622f5393f42c246 100644 --- a/packages/uni-app-plus/__tests__/service/dom/dom.spec.ts +++ b/packages/uni-app-plus/__tests__/service/dom/dom.spec.ts @@ -1,21 +1,22 @@ import { UniNodeJSON } from '@dcloudio/uni-shared' -import { - ACTION_TYPE_INSERT, - ACTION_TYPE_REMOVE, - ACTION_TYPE_REMOVE_ATTRIBUTE, - ACTION_TYPE_SET_ATTRIBUTE, - ACTION_TYPE_SET_TEXT, - createPageNode, - InsertAction, - SetAttributeAction, -} from '../../../src/service/framework/dom/Page' +import { createPageNode } from '../../../src/service/framework/dom/Page' import { createElement, createTextNode, } from '../../../../uni-app-vue/lib/service.runtime.esm' +import { + InsertAction, + ACTION_TYPE_INSERT, + SetAttributeAction, + ACTION_TYPE_SET_ATTRIBUTE, + ACTION_TYPE_REMOVE_ATTRIBUTE, + ACTION_TYPE_SET_TEXT, + ACTION_TYPE_REMOVE, +} from '../../../src/PageAction' describe('dom', () => { const pageId = 1 const root = createPageNode(pageId, { + route: 'pages/index/index', version: 1, locale: 'zh_CN', disableScroll: false, diff --git a/packages/uni-app-plus/__tests__/service/index.spec.ts b/packages/uni-app-plus/__tests__/service/index.spec.ts index 6c09c893124f1d9adc794e3c5f307a9bf914534a..f6580e69c83a908a8eb85b1cd16ff76a453f1615 100644 --- a/packages/uni-app-plus/__tests__/service/index.spec.ts +++ b/packages/uni-app-plus/__tests__/service/index.spec.ts @@ -11,6 +11,7 @@ import { import { createPageNode } from '../../src/service/framework/dom/Page' const defaultPageNodeOptions = { + route: 'pages/index/index', version: 1, locale: 'zh_CN', disableScroll: false, @@ -55,7 +56,6 @@ describe('vue', () => { } const pageNode = createPageNode(1, defaultPageNodeOptions, true) createApp(Page).mount(pageNode as unknown as Element) - pageNode.mounted() show.value = false handleClick = null nextTick(() => { diff --git a/packages/uni-app-plus/dist/uni-app-view.umd.js b/packages/uni-app-plus/dist/uni-app-view.umd.js index 142d6d6cdef53492473f1fc012ce992903c6c0cc..bf2527b42fca1cf0234f2415c1218aa57f0a7577 100644 --- a/packages/uni-app-plus/dist/uni-app-view.umd.js +++ b/packages/uni-app-plus/dist/uni-app-view.umd.js @@ -818,6 +818,84 @@ function formatLog(module, ...args) { return `[${Date.now()}][${module}]\uFF1A${args.map((arg) => JSON.stringify(arg)).join(" ")}`; } + const ATTR_MAP = { + class: ".c", + style: ".s", + onClick: ".e0", + onChange: ".e1", + onInput: ".e2", + onLoad: ".e3", + onError: ".e4", + onTouchstart: ".e5", + onTouchmove: ".e6", + onTouchcancel: ".e7", + onTouchend: ".e8", + onLongpress: ".e9", + onTransitionend: ".ea", + onAnimationstart: ".eb", + onAnimationiteration: ".ec", + onAnimationend: ".ed", + onTouchforcechange: ".ee" + }; + const COMPONENT_MAP = { + VIEW: 1, + IMAGE: 2, + TEXT: 3, + "#text": 4, + "#comment": 5, + NAVIGATOR: 6, + FORM: 7, + BUTTON: 8, + INPUT: 9, + LABEL: 10, + RADIO: 11, + CHECKBOX: 12, + "CHECKBOX-GROUP": 13, + AD: 14, + AUDIO: 15, + CAMERA: 16, + CANVAS: 17, + "COVER-IMAGE": 18, + "COVER-VIEW": 19, + EDITOR: 20, + "FUNCTIONAL-PAGE-NAVIGATOR": 21, + ICON: 22, + "RADIO-GROUP": 23, + "LIVE-PLAYER": 24, + "LIVE-PUSHER": 25, + MAP: 26, + "MOVABLE-AREA": 27, + "MOVABLE-VIEW": 28, + "OFFICIAL-ACCOUNT": 29, + "OPEN-DATA": 30, + PICKER: 31, + "PICKER-VIEW": 32, + "PICKER-VIEW-COLUMN": 33, + PROGRESS: 34, + "RICH-TEXT": 35, + "SCROLL-VIEW": 36, + SLIDER: 37, + SWIPER: 38, + "SWIPER-ITEM": 39, + SWITCH: 40, + TEXTAREA: 41, + VIDEO: 42, + "WEB-VIEW": 43 + }; + const DECODED_ATTR_MAP = /* @__PURE__ */ Object.keys(ATTR_MAP).reduce((map, name) => { + map[ATTR_MAP[name]] = name; + return map; + }, Object.create(null)); + function decodeAttr(name) { + return DECODED_ATTR_MAP[name] || name; + } + const DECODED_COMPONENT_ARR = /* @__PURE__ */ Object.keys(COMPONENT_MAP).reduce((arr, name) => { + arr.push(name.toLowerCase()); + return arr; + }, [""]); + function decodeTag(tag) { + return DECODED_COMPONENT_ARR[tag] || tag; + } const E = function() { }; E.prototype = { @@ -2593,6 +2671,49 @@ } const ACTION_TYPE_PAGE_CREATE = 1; const ACTION_TYPE_PAGE_CREATED = 2; + const ACTION_TYPE_CREATE = 3; + const ACTION_TYPE_INSERT = 4; + const ACTION_TYPE_REMOVE = 5; + const ACTION_TYPE_SET_ATTRIBUTE = 6; + const ACTION_TYPE_REMOVE_ATTRIBUTE = 7; + const ACTION_TYPE_SET_TEXT = 8; + const elements = new Map(); + function $(id) { + return elements.get(id); + } + function createElement(id, tag) { + const element = document.createElement(decodeTag(tag)); + elements.set(id, element); + return element; + } + function setElementAttr(element, name, value) { + element.setAttribute(decodeAttr(name), value); + } + function onNodeCreate(id, tag) { + return createElement(id, decodeTag(tag)); + } + function onNodeInsert(nodeId, parentNodeId, refNodeId, nodeJson) { + const element = $(nodeId); + $(parentNodeId).insertBefore(initElement(element, nodeJson), $(refNodeId)); + } + function initElement(element, { a, s }) { + initAttribute(element, a); + return element; + } + function initAttribute(element, attr) { + if (!attr) { + return; + } + Object.keys(attr).forEach((name) => setElementAttr(element, name, attr[name])); + } + function onNodeRemove(nodeId, parentNodeId) { + } + function onNodeRemoveAttr(nodeId, name) { + } + function onNodeSetAttr(nodeId, name, value) { + } + function onNodeSetText(nodeId, text) { + } function onPageCreate({ route, disableScroll, @@ -2648,6 +2769,18 @@ return onPageCreate(action[1]); case ACTION_TYPE_PAGE_CREATED: return onPageCreated(); + case ACTION_TYPE_CREATE: + return onNodeCreate(action[1], action[2]); + case ACTION_TYPE_INSERT: + return onNodeInsert(action[1], action[2], action[3], action[4]); + case ACTION_TYPE_REMOVE: + return onNodeRemove(action[1], action[2]); + case ACTION_TYPE_SET_ATTRIBUTE: + return onNodeSetAttr(action[1], action[2], action[3]); + case ACTION_TYPE_REMOVE_ATTRIBUTE: + return onNodeRemoveAttr(action[1], action[2]); + case ACTION_TYPE_SET_TEXT: + return onNodeSetText(action[1], action[2]); } }); } diff --git a/packages/uni-app-plus/src/PageAction.ts b/packages/uni-app-plus/src/PageAction.ts index 068f9e10fc13d47687e632469e6ad057b0533b3b..c803b8db01fef8b7375d3d768094e67c2b79c5a3 100644 --- a/packages/uni-app-plus/src/PageAction.ts +++ b/packages/uni-app-plus/src/PageAction.ts @@ -1,3 +1,10 @@ +import { onNodeCreate } from './view/framework/subscriber/vdom/onNodeCreate' +import { onNodeInsert } from './view/framework/subscriber/vdom/onNodeInsert' +import { onNodeRemove } from './view/framework/subscriber/vdom/onNodeRemove' +import { onNodeRemoveAttr } from './view/framework/subscriber/vdom/onNodeRemoveAttr' +import { onNodeSetAttr } from './view/framework/subscriber/vdom/onNodeSetAttr' +import { onNodeSetText } from './view/framework/subscriber/vdom/onNodeSetText' + export const ACTION_TYPE_PAGE_CREATE = 1 export const ACTION_TYPE_PAGE_CREATED = 2 export const ACTION_TYPE_CREATE = 3 @@ -27,40 +34,32 @@ export type PageCreatedAction = [typeof ACTION_TYPE_PAGE_CREATED] export type CreateAction = [ typeof ACTION_TYPE_CREATE, - number, // nodeId - string | number //nodeName + ...Parameters ] export type InsertAction = [ typeof ACTION_TYPE_INSERT, - number, // nodeId - number, // parentNodeId - number, // index - Record // Element JSON + ...Parameters ] export type RemoveAction = [ typeof ACTION_TYPE_REMOVE, - number, // nodeId - number // parentNodeId + ...Parameters ] export type SetAttributeAction = [ typeof ACTION_TYPE_SET_ATTRIBUTE, - number, // nodeId - string, // attribute name - unknown // attribute value + ...Parameters ] + export type RemoveAttributeAction = [ typeof ACTION_TYPE_REMOVE_ATTRIBUTE, - number, // nodeId - string // attribute name + ...Parameters ] export type SetTextAction = [ typeof ACTION_TYPE_SET_TEXT, - number, // nodeId - string // text content + ...Parameters ] export type PageUpdateAction = diff --git a/packages/uni-app-plus/src/service/framework/page/define.ts b/packages/uni-app-plus/src/service/framework/page/define.ts index e061d72ff31e2a4dad5d2c92b14b5e67a092905f..40b99418b8149c8baf8ca69caa4f0a13cd3a6b35 100644 --- a/packages/uni-app-plus/src/service/framework/page/define.ts +++ b/packages/uni-app-plus/src/service/framework/page/define.ts @@ -1,11 +1,11 @@ import { once } from '@dcloudio/uni-shared' -import { createApp, defineComponent } from 'vue' +import { createApp, DefineComponent } from 'vue' import { createPageNode } from '../dom/Page' import { setupPage } from './setup' import __vuePlugin from '../plugin' import { PageNodeOptions } from '../../../PageAction' -export type VueComponent = ReturnType +export type VueComponent = DefineComponent const pagesMap = new Map>() diff --git a/packages/uni-app-plus/src/view/framework/subscriber/vdom/index.ts b/packages/uni-app-plus/src/view/framework/subscriber/vdom/index.ts index 08e7c1c80f05f5819584a0ae5c3ecfebdcebc667..284744290cf847bf24535bbec17d7c4a785456cf 100644 --- a/packages/uni-app-plus/src/view/framework/subscriber/vdom/index.ts +++ b/packages/uni-app-plus/src/view/framework/subscriber/vdom/index.ts @@ -1,8 +1,20 @@ import { + ACTION_TYPE_CREATE, + ACTION_TYPE_INSERT, ACTION_TYPE_PAGE_CREATE, ACTION_TYPE_PAGE_CREATED, + ACTION_TYPE_REMOVE, + ACTION_TYPE_REMOVE_ATTRIBUTE, + ACTION_TYPE_SET_ATTRIBUTE, + ACTION_TYPE_SET_TEXT, PageAction, } from '../../../../PageAction' +import { onNodeCreate } from './onNodeCreate' +import { onNodeInsert } from './onNodeInsert' +import { onNodeRemove } from './onNodeRemove' +import { onNodeRemoveAttr } from './onNodeRemoveAttr' +import { onNodeSetAttr } from './onNodeSetAttr' +import { onNodeSetText } from './onNodeSetText' import { onPageCreate } from './onPageCreate' import { onPageCreated } from './onPageCreated' @@ -13,6 +25,18 @@ export function onVdSync(actions: PageAction[]) { return onPageCreate(action[1]) case ACTION_TYPE_PAGE_CREATED: return onPageCreated() + case ACTION_TYPE_CREATE: + return onNodeCreate(action[1], action[2]) + case ACTION_TYPE_INSERT: + return onNodeInsert(action[1], action[2], action[3], action[4]) + case ACTION_TYPE_REMOVE: + return onNodeRemove(action[1], action[2]) + case ACTION_TYPE_SET_ATTRIBUTE: + return onNodeSetAttr(action[1], action[2], action[3]) + case ACTION_TYPE_REMOVE_ATTRIBUTE: + return onNodeRemoveAttr(action[1], action[2]) + case ACTION_TYPE_SET_TEXT: + return onNodeSetText(action[1], action[2]) } }) } diff --git a/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeCreate.ts b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeCreate.ts new file mode 100644 index 0000000000000000000000000000000000000000..51fd515bed04c85cf30731fc2d5df5a5b37953f5 --- /dev/null +++ b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeCreate.ts @@ -0,0 +1,6 @@ +import { decodeTag } from '@dcloudio/uni-shared' +import { createElement } from './utils' + +export function onNodeCreate(id: number, tag: string | number) { + return createElement(id, decodeTag(tag)) +} diff --git a/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeInsert.ts b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeInsert.ts new file mode 100644 index 0000000000000000000000000000000000000000..0d06c29dbaa4f4a0ed45a6612e68f2f680700810 --- /dev/null +++ b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeInsert.ts @@ -0,0 +1,25 @@ +import { UniNodeJSON } from '@dcloudio/uni-shared' +import { $, setElementAttr } from './utils' + +export function onNodeInsert( + nodeId: number, + parentNodeId: number, + refNodeId: number, + nodeJson: Partial +) { + const element = $(nodeId) + $(parentNodeId).insertBefore(initElement(element, nodeJson), $(refNodeId)) +} + +function initElement(element: Element, { a, s }: Partial) { + initAttribute(element, a) + // TODO style + return element +} + +function initAttribute(element: Element, attr?: Record) { + if (!attr) { + return + } + Object.keys(attr).forEach((name) => setElementAttr(element, name, attr[name])) +} diff --git a/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeRemove.ts b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeRemove.ts new file mode 100644 index 0000000000000000000000000000000000000000..12bcb7ec66d894d3ea41371def54551ef44e7da9 --- /dev/null +++ b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeRemove.ts @@ -0,0 +1 @@ +export function onNodeRemove(nodeId: number, parentNodeId: number) {} diff --git a/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeRemoveAttr.ts b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeRemoveAttr.ts new file mode 100644 index 0000000000000000000000000000000000000000..beb3e03333be18e1e37f6e6729f19681abe43810 --- /dev/null +++ b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeRemoveAttr.ts @@ -0,0 +1 @@ +export function onNodeRemoveAttr(nodeId: number, name: string) {} diff --git a/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeSetAttr.ts b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeSetAttr.ts new file mode 100644 index 0000000000000000000000000000000000000000..a77aa84836973f0946ea759d3a34d6b6b43143ad --- /dev/null +++ b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeSetAttr.ts @@ -0,0 +1 @@ +export function onNodeSetAttr(nodeId: number, name: string, value: unknown) {} diff --git a/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeSetText.ts b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeSetText.ts new file mode 100644 index 0000000000000000000000000000000000000000..8b21acbdc7b6f01338100a519b6f4d03f47aafc3 --- /dev/null +++ b/packages/uni-app-plus/src/view/framework/subscriber/vdom/onNodeSetText.ts @@ -0,0 +1 @@ +export function onNodeSetText(nodeId: number, text: string) {} diff --git a/packages/uni-app-plus/src/view/framework/subscriber/vdom/utils.ts b/packages/uni-app-plus/src/view/framework/subscriber/vdom/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..907b551ac5303d4d71579c93680157acfffcd8a4 --- /dev/null +++ b/packages/uni-app-plus/src/view/framework/subscriber/vdom/utils.ts @@ -0,0 +1,18 @@ +import { decodeAttr, decodeTag } from '@dcloudio/uni-shared' + +const elements = new Map() + +export function $(id: number) { + return elements.get(id)! +} + +export function createElement(id: number, tag: string) { + const element = document.createElement(decodeTag(tag)) + elements.set(id, element) + return element +} + +export function setElementAttr(element: Element, name: string, value: unknown) { + // TODO + element.setAttribute(decodeAttr(name), value as string) +} diff --git a/packages/uni-app-vue/dist/service.runtime.esm.js b/packages/uni-app-vue/dist/service.runtime.esm.js index bbab6c2e34c92684cf69d6079014b3789c1fe5b1..6c882cdf00108dd8dc1ec1aaa9b6fa57065f2c57 100644 --- a/packages/uni-app-vue/dist/service.runtime.esm.js +++ b/packages/uni-app-vue/dist/service.runtime.esm.js @@ -1,9746 +1,12384 @@ -import { UniElement, UniTextNode, UniCommentNode } from '@dcloudio/uni-shared'; - -/** - * 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]; -} +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } + +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } + +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); } + +function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +export default function vueFactory(exports) { + /** + * 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. + */ + process.env.NODE_ENV !== 'production' ? Object.freeze({}) : {}; + process.env.NODE_ENV !== 'production' ? Object.freeze([]) : []; + var extend$1 = Object.assign; + + var cacheStringFunction$1 = function cacheStringFunction$1(fn) { + var cache = Object.create(null); + return function (str) { + var hit = cache[str]; + return hit || (cache[str] = fn(str)); + }; + }; + + var camelizeRE$1 = /-(\w)/g; + /** + * @private + */ + + var camelize$1 = cacheStringFunction$1(function (str) { + return str.replace(camelizeRE$1, function (_, c) { + return c ? c.toUpperCase() : ''; + }); + }); + /** + * @private + */ + + var capitalize$1 = cacheStringFunction$1(function (str) { + return str.charAt(0).toUpperCase() + str.slice(1); + }); + + var DOMException = /*#__PURE__*/function (_Error) { + _inherits(DOMException, _Error); + + var _super = _createSuper(DOMException); + + function DOMException(message) { + var _this; + + _classCallCheck(this, DOMException); + + _this = _super.call(this, message); + _this.name = 'DOMException'; + return _this; + } + + return DOMException; + }( /*#__PURE__*/_wrapNativeSuper(Error)); + + function normalizeEventType(type) { + return "on".concat(capitalize$1(camelize$1(type))); + } + + var UniEventTarget = /*#__PURE__*/function () { + function UniEventTarget() { + _classCallCheck(this, UniEventTarget); + + this._listeners = {}; + } + + _createClass(UniEventTarget, [{ + key: "dispatchEvent", + value: function dispatchEvent(evt) { + var listeners = this._listeners[evt.type]; + + if (!listeners) { + return false; + } + + var len = listeners.length; + + for (var i = 0; i < len; i++) { + listeners[i].call(this, evt); + + if (evt._end) { + break; + } + } + + return evt.cancelable && evt.defaultPrevented; + } + }, { + key: "addEventListener", + value: function addEventListener(type, listener, options) { + var isOnce = options && options.once; + + if (isOnce) { + var wrapper = function wrapper(evt) { + listener.apply(this, [evt]); + this.removeEventListener(type, wrapper, options); + }; + + return this.addEventListener(type, wrapper, extend$1(options, { + once: false + })); + } + + (this._listeners[type] || (this._listeners[type] = [])).push(listener); + } + }, { + key: "removeEventListener", + value: function removeEventListener(type, callback, options) { + var listeners = this._listeners[type.toLowerCase()]; + + if (!listeners) { + return; + } + + var index = listeners.indexOf(callback); + + if (index > -1) { + listeners.splice(index, 1); + } + } + }]); + + return UniEventTarget; + }(); + + var UniCSSStyleDeclaration = /*#__PURE__*/function () { + function UniCSSStyleDeclaration() { + _classCallCheck(this, UniCSSStyleDeclaration); + + this._cssText = null; + this._value = null; + } + + _createClass(UniCSSStyleDeclaration, [{ + key: "setProperty", + value: function setProperty(property, value) { + if (value === null || value === '') { + this.removeProperty(property); + } else { + if (!this._value) { + this._value = {}; + } + + this._value[property] = value; + } + } + }, { + key: "getPropertyValue", + value: function getPropertyValue(property) { + if (!this._value) { + return ''; + } + + return this._value[property] || ''; + } + }, { + key: "removeProperty", + value: function removeProperty(property) { + if (!this._value) { + return ''; + } + + var value = this._value[property]; + delete this._value[property]; + return value; + } + }, { + key: "cssText", + get: function get() { + return this._cssText || ''; + }, + set: function set(cssText) { + this._cssText = cssText; + } + }, { + key: "toJSON", + value: function toJSON() { + var _cssText = this._cssText, + _value = this._value; + var hasCssText = _cssText !== null; + var hasValue = _value !== null; + + if (hasCssText && hasValue) { + return [_cssText, _value]; + } + + if (hasCssText) { + return _cssText; + } + + if (hasValue) { + return _value; + } + } + }]); + + return UniCSSStyleDeclaration; + }(); + + var STYLE_PROPS = ['_value', '_cssText', 'cssText', 'getPropertyValue', 'setProperty', 'removeProperty', 'toJSON']; + + function proxyStyle(uniCssStyle) { + return new Proxy(uniCssStyle, { + get(target, key, receiver) { + if (STYLE_PROPS.indexOf(key) === -1) { + return target.getPropertyValue(key); + } + + return Reflect.get(target, key, receiver); + }, + + set(target, key, value, receiver) { + if (STYLE_PROPS.indexOf(key) === -1) { + target.setProperty(key, value); + return true; + } + + return Reflect.set(target, key, value, receiver); + } + + }); + } + + var ATTR_MAP = { + class: '.c', + style: '.s', + onClick: '.e0', + onChange: '.e1', + onInput: '.e2', + onLoad: '.e3', + onError: '.e4', + onTouchstart: '.e5', + onTouchmove: '.e6', + onTouchcancel: '.e7', + onTouchend: '.e8', + onLongpress: '.e9', + onTransitionend: '.ea', + onAnimationstart: '.eb', + onAnimationiteration: '.ec', + onAnimationend: '.ed', + onTouchforcechange: '.ee' + }; + + function encodeAttr(name) { + return ATTR_MAP[name] || name; + } + + var COMPONENT_MAP = { + VIEW: 1, + IMAGE: 2, + TEXT: 3, + '#text': 4, + '#comment': 5, + NAVIGATOR: 6, + FORM: 7, + BUTTON: 8, + INPUT: 9, + LABEL: 10, + RADIO: 11, + CHECKBOX: 12, + 'CHECKBOX-GROUP': 13, + AD: 14, + AUDIO: 15, + CAMERA: 16, + CANVAS: 17, + 'COVER-IMAGE': 18, + 'COVER-VIEW': 19, + EDITOR: 20, + 'FUNCTIONAL-PAGE-NAVIGATOR': 21, + ICON: 22, + 'RADIO-GROUP': 23, + 'LIVE-PLAYER': 24, + 'LIVE-PUSHER': 25, + MAP: 26, + 'MOVABLE-AREA': 27, + 'MOVABLE-VIEW': 28, + 'OFFICIAL-ACCOUNT': 29, + 'OPEN-DATA': 30, + PICKER: 31, + 'PICKER-VIEW': 32, + 'PICKER-VIEW-COLUMN': 33, + PROGRESS: 34, + 'RICH-TEXT': 35, + 'SCROLL-VIEW': 36, + SLIDER: 37, + SWIPER: 38, + 'SWIPER-ITEM': 39, + SWITCH: 40, + TEXTAREA: 41, + VIDEO: 42, + 'WEB-VIEW': 43 + }; + + function encodeTag(tag) { + return COMPONENT_MAP[tag] || tag; + } + + var NODE_TYPE_ELEMENT = 1; + var NODE_TYPE_TEXT = 3; + var NODE_TYPE_COMMENT = 8; + + function sibling(node, type) { + var parentNode = node.parentNode; + + if (!parentNode) { + return null; + } + + var childNodes = parentNode.childNodes; + return childNodes[childNodes.indexOf(node) + (type === 'n' ? 1 : -1)] || null; + } + + function removeNode(node) { + var parentNode = node.parentNode; + + if (parentNode) { + parentNode.removeChild(node); + } + } + + function checkNodeId(node) { + if (!node.nodeId && node.pageNode) { + node.nodeId = node.pageNode.genId(); + } + } // 为优化性能，各平台不使用proxy来实现node的操作拦截，而是直接通过pageNode定制 + + + var UniNode = /*#__PURE__*/function (_UniEventTarget) { + _inherits(UniNode, _UniEventTarget); + + var _super2 = _createSuper(UniNode); + + function UniNode(nodeType, nodeName, container) { + var _this2; + + _classCallCheck(this, UniNode); + + _this2 = _super2.call(this); + _this2.pageNode = null; + _this2.parentNode = null; + _this2._text = null; + + if (container) { + var pageNode = container.pageNode; + + if (pageNode) { + _this2.pageNode = pageNode; + _this2.nodeId = pageNode.genId(); + pageNode.onCreate(_assertThisInitialized(_this2), encodeTag(nodeName)); + } + } + + _this2.nodeType = nodeType; + _this2.nodeName = nodeName; + _this2.childNodes = []; + return _this2; + } + + _createClass(UniNode, [{ + key: "firstChild", + get: function get() { + return this.childNodes[0] || null; + } + }, { + key: "lastChild", + get: function get() { + var childNodes = this.childNodes; + var length = childNodes.length; + return length ? childNodes[length - 1] : null; + } + }, { + key: "nextSibling", + get: function get() { + return sibling(this, 'n'); + } + }, { + key: "nodeValue", + get: function get() { + return null; + }, + set: function set(_val) {} + }, { + key: "textContent", + get: function get() { + return this._text || ''; + }, + set: function set(text) { + this._text = text; + + if (this.pageNode) { + this.pageNode.onTextContent(this, text); + } + } + }, { + key: "parentElement", + get: function get() { + var parentNode = this.parentNode; + + if (parentNode && parentNode.nodeType === NODE_TYPE_ELEMENT) { + return parentNode; + } + + return null; + } + }, { + key: "previousSibling", + get: function get() { + return sibling(this, 'p'); + } + }, { + key: "appendChild", + value: function appendChild(newChild) { + return this.insertBefore(newChild, null); + } + }, { + key: "cloneNode", + value: function cloneNode(deep) { + var cloned = extend$1(Object.create(Object.getPrototypeOf(this)), this); + var attributes = cloned.attributes; + + if (attributes) { + cloned.attributes = extend$1({}, attributes); + } + + if (deep) { + cloned.childNodes = cloned.childNodes.map(function (childNode) { + return childNode.cloneNode(true); + }); + } + + return cloned; + } + }, { + key: "insertBefore", + value: function insertBefore(newChild, refChild) { + removeNode(newChild); + newChild.pageNode = this.pageNode; + newChild.parentNode = this; + checkNodeId(newChild); + var childNodes = this.childNodes; + var index; + + if (refChild) { + index = childNodes.indexOf(refChild); + + if (index === -1) { + throw new DOMException("Failed to execute 'insertBefore' on 'Node': The node before which the new node is to be inserted is not a child of this node."); + } + + childNodes.splice(index, 0, newChild); + } else { + index = childNodes.length; + childNodes.push(newChild); + } + + return this.pageNode ? this.pageNode.onInsertBefore(this, newChild, index) : newChild; + } + }, { + key: "removeChild", + value: function removeChild(oldChild) { + var childNodes = this.childNodes; + var index = childNodes.indexOf(oldChild); + + if (index === -1) { + throw new DOMException("Failed to execute 'removeChild' on 'Node': The node to be removed is not a child of this node."); + } + + oldChild.parentNode = null; + childNodes.splice(index, 1); + return this.pageNode ? this.pageNode.onRemoveChild(this, oldChild) : oldChild; + } + }]); + + return UniNode; + }(UniEventTarget); + + var UniBaseNode = /*#__PURE__*/function (_UniNode) { + _inherits(UniBaseNode, _UniNode); + + var _super3 = _createSuper(UniBaseNode); + + function UniBaseNode(nodeType, nodeName, container) { + var _this3; + + _classCallCheck(this, UniBaseNode); + + _this3 = _super3.call(this, nodeType, nodeName, container); + _this3.attributes = Object.create(null); + _this3._html = null; + _this3.style = proxyStyle(new UniCSSStyleDeclaration()); + return _this3; + } + + _createClass(UniBaseNode, [{ + key: "className", + get: function get() { + return this.attributes['class'] || ''; + }, + set: function set(val) { + this.setAttribute('class', val); + } + }, { + key: "innerHTML", + get: function get() { + return ''; + }, + set: function set(html) { + this._html = html; + } + }, { + key: "addEventListener", + value: function addEventListener(type, listener, options) { + _get(_getPrototypeOf(UniBaseNode.prototype), "addEventListener", this).call(this, type, listener, options); + + var normalized = normalizeEventType(type); + + if (!this.attributes[normalized]) { + this.setAttribute(normalized, 1); + } + } + }, { + key: "removeEventListener", + value: function removeEventListener(type, callback, options) { + _get(_getPrototypeOf(UniBaseNode.prototype), "removeEventListener", this).call(this, type, callback, options); + + var normalized = normalizeEventType(type); + + if (this.attributes[encodeAttr(normalized)]) { + this.removeAttribute(normalized); + } + } + }, { + key: "getAttribute", + value: function getAttribute(qualifiedName) { + return this.attributes[encodeAttr(qualifiedName)]; + } + }, { + key: "removeAttribute", + value: function removeAttribute(qualifiedName) { + qualifiedName = encodeAttr(qualifiedName); + delete this.attributes[qualifiedName]; + + if (this.pageNode) { + this.pageNode.onRemoveAttribute(this, qualifiedName); + } + } + }, { + key: "setAttribute", + value: function setAttribute(qualifiedName, value) { + qualifiedName = encodeAttr(qualifiedName); + this.attributes[qualifiedName] = value; + + if (this.pageNode) { + this.pageNode.onSetAttribute(this, qualifiedName, value); + } + } + }, { + key: "toJSON", + value: function toJSON() { + var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var res = { + a: this.attributes, + s: this.style.toJSON() + }; + + if (!opts.attr) { + res.i = this.nodeId; + res.n = encodeTag(this.nodeName); + } + + if (this._text !== null) { + res.t = this._text; + } + + return res; + } + }]); + + return UniBaseNode; + }(UniNode); + + var UniCommentNode = /*#__PURE__*/function (_UniNode2) { + _inherits(UniCommentNode, _UniNode2); + + var _super4 = _createSuper(UniCommentNode); + + function UniCommentNode(text, container) { + var _this4; + + _classCallCheck(this, UniCommentNode); + + _this4 = _super4.call(this, NODE_TYPE_COMMENT, '#comment', container); + _this4._text = text; + return _this4; + } + + _createClass(UniCommentNode, [{ + key: "toJSON", + value: function toJSON() { + var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + return opts.attr ? { + t: this._text + } : { + i: this.nodeId, + t: this._text + }; + } + }]); + + return UniCommentNode; + }(UniNode); + + var UniElement = /*#__PURE__*/function (_UniBaseNode) { + _inherits(UniElement, _UniBaseNode); + + var _super5 = _createSuper(UniElement); + + function UniElement(nodeName, container) { + var _this5; + + _classCallCheck(this, UniElement); + + _this5 = _super5.call(this, NODE_TYPE_ELEMENT, nodeName.toUpperCase(), container); + _this5.tagName = _this5.nodeName; + return _this5; + } + + return UniElement; + }(UniBaseNode); + + var UniTextNode = /*#__PURE__*/function (_UniBaseNode2) { + _inherits(UniTextNode, _UniBaseNode2); + + var _super6 = _createSuper(UniTextNode); + + function UniTextNode(text, container) { + var _this6; + + _classCallCheck(this, UniTextNode); + + _this6 = _super6.call(this, NODE_TYPE_TEXT, '#text', container); + _this6._text = text; + return _this6; + } + + _createClass(UniTextNode, [{ + key: "nodeValue", + get: function get() { + return this._text || ''; + }, + set: function set(text) { + this._text = text; + + if (this.pageNode) { + this.pageNode.onNodeValue(this, text); + } + } + }]); + + return UniTextNode; + }(UniBaseNode); + /** + * Make a map and return a function for checking if a key + * is in that map. + * IMPORTANT: all calls of this function must be prefixed with + * \/\*#\_\_PURE\_\_\*\/ + * So that rollup can tree-shake them if necessary. + */ + + + function makeMap(str, expectsLowerCase) { + var map = Object.create(null); + var list = str.split(','); + + for (var i = 0; i < list.length; i++) { + map[list[i]] = true; + } + + return expectsLowerCase ? function (val) { + return !!map[val.toLowerCase()]; + } : function (val) { + return !!map[val]; + }; + } + + var GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt'; + var isGloballyWhitelisted = /*#__PURE__*/makeMap(GLOBALS_WHITE_LISTED); + + function normalizeStyle(value) { + if (isArray(value)) { + var res = {}; + + for (var i = 0; i < value.length; i++) { + var item = value[i]; + var normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item); + + if (normalized) { + for (var key in normalized) { + res[key] = normalized[key]; + } + } + } + + return res; + } else if (isObject(value)) { + return value; + } + } + + var listDelimiterRE = /;(?![^(]*\))/g; + var propertyDelimiterRE = /:(.+)/; + + function parseStringStyle(cssText) { + var ret = {}; + cssText.split(listDelimiterRE).forEach(function (item) { + if (item) { + var tmp = item.split(propertyDelimiterRE); + tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); + } + }); + return ret; + } + + function normalizeClass(value) { + var res = ''; + + if (isString(value)) { + res = value; + } else if (isArray(value)) { + for (var i = 0; i < value.length; i++) { + var normalized = normalizeClass(value[i]); + + if (normalized) { + res += normalized + ' '; + } + } + } else if (isObject(value)) { + for (var name in value) { + if (value[name]) { + res += name + ' '; + } + } + } + + return res.trim(); + } // These tag configs are shared between compiler-dom and runtime-dom, so they + // https://developer.mozilla.org/en-US/docs/Web/HTML/Element + + + var HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' + 'header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,' + 'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' + 'data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,' + 'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' + 'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' + 'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' + 'option,output,progress,select,textarea,details,dialog,menu,' + 'summary,template,blockquote,iframe,tfoot'; // https://developer.mozilla.org/en-US/docs/Web/SVG/Element + + var SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' + 'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' + 'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' + 'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' + 'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' + 'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' + 'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' + 'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' + 'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' + 'text,textPath,title,tspan,unknown,use,view'; + var isHTMLTag = /*#__PURE__*/makeMap(HTML_TAGS); + var isSVGTag = /*#__PURE__*/makeMap(SVG_TAGS); + /** + * For converting {{ interpolation }} values to displayed strings. + * @private + */ + + var toDisplayString = function toDisplayString(val) { + return val == null ? '' : isObject(val) ? JSON.stringify(val, replacer, 2) : String(val); + }; + + var replacer = function replacer(_key, val) { + if (isMap(val)) { + return { + ["Map(".concat(val.size, ")")]: _toConsumableArray(val.entries()).reduce(function (entries, _ref) { + var _ref2 = _slicedToArray(_ref, 2), + key = _ref2[0], + val = _ref2[1]; + + entries["".concat(key, " =>")] = val; + return entries; + }, {}) + }; + } else if (isSet(val)) { + return { + ["Set(".concat(val.size, ")")]: _toConsumableArray(val.values()) + }; + } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) { + return String(val); + } + + return val; + }; + + var EMPTY_OBJ = process.env.NODE_ENV !== 'production' ? Object.freeze({}) : {}; + var EMPTY_ARR = process.env.NODE_ENV !== 'production' ? Object.freeze([]) : []; + + var NOOP = function NOOP() {}; + /** + * Always return false. + */ + + + var NO = function NO() { + return false; + }; + + var onRE = /^on[^a-z]/; + + var isOn = function isOn(key) { + return onRE.test(key); + }; + + var isModelListener = function isModelListener(key) { + return key.startsWith('onUpdate:'); + }; + + var extend = Object.assign; + + var remove = function remove(arr, el) { + var i = arr.indexOf(el); + + if (i > -1) { + arr.splice(i, 1); + } + }; + + var hasOwnProperty = Object.prototype.hasOwnProperty; + + var hasOwn = function hasOwn(val, key) { + return hasOwnProperty.call(val, key); + }; + + var isArray = Array.isArray; + + var isMap = function isMap(val) { + return toTypeString(val) === '[object Map]'; + }; + + var isSet = function isSet(val) { + return toTypeString(val) === '[object Set]'; + }; + + var isFunction = function isFunction(val) { + return typeof val === 'function'; + }; + + var isString = function isString(val) { + return typeof val === 'string'; + }; + + var isSymbol = function isSymbol(val) { + return typeof val === 'symbol'; + }; + + var isObject = function isObject(val) { + return val !== null && typeof val === 'object'; + }; + + var isPromise = function isPromise(val) { + return isObject(val) && isFunction(val.then) && isFunction(val.catch); + }; + + var objectToString = Object.prototype.toString; + + var toTypeString = function toTypeString(value) { + return objectToString.call(value); + }; + + var toRawType = function toRawType(value) { + // extract "RawType" from strings like "[object RawType]" + return toTypeString(value).slice(8, -1); + }; + + var isPlainObject = function isPlainObject(val) { + return toTypeString(val) === '[object Object]'; + }; + + var isIntegerKey = function isIntegerKey(key) { + return isString(key) && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key; + }; + + var isReservedProp = /*#__PURE__*/makeMap( // the leading comma is intentional so empty string "" is also included + ',key,ref,' + 'onVnodeBeforeMount,onVnodeMounted,' + 'onVnodeBeforeUpdate,onVnodeUpdated,' + 'onVnodeBeforeUnmount,onVnodeUnmounted'); + + var cacheStringFunction = function cacheStringFunction(fn) { + var cache = Object.create(null); + return function (str) { + var hit = cache[str]; + return hit || (cache[str] = fn(str)); + }; + }; + + var camelizeRE = /-(\w)/g; + /** + * @private + */ + + var camelize = cacheStringFunction(function (str) { + return str.replace(camelizeRE, function (_, c) { + return c ? c.toUpperCase() : ''; + }); + }); + var hyphenateRE = /\B([A-Z])/g; + /** + * @private + */ + + var hyphenate = cacheStringFunction(function (str) { + return str.replace(hyphenateRE, '-$1').toLowerCase(); + }); + /** + * @private + */ + + var capitalize = cacheStringFunction(function (str) { + return str.charAt(0).toUpperCase() + str.slice(1); + }); + /** + * @private + */ + + var toHandlerKey = cacheStringFunction(function (str) { + return str ? "on".concat(capitalize(str)) : ""; + }); // compare whether a value has changed, accounting for NaN. + + var hasChanged = function hasChanged(value, oldValue) { + return value !== oldValue && (value === value || oldValue === oldValue); + }; + + var invokeArrayFns = function invokeArrayFns(fns, arg) { + for (var i = 0; i < fns.length; i++) { + fns[i](arg); + } + }; + + var def = function def(obj, key, value) { + Object.defineProperty(obj, key, { + configurable: true, + enumerable: false, + value + }); + }; + + var toNumber = function toNumber(val) { + var n = parseFloat(val); + return isNaN(n) ? val : n; + }; + + var _globalThis; + + var getGlobalThis = function getGlobalThis() { + return _globalThis || (_globalThis = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof window !== 'undefined' ? window : {}); + }; + + var targetMap = new WeakMap(); + var effectStack = []; + var activeEffect; + var ITERATE_KEY = Symbol(process.env.NODE_ENV !== 'production' ? 'iterate' : ''); + var MAP_KEY_ITERATE_KEY = Symbol(process.env.NODE_ENV !== 'production' ? 'Map key iterate' : ''); + + function isEffect(fn) { + return fn && fn._isEffect === true; + } + + function effect(fn) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_OBJ; + + if (isEffect(fn)) { + fn = fn.raw; + } + + var effect = createReactiveEffect(fn, options); + + if (!options.lazy) { + effect(); + } + + return effect; + } + + function stop(effect) { + if (effect.active) { + cleanup(effect); + + if (effect.options.onStop) { + effect.options.onStop(); + } + + effect.active = false; + } + } + + var uid = 0; + + function createReactiveEffect(fn, options) { + var effect = function reactiveEffect() { + if (!effect.active) { + return fn(); + } + + if (!effectStack.includes(effect)) { + cleanup(effect); + + try { + enableTracking(); + effectStack.push(effect); + activeEffect = effect; + return fn(); + } finally { + effectStack.pop(); + resetTracking(); + activeEffect = effectStack[effectStack.length - 1]; + } + } + }; + + effect.id = uid++; + effect.allowRecurse = !!options.allowRecurse; + effect._isEffect = true; + effect.active = true; + effect.raw = fn; + effect.deps = []; + effect.options = options; + return effect; + } + + function cleanup(effect) { + var deps = effect.deps; + + if (deps.length) { + for (var i = 0; i < deps.length; i++) { + deps[i].delete(effect); + } + + deps.length = 0; + } + } + + var shouldTrack = true; + var trackStack = []; + + function pauseTracking() { + trackStack.push(shouldTrack); + shouldTrack = false; + } + + function enableTracking() { + trackStack.push(shouldTrack); + shouldTrack = true; + } + + function resetTracking() { + var last = trackStack.pop(); + shouldTrack = last === undefined ? true : last; + } + + function track(target, type, key) { + if (!shouldTrack || activeEffect === undefined) { + return; + } + + var depsMap = targetMap.get(target); + + if (!depsMap) { + targetMap.set(target, depsMap = new Map()); + } + + var dep = depsMap.get(key); + + if (!dep) { + depsMap.set(key, dep = new Set()); + } + + if (!dep.has(activeEffect)) { + dep.add(activeEffect); + activeEffect.deps.push(dep); + + if (process.env.NODE_ENV !== 'production' && activeEffect.options.onTrack) { + activeEffect.options.onTrack({ + effect: activeEffect, + target, + type, + key + }); + } + } + } + + function trigger(target, type, key, newValue, oldValue, oldTarget) { + var depsMap = targetMap.get(target); + + if (!depsMap) { + // never been tracked + return; + } + + var effects = new Set(); + + var add = function add(effectsToAdd) { + if (effectsToAdd) { + effectsToAdd.forEach(function (effect) { + if (effect !== activeEffect || effect.allowRecurse) { + effects.add(effect); + } + }); + } + }; + + if (type === 'clear' + /* CLEAR */ + ) { + // collection being cleared + // trigger all effects for target + depsMap.forEach(add); + } else if (key === 'length' && isArray(target)) { + depsMap.forEach(function (dep, key) { + if (key === 'length' || key >= newValue) { + add(dep); + } + }); + } else { + // schedule runs for SET | ADD | DELETE + if (key !== void 0) { + add(depsMap.get(key)); + } // also run for iteration key on ADD | DELETE | Map.SET + + + switch (type) { + case 'add' + /* ADD */ + : + if (!isArray(target)) { + add(depsMap.get(ITERATE_KEY)); + + if (isMap(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } else if (isIntegerKey(key)) { + // new index added to array -> length changes + add(depsMap.get('length')); + } + + break; + + case 'delete' + /* DELETE */ + : + if (!isArray(target)) { + add(depsMap.get(ITERATE_KEY)); + + if (isMap(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + + break; + + case 'set' + /* SET */ + : + if (isMap(target)) { + add(depsMap.get(ITERATE_KEY)); + } + + break; + } + } + + var run = function run(effect) { + if (process.env.NODE_ENV !== 'production' && effect.options.onTrigger) { + effect.options.onTrigger({ + effect, + target, + key, + type, + newValue, + oldValue, + oldTarget + }); + } + + if (effect.options.scheduler) { + effect.options.scheduler(effect); + } else { + effect(); + } + }; + + effects.forEach(run); + } + + var isNonTrackableKeys = /*#__PURE__*/makeMap("__proto__,__v_isRef,__isVue"); + var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map(function (key) { + return Symbol[key]; + }).filter(isSymbol)); + var get = /*#__PURE__*/createGetter(); + var shallowGet = /*#__PURE__*/createGetter(false, true); + var readonlyGet = /*#__PURE__*/createGetter(true); + var shallowReadonlyGet = /*#__PURE__*/createGetter(true, true); + var arrayInstrumentations = {}; + ['includes', 'indexOf', 'lastIndexOf'].forEach(function (key) { + var method = Array.prototype[key]; + + arrayInstrumentations[key] = function () { + var arr = toRaw(this); + + for (var i = 0, l = this.length; i < l; i++) { + track(arr, 'get' + /* GET */ + , i + ''); + } // we run the method using the original args first (which may be reactive) + + + for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) { + args[_key2] = arguments[_key2]; + } + + var res = method.apply(arr, args); + + if (res === -1 || res === false) { + // if that didn't work, run it again using raw values. + return method.apply(arr, args.map(toRaw)); + } else { + return res; + } + }; + }); + ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(function (key) { + var method = Array.prototype[key]; + + arrayInstrumentations[key] = function () { + pauseTracking(); + + for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) { + args[_key3] = arguments[_key3]; + } + + var res = method.apply(this, args); + resetTracking(); + return res; + }; + }); + + function createGetter() { + var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var shallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + return function get(target, key, receiver) { + if (key === '__v_isReactive' + /* IS_REACTIVE */ + ) { + return !isReadonly; + } else if (key === '__v_isReadonly' + /* IS_READONLY */ + ) { + return isReadonly; + } else if (key === '__v_raw' + /* RAW */ + && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) { + return target; + } + + var targetIsArray = isArray(target); + + if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver); + } + + var res = Reflect.get(target, key, receiver); + + if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { + return res; + } + + if (!isReadonly) { + track(target, 'get' + /* GET */ + , key); + } + + if (shallow) { + return res; + } + + if (isRef(res)) { + // ref unwrapping - does not apply for Array + integer key. + var shouldUnwrap = !targetIsArray || !isIntegerKey(key); + return shouldUnwrap ? res.value : res; + } + + if (isObject(res)) { + // Convert returned value into a proxy as well. we do the isObject check + // here to avoid invalid value warning. Also need to lazy access readonly + // and reactive here to avoid circular dependency. + return isReadonly ? readonly(res) : reactive(res); + } + + return res; + }; + } + + var set = /*#__PURE__*/createSetter(); + var shallowSet = /*#__PURE__*/createSetter(true); + + function createSetter() { + var shallow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + return function set(target, key, value, receiver) { + var oldValue = target[key]; + + if (!shallow) { + value = toRaw(value); + oldValue = toRaw(oldValue); + + if (!isArray(target) && isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } + } + + var hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key); + var result = Reflect.set(target, key, value, receiver); // don't trigger if target is something up in the prototype chain of original + + if (target === toRaw(receiver)) { + if (!hadKey) { + trigger(target, 'add' + /* ADD */ + , key, value); + } else if (hasChanged(value, oldValue)) { + trigger(target, 'set' + /* SET */ + , key, value, oldValue); + } + } + + return result; + }; + } + + function deleteProperty(target, key) { + var hadKey = hasOwn(target, key); + var oldValue = target[key]; + var result = Reflect.deleteProperty(target, key); + + if (result && hadKey) { + trigger(target, 'delete' + /* DELETE */ + , key, undefined, oldValue); + } + + return result; + } + + function has(target, key) { + var result = Reflect.has(target, key); + + if (!isSymbol(key) || !builtInSymbols.has(key)) { + track(target, 'has' + /* HAS */ + , key); + } + + return result; + } + + function ownKeys(target) { + track(target, 'iterate' + /* ITERATE */ + , isArray(target) ? 'length' : ITERATE_KEY); + return Reflect.ownKeys(target); + } + + var mutableHandlers = { + get, + set, + deleteProperty, + has, + ownKeys + }; + var readonlyHandlers = { + get: readonlyGet, + + set(target, key) { + if (process.env.NODE_ENV !== 'production') { + console.warn("Set operation on key \"".concat(String(key), "\" failed: target is readonly."), target); + } + + return true; + }, + + deleteProperty(target, key) { + if (process.env.NODE_ENV !== 'production') { + console.warn("Delete operation on key \"".concat(String(key), "\" failed: target is readonly."), target); + } + + return true; + } + + }; + var shallowReactiveHandlers = extend({}, mutableHandlers, { + get: shallowGet, + set: shallowSet + }); // Props handlers are special in the sense that it should not unwrap top-level + // refs (in order to allow refs to be explicitly passed down), but should + // retain the reactivity of the normal readonly object. + + var shallowReadonlyHandlers = extend({}, readonlyHandlers, { + get: shallowReadonlyGet + }); + + var toReactive = function toReactive(value) { + return isObject(value) ? reactive(value) : value; + }; + + var toReadonly = function toReadonly(value) { + return isObject(value) ? readonly(value) : value; + }; + + var toShallow = function toShallow(value) { + return value; + }; + + var getProto = function getProto(v) { + return Reflect.getPrototypeOf(v); + }; + + function get$1(target, key) { + var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var isShallow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + // #1772: readonly(reactive(Map)) should return readonly + reactive version + // of the value + target = target['__v_raw' + /* RAW */ + ]; + var rawTarget = toRaw(target); + var rawKey = toRaw(key); + + if (key !== rawKey) { + !isReadonly && track(rawTarget, 'get' + /* GET */ + , key); + } + + !isReadonly && track(rawTarget, 'get' + /* GET */ + , rawKey); + + var _getProto = getProto(rawTarget), + has = _getProto.has; + + var wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; + + if (has.call(rawTarget, key)) { + return wrap(target.get(key)); + } else if (has.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } else if (target !== rawTarget) { + // #3602 readonly(reactive(Map)) + // ensure that the nested reactive `Map` can do tracking for itself + target.get(key); + } + } + + function has$1(key) { + var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var target = this['__v_raw' + /* RAW */ + ]; + var rawTarget = toRaw(target); + var rawKey = toRaw(key); + + if (key !== rawKey) { + !isReadonly && track(rawTarget, 'has' + /* HAS */ + , key); + } + + !isReadonly && track(rawTarget, 'has' + /* HAS */ + , rawKey); + return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); + } + + function size(target) { + var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + target = target['__v_raw' + /* RAW */ + ]; + !isReadonly && track(toRaw(target), 'iterate' + /* ITERATE */ + , ITERATE_KEY); + return Reflect.get(target, 'size', target); + } + + function add(value) { + value = toRaw(value); + var target = toRaw(this); + var proto = getProto(target); + var hadKey = proto.has.call(target, value); + + if (!hadKey) { + target.add(value); + trigger(target, 'add' + /* ADD */ + , value, value); + } + + return this; + } + + function set$1(key, value) { + value = toRaw(value); + var target = toRaw(this); + + var _getProto2 = getProto(target), + has = _getProto2.has, + get = _getProto2.get; + + var hadKey = has.call(target, key); + + if (!hadKey) { + key = toRaw(key); + hadKey = has.call(target, key); + } else if (process.env.NODE_ENV !== 'production') { + checkIdentityKeys(target, has, key); + } + + var oldValue = get.call(target, key); + target.set(key, value); + + if (!hadKey) { + trigger(target, 'add' + /* ADD */ + , key, value); + } else if (hasChanged(value, oldValue)) { + trigger(target, 'set' + /* SET */ + , key, value, oldValue); + } + + return this; + } + + function deleteEntry(key) { + var target = toRaw(this); + + var _getProto3 = getProto(target), + has = _getProto3.has, + get = _getProto3.get; + + var hadKey = has.call(target, key); + + if (!hadKey) { + key = toRaw(key); + hadKey = has.call(target, key); + } else if (process.env.NODE_ENV !== 'production') { + checkIdentityKeys(target, has, key); + } + + var oldValue = get ? get.call(target, key) : undefined; // forward the operation before queueing reactions + + var result = target.delete(key); + + if (hadKey) { + trigger(target, 'delete' + /* DELETE */ + , key, undefined, oldValue); + } + + return result; + } + + function clear() { + var target = toRaw(this); + var hadItems = target.size !== 0; + var oldTarget = process.env.NODE_ENV !== 'production' ? isMap(target) ? new Map(target) : new Set(target) : undefined; // forward the operation before queueing reactions + + var result = target.clear(); + + if (hadItems) { + trigger(target, 'clear' + /* CLEAR */ + , undefined, undefined, oldTarget); + } + + return result; + } + + function createForEach(isReadonly, isShallow) { + return function forEach(callback, thisArg) { + var observed = this; + var target = observed['__v_raw' + /* RAW */ + ]; + var rawTarget = toRaw(target); + var wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; + !isReadonly && track(rawTarget, 'iterate' + /* ITERATE */ + , ITERATE_KEY); + return target.forEach(function (value, key) { + // important: make sure the callback is + // 1. invoked with the reactive map as `this` and 3rd arg + // 2. the value received should be a corresponding reactive/readonly. + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; + } + + function createIterableMethod(method, isReadonly, isShallow) { + return function () { + var target = this['__v_raw' + /* RAW */ + ]; + var rawTarget = toRaw(target); + var targetIsMap = isMap(rawTarget); + var isPair = method === 'entries' || method === Symbol.iterator && targetIsMap; + var isKeyOnly = method === 'keys' && targetIsMap; + var innerIterator = target[method].apply(target, arguments); + var wrap = isShallow ? toShallow : isReadonly ? toReadonly : 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() { + var _innerIterator$next = innerIterator.next(), + value = _innerIterator$next.value, + done = _innerIterator$next.done; + + 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 () { + if (process.env.NODE_ENV !== 'production') { + var key = (arguments.length <= 0 ? undefined : arguments[0]) ? "on key \"".concat(arguments.length <= 0 ? undefined : arguments[0], "\" ") : ""; + console.warn("".concat(capitalize(type), " operation ").concat(key, "failed: target is readonly."), toRaw(this)); + } + + return type === 'delete' + /* DELETE */ + ? false : this; + }; + } + + var mutableInstrumentations = { + get(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) + }; + var 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) + }; + var 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) + }; + var shallowReadonlyInstrumentations = { + get(key) { + return get$1(this, key, true, 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, true) + }; + var iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]; + iteratorMethods.forEach(function (method) { + mutableInstrumentations[method] = createIterableMethod(method, false, false); + readonlyInstrumentations[method] = createIterableMethod(method, true, false); + shallowInstrumentations[method] = createIterableMethod(method, false, true); + shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true); + }); + + function createInstrumentationGetter(isReadonly, shallow) { + var instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations; + return function (target, key, receiver) { + if (key === '__v_isReactive' + /* IS_REACTIVE */ + ) { + return !isReadonly; + } else if (key === '__v_isReadonly' + /* IS_READONLY */ + ) { + return isReadonly; + } else if (key === '__v_raw' + /* RAW */ + ) { + return target; + } + + return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver); + }; + } + + var mutableCollectionHandlers = { + get: createInstrumentationGetter(false, false) + }; + var shallowCollectionHandlers = { + get: createInstrumentationGetter(false, true) + }; + var readonlyCollectionHandlers = { + get: createInstrumentationGetter(true, false) + }; + var shallowReadonlyCollectionHandlers = { + get: createInstrumentationGetter(true, true) + }; + + function checkIdentityKeys(target, has, key) { + var rawKey = toRaw(key); + + if (rawKey !== key && has.call(target, rawKey)) { + var type = toRawType(target); + console.warn("Reactive ".concat(type, " contains both the raw and reactive ") + "versions of the same object".concat(type === "Map" ? " as keys" : "", ", ") + "which can lead to inconsistencies. " + "Avoid differentiating between the raw and reactive versions " + "of an object and only use the reactive version if possible."); + } + } + + var reactiveMap = new WeakMap(); + var shallowReactiveMap = new WeakMap(); + var readonlyMap = new WeakMap(); + var shallowReadonlyMap = 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, reactiveMap); + } + /** + * Return a shallowly-reactive copy of the original object, where only the root + * level properties are reactive. It also does not auto-unwrap refs (even at the + * root level). + */ + + + function shallowReactive(target) { + return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); + } + /** + * 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, readonlyMap); + } + /** + * 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, shallowReadonlyCollectionHandlers, shallowReadonlyMap); + } + + function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) { + if (!isObject(target)) { + if (process.env.NODE_ENV !== 'production') { + console.warn("value cannot be made reactive: ".concat(String(target))); + } + + return target; + } // target is already a Proxy, return it. + // exception: calling readonly() on a reactive object + + + if (target['__v_raw' + /* RAW */ + ] && !(isReadonly && target['__v_isReactive' + /* IS_REACTIVE */ + ])) { + return target; + } // target already has corresponding Proxy + + + var existingProxy = proxyMap.get(target); + + if (existingProxy) { + return existingProxy; + } // only a whitelist of value types can be observed. + + + var targetType = getTargetType(target); + + if (targetType === 0 + /* INVALID */ + ) { + return target; + } + + var proxy = new Proxy(target, targetType === 2 + /* COLLECTION */ + ? collectionHandlers : baseHandlers); + proxyMap.set(target, proxy); + return proxy; + } + + function isReactive(value) { + if (isReadonly(value)) { + return isReactive(value['__v_raw' + /* RAW */ + ]); + } + + return !!(value && value['__v_isReactive' + /* IS_REACTIVE */ + ]); + } + + function isReadonly(value) { + return !!(value && value['__v_isReadonly' + /* IS_READONLY */ + ]); + } + + function isProxy(value) { + return isReactive(value) || isReadonly(value); + } + + function toRaw(observed) { + return observed && toRaw(observed['__v_raw' + /* RAW */ + ]) || observed; + } + + function markRaw(value) { + def(value, '__v_skip' + /* SKIP */ + , true); + return value; + } + + var convert = function convert(val) { + return isObject(val) ? reactive(val) : val; + }; + + function isRef(r) { + return Boolean(r && r.__v_isRef === true); + } + + function ref(value) { + return createRef(value); + } + + function shallowRef(value) { + return createRef(value, true); + } + + var RefImpl = /*#__PURE__*/function () { + function RefImpl(_rawValue, _shallow) { + _classCallCheck(this, RefImpl); + + this._rawValue = _rawValue; + this._shallow = _shallow; + this.__v_isRef = true; + this._value = _shallow ? _rawValue : convert(_rawValue); + } + + _createClass(RefImpl, [{ + key: "value", + get: function get() { + track(toRaw(this), 'get' + /* GET */ + , 'value'); + return this._value; + }, + set: function set(newVal) { + if (hasChanged(toRaw(newVal), this._rawValue)) { + this._rawValue = newVal; + this._value = this._shallow ? newVal : convert(newVal); + trigger(toRaw(this), 'set' + /* SET */ + , 'value', newVal); + } + } + }]); + + return RefImpl; + }(); + + function createRef(rawValue) { + var shallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + if (isRef(rawValue)) { + return rawValue; + } + + return new RefImpl(rawValue, shallow); + } + + function triggerRef(ref) { + trigger(toRaw(ref), 'set' + /* SET */ + , 'value', process.env.NODE_ENV !== 'production' ? ref.value : void 0); + } + + function unref(ref) { + return isRef(ref) ? ref.value : ref; + } + + var shallowUnwrapHandlers = { + get: function get(target, key, receiver) { + return unref(Reflect.get(target, key, receiver)); + }, + set: function set(target, key, value, receiver) { + var oldValue = target[key]; + + if (isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } else { + return Reflect.set(target, key, value, receiver); + } + } + }; + + function proxyRefs(objectWithRefs) { + return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers); + } + + var CustomRefImpl = /*#__PURE__*/function () { + function CustomRefImpl(factory) { + var _this7 = this; + + _classCallCheck(this, CustomRefImpl); + + this.__v_isRef = true; + + var _factory = factory(function () { + return track(_this7, 'get' + /* GET */ + , + /* GET */ + 'value'); + }, function () { + return trigger(_this7, 'set' + /* SET */ + , + /* SET */ + 'value'); + }), + get = _factory.get, + set = _factory.set; + + this._get = get; + this._set = set; + } + + _createClass(CustomRefImpl, [{ + key: "value", + get: function get() { + return this._get(); + }, + set: function set(newVal) { + this._set(newVal); + } + }]); + + return CustomRefImpl; + }(); + + function customRef(factory) { + return new CustomRefImpl(factory); + } + + function toRefs(object) { + if (process.env.NODE_ENV !== 'production' && !isProxy(object)) { + console.warn("toRefs() expects a reactive object but received a plain one."); + } + + var ret = isArray(object) ? new Array(object.length) : {}; + + for (var key in object) { + ret[key] = toRef(object, key); + } + + return ret; + } + + var ObjectRefImpl = /*#__PURE__*/function () { + function ObjectRefImpl(_object, _key) { + _classCallCheck(this, ObjectRefImpl); + + this._object = _object; + this._key = _key; + this.__v_isRef = true; + } + + _createClass(ObjectRefImpl, [{ + key: "value", + get: function get() { + return this._object[this._key]; + }, + set: function set(newVal) { + this._object[this._key] = newVal; + } + }]); + + return ObjectRefImpl; + }(); + + function toRef(object, key) { + return isRef(object[key]) ? object[key] : new ObjectRefImpl(object, key); + } + + var ComputedRefImpl = /*#__PURE__*/function () { + function ComputedRefImpl(getter, _setter, isReadonly) { + var _this8 = this; + + _classCallCheck(this, ComputedRefImpl); + + this._setter = _setter; + this._dirty = true; + this.__v_isRef = true; + this.effect = effect(getter, { + lazy: true, + scheduler: function scheduler() { + if (!_this8._dirty) { + _this8._dirty = true; + trigger(toRaw(_this8), 'set' + /* SET */ + , 'value'); + } + } + }); + this['__v_isReadonly' + /* IS_READONLY */ + ] = isReadonly; + } + + _createClass(ComputedRefImpl, [{ + key: "value", + get: function get() { + // the computed ref may get wrapped by other proxies e.g. readonly() #3376 + var self = toRaw(this); + + if (self._dirty) { + self._value = this.effect(); + self._dirty = false; + } + + track(self, 'get' + /* GET */ + , 'value'); + return self._value; + }, + set: function set(newValue) { + this._setter(newValue); + } + }]); + + return ComputedRefImpl; + }(); + + function computed(getterOrOptions) { + var getter; + var setter; + + if (isFunction(getterOrOptions)) { + getter = getterOrOptions; + setter = process.env.NODE_ENV !== 'production' ? function () { + console.warn('Write operation failed: computed value is readonly'); + } : NOOP; + } else { + getter = getterOrOptions.get; + setter = getterOrOptions.set; + } + + return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set); + } + + var stack = []; + + function pushWarningContext(vnode) { + stack.push(vnode); + } + + function popWarningContext() { + stack.pop(); + } + + function warn(msg) { + // avoid props formatting or warn handler tracking deps that might be mutated + // during patch, leading to infinite recursion. + pauseTracking(); + var instance = stack.length ? stack[stack.length - 1].component : null; + var appWarnHandler = instance && instance.appContext.config.warnHandler; + var trace = getComponentTrace(); + + for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key4 = 1; _key4 < _len3; _key4++) { + args[_key4 - 1] = arguments[_key4]; + } + + if (appWarnHandler) { + callWithErrorHandling(appWarnHandler, instance, 11 + /* APP_WARN_HANDLER */ + , [msg + args.join(''), instance && instance.proxy, trace.map(function (_ref3) { + var vnode = _ref3.vnode; + return "at <".concat(formatComponentName(instance, vnode.type), ">"); + }).join('\n'), trace]); + } else { + var _console; + + var warnArgs = ["[Vue warn]: ".concat(msg)].concat(args); + /* istanbul ignore if */ + + if (trace.length && // avoid spamming console during tests + !false) { + warnArgs.push.apply(warnArgs, ["\n"].concat(_toConsumableArray(formatTrace(trace)))); + } + + (_console = console).warn.apply(_console, _toConsumableArray(warnArgs)); + } + + resetTracking(); + } + + function getComponentTrace() { + var currentVNode = stack[stack.length - 1]; + + if (!currentVNode) { + return []; + } // we can't just use the stack because it will be incomplete during updates + // that did not start from the root. Re-construct the parent chain using + // instance parent pointers. + + + var normalizedStack = []; + + while (currentVNode) { + var last = normalizedStack[0]; + + if (last && last.vnode === currentVNode) { + last.recurseCount++; + } else { + normalizedStack.push({ + vnode: currentVNode, + recurseCount: 0 + }); + } + + var parentInstance = currentVNode.component && currentVNode.component.parent; + currentVNode = parentInstance && parentInstance.vnode; + } + + return normalizedStack; + } + /* istanbul ignore next */ + + + function formatTrace(trace) { + var logs = []; + trace.forEach(function (entry, i) { + logs.push.apply(logs, _toConsumableArray(i === 0 ? [] : ["\n"]).concat(_toConsumableArray(formatTraceEntry(entry)))); + }); + return logs; + } + + function formatTraceEntry(_ref4) { + var vnode = _ref4.vnode, + recurseCount = _ref4.recurseCount; + var postfix = recurseCount > 0 ? "... (".concat(recurseCount, " recursive calls)") : ""; + var isRoot = vnode.component ? vnode.component.parent == null : false; + var open = " at <".concat(formatComponentName(vnode.component, vnode.type, isRoot)); + var close = ">" + postfix; + return vnode.props ? [open].concat(_toConsumableArray(formatProps(vnode.props)), [close]) : [open + close]; + } + /* istanbul ignore next */ + + + function formatProps(props) { + var res = []; + var keys = Object.keys(props); + keys.slice(0, 3).forEach(function (key) { + res.push.apply(res, _toConsumableArray(formatProp(key, props[key]))); + }); + + if (keys.length > 3) { + res.push(" ..."); + } + + return res; + } + /* istanbul ignore next */ + + + function formatProp(key, value, raw) { + if (isString(value)) { + value = JSON.stringify(value); + return raw ? value : ["".concat(key, "=").concat(value)]; + } else if (typeof value === 'number' || typeof value === 'boolean' || value == null) { + return raw ? value : ["".concat(key, "=").concat(value)]; + } else if (isRef(value)) { + value = formatProp(key, toRaw(value.value), true); + return raw ? value : ["".concat(key, "=Ref<"), value, ">"]; + } else if (isFunction(value)) { + return ["".concat(key, "=fn").concat(value.name ? "<".concat(value.name, ">") : "")]; + } else { + value = toRaw(value); + return raw ? value : ["".concat(key, "="), value]; + } + } + + var ErrorTypeStrings = { + ['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) { + var res; + + try { + res = args ? fn.apply(void 0, _toConsumableArray(args)) : fn(); + } catch (err) { + handleError(err, instance, type); + } + + return res; + } + + function callWithAsyncErrorHandling(fn, instance, type, args) { + if (isFunction(fn)) { + var res = callWithErrorHandling(fn, instance, type, args); + + if (res && isPromise(res)) { + res.catch(function (err) { + handleError(err, instance, type); + }); + } + + return res; + } + + var values = []; + + for (var i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); + } + + return values; + } + + function handleError(err, instance, type) { + var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + var contextVNode = instance ? instance.vnode : null; + + if (instance) { + var cur = instance.parent; // the exposed instance is the render proxy to keep it consistent with 2.x + + var exposedInstance = instance.proxy; // in production the hook receives only the error code + + var errorInfo = process.env.NODE_ENV !== 'production' ? ErrorTypeStrings[type] : type; + + while (cur) { + var errorCapturedHooks = cur.ec; + + if (errorCapturedHooks) { + for (var i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { + return; + } + } + } + + cur = cur.parent; + } // app-level handling + + + var appErrorHandler = instance.appContext.config.errorHandler; + + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10 + /* APP_ERROR_HANDLER */ + , [err, exposedInstance, errorInfo]); + return; + } + } + + logError(err, type, contextVNode, throwInDev); + } + + function logError(err, type, contextVNode) { + var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + + if (process.env.NODE_ENV !== 'production') { + var info = ErrorTypeStrings[type]; + + if (contextVNode) { + pushWarningContext(contextVNode); + } + + warn("Unhandled error".concat(info ? " during execution of ".concat(info) : "")); + + if (contextVNode) { + popWarningContext(); + } // crash in dev by default so it's more noticeable + + + if (throwInDev) { + throw err; + } else { + console.error(err); + } + } else { + // recover in prod to reduce the impact on end-user + console.error(err); + } + } + + var isFlushing = false; + var isFlushPending = false; + var queue = []; + var flushIndex = 0; + var pendingPreFlushCbs = []; + var activePreFlushCbs = null; + var preFlushIndex = 0; + var pendingPostFlushCbs = []; + var activePostFlushCbs = null; + var postFlushIndex = 0; + var resolvedPromise = Promise.resolve(); + var currentFlushPromise = null; + var currentPreFlushParentJob = null; + var RECURSION_LIMIT = 100; + + function nextTick(fn) { + var p = currentFlushPromise || resolvedPromise; + return fn ? p.then(this ? fn.bind(this) : fn) : p; + } // #2768 + // Use binary-search to find a suitable position in the queue, + // so that the queue maintains the increasing order of job's id, + // which can prevent the job from being skipped and also can avoid repeated patching. + + + function findInsertionIndex(job) { + // the start index should be `flushIndex + 1` + var start = flushIndex + 1; + var end = queue.length; + var jobId = getId(job); + + while (start < end) { + var middle = start + end >>> 1; + var middleJobId = getId(queue[middle]); + middleJobId < jobId ? start = middle + 1 : end = middle; + } + + return start; + } + + 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) { + var pos = findInsertionIndex(job); + + if (pos > -1) { + queue.splice(pos, 0, job); + } else { + queue.push(job); + } + + queueFlush(); + } + } + + function queueFlush() { + if (!isFlushing && !isFlushPending) { + isFlushPending = true; + currentFlushPromise = resolvedPromise.then(flushJobs); + } + } + + function invalidateJob(job) { + var i = queue.indexOf(job); + + if (i > flushIndex) { + queue.splice(i, 1); + } + } + + function queueCb(cb, activeQueue, pendingQueue, index) { + if (!isArray(cb)) { + if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { + pendingQueue.push(cb); + } + } else { + // if cb is an array, it is a component lifecycle hook which can only be + // triggered by a job, which is already deduped in the main queue, so + // we can skip duplicate check here to improve perf + pendingQueue.push.apply(pendingQueue, _toConsumableArray(cb)); + } + + queueFlush(); + } + + function queuePreFlushCb(cb) { + queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); + } + + function queuePostFlushCb(cb) { + queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); + } + + function flushPreFlushCbs(seen) { + var parentJob = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + + if (pendingPreFlushCbs.length) { + currentPreFlushParentJob = parentJob; + activePreFlushCbs = _toConsumableArray(new Set(pendingPreFlushCbs)); + pendingPreFlushCbs.length = 0; + + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map(); + } + + for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { + if (process.env.NODE_ENV !== 'production' && checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex])) { + continue; + } + + activePreFlushCbs[preFlushIndex](); + } + + activePreFlushCbs = null; + preFlushIndex = 0; + currentPreFlushParentJob = null; // recursively flush until it drains + + flushPreFlushCbs(seen, parentJob); + } + } + + function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + var deduped = _toConsumableArray(new Set(pendingPostFlushCbs)); + + pendingPostFlushCbs.length = 0; // #1947 already has active queue, nested flushPostFlushCbs call + + if (activePostFlushCbs) { + var _activePostFlushCbs; + + (_activePostFlushCbs = activePostFlushCbs).push.apply(_activePostFlushCbs, _toConsumableArray(deduped)); + + return; + } + + activePostFlushCbs = deduped; + + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map(); + } + + activePostFlushCbs.sort(function (a, b) { + return getId(a) - getId(b); + }); + + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + if (process.env.NODE_ENV !== 'production' && checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) { + continue; + } + + activePostFlushCbs[postFlushIndex](); + } + + activePostFlushCbs = null; + postFlushIndex = 0; + } + } + + var getId = function getId(job) { + return job.id == null ? Infinity : job.id; + }; + + function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map(); + } + + flushPreFlushCbs(seen); // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child so its render effect will have smaller + // priority number) + // 2. If a component is unmounted during a parent component's update, + // its update can be skipped. + + queue.sort(function (a, b) { + return getId(a) - getId(b); + }); + + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + var job = queue[flushIndex]; + + if (job && job.active !== false) { + if (process.env.NODE_ENV !== 'production' && checkRecursiveUpdates(seen, job)) { + continue; + } + + 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 || pendingPreFlushCbs.length || pendingPostFlushCbs.length) { + flushJobs(seen); + } + } + } + + function checkRecursiveUpdates(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } else { + var count = seen.get(fn); + + if (count > RECURSION_LIMIT) { + var instance = fn.ownerInstance; + var componentName = instance && getComponentName(instance.type); + warn("Maximum recursive updates exceeded".concat(componentName ? " in component <".concat(componentName, ">") : "", ". ") + "This means you have a reactive effect that is mutating its own " + "dependencies and thus recursively triggering itself. Possible sources " + "include component template, render function, updated hook or " + "watcher source function."); + return true; + } else { + seen.set(fn, count + 1); + } + } + } + /* eslint-disable no-restricted-globals */ + + + var isHmrUpdating = false; + var hmrDirtyComponents = new Set(); // Expose the HMR runtime on the window object + // This makes it entirely tree-shakable without polluting the exports and makes + // it easier to be used in toolings like vue-loader + // Note: for a component to be eligible for HMR it also needs the __hmrId option + // to be set so that its instances can be registered / removed. + + if (process.env.NODE_ENV !== 'production') { + var globalObject = typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {}; + globalObject.__VUE_HMR_RUNTIME__ = { + createRecord: tryWrap(createRecord), + rerender: tryWrap(rerender), + reload: tryWrap(reload) + }; + } + + var map = new Map(); + + function registerHMR(instance) { + var id = instance.type.__hmrId; + var record = map.get(id); + + if (!record) { + createRecord(id, instance.type); + record = map.get(id); + } + + record.instances.add(instance); + } + + function unregisterHMR(instance) { + map.get(instance.type.__hmrId).instances.delete(instance); + } + + function createRecord(id, component) { + if (!component) { + warn("HMR API usage is out of date.\n" + "Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant " + "dependency that handles Vue SFC compilation."); + component = {}; + } + + if (map.has(id)) { + return false; + } + + map.set(id, { + component: isClassComponent(component) ? component.__vccOpts : component, + instances: new Set() + }); + return true; + } + + function rerender(id, newRender) { + var record = map.get(id); + if (!record) return; + if (newRender) record.component.render = newRender; // Array.from creates a snapshot which avoids the set being mutated during + // updates + + Array.from(record.instances).forEach(function (instance) { + if (newRender) { + instance.render = newRender; + } + + instance.renderCache = []; // this flag forces child components with slot content to update + + isHmrUpdating = true; + instance.update(); + isHmrUpdating = false; + }); + } + + function reload(id, newComp) { + var record = map.get(id); + if (!record) return; // Array.from creates a snapshot which avoids the set being mutated during + // updates + + var component = record.component, + instances = record.instances; + + if (!hmrDirtyComponents.has(component)) { + // 1. Update existing comp definition to match new one + newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp; + extend(component, newComp); + + for (var key in component) { + if (key !== '__file' && !(key in newComp)) { + delete component[key]; + } + } // 2. Mark component dirty. This forces the renderer to replace the component + // on patch. + + + hmrDirtyComponents.add(component); // 3. Make sure to unmark the component after the reload. + + queuePostFlushCb(function () { + hmrDirtyComponents.delete(component); + }); + } + + Array.from(instances).forEach(function (instance) { + if (instance.parent) { + // 4. Force the parent instance to re-render. This will cause all updated + // components to be unmounted and re-mounted. Queue the update so that we + // don't end up forcing the same parent to re-render multiple times. + queueJob(instance.parent.update); + } else if (instance.appContext.reload) { + // root instance mounted via createApp() has a reload method + instance.appContext.reload(); + } else if (typeof window !== 'undefined') { + // root instance inside tree created via raw render(). Force reload. + window.location.reload(); + } else { + console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); + } + }); + } + + function tryWrap(fn) { + return function (id, arg) { + try { + return fn(id, arg); + } catch (e) { + console.error(e); + console.warn("[HMR] Something went wrong during Vue component hot-reload. " + "Full reload required."); + } + }; + } + + var devtools; + + function setDevtoolsHook(hook) { + devtools = hook; + } + + function devtoolsInitApp(app, version) { + // TODO queue if devtools is undefined + if (!devtools) return; + devtools.emit('app:init' + /* APP_INIT */ + , app, version, { + Fragment, + Text, + Comment: Comment$1, + Static + }); + } + + function devtoolsUnmountApp(app) { + if (!devtools) return; + devtools.emit('app:unmount' + /* APP_UNMOUNT */ + , app); + } + + var devtoolsComponentAdded = /*#__PURE__*/createDevtoolsComponentHook('component:added' + /* COMPONENT_ADDED */ + ); + var devtoolsComponentUpdated = /*#__PURE__*/createDevtoolsComponentHook('component:updated' + /* COMPONENT_UPDATED */ + ); + var devtoolsComponentRemoved = /*#__PURE__*/createDevtoolsComponentHook('component:removed' + /* COMPONENT_REMOVED */ + ); + + function createDevtoolsComponentHook(hook) { + return function (component) { + if (!devtools) return; + devtools.emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined, component); + }; + } + + var devtoolsPerfStart = /*#__PURE__*/createDevtoolsPerformanceHook('perf:start' + /* PERFORMANCE_START */ + ); + var devtoolsPerfEnd = /*#__PURE__*/createDevtoolsPerformanceHook('perf:end' + /* PERFORMANCE_END */ + ); + + function createDevtoolsPerformanceHook(hook) { + return function (component, type, time) { + if (!devtools) return; + devtools.emit(hook, component.appContext.app, component.uid, component, type, time); + }; + } + + function devtoolsComponentEmit(component, event, params) { + if (!devtools) return; + devtools.emit('component:emit' + /* COMPONENT_EMIT */ + , component.appContext.app, component, event, params); + } + + var globalCompatConfig = { + MODE: 2 + }; + + function getCompatConfigForKey(key, instance) { + var instanceConfig = instance && instance.type.compatConfig; + + if (instanceConfig && key in instanceConfig) { + return instanceConfig[key]; + } + + return globalCompatConfig[key]; + } + + function isCompatEnabled(key, instance) { + var enableForBuiltIn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + // skip compat for built-in components + if (!enableForBuiltIn && instance && instance.type.__isBuiltIn) { + return false; + } + + var rawMode = getCompatConfigForKey('MODE', instance) || 2; + var val = getCompatConfigForKey(key, instance); + var mode = isFunction(rawMode) ? rawMode(instance && instance.type) : rawMode; + + if (mode === 2) { + return val !== false; + } else { + return val === true || val === 'suppress-warning'; + } + } + + function emit(instance, event) { + var props = instance.vnode.props || EMPTY_OBJ; + + for (var _len4 = arguments.length, rawArgs = new Array(_len4 > 2 ? _len4 - 2 : 0), _key5 = 2; _key5 < _len4; _key5++) { + rawArgs[_key5 - 2] = arguments[_key5]; + } + + if (process.env.NODE_ENV !== 'production') { + var emitsOptions = instance.emitsOptions, + _instance$propsOption = _slicedToArray(instance.propsOptions, 1), + propsOptions = _instance$propsOption[0]; + + if (emitsOptions) { + if (!(event in emitsOptions) && !false) { + if (!propsOptions || !(toHandlerKey(event) in propsOptions)) { + warn("Component emitted event \"".concat(event, "\" but it is neither declared in ") + "the emits option nor as an \"".concat(toHandlerKey(event), "\" prop.")); + } + } else { + var validator = emitsOptions[event]; + + if (isFunction(validator)) { + var isValid = validator.apply(void 0, rawArgs); + + if (!isValid) { + warn("Invalid event arguments: event validation failed for event \"".concat(event, "\".")); + } + } + } + } + } + + var args = rawArgs; + var isModelListener = event.startsWith('update:'); // for v-model update:xxx events, apply modifiers on args + + var modelArg = isModelListener && event.slice(7); + + if (modelArg && modelArg in props) { + var modifiersKey = "".concat(modelArg === 'modelValue' ? 'model' : modelArg, "Modifiers"); + + var _ref5 = props[modifiersKey] || EMPTY_OBJ, + number = _ref5.number, + trim = _ref5.trim; + + if (trim) { + args = rawArgs.map(function (a) { + return a.trim(); + }); + } else if (number) { + args = rawArgs.map(toNumber); + } + } + + if (process.env.NODE_ENV !== 'production' || false) { + devtoolsComponentEmit(instance, event, args); + } + + if (process.env.NODE_ENV !== 'production') { + var lowerCaseEvent = event.toLowerCase(); + + if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) { + warn("Event \"".concat(lowerCaseEvent, "\" is emitted in component ") + "".concat(formatComponentName(instance, instance.type), " but the handler is registered for \"").concat(event, "\". ") + "Note that HTML attributes are case-insensitive and you cannot use " + "v-on to listen to camelCase events when using in-DOM templates. " + "You should probably use \"".concat(hyphenate(event), "\" instead of \"").concat(event, "\".")); + } + } + + var handlerName; + var handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249) + props[handlerName = toHandlerKey(camelize(event))]; // for v-model update:xxx events, also trigger kebab-case equivalent + // for props passed via kebab-case + + if (!handler && isModelListener) { + handler = props[handlerName = toHandlerKey(hyphenate(event))]; + } + + if (handler) { + callWithAsyncErrorHandling(handler, instance, 6 + /* COMPONENT_EVENT_HANDLER */ + , args); + } + + var onceHandler = props[handlerName + "Once"]; + + if (onceHandler) { + if (!instance.emitted) { + instance.emitted = {}; + } else if (instance.emitted[handlerName]) { + return; + } + + instance.emitted[handlerName] = true; + callWithAsyncErrorHandling(onceHandler, instance, 6 + /* COMPONENT_EVENT_HANDLER */ + , args); + } + } + + function normalizeEmitsOptions(comp, appContext) { + var asMixin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var cache = appContext.emitsCache; + var cached = cache.get(comp); + + if (cached !== undefined) { + return cached; + } + + var raw = comp.emits; + var normalized = {}; // apply mixin/extends props + + var hasExtends = false; + + if (!isFunction(comp)) { + var extendEmits = function extendEmits(raw) { + var normalizedFromExtend = normalizeEmitsOptions(raw, appContext, true); + + if (normalizedFromExtend) { + hasExtends = true; + extend(normalized, normalizedFromExtend); + } + }; + + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendEmits); + } + + if (comp.extends) { + extendEmits(comp.extends); + } + + if (comp.mixins) { + comp.mixins.forEach(extendEmits); + } + } + + if (!raw && !hasExtends) { + cache.set(comp, null); + return null; + } + + if (isArray(raw)) { + raw.forEach(function (key) { + return normalized[key] = null; + }); + } else { + extend(normalized, raw); + } + + cache.set(comp, normalized); + return normalized; + } // Check if an incoming prop key is a declared emit event listener. + // e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are + // both considered matched listeners. + + + function isEmitListener(options, key) { + if (!options || !isOn(key)) { + return false; + } + + key = key.slice(2).replace(/Once$/, ''); + return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key); + } + /** + * mark the current rendering instance for asset resolution (e.g. + * resolveComponent, resolveDirective) during render + */ + + + var currentRenderingInstance = null; + var currentScopeId = null; + /** + * Note: rendering calls maybe nested. The function returns the parent rendering + * instance if present, which should be restored after the render is done: + * + * ```js + * const prev = setCurrentRenderingInstance(i) + * // ...render + * setCurrentRenderingInstance(prev) + * ``` + */ + + function setCurrentRenderingInstance(instance) { + var prev = currentRenderingInstance; + currentRenderingInstance = instance; + currentScopeId = instance && instance.type.__scopeId || null; + return prev; + } + /** + * Set scope id when creating hoisted vnodes. + * @private compiler helper + */ + + + function pushScopeId(id) { + currentScopeId = id; + } + /** + * Technically we no longer need this after 3.0.8 but we need to keep the same + * API for backwards compat w/ code generated by compilers. + * @private + */ + + + function popScopeId() { + currentScopeId = null; + } + /** + * Only for backwards compat + * @private + */ + + + var withScopeId = function withScopeId(_id) { + return withCtx; + }; + /** + * Wrap a slot function to memoize current rendering instance + * @private compiler helper + */ + + + function withCtx(fn) // false only + { + var ctx = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentRenderingInstance; + var isNonScopedSlot = arguments.length > 2 ? arguments[2] : undefined; + if (!ctx) return fn; // already normalized + + if (fn._n) { + return fn; + } + + var renderFnWithContext = function renderFnWithContext() { + // If a user calls a compiled slot inside a template expression (#1745), it + // can mess up block tracking, so by default we disable block tracking and + // force bail out when invoking a compiled slot (indicated by the ._d flag). + // This isn't necessary if rendering a compiled ``, so we flip the + // ._d flag off when invoking the wrapped fn inside `renderSlot`. + if (renderFnWithContext._d) { + setBlockTracking(-1); + } + + var prevInstance = setCurrentRenderingInstance(ctx); + var res = fn.apply(void 0, arguments); + setCurrentRenderingInstance(prevInstance); + + if (renderFnWithContext._d) { + setBlockTracking(1); + } + + if (process.env.NODE_ENV !== 'production' || false) { + devtoolsComponentUpdated(ctx); + } + + return res; + }; // mark normalized to avoid duplicated wrapping + + + renderFnWithContext._n = true; // mark this as compiled by default + // this is used in vnode.ts -> normalizeChildren() to set the slot + // rendering flag. + + renderFnWithContext._c = true; // disable block tracking by default + + renderFnWithContext._d = true; + return renderFnWithContext; + } + /** + * dev only flag to track whether $attrs was used during render. + * If $attrs was used during render then the warning for failed attrs + * fallthrough can be suppressed. + */ + + + var accessedAttrs = false; + + function markAttrsAccessed() { + accessedAttrs = true; + } + + function renderComponentRoot(instance) { + var Component = instance.type, + vnode = instance.vnode, + proxy = instance.proxy, + withProxy = instance.withProxy, + props = instance.props, + _instance$propsOption2 = _slicedToArray(instance.propsOptions, 1), + propsOptions = _instance$propsOption2[0], + slots = instance.slots, + attrs = instance.attrs, + emit = instance.emit, + render = instance.render, + renderCache = instance.renderCache, + data = instance.data, + setupState = instance.setupState, + ctx = instance.ctx, + inheritAttrs = instance.inheritAttrs; + + var result; + var prev = setCurrentRenderingInstance(instance); + + if (process.env.NODE_ENV !== 'production') { + accessedAttrs = false; + } + + try { + var fallthroughAttrs; + + if (vnode.shapeFlag & 4 + /* STATEFUL_COMPONENT */ + ) { + // withProxy is a proxy with a different `has` trap only for + // runtime-compiled render functions using `with` block. + var proxyToUse = withProxy || proxy; + result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx)); + fallthroughAttrs = attrs; + } else { + // functional + var _render = Component; // in dev, mark attrs accessed if optional props (attrs === props) + + if (process.env.NODE_ENV !== 'production' && attrs === props) { + markAttrsAccessed(); + } + + result = normalizeVNode(_render.length > 1 ? _render(props, process.env.NODE_ENV !== 'production' ? { + get attrs() { + markAttrsAccessed(); + return attrs; + }, + + slots, + emit + } : { + attrs, + slots, + emit + }) : _render(props, null + /* we know it doesn't need it */ + )); + fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs); + } // attr merging + // in dev mode, comments are preserved, and it's possible for a template + // to have comments along side the root element which makes it a fragment + + + var root = result; + var setRoot = undefined; + + if (process.env.NODE_ENV !== 'production' && result.patchFlag > 0 && result.patchFlag & 2048 + /* DEV_ROOT_FRAGMENT */ + ) { + ; + + var _getChildRoot = getChildRoot(result); + + var _getChildRoot2 = _slicedToArray(_getChildRoot, 2); + + root = _getChildRoot2[0]; + setRoot = _getChildRoot2[1]; + } + + if (fallthroughAttrs && inheritAttrs !== false) { + var keys = Object.keys(fallthroughAttrs); + var _root = root, + shapeFlag = _root.shapeFlag; + + if (keys.length) { + if (shapeFlag & 1 + /* ELEMENT */ + || shapeFlag & 6 + /* COMPONENT */ + ) { + if (propsOptions && keys.some(isModelListener)) { + // If a v-model listener (onUpdate:xxx) has a corresponding declared + // prop, it indicates this component expects to handle v-model and + // it should not fallthrough. + // related: #1543, #1643, #1989 + fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions); + } + + root = cloneVNode(root, fallthroughAttrs); + } else if (process.env.NODE_ENV !== 'production' && !accessedAttrs && root.type !== Comment$1) { + var allAttrs = Object.keys(attrs); + var eventAttrs = []; + var extraAttrs = []; + + for (var i = 0, l = allAttrs.length; i < l; i++) { + var key = allAttrs[i]; + + if (isOn(key)) { + // ignore v-model handlers when they fail to fallthrough + if (!isModelListener(key)) { + // remove `on`, lowercase first letter to reflect event casing + // accurately + eventAttrs.push(key[2].toLowerCase() + key.slice(3)); + } + } else { + extraAttrs.push(key); + } + } + + if (extraAttrs.length) { + warn("Extraneous non-props attributes (" + "".concat(extraAttrs.join(', '), ") ") + "were passed to component but could not be automatically inherited " + "because component renders fragment or text root nodes."); + } + + if (eventAttrs.length) { + warn("Extraneous non-emits event listeners (" + "".concat(eventAttrs.join(', '), ") ") + "were passed to component but could not be automatically inherited " + "because component renders fragment or text root nodes. " + "If the listener is intended to be a component custom event listener only, " + "declare it using the \"emits\" option."); + } + } + } + } + + if (false && isCompatEnabled('INSTANCE_ATTRS_CLASS_STYLE' + /* INSTANCE_ATTRS_CLASS_STYLE */ + , instance) && vnode.shapeFlag & 4 + /* STATEFUL_COMPONENT */ + && (root.shapeFlag & 1 + /* ELEMENT */ + || root.shapeFlag & 6) + /* COMPONENT */ + ) ; // inherit directives + + if (vnode.dirs) { + if (process.env.NODE_ENV !== 'production' && !isElementRoot(root)) { + warn("Runtime directive used on component with non-element root node. " + "The directives will not function as intended."); + } + + root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs; + } // inherit transition data + + + if (vnode.transition) { + if (process.env.NODE_ENV !== 'production' && !isElementRoot(root)) { + warn("Component inside renders non-element root node " + "that cannot be animated."); + } + + root.transition = vnode.transition; + } + + if (process.env.NODE_ENV !== 'production' && setRoot) { + setRoot(root); + } else { + result = root; + } + } catch (err) { + blockStack.length = 0; + handleError(err, instance, 1 + /* RENDER_FUNCTION */ + ); + result = createVNode(Comment$1); + } + + setCurrentRenderingInstance(prev); + return result; + } + /** + * dev only + * In dev mode, template root level comments are rendered, which turns the + * template into a fragment root, but we need to locate the single element + * root for attrs and scope id processing. + */ + + + var getChildRoot = function getChildRoot(vnode) { + var rawChildren = vnode.children; + var dynamicChildren = vnode.dynamicChildren; + var childRoot = filterSingleRoot(rawChildren); + + if (!childRoot) { + return [vnode, undefined]; + } + + var index = rawChildren.indexOf(childRoot); + var dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1; + + var setRoot = function setRoot(updatedRoot) { + rawChildren[index] = updatedRoot; + + if (dynamicChildren) { + if (dynamicIndex > -1) { + dynamicChildren[dynamicIndex] = updatedRoot; + } else if (updatedRoot.patchFlag > 0) { + vnode.dynamicChildren = [].concat(_toConsumableArray(dynamicChildren), [updatedRoot]); + } + } + }; + + return [normalizeVNode(childRoot), setRoot]; + }; + + function filterSingleRoot(children) { + var singleRoot; + + for (var i = 0; i < children.length; i++) { + var child = children[i]; + + if (isVNode(child)) { + // ignore user comment + if (child.type !== Comment$1 || child.children === 'v-if') { + if (singleRoot) { + // has more than 1 non-comment child, return now + return; + } else { + singleRoot = child; + } + } + } else { + return; + } + } + + return singleRoot; + } + + var getFunctionalFallthrough = function getFunctionalFallthrough(attrs) { + var res; + + for (var key in attrs) { + if (key === 'class' || key === 'style' || isOn(key)) { + (res || (res = {}))[key] = attrs[key]; + } + } + + return res; + }; + + var filterModelListeners = function filterModelListeners(attrs, props) { + var res = {}; + + for (var key in attrs) { + if (!isModelListener(key) || !(key.slice(9) in props)) { + res[key] = attrs[key]; + } + } + + return res; + }; + + var isElementRoot = function isElementRoot(vnode) { + return vnode.shapeFlag & 6 + /* COMPONENT */ + || vnode.shapeFlag & 1 + /* ELEMENT */ + || vnode.type === Comment$1 // potential v-if branch switch + ; + }; + + function shouldUpdateComponent(prevVNode, nextVNode, optimized) { + var prevProps = prevVNode.props, + prevChildren = prevVNode.children, + component = prevVNode.component; + var nextProps = nextVNode.props, + nextChildren = nextVNode.children, + patchFlag = nextVNode.patchFlag; + var emits = component.emitsOptions; // Parent component's render function was hot-updated. Since this may have + // caused the child component's slots content to have changed, we need to + // force the child to update as well. + + if (process.env.NODE_ENV !== 'production' && (prevChildren || nextChildren) && isHmrUpdating) { + return true; + } // force child update for runtime directive or transition on component vnode. + + + if (nextVNode.dirs || nextVNode.transition) { + return true; + } + + if (optimized && patchFlag >= 0) { + if (patchFlag & 1024 + /* DYNAMIC_SLOTS */ + ) { + // slot content that references values that might have changed, + // e.g. in a v-for + return true; + } + + if (patchFlag & 16 + /* FULL_PROPS */ + ) { + if (!prevProps) { + return !!nextProps; + } // presence of this flag indicates props are always non-null + + + return hasPropsChanged(prevProps, nextProps, emits); + } else if (patchFlag & 8 + /* PROPS */ + ) { + var dynamicProps = nextVNode.dynamicProps; + + for (var i = 0; i < dynamicProps.length; i++) { + var key = dynamicProps[i]; + + if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) { + return true; + } + } + } + } else { + // this path is only taken by manually written render functions + // so presence of any children leads to a forced update + if (prevChildren || nextChildren) { + if (!nextChildren || !nextChildren.$stable) { + return true; + } + } + + if (prevProps === nextProps) { + return false; + } + + if (!prevProps) { + return !!nextProps; + } + + if (!nextProps) { + return true; + } + + return hasPropsChanged(prevProps, nextProps, emits); + } + + return false; + } + + function hasPropsChanged(prevProps, nextProps, emitsOptions) { + var nextKeys = Object.keys(nextProps); + + if (nextKeys.length !== Object.keys(prevProps).length) { + return true; + } + + for (var i = 0; i < nextKeys.length; i++) { + var key = nextKeys[i]; + + if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) { + return true; + } + } + + return false; + } + + function updateHOCHostEl(_ref6, el // HostNode + ) { + var vnode = _ref6.vnode, + parent = _ref6.parent; + + while (parent && parent.subTree === vnode) { + (vnode = parent.vnode).el = el; + parent = parent.parent; + } + } + + var isSuspense = function isSuspense(type) { + return type.__isSuspense; + }; // Suspense exposes a component-like API, and is treated like a component + // in the compiler, but internally it's a special built-in type that hooks + // directly into the renderer. + + + var SuspenseImpl = { + name: 'Suspense', + // In order to make Suspense tree-shakable, we need to avoid importing it + // directly in the renderer. The renderer checks for the __isSuspense flag + // on a vnode's type and calls the `process` method, passing in renderer + // internals. + __isSuspense: true, + + process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, // platform-specific impl passed from renderer + rendererInternals) { + if (n1 == null) { + mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals); + } else { + patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, rendererInternals); + } + }, + + hydrate: hydrateSuspense, + create: createSuspenseBoundary, + normalize: normalizeSuspenseChildren + }; // Force-casted public typing for h and TSX props inference + + var Suspense = SuspenseImpl; + + function triggerEvent(vnode, name) { + var eventListener = vnode.props && vnode.props[name]; + + if (isFunction(eventListener)) { + eventListener(); + } + } + + function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) { + var patch = rendererInternals.p, + createElement = rendererInternals.o.createElement; + var hiddenContainer = createElement('div', container); // fixed by xxxxxx + + var suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals); // start mounting the content subtree in an off-dom container + + patch(null, suspense.pendingBranch = vnode.ssContent, hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds); // now check if we have encountered any async deps + + if (suspense.deps > 0) { + // has async + // invoke @fallback event + triggerEvent(vnode, 'onPending'); + triggerEvent(vnode, 'onFallback'); // mount the fallback tree + + patch(null, vnode.ssFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds); + setActiveBranch(suspense, vnode.ssFallback); + } else { + // Suspense has no async deps. Just resolve. + suspense.resolve(); + } + } + + function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, _ref7) { + var patch = _ref7.p, + unmount = _ref7.um, + createElement = _ref7.o.createElement; + var suspense = n2.suspense = n1.suspense; + suspense.vnode = n2; + n2.el = n1.el; + var newBranch = n2.ssContent; + var newFallback = n2.ssFallback; + var activeBranch = suspense.activeBranch, + pendingBranch = suspense.pendingBranch, + isInFallback = suspense.isInFallback, + isHydrating = suspense.isHydrating; + + if (pendingBranch) { + suspense.pendingBranch = newBranch; + + if (isSameVNodeType(newBranch, pendingBranch)) { + // same root type but content may have changed. + patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + + if (suspense.deps <= 0) { + suspense.resolve(); + } else if (isInFallback) { + patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newFallback); + } + } else { + // toggled before pending tree is resolved + suspense.pendingId++; + + if (isHydrating) { + // if toggled before hydration is finished, the current DOM tree is + // no longer valid. set it as the active branch so it will be unmounted + // when resolved + suspense.isHydrating = false; + suspense.activeBranch = pendingBranch; + } else { + unmount(pendingBranch, parentComponent, suspense); + } // increment pending ID. this is used to invalidate async callbacks + // reset suspense state + + + suspense.deps = 0; // discard effects from pending branch + + suspense.effects.length = 0; // discard previous container + + suspense.hiddenContainer = createElement('div', container); // fixed by xxxxxx + + if (isInFallback) { + // already in fallback state + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + + if (suspense.deps <= 0) { + suspense.resolve(); + } else { + patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newFallback); + } + } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { + // toggled "back" to current active branch + patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); // force resolve + + suspense.resolve(true); + } else { + // switched to a 3rd branch + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + + if (suspense.deps <= 0) { + suspense.resolve(); + } + } + } + } else { + if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { + // root did not change, just normal patch + patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newBranch); + } else { + // root node toggled + // invoke @pending event + triggerEvent(n2, 'onPending'); // mount pending branch in off-dom container + + suspense.pendingBranch = newBranch; + suspense.pendingId++; + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + + if (suspense.deps <= 0) { + // incoming branch has no async deps, resolve now. + suspense.resolve(); + } else { + var timeout = suspense.timeout, + pendingId = suspense.pendingId; + + if (timeout > 0) { + setTimeout(function () { + if (suspense.pendingId === pendingId) { + suspense.fallback(newFallback); + } + }, timeout); + } else if (timeout === 0) { + suspense.fallback(newFallback); + } + } + } + } + } + + var hasWarned = false; + + function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals) { + var isHydrating = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : false; + + /* istanbul ignore if */ + if (process.env.NODE_ENV !== 'production' && !false && !hasWarned) { + hasWarned = true; // @ts-ignore `console.info` cannot be null error + + console[console.info ? 'info' : 'log'](" is an experimental feature and its API will likely change."); + } + + var patch = rendererInternals.p, + move = rendererInternals.m, + unmount = rendererInternals.um, + next = rendererInternals.n, + _rendererInternals$o = rendererInternals.o, + parentNode = _rendererInternals$o.parentNode, + remove = _rendererInternals$o.remove; + var timeout = toNumber(vnode.props && vnode.props.timeout); + var suspense = { + vnode, + parent, + parentComponent, + isSVG, + container, + hiddenContainer, + anchor, + deps: 0, + pendingId: 0, + timeout: typeof timeout === 'number' ? timeout : -1, + activeBranch: null, + pendingBranch: null, + isInFallback: true, + isHydrating, + isUnmounted: false, + effects: [], + + resolve() { + var resume = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + if (process.env.NODE_ENV !== 'production') { + if (!resume && !suspense.pendingBranch) { + throw new Error("suspense.resolve() is called without a pending branch."); + } + + if (suspense.isUnmounted) { + throw new Error("suspense.resolve() is called on an already unmounted suspense boundary."); + } + } + + var vnode = suspense.vnode, + activeBranch = suspense.activeBranch, + pendingBranch = suspense.pendingBranch, + pendingId = suspense.pendingId, + effects = suspense.effects, + parentComponent = suspense.parentComponent, + container = suspense.container; + + if (suspense.isHydrating) { + suspense.isHydrating = false; + } else if (!resume) { + var delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === 'out-in'; + + if (delayEnter) { + activeBranch.transition.afterLeave = function () { + if (pendingId === suspense.pendingId) { + move(pendingBranch, container, _anchor, 0 + /* ENTER */ + ); + } + }; + } // this is initial anchor on mount + + + var _anchor = suspense.anchor; // unmount current active tree + + if (activeBranch) { + // if the fallback tree was mounted, it may have been moved + // as part of a parent suspense. get the latest anchor for insertion + _anchor = next(activeBranch); + unmount(activeBranch, parentComponent, suspense, true); + } + + if (!delayEnter) { + // move content from off-dom container to actual container + move(pendingBranch, container, _anchor, 0 + /* ENTER */ + ); + } + } + + setActiveBranch(suspense, pendingBranch); + suspense.pendingBranch = null; + suspense.isInFallback = false; // flush buffered effects + // check if there is a pending parent suspense + + var parent = suspense.parent; + var hasUnresolvedAncestor = false; + + while (parent) { + if (parent.pendingBranch) { + var _parent$effects; + + // found a pending parent suspense, merge buffered post jobs + // into that parent + (_parent$effects = parent.effects).push.apply(_parent$effects, _toConsumableArray(effects)); + + hasUnresolvedAncestor = true; + break; + } + + parent = parent.parent; + } // no pending parent suspense, flush all jobs + + + if (!hasUnresolvedAncestor) { + queuePostFlushCb(effects); + } + + suspense.effects = []; // invoke @resolve event + + triggerEvent(vnode, 'onResolve'); + }, + + fallback(fallbackVNode) { + if (!suspense.pendingBranch) { + return; + } + + var vnode = suspense.vnode, + activeBranch = suspense.activeBranch, + parentComponent = suspense.parentComponent, + container = suspense.container, + isSVG = suspense.isSVG; // invoke @fallback event + + triggerEvent(vnode, 'onFallback'); + var anchor = next(activeBranch); + + var mountFallback = function mountFallback() { + if (!suspense.isInFallback) { + return; + } // mount the fallback tree + + + patch(null, fallbackVNode, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, fallbackVNode); + }; + + var delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === 'out-in'; + + if (delayEnter) { + activeBranch.transition.afterLeave = mountFallback; + } + + suspense.isInFallback = true; // unmount current active branch + + unmount(activeBranch, parentComponent, null, // no suspense so unmount hooks fire now + true // shouldRemove + ); + + if (!delayEnter) { + mountFallback(); + } + }, + + move(container, anchor, type) { + suspense.activeBranch && move(suspense.activeBranch, container, anchor, type); + suspense.container = container; + }, + + next() { + return suspense.activeBranch && next(suspense.activeBranch); + }, + + registerDep(instance, setupRenderEffect) { + var isInPendingSuspense = !!suspense.pendingBranch; + + if (isInPendingSuspense) { + suspense.deps++; + } + + var hydratedEl = instance.vnode.el; + instance.asyncDep.catch(function (err) { + handleError(err, instance, 0 + /* SETUP_FUNCTION */ + ); + }).then(function (asyncSetupResult) { + // retry when the setup() promise resolves. + // component may have been unmounted before resolve. + if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) { + return; + } // retry from this component + + + instance.asyncResolved = true; + var vnode = instance.vnode; + + if (process.env.NODE_ENV !== 'production') { + pushWarningContext(vnode); + } + + handleSetupResult(instance, asyncSetupResult, false); + + if (hydratedEl) { + // vnode may have been replaced if an update happened before the + // async dep is resolved. + vnode.el = hydratedEl; + } + + var placeholder = !hydratedEl && instance.subTree.el; + setupRenderEffect(instance, vnode, // component may have been moved before resolve. + // if this is not a hydration, instance.subTree will be the comment + // placeholder. + parentNode(hydratedEl || instance.subTree.el), // anchor will not be used if this is hydration, so only need to + // consider the comment placeholder case. + hydratedEl ? null : next(instance.subTree), suspense, isSVG, optimized); + + if (placeholder) { + remove(placeholder); + } + + updateHOCHostEl(instance, vnode.el); + + if (process.env.NODE_ENV !== 'production') { + popWarningContext(); + } // only decrease deps count if suspense is not already resolved + + + if (isInPendingSuspense && --suspense.deps === 0) { + suspense.resolve(); + } + }); + }, + + unmount(parentSuspense, doRemove) { + suspense.isUnmounted = true; + + if (suspense.activeBranch) { + unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove); + } + + if (suspense.pendingBranch) { + unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove); + } + } + + }; + return suspense; + } + + function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) { + /* eslint-disable no-restricted-globals */ + var suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, slotScopeIds, optimized, rendererInternals, true + /* hydrating */ + ); // there are two possible scenarios for server-rendered suspense: + // - success: ssr content should be fully resolved + // - failure: ssr content should be the fallback branch. + // however, on the client we don't really know if it has failed or not + // attempt to hydrate the DOM assuming it has succeeded, but we still + // need to construct a suspense boundary first + + var result = hydrateNode(node, suspense.pendingBranch = vnode.ssContent, parentComponent, suspense, slotScopeIds, optimized); + + if (suspense.deps === 0) { + suspense.resolve(); + } + + return result; + /* eslint-enable no-restricted-globals */ + } + + function normalizeSuspenseChildren(vnode) { + var shapeFlag = vnode.shapeFlag, + children = vnode.children; + var isSlotChildren = shapeFlag & 32; + /* SLOTS_CHILDREN */ + + vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children); + vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment); + } + + function normalizeSuspenseSlot(s) { + var block; + + if (isFunction(s)) { + var isCompiledSlot = s._c; + + if (isCompiledSlot) { + // disableTracking: false + // allow block tracking for compiled slots + // (see ./componentRenderContext.ts) + s._d = false; + openBlock(); + } + + s = s(); + + if (isCompiledSlot) { + s._d = true; + block = currentBlock; + closeBlock(); + } + } + + if (isArray(s)) { + var singleChild = filterSingleRoot(s); + + if (process.env.NODE_ENV !== 'production' && !singleChild) { + warn(" slots expect a single root node."); + } + + s = singleChild; + } + + s = normalizeVNode(s); + + if (block) { + s.dynamicChildren = block.filter(function (c) { + return c !== s; + }); + } + + return s; + } + + function queueEffectWithSuspense(fn, suspense) { + if (suspense && suspense.pendingBranch) { + if (isArray(fn)) { + var _suspense$effects; + + (_suspense$effects = suspense.effects).push.apply(_suspense$effects, _toConsumableArray(fn)); + } else { + suspense.effects.push(fn); + } + } else { + queuePostFlushCb(fn); + } + } + + function setActiveBranch(suspense, branch) { + suspense.activeBranch = branch; + var vnode = suspense.vnode, + parentComponent = suspense.parentComponent; + var el = vnode.el = branch.el; // in case suspense is the root node of a component, + // recursively update the HOC el + + if (parentComponent && parentComponent.subTree === vnode) { + parentComponent.vnode.el = el; + updateHOCHostEl(parentComponent, el); + } + } + + function provide(key, value) { + if (!currentInstance) { + if (process.env.NODE_ENV !== 'production') { + warn("provide() can only be used inside setup()."); + } + } else { + var provides = currentInstance.provides; // by default an instance inherits its parent's provides object + // but when it needs to provide values of its own, it creates its + // own provides object using parent provides object as prototype. + // this way in `inject` we can simply look up injections from direct + // parent and let the prototype chain do the work. + + var parentProvides = currentInstance.parent && currentInstance.parent.provides; + + if (parentProvides === provides) { + provides = currentInstance.provides = Object.create(parentProvides); + } // TS doesn't allow symbol as index type + + + provides[key] = value; + } + } + + function inject(key, defaultValue) { + var treatDefaultAsFactory = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + // fallback to `currentRenderingInstance` so that this can be called in + // a functional component + var instance = currentInstance || currentRenderingInstance; + + if (instance) { + // #2400 + // to support `app.use` plugins, + // fallback to appContext's `provides` if the intance is at root + var provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides; + + if (provides && key in provides) { + // TS doesn't allow symbol as index type + return provides[key]; + } else if (arguments.length > 1) { + return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance.proxy) : defaultValue; + } else if (process.env.NODE_ENV !== 'production') { + warn("injection \"".concat(String(key), "\" not found.")); + } + } else if (process.env.NODE_ENV !== 'production') { + warn("inject() can only be used inside setup() or functional components."); + } + } // Simple effect. + + + function watchEffect(effect, options) { + return doWatch(effect, null, options); + } // initial value for watchers to trigger on undefined initial values + + + var INITIAL_WATCHER_VALUE = {}; // implementation + + function watch(source, cb, options) { + if (process.env.NODE_ENV !== 'production' && !isFunction(cb)) { + warn("`watch(fn, options?)` signature has been moved to a separate API. " + "Use `watchEffect(fn, options?)` instead. `watch` now only " + "supports `watch(source, cb, options?) signature."); + } + + return doWatch(source, cb, options); + } + + function doWatch(source, cb) { + var _ref8 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_OBJ, + immediate = _ref8.immediate, + deep = _ref8.deep, + flush = _ref8.flush, + onTrack = _ref8.onTrack, + onTrigger = _ref8.onTrigger; + + var instance = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : currentInstance; + + if (process.env.NODE_ENV !== 'production' && !cb) { + if (immediate !== undefined) { + warn("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature."); + } + + if (deep !== undefined) { + warn("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature."); + } + } + + var warnInvalidSource = function warnInvalidSource(s) { + warn("Invalid watch source: ", s, "A watch source can only be a getter/effect function, a ref, " + "a reactive object, or an array of these types."); + }; + + var getter; + var forceTrigger = false; + var isMultiSource = false; + + if (isRef(source)) { + getter = function getter() { + return source.value; + }; + + forceTrigger = !!source._shallow; + } else if (isReactive(source)) { + getter = function getter() { + return source; + }; + + deep = true; + } else if (isArray(source)) { + isMultiSource = true; + forceTrigger = source.some(isReactive); + + getter = function getter() { + return source.map(function (s) { + if (isRef(s)) { + return s.value; + } else if (isReactive(s)) { + return traverse(s); + } else if (isFunction(s)) { + return callWithErrorHandling(s, instance, 2 + /* WATCH_GETTER */ + ); + } else { + process.env.NODE_ENV !== 'production' && warnInvalidSource(s); + } + }); + }; + } else if (isFunction(source)) { + if (cb) { + // getter with cb + getter = function getter() { + return callWithErrorHandling(source, instance, 2 + /* WATCH_GETTER */ + ); + }; + } else { + // no cb -> simple effect + getter = function getter() { + if (instance && instance.isUnmounted) { + return; + } + + if (cleanup) { + cleanup(); + } + + return callWithAsyncErrorHandling(source, instance, 3 + /* WATCH_CALLBACK */ + , [onInvalidate]); + }; + } + } else { + getter = NOOP; + process.env.NODE_ENV !== 'production' && warnInvalidSource(source); + } + + if (cb && deep) { + var baseGetter = getter; + + getter = function getter() { + return traverse(baseGetter()); + }; + } + + var cleanup; + + var onInvalidate = function onInvalidate(fn) { + cleanup = runner.options.onStop = function () { + callWithErrorHandling(fn, instance, 4 + /* WATCH_CLEANUP */ + ); + }; + }; + + var oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE; + + var job = function job() { + if (!runner.active) { + return; + } + + if (cb) { + // watch(source, cb) + var newValue = runner(); + + if (deep || forceTrigger || (isMultiSource ? newValue.some(function (v, i) { + return hasChanged(v, oldValue[i]); + }) : hasChanged(newValue, oldValue)) || false) { + // cleanup before running cb again + if (cleanup) { + cleanup(); + } + + callWithAsyncErrorHandling(cb, instance, 3 + /* WATCH_CALLBACK */ + , [newValue, // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, onInvalidate]); + oldValue = newValue; + } + } else { + // watchEffect + runner(); + } + }; // important: mark the job as a watcher callback so that scheduler knows + // it is allowed to self-trigger (#1727) + + + job.allowRecurse = !!cb; + var scheduler; + + if (flush === 'sync') { + scheduler = job; // the scheduler function gets called directly + } else if (flush === 'post') { + scheduler = function scheduler() { + return queuePostRenderEffect(job, instance && instance.suspense); + }; + } else { + // default: 'pre' + scheduler = function scheduler() { + if (!instance || instance.isMounted) { + queuePreFlushCb(job); + } else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job(); + } + }; + } + + var runner = effect(getter, { + lazy: true, + onTrack, + 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 function () { + stop(runner); + + if (instance) { + remove(instance.effects, runner); + } + }; + } // this.$watch + + + function instanceWatch(source, value, options) { + var publicThis = this.proxy; + var getter = isString(source) ? source.includes('.') ? createPathGetter(publicThis, source) : function () { + return publicThis[source]; + } : source.bind(publicThis, publicThis); + var cb; + + if (isFunction(value)) { + cb = value; + } else { + cb = value.handler; + options = value; + } + + return doWatch(getter, cb.bind(publicThis), options, this); + } + + function createPathGetter(ctx, path) { + var segments = path.split('.'); + return function () { + var cur = ctx; + + for (var i = 0; i < segments.length && cur; i++) { + cur = cur[segments[i]]; + } + + return cur; + }; + } + + function traverse(value) { + var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set(); + + if (!isObject(value) || seen.has(value) || value['__v_skip' + /* SKIP */ + ]) { + return value; + } + + seen.add(value); + + if (isRef(value)) { + traverse(value.value, seen); + } else if (isArray(value)) { + for (var i = 0; i < value.length; i++) { + traverse(value[i], seen); + } + } else if (isSet(value) || isMap(value)) { + value.forEach(function (v) { + traverse(v, seen); + }); + } else if (isPlainObject(value)) { + for (var key in value) { + traverse(value[key], seen); + } + } + + return value; + } + + function useTransitionState() { + var state = { + isMounted: false, + isLeaving: false, + isUnmounting: false, + leavingVNodes: new Map() + }; + onMounted(function () { + state.isMounted = true; + }); + onBeforeUnmount(function () { + state.isUnmounting = true; + }); + return state; + } + + var TransitionHookValidator = [Function, Array]; + var BaseTransitionImpl = { + name: "BaseTransition", + props: { + mode: String, + appear: Boolean, + persisted: Boolean, + // enter + onBeforeEnter: TransitionHookValidator, + onEnter: TransitionHookValidator, + onAfterEnter: TransitionHookValidator, + onEnterCancelled: TransitionHookValidator, + // leave + onBeforeLeave: TransitionHookValidator, + onLeave: TransitionHookValidator, + onAfterLeave: TransitionHookValidator, + onLeaveCancelled: TransitionHookValidator, + // appear + onBeforeAppear: TransitionHookValidator, + onAppear: TransitionHookValidator, + onAfterAppear: TransitionHookValidator, + onAppearCancelled: TransitionHookValidator + }, + + setup(props, _ref9) { + var slots = _ref9.slots; + var instance = getCurrentInstance(); + var state = useTransitionState(); + var prevTransitionKey; + return function () { + var children = slots.default && getTransitionRawChildren(slots.default(), true); + + if (!children || !children.length) { + return; + } // warn multiple elements + + + if (process.env.NODE_ENV !== 'production' && children.length > 1) { + warn(' can only be used on a single element or component. Use ' + ' for lists.'); + } // there's no need to track reactivity for these props so use the raw + // props for a bit better perf + + + var rawProps = toRaw(props); + var mode = rawProps.mode; // check mode + + if (process.env.NODE_ENV !== 'production' && mode && !['in-out', 'out-in', 'default'].includes(mode)) { + warn("invalid mode: ".concat(mode)); + } // at this point children has a guaranteed length of 1. + + + var child = children[0]; + + if (state.isLeaving) { + return emptyPlaceholder(child); + } // in the case of , we need to + // compare the type of the kept-alive children. + + + var innerChild = getKeepAliveChild(child); + + if (!innerChild) { + return emptyPlaceholder(child); + } + + var enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance); + setTransitionHooks(innerChild, enterHooks); + var oldChild = instance.subTree; + var oldInnerChild = oldChild && getKeepAliveChild(oldChild); + var transitionKeyChanged = false; + var getTransitionKey = innerChild.type.getTransitionKey; + + if (getTransitionKey) { + var key = getTransitionKey(); + + if (prevTransitionKey === undefined) { + prevTransitionKey = key; + } else if (key !== prevTransitionKey) { + prevTransitionKey = key; + transitionKeyChanged = true; + } + } // handle mode + + + if (oldInnerChild && oldInnerChild.type !== Comment$1 && (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) { + var leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance); // update old tree's hooks in case of dynamic transition + + setTransitionHooks(oldInnerChild, leavingHooks); // switching between different views + + if (mode === 'out-in') { + state.isLeaving = true; // return placeholder node and queue update when leave finishes + + leavingHooks.afterLeave = function () { + state.isLeaving = false; + instance.update(); + }; + + return emptyPlaceholder(child); + } else if (mode === 'in-out' && innerChild.type !== Comment$1) { + leavingHooks.delayLeave = function (el, earlyRemove, delayedLeave) { + var leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild); + leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild; // early removal callback + + el._leaveCb = function () { + earlyRemove(); + el._leaveCb = undefined; + delete enterHooks.delayedLeave; + }; + + enterHooks.delayedLeave = delayedLeave; + }; + } + } + + return child; + }; + } + + }; // export the public type for h/tsx inference + // also to avoid inline import() in generated d.ts files + + var BaseTransition = BaseTransitionImpl; + + function getLeavingNodesForType(state, vnode) { + var leavingVNodes = state.leavingVNodes; + var leavingVNodesCache = leavingVNodes.get(vnode.type); + + if (!leavingVNodesCache) { + leavingVNodesCache = Object.create(null); + leavingVNodes.set(vnode.type, leavingVNodesCache); + } + + return leavingVNodesCache; + } // The transition hooks are attached to the vnode as vnode.transition + // and will be called at appropriate timing in the renderer. + + + function resolveTransitionHooks(vnode, props, state, instance) { + var appear = props.appear, + mode = props.mode, + _props$persisted = props.persisted, + persisted = _props$persisted === void 0 ? false : _props$persisted, + onBeforeEnter = props.onBeforeEnter, + onEnter = props.onEnter, + onAfterEnter = props.onAfterEnter, + onEnterCancelled = props.onEnterCancelled, + onBeforeLeave = props.onBeforeLeave, + onLeave = props.onLeave, + onAfterLeave = props.onAfterLeave, + onLeaveCancelled = props.onLeaveCancelled, + onBeforeAppear = props.onBeforeAppear, + onAppear = props.onAppear, + onAfterAppear = props.onAfterAppear, + onAppearCancelled = props.onAppearCancelled; + var key = String(vnode.key); + var leavingVNodesCache = getLeavingNodesForType(state, vnode); + + var callHook = function callHook(hook, args) { + hook && callWithAsyncErrorHandling(hook, instance, 9 + /* TRANSITION_HOOK */ + , args); + }; + + var hooks = { + mode, + persisted, + + beforeEnter(el) { + var hook = onBeforeEnter; + + if (!state.isMounted) { + if (appear) { + hook = onBeforeAppear || onBeforeEnter; + } else { + return; + } + } // for same element (v-show) + + + if (el._leaveCb) { + el._leaveCb(true + /* cancelled */ + ); + } // for toggled element with same key (v-if) + + + var leavingVNode = leavingVNodesCache[key]; + + if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el._leaveCb) { + // force early removal (not cancelled) + leavingVNode.el._leaveCb(); + } + + callHook(hook, [el]); + }, + + enter(el) { + var hook = onEnter; + var afterHook = onAfterEnter; + var cancelHook = onEnterCancelled; + + if (!state.isMounted) { + if (appear) { + hook = onAppear || onEnter; + afterHook = onAfterAppear || onAfterEnter; + cancelHook = onAppearCancelled || onEnterCancelled; + } else { + return; + } + } + + var called = false; + + var done = el._enterCb = function (cancelled) { + if (called) return; + called = true; + + if (cancelled) { + callHook(cancelHook, [el]); + } else { + callHook(afterHook, [el]); + } + + if (hooks.delayedLeave) { + hooks.delayedLeave(); + } + + el._enterCb = undefined; + }; + + if (hook) { + hook(el, done); + + if (hook.length <= 1) { + done(); + } + } else { + done(); + } + }, + + leave(el, remove) { + var key = String(vnode.key); + + if (el._enterCb) { + el._enterCb(true + /* cancelled */ + ); + } + + if (state.isUnmounting) { + return remove(); + } + + callHook(onBeforeLeave, [el]); + var called = false; + + var done = el._leaveCb = function (cancelled) { + if (called) return; + called = true; + remove(); + + if (cancelled) { + callHook(onLeaveCancelled, [el]); + } else { + callHook(onAfterLeave, [el]); + } + + el._leaveCb = undefined; + + if (leavingVNodesCache[key] === vnode) { + delete leavingVNodesCache[key]; + } + }; + + leavingVNodesCache[key] = vnode; + + if (onLeave) { + onLeave(el, done); + + if (onLeave.length <= 1) { + done(); + } + } else { + done(); + } + }, + + clone(vnode) { + return resolveTransitionHooks(vnode, props, state, instance); + } + + }; + return hooks; + } // the placeholder really only handles one special case: KeepAlive + // in the case of a KeepAlive in a leave phase we need to return a KeepAlive + // placeholder with empty content to avoid the KeepAlive instance from being + // unmounted. + + + function emptyPlaceholder(vnode) { + if (isKeepAlive(vnode)) { + vnode = cloneVNode(vnode); + vnode.children = null; + return vnode; + } + } + + function getKeepAliveChild(vnode) { + return isKeepAlive(vnode) ? vnode.children ? vnode.children[0] : undefined : vnode; + } + + function setTransitionHooks(vnode, hooks) { + if (vnode.shapeFlag & 6 + /* COMPONENT */ + && vnode.component) { + setTransitionHooks(vnode.component.subTree, hooks); + } else if (vnode.shapeFlag & 128 + /* SUSPENSE */ + ) { + vnode.ssContent.transition = hooks.clone(vnode.ssContent); + vnode.ssFallback.transition = hooks.clone(vnode.ssFallback); + } else { + vnode.transition = hooks; + } + } + + function getTransitionRawChildren(children) { + var keepComment = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var ret = []; + var keyedFragmentCount = 0; + + for (var i = 0; i < children.length; i++) { + var child = children[i]; // handle fragment children case, e.g. v-for + + if (child.type === Fragment) { + if (child.patchFlag & 128 + /* KEYED_FRAGMENT */ + ) keyedFragmentCount++; + ret = ret.concat(getTransitionRawChildren(child.children, keepComment)); + } // comment placeholders should be skipped, e.g. v-if + else if (keepComment || child.type !== Comment$1) { + ret.push(child); + } + } // #1126 if a transition children list contains multiple sub fragments, these + // fragments will be merged into a flat children array. Since each v-for + // fragment may contain different static bindings inside, we need to de-op + // these children to force full diffs to ensure correct behavior. + + + if (keyedFragmentCount > 1) { + for (var _i2 = 0; _i2 < ret.length; _i2++) { + ret[_i2].patchFlag = -2; + /* BAIL */ + } + } + + return ret; + } // implementation, close to no-op + + + function defineComponent(options) { + return isFunction(options) ? { + setup: options, + name: options.name + } : options; + } + + var isAsyncWrapper = function isAsyncWrapper(i) { + return !!i.type.__asyncLoader; + }; + + function defineAsyncComponent(source) { + if (isFunction(source)) { + source = { + loader: source + }; + } + + var _source = source, + loader = _source.loader, + loadingComponent = _source.loadingComponent, + errorComponent = _source.errorComponent, + _source$delay = _source.delay, + delay = _source$delay === void 0 ? 200 : _source$delay, + timeout = _source.timeout, + _source$suspensible = _source.suspensible, + suspensible = _source$suspensible === void 0 ? true : _source$suspensible, + userOnError = _source.onError; + var pendingRequest = null; + var resolvedComp; + var retries = 0; + + var retry = function retry() { + retries++; + pendingRequest = null; + return load(); + }; + + var load = function load() { + var thisRequest; + return pendingRequest || (thisRequest = pendingRequest = loader().catch(function (err) { + err = err instanceof Error ? err : new Error(String(err)); + + if (userOnError) { + return new Promise(function (resolve, reject) { + var userRetry = function userRetry() { + return resolve(retry()); + }; + + var userFail = function userFail() { + return reject(err); + }; + + userOnError(err, userRetry, userFail, retries + 1); + }); + } else { + throw err; + } + }).then(function (comp) { + if (thisRequest !== pendingRequest && pendingRequest) { + return pendingRequest; + } + + if (process.env.NODE_ENV !== 'production' && !comp) { + warn("Async component loader resolved to undefined. " + "If you are using retry(), make sure to return its return value."); + } // interop module default + + + if (comp && (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) { + comp = comp.default; + } + + if (process.env.NODE_ENV !== 'production' && comp && !isObject(comp) && !isFunction(comp)) { + throw new Error("Invalid async component load result: ".concat(comp)); + } + + resolvedComp = comp; + return comp; + })); + }; + + return defineComponent({ + name: 'AsyncComponentWrapper', + __asyncLoader: load, + + get __asyncResolved() { + return resolvedComp; + }, + + setup() { + var instance = currentInstance; // already resolved + + if (resolvedComp) { + return function () { + return createInnerComp(resolvedComp, instance); + }; + } + + var onError = function onError(err) { + pendingRequest = null; + handleError(err, instance, 13 + /* ASYNC_COMPONENT_LOADER */ + , !errorComponent + /* do not throw in dev if user provided error component */ + ); + }; // suspense-controlled or SSR. + + + if (suspensible && instance.suspense || false) { + return load().then(function (comp) { + return function () { + return createInnerComp(comp, instance); + }; + }).catch(function (err) { + onError(err); + return function () { + return errorComponent ? createVNode(errorComponent, { + error: err + }) : null; + }; + }); + } + + var loaded = ref(false); + var error = ref(); + var delayed = ref(!!delay); + + if (delay) { + setTimeout(function () { + delayed.value = false; + }, delay); + } + + if (timeout != null) { + setTimeout(function () { + if (!loaded.value && !error.value) { + var err = new Error("Async component timed out after ".concat(timeout, "ms.")); + onError(err); + error.value = err; + } + }, timeout); + } + + load().then(function () { + loaded.value = true; + + if (instance.parent && isKeepAlive(instance.parent.vnode)) { + // parent is keep-alive, force update so the loaded component's + // name is taken into account + queueJob(instance.parent.update); + } + }).catch(function (err) { + onError(err); + error.value = err; + }); + return function () { + if (loaded.value && resolvedComp) { + return createInnerComp(resolvedComp, instance); + } else if (error.value && errorComponent) { + return createVNode(errorComponent, { + error: error.value + }); + } else if (loadingComponent && !delayed.value) { + return createVNode(loadingComponent); + } + }; + } + + }); + } + + function createInnerComp(comp, _ref10) { + var _ref10$vnode = _ref10.vnode, + ref = _ref10$vnode.ref, + props = _ref10$vnode.props, + children = _ref10$vnode.children; + var vnode = createVNode(comp, props, children); // ensure inner component inherits the async wrapper's ref owner + + vnode.ref = ref; + return vnode; + } + + var isKeepAlive = function isKeepAlive(vnode) { + return vnode.type.__isKeepAlive; + }; + + var KeepAliveImpl = { + name: "KeepAlive", + // Marker for special handling inside the renderer. We are not using a === + // check directly on KeepAlive in the renderer, because importing it directly + // would prevent it from being tree-shaken. + __isKeepAlive: true, + props: { + include: [String, RegExp, Array], + exclude: [String, RegExp, Array], + max: [String, Number] + }, + + setup(props, _ref11) { + var slots = _ref11.slots; + var instance = getCurrentInstance(); // KeepAlive communicates with the instantiated renderer via the + // ctx where the renderer passes in its internals, + // and the KeepAlive instance exposes activate/deactivate implementations. + // The whole point of this is to avoid importing KeepAlive directly in the + // renderer to facilitate tree-shaking. + + var sharedContext = instance.ctx; // if the internal renderer is not registered, it indicates that this is server-side rendering, + // for KeepAlive, we just need to render its children + + if (!sharedContext.renderer) { + return slots.default; + } + + var cache = new Map(); + var keys = new Set(); + var current = null; + + if (process.env.NODE_ENV !== 'production' || false) { + instance.__v_cache = cache; + } + + var parentSuspense = instance.suspense; + var _sharedContext$render = sharedContext.renderer, + patch = _sharedContext$render.p, + move = _sharedContext$render.m, + _unmount = _sharedContext$render.um, + createElement = _sharedContext$render.o.createElement; + var storageContainer = createElement('div', null); // fixed by xxxxx + + sharedContext.activate = function (vnode, container, anchor, isSVG, optimized) { + var instance = vnode.component; + move(vnode, container, anchor, 0 + /* ENTER */ + , parentSuspense); // in case props have changed + + patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, vnode.slotScopeIds, optimized); + queuePostRenderEffect(function () { + instance.isDeactivated = false; + + if (instance.a) { + invokeArrayFns(instance.a); + } + + var vnodeHook = vnode.props && vnode.props.onVnodeMounted; + + if (vnodeHook) { + invokeVNodeHook(vnodeHook, instance.parent, vnode); + } + }, parentSuspense); + + if (process.env.NODE_ENV !== 'production' || false) { + // Update components tree + devtoolsComponentAdded(instance); + } + }; + + sharedContext.deactivate = function (vnode) { + var instance = vnode.component; + move(vnode, storageContainer, null, 1 + /* LEAVE */ + , parentSuspense); + queuePostRenderEffect(function () { + if (instance.da) { + invokeArrayFns(instance.da); + } + + var vnodeHook = vnode.props && vnode.props.onVnodeUnmounted; + + if (vnodeHook) { + invokeVNodeHook(vnodeHook, instance.parent, vnode); + } + + instance.isDeactivated = true; + }, parentSuspense); + + if (process.env.NODE_ENV !== 'production' || false) { + // Update components tree + devtoolsComponentAdded(instance); + } + }; + + function unmount(vnode) { + // reset the shapeFlag so it can be properly unmounted + resetShapeFlag(vnode); + + _unmount(vnode, instance, parentSuspense); + } + + function pruneCache(filter) { + cache.forEach(function (vnode, key) { + var name = getComponentName(vnode.type); + + if (name && (!filter || !filter(name))) { + pruneCacheEntry(key); + } + }); + } + + function pruneCacheEntry(key) { + var cached = cache.get(key); + + if (!current || cached.type !== current.type) { + unmount(cached); + } else if (current) { + // current active instance should no longer be kept-alive. + // we can't unmount it now but it might be later, so reset its flag now. + resetShapeFlag(current); + } + + cache.delete(key); + keys.delete(key); + } // prune cache on include/exclude prop change + + + watch(function () { + return [props.include, props.exclude]; + }, function (_ref12) { + var _ref13 = _slicedToArray(_ref12, 2), + include = _ref13[0], + exclude = _ref13[1]; + + include && pruneCache(function (name) { + return matches(include, name); + }); + exclude && pruneCache(function (name) { + return !matches(exclude, name); + }); + }, // prune post-render after `current` has been updated + { + flush: 'post', + deep: true + }); // cache sub tree after render + + var pendingCacheKey = null; + + var cacheSubtree = function cacheSubtree() { + // fix #1621, the pendingCacheKey could be 0 + if (pendingCacheKey != null) { + cache.set(pendingCacheKey, getInnerChild(instance.subTree)); + } + }; + + onMounted(cacheSubtree); + onUpdated(cacheSubtree); + onBeforeUnmount(function () { + cache.forEach(function (cached) { + var subTree = instance.subTree, + suspense = instance.suspense; + var vnode = getInnerChild(subTree); + + if (cached.type === vnode.type) { + // current instance will be unmounted as part of keep-alive's unmount + resetShapeFlag(vnode); // but invoke its deactivated hook here + + var da = vnode.component.da; + da && queuePostRenderEffect(da, suspense); + return; + } + + unmount(cached); + }); + }); + return function () { + pendingCacheKey = null; + + if (!slots.default) { + return null; + } + + var children = slots.default(); + var rawVNode = children[0]; + + if (children.length > 1) { + if (process.env.NODE_ENV !== 'production') { + warn("KeepAlive should contain exactly one component child."); + } + + current = null; + return children; + } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) { + current = null; + return rawVNode; + } + + var vnode = getInnerChild(rawVNode); + var comp = vnode.type; // for async components, name check should be based in its loaded + // inner component if available + + var name = getComponentName(isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp); + var include = props.include, + exclude = props.exclude, + max = props.max; + + if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) { + current = vnode; + return rawVNode; + } + + var key = vnode.key == null ? comp : vnode.key; + var cachedVNode = cache.get(key); // clone vnode if it's reused because we are going to mutate it + + if (vnode.el) { + vnode = cloneVNode(vnode); + + if (rawVNode.shapeFlag & 128 + /* SUSPENSE */ + ) { + rawVNode.ssContent = vnode; + } + } // #1513 it's possible for the returned vnode to be cloned due to attr + // fallthrough or scopeId, so the vnode here may not be the final vnode + // that is mounted. Instead of caching it directly, we store the pending + // key and cache `instance.subTree` (the normalized vnode) in + // beforeMount/beforeUpdate hooks. + + + pendingCacheKey = key; + + if (cachedVNode) { + // copy over mounted state + vnode.el = cachedVNode.el; + vnode.component = cachedVNode.component; + + if (vnode.transition) { + // recursively update transition hooks on subTree + setTransitionHooks(vnode, vnode.transition); + } // avoid vnode being mounted as fresh + + + vnode.shapeFlag |= 512; + /* COMPONENT_KEPT_ALIVE */ + // make this key the freshest + + keys.delete(key); + keys.add(key); + } else { + keys.add(key); // prune oldest entry + + if (max && keys.size > parseInt(max, 10)) { + pruneCacheEntry(keys.values().next().value); + } + } // avoid vnode being unmounted + + + vnode.shapeFlag |= 256; + /* COMPONENT_SHOULD_KEEP_ALIVE */ + + current = vnode; + return rawVNode; + }; + } + + }; // export the public type for h/tsx inference + // also to avoid inline import() in generated d.ts files + + var KeepAlive = KeepAliveImpl; + + function matches(pattern, name) { + if (isArray(pattern)) { + return pattern.some(function (p) { + return matches(p, name); + }); + } else if (isString(pattern)) { + return pattern.split(',').indexOf(name) > -1; + } else if (pattern.test) { + return pattern.test(name); + } + /* istanbul ignore next */ + + + return false; + } + + function onActivated(hook, target) { + registerKeepAliveHook(hook, 'a' + /* ACTIVATED */ + , target); + } + + function onDeactivated(hook, target) { + registerKeepAliveHook(hook, 'da' + /* DEACTIVATED */ + , target); + } + + function registerKeepAliveHook(hook, type) { + var target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : currentInstance; + + // cache the deactivate branch check wrapper for injected hooks so the same + // hook can be properly deduped by the scheduler. "__wdc" stands for "with + // deactivation check". + var wrappedHook = hook.__wdc || (hook.__wdc = function () { + // only fire the hook if the target instance is NOT in a deactivated branch. + var current = target; + + while (current) { + if (current.isDeactivated) { + return; + } + + current = current.parent; + } + + hook(); + }); + + injectHook(type, wrappedHook, target); // In addition to registering it on the target instance, we walk up the parent + // chain and register it on all ancestor instances that are keep-alive roots. + // This avoids the need to walk the entire component tree when invoking these + // hooks, and more importantly, avoids the need to track child components in + // arrays. + + if (target) { + var current = target.parent; + + while (current && current.parent) { + if (isKeepAlive(current.parent.vnode)) { + injectToKeepAliveRoot(wrappedHook, type, target, current); + } + + current = current.parent; + } + } + } + + function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { + // injectHook wraps the original for error handling, so make sure to remove + // the wrapped version. + var injected = injectHook(type, hook, keepAliveRoot, true + /* prepend */ + ); + onUnmounted(function () { + remove(keepAliveRoot[type], injected); + }, target); + } + + function resetShapeFlag(vnode) { + var shapeFlag = vnode.shapeFlag; + + if (shapeFlag & 256 + /* COMPONENT_SHOULD_KEEP_ALIVE */ + ) { + shapeFlag -= 256; + /* COMPONENT_SHOULD_KEEP_ALIVE */ + } + + if (shapeFlag & 512 + /* COMPONENT_KEPT_ALIVE */ + ) { + shapeFlag -= 512; + /* COMPONENT_KEPT_ALIVE */ + } + + vnode.shapeFlag = shapeFlag; + } + + function getInnerChild(vnode) { + return vnode.shapeFlag & 128 + /* SUSPENSE */ + ? vnode.ssContent : vnode; + } + + function injectHook(type, hook) { + var target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : currentInstance; + var prepend = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + + if (target) { + var hooks = target[type] || (target[type] = []); // cache the error handling wrapper for injected hooks so the same hook + // can be properly deduped by the scheduler. "__weh" stands for "with error + // handling". + + var wrappedHook = hook.__weh || (hook.__weh = function () { + if (target.isUnmounted) { + return; + } // disable tracking inside all lifecycle hooks + // since they can potentially be called inside effects. + + + pauseTracking(); // Set currentInstance during hook invocation. + // This assumes the hook does not synchronously trigger other hooks, which + // can only be false when the user does something really funky. + + setCurrentInstance(target); + + for (var _len5 = arguments.length, args = new Array(_len5), _key6 = 0; _key6 < _len5; _key6++) { + args[_key6] = arguments[_key6]; + } + + var res = callWithAsyncErrorHandling(hook, target, type, args); + setCurrentInstance(null); + resetTracking(); + return res; + }); + + if (prepend) { + hooks.unshift(wrappedHook); + } else { + hooks.push(wrappedHook); + } + + return wrappedHook; + } else if (process.env.NODE_ENV !== 'production') { + var apiName = toHandlerKey(ErrorTypeStrings[type].replace(/ hook$/, '')); + warn("".concat(apiName, " is called when there is no active component instance to be ") + "associated with. " + "Lifecycle injection APIs can only be used during execution of setup()." + (" If you are using async setup(), make sure to register lifecycle " + "hooks before the first await statement.")); + } + } + + var createHook = function createHook(lifecycle) { + return function (hook) { + var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance; + return (// post-create lifecycle registrations are noops during SSR (except for serverPrefetch) + (!isInSSRComponentSetup || lifecycle === 'sp') && + /* SERVER_PREFETCH */ + injectHook(lifecycle, hook, target) + ); + }; + }; + + var onBeforeMount = createHook('bm' + /* BEFORE_MOUNT */ + ); + var onMounted = createHook('m' + /* MOUNTED */ + ); + var onBeforeUpdate = createHook('bu' + /* BEFORE_UPDATE */ + ); + var onUpdated = createHook('u' + /* UPDATED */ + ); + var onBeforeUnmount = createHook('bum' + /* BEFORE_UNMOUNT */ + ); + var onUnmounted = createHook('um' + /* UNMOUNTED */ + ); + var onServerPrefetch = createHook('sp' + /* SERVER_PREFETCH */ + ); + var onRenderTriggered = createHook('rtg' + /* RENDER_TRIGGERED */ + ); + var onRenderTracked = createHook('rtc' + /* RENDER_TRACKED */ + ); + + function onErrorCaptured(hook) { + var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance; + injectHook('ec' + /* ERROR_CAPTURED */ + , hook, target); + } + + function createDuplicateChecker() { + var cache = Object.create(null); + return function (type, key) { + if (cache[key]) { + warn("".concat(type, " property \"").concat(key, "\" is already defined in ").concat(cache[key], ".")); + } else { + cache[key] = type; + } + }; + } + + var shouldCacheAccess = true; + + function applyOptions(instance) { + var options = resolveMergedOptions(instance); + var publicThis = instance.proxy; + var ctx = instance.ctx; // fixed by xxxxxx + + var customApplyOptions = instance.appContext.config.globalProperties.$applyOptions; + + if (customApplyOptions) { + customApplyOptions(options, instance, publicThis); + } // do not cache property access on public proxy during state initialization + + + shouldCacheAccess = false; // call beforeCreate first before accessing other options since + // the hook may mutate resolved options (#2791) + + if (options.beforeCreate) { + callHook(options.beforeCreate, instance, 'bc' + /* BEFORE_CREATE */ + ); + } + + var dataOptions = options.data, + computedOptions = options.computed, + methods = options.methods, + watchOptions = options.watch, + provideOptions = options.provide, + injectOptions = options.inject, + created = options.created, + beforeMount = options.beforeMount, + mounted = options.mounted, + beforeUpdate = options.beforeUpdate, + updated = options.updated, + activated = options.activated, + deactivated = options.deactivated, + beforeDestroy = options.beforeDestroy, + beforeUnmount = options.beforeUnmount, + destroyed = options.destroyed, + unmounted = options.unmounted, + render = options.render, + renderTracked = options.renderTracked, + renderTriggered = options.renderTriggered, + errorCaptured = options.errorCaptured, + serverPrefetch = options.serverPrefetch, + expose = options.expose, + inheritAttrs = options.inheritAttrs, + components = options.components, + directives = options.directives, + filters = options.filters; + var checkDuplicateProperties = process.env.NODE_ENV !== 'production' ? createDuplicateChecker() : null; + + if (process.env.NODE_ENV !== 'production') { + var _instance$propsOption3 = _slicedToArray(instance.propsOptions, 1), + propsOptions = _instance$propsOption3[0]; + + if (propsOptions) { + for (var key in propsOptions) { + checkDuplicateProperties('Props' + /* PROPS */ + , key); + } + } + } // options initialization order (to be consistent with Vue 2): + // - props (already done outside of this function) + // - inject + // - methods + // - data (deferred since it relies on `this` access) + // - computed + // - watch (deferred since it relies on `this` access) + + + if (injectOptions) { + resolveInjections(injectOptions, ctx, checkDuplicateProperties); + } + + if (methods) { + for (var _key7 in methods) { + var methodHandler = methods[_key7]; + + if (isFunction(methodHandler)) { + // In dev mode, we use the `createRenderContext` function to define methods to the proxy target, + // and those are read-only but reconfigurable, so it needs to be redefined here + if (process.env.NODE_ENV !== 'production') { + Object.defineProperty(ctx, _key7, { + value: methodHandler.bind(publicThis), + configurable: true, + enumerable: true, + writable: true + }); + } else { + ctx[_key7] = methodHandler.bind(publicThis); + } + + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Methods' + /* METHODS */ + , _key7); + } + } else if (process.env.NODE_ENV !== 'production') { + warn("Method \"".concat(_key7, "\" has type \"").concat(typeof methodHandler, "\" in the component definition. ") + "Did you reference the function correctly?"); + } + } + } + + if (dataOptions) { + (function () { + if (process.env.NODE_ENV !== 'production' && !isFunction(dataOptions)) { + warn("The data option must be a function. " + "Plain object usage is no longer supported."); + } + + var data = dataOptions.call(publicThis, publicThis); + + if (process.env.NODE_ENV !== 'production' && isPromise(data)) { + warn("data() returned a Promise - note data() cannot be async; If you " + "intend to perform data fetching before component renders, use " + "async setup() + ."); + } + + if (!isObject(data)) { + process.env.NODE_ENV !== 'production' && warn("data() should return an object."); + } else { + instance.data = reactive(data); + + if (process.env.NODE_ENV !== 'production') { + var _loop = function _loop(_key8) { + checkDuplicateProperties('Data' + /* DATA */ + , _key8); // expose data on ctx during dev + + if (_key8[0] !== '$' && _key8[0] !== '_') { + Object.defineProperty(ctx, _key8, { + configurable: true, + enumerable: true, + get: function get() { + return data[_key8]; + }, + set: NOOP + }); + } + }; + + for (var _key8 in data) { + _loop(_key8); + } + } + } + })(); + } // state initialization complete at this point - start caching access + + + shouldCacheAccess = true; + + if (computedOptions) { + var _loop2 = function _loop2(_key9) { + var opt = computedOptions[_key9]; + var get = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP; + + if (process.env.NODE_ENV !== 'production' && get === NOOP) { + warn("Computed property \"".concat(_key9, "\" has no getter.")); + } + + var set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : process.env.NODE_ENV !== 'production' ? function () { + warn("Write operation failed: computed property \"".concat(_key9, "\" is readonly.")); + } : NOOP; + var c = computed$1({ + get, + set + }); + Object.defineProperty(ctx, _key9, { + enumerable: true, + configurable: true, + get: function get() { + return c.value; + }, + set: function set(v) { + return c.value = v; + } + }); + + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Computed' + /* COMPUTED */ + , _key9); + } + }; + + for (var _key9 in computedOptions) { + _loop2(_key9); + } + } + + if (watchOptions) { + for (var _key10 in watchOptions) { + createWatcher(watchOptions[_key10], ctx, publicThis, _key10); + } + } + + if (provideOptions) { + var provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions; + Reflect.ownKeys(provides).forEach(function (key) { + provide(key, provides[key]); + }); + } + + if (created) { + callHook(created, instance, 'c' + /* CREATED */ + ); + } + + function registerLifecycleHook(register, hook) { + if (isArray(hook)) { + hook.forEach(function (_hook) { + return register(_hook.bind(publicThis)); + }); + } else if (hook) { + register(hook.bind(publicThis)); + } + } + + registerLifecycleHook(onBeforeMount, beforeMount); + registerLifecycleHook(onMounted, mounted); + registerLifecycleHook(onBeforeUpdate, beforeUpdate); + registerLifecycleHook(onUpdated, updated); + registerLifecycleHook(onActivated, activated); + registerLifecycleHook(onDeactivated, deactivated); + registerLifecycleHook(onErrorCaptured, errorCaptured); + registerLifecycleHook(onRenderTracked, renderTracked); + registerLifecycleHook(onRenderTriggered, renderTriggered); + registerLifecycleHook(onBeforeUnmount, beforeUnmount); + registerLifecycleHook(onUnmounted, unmounted); + registerLifecycleHook(onServerPrefetch, serverPrefetch); + + if (isArray(expose)) { + if (expose.length) { + var exposed = instance.exposed || (instance.exposed = {}); + expose.forEach(function (key) { + Object.defineProperty(exposed, key, { + get: function get() { + return publicThis[key]; + }, + set: function set(val) { + return publicThis[key] = val; + } + }); + }); + } else if (!instance.exposed) { + instance.exposed = {}; + } + } // options that are handled when creating the instance but also need to be + // applied from mixins + + + if (render && instance.render === NOOP) { + instance.render = render; + } + + if (inheritAttrs != null) { + instance.inheritAttrs = inheritAttrs; + } // asset options. + + + if (components) instance.components = components; + if (directives) instance.directives = directives; + } + + function resolveInjections(injectOptions, ctx) { + var checkDuplicateProperties = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : NOOP; + + if (isArray(injectOptions)) { + injectOptions = normalizeInject(injectOptions); + } + + for (var key in injectOptions) { + var opt = injectOptions[key]; + + if (isObject(opt)) { + if ('default' in opt) { + ctx[key] = inject(opt.from || key, opt.default, true + /* treat default function as factory */ + ); + } else { + ctx[key] = inject(opt.from || key); + } + } else { + ctx[key] = inject(opt); + } + + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Inject' + /* INJECT */ + , key); + } + } + } + + function callHook(hook, instance, type) { + callWithAsyncErrorHandling(isArray(hook) ? hook.map(function (h) { + return h.bind(instance.proxy); + }) : hook.bind(instance.proxy), instance, type); + } + + function createWatcher(raw, ctx, publicThis, key) { + var getter = key.includes('.') ? createPathGetter(publicThis, key) : function () { + return publicThis[key]; + }; + + if (isString(raw)) { + var handler = ctx[raw]; + + if (isFunction(handler)) { + watch(getter, handler); + } else if (process.env.NODE_ENV !== 'production') { + warn("Invalid watch handler specified by key \"".concat(raw, "\""), handler); + } + } else if (isFunction(raw)) { + watch(getter, raw.bind(publicThis)); + } else if (isObject(raw)) { + if (isArray(raw)) { + raw.forEach(function (r) { + return createWatcher(r, ctx, publicThis, key); + }); + } else { + var _handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler]; + + if (isFunction(_handler)) { + watch(getter, _handler, raw); + } else if (process.env.NODE_ENV !== 'production') { + warn("Invalid watch handler specified by key \"".concat(raw.handler, "\""), _handler); + } + } + } else if (process.env.NODE_ENV !== 'production') { + warn("Invalid watch option: \"".concat(key, "\""), raw); + } + } + /** + * Resolve merged options and cache it on the component. + * This is done only once per-component since the merging does not involve + * instances. + */ + + + function resolveMergedOptions(instance) { + var base = instance.type; + var mixins = base.mixins, + extendsOptions = base.extends; + var _instance$appContext = instance.appContext, + globalMixins = _instance$appContext.mixins, + cache = _instance$appContext.optionsCache, + optionMergeStrategies = _instance$appContext.config.optionMergeStrategies; + var cached = cache.get(base); + var resolved; + + if (cached) { + resolved = cached; + } else if (!globalMixins.length && !mixins && !extendsOptions) { + { + resolved = base; + } + } else { + resolved = {}; + + if (globalMixins.length) { + globalMixins.forEach(function (m) { + return mergeOptions(resolved, m, optionMergeStrategies, true); + }); + } + + mergeOptions(resolved, base, optionMergeStrategies); + } + + cache.set(base, resolved); + return resolved; + } + + function mergeOptions(to, from, strats) { + var asMixin = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + var mixins = from.mixins, + extendsOptions = from.extends; + + if (extendsOptions) { + mergeOptions(to, extendsOptions, strats, true); + } + + if (mixins) { + mixins.forEach(function (m) { + return mergeOptions(to, m, strats, true); + }); + } + + for (var key in from) { + if (asMixin && key === 'expose') { + process.env.NODE_ENV !== 'production' && warn("\"expose\" option is ignored when declared in mixins or extends. " + "It should only be declared in the base component itself."); + } else { + var strat = internalOptionMergeStrats[key] || strats && strats[key]; + to[key] = strat ? strat(to[key], from[key]) : from[key]; + } + } + + return to; + } + + var internalOptionMergeStrats = { + data: mergeDataFn, + props: mergeObjectOptions, + emits: mergeObjectOptions, + // objects + methods: mergeObjectOptions, + computed: mergeObjectOptions, + // lifecycle + beforeCreate: mergeAsArray, + created: mergeAsArray, + beforeMount: mergeAsArray, + mounted: mergeAsArray, + beforeUpdate: mergeAsArray, + updated: mergeAsArray, + beforeDestroy: mergeAsArray, + destroyed: mergeAsArray, + activated: mergeAsArray, + deactivated: mergeAsArray, + errorCaptured: mergeAsArray, + serverPrefetch: mergeAsArray, + // assets + components: mergeObjectOptions, + directives: mergeObjectOptions, + // watch + watch: mergeWatchOptions, + // provide / inject + provide: mergeDataFn, + inject: mergeInject + }; + + function mergeDataFn(to, from) { + if (!from) { + return to; + } + + if (!to) { + return from; + } + + return function mergedDataFn() { + return extend(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from); + }; + } + + function mergeInject(to, from) { + return mergeObjectOptions(normalizeInject(to), normalizeInject(from)); + } + + function normalizeInject(raw) { + if (isArray(raw)) { + var res = {}; + + for (var i = 0; i < raw.length; i++) { + res[raw[i]] = raw[i]; + } + + return res; + } + + return raw; + } + + function mergeAsArray(to, from) { + return to ? _toConsumableArray(new Set([].concat(to, from))) : from; + } + + function mergeObjectOptions(to, from) { + return to ? extend(extend(Object.create(null), to), from) : from; + } + + function mergeWatchOptions(to, from) { + if (!to) return from; + if (!from) return to; + var merged = extend(Object.create(null), to); + + for (var key in from) { + merged[key] = mergeAsArray(to[key], from[key]); + } + + return merged; + } + + function initProps(instance, rawProps, isStateful) { + var isSSR = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + var props = {}; + var attrs = {}; + def(attrs, InternalObjectKey, 1); + instance.propsDefaults = Object.create(null); + setFullProps(instance, rawProps, props, attrs); // ensure all declared prop keys are present + + for (var key in instance.propsOptions[0]) { + if (!(key in props)) { + props[key] = undefined; + } + } // validation + + + if (process.env.NODE_ENV !== 'production') { + validateProps(rawProps || {}, props, instance); + } + + if (isStateful) { + // stateful + instance.props = isSSR ? props : shallowReactive(props); + } else { + if (!instance.type.props) { + // functional w/ optional props, props === attrs + instance.props = attrs; + } else { + // functional w/ declared props + instance.props = props; + } + } + + instance.attrs = attrs; + } + + function updateProps(instance, rawProps, rawPrevProps, optimized) { + var props = instance.props, + attrs = instance.attrs, + patchFlag = instance.vnode.patchFlag; + var rawCurrentProps = toRaw(props); + + var _instance$propsOption4 = _slicedToArray(instance.propsOptions, 1), + options = _instance$propsOption4[0]; + + var hasAttrsChanged = false; + + if ( // always force full diff in dev + // - #1942 if hmr is enabled with sfc component + // - vite#872 non-sfc component used by sfc component + !(process.env.NODE_ENV !== 'production' && (instance.type.__hmrId || instance.parent && instance.parent.type.__hmrId)) && (optimized || patchFlag > 0) && !(patchFlag & 16)) { + if (patchFlag & 8 + /* PROPS */ + ) { + // Compiler-generated props & no keys change, just set the updated + // the props. + var propsToUpdate = instance.vnode.dynamicProps; + + for (var i = 0; i < propsToUpdate.length; i++) { + var key = propsToUpdate[i]; // PROPS flag guarantees rawProps to be non-null + + var value = rawProps[key]; + + if (options) { + // attr / props separation was done on init and will be consistent + // in this code path, so just check if attrs have it. + if (hasOwn(attrs, key)) { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } else { + var camelizedKey = camelize(key); + props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false + /* isAbsent */ + ); + } + } else { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + } + } + } else { + // full props update. + if (setFullProps(instance, rawProps, props, attrs)) { + hasAttrsChanged = true; + } // in case of dynamic props, check if we need to delete keys from + // the props object + + + var kebabKey; + + for (var _key11 in rawCurrentProps) { + if (!rawProps || // for camelCase + !hasOwn(rawProps, _key11) && ( // it's possible the original props was passed in as kebab-case + // and converted to camelCase (#955) + (kebabKey = hyphenate(_key11)) === _key11 || !hasOwn(rawProps, kebabKey))) { + if (options) { + if (rawPrevProps && ( // for camelCase + rawPrevProps[_key11] !== undefined || // for kebab-case + rawPrevProps[kebabKey] !== undefined)) { + props[_key11] = resolvePropValue(options, rawCurrentProps, _key11, undefined, instance, true + /* isAbsent */ + ); + } + } else { + delete props[_key11]; + } + } + } // in the case of functional component w/o props declaration, props and + // attrs point to the same object so it should already have been updated. + + + if (attrs !== rawCurrentProps) { + for (var _key12 in attrs) { + if (!rawProps || !hasOwn(rawProps, _key12)) { + delete attrs[_key12]; + hasAttrsChanged = true; + } + } + } + } // trigger updates for $attrs in case it's used in component slots + + + if (hasAttrsChanged) { + trigger(instance, 'set' + /* SET */ + , '$attrs'); + } + + if (process.env.NODE_ENV !== 'production') { + validateProps(rawProps || {}, props, instance); + } + } + + function setFullProps(instance, rawProps, props, attrs) { + var _instance$propsOption5 = _slicedToArray(instance.propsOptions, 2), + options = _instance$propsOption5[0], + needCastKeys = _instance$propsOption5[1]; + + var hasAttrsChanged = false; + var rawCastValues; + + if (rawProps) { + for (var key in rawProps) { + // key, ref are reserved and never passed down + if (isReservedProp(key)) { + continue; + } + + var value = rawProps[key]; // prop option names are camelized during normalization, so to support + // kebab -> camel conversion here we need to camelize the key. + + var camelKey = void 0; + + if (options && hasOwn(options, camelKey = camelize(key))) { + if (!needCastKeys || !needCastKeys.includes(camelKey)) { + props[camelKey] = value; + } else { + (rawCastValues || (rawCastValues = {}))[camelKey] = value; + } + } else if (!isEmitListener(instance.emitsOptions, key)) { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + } + } + + if (needCastKeys) { + var rawCurrentProps = toRaw(props); + var castValues = rawCastValues || EMPTY_OBJ; + + for (var i = 0; i < needCastKeys.length; i++) { + var _key13 = needCastKeys[i]; + props[_key13] = resolvePropValue(options, rawCurrentProps, _key13, castValues[_key13], instance, !hasOwn(castValues, _key13)); + } + } + + return hasAttrsChanged; + } + + function resolvePropValue(options, props, key, value, instance, isAbsent) { + var opt = options[key]; + + if (opt != null) { + var hasDefault = hasOwn(opt, 'default'); // default values + + if (hasDefault && value === undefined) { + var defaultValue = opt.default; + + if (opt.type !== Function && isFunction(defaultValue)) { + var propsDefaults = instance.propsDefaults; + + if (key in propsDefaults) { + value = propsDefaults[key]; + } else { + setCurrentInstance(instance); + value = propsDefaults[key] = defaultValue.call(null, props); + setCurrentInstance(null); + } + } else { + value = defaultValue; + } + } // boolean casting + + + if (opt[0 + /* shouldCast */ + ]) { + if (isAbsent && !hasDefault) { + value = false; + } else if (opt[1 + /* shouldCastTrue */ + ] && (value === '' || value === hyphenate(key))) { + value = true; + } + } + } + + return value; + } + + function normalizePropsOptions(comp, appContext) { + var asMixin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var cache = appContext.propsCache; + var cached = cache.get(comp); + + if (cached) { + return cached; + } + + var raw = comp.props; + var normalized = {}; + var needCastKeys = []; // apply mixin/extends props + + var hasExtends = false; + + if (!isFunction(comp)) { + var extendProps = function extendProps(raw) { + hasExtends = true; + + var _normalizePropsOption = normalizePropsOptions(raw, appContext, true), + _normalizePropsOption2 = _slicedToArray(_normalizePropsOption, 2), + props = _normalizePropsOption2[0], + keys = _normalizePropsOption2[1]; + + extend(normalized, props); + if (keys) needCastKeys.push.apply(needCastKeys, _toConsumableArray(keys)); + }; + + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendProps); + } + + if (comp.extends) { + extendProps(comp.extends); + } + + if (comp.mixins) { + comp.mixins.forEach(extendProps); + } + } + + if (!raw && !hasExtends) { + cache.set(comp, EMPTY_ARR); + return EMPTY_ARR; + } + + if (isArray(raw)) { + for (var i = 0; i < raw.length; i++) { + if (process.env.NODE_ENV !== 'production' && !isString(raw[i])) { + warn("props must be strings when using array syntax.", raw[i]); + } + + var normalizedKey = camelize(raw[i]); + + if (validatePropName(normalizedKey)) { + normalized[normalizedKey] = EMPTY_OBJ; + } + } + } else if (raw) { + if (process.env.NODE_ENV !== 'production' && !isObject(raw)) { + warn("invalid props options", raw); + } + + for (var key in raw) { + var _normalizedKey = camelize(key); + + if (validatePropName(_normalizedKey)) { + var opt = raw[key]; + var prop = normalized[_normalizedKey] = isArray(opt) || isFunction(opt) ? { + type: opt + } : opt; + + if (prop) { + var booleanIndex = getTypeIndex(Boolean, prop.type); + var stringIndex = getTypeIndex(String, prop.type); + prop[0 + /* shouldCast */ + ] = booleanIndex > -1; + prop[1 + /* shouldCastTrue */ + ] = stringIndex < 0 || booleanIndex < stringIndex; // if the prop needs boolean casting or default value + + if (booleanIndex > -1 || hasOwn(prop, 'default')) { + needCastKeys.push(_normalizedKey); + } + } + } + } + } + + var res = [normalized, needCastKeys]; + cache.set(comp, res); + return res; + } + + function validatePropName(key) { + if (key[0] !== '$') { + return true; + } else if (process.env.NODE_ENV !== 'production') { + warn("Invalid prop name: \"".concat(key, "\" is a reserved property.")); + } + + return false; + } // use function string name to check type constructors + // so that it works across vms / iframes. + + + function getType(ctor) { + var match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ''; + } + + function isSameType(a, b) { + return getType(a) === getType(b); + } + + function getTypeIndex(type, expectedTypes) { + if (isArray(expectedTypes)) { + return expectedTypes.findIndex(function (t) { + return isSameType(t, type); + }); + } else if (isFunction(expectedTypes)) { + return isSameType(expectedTypes, type) ? 0 : -1; + } + + return -1; + } + /** + * dev only + */ + + + function validateProps(rawProps, props, instance) { + var resolvedValues = toRaw(props); + var options = instance.propsOptions[0]; + + for (var key in options) { + var opt = options[key]; + if (opt == null) continue; + validateProp(key, resolvedValues[key], opt, !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key))); + } + } + /** + * dev only + */ + + + function validateProp(name, value, prop, isAbsent) { + var type = prop.type, + required = prop.required, + validator = prop.validator; // required! + + if (required && isAbsent) { + warn('Missing required prop: "' + name + '"'); + return; + } // missing but optional + + + if (value == null && !prop.required) { + return; + } // type check + + + if (type != null && type !== true) { + var isValid = false; + var types = isArray(type) ? type : [type]; + var expectedTypes = []; // value is valid as long as one of the specified types match + + for (var i = 0; i < types.length && !isValid; i++) { + var _assertType = assertType(value, types[i]), + valid = _assertType.valid, + expectedType = _assertType.expectedType; + + expectedTypes.push(expectedType || ''); + isValid = valid; + } + + if (!isValid) { + warn(getInvalidTypeMessage(name, value, expectedTypes)); + return; + } + } // custom validator + + + if (validator && !validator(value)) { + warn('Invalid prop: custom validator check failed for prop "' + name + '".'); + } + } + + var isSimpleType = /*#__PURE__*/makeMap('String,Number,Boolean,Function,Symbol,BigInt'); + /** + * dev only + */ + + function assertType(value, type) { + var valid; + var expectedType = getType(type); + + if (isSimpleType(expectedType)) { + var t = typeof value; + valid = t === expectedType.toLowerCase(); // for primitive wrapper objects + + if (!valid && t === 'object') { + valid = value instanceof type; + } + } else if (expectedType === 'Object') { + valid = isObject(value); + } else if (expectedType === 'Array') { + valid = isArray(value); + } else { + valid = value instanceof type; + } + + return { + valid, + expectedType + }; + } + /** + * dev only + */ + + + function getInvalidTypeMessage(name, value, expectedTypes) { + var message = "Invalid prop: type check failed for prop \"".concat(name, "\".") + " Expected ".concat(expectedTypes.map(capitalize).join(', ')); + var expectedType = expectedTypes[0]; + var receivedType = toRawType(value); + var expectedValue = styleValue(value, expectedType); + var receivedValue = styleValue(value, receivedType); // check if we need to specify expected value + + if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) { + message += " with value ".concat(expectedValue); + } + + message += ", got ".concat(receivedType, " "); // check if we need to specify received value + + if (isExplicable(receivedType)) { + message += "with value ".concat(receivedValue, "."); + } + + return message; + } + /** + * dev only + */ + + + function styleValue(value, type) { + if (type === 'String') { + return "\"".concat(value, "\""); + } else if (type === 'Number') { + return "".concat(Number(value)); + } else { + return "".concat(value); + } + } + /** + * dev only + */ + + + function isExplicable(type) { + var explicitTypes = ['string', 'number', 'boolean']; + return explicitTypes.some(function (elem) { + return type.toLowerCase() === elem; + }); + } + /** + * dev only + */ + + + function isBoolean() { + for (var _len6 = arguments.length, args = new Array(_len6), _key14 = 0; _key14 < _len6; _key14++) { + args[_key14] = arguments[_key14]; + } + + return args.some(function (elem) { + return elem.toLowerCase() === 'boolean'; + }); + } + + var isInternalKey = function isInternalKey(key) { + return key[0] === '_' || key === '$stable'; + }; + + var normalizeSlotValue = function normalizeSlotValue(value) { + return isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)]; + }; + + var normalizeSlot = function normalizeSlot(key, rawSlot, ctx) { + var normalized = withCtx(function (props) { + if (process.env.NODE_ENV !== 'production' && currentInstance) { + warn("Slot \"".concat(key, "\" invoked outside of the render function: ") + "this will not track dependencies used in the slot. " + "Invoke the slot function inside the render function instead."); + } + + return normalizeSlotValue(rawSlot(props)); + }, ctx); + normalized._c = false; + return normalized; + }; + + var normalizeObjectSlots = function normalizeObjectSlots(rawSlots, slots, instance) { + var ctx = rawSlots._ctx; + + for (var key in rawSlots) { + if (isInternalKey(key)) continue; + var value = rawSlots[key]; + + if (isFunction(value)) { + slots[key] = normalizeSlot(key, value, ctx); + } else if (value != null) { + (function () { + if (process.env.NODE_ENV !== 'production' && !false) { + warn("Non-function value encountered for slot \"".concat(key, "\". ") + "Prefer function slots for better performance."); + } + + var normalized = normalizeSlotValue(value); + + slots[key] = function () { + return normalized; + }; + })(); + } + } + }; + + var normalizeVNodeSlots = function normalizeVNodeSlots(instance, children) { + if (process.env.NODE_ENV !== 'production' && !isKeepAlive(instance.vnode) && !false) { + warn("Non-function value encountered for default slot. " + "Prefer function slots for better performance."); + } + + var normalized = normalizeSlotValue(children); + + instance.slots.default = function () { + return normalized; + }; + }; + + var initSlots = function initSlots(instance, children) { + if (instance.vnode.shapeFlag & 32 + /* SLOTS_CHILDREN */ + ) { + var type = children._; + + if (type) { + // users can get the shallow readonly version of the slots object through `this.$slots`, + // we should avoid the proxy object polluting the slots of the internal instance + instance.slots = toRaw(children); // make compiler marker non-enumerable + + def(children, '_', type); + } else { + normalizeObjectSlots(children, instance.slots = {}); + } + } else { + instance.slots = {}; + + if (children) { + normalizeVNodeSlots(instance, children); + } + } + + def(instance.slots, InternalObjectKey, 1); + }; + + var updateSlots = function updateSlots(instance, children, optimized) { + var vnode = instance.vnode, + slots = instance.slots; + var needDeletionCheck = true; + var deletionComparisonTarget = EMPTY_OBJ; + + if (vnode.shapeFlag & 32 + /* SLOTS_CHILDREN */ + ) { + var type = children._; + + if (type) { + // compiled slots. + if (process.env.NODE_ENV !== 'production' && isHmrUpdating) { + // Parent was HMR updated so slot content may have changed. + // force update slots and mark instance for hmr as well + extend(slots, children); + } else if (optimized && type === 1 + /* STABLE */ + ) { + // compiled AND stable. + // no need to update, and skip stale slots removal. + needDeletionCheck = false; + } else { + // compiled but dynamic (v-if/v-for on slots) - update slots, but skip + // normalization. + extend(slots, children); // #2893 + // when rendering the optimized slots by manually written render function, + // we need to delete the `slots._` flag if necessary to make subsequent updates reliable, + // i.e. let the `renderSlot` create the bailed Fragment + + if (!optimized && type === 1 + /* STABLE */ + ) { + delete slots._; + } + } + } else { + needDeletionCheck = !children.$stable; + normalizeObjectSlots(children, slots); + } + + deletionComparisonTarget = children; + } else if (children) { + // non slot object children (direct value) passed to a component + normalizeVNodeSlots(instance, children); + deletionComparisonTarget = { + default: 1 + }; + } // delete stale slots + + + if (needDeletionCheck) { + for (var key in slots) { + if (!isInternalKey(key) && !(key in deletionComparisonTarget)) { + delete slots[key]; + } + } + } + }; + /** + Runtime helper for applying directives to a vnode. Example usage: + + const comp = resolveComponent('comp') + const foo = resolveDirective('foo') + const bar = resolveDirective('bar') + + return withDirectives(h(comp), [ + [foo, this.x], + [bar, this.y] + ]) + */ + + + var isBuiltInDirective = /*#__PURE__*/makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text'); + + function validateDirectiveName(name) { + if (isBuiltInDirective(name)) { + warn('Do not use built-in directive ids as custom directive id: ' + name); + } + } + /** + * Adds directives to a VNode. + */ + + + function withDirectives(vnode, directives) { + var internalInstance = currentRenderingInstance; + + if (internalInstance === null) { + process.env.NODE_ENV !== 'production' && warn("withDirectives can only be used inside render functions."); + return vnode; + } + + var instance = internalInstance.proxy; + var bindings = vnode.dirs || (vnode.dirs = []); + + for (var i = 0; i < directives.length; i++) { + var _directives$i = _slicedToArray(directives[i], 4), + dir = _directives$i[0], + value = _directives$i[1], + arg = _directives$i[2], + _directives$i$ = _directives$i[3], + modifiers = _directives$i$ === void 0 ? EMPTY_OBJ : _directives$i$; + + if (isFunction(dir)) { + dir = { + mounted: dir, + updated: dir + }; + } + + bindings.push({ + dir, + instance, + value, + oldValue: void 0, + arg, + modifiers + }); + } + + return vnode; + } + + function invokeDirectiveHook(vnode, prevVNode, instance, name) { + var bindings = vnode.dirs; + var oldBindings = prevVNode && prevVNode.dirs; + + for (var i = 0; i < bindings.length; i++) { + var binding = bindings[i]; + + if (oldBindings) { + binding.oldValue = oldBindings[i].value; + } + + var hook = binding.dir[name]; + + if (hook) { + // disable tracking inside all lifecycle hooks + // since they can potentially be called inside effects. + pauseTracking(); + callWithAsyncErrorHandling(hook, instance, 8 + /* DIRECTIVE_HOOK */ + , [vnode.el, binding, vnode, prevVNode]); + resetTracking(); + } + } + } + + function createAppContext() { + return { + app: null, + config: { + isNativeTag: NO, + performance: false, + globalProperties: {}, + optionMergeStrategies: {}, + errorHandler: undefined, + warnHandler: undefined, + compilerOptions: {} + }, + mixins: [], + components: {}, + directives: {}, + provides: Object.create(null), + optionsCache: new WeakMap(), + propsCache: new WeakMap(), + emitsCache: new WeakMap() + }; + } + + var uid$1 = 0; + + function createAppAPI(render, hydrate) { + return function createApp(rootComponent) { + var rootProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + + if (rootProps != null && !isObject(rootProps)) { + process.env.NODE_ENV !== 'production' && warn("root props passed to app.mount() must be an object."); + rootProps = null; + } + + var context = createAppContext(); + var installedPlugins = new Set(); + var isMounted = false; + var app = context.app = { + _uid: uid$1++, + _component: rootComponent, + _props: rootProps, + _container: null, + _context: context, + _instance: null, + version, + + get config() { + return context.config; + }, + + set config(v) { + if (process.env.NODE_ENV !== 'production') { + warn("app.config cannot be replaced. Modify individual options instead."); + } + }, + + use(plugin) { + for (var _len7 = arguments.length, options = new Array(_len7 > 1 ? _len7 - 1 : 0), _key15 = 1; _key15 < _len7; _key15++) { + options[_key15 - 1] = arguments[_key15]; + } + + if (installedPlugins.has(plugin)) { + process.env.NODE_ENV !== 'production' && warn("Plugin has already been applied to target app."); + } else if (plugin && isFunction(plugin.install)) { + installedPlugins.add(plugin); + plugin.install.apply(plugin, [app].concat(options)); + } else if (isFunction(plugin)) { + installedPlugins.add(plugin); + plugin.apply(void 0, [app].concat(options)); + } else if (process.env.NODE_ENV !== 'production') { + warn("A plugin must either be a function or an object with an \"install\" " + "function."); + } + + return app; + }, + + mixin(mixin) { + { + if (!context.mixins.includes(mixin)) { + context.mixins.push(mixin); + } else if (process.env.NODE_ENV !== 'production') { + warn('Mixin has already been applied to target app' + (mixin.name ? ": ".concat(mixin.name) : '')); + } + } + return app; + }, + + component(name, component) { + if (process.env.NODE_ENV !== 'production') { + validateComponentName(name, context.config); + } + + if (!component) { + return context.components[name]; + } + + if (process.env.NODE_ENV !== 'production' && context.components[name]) { + warn("Component \"".concat(name, "\" has already been registered in target app.")); + } + + context.components[name] = component; + return app; + }, + + directive(name, directive) { + if (process.env.NODE_ENV !== 'production') { + validateDirectiveName(name); + } + + if (!directive) { + return context.directives[name]; + } + + if (process.env.NODE_ENV !== 'production' && context.directives[name]) { + warn("Directive \"".concat(name, "\" has already been registered in target app.")); + } + + context.directives[name] = directive; + return app; + }, + + mount(rootContainer, isHydrate, isSVG) { + if (!isMounted) { + var vnode = createVNode(rootComponent, rootProps); // store app context on the root VNode. + // this will be set on the root instance on initial mount. + + vnode.appContext = context; // HMR root reload + + if (process.env.NODE_ENV !== 'production') { + context.reload = function () { + render(cloneVNode(vnode), rootContainer, isSVG); + }; + } + + if (isHydrate && hydrate) { + hydrate(vnode, rootContainer); + } else { + render(vnode, rootContainer, isSVG); + } + + isMounted = true; + app._container = rootContainer; + rootContainer.__vue_app__ = app; + + if (process.env.NODE_ENV !== 'production' || false) { + app._instance = vnode.component; + devtoolsInitApp(app, version); + } + + return vnode.component.proxy; + } else if (process.env.NODE_ENV !== 'production') { + warn("App has already been mounted.\n" + "If you want to remount the same app, move your app creation logic " + "into a factory function and create fresh app instances for each " + "mount - e.g. `const createMyApp = () => createApp(App)`"); + } + }, + + unmount() { + if (isMounted) { + render(null, app._container); + + if (process.env.NODE_ENV !== 'production' || false) { + app._instance = null; + devtoolsUnmountApp(app); + } + + delete app._container.__vue_app__; + } else if (process.env.NODE_ENV !== 'production') { + warn("Cannot unmount an app that is not mounted."); + } + }, + + provide(key, value) { + if (process.env.NODE_ENV !== 'production' && key in context.provides) { + warn("App already provides property with key \"".concat(String(key), "\". ") + "It will be overwritten with the new value."); + } // TypeScript doesn't allow symbols as index type + // https://github.com/Microsoft/TypeScript/issues/24587 + + + context.provides[key] = value; + return app; + } + + }; + return app; + }; + } + + var hasMismatch = false; + + var isSVGContainer = function isSVGContainer(container) { + return /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject'; + }; + + var isComment = function isComment(node) { + return node.nodeType === 8; + }; + /* COMMENT */ + // Note: hydration is DOM-specific + // But we have to place it in core due to tight coupling with core - splitting + // it out creates a ton of unnecessary complexity. + // Hydration also depends on some renderer internal logic which needs to be + // passed in via arguments. + + + function createHydrationFunctions(rendererInternals) { + var mountComponent = rendererInternals.mt, + patch = rendererInternals.p, + _rendererInternals$o2 = rendererInternals.o, + patchProp = _rendererInternals$o2.patchProp, + nextSibling = _rendererInternals$o2.nextSibling, + parentNode = _rendererInternals$o2.parentNode, + remove = _rendererInternals$o2.remove, + insert = _rendererInternals$o2.insert, + createComment = _rendererInternals$o2.createComment; + + var hydrate = function hydrate(vnode, container) { + if (process.env.NODE_ENV !== 'production' && !container.hasChildNodes()) { + warn("Attempting to hydrate existing markup but container is empty. " + "Performing full mount instead."); + patch(null, vnode, container); + return; + } + + hasMismatch = false; + hydrateNode(container.firstChild, vnode, null, null, null); + flushPostFlushCbs(); + + if (hasMismatch && !false) { + // this error should show up in production + console.error("Hydration completed but contains mismatches."); + } + }; + + var hydrateNode = function hydrateNode(node, vnode, parentComponent, parentSuspense, slotScopeIds) { + var optimized = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false; + var isFragmentStart = isComment(node) && node.data === '['; + + var onMismatch = function onMismatch() { + return handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart); + }; + + var type = vnode.type, + ref = vnode.ref, + shapeFlag = vnode.shapeFlag; + var domType = node.nodeType; + vnode.el = node; + var nextNode = null; + + switch (type) { + case Text: + if (domType !== 3 + /* TEXT */ + ) { + nextNode = onMismatch(); + } else { + if (node.data !== vnode.children) { + hasMismatch = true; + process.env.NODE_ENV !== 'production' && warn("Hydration text mismatch:" + "\n- Client: ".concat(JSON.stringify(node.data)) + "\n- Server: ".concat(JSON.stringify(vnode.children))); + node.data = vnode.children; + } + + nextNode = nextSibling(node); + } + + break; + + case Comment$1: + if (domType !== 8 + /* COMMENT */ + || isFragmentStart) { + nextNode = onMismatch(); + } else { + nextNode = nextSibling(node); + } + + break; + + case Static: + if (domType !== 1 + /* ELEMENT */ + ) { + nextNode = onMismatch(); + } else { + // determine anchor, adopt content + nextNode = node; // if the static vnode has its content stripped during build, + // adopt it from the server-rendered HTML. + + var needToAdoptContent = !vnode.children.length; + + for (var i = 0; i < vnode.staticCount; i++) { + if (needToAdoptContent) vnode.children += nextNode.outerHTML; + + if (i === vnode.staticCount - 1) { + vnode.anchor = nextNode; + } + + nextNode = nextSibling(nextNode); + } + + return nextNode; + } + + break; + + case Fragment: + if (!isFragmentStart) { + nextNode = onMismatch(); + } else { + nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } + + break; + + default: + if (shapeFlag & 1 + /* ELEMENT */ + ) { + if (domType !== 1 + /* ELEMENT */ + || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) { + nextNode = onMismatch(); + } else { + nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } + } else if (shapeFlag & 6 + /* COMPONENT */ + ) { + // when setting up the render effect, if the initial vnode already + // has .el set, the component will perform hydration instead of mount + // on its sub-tree. + vnode.slotScopeIds = slotScopeIds; + var container = parentNode(node); + mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized); // component may be async, so in the case of fragments we cannot rely + // on component's rendered output to determine the end of the fragment + // instead, we do a lookahead to find the end anchor node. + + nextNode = isFragmentStart ? locateClosingAsyncAnchor(node) : nextSibling(node); // #3787 + // if component is async, it may get moved / unmounted before its + // inner component is loaded, so we need to give it a placeholder + // vnode that matches its adopted DOM. + + if (isAsyncWrapper(vnode)) { + var subTree; + + if (isFragmentStart) { + subTree = createVNode(Fragment); + subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild; + } else { + subTree = node.nodeType === 3 ? createTextVNode('') : createVNode('div'); + } + + subTree.el = node; + vnode.component.subTree = subTree; + } + } else if (shapeFlag & 64 + /* TELEPORT */ + ) { + if (domType !== 8 + /* COMMENT */ + ) { + nextNode = onMismatch(); + } else { + nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren); + } + } else if (shapeFlag & 128 + /* SUSPENSE */ + ) { + nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode); + } else if (process.env.NODE_ENV !== 'production') { + warn('Invalid HostVNode type:', type, "(".concat(typeof type, ")")); + } + + } + + if (ref != null) { + setRef(ref, null, parentSuspense, vnode); + } + + return nextNode; + }; + + var hydrateElement = function hydrateElement(el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) { + optimized = optimized || !!vnode.dynamicChildren; + var props = vnode.props, + patchFlag = vnode.patchFlag, + shapeFlag = vnode.shapeFlag, + dirs = vnode.dirs; // skip props & children if this is hoisted static nodes + + if (patchFlag !== -1 + /* HOISTED */ + ) { + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'created'); + } // props + + + if (props) { + if (!optimized || patchFlag & 16 + /* FULL_PROPS */ + || patchFlag & 32 + /* HYDRATE_EVENTS */ + ) { + for (var key in props) { + if (!isReservedProp(key) && isOn(key)) { + patchProp(el, key, null, props[key]); + } + } + } else if (props.onClick) { + // Fast path for click listeners (which is most often) to avoid + // iterating through props. + patchProp(el, 'onClick', null, props.onClick); + } + } // vnode / directive hooks + + + var vnodeHooks; + + if (vnodeHooks = props && props.onVnodeBeforeMount) { + invokeVNodeHook(vnodeHooks, parentComponent, vnode); + } + + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount'); + } + + if ((vnodeHooks = props && props.onVnodeMounted) || dirs) { + queueEffectWithSuspense(function () { + vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode); + dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted'); + }, parentSuspense); + } // children + + + if (shapeFlag & 16 + /* ARRAY_CHILDREN */ + && // skip if element has innerHTML / textContent + !(props && (props.innerHTML || props.textContent))) { + var next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, slotScopeIds, optimized); + var _hasWarned = false; + + while (next) { + hasMismatch = true; + + if (process.env.NODE_ENV !== 'production' && !_hasWarned) { + warn("Hydration children mismatch in <".concat(vnode.type, ">: ") + "server rendered element contains more child nodes than client vdom."); + _hasWarned = true; + } // The SSRed DOM contains more nodes than it should. Remove them. + + + var cur = next; + next = next.nextSibling; + remove(cur); + } + } else if (shapeFlag & 8 + /* TEXT_CHILDREN */ + ) { + if (el.textContent !== vnode.children) { + hasMismatch = true; + process.env.NODE_ENV !== 'production' && warn("Hydration text content mismatch in <".concat(vnode.type, ">:\n") + "- Client: ".concat(el.textContent, "\n") + "- Server: ".concat(vnode.children)); + el.textContent = vnode.children; + } + } + } + + return el.nextSibling; + }; + + var hydrateChildren = function hydrateChildren(node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) { + optimized = optimized || !!parentVNode.dynamicChildren; + var children = parentVNode.children; + var l = children.length; + var hasWarned = false; + + for (var i = 0; i < l; i++) { + var vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]); + + if (node) { + node = hydrateNode(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } else if (vnode.type === Text && !vnode.children) { + continue; + } else { + hasMismatch = true; + + if (process.env.NODE_ENV !== 'production' && !hasWarned) { + warn("Hydration children mismatch in <".concat(container.tagName.toLowerCase(), ">: ") + "server rendered element contains fewer child nodes than client vdom."); + hasWarned = true; + } // the SSRed DOM didn't contain enough nodes. Mount the missing ones. + + + patch(null, vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), slotScopeIds); + } + } + + return node; + }; + + var hydrateFragment = function hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) { + var fragmentSlotScopeIds = vnode.slotScopeIds; + + if (fragmentSlotScopeIds) { + slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds; + } + + var container = parentNode(node); + var next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized); + + if (next && isComment(next) && next.data === ']') { + return nextSibling(vnode.anchor = next); + } else { + // fragment didn't hydrate successfully, since we didn't get a end anchor + // back. This should have led to node/children mismatch warnings. + hasMismatch = true; // since the anchor is missing, we need to create one and insert it + + insert(vnode.anchor = createComment("]", container), container, next); // fixed by xxxxxx + + return next; + } + }; + + var handleMismatch = function handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) { + hasMismatch = true; + process.env.NODE_ENV !== 'production' && warn("Hydration node mismatch:\n- Client vnode:", vnode.type, "\n- Server rendered DOM:", node, node.nodeType === 3 + /* TEXT */ + ? "(text)" : isComment(node) && node.data === '[' ? "(start of fragment)" : ""); + vnode.el = null; + + if (isFragment) { + // remove excessive fragment nodes + var end = locateClosingAsyncAnchor(node); + + while (true) { + var _next = nextSibling(node); + + if (_next && _next !== end) { + remove(_next); + } else { + break; + } + } + } + + var next = nextSibling(node); + var container = parentNode(node); + remove(node); + patch(null, vnode, container, next, parentComponent, parentSuspense, isSVGContainer(container), slotScopeIds); + return next; + }; + + var locateClosingAsyncAnchor = function locateClosingAsyncAnchor(node) { + var match = 0; + + while (node) { + node = nextSibling(node); + + if (node && isComment(node)) { + if (node.data === '[') match++; + + if (node.data === ']') { + if (match === 0) { + return nextSibling(node); + } else { + match--; + } + } + } + } + + return node; + }; + + return [hydrate, hydrateNode]; + } + + var supported; + var perf; + + function startMeasure(instance, type) { + if (instance.appContext.config.performance && isSupported()) { + perf.mark("vue-".concat(type, "-").concat(instance.uid)); + } + + if (process.env.NODE_ENV !== 'production' || false) { + devtoolsPerfStart(instance, type, supported ? perf.now() : Date.now()); + } + } + + function endMeasure(instance, type) { + if (instance.appContext.config.performance && isSupported()) { + var startTag = "vue-".concat(type, "-").concat(instance.uid); + var endTag = startTag + ":end"; + perf.mark(endTag); + perf.measure("<".concat(formatComponentName(instance, instance.type), "> ").concat(type), startTag, endTag); + perf.clearMarks(startTag); + perf.clearMarks(endTag); + } + + if (process.env.NODE_ENV !== 'production' || false) { + devtoolsPerfEnd(instance, type, supported ? perf.now() : Date.now()); + } + } + + function isSupported() { + if (supported !== undefined) { + return supported; + } + /* eslint-disable no-restricted-globals */ + + + if (typeof window !== 'undefined' && window.performance) { + supported = true; + perf = window.performance; + } else { + supported = false; + } + /* eslint-enable no-restricted-globals */ + + + return supported; + } + /** + * This is only called in esm-bundler builds. + * It is called when a renderer is created, in `baseCreateRenderer` so that + * importing runtime-core is side-effects free. + * + * istanbul-ignore-next + */ + + + function initFeatureFlags() { + var needWarn = false; + + if (process.env.NODE_ENV !== 'production' && needWarn) { + console.warn("You are running the esm-bundler build of Vue. It is recommended to " + "configure your bundler to explicitly replace feature flag globals " + "with boolean literals to get proper tree-shaking in the final bundle. " + "See http://link.vuejs.org/feature-flags for more details."); + } + } + + var prodEffectOptions = { + scheduler: queueJob, + // #1801, #2043 component render effects should allow recursive updates + allowRecurse: true + }; + + function createDevEffectOptions(instance) { + return { + scheduler: queueJob, + allowRecurse: true, + onTrack: instance.rtc ? function (e) { + return invokeArrayFns(instance.rtc, e); + } : void 0, + onTrigger: instance.rtg ? function (e) { + return invokeArrayFns(instance.rtg, e); + } : void 0 + }; + } + + var queuePostRenderEffect = queueEffectWithSuspense; + + var setRef = function setRef(rawRef, oldRawRef, parentSuspense, vnode) { + var isUnmount = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; + + if (isArray(rawRef)) { + rawRef.forEach(function (r, i) { + return setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount); + }); + return; + } + + if (isAsyncWrapper(vnode) && !isUnmount) { + // when mounting async components, nothing needs to be done, + // because the template ref is forwarded to inner component + return; + } + + var refValue = vnode.shapeFlag & 4 + /* STATEFUL_COMPONENT */ + ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el; + var value = isUnmount ? null : refValue; + var owner = rawRef.i, + ref = rawRef.r; + + if (process.env.NODE_ENV !== 'production' && !owner) { + warn("Missing ref owner context. ref cannot be used on hoisted vnodes. " + "A vnode with ref must be created inside the render function."); + return; + } + + var oldRef = oldRawRef && oldRawRef.r; + var refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs; + var setupState = owner.setupState; // dynamic ref changed. unset old ref + + if (oldRef != null && oldRef !== ref) { + if (isString(oldRef)) { + refs[oldRef] = null; + + if (hasOwn(setupState, oldRef)) { + setupState[oldRef] = null; + } + } else if (isRef(oldRef)) { + oldRef.value = null; + } + } + + if (isString(ref)) { + var doSet = function doSet() { + { + refs[ref] = value; + } + + if (hasOwn(setupState, ref)) { + setupState[ref] = value; + } + }; // #1789: for non-null values, set them after render + // null values means this is unmount and it should not overwrite another + // ref with the same key + + + if (value) { + doSet.id = -1; + queuePostRenderEffect(doSet, parentSuspense); + } else { + doSet(); + } + } else if (isRef(ref)) { + var _doSet = function _doSet() { + ref.value = value; + }; + + if (value) { + _doSet.id = -1; + queuePostRenderEffect(_doSet, parentSuspense); + } else { + _doSet(); + } + } else if (isFunction(ref)) { + callWithErrorHandling(ref, owner, 12 + /* FUNCTION_REF */ + , [value, refs]); + } else if (process.env.NODE_ENV !== 'production') { + warn('Invalid template ref type:', value, "(".concat(typeof value, ")")); + } + }; + /** + * The createRenderer function accepts two generic arguments: + * HostNode and HostElement, corresponding to Node and Element types in the + * host environment. For example, for runtime-dom, HostNode would be the DOM + * `Node` interface and HostElement would be the DOM `Element` interface. + * + * Custom renderers can pass in the platform specific types like this: + * + * ``` js + * const { render, createApp } = createRenderer({ + * patchProp, + * ...nodeOps + * }) + * ``` + */ + + + function createRenderer(options) { + return baseCreateRenderer(options); + } // Separate API for creating hydration-enabled renderer. + // Hydration logic is only used when calling this function, making it + // tree-shakable. + + + function createHydrationRenderer(options) { + return baseCreateRenderer(options, createHydrationFunctions); + } // implementation + + + function baseCreateRenderer(options, createHydrationFns) { + // compile-time feature flags check + { + initFeatureFlags(); + } + + if (process.env.NODE_ENV !== 'production' || false) { + var target = getGlobalThis(); + target.__VUE__ = true; + setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__); + } + + var hostInsert = options.insert, + hostRemove = options.remove, + hostPatchProp = options.patchProp, + hostForcePatchProp = options.forcePatchProp, + hostCreateElement = options.createElement, + hostCreateText = options.createText, + hostCreateComment = options.createComment, + hostSetText = options.setText, + hostSetElementText = options.setElementText, + hostParentNode = options.parentNode, + hostNextSibling = options.nextSibling, + _options$setScopeId = options.setScopeId, + hostSetScopeId = _options$setScopeId === void 0 ? NOOP : _options$setScopeId, + hostCloneNode = options.cloneNode, + hostInsertStaticContent = options.insertStaticContent; // Note: functions inside this closure should use `const xxx = () => {}` + // style in order to prevent being inlined by minifiers. + + var patch = function patch(n1, n2, container) { + var anchor = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null; + var parentComponent = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null; + var parentSuspense = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null; + var isSVG = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false; + var slotScopeIds = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null; + var optimized = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : false; + + // patching & not same type, unmount old tree + if (n1 && !isSameVNodeType(n1, n2)) { + anchor = getNextHostNode(n1); + unmount(n1, parentComponent, parentSuspense, true); + n1 = null; + } + + if (n2.patchFlag === -2 + /* BAIL */ + ) { + optimized = false; + n2.dynamicChildren = null; + } + + var type = n2.type, + ref = n2.ref, + shapeFlag = n2.shapeFlag; + + switch (type) { + case Text: + processText(n1, n2, container, anchor); + break; + + case Comment$1: + processCommentNode(n1, n2, container, anchor); + break; + + case Static: + if (n1 == null) { + mountStaticNode(n2, container, anchor, isSVG); + } else if (process.env.NODE_ENV !== 'production') { + patchStaticNode(n1, n2, container, isSVG); + } + + break; + + case Fragment: + processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + break; + + default: + if (shapeFlag & 1 + /* ELEMENT */ + ) { + processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else if (shapeFlag & 6 + /* COMPONENT */ + ) { + processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else if (shapeFlag & 64 + /* TELEPORT */ + ) { + type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals); + } else if (shapeFlag & 128 + /* SUSPENSE */ + ) { + type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals); + } else if (process.env.NODE_ENV !== 'production') { + warn('Invalid VNode type:', type, "(".concat(typeof type, ")")); + } + + } // set ref + + + if (ref != null && parentComponent) { + setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2); + } + }; + + var processText = function processText(n1, n2, container, anchor) { + if (n1 == null) { + hostInsert(n2.el = hostCreateText(n2.children, container), // fixed by xxxxxx + container, anchor); + } else { + var el = n2.el = n1.el; + + if (n2.children !== n1.children) { + hostSetText(el, n2.children); + } + } + }; + + var processCommentNode = function processCommentNode(n1, n2, container, anchor) { + if (n1 == null) { + hostInsert(n2.el = hostCreateComment(n2.children || '', container), // fixed by xxxxxx + container, anchor); + } else { + // there's no support for dynamic comments + n2.el = n1.el; + } + }; + + var mountStaticNode = function mountStaticNode(n2, container, anchor, isSVG) { + var _hostInsertStaticCont = hostInsertStaticContent(n2.children, container, anchor, isSVG, // pass cached nodes if the static node is being mounted multiple times + // so that runtime-dom can simply cloneNode() instead of inserting new + // HTML + n2.el && [n2.el, n2.anchor]); + + var _hostInsertStaticCont2 = _slicedToArray(_hostInsertStaticCont, 2); + + n2.el = _hostInsertStaticCont2[0]; + n2.anchor = _hostInsertStaticCont2[1]; + }; + /** + * Dev / HMR only + */ + + + var patchStaticNode = function patchStaticNode(n1, n2, container, isSVG) { + // static nodes are only patched during dev for HMR + if (n2.children !== n1.children) { + var anchor = hostNextSibling(n1.anchor); // remove existing + + removeStaticNode(n1); + + var _hostInsertStaticCont3 = hostInsertStaticContent(n2.children, container, anchor, isSVG); + + var _hostInsertStaticCont4 = _slicedToArray(_hostInsertStaticCont3, 2); + + n2.el = _hostInsertStaticCont4[0]; + n2.anchor = _hostInsertStaticCont4[1]; + } else { + n2.el = n1.el; + n2.anchor = n1.anchor; + } + }; + + var moveStaticNode = function moveStaticNode(_ref14, container, nextSibling) { + var el = _ref14.el, + anchor = _ref14.anchor; + var next; + + while (el && el !== anchor) { + next = hostNextSibling(el); + hostInsert(el, container, nextSibling); + el = next; + } + + hostInsert(anchor, container, nextSibling); + }; + + var removeStaticNode = function removeStaticNode(_ref15) { + var el = _ref15.el, + anchor = _ref15.anchor; + var next; + + while (el && el !== anchor) { + next = hostNextSibling(el); + hostRemove(el); + el = next; + } + + hostRemove(anchor); + }; + + var processElement = function processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) { + isSVG = isSVG || n2.type === 'svg'; + + if (n1 == null) { + mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else { + patchElement(n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + }; + + var mountElement = function mountElement(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) { + var el; + var vnodeHook; + var type = vnode.type, + props = vnode.props, + shapeFlag = vnode.shapeFlag, + transition = vnode.transition, + patchFlag = vnode.patchFlag, + dirs = vnode.dirs; + + if (!(process.env.NODE_ENV !== 'production') && vnode.el && hostCloneNode !== undefined && patchFlag === -1 + /* HOISTED */ + ) { + // If a vnode has non-null el, it means it's being reused. + // Only static vnodes can be reused, so its mounted DOM nodes should be + // exactly the same, and we can simply do a clone here. + // only do this in production since cloned trees cannot be HMR updated. + el = vnode.el = hostCloneNode(vnode.el); + } else { + el = vnode.el = hostCreateElement( // fixed by xxxxxx + vnode.type, container); // mount children first, since some props may rely on child content + // being already rendered, e.g. `