{"version":3,"sources":["webpack:///./node_modules/@vue/runtime-dom/node_modules/@vue/shared/dist/shared.esm-bundler.js","webpack:///./node_modules/@vue/reactivity/node_modules/@vue/shared/dist/shared.esm-bundler.js","webpack:///./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js","webpack:///./node_modules/@vue/runtime-core/node_modules/@vue/shared/dist/shared.esm-bundler.js","webpack:///./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js","webpack:///./node_modules/vue-router/dist/vue-router.esm.js","webpack:///./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js","webpack:///(webpack)/buildin/global.js"],"names":["makeMap","str","expectsLowerCase","map","Object","create","list","split","i","length","val","toLowerCase","specialBooleanAttrs","isSpecialBooleanAttr","HTML_TAGS","SVG_TAGS","isHTMLTag","isSVGTag","looseCompareArrays","a","b","equal","looseEqual","aValidType","isDate","bValidType","getTime","isArray","isObject","aKeysCount","keys","bKeysCount","key","aHasKey","hasOwnProperty","bHasKey","String","looseIndexOf","arr","findIndex","item","EMPTY_OBJ","onRE","isOn","test","isModelListener","startsWith","extend","assign","prototype","Array","Date","isFunction","isString","cacheStringFunction","toString","fn","cache","hit","camelizeRE","hyphenateRE","replace","_","c","toUpperCase","hyphenate","capitalize","charAt","slice","invokeArrayFns","fns","arg","toNumber","n","parseFloat","isNaN","NOOP","hasOwn","call","isSymbol","objectToString","toTypeString","value","toRawType","hasChanged","oldValue","def","obj","defineProperty","configurable","enumerable","stack","warn","msg","args","instance","component","appWarnHandler","appContext","config","warnHandler","trace","getComponentTrace","callWithErrorHandling","join","proxy","vnode","formatComponentName","type","warnArgs","push","formatTrace","console","currentVNode","normalizedStack","last","recurseCount","parentInstance","parent","logs","forEach","entry","formatTraceEntry","postfix","isRoot","open","close","props","formatProps","res","formatProp","raw","JSON","stringify","name","err","handleError","callWithAsyncErrorHandling","catch","values","contextVNode","cur","exposedInstance","errorInfo","errorCapturedHooks","ec","appErrorHandler","errorHandler","logError","queue","postFlushCbs","p","Promise","resolve","isFlushing","isFlushPending","flushIndex","pendingPostFlushCbs","pendingPostFlushIndex","nextTick","then","queueJob","job","includes","queueFlush","invalidateJob","indexOf","queuePostFlushCb","cb","flushJobs","flushPostFlushCbs","seen","Set","getId","id","Infinity","sort","Map","currentRenderingInstance","setCurrentRenderingInstance","renderComponentRoot","Component","withProxy","slots","attrs","emit","render","renderCache","data","setupState","ctx","result","fallthroughAttrs","shapeFlag","proxyToUse","normalizeVNode","getFunctionalFallthrough","root","inheritAttrs","some","filterModelListeners","cloneVNode","scopeId","needScopeId","treeOwnerId","__scopeId","slotScopeId","extras","dirs","transition","createVNode","Comment","shouldUpdateComponent","prevVNode","nextVNode","optimized","prevProps","children","prevChildren","nextProps","nextChildren","patchFlag","$stable","hasPropsChanged","dynamicProps","nextKeys","updateHOCHostEl","el","subTree","isSuspense","__isSuspense","queueEffectWithSuspense","suspense","isResolved","effects","withCtx","owner","apply","arguments","currentScopeId","isTeleport","__isTeleport","isTeleportDisabled","disabled","resolveTarget","select","targetSelector","to","target","TeleportImpl","n1","n2","container","anchor","parentComponent","parentSuspense","isSVG","internals","mc","mountChildren","pc","patchChildren","pbc","patchBlockChildren","o","insert","querySelector","createText","createComment","placeholder","mainAnchor","targetAnchor","mount","wasDisabled","currentContainer","currentAnchor","dynamicChildren","moveTeleport","nextTarget","r","remove","hostRemove","move","hydrate","hydrateTeleport","parentAnchor","m","moveType","isReorder","node","nextSibling","parentNode","hydrateChildren","targetNode","_lpa","firstChild","Teleport","NULL_DYNAMIC_COMPONENT","Symbol","Fragment","undefined","Text","Static","currentBlock","shouldTrack","isVNode","__v_isVNode","isSameVNodeType","InternalObjectKey","normalizeKey","normalizeRef","ref","_createVNode","isBlockNode","cloned","normalizeChildren","__vccOpts","class","klass","style","__v_skip","staticCount","extraProps","mergedProps","mergeProps","createTextVNode","text","flag","child","cloneIfMounted","default","slotFlag","_ctx","ret","toMerge","existing","incoming","concat","event","handlerName","handler","emitted","normalizeEmitsOptions","comp","__emits","emits","normalized","hasExtends","__VUE_OPTIONS_API__","extends","mixins","isEmitListener","initProps","rawProps","isStateful","isSSR","setFullProps","updateProps","rawPrevProps","rawCurrentProps","options","normalizePropsOptions","kebabKey","resolvePropValue","propsToUpdate","camelizedKey","needCastKeys","camelKey","opt","hasDefault","defaultValue","Function","__props","extendProps","normalizedKey","validatePropName","prop","booleanIndex","getTypeIndex","Boolean","stringIndex","normalizedEntry","getType","ctor","match","isSameType","expectedTypes","len","injectHook","hook","currentInstance","prepend","hooks","wrappedHook","__weh","isUnmounted","setCurrentInstance","unshift","createHook","lifecycle","isInSSRComponentSetup","onBeforeMount","onMounted","onBeforeUpdate","onUpdated","onBeforeUnmount","onUnmounted","onRenderTriggered","onRenderTracked","onErrorCaptured","useTransitionState","state","isMounted","isLeaving","isUnmounting","leavingVNodes","BaseTransitionImpl","mode","appear","persisted","onBeforeEnter","onEnter","onAfterEnter","onEnterCancelled","onBeforeLeave","onLeave","onAfterLeave","onLeaveCancelled","onBeforeAppear","onAppear","onAfterAppear","onAppearCancelled","getCurrentInstance","prevTransitionKey","getTransitionRawChildren","emptyPlaceholder","innerChild","getKeepAliveChild","enterHooks","resolveTransitionHooks","oldChild","oldInnerChild","transitionKeyChanged","getTransitionKey","leavingHooks","setTransitionHooks","afterLeave","update","delayLeave","earlyRemove","delayedLeave","leavingVNodesCache","getLeavingNodesForType","_leaveCb","BaseTransition","get","set","callHook","leavingVNode","afterHook","cancelHook","called","done","_enterCb","cancelled","isKeepAlive","keepComment","keyedFragmentCount","__isKeepAlive","RegExp","getName","displayName","matches","pattern","onActivated","registerKeepAliveHook","onDeactivated","__wdc","current","isDeactivated","injectToKeepAliveRoot","keepAliveRoot","resetShapeFlag","isInternalKey","normalizeSlotValue","normalizeSlot","rawSlot","normalizeObjectSlots","rawSlots","normalizeVNodeSlots","initSlots","updateSlots","needDeletionCheck","deletionComparisonTarget","invokeDirectiveHook","bindings","oldBindings","binding","dir","devtools","devtoolsInitApp","app","version","devtoolsUnmountApp","devtoolsComponentAdded","createDevtoolsHook","devtoolsComponentUpdated","devtoolsComponentRemoved","uid","createAppContext","isNativeTag","performance","globalProperties","optionMergeStrategies","isCustomElement","components","directives","provides","createAppAPI","rootComponent","rootProps","context","installedPlugins","_component","_props","_container","_context","v","plugin","has","install","add","mixin","directive","rootContainer","isHydrate","__vue_app__","__VUE_PROD_DEVTOOLS__","hasMismatch","isSVGContainer","namespaceURI","tagName","isComment","nodeType","createHydrationFunctions","rendererInternals","mt","mountComponent","patch","patchProp","hydrateNode","error","isFragmentStart","onMismatch","handleMismatch","domType","nextNode","needToAdoptContent","outerHTML","hydrateFragment","hydrateElement","hydrateComponent","loadAsync","__asyncLoader","locateClosingAsyncAnchor","setRef","onClick","vnodeHooks","onVnodeBeforeMount","invokeVNodeHook","onVnodeMounted","innerHTML","textContent","next","l","isFragment","end","initFeatureFlags","needWarn","prodEffectOptions","scheduler","queuePostRenderEffect","rawRef","oldRawRef","oldRef","refs","createRenderer","baseCreateRenderer","createHydrationRenderer","createHydrationFns","hostInsert","hostPatchProp","forcePatchProp","hostForcePatchProp","createElement","hostCreateElement","hostCreateText","hostCreateComment","setText","hostSetText","setElementText","hostSetElementText","hostParentNode","hostNextSibling","setScopeId","hostSetScopeId","cloneNode","hostCloneNode","insertStaticContent","hostInsertStaticContent","getNextHostNode","unmount","processText","processCommentNode","mountStaticNode","processFragment","processElement","processComponent","process","mountElement","patchElement","vnodeHook","is","unmountChildren","beforeEnter","needCallTransitionHooks","enter","start","oldProps","newProps","onVnodeBeforeUpdate","patchProps","prev","areChildrenSVG","onVnodeUpdated","oldChildren","newChildren","fallbackContainer","oldVNode","newVNode","fragmentStartAnchor","fragmentEndAnchor","activate","updateComponent","initialVNode","createComponentInstance","renderer","setupComponent","asyncDep","registerDep","setupRenderEffect","asyncResolved","updateComponentPreRender","bu","u","originNext","nextTree","prevTree","bm","c1","prevShapeFlag","c2","patchKeyedChildren","patchUnkeyedChildren","oldLength","newLength","commonLength","Math","min","nextChild","l2","e1","e2","nextPos","s1","s2","keyToNewIndexMap","j","patched","toBePatched","moved","maxNewIndexSoFar","newIndexToOldIndexMap","prevChild","newIndex","increasingNewIndexSequence","getSequence","nextIndex","needTransition","leave","performLeave","doRemove","deactivate","shouldInvokeDirs","onVnodeBeforeUnmount","unmountComponent","onVnodeUnmounted","removeFragment","performRemove","bum","um","da","deps","_vnode","createApp","arrI","watchEffect","effect","doWatch","INITIAL_WATCHER_VALUE","watch","source","immediate","deep","flush","onTrack","onTrigger","getter","cleanup","s","traverse","onInvalidate","baseGetter","runner","onStop","active","newValue","lazy","recordInstanceBoundEffect","instanceWatch","publicThis","this","bind","provide","parentProvides","inject","applyOptions","deferredData","deferredWatch","asMixin","extendsOptions","dataOptions","computed","computedOptions","methods","watchOptions","provideOptions","injectOptions","beforeMount","mounted","beforeUpdate","updated","activated","deactivated","beforeUnmount","unmounted","renderTracked","renderTriggered","errorCaptured","globalMixins","callSyncHook","applyMixins","from","methodHandler","resolveData","dataFn","createWatcher","callHookFromMixins","baseHook","selfHook","resolveMergedOptions","__merged","mergeOptions","strats","publicPropertiesMap","$","$el","$data","$props","$attrs","$slots","$refs","$parent","$root","$emit","$options","$forceUpdate","$nextTick","$watch","PublicInstanceProxyHandlers","accessCache","normalizedProps","publicGetter","cssModule","__cssModules","RuntimeCompiledPublicInstanceProxyHandlers","unscopables","emptyAppContext","setupContext","bc","rtg","rtc","compile","setupResult","setupStatefulComponent","Proxy","setup","createSetupContext","resolvedResult","handleSetupResult","finishComponentSetup","template","_rc","classifyRE","classify","__file","registry","getterOrOptions","defineComponent","h","propsOrChildren","GLOBALS_WHITE_LISTED","isGloballyWhitelisted","normalizeStyle","parseStringStyle","listDelimiterRE","propertyDelimiterRE","cssText","tmp","trim","normalizeClass","EMPTY_ARR","NO","splice","isPromise","isReservedProp","camelize","_globalThis","getGlobalThis","globalThis","self","window","global","svgNS","doc","document","tempContainer","tempSVGContainer","nodeOps","insertBefore","removeChild","tag","createElementNS","createTextNode","nodeValue","selector","setAttribute","content","temp","first","patchClass","transitionClasses","_vtc","className","patchStyle","setStyle","removeAttribute","importantRE","setProperty","prefixed","autoPrefix","prefixes","prefixCache","rawName","cached","xlinkNS","patchAttr","removeAttributeNS","setAttributeNS","isBoolean","patchDOMProp","_value","e","_getNow","now","createEvent","timeStamp","cachedNow","reset","getNow","addEventListener","removeEventListener","patchEvent","prevValue","nextValue","invoker","parseName","createInvoker","optionsModifierRE","initialValue","attached","patchStopImmediatePropagation","originalStop","stopImmediatePropagation","_stopped","nativeOnRE","shouldSetAsProp","_trueValue","_falseValue","TRANSITION","ANIMATION","Transition","resolveTransitionProps","DOMTransitionPropsValidators","css","duration","Number","enterFromClass","enterActiveClass","enterToClass","appearFromClass","appearActiveClass","appearToClass","leaveFromClass","leaveActiveClass","leaveToClass","baseProps","durations","normalizeDuration","enterDuration","leaveDuration","finishEnter","isAppear","removeTransitionClass","finishLeave","makeEnterHook","nextFrame","addTransitionClass","setTimeout","whenTransitionEnds","NumberOf","cls","classList","delete","size","requestAnimationFrame","expectedType","timeout","propCount","getTransitionInfo","endEvent","ended","onEnd","styles","getComputedStyle","getStyleProperties","transitionDelays","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationDurations","animationTimeout","max","hasTransform","delays","d","toMs","WeakMap","rendererOptions","ensureRenderer","containerOrSelector","normalizeContainer","hasSymbol","toStringTag","PolySymbol","matchedRouteKey","viewDepthKey","routerKey","routeLocationKey","isBrowser","isESModule","__esModule","applyToParams","params","newParams","noop","TRAILING_SLASH_RE","removeTrailingSlash","path","parseURL","parseQuery","location","currentLocation","query","searchString","hash","searchPos","hashPos","fullPath","stringifyURL","stringifyQuery","stripBase","pathname","base","isSameRouteLocation","aLastIndex","matched","bLastIndex","isSameRouteRecord","isSameRouteLocationParams","aliasOf","isSameRouteLocationParamsValue","isEquivalentArray","every","NavigationType","NavigationDirection","normalizeBase","baseEl","getAttribute","BEFORE_HASH_RE","createHref","getElementPosition","offset","docRect","documentElement","getBoundingClientRect","elRect","behavior","left","top","computeScrollPosition","pageXOffset","pageYOffset","scrollToPosition","position","scrollToOptions","positionEl","isIdSelector","getElementById","foundEl","scrollTo","getScrollKey","delta","history","scrollPositions","saveScrollPosition","scrollPosition","getSavedScrollPosition","scroll","createBaseLocation","protocol","host","createCurrentLocation","search","pathFromHash","useHistoryListeners","historyState","listeners","teardowns","pauseState","popStateHandler","fromState","listener","pop","direction","forward","back","unknown","pauseListeners","listen","callback","teardown","index","beforeUnloadListener","replaceState","destroy","buildState","replaced","computeScroll","useHistoryStateNavigation","changeLocation","url","currentState","createWebHistory","historyNavigation","historyListeners","go","triggerListeners","routerHistory","HASH_RE","AMPERSAND_RE","SLASH_RE","EQUAL_RE","IM_RE","ENC_BRACKET_OPEN_RE","ENC_BRACKET_CLOSE_RE","ENC_CARET_RE","ENC_BACKTICK_RE","ENC_CURLY_OPEN_RE","ENC_PIPE_RE","ENC_CURLY_CLOSE_RE","commonEncode","encodeURI","encodeHash","encodeQueryProperty","encodePath","encodeParam","decode","decodeURIComponent","hasLeadingIM","searchParams","rawValue","currentValue","normalizeQuery","normalizedQuery","isRouteLocation","route","isRouteName","START_LOCATION_NORMALIZED","meta","redirectedFrom","NavigationFailureSymbol","NavigationFailureType","ErrorTypeMessages","stringifyRoute","createRouterError","Error","isNavigationFailure","propertiesToLog","BASE_PARAM_PATTERN","BASE_PATH_PARSER_OPTIONS","sensitive","strict","REGEX_CHARS_RE","tokensToParser","segments","extraOptions","score","segment","segmentScores","tokenIndex","token","subSegmentScore","repeatable","optional","regexp","re","message","subPattern","parse","avoidDuplicatedSlash","param","compareScoreArray","diff","comparePathParserScore","aScore","bScore","ROOT_TOKEN","VALID_PARAM_RE","tokenizePath","crash","buffer","previousState","tokens","finalizeSegment","char","customRe","consumeBuffer","addCharToBuffer","createRouteRecordMatcher","record","parser","existingKeys","matcher","alias","createRouterMatcher","routes","globalOptions","matchers","matcherMap","getRecordMatcher","addRoute","originalRecord","isRootAdd","mainNormalizedRecord","normalizeRouteRecord","normalizedRecords","aliases","originalMatcher","normalizedRecord","parentPath","connectingSlash","checkMissingParamsInAbsolutePath","checkSameParams","isAliasRecord","removeRoute","insertMatcher","matcherRef","getRoutes","paramsFromLocation","k","find","parentMatcher","mergeMetaFields","redirect","normalizeRecordProps","instances","leaveGuards","updateGuards","enterCallbacks","propsObject","reduce","defaults","partialOptions","isSameParam","useCallbacks","handlers","guardToPromiseFn","guard","enterCallbackArray","reject","valid","guardCall","canOnlyBeCalledOnce","extractComponentsGuards","guardType","guards","rawComponent","promise","isRouteComponent","componentPromise","resolved","resolvedComponent","useLink","router","currentRoute","activeRecordIndex","routeMatched","currentMatched","parentRecordPath","getOriginalPath","isActive","includesParams","isExactActive","navigate","guardEvent","href","RouterLinkImpl","required","activeClass","exactActiveClass","custom","link","elClass","getLinkClass","linkActiveClass","linkExactActiveClass","RouterLink","metaKey","altKey","ctrlKey","shiftKey","defaultPrevented","button","currentTarget","preventDefault","outer","inner","innerValue","outerValue","propClass","globalClass","defaultClass","RouterViewImpl","warnDeprecatedUsage","depth","matchedRouteRef","viewRef","matchedRoute","ViewComponent","routePropsOption","routeProps","currentName","RouterView","parentName","createRouter","parseQuery$1","stringifyQuery$1","scrollBehavior","beforeGuards","beforeResolveGuards","afterGuards","pendingLocation","scrollRestoration","normalizeParams","paramValue","encodeParams","decodeParams","parentOrRoute","recordMatcher","routeMatcher","hasRoute","rawLocation","locationNormalized","matcherLocation","locationAsObject","checkCanceledNavigation","pushWithRedirect","targetLocation","force","lastMatched","newTargetLocation","toLocation","failure","handleScroll","triggerError","finalizeNavigation","triggerAfterEach","checkCanceledNavigationAndReject","filter","reverse","leavingRecords","updatingRecords","extractChangingRecords","canceledNavigationCheck","runGuardQueue","isPush","isFirstNavigation","markAsReady","removeHistoryListener","setupListeners","_from","info","ready","started","readyHandlers","errorHandlers","isReady","removeError","removeAfterEach","_to","installedApps","beforeEach","beforeResolve","afterEach","onError","$router","reactiveRoute","unmountApp","enteringRecords","recordFrom","recordTo","targetMap","effectStack","activeEffect","ITERATE_KEY","MAP_KEY_ITERATE_KEY","isEffect","_isEffect","createReactiveEffect","stop","enableTracking","resetTracking","trackStack","pauseTracking","track","depsMap","dep","trigger","oldTarget","effectsToAdd","isAddOrDelete","run","builtInSymbols","getOwnPropertyNames","createGetter","shallowGet","readonlyGet","shallowReadonlyGet","arrayInstrumentations","isReadonly","shallow","receiver","targetIsArray","Reflect","isRef","readonly","reactive","toRaw","createSetter","shallowSet","hadKey","deleteProperty","ownKeys","mutableHandlers","readonlyHandlers","shallowReactiveHandlers","toReactive","toReadonly","toShallow","getProto","getPrototypeOf","get$1","wrap","rawKey","has$1","proto","set$1","deleteEntry","del","clear","hadItems","createForEach","thisArg","observed","wrappedCallback","createIterableMethod","method","isMap","isPair","iterator","isKeyOnly","innerIterator","createReadonlyMethod","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","iteratorMethods","createInstrumentationGetter","instrumentations","mutableCollectionHandlers","shallowCollectionHandlers","readonlyCollectionHandlers","collectionTypes","WeakSet","isObservableType","canObserve","isFrozen","createReactiveObject","shallowReactive","baseHandlers","collectionHandlers","reactiveFlag","constructor","isReactive","isProxy","convert","__v_isRef","createRef","shallowRef","newVal","unref","setter","dirty","g","module","exports"],"mappings":"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","file":"js/chunk-vendors.d2b67035.js","sourcesContent":["/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n    const map = Object.create(null);\r\n    const list = str.split(',');\r\n    for (let i = 0; i < list.length; i++) {\r\n        map[list[i]] = true;\r\n    }\r\n    return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\n// Patch flags are optimization hints generated by the compiler.\r\n// when a block with dynamicChildren is encountered during diff, the algorithm\r\n// enters \"optimized mode\". In this mode, we know that the vdom is produced by\r\n// a render function generated by the compiler, so the algorithm only needs to\r\n// handle updates explicitly marked by these patch flags.\r\n// dev only flag -> name mapping\r\nconst PatchFlagNames = {\r\n    [1 /* TEXT */]: `TEXT`,\r\n    [2 /* CLASS */]: `CLASS`,\r\n    [4 /* STYLE */]: `STYLE`,\r\n    [8 /* PROPS */]: `PROPS`,\r\n    [16 /* FULL_PROPS */]: `FULL_PROPS`,\r\n    [32 /* HYDRATE_EVENTS */]: `HYDRATE_EVENTS`,\r\n    [64 /* STABLE_FRAGMENT */]: `STABLE_FRAGMENT`,\r\n    [128 /* KEYED_FRAGMENT */]: `KEYED_FRAGMENT`,\r\n    [256 /* UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`,\r\n    [1024 /* DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`,\r\n    [512 /* NEED_PATCH */]: `NEED_PATCH`,\r\n    [-1 /* HOISTED */]: `HOISTED`,\r\n    [-2 /* BAIL */]: `BAIL`\r\n};\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n    'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n    'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nconst range = 2;\r\nfunction generateCodeFrame(source, start = 0, end = source.length) {\r\n    const lines = source.split(/\\r?\\n/);\r\n    let count = 0;\r\n    const res = [];\r\n    for (let i = 0; i < lines.length; i++) {\r\n        count += lines[i].length + 1;\r\n        if (count >= start) {\r\n            for (let j = i - range; j <= i + range || end > count; j++) {\r\n                if (j < 0 || j >= lines.length)\r\n                    continue;\r\n                const line = j + 1;\r\n                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);\r\n                const lineLength = lines[j].length;\r\n                if (j === i) {\r\n                    // push underline\r\n                    const pad = start - (count - lineLength) + 1;\r\n                    const length = Math.max(1, end > count ? lineLength - pad : end - start);\r\n                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));\r\n                }\r\n                else if (j > i) {\r\n                    if (end > count) {\r\n                        const length = Math.max(Math.min(end - count, lineLength), 1);\r\n                        res.push(`   |  ` + '^'.repeat(length));\r\n                    }\r\n                    count += lineLength + 1;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    }\r\n    return res.join('\\n');\r\n}\n\nconst mockError = () => mockWarn(true);\r\nfunction mockWarn(asError = false) {\r\n    expect.extend({\r\n        toHaveBeenWarned(received) {\r\n            asserted.add(received);\r\n            const passed = warn.mock.calls.some(args => args[0].indexOf(received) > -1);\r\n            if (passed) {\r\n                return {\r\n                    pass: true,\r\n                    message: () => `expected \"${received}\" not to have been warned.`\r\n                };\r\n            }\r\n            else {\r\n                const msgs = warn.mock.calls.map(args => args[0]).join('\\n - ');\r\n                return {\r\n                    pass: false,\r\n                    message: () => `expected \"${received}\" to have been warned.\\n\\nActual messages:\\n\\n - ${msgs}`\r\n                };\r\n            }\r\n        },\r\n        toHaveBeenWarnedLast(received) {\r\n            asserted.add(received);\r\n            const passed = warn.mock.calls[warn.mock.calls.length - 1][0].indexOf(received) > -1;\r\n            if (passed) {\r\n                return {\r\n                    pass: true,\r\n                    message: () => `expected \"${received}\" not to have been warned last.`\r\n                };\r\n            }\r\n            else {\r\n                const msgs = warn.mock.calls.map(args => args[0]).join('\\n - ');\r\n                return {\r\n                    pass: false,\r\n                    message: () => `expected \"${received}\" to have been warned last.\\n\\nActual messages:\\n\\n - ${msgs}`\r\n                };\r\n            }\r\n        },\r\n        toHaveBeenWarnedTimes(received, n) {\r\n            asserted.add(received);\r\n            let found = 0;\r\n            warn.mock.calls.forEach(args => {\r\n                if (args[0].indexOf(received) > -1) {\r\n                    found++;\r\n                }\r\n            });\r\n            if (found === n) {\r\n                return {\r\n                    pass: true,\r\n                    message: () => `expected \"${received}\" to have been warned ${n} times.`\r\n                };\r\n            }\r\n            else {\r\n                return {\r\n                    pass: false,\r\n                    message: () => `expected \"${received}\" to have been warned ${n} times but got ${found}.`\r\n                };\r\n            }\r\n        }\r\n    });\r\n    let warn;\r\n    const asserted = new Set();\r\n    beforeEach(() => {\r\n        asserted.clear();\r\n        warn = jest.spyOn(console, asError ? 'error' : 'warn');\r\n        warn.mockImplementation(() => { });\r\n    });\r\n    afterEach(() => {\r\n        const assertedArray = Array.from(asserted);\r\n        const nonAssertedWarnings = warn.mock.calls\r\n            .map(args => args[0])\r\n            .filter(received => {\r\n            return !assertedArray.some(assertedMsg => {\r\n                return received.indexOf(assertedMsg) > -1;\r\n            });\r\n        });\r\n        warn.mockRestore();\r\n        if (nonAssertedWarnings.length) {\r\n            nonAssertedWarnings.forEach(warning => {\r\n                console.warn(warning);\r\n            });\r\n            throw new Error(`test case threw unexpected warnings.`);\r\n        }\r\n    });\r\n}\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n/**\r\n * The full list is needed during SSR to produce the correct initial markup.\r\n */\r\nconst isBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs +\r\n    `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,` +\r\n    `loop,open,required,reversed,scoped,seamless,` +\r\n    `checked,muted,multiple,selected`);\r\nconst unsafeAttrCharRE = /[>/=\"'\\u0009\\u000a\\u000c\\u0020]/;\r\nconst attrValidationCache = {};\r\nfunction isSSRSafeAttrName(name) {\r\n    if (attrValidationCache.hasOwnProperty(name)) {\r\n        return attrValidationCache[name];\r\n    }\r\n    const isUnsafe = unsafeAttrCharRE.test(name);\r\n    if (isUnsafe) {\r\n        console.error(`unsafe attribute name: ${name}`);\r\n    }\r\n    return (attrValidationCache[name] = !isUnsafe);\r\n}\r\nconst propsToAttrMap = {\r\n    acceptCharset: 'accept-charset',\r\n    className: 'class',\r\n    htmlFor: 'for',\r\n    httpEquiv: 'http-equiv'\r\n};\r\n/**\r\n * CSS properties that accept plain numbers\r\n */\r\nconst isNoUnitNumericStyleProp = /*#__PURE__*/ makeMap(`animation-iteration-count,border-image-outset,border-image-slice,` +\r\n    `border-image-width,box-flex,box-flex-group,box-ordinal-group,column-count,` +\r\n    `columns,flex,flex-grow,flex-positive,flex-shrink,flex-negative,flex-order,` +\r\n    `grid-row,grid-row-end,grid-row-span,grid-row-start,grid-column,` +\r\n    `grid-column-end,grid-column-span,grid-column-start,font-weight,line-clamp,` +\r\n    `line-height,opacity,order,orphans,tab-size,widows,z-index,zoom,` +\r\n    // SVG\r\n    `fill-opacity,flood-opacity,stop-opacity,stroke-dasharray,stroke-dashoffset,` +\r\n    `stroke-miterlimit,stroke-opacity,stroke-width`);\r\n/**\r\n * Known attributes, this is used for stringification of runtime static nodes\r\n * so that we don't stringify bindings that cannot be set from HTML.\r\n * Don't also forget to allow `data-*` and `aria-*`!\r\n * Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes\r\n */\r\nconst isKnownAttr = /*#__PURE__*/ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,` +\r\n    `autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,` +\r\n    `border,buffered,capture,challenge,charset,checked,cite,class,code,` +\r\n    `codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,` +\r\n    `coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,` +\r\n    `disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,` +\r\n    `formaction,formenctype,formmethod,formnovalidate,formtarget,headers,` +\r\n    `height,hidden,high,href,hreflang,http-equiv,icon,id,importance,integrity,` +\r\n    `ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,` +\r\n    `manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,` +\r\n    `open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,` +\r\n    `referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,` +\r\n    `selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,` +\r\n    `start,step,style,summary,tabindex,target,title,translate,type,usemap,` +\r\n    `value,width,wrap`);\n\nfunction normalizeStyle(value) {\r\n    if (isArray(value)) {\r\n        const res = {};\r\n        for (let i = 0; i < value.length; i++) {\r\n            const item = value[i];\r\n            const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n            if (normalized) {\r\n                for (const key in normalized) {\r\n                    res[key] = normalized[key];\r\n                }\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n    else if (isObject(value)) {\r\n        return value;\r\n    }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n    const ret = {};\r\n    cssText.split(listDelimiterRE).forEach(item => {\r\n        if (item) {\r\n            const tmp = item.split(propertyDelimiterRE);\r\n            tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n        }\r\n    });\r\n    return ret;\r\n}\r\nfunction stringifyStyle(styles) {\r\n    let ret = '';\r\n    if (!styles) {\r\n        return ret;\r\n    }\r\n    for (const key in styles) {\r\n        const value = styles[key];\r\n        const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);\r\n        if (isString(value) ||\r\n            (typeof value === 'number' && isNoUnitNumericStyleProp(normalizedKey))) {\r\n            // only render valid values\r\n            ret += `${normalizedKey}:${value};`;\r\n        }\r\n    }\r\n    return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n    let res = '';\r\n    if (isString(value)) {\r\n        res = value;\r\n    }\r\n    else if (isArray(value)) {\r\n        for (let i = 0; i < value.length; i++) {\r\n            res += normalizeClass(value[i]) + ' ';\r\n        }\r\n    }\r\n    else if (isObject(value)) {\r\n        for (const name in value) {\r\n            if (value[name]) {\r\n                res += name + ' ';\r\n            }\r\n        }\r\n    }\r\n    return res.trim();\r\n}\n\n// These tag configs are shared between compiler-dom and runtime-dom, so they\r\n// https://developer.mozilla.org/en-US/docs/Web/HTML/Element\r\nconst HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' +\r\n    'header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,' +\r\n    'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' +\r\n    'data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,' +\r\n    'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' +\r\n    'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' +\r\n    'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' +\r\n    'option,output,progress,select,textarea,details,dialog,menu,' +\r\n    'summary,content,template,blockquote,iframe,tfoot';\r\n// https://developer.mozilla.org/en-US/docs/Web/SVG/Element\r\nconst SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +\r\n    'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +\r\n    'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +\r\n    'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +\r\n    'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +\r\n    'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +\r\n    'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +\r\n    'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +\r\n    'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +\r\n    'text,textPath,title,tspan,unknown,use,view';\r\nconst VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';\r\nconst isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS);\r\nconst isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS);\r\nconst isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS);\n\nconst escapeRE = /[\"'&<>]/;\r\nfunction escapeHtml(string) {\r\n    const str = '' + string;\r\n    const match = escapeRE.exec(str);\r\n    if (!match) {\r\n        return str;\r\n    }\r\n    let html = '';\r\n    let escaped;\r\n    let index;\r\n    let lastIndex = 0;\r\n    for (index = match.index; index < str.length; index++) {\r\n        switch (str.charCodeAt(index)) {\r\n            case 34: // \"\r\n                escaped = '&quot;';\r\n                break;\r\n            case 38: // &\r\n                escaped = '&amp;';\r\n                break;\r\n            case 39: // '\r\n                escaped = '&#39;';\r\n                break;\r\n            case 60: // <\r\n                escaped = '&lt;';\r\n                break;\r\n            case 62: // >\r\n                escaped = '&gt;';\r\n                break;\r\n            default:\r\n                continue;\r\n        }\r\n        if (lastIndex !== index) {\r\n            html += str.substring(lastIndex, index);\r\n        }\r\n        lastIndex = index + 1;\r\n        html += escaped;\r\n    }\r\n    return lastIndex !== index ? html + str.substring(lastIndex, index) : html;\r\n}\r\n// https://www.w3.org/TR/html52/syntax.html#comments\r\nconst commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;\r\nfunction escapeHtmlComment(src) {\r\n    return src.replace(commentStripRE, '');\r\n}\n\nfunction looseCompareArrays(a, b) {\r\n    if (a.length !== b.length)\r\n        return false;\r\n    let equal = true;\r\n    for (let i = 0; equal && i < a.length; i++) {\r\n        equal = looseEqual(a[i], b[i]);\r\n    }\r\n    return equal;\r\n}\r\nfunction looseEqual(a, b) {\r\n    if (a === b)\r\n        return true;\r\n    let aValidType = isDate(a);\r\n    let bValidType = isDate(b);\r\n    if (aValidType || bValidType) {\r\n        return aValidType && bValidType ? a.getTime() === b.getTime() : false;\r\n    }\r\n    aValidType = isArray(a);\r\n    bValidType = isArray(b);\r\n    if (aValidType || bValidType) {\r\n        return aValidType && bValidType ? looseCompareArrays(a, b) : false;\r\n    }\r\n    aValidType = isObject(a);\r\n    bValidType = isObject(b);\r\n    if (aValidType || bValidType) {\r\n        /* istanbul ignore if: this if will probably never be called */\r\n        if (!aValidType || !bValidType) {\r\n            return false;\r\n        }\r\n        const aKeysCount = Object.keys(a).length;\r\n        const bKeysCount = Object.keys(b).length;\r\n        if (aKeysCount !== bKeysCount) {\r\n            return false;\r\n        }\r\n        for (const key in a) {\r\n            const aHasKey = a.hasOwnProperty(key);\r\n            const bHasKey = b.hasOwnProperty(key);\r\n            if ((aHasKey && !bHasKey) ||\r\n                (!aHasKey && bHasKey) ||\r\n                !looseEqual(a[key], b[key])) {\r\n                return false;\r\n            }\r\n        }\r\n    }\r\n    return String(a) === String(b);\r\n}\r\nfunction looseIndexOf(arr, val) {\r\n    return arr.findIndex(item => looseEqual(item, val));\r\n}\n\n/**\r\n * For converting {{ interpolation }} values to displayed strings.\r\n * @private\r\n */\r\nconst toDisplayString = (val) => {\r\n    return val == null\r\n        ? ''\r\n        : isObject(val)\r\n            ? JSON.stringify(val, replacer, 2)\r\n            : String(val);\r\n};\r\nconst replacer = (_key, val) => {\r\n    if (val instanceof Map) {\r\n        return {\r\n            [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => {\r\n                entries[`${key} =>`] = val;\r\n                return entries;\r\n            }, {})\r\n        };\r\n    }\r\n    else if (val instanceof Set) {\r\n        return {\r\n            [`Set(${val.size})`]: [...val.values()]\r\n        };\r\n    }\r\n    else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {\r\n        return String(val);\r\n    }\r\n    return val;\r\n};\n\n/**\r\n * List of @babel/parser plugins that are used for template expression\r\n * transforms and SFC script transforms. By default we enable proposals slated\r\n * for ES2020. This will need to be updated as the spec moves forward.\r\n * Full list at https://babeljs.io/docs/en/next/babel-parser#plugins\r\n */\r\nconst babelParserDefautPlugins = [\r\n    'bigInt',\r\n    'optionalChaining',\r\n    'nullishCoalescingOperator'\r\n];\r\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n    ? Object.freeze({})\r\n    : {};\r\nconst EMPTY_ARR = [];\r\nconst NOOP = () => { };\r\n/**\r\n * Always return false.\r\n */\r\nconst NO = () => false;\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n    const i = arr.indexOf(el);\r\n    if (i > -1) {\r\n        arr.splice(i, 1);\r\n    }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isDate = (val) => val instanceof Date;\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n    return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n    return toTypeString(value).slice(8, -1);\r\n};\r\nconst isPlainObject = (val) => toTypeString(val) === '[object Object]';\r\nconst isReservedProp = /*#__PURE__*/ makeMap('key,ref,' +\r\n    'onVnodeBeforeMount,onVnodeMounted,' +\r\n    'onVnodeBeforeUpdate,onVnodeUpdated,' +\r\n    'onVnodeBeforeUnmount,onVnodeUnmounted');\r\nconst cacheStringFunction = (fn) => {\r\n    const cache = Object.create(null);\r\n    return ((str) => {\r\n        const hit = cache[str];\r\n        return hit || (cache[str] = fn(str));\r\n    });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => {\r\n    return str.replace(hyphenateRE, '-$1').toLowerCase();\r\n});\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => {\r\n    return str.charAt(0).toUpperCase() + str.slice(1);\r\n});\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nconst invokeArrayFns = (fns, arg) => {\r\n    for (let i = 0; i < fns.length; i++) {\r\n        fns[i](arg);\r\n    }\r\n};\r\nconst def = (obj, key, value) => {\r\n    Object.defineProperty(obj, key, {\r\n        configurable: true,\r\n        enumerable: false,\r\n        value\r\n    });\r\n};\r\nconst toNumber = (val) => {\r\n    const n = parseFloat(val);\r\n    return isNaN(n) ? val : n;\r\n};\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n    return (_globalThis ||\r\n        (_globalThis =\r\n            typeof globalThis !== 'undefined'\r\n                ? globalThis\r\n                : typeof self !== 'undefined'\r\n                    ? self\r\n                    : typeof window !== 'undefined'\r\n                        ? window\r\n                        : typeof global !== 'undefined'\r\n                            ? global\r\n                            : {}));\r\n};\n\nexport { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, PatchFlagNames, babelParserDefautPlugins, camelize, capitalize, def, escapeHtml, escapeHtmlComment, extend, generateCodeFrame, getGlobalThis, hasChanged, hasOwn, hyphenate, invokeArrayFns, isArray, isBooleanAttr, isDate, isFunction, isGloballyWhitelisted, isHTMLTag, isKnownAttr, isModelListener, isNoUnitNumericStyleProp, isObject, isOn, isPlainObject, isPromise, isReservedProp, isSSRSafeAttrName, isSVGTag, isSpecialBooleanAttr, isString, isSymbol, isVoidTag, looseEqual, looseIndexOf, makeMap, mockError, mockWarn, normalizeClass, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, stringifyStyle, toDisplayString, toNumber, toRawType, toTypeString };\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n    const map = Object.create(null);\r\n    const list = str.split(',');\r\n    for (let i = 0; i < list.length; i++) {\r\n        map[list[i]] = true;\r\n    }\r\n    return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\n// Patch flags are optimization hints generated by the compiler.\r\n// when a block with dynamicChildren is encountered during diff, the algorithm\r\n// enters \"optimized mode\". In this mode, we know that the vdom is produced by\r\n// a render function generated by the compiler, so the algorithm only needs to\r\n// handle updates explicitly marked by these patch flags.\r\n// dev only flag -> name mapping\r\nconst PatchFlagNames = {\r\n    [1 /* TEXT */]: `TEXT`,\r\n    [2 /* CLASS */]: `CLASS`,\r\n    [4 /* STYLE */]: `STYLE`,\r\n    [8 /* PROPS */]: `PROPS`,\r\n    [16 /* FULL_PROPS */]: `FULL_PROPS`,\r\n    [32 /* HYDRATE_EVENTS */]: `HYDRATE_EVENTS`,\r\n    [64 /* STABLE_FRAGMENT */]: `STABLE_FRAGMENT`,\r\n    [128 /* KEYED_FRAGMENT */]: `KEYED_FRAGMENT`,\r\n    [256 /* UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`,\r\n    [1024 /* DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`,\r\n    [512 /* NEED_PATCH */]: `NEED_PATCH`,\r\n    [-1 /* HOISTED */]: `HOISTED`,\r\n    [-2 /* BAIL */]: `BAIL`\r\n};\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n    'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n    'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nconst range = 2;\r\nfunction generateCodeFrame(source, start = 0, end = source.length) {\r\n    const lines = source.split(/\\r?\\n/);\r\n    let count = 0;\r\n    const res = [];\r\n    for (let i = 0; i < lines.length; i++) {\r\n        count += lines[i].length + 1;\r\n        if (count >= start) {\r\n            for (let j = i - range; j <= i + range || end > count; j++) {\r\n                if (j < 0 || j >= lines.length)\r\n                    continue;\r\n                const line = j + 1;\r\n                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);\r\n                const lineLength = lines[j].length;\r\n                if (j === i) {\r\n                    // push underline\r\n                    const pad = start - (count - lineLength) + 1;\r\n                    const length = Math.max(1, end > count ? lineLength - pad : end - start);\r\n                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));\r\n                }\r\n                else if (j > i) {\r\n                    if (end > count) {\r\n                        const length = Math.max(Math.min(end - count, lineLength), 1);\r\n                        res.push(`   |  ` + '^'.repeat(length));\r\n                    }\r\n                    count += lineLength + 1;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    }\r\n    return res.join('\\n');\r\n}\n\nconst mockError = () => mockWarn(true);\r\nfunction mockWarn(asError = false) {\r\n    expect.extend({\r\n        toHaveBeenWarned(received) {\r\n            asserted.add(received);\r\n            const passed = warn.mock.calls.some(args => args[0].indexOf(received) > -1);\r\n            if (passed) {\r\n                return {\r\n                    pass: true,\r\n                    message: () => `expected \"${received}\" not to have been warned.`\r\n                };\r\n            }\r\n            else {\r\n                const msgs = warn.mock.calls.map(args => args[0]).join('\\n - ');\r\n                return {\r\n                    pass: false,\r\n                    message: () => `expected \"${received}\" to have been warned.\\n\\nActual messages:\\n\\n - ${msgs}`\r\n                };\r\n            }\r\n        },\r\n        toHaveBeenWarnedLast(received) {\r\n            asserted.add(received);\r\n            const passed = warn.mock.calls[warn.mock.calls.length - 1][0].indexOf(received) > -1;\r\n            if (passed) {\r\n                return {\r\n                    pass: true,\r\n                    message: () => `expected \"${received}\" not to have been warned last.`\r\n                };\r\n            }\r\n            else {\r\n                const msgs = warn.mock.calls.map(args => args[0]).join('\\n - ');\r\n                return {\r\n                    pass: false,\r\n                    message: () => `expected \"${received}\" to have been warned last.\\n\\nActual messages:\\n\\n - ${msgs}`\r\n                };\r\n            }\r\n        },\r\n        toHaveBeenWarnedTimes(received, n) {\r\n            asserted.add(received);\r\n            let found = 0;\r\n            warn.mock.calls.forEach(args => {\r\n                if (args[0].indexOf(received) > -1) {\r\n                    found++;\r\n                }\r\n            });\r\n            if (found === n) {\r\n                return {\r\n                    pass: true,\r\n                    message: () => `expected \"${received}\" to have been warned ${n} times.`\r\n                };\r\n            }\r\n            else {\r\n                return {\r\n                    pass: false,\r\n                    message: () => `expected \"${received}\" to have been warned ${n} times but got ${found}.`\r\n                };\r\n            }\r\n        }\r\n    });\r\n    let warn;\r\n    const asserted = new Set();\r\n    beforeEach(() => {\r\n        asserted.clear();\r\n        warn = jest.spyOn(console, asError ? 'error' : 'warn');\r\n        warn.mockImplementation(() => { });\r\n    });\r\n    afterEach(() => {\r\n        const assertedArray = Array.from(asserted);\r\n        const nonAssertedWarnings = warn.mock.calls\r\n            .map(args => args[0])\r\n            .filter(received => {\r\n            return !assertedArray.some(assertedMsg => {\r\n                return received.indexOf(assertedMsg) > -1;\r\n            });\r\n        });\r\n        warn.mockRestore();\r\n        if (nonAssertedWarnings.length) {\r\n            nonAssertedWarnings.forEach(warning => {\r\n                console.warn(warning);\r\n            });\r\n            throw new Error(`test case threw unexpected warnings.`);\r\n        }\r\n    });\r\n}\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n/**\r\n * The full list is needed during SSR to produce the correct initial markup.\r\n */\r\nconst isBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs +\r\n    `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,` +\r\n    `loop,open,required,reversed,scoped,seamless,` +\r\n    `checked,muted,multiple,selected`);\r\nconst unsafeAttrCharRE = /[>/=\"'\\u0009\\u000a\\u000c\\u0020]/;\r\nconst attrValidationCache = {};\r\nfunction isSSRSafeAttrName(name) {\r\n    if (attrValidationCache.hasOwnProperty(name)) {\r\n        return attrValidationCache[name];\r\n    }\r\n    const isUnsafe = unsafeAttrCharRE.test(name);\r\n    if (isUnsafe) {\r\n        console.error(`unsafe attribute name: ${name}`);\r\n    }\r\n    return (attrValidationCache[name] = !isUnsafe);\r\n}\r\nconst propsToAttrMap = {\r\n    acceptCharset: 'accept-charset',\r\n    className: 'class',\r\n    htmlFor: 'for',\r\n    httpEquiv: 'http-equiv'\r\n};\r\n/**\r\n * CSS properties that accept plain numbers\r\n */\r\nconst isNoUnitNumericStyleProp = /*#__PURE__*/ makeMap(`animation-iteration-count,border-image-outset,border-image-slice,` +\r\n    `border-image-width,box-flex,box-flex-group,box-ordinal-group,column-count,` +\r\n    `columns,flex,flex-grow,flex-positive,flex-shrink,flex-negative,flex-order,` +\r\n    `grid-row,grid-row-end,grid-row-span,grid-row-start,grid-column,` +\r\n    `grid-column-end,grid-column-span,grid-column-start,font-weight,line-clamp,` +\r\n    `line-height,opacity,order,orphans,tab-size,widows,z-index,zoom,` +\r\n    // SVG\r\n    `fill-opacity,flood-opacity,stop-opacity,stroke-dasharray,stroke-dashoffset,` +\r\n    `stroke-miterlimit,stroke-opacity,stroke-width`);\r\n/**\r\n * Known attributes, this is used for stringification of runtime static nodes\r\n * so that we don't stringify bindings that cannot be set from HTML.\r\n * Don't also forget to allow `data-*` and `aria-*`!\r\n * Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes\r\n */\r\nconst isKnownAttr = /*#__PURE__*/ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,` +\r\n    `autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,` +\r\n    `border,buffered,capture,challenge,charset,checked,cite,class,code,` +\r\n    `codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,` +\r\n    `coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,` +\r\n    `disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,` +\r\n    `formaction,formenctype,formmethod,formnovalidate,formtarget,headers,` +\r\n    `height,hidden,high,href,hreflang,http-equiv,icon,id,importance,integrity,` +\r\n    `ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,` +\r\n    `manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,` +\r\n    `open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,` +\r\n    `referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,` +\r\n    `selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,` +\r\n    `start,step,style,summary,tabindex,target,title,translate,type,usemap,` +\r\n    `value,width,wrap`);\n\nfunction normalizeStyle(value) {\r\n    if (isArray(value)) {\r\n        const res = {};\r\n        for (let i = 0; i < value.length; i++) {\r\n            const item = value[i];\r\n            const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n            if (normalized) {\r\n                for (const key in normalized) {\r\n                    res[key] = normalized[key];\r\n                }\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n    else if (isObject(value)) {\r\n        return value;\r\n    }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n    const ret = {};\r\n    cssText.split(listDelimiterRE).forEach(item => {\r\n        if (item) {\r\n            const tmp = item.split(propertyDelimiterRE);\r\n            tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n        }\r\n    });\r\n    return ret;\r\n}\r\nfunction stringifyStyle(styles) {\r\n    let ret = '';\r\n    if (!styles) {\r\n        return ret;\r\n    }\r\n    for (const key in styles) {\r\n        const value = styles[key];\r\n        const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);\r\n        if (isString(value) ||\r\n            (typeof value === 'number' && isNoUnitNumericStyleProp(normalizedKey))) {\r\n            // only render valid values\r\n            ret += `${normalizedKey}:${value};`;\r\n        }\r\n    }\r\n    return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n    let res = '';\r\n    if (isString(value)) {\r\n        res = value;\r\n    }\r\n    else if (isArray(value)) {\r\n        for (let i = 0; i < value.length; i++) {\r\n            res += normalizeClass(value[i]) + ' ';\r\n        }\r\n    }\r\n    else if (isObject(value)) {\r\n        for (const name in value) {\r\n            if (value[name]) {\r\n                res += name + ' ';\r\n            }\r\n        }\r\n    }\r\n    return res.trim();\r\n}\n\n// These tag configs are shared between compiler-dom and runtime-dom, so they\r\n// https://developer.mozilla.org/en-US/docs/Web/HTML/Element\r\nconst HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' +\r\n    'header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,' +\r\n    'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' +\r\n    'data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,' +\r\n    'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' +\r\n    'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' +\r\n    'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' +\r\n    'option,output,progress,select,textarea,details,dialog,menu,' +\r\n    'summary,content,template,blockquote,iframe,tfoot';\r\n// https://developer.mozilla.org/en-US/docs/Web/SVG/Element\r\nconst SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +\r\n    'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +\r\n    'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +\r\n    'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +\r\n    'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +\r\n    'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +\r\n    'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +\r\n    'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +\r\n    'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +\r\n    'text,textPath,title,tspan,unknown,use,view';\r\nconst VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';\r\nconst isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS);\r\nconst isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS);\r\nconst isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS);\n\nconst escapeRE = /[\"'&<>]/;\r\nfunction escapeHtml(string) {\r\n    const str = '' + string;\r\n    const match = escapeRE.exec(str);\r\n    if (!match) {\r\n        return str;\r\n    }\r\n    let html = '';\r\n    let escaped;\r\n    let index;\r\n    let lastIndex = 0;\r\n    for (index = match.index; index < str.length; index++) {\r\n        switch (str.charCodeAt(index)) {\r\n            case 34: // \"\r\n                escaped = '&quot;';\r\n                break;\r\n            case 38: // &\r\n                escaped = '&amp;';\r\n                break;\r\n            case 39: // '\r\n                escaped = '&#39;';\r\n                break;\r\n            case 60: // <\r\n                escaped = '&lt;';\r\n                break;\r\n            case 62: // >\r\n                escaped = '&gt;';\r\n                break;\r\n            default:\r\n                continue;\r\n        }\r\n        if (lastIndex !== index) {\r\n            html += str.substring(lastIndex, index);\r\n        }\r\n        lastIndex = index + 1;\r\n        html += escaped;\r\n    }\r\n    return lastIndex !== index ? html + str.substring(lastIndex, index) : html;\r\n}\r\n// https://www.w3.org/TR/html52/syntax.html#comments\r\nconst commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;\r\nfunction escapeHtmlComment(src) {\r\n    return src.replace(commentStripRE, '');\r\n}\n\nfunction looseCompareArrays(a, b) {\r\n    if (a.length !== b.length)\r\n        return false;\r\n    let equal = true;\r\n    for (let i = 0; equal && i < a.length; i++) {\r\n        equal = looseEqual(a[i], b[i]);\r\n    }\r\n    return equal;\r\n}\r\nfunction looseEqual(a, b) {\r\n    if (a === b)\r\n        return true;\r\n    let aValidType = isDate(a);\r\n    let bValidType = isDate(b);\r\n    if (aValidType || bValidType) {\r\n        return aValidType && bValidType ? a.getTime() === b.getTime() : false;\r\n    }\r\n    aValidType = isArray(a);\r\n    bValidType = isArray(b);\r\n    if (aValidType || bValidType) {\r\n        return aValidType && bValidType ? looseCompareArrays(a, b) : false;\r\n    }\r\n    aValidType = isObject(a);\r\n    bValidType = isObject(b);\r\n    if (aValidType || bValidType) {\r\n        /* istanbul ignore if: this if will probably never be called */\r\n        if (!aValidType || !bValidType) {\r\n            return false;\r\n        }\r\n        const aKeysCount = Object.keys(a).length;\r\n        const bKeysCount = Object.keys(b).length;\r\n        if (aKeysCount !== bKeysCount) {\r\n            return false;\r\n        }\r\n        for (const key in a) {\r\n            const aHasKey = a.hasOwnProperty(key);\r\n            const bHasKey = b.hasOwnProperty(key);\r\n            if ((aHasKey && !bHasKey) ||\r\n                (!aHasKey && bHasKey) ||\r\n                !looseEqual(a[key], b[key])) {\r\n                return false;\r\n            }\r\n        }\r\n    }\r\n    return String(a) === String(b);\r\n}\r\nfunction looseIndexOf(arr, val) {\r\n    return arr.findIndex(item => looseEqual(item, val));\r\n}\n\n/**\r\n * For converting {{ interpolation }} values to displayed strings.\r\n * @private\r\n */\r\nconst toDisplayString = (val) => {\r\n    return val == null\r\n        ? ''\r\n        : isObject(val)\r\n            ? JSON.stringify(val, replacer, 2)\r\n            : String(val);\r\n};\r\nconst replacer = (_key, val) => {\r\n    if (val instanceof Map) {\r\n        return {\r\n            [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => {\r\n                entries[`${key} =>`] = val;\r\n                return entries;\r\n            }, {})\r\n        };\r\n    }\r\n    else if (val instanceof Set) {\r\n        return {\r\n            [`Set(${val.size})`]: [...val.values()]\r\n        };\r\n    }\r\n    else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {\r\n        return String(val);\r\n    }\r\n    return val;\r\n};\n\n/**\r\n * List of @babel/parser plugins that are used for template expression\r\n * transforms and SFC script transforms. By default we enable proposals slated\r\n * for ES2020. This will need to be updated as the spec moves forward.\r\n * Full list at https://babeljs.io/docs/en/next/babel-parser#plugins\r\n */\r\nconst babelParserDefautPlugins = [\r\n    'bigInt',\r\n    'optionalChaining',\r\n    'nullishCoalescingOperator'\r\n];\r\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n    ? Object.freeze({})\r\n    : {};\r\nconst EMPTY_ARR = [];\r\nconst NOOP = () => { };\r\n/**\r\n * Always return false.\r\n */\r\nconst NO = () => false;\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n    const i = arr.indexOf(el);\r\n    if (i > -1) {\r\n        arr.splice(i, 1);\r\n    }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isDate = (val) => val instanceof Date;\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n    return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n    return toTypeString(value).slice(8, -1);\r\n};\r\nconst isPlainObject = (val) => toTypeString(val) === '[object Object]';\r\nconst isReservedProp = /*#__PURE__*/ makeMap('key,ref,' +\r\n    'onVnodeBeforeMount,onVnodeMounted,' +\r\n    'onVnodeBeforeUpdate,onVnodeUpdated,' +\r\n    'onVnodeBeforeUnmount,onVnodeUnmounted');\r\nconst cacheStringFunction = (fn) => {\r\n    const cache = Object.create(null);\r\n    return ((str) => {\r\n        const hit = cache[str];\r\n        return hit || (cache[str] = fn(str));\r\n    });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => {\r\n    return str.replace(hyphenateRE, '-$1').toLowerCase();\r\n});\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => {\r\n    return str.charAt(0).toUpperCase() + str.slice(1);\r\n});\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nconst invokeArrayFns = (fns, arg) => {\r\n    for (let i = 0; i < fns.length; i++) {\r\n        fns[i](arg);\r\n    }\r\n};\r\nconst def = (obj, key, value) => {\r\n    Object.defineProperty(obj, key, {\r\n        configurable: true,\r\n        enumerable: false,\r\n        value\r\n    });\r\n};\r\nconst toNumber = (val) => {\r\n    const n = parseFloat(val);\r\n    return isNaN(n) ? val : n;\r\n};\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n    return (_globalThis ||\r\n        (_globalThis =\r\n            typeof globalThis !== 'undefined'\r\n                ? globalThis\r\n                : typeof self !== 'undefined'\r\n                    ? self\r\n                    : typeof window !== 'undefined'\r\n                        ? window\r\n                        : typeof global !== 'undefined'\r\n                            ? global\r\n                            : {}));\r\n};\n\nexport { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, PatchFlagNames, babelParserDefautPlugins, camelize, capitalize, def, escapeHtml, escapeHtmlComment, extend, generateCodeFrame, getGlobalThis, hasChanged, hasOwn, hyphenate, invokeArrayFns, isArray, isBooleanAttr, isDate, isFunction, isGloballyWhitelisted, isHTMLTag, isKnownAttr, isModelListener, isNoUnitNumericStyleProp, isObject, isOn, isPlainObject, isPromise, isReservedProp, isSSRSafeAttrName, isSVGTag, isSpecialBooleanAttr, isString, isSymbol, isVoidTag, looseEqual, looseIndexOf, makeMap, mockError, mockWarn, normalizeClass, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, stringifyStyle, toDisplayString, toNumber, toRawType, toTypeString };\n","import { pauseTracking, resetTracking, isRef, toRaw, isProxy, shallowReactive, trigger, effect, stop, isReactive, reactive, shallowReadonly, track, computed as computed$1, ref } from '@vue/reactivity';\nexport { customRef, isProxy, isReactive, isReadonly, isRef, markRaw, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref } from '@vue/reactivity';\nimport { isString, isFunction, isPromise, isArray, extend, isModelListener, isOn, camelize, capitalize, EMPTY_ARR, normalizeClass, isObject, normalizeStyle, EMPTY_OBJ, hyphenate, hasOwn, def, isReservedProp, toRawType, makeMap, remove, invokeArrayFns, NO, getGlobalThis, NOOP, hasChanged, isGloballyWhitelisted } from '@vue/shared';\nexport { camelize, capitalize, toDisplayString } from '@vue/shared';\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n    stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n    stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n    // avoid props formatting or warn handler tracking deps that might be mutated\r\n    // during patch, leading to infinite recursion.\r\n    pauseTracking();\r\n    const instance = stack.length ? stack[stack.length - 1].component : null;\r\n    const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n    const trace = getComponentTrace();\r\n    if (appWarnHandler) {\r\n        callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n            msg + args.join(''),\r\n            instance && instance.proxy,\r\n            trace\r\n                .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n                .join('\\n'),\r\n            trace\r\n        ]);\r\n    }\r\n    else {\r\n        const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n        /* istanbul ignore if */\r\n        if (trace.length &&\r\n            // avoid spamming console during tests\r\n            !false) {\r\n            warnArgs.push(`\\n`, ...formatTrace(trace));\r\n        }\r\n        console.warn(...warnArgs);\r\n    }\r\n    resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n    let currentVNode = stack[stack.length - 1];\r\n    if (!currentVNode) {\r\n        return [];\r\n    }\r\n    // we can't just use the stack because it will be incomplete during updates\r\n    // that did not start from the root. Re-construct the parent chain using\r\n    // instance parent pointers.\r\n    const normalizedStack = [];\r\n    while (currentVNode) {\r\n        const last = normalizedStack[0];\r\n        if (last && last.vnode === currentVNode) {\r\n            last.recurseCount++;\r\n        }\r\n        else {\r\n            normalizedStack.push({\r\n                vnode: currentVNode,\r\n                recurseCount: 0\r\n            });\r\n        }\r\n        const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n        currentVNode = parentInstance && parentInstance.vnode;\r\n    }\r\n    return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n    const logs = [];\r\n    trace.forEach((entry, i) => {\r\n        logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n    });\r\n    return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n    const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n    const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n    const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n    const close = `>` + postfix;\r\n    return vnode.props\r\n        ? [open, ...formatProps(vnode.props), close]\r\n        : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n    const res = [];\r\n    const keys = Object.keys(props);\r\n    keys.slice(0, 3).forEach(key => {\r\n        res.push(...formatProp(key, props[key]));\r\n    });\r\n    if (keys.length > 3) {\r\n        res.push(` ...`);\r\n    }\r\n    return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n    if (isString(value)) {\r\n        value = JSON.stringify(value);\r\n        return raw ? value : [`${key}=${value}`];\r\n    }\r\n    else if (typeof value === 'number' ||\r\n        typeof value === 'boolean' ||\r\n        value == null) {\r\n        return raw ? value : [`${key}=${value}`];\r\n    }\r\n    else if (isRef(value)) {\r\n        value = formatProp(key, toRaw(value.value), true);\r\n        return raw ? value : [`${key}=Ref<`, value, `>`];\r\n    }\r\n    else if (isFunction(value)) {\r\n        return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n    }\r\n    else {\r\n        value = toRaw(value);\r\n        return raw ? value : [`${key}=`, value];\r\n    }\r\n}\n\nconst ErrorTypeStrings = {\r\n    [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n    [\"c\" /* CREATED */]: 'created hook',\r\n    [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n    [\"m\" /* MOUNTED */]: 'mounted hook',\r\n    [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n    [\"u\" /* UPDATED */]: 'updated',\r\n    [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n    [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n    [\"a\" /* ACTIVATED */]: 'activated hook',\r\n    [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n    [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n    [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n    [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n    [0 /* SETUP_FUNCTION */]: 'setup function',\r\n    [1 /* RENDER_FUNCTION */]: 'render function',\r\n    [2 /* WATCH_GETTER */]: 'watcher getter',\r\n    [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n    [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n    [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n    [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n    [7 /* VNODE_HOOK */]: 'vnode hook',\r\n    [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n    [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n    [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n    [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n    [12 /* FUNCTION_REF */]: 'ref function',\r\n    [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n    [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n        'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n    let res;\r\n    try {\r\n        res = args ? fn(...args) : fn();\r\n    }\r\n    catch (err) {\r\n        handleError(err, instance, type);\r\n    }\r\n    return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n    if (isFunction(fn)) {\r\n        const res = callWithErrorHandling(fn, instance, type, args);\r\n        if (res && isPromise(res)) {\r\n            res.catch(err => {\r\n                handleError(err, instance, type);\r\n            });\r\n        }\r\n        return res;\r\n    }\r\n    const values = [];\r\n    for (let i = 0; i < fn.length; i++) {\r\n        values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n    }\r\n    return values;\r\n}\r\nfunction handleError(err, instance, type) {\r\n    const contextVNode = instance ? instance.vnode : null;\r\n    if (instance) {\r\n        let cur = instance.parent;\r\n        // the exposed instance is the render proxy to keep it consistent with 2.x\r\n        const exposedInstance = instance.proxy;\r\n        // in production the hook receives only the error code\r\n        const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n        while (cur) {\r\n            const errorCapturedHooks = cur.ec;\r\n            if (errorCapturedHooks) {\r\n                for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n                    if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) {\r\n                        return;\r\n                    }\r\n                }\r\n            }\r\n            cur = cur.parent;\r\n        }\r\n        // app-level handling\r\n        const appErrorHandler = instance.appContext.config.errorHandler;\r\n        if (appErrorHandler) {\r\n            callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n            return;\r\n        }\r\n    }\r\n    logError(err, type, contextVNode);\r\n}\r\nfunction logError(err, type, contextVNode) {\r\n    // default behavior is crash in prod & test, recover in dev.\r\n    if ((process.env.NODE_ENV !== 'production') && ( !false)) {\r\n        const info = ErrorTypeStrings[type];\r\n        if (contextVNode) {\r\n            pushWarningContext(contextVNode);\r\n        }\r\n        warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n        console.error(err);\r\n        if (contextVNode) {\r\n            popWarningContext();\r\n        }\r\n    }\r\n    else {\r\n        throw err;\r\n    }\r\n}\n\nconst queue = [];\r\nconst postFlushCbs = [];\r\nconst p = Promise.resolve();\r\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nlet flushIndex = 0;\r\nlet pendingPostFlushCbs = null;\r\nlet pendingPostFlushIndex = 0;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n    return fn ? p.then(fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n    if (!queue.includes(job, flushIndex)) {\r\n        queue.push(job);\r\n        queueFlush();\r\n    }\r\n}\r\nfunction invalidateJob(job) {\r\n    const i = queue.indexOf(job);\r\n    if (i > -1) {\r\n        queue[i] = null;\r\n    }\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n    if (!isArray(cb)) {\r\n        if (!pendingPostFlushCbs ||\r\n            !pendingPostFlushCbs.includes(cb, pendingPostFlushIndex)) {\r\n            postFlushCbs.push(cb);\r\n        }\r\n    }\r\n    else {\r\n        // if cb is an array, it is a component lifecycle hook which can only be\r\n        // triggered by a job, which is already deduped in the main queue, so\r\n        // we can skip dupicate check here to improve perf\r\n        postFlushCbs.push(...cb);\r\n    }\r\n    queueFlush();\r\n}\r\nfunction queueFlush() {\r\n    if (!isFlushing && !isFlushPending) {\r\n        isFlushPending = true;\r\n        nextTick(flushJobs);\r\n    }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n    if (postFlushCbs.length) {\r\n        pendingPostFlushCbs = [...new Set(postFlushCbs)];\r\n        postFlushCbs.length = 0;\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            seen = seen || new Map();\r\n        }\r\n        for (pendingPostFlushIndex = 0; pendingPostFlushIndex < pendingPostFlushCbs.length; pendingPostFlushIndex++) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                checkRecursiveUpdates(seen, pendingPostFlushCbs[pendingPostFlushIndex]);\r\n            }\r\n            pendingPostFlushCbs[pendingPostFlushIndex]();\r\n        }\r\n        pendingPostFlushCbs = null;\r\n        pendingPostFlushIndex = 0;\r\n    }\r\n}\r\nconst getId = (job) => (job.id == null ? Infinity : job.id);\r\nfunction flushJobs(seen) {\r\n    isFlushPending = false;\r\n    isFlushing = true;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        seen = seen || new Map();\r\n    }\r\n    // Sort queue before flush.\r\n    // This ensures that:\r\n    // 1. Components are updated from parent to child. (because parent is always\r\n    //    created before the child so its render effect will have smaller\r\n    //    priority number)\r\n    // 2. If a component is unmounted during a parent component's update,\r\n    //    its update can be skipped.\r\n    // Jobs can never be null before flush starts, since they are only invalidated\r\n    // during execution of another flushed job.\r\n    queue.sort((a, b) => getId(a) - getId(b));\r\n    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n        const job = queue[flushIndex];\r\n        if (job) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                checkRecursiveUpdates(seen, job);\r\n            }\r\n            callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n        }\r\n    }\r\n    flushIndex = 0;\r\n    queue.length = 0;\r\n    flushPostFlushCbs(seen);\r\n    isFlushing = false;\r\n    // some postFlushCb queued jobs!\r\n    // keep flushing until it drains.\r\n    if (queue.length || postFlushCbs.length) {\r\n        flushJobs(seen);\r\n    }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n    if (!seen.has(fn)) {\r\n        seen.set(fn, 1);\r\n    }\r\n    else {\r\n        const count = seen.get(fn);\r\n        if (count > RECURSION_LIMIT) {\r\n            throw new Error('Maximum recursive updates exceeded. ' +\r\n                \"You may have code that is mutating state in your component's \" +\r\n                'render function or updated hook or watcher source function.');\r\n        }\r\n        else {\r\n            seen.set(fn, count + 1);\r\n        }\r\n    }\r\n}\n\nlet isHmrUpdating = false;\r\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n    const globalObject = typeof global !== 'undefined'\r\n        ? global\r\n        : typeof self !== 'undefined'\r\n            ? self\r\n            : typeof window !== 'undefined'\r\n                ? window\r\n                : {};\r\n    globalObject.__VUE_HMR_RUNTIME__ = {\r\n        createRecord: tryWrap(createRecord),\r\n        rerender: tryWrap(rerender),\r\n        reload: tryWrap(reload)\r\n    };\r\n}\r\nconst map = new Map();\r\nfunction registerHMR(instance) {\r\n    const id = instance.type.__hmrId;\r\n    let record = map.get(id);\r\n    if (!record) {\r\n        createRecord(id);\r\n        record = map.get(id);\r\n    }\r\n    record.add(instance);\r\n}\r\nfunction unregisterHMR(instance) {\r\n    map.get(instance.type.__hmrId).delete(instance);\r\n}\r\nfunction createRecord(id) {\r\n    if (map.has(id)) {\r\n        return false;\r\n    }\r\n    map.set(id, new Set());\r\n    return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n    const record = map.get(id);\r\n    if (!record)\r\n        return;\r\n    // Array.from creates a snapshot which avoids the set being mutated during\r\n    // updates\r\n    Array.from(record).forEach(instance => {\r\n        if (newRender) {\r\n            instance.render = newRender;\r\n        }\r\n        instance.renderCache = [];\r\n        // this flag forces child components with slot content to update\r\n        isHmrUpdating = true;\r\n        instance.update();\r\n        isHmrUpdating = false;\r\n    });\r\n}\r\nfunction reload(id, newComp) {\r\n    const record = map.get(id);\r\n    if (!record)\r\n        return;\r\n    // Array.from creates a snapshot which avoids the set being mutated during\r\n    // updates\r\n    Array.from(record).forEach(instance => {\r\n        const comp = instance.type;\r\n        if (!hmrDirtyComponents.has(comp)) {\r\n            // 1. Update existing comp definition to match new one\r\n            extend(comp, newComp);\r\n            for (const key in comp) {\r\n                if (!(key in newComp)) {\r\n                    delete comp[key];\r\n                }\r\n            }\r\n            // 2. Mark component dirty. This forces the renderer to replace the component\r\n            // on patch.\r\n            hmrDirtyComponents.add(comp);\r\n            // 3. Make sure to unmark the component after the reload.\r\n            queuePostFlushCb(() => {\r\n                hmrDirtyComponents.delete(comp);\r\n            });\r\n        }\r\n        if (instance.parent) {\r\n            // 4. Force the parent instance to re-render. This will cause all updated\r\n            // components to be unmounted and re-mounted. Queue the update so that we\r\n            // don't end up forcing the same parent to re-render multiple times.\r\n            queueJob(instance.parent.update);\r\n        }\r\n        else if (instance.appContext.reload) {\r\n            // root instance mounted via createApp() has a reload method\r\n            instance.appContext.reload();\r\n        }\r\n        else if (typeof window !== 'undefined') {\r\n            // root instance inside tree created via raw render(). Force reload.\r\n            window.location.reload();\r\n        }\r\n        else {\r\n            console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n        }\r\n    });\r\n}\r\nfunction tryWrap(fn) {\r\n    return (id, arg) => {\r\n        try {\r\n            return fn(id, arg);\r\n        }\r\n        catch (e) {\r\n            console.error(e);\r\n            console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n                `Full reload required.`);\r\n        }\r\n    };\r\n}\n\n// mark the current rendering instance for asset resolution (e.g.\r\n// resolveComponent, resolveDirective) during render\r\nlet currentRenderingInstance = null;\r\nfunction setCurrentRenderingInstance(instance) {\r\n    currentRenderingInstance = instance;\r\n}\r\n// dev only flag to track whether $attrs was used during render.\r\n// If $attrs was used during render then the warning for failed attrs\r\n// fallthrough can be suppressed.\r\nlet accessedAttrs = false;\r\nfunction markAttrsAccessed() {\r\n    accessedAttrs = true;\r\n}\r\nfunction renderComponentRoot(instance) {\r\n    const { type: Component, parent, vnode, proxy, withProxy, props, slots, attrs, emit, render, renderCache, data, setupState, ctx } = instance;\r\n    let result;\r\n    currentRenderingInstance = instance;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        accessedAttrs = false;\r\n    }\r\n    try {\r\n        let fallthroughAttrs;\r\n        if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {\r\n            // withProxy is a proxy with a different `has` trap only for\r\n            // runtime-compiled render functions using `with` block.\r\n            const proxyToUse = withProxy || proxy;\r\n            result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx));\r\n            fallthroughAttrs = attrs;\r\n        }\r\n        else {\r\n            // functional\r\n            const render = Component;\r\n            // in dev, mark attrs accessed if optional props (attrs === props)\r\n            if ((process.env.NODE_ENV !== 'production') && attrs === props) {\r\n                markAttrsAccessed();\r\n            }\r\n            result = normalizeVNode(render.length > 1\r\n                ? render(props, (process.env.NODE_ENV !== 'production')\r\n                    ? {\r\n                        get attrs() {\r\n                            markAttrsAccessed();\r\n                            return attrs;\r\n                        },\r\n                        slots,\r\n                        emit\r\n                    }\r\n                    : { attrs, slots, emit })\r\n                : render(props, null /* we know it doesn't need it */));\r\n            fallthroughAttrs = Component.props\r\n                ? attrs\r\n                : getFunctionalFallthrough(attrs);\r\n        }\r\n        // attr merging\r\n        // in dev mode, comments are preserved, and it's possible for a template\r\n        // to have comments along side the root element which makes it a fragment\r\n        let root = result;\r\n        let setRoot = undefined;\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            ;\r\n            [root, setRoot] = getChildRoot(result);\r\n        }\r\n        if (Component.inheritAttrs !== false && fallthroughAttrs) {\r\n            const keys = Object.keys(fallthroughAttrs);\r\n            const { shapeFlag } = root;\r\n            if (keys.length) {\r\n                if (shapeFlag & 1 /* ELEMENT */ ||\r\n                    shapeFlag & 6 /* COMPONENT */) {\r\n                    if (shapeFlag & 1 /* ELEMENT */ && keys.some(isModelListener)) {\r\n                        // #1643, #1543\r\n                        // component v-model listeners should only fallthrough for component\r\n                        // HOCs\r\n                        fallthroughAttrs = filterModelListeners(fallthroughAttrs);\r\n                    }\r\n                    root = cloneVNode(root, fallthroughAttrs);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production') && !accessedAttrs && root.type !== Comment) {\r\n                    const allAttrs = Object.keys(attrs);\r\n                    const eventAttrs = [];\r\n                    const extraAttrs = [];\r\n                    for (let i = 0, l = allAttrs.length; i < l; i++) {\r\n                        const key = allAttrs[i];\r\n                        if (isOn(key)) {\r\n                            // ignore v-model handlers when they fail to fallthrough\r\n                            if (!isModelListener(key)) {\r\n                                // remove `on`, lowercase first letter to reflect event casing\r\n                                // accurately\r\n                                eventAttrs.push(key[2].toLowerCase() + key.slice(3));\r\n                            }\r\n                        }\r\n                        else {\r\n                            extraAttrs.push(key);\r\n                        }\r\n                    }\r\n                    if (extraAttrs.length) {\r\n                        warn(`Extraneous non-props attributes (` +\r\n                            `${extraAttrs.join(', ')}) ` +\r\n                            `were passed to component but could not be automatically inherited ` +\r\n                            `because component renders fragment or text root nodes.`);\r\n                    }\r\n                    if (eventAttrs.length) {\r\n                        warn(`Extraneous non-emits event listeners (` +\r\n                            `${eventAttrs.join(', ')}) ` +\r\n                            `were passed to component but could not be automatically inherited ` +\r\n                            `because component renders fragment or text root nodes. ` +\r\n                            `If the listener is intended to be a component custom event listener only, ` +\r\n                            `declare it using the \"emits\" option.`);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        // inherit scopeId\r\n        const scopeId = vnode.scopeId;\r\n        // vite#536: if subtree root is created from parent slot if would already\r\n        // have the correct scopeId, in this case adding the scopeId will cause\r\n        // it to be removed if the original slot vnode is reused.\r\n        const needScopeId = scopeId && root.scopeId !== scopeId;\r\n        const treeOwnerId = parent && parent.type.__scopeId;\r\n        const slotScopeId = treeOwnerId && treeOwnerId !== scopeId ? treeOwnerId + '-s' : null;\r\n        if (needScopeId || slotScopeId) {\r\n            const extras = {};\r\n            if (needScopeId)\r\n                extras[scopeId] = '';\r\n            if (slotScopeId)\r\n                extras[slotScopeId] = '';\r\n            root = cloneVNode(root, extras);\r\n        }\r\n        // inherit directives\r\n        if (vnode.dirs) {\r\n            if ((process.env.NODE_ENV !== 'production') && !isElementRoot(root)) {\r\n                warn(`Runtime directive used on component with non-element root node. ` +\r\n                    `The directives will not function as intended.`);\r\n            }\r\n            root.dirs = vnode.dirs;\r\n        }\r\n        // inherit transition data\r\n        if (vnode.transition) {\r\n            if ((process.env.NODE_ENV !== 'production') && !isElementRoot(root)) {\r\n                warn(`Component inside <Transition> renders non-element root node ` +\r\n                    `that cannot be animated.`);\r\n            }\r\n            root.transition = vnode.transition;\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') && setRoot) {\r\n            setRoot(root);\r\n        }\r\n        else {\r\n            result = root;\r\n        }\r\n    }\r\n    catch (err) {\r\n        handleError(err, instance, 1 /* RENDER_FUNCTION */);\r\n        result = createVNode(Comment);\r\n    }\r\n    currentRenderingInstance = null;\r\n    return result;\r\n}\r\n/**\r\n * dev only\r\n */\r\nconst getChildRoot = (vnode) => {\r\n    if (vnode.type !== Fragment) {\r\n        return [vnode, undefined];\r\n    }\r\n    const rawChildren = vnode.children;\r\n    const dynamicChildren = vnode.dynamicChildren;\r\n    const children = rawChildren.filter(child => {\r\n        return !(isVNode(child) && child.type === Comment);\r\n    });\r\n    if (children.length !== 1) {\r\n        return [vnode, undefined];\r\n    }\r\n    const childRoot = children[0];\r\n    const index = rawChildren.indexOf(childRoot);\r\n    const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;\r\n    const setRoot = (updatedRoot) => {\r\n        rawChildren[index] = updatedRoot;\r\n        if (dynamicIndex > -1) {\r\n            dynamicChildren[dynamicIndex] = updatedRoot;\r\n        }\r\n        else if (dynamicChildren && updatedRoot.patchFlag > 0) {\r\n            dynamicChildren.push(updatedRoot);\r\n        }\r\n    };\r\n    return [normalizeVNode(childRoot), setRoot];\r\n};\r\nconst getFunctionalFallthrough = (attrs) => {\r\n    let res;\r\n    for (const key in attrs) {\r\n        if (key === 'class' || key === 'style' || isOn(key)) {\r\n            (res || (res = {}))[key] = attrs[key];\r\n        }\r\n    }\r\n    return res;\r\n};\r\nconst filterModelListeners = (attrs) => {\r\n    const res = {};\r\n    for (const key in attrs) {\r\n        if (!isModelListener(key)) {\r\n            res[key] = attrs[key];\r\n        }\r\n    }\r\n    return res;\r\n};\r\nconst isElementRoot = (vnode) => {\r\n    return (vnode.shapeFlag & 6 /* COMPONENT */ ||\r\n        vnode.shapeFlag & 1 /* ELEMENT */ ||\r\n        vnode.type === Comment // potential v-if branch switch\r\n    );\r\n};\r\nfunction shouldUpdateComponent(prevVNode, nextVNode, optimized) {\r\n    const { props: prevProps, children: prevChildren } = prevVNode;\r\n    const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;\r\n    // Parent component's render function was hot-updated. Since this may have\r\n    // caused the child component's slots content to have changed, we need to\r\n    // force the child to update as well.\r\n    if ((process.env.NODE_ENV !== 'production') && (prevChildren || nextChildren) && isHmrUpdating) {\r\n        return true;\r\n    }\r\n    // force child update for runtime directive or transition on component vnode.\r\n    if (nextVNode.dirs || nextVNode.transition) {\r\n        return true;\r\n    }\r\n    if (optimized && patchFlag > 0) {\r\n        if (patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n            // slot content that references values that might have changed,\r\n            // e.g. in a v-for\r\n            return true;\r\n        }\r\n        if (patchFlag & 16 /* FULL_PROPS */) {\r\n            if (!prevProps) {\r\n                return !!nextProps;\r\n            }\r\n            // presence of this flag indicates props are always non-null\r\n            return hasPropsChanged(prevProps, nextProps);\r\n        }\r\n        else if (patchFlag & 8 /* PROPS */) {\r\n            const dynamicProps = nextVNode.dynamicProps;\r\n            for (let i = 0; i < dynamicProps.length; i++) {\r\n                const key = dynamicProps[i];\r\n                if (nextProps[key] !== prevProps[key]) {\r\n                    return true;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        // this path is only taken by manually written render functions\r\n        // so presence of any children leads to a forced update\r\n        if (prevChildren || nextChildren) {\r\n            if (!nextChildren || !nextChildren.$stable) {\r\n                return true;\r\n            }\r\n        }\r\n        if (prevProps === nextProps) {\r\n            return false;\r\n        }\r\n        if (!prevProps) {\r\n            return !!nextProps;\r\n        }\r\n        if (!nextProps) {\r\n            return true;\r\n        }\r\n        return hasPropsChanged(prevProps, nextProps);\r\n    }\r\n    return false;\r\n}\r\nfunction hasPropsChanged(prevProps, nextProps) {\r\n    const nextKeys = Object.keys(nextProps);\r\n    if (nextKeys.length !== Object.keys(prevProps).length) {\r\n        return true;\r\n    }\r\n    for (let i = 0; i < nextKeys.length; i++) {\r\n        const key = nextKeys[i];\r\n        if (nextProps[key] !== prevProps[key]) {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\nfunction updateHOCHostEl({ vnode, parent }, el // HostNode\r\n) {\r\n    while (parent && parent.subTree === vnode) {\r\n        (vnode = parent.vnode).el = el;\r\n        parent = parent.parent;\r\n    }\r\n}\n\nconst isSuspense = (type) => type.__isSuspense;\r\n// Suspense exposes a component-like API, and is treated like a component\r\n// in the compiler, but internally it's a special built-in type that hooks\r\n// directly into the renderer.\r\nconst SuspenseImpl = {\r\n    // In order to make Suspense tree-shakable, we need to avoid importing it\r\n    // directly in the renderer. The renderer checks for the __isSuspense flag\r\n    // on a vnode's type and calls the `process` method, passing in renderer\r\n    // internals.\r\n    __isSuspense: true,\r\n    process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, \r\n    // platform-specific impl passed from renderer\r\n    rendererInternals) {\r\n        if (n1 == null) {\r\n            mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, rendererInternals);\r\n        }\r\n        else {\r\n            patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, optimized, rendererInternals);\r\n        }\r\n    },\r\n    hydrate: hydrateSuspense\r\n};\r\n// Force-casted public typing for h and TSX props inference\r\nconst Suspense = ( SuspenseImpl\r\n    );\r\nfunction mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, rendererInternals) {\r\n    const { p: patch, o: { createElement } } = rendererInternals;\r\n    const hiddenContainer = createElement('div');\r\n    const suspense = (n2.suspense = createSuspenseBoundary(n2, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, optimized, rendererInternals));\r\n    // start mounting the content subtree in an off-dom container\r\n    patch(null, suspense.subTree, hiddenContainer, null, parentComponent, suspense, isSVG, optimized);\r\n    // now check if we have encountered any async deps\r\n    if (suspense.deps > 0) {\r\n        // mount the fallback tree\r\n        patch(null, suspense.fallbackTree, container, anchor, parentComponent, null, // fallback tree will not have suspense context\r\n        isSVG, optimized);\r\n        n2.el = suspense.fallbackTree.el;\r\n    }\r\n    else {\r\n        // Suspense has no async deps. Just resolve.\r\n        suspense.resolve();\r\n    }\r\n}\r\nfunction patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, optimized, { p: patch }) {\r\n    const suspense = (n2.suspense = n1.suspense);\r\n    suspense.vnode = n2;\r\n    const { content, fallback } = normalizeSuspenseChildren(n2);\r\n    const oldSubTree = suspense.subTree;\r\n    const oldFallbackTree = suspense.fallbackTree;\r\n    if (!suspense.isResolved) {\r\n        patch(oldSubTree, content, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, optimized);\r\n        if (suspense.deps > 0) {\r\n            // still pending. patch the fallback tree.\r\n            patch(oldFallbackTree, fallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context\r\n            isSVG, optimized);\r\n            n2.el = fallback.el;\r\n        }\r\n        // If deps somehow becomes 0 after the patch it means the patch caused an\r\n        // async dep component to unmount and removed its dep. It will cause the\r\n        // suspense to resolve and we don't need to do anything here.\r\n    }\r\n    else {\r\n        // just normal patch inner content as a fragment\r\n        patch(oldSubTree, content, container, anchor, parentComponent, suspense, isSVG, optimized);\r\n        n2.el = content.el;\r\n    }\r\n    suspense.subTree = content;\r\n    suspense.fallbackTree = fallback;\r\n}\r\nlet hasWarned = false;\r\nfunction createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, optimized, rendererInternals, isHydrating = false) {\r\n    /* istanbul ignore if */\r\n    if ((process.env.NODE_ENV !== 'production') && !false && !hasWarned) {\r\n        hasWarned = true;\r\n        // @ts-ignore `console.info` cannot be null error\r\n        console[console.info ? 'info' : 'log'](`<Suspense> is an experimental feature and its API will likely change.`);\r\n    }\r\n    const { p: patch, m: move, um: unmount, n: next, o: { parentNode } } = rendererInternals;\r\n    const getCurrentTree = () => suspense.isResolved || suspense.isHydrating\r\n        ? suspense.subTree\r\n        : suspense.fallbackTree;\r\n    const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n    const suspense = {\r\n        vnode,\r\n        parent,\r\n        parentComponent,\r\n        isSVG,\r\n        optimized,\r\n        container,\r\n        hiddenContainer,\r\n        anchor,\r\n        deps: 0,\r\n        subTree: content,\r\n        fallbackTree: fallback,\r\n        isHydrating,\r\n        isResolved: false,\r\n        isUnmounted: false,\r\n        effects: [],\r\n        resolve() {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                if (suspense.isResolved) {\r\n                    throw new Error(`resolveSuspense() is called on an already resolved suspense boundary.`);\r\n                }\r\n                if (suspense.isUnmounted) {\r\n                    throw new Error(`resolveSuspense() is called on an already unmounted suspense boundary.`);\r\n                }\r\n            }\r\n            const { vnode, subTree, fallbackTree, effects, parentComponent, container } = suspense;\r\n            if (suspense.isHydrating) {\r\n                suspense.isHydrating = false;\r\n            }\r\n            else {\r\n                // this is initial anchor on mount\r\n                let { anchor } = suspense;\r\n                // unmount fallback tree\r\n                if (fallbackTree.el) {\r\n                    // if the fallback tree was mounted, it may have been moved\r\n                    // as part of a parent suspense. get the latest anchor for insertion\r\n                    anchor = next(fallbackTree);\r\n                    unmount(fallbackTree, parentComponent, suspense, true);\r\n                }\r\n                // move content from off-dom container to actual container\r\n                move(subTree, container, anchor, 0 /* ENTER */);\r\n            }\r\n            const el = (vnode.el = subTree.el);\r\n            // suspense as the root node of a component...\r\n            if (parentComponent && parentComponent.subTree === vnode) {\r\n                parentComponent.vnode.el = el;\r\n                updateHOCHostEl(parentComponent, el);\r\n            }\r\n            // check if there is a pending parent suspense\r\n            let parent = suspense.parent;\r\n            let hasUnresolvedAncestor = false;\r\n            while (parent) {\r\n                if (!parent.isResolved) {\r\n                    // found a pending parent suspense, merge buffered post jobs\r\n                    // into that parent\r\n                    parent.effects.push(...effects);\r\n                    hasUnresolvedAncestor = true;\r\n                    break;\r\n                }\r\n                parent = parent.parent;\r\n            }\r\n            // no pending parent suspense, flush all jobs\r\n            if (!hasUnresolvedAncestor) {\r\n                queuePostFlushCb(effects);\r\n            }\r\n            suspense.isResolved = true;\r\n            suspense.effects = [];\r\n            // invoke @resolve event\r\n            const onResolve = vnode.props && vnode.props.onResolve;\r\n            if (isFunction(onResolve)) {\r\n                onResolve();\r\n            }\r\n        },\r\n        recede() {\r\n            suspense.isResolved = false;\r\n            const { vnode, subTree, fallbackTree, parentComponent, container, hiddenContainer, isSVG, optimized } = suspense;\r\n            // move content tree back to the off-dom container\r\n            const anchor = next(subTree);\r\n            move(subTree, hiddenContainer, null, 1 /* LEAVE */);\r\n            // remount the fallback tree\r\n            patch(null, fallbackTree, container, anchor, parentComponent, null, // fallback tree will not have suspense context\r\n            isSVG, optimized);\r\n            const el = (vnode.el = fallbackTree.el);\r\n            // suspense as the root node of a component...\r\n            if (parentComponent && parentComponent.subTree === vnode) {\r\n                parentComponent.vnode.el = el;\r\n                updateHOCHostEl(parentComponent, el);\r\n            }\r\n            // invoke @recede event\r\n            const onRecede = vnode.props && vnode.props.onRecede;\r\n            if (isFunction(onRecede)) {\r\n                onRecede();\r\n            }\r\n        },\r\n        move(container, anchor, type) {\r\n            move(getCurrentTree(), container, anchor, type);\r\n            suspense.container = container;\r\n        },\r\n        next() {\r\n            return next(getCurrentTree());\r\n        },\r\n        registerDep(instance, setupRenderEffect) {\r\n            // suspense is already resolved, need to recede.\r\n            // use queueJob so it's handled synchronously after patching the current\r\n            // suspense tree\r\n            if (suspense.isResolved) {\r\n                queueJob(() => {\r\n                    suspense.recede();\r\n                });\r\n            }\r\n            const hydratedEl = instance.vnode.el;\r\n            suspense.deps++;\r\n            instance\r\n                .asyncDep.catch(err => {\r\n                handleError(err, instance, 0 /* SETUP_FUNCTION */);\r\n            })\r\n                .then(asyncSetupResult => {\r\n                // retry when the setup() promise resolves.\r\n                // component may have been unmounted before resolve.\r\n                if (instance.isUnmounted || suspense.isUnmounted) {\r\n                    return;\r\n                }\r\n                suspense.deps--;\r\n                // retry from this component\r\n                instance.asyncResolved = true;\r\n                const { vnode } = instance;\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    pushWarningContext(vnode);\r\n                }\r\n                handleSetupResult(instance, asyncSetupResult);\r\n                if (hydratedEl) {\r\n                    // vnode may have been replaced if an update happened before the\r\n                    // async dep is resolved.\r\n                    vnode.el = hydratedEl;\r\n                }\r\n                setupRenderEffect(instance, vnode, \r\n                // component may have been moved before resolve.\r\n                // if this is not a hydration, instance.subTree will be the comment\r\n                // placeholder.\r\n                hydratedEl\r\n                    ? parentNode(hydratedEl)\r\n                    : parentNode(instance.subTree.el), \r\n                // anchor will not be used if this is hydration, so only need to\r\n                // consider the comment placeholder case.\r\n                hydratedEl ? null : next(instance.subTree), suspense, isSVG, optimized);\r\n                updateHOCHostEl(instance, vnode.el);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    popWarningContext();\r\n                }\r\n                if (suspense.deps === 0) {\r\n                    suspense.resolve();\r\n                }\r\n            });\r\n        },\r\n        unmount(parentSuspense, doRemove) {\r\n            suspense.isUnmounted = true;\r\n            unmount(suspense.subTree, parentComponent, parentSuspense, doRemove);\r\n            if (!suspense.isResolved) {\r\n                unmount(suspense.fallbackTree, parentComponent, parentSuspense, doRemove);\r\n            }\r\n        }\r\n    };\r\n    return suspense;\r\n}\r\nfunction hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, optimized, rendererInternals, hydrateNode) {\r\n    /* eslint-disable no-restricted-globals */\r\n    const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, optimized, rendererInternals, true /* hydrating */));\r\n    // there are two possible scenarios for server-rendered suspense:\r\n    // - success: ssr content should be fully resolved\r\n    // - failure: ssr content should be the fallback branch.\r\n    // however, on the client we don't really know if it has failed or not\r\n    // attempt to hydrate the DOM assuming it has succeeded, but we still\r\n    // need to construct a suspense boundary first\r\n    const result = hydrateNode(node, suspense.subTree, parentComponent, suspense, optimized);\r\n    if (suspense.deps === 0) {\r\n        suspense.resolve();\r\n    }\r\n    return result;\r\n    /* eslint-enable no-restricted-globals */\r\n}\r\nfunction normalizeSuspenseChildren(vnode) {\r\n    const { shapeFlag, children } = vnode;\r\n    if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n        const { default: d, fallback } = children;\r\n        return {\r\n            content: normalizeVNode(isFunction(d) ? d() : d),\r\n            fallback: normalizeVNode(isFunction(fallback) ? fallback() : fallback)\r\n        };\r\n    }\r\n    else {\r\n        return {\r\n            content: normalizeVNode(children),\r\n            fallback: normalizeVNode(null)\r\n        };\r\n    }\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n    if (suspense && !suspense.isResolved) {\r\n        if (isArray(fn)) {\r\n            suspense.effects.push(...fn);\r\n        }\r\n        else {\r\n            suspense.effects.push(fn);\r\n        }\r\n    }\r\n    else {\r\n        queuePostFlushCb(fn);\r\n    }\r\n}\n\n/**\r\n * Wrap a slot function to memoize current rendering instance\r\n * @private\r\n */\r\nfunction withCtx(fn, ctx = currentRenderingInstance) {\r\n    if (!ctx)\r\n        return fn;\r\n    return function renderFnWithContext() {\r\n        const owner = currentRenderingInstance;\r\n        setCurrentRenderingInstance(ctx);\r\n        const res = fn.apply(null, arguments);\r\n        setCurrentRenderingInstance(owner);\r\n        return res;\r\n    };\r\n}\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\nconst scopeIdStack = [];\r\n/**\r\n * @private\r\n */\r\nfunction pushScopeId(id) {\r\n    scopeIdStack.push((currentScopeId = id));\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction popScopeId() {\r\n    scopeIdStack.pop();\r\n    currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null;\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction withScopeId(id) {\r\n    return ((fn) => withCtx(function () {\r\n        pushScopeId(id);\r\n        const res = fn.apply(this, arguments);\r\n        popScopeId();\r\n        return res;\r\n    }));\r\n}\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst isTeleportDisabled = (props) => props && (props.disabled || props.disabled === '');\r\nconst resolveTarget = (props, select) => {\r\n    const targetSelector = props && props.to;\r\n    if (isString(targetSelector)) {\r\n        if (!select) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Current renderer does not support string target for Teleports. ` +\r\n                    `(missing querySelector renderer option)`);\r\n            return null;\r\n        }\r\n        else {\r\n            const target = select(targetSelector);\r\n            if (!target) {\r\n                (process.env.NODE_ENV !== 'production') &&\r\n                    warn(`Failed to locate Teleport target with selector \"${targetSelector}\". ` +\r\n                        `Note the target element must exist before the component is mounted - ` +\r\n                        `i.e. the target cannot be rendered by the component itself, and ` +\r\n                        `ideally should be outside of the entire Vue component tree.`);\r\n            }\r\n            return target;\r\n        }\r\n    }\r\n    else {\r\n        if ((process.env.NODE_ENV !== 'production') && !targetSelector) {\r\n            warn(`Invalid Teleport target: ${targetSelector}`);\r\n        }\r\n        return targetSelector;\r\n    }\r\n};\r\nconst TeleportImpl = {\r\n    __isTeleport: true,\r\n    process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals) {\r\n        const { mc: mountChildren, pc: patchChildren, pbc: patchBlockChildren, o: { insert, querySelector, createText, createComment } } = internals;\r\n        const disabled = isTeleportDisabled(n2.props);\r\n        const { shapeFlag, children } = n2;\r\n        if (n1 == null) {\r\n            // insert anchors in the main view\r\n            const placeholder = (n2.el = (process.env.NODE_ENV !== 'production')\r\n                ? createComment('teleport start')\r\n                : createText(''));\r\n            const mainAnchor = (n2.anchor = (process.env.NODE_ENV !== 'production')\r\n                ? createComment('teleport end')\r\n                : createText(''));\r\n            insert(placeholder, container, anchor);\r\n            insert(mainAnchor, container, anchor);\r\n            const target = (n2.target = resolveTarget(n2.props, querySelector));\r\n            const targetAnchor = (n2.targetAnchor = createText(''));\r\n            if (target) {\r\n                insert(targetAnchor, target);\r\n            }\r\n            else if ((process.env.NODE_ENV !== 'production')) {\r\n                warn('Invalid Teleport target on mount:', target, `(${typeof target})`);\r\n            }\r\n            const mount = (container, anchor) => {\r\n                // Teleport *always* has Array children. This is enforced in both the\r\n                // compiler and vnode children normalization.\r\n                if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                    mountChildren(children, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                }\r\n            };\r\n            if (disabled) {\r\n                mount(container, mainAnchor);\r\n            }\r\n            else if (target) {\r\n                mount(target, targetAnchor);\r\n            }\r\n        }\r\n        else {\r\n            // update content\r\n            n2.el = n1.el;\r\n            const mainAnchor = (n2.anchor = n1.anchor);\r\n            const target = (n2.target = n1.target);\r\n            const targetAnchor = (n2.targetAnchor = n1.targetAnchor);\r\n            const wasDisabled = isTeleportDisabled(n1.props);\r\n            const currentContainer = wasDisabled ? container : target;\r\n            const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;\r\n            if (n2.dynamicChildren) {\r\n                // fast path when the teleport happens to be a block root\r\n                patchBlockChildren(n1.dynamicChildren, n2.dynamicChildren, currentContainer, parentComponent, parentSuspense, isSVG);\r\n            }\r\n            else if (!optimized) {\r\n                patchChildren(n1, n2, currentContainer, currentAnchor, parentComponent, parentSuspense, isSVG);\r\n            }\r\n            if (disabled) {\r\n                if (!wasDisabled) {\r\n                    // enabled -> disabled\r\n                    // move into main container\r\n                    moveTeleport(n2, container, mainAnchor, internals, 1 /* TOGGLE */);\r\n                }\r\n            }\r\n            else {\r\n                // target changed\r\n                if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {\r\n                    const nextTarget = (n2.target = resolveTarget(n2.props, querySelector));\r\n                    if (nextTarget) {\r\n                        moveTeleport(n2, nextTarget, null, internals, 0 /* TARGET_CHANGE */);\r\n                    }\r\n                    else if ((process.env.NODE_ENV !== 'production')) {\r\n                        warn('Invalid Teleport target on update:', target, `(${typeof target})`);\r\n                    }\r\n                }\r\n                else if (wasDisabled) {\r\n                    // disabled -> enabled\r\n                    // move into teleport target\r\n                    moveTeleport(n2, target, targetAnchor, internals, 1 /* TOGGLE */);\r\n                }\r\n            }\r\n        }\r\n    },\r\n    remove(vnode, { r: remove, o: { remove: hostRemove } }) {\r\n        const { shapeFlag, children, anchor } = vnode;\r\n        hostRemove(anchor);\r\n        if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n            for (let i = 0; i < children.length; i++) {\r\n                remove(children[i]);\r\n            }\r\n        }\r\n    },\r\n    move: moveTeleport,\r\n    hydrate: hydrateTeleport\r\n};\r\nfunction moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2 /* REORDER */) {\r\n    // move target anchor if this is a target change.\r\n    if (moveType === 0 /* TARGET_CHANGE */) {\r\n        insert(vnode.targetAnchor, container, parentAnchor);\r\n    }\r\n    const { el, anchor, shapeFlag, children, props } = vnode;\r\n    const isReorder = moveType === 2 /* REORDER */;\r\n    // move main view anchor if this is a re-order.\r\n    if (isReorder) {\r\n        insert(el, container, parentAnchor);\r\n    }\r\n    // if this is a re-order and teleport is enabled (content is in target)\r\n    // do not move children. So the opposite is: only move children if this\r\n    // is not a reorder, or the teleport is disabled\r\n    if (!isReorder || isTeleportDisabled(props)) {\r\n        // Teleport has either Array children or no children.\r\n        if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n            for (let i = 0; i < children.length; i++) {\r\n                move(children[i], container, parentAnchor, 2 /* REORDER */);\r\n            }\r\n        }\r\n    }\r\n    // move main view anchor if this is a re-order.\r\n    if (isReorder) {\r\n        insert(anchor, container, parentAnchor);\r\n    }\r\n}\r\nfunction hydrateTeleport(node, vnode, parentComponent, parentSuspense, optimized, { o: { nextSibling, parentNode, querySelector } }, hydrateChildren) {\r\n    const target = (vnode.target = resolveTarget(vnode.props, querySelector));\r\n    if (target) {\r\n        // if multiple teleports rendered to the same target element, we need to\r\n        // pick up from where the last teleport finished instead of the first node\r\n        const targetNode = target._lpa || target.firstChild;\r\n        if (vnode.shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n            if (isTeleportDisabled(vnode.props)) {\r\n                vnode.anchor = hydrateChildren(nextSibling(node), vnode, parentNode(node), parentComponent, parentSuspense, optimized);\r\n                vnode.targetAnchor = targetNode;\r\n            }\r\n            else {\r\n                vnode.anchor = nextSibling(node);\r\n                vnode.targetAnchor = hydrateChildren(targetNode, vnode, target, parentComponent, parentSuspense, optimized);\r\n            }\r\n            target._lpa =\r\n                vnode.targetAnchor && nextSibling(vnode.targetAnchor);\r\n        }\r\n    }\r\n    return vnode.anchor && nextSibling(vnode.anchor);\r\n}\r\n// Force-casted public typing for h and TSX props inference\r\nconst Teleport = TeleportImpl;\n\nconst COMPONENTS = 'components';\r\nconst DIRECTIVES = 'directives';\r\n/**\r\n * @private\r\n */\r\nfunction resolveComponent(name) {\r\n    return resolveAsset(COMPONENTS, name) || name;\r\n}\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n/**\r\n * @private\r\n */\r\nfunction resolveDynamicComponent(component) {\r\n    if (isString(component)) {\r\n        return resolveAsset(COMPONENTS, component, false) || component;\r\n    }\r\n    else {\r\n        // invalid types will fallthrough to createVNode and raise warning\r\n        return (component || NULL_DYNAMIC_COMPONENT);\r\n    }\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction resolveDirective(name) {\r\n    return resolveAsset(DIRECTIVES, name);\r\n}\r\n// implementation\r\nfunction resolveAsset(type, name, warnMissing = true) {\r\n    const instance = currentRenderingInstance || currentInstance;\r\n    if (instance) {\r\n        let camelized, capitalized;\r\n        const registry = instance[type];\r\n        let res = registry[name] ||\r\n            registry[(camelized = camelize(name))] ||\r\n            registry[(capitalized = capitalize(camelized))];\r\n        if (!res && type === COMPONENTS) {\r\n            const self = instance.type;\r\n            const selfName = self.displayName || self.name;\r\n            if (selfName &&\r\n                (selfName === name ||\r\n                    selfName === camelized ||\r\n                    selfName === capitalized)) {\r\n                res = self;\r\n            }\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') && warnMissing && !res) {\r\n            warn(`Failed to resolve ${type.slice(0, -1)}: ${name}`);\r\n        }\r\n        return res;\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`resolve${capitalize(type.slice(0, -1))} ` +\r\n            `can only be used in render() or setup().`);\r\n    }\r\n}\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\n// Since v-if and v-for are the two possible ways node structure can dynamically\r\n// change, once we consider v-if branches and each v-for fragment a block, we\r\n// can divide a template into nested blocks, and within each block the node\r\n// structure would be stable. This allows us to skip most children diffing\r\n// and only worry about the dynamic nodes (indicated by patch flags).\r\nconst blockStack = [];\r\nlet currentBlock = null;\r\n/**\r\n * Open a block.\r\n * This must be called before `createBlock`. It cannot be part of `createBlock`\r\n * because the children of the block are evaluated before `createBlock` itself\r\n * is called. The generated code typically looks like this:\r\n *\r\n * ```js\r\n * function render() {\r\n *   return (openBlock(),createBlock('div', null, [...]))\r\n * }\r\n * ```\r\n * disableTracking is true when creating a v-for fragment block, since a v-for\r\n * fragment always diffs its children.\r\n *\r\n * @private\r\n */\r\nfunction openBlock(disableTracking = false) {\r\n    blockStack.push((currentBlock = disableTracking ? null : []));\r\n}\r\n// Whether we should be tracking dynamic child nodes inside a block.\r\n// Only tracks when this value is > 0\r\n// We are not using a simple boolean because this value may need to be\r\n// incremented/decremented by nested usage of v-once (see below)\r\nlet shouldTrack = 1;\r\n/**\r\n * Block tracking sometimes needs to be disabled, for example during the\r\n * creation of a tree that needs to be cached by v-once. The compiler generates\r\n * code like this:\r\n *\r\n * ``` js\r\n * _cache[1] || (\r\n *   setBlockTracking(-1),\r\n *   _cache[1] = createVNode(...),\r\n *   setBlockTracking(1),\r\n *   _cache[1]\r\n * )\r\n * ```\r\n *\r\n * @private\r\n */\r\nfunction setBlockTracking(value) {\r\n    shouldTrack += value;\r\n}\r\n/**\r\n * Create a block root vnode. Takes the same exact arguments as `createVNode`.\r\n * A block root keeps track of dynamic nodes within the block in the\r\n * `dynamicChildren` array.\r\n *\r\n * @private\r\n */\r\nfunction createBlock(type, props, children, patchFlag, dynamicProps) {\r\n    const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */);\r\n    // save current block children on the block vnode\r\n    vnode.dynamicChildren = currentBlock || EMPTY_ARR;\r\n    // close block\r\n    blockStack.pop();\r\n    currentBlock = blockStack[blockStack.length - 1] || null;\r\n    // a block is always going to be patched, so track it as a child of its\r\n    // parent block\r\n    if (currentBlock) {\r\n        currentBlock.push(vnode);\r\n    }\r\n    return vnode;\r\n}\r\nfunction isVNode(value) {\r\n    return value ? value.__v_isVNode === true : false;\r\n}\r\nfunction isSameVNodeType(n1, n2) {\r\n    if ((process.env.NODE_ENV !== 'production') &&\r\n        n2.shapeFlag & 6 /* COMPONENT */ &&\r\n        hmrDirtyComponents.has(n2.type)) {\r\n        // HMR only: if the component has been hot-updated, force a reload.\r\n        return false;\r\n    }\r\n    return n1.type === n2.type && n1.key === n2.key;\r\n}\r\nlet vnodeArgsTransformer;\r\n/**\r\n * Internal API for registering an arguments transform for createVNode\r\n * used for creating stubs in the test-utils\r\n * It is *internal* but needs to be exposed for test-utils to pick up proper\r\n * typings\r\n */\r\nfunction transformVNodeArgs(transformer) {\r\n    vnodeArgsTransformer = transformer;\r\n}\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n    return _createVNode(...(vnodeArgsTransformer\r\n        ? vnodeArgsTransformer(args, currentRenderingInstance)\r\n        : args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n    return (ref != null\r\n        ? isArray(ref)\r\n            ? ref\r\n            : [currentRenderingInstance, ref]\r\n        : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n    ? createVNodeWithArgsTransform\r\n    : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n    if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n        if ((process.env.NODE_ENV !== 'production') && !type) {\r\n            warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n        }\r\n        type = Comment;\r\n    }\r\n    if (isVNode(type)) {\r\n        const cloned = cloneVNode(type, props);\r\n        if (children) {\r\n            normalizeChildren(cloned, children);\r\n        }\r\n        return cloned;\r\n    }\r\n    // class component normalization.\r\n    if (isFunction(type) && '__vccOpts' in type) {\r\n        type = type.__vccOpts;\r\n    }\r\n    // class & style normalization.\r\n    if (props) {\r\n        // for reactive or proxy objects, we need to clone it to enable mutation.\r\n        if (isProxy(props) || InternalObjectKey in props) {\r\n            props = extend({}, props);\r\n        }\r\n        let { class: klass, style } = props;\r\n        if (klass && !isString(klass)) {\r\n            props.class = normalizeClass(klass);\r\n        }\r\n        if (isObject(style)) {\r\n            // reactive state objects need to be cloned since they are likely to be\r\n            // mutated\r\n            if (isProxy(style) && !isArray(style)) {\r\n                style = extend({}, style);\r\n            }\r\n            props.style = normalizeStyle(style);\r\n        }\r\n    }\r\n    // encode the vnode type information into a bitmap\r\n    const shapeFlag = isString(type)\r\n        ? 1 /* ELEMENT */\r\n        :  isSuspense(type)\r\n            ? 128 /* SUSPENSE */\r\n            : isTeleport(type)\r\n                ? 64 /* TELEPORT */\r\n                : isObject(type)\r\n                    ? 4 /* STATEFUL_COMPONENT */\r\n                    : isFunction(type)\r\n                        ? 2 /* FUNCTIONAL_COMPONENT */\r\n                        : 0;\r\n    if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n        type = toRaw(type);\r\n        warn(`Vue received a Component which was made a reactive object. This can ` +\r\n            `lead to unnecessary performance overhead, and should be avoided by ` +\r\n            `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n            `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n    }\r\n    const vnode = {\r\n        __v_isVNode: true,\r\n        __v_skip: true,\r\n        type,\r\n        props,\r\n        key: props && normalizeKey(props),\r\n        ref: props && normalizeRef(props),\r\n        scopeId: currentScopeId,\r\n        children: null,\r\n        component: null,\r\n        suspense: null,\r\n        dirs: null,\r\n        transition: null,\r\n        el: null,\r\n        anchor: null,\r\n        target: null,\r\n        targetAnchor: null,\r\n        staticCount: 0,\r\n        shapeFlag,\r\n        patchFlag,\r\n        dynamicProps,\r\n        dynamicChildren: null,\r\n        appContext: null\r\n    };\r\n    // validate key\r\n    if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n        warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n    }\r\n    normalizeChildren(vnode, children);\r\n    // presence of a patch flag indicates this node needs patching on updates.\r\n    // component nodes also should always be patched, because even if the\r\n    // component doesn't need to update, it needs to persist the instance on to\r\n    // the next vnode so that it can be properly unmounted later.\r\n    if (shouldTrack > 0 &&\r\n        !isBlockNode &&\r\n        currentBlock &&\r\n        // the EVENTS flag is only for hydration and if it is the only flag, the\r\n        // vnode should not be considered dynamic due to handler caching.\r\n        patchFlag !== 32 /* HYDRATE_EVENTS */ &&\r\n        (patchFlag > 0 ||\r\n            shapeFlag & 128 /* SUSPENSE */ ||\r\n            shapeFlag & 64 /* TELEPORT */ ||\r\n            shapeFlag & 4 /* STATEFUL_COMPONENT */ ||\r\n            shapeFlag & 2 /* FUNCTIONAL_COMPONENT */)) {\r\n        currentBlock.push(vnode);\r\n    }\r\n    return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps) {\r\n    // This is intentionally NOT using spread or extend to avoid the runtime\r\n    // key enumeration cost.\r\n    const { props, patchFlag } = vnode;\r\n    const mergedProps = extraProps\r\n        ? props\r\n            ? mergeProps(props, extraProps)\r\n            : extend({}, extraProps)\r\n        : props;\r\n    return {\r\n        __v_isVNode: true,\r\n        __v_skip: true,\r\n        type: vnode.type,\r\n        props: mergedProps,\r\n        key: mergedProps && normalizeKey(mergedProps),\r\n        ref: extraProps && extraProps.ref ? normalizeRef(extraProps) : vnode.ref,\r\n        scopeId: vnode.scopeId,\r\n        children: vnode.children,\r\n        target: vnode.target,\r\n        targetAnchor: vnode.targetAnchor,\r\n        staticCount: vnode.staticCount,\r\n        shapeFlag: vnode.shapeFlag,\r\n        // if the vnode is cloned with extra props, we can no longer assume its\r\n        // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n        // note: perserve flag for fragments since they use the flag for children\r\n        // fast paths only.\r\n        patchFlag: extraProps && vnode.type !== Fragment\r\n            ? patchFlag === -1 // hoisted node\r\n                ? 16 /* FULL_PROPS */\r\n                : patchFlag | 16 /* FULL_PROPS */\r\n            : patchFlag,\r\n        dynamicProps: vnode.dynamicProps,\r\n        dynamicChildren: vnode.dynamicChildren,\r\n        appContext: vnode.appContext,\r\n        dirs: vnode.dirs,\r\n        transition: vnode.transition,\r\n        // These should technically only be non-null on mounted VNodes. However,\r\n        // they *should* be copied for kept-alive vnodes. So we just always copy\r\n        // them since them being non-null during a mount doesn't affect the logic as\r\n        // they will simply be overwritten.\r\n        component: vnode.component,\r\n        suspense: vnode.suspense,\r\n        el: vnode.el,\r\n        anchor: vnode.anchor\r\n    };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n    return createVNode(Text, null, text, flag);\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createStaticVNode(content, numberOfNodes) {\r\n    // A static vnode can contain multiple stringified elements, and the number\r\n    // of elements is necessary for hydration.\r\n    const vnode = createVNode(Static, null, content);\r\n    vnode.staticCount = numberOfNodes;\r\n    return vnode;\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createCommentVNode(text = '', \r\n// when used as the v-else branch, the comment node must be created as a\r\n// block to ensure correct updates.\r\nasBlock = false) {\r\n    return asBlock\r\n        ? (openBlock(), createBlock(Comment, null, text))\r\n        : createVNode(Comment, null, text);\r\n}\r\nfunction normalizeVNode(child) {\r\n    if (child == null || typeof child === 'boolean') {\r\n        // empty placeholder\r\n        return createVNode(Comment);\r\n    }\r\n    else if (isArray(child)) {\r\n        // fragment\r\n        return createVNode(Fragment, null, child);\r\n    }\r\n    else if (typeof child === 'object') {\r\n        // already vnode, this should be the most common since compiled templates\r\n        // always produce all-vnode children arrays\r\n        return child.el === null ? child : cloneVNode(child);\r\n    }\r\n    else {\r\n        // strings and numbers\r\n        return createVNode(Text, null, String(child));\r\n    }\r\n}\r\n// optimized normalization for template-compiled render fns\r\nfunction cloneIfMounted(child) {\r\n    return child.el === null ? child : cloneVNode(child);\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n    let type = 0;\r\n    const { shapeFlag } = vnode;\r\n    if (children == null) {\r\n        children = null;\r\n    }\r\n    else if (isArray(children)) {\r\n        type = 16 /* ARRAY_CHILDREN */;\r\n    }\r\n    else if (typeof children === 'object') {\r\n        // Normalize slot to plain children\r\n        if ((shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) &&\r\n            children.default) {\r\n            normalizeChildren(vnode, children.default());\r\n            return;\r\n        }\r\n        else {\r\n            type = 32 /* SLOTS_CHILDREN */;\r\n            const slotFlag = children._;\r\n            if (!slotFlag && !(InternalObjectKey in children)) {\r\n                children._ctx = currentRenderingInstance;\r\n            }\r\n            else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n                // a child component receives forwarded slots from the parent.\r\n                // its slot type is determined by its parent's slot type.\r\n                if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n                    children._ = 2 /* DYNAMIC */;\r\n                    vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n                }\r\n                else {\r\n                    children._ = 1 /* STABLE */;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else if (isFunction(children)) {\r\n        children = { default: children, _ctx: currentRenderingInstance };\r\n        type = 32 /* SLOTS_CHILDREN */;\r\n    }\r\n    else {\r\n        children = String(children);\r\n        // force teleport children to array so it can be moved around\r\n        if (shapeFlag & 64 /* TELEPORT */) {\r\n            type = 16 /* ARRAY_CHILDREN */;\r\n            children = [createTextVNode(children)];\r\n        }\r\n        else {\r\n            type = 8 /* TEXT_CHILDREN */;\r\n        }\r\n    }\r\n    vnode.children = children;\r\n    vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n    const ret = extend({}, args[0]);\r\n    for (let i = 1; i < args.length; i++) {\r\n        const toMerge = args[i];\r\n        for (const key in toMerge) {\r\n            if (key === 'class') {\r\n                if (ret.class !== toMerge.class) {\r\n                    ret.class = normalizeClass([ret.class, toMerge.class]);\r\n                }\r\n            }\r\n            else if (key === 'style') {\r\n                ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n            }\r\n            else if (isOn(key)) {\r\n                const existing = ret[key];\r\n                const incoming = toMerge[key];\r\n                if (existing !== incoming) {\r\n                    ret[key] = existing\r\n                        ? [].concat(existing, toMerge[key])\r\n                        : incoming;\r\n                }\r\n            }\r\n            else {\r\n                ret[key] = toMerge[key];\r\n            }\r\n        }\r\n    }\r\n    return ret;\r\n}\n\nfunction emit(instance, event, ...args) {\r\n    const props = instance.vnode.props || EMPTY_OBJ;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const options = normalizeEmitsOptions(instance.type);\r\n        if (options) {\r\n            if (!(event in options)) {\r\n                const propsOptions = normalizePropsOptions(instance.type)[0];\r\n                if (!propsOptions || !(`on` + capitalize(event) in propsOptions)) {\r\n                    warn(`Component emitted event \"${event}\" but it is neither declared in ` +\r\n                        `the emits option nor as an \"on${capitalize(event)}\" prop.`);\r\n                }\r\n            }\r\n            else {\r\n                const validator = options[event];\r\n                if (isFunction(validator)) {\r\n                    const isValid = validator(...args);\r\n                    if (!isValid) {\r\n                        warn(`Invalid event arguments: event validation failed for event \"${event}\".`);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    let handlerName = `on${capitalize(event)}`;\r\n    let handler = props[handlerName];\r\n    // for v-model update:xxx events, also trigger kebab-case equivalent\r\n    // for props passed via kebab-case\r\n    if (!handler && event.startsWith('update:')) {\r\n        handlerName = `on${capitalize(hyphenate(event))}`;\r\n        handler = props[handlerName];\r\n    }\r\n    if (!handler) {\r\n        handler = props[handlerName + `Once`];\r\n        if (!instance.emitted) {\r\n            (instance.emitted = {})[handlerName] = true;\r\n        }\r\n        else if (instance.emitted[handlerName]) {\r\n            return;\r\n        }\r\n    }\r\n    if (handler) {\r\n        callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);\r\n    }\r\n}\r\nfunction normalizeEmitsOptions(comp) {\r\n    if (hasOwn(comp, '__emits')) {\r\n        return comp.__emits;\r\n    }\r\n    const raw = comp.emits;\r\n    let normalized = {};\r\n    // apply mixin/extends props\r\n    let hasExtends = false;\r\n    if (__VUE_OPTIONS_API__ && !isFunction(comp)) {\r\n        if (comp.extends) {\r\n            hasExtends = true;\r\n            extend(normalized, normalizeEmitsOptions(comp.extends));\r\n        }\r\n        if (comp.mixins) {\r\n            hasExtends = true;\r\n            comp.mixins.forEach(m => extend(normalized, normalizeEmitsOptions(m)));\r\n        }\r\n    }\r\n    if (!raw && !hasExtends) {\r\n        return (comp.__emits = undefined);\r\n    }\r\n    if (isArray(raw)) {\r\n        raw.forEach(key => (normalized[key] = null));\r\n    }\r\n    else {\r\n        extend(normalized, raw);\r\n    }\r\n    return (comp.__emits = normalized);\r\n}\r\n// Check if an incoming prop key is a declared emit event listener.\r\n// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are\r\n// both considered matched listeners.\r\nfunction isEmitListener(comp, key) {\r\n    let emits;\r\n    if (!isOn(key) || !(emits = normalizeEmitsOptions(comp))) {\r\n        return false;\r\n    }\r\n    key = key.replace(/Once$/, '');\r\n    return (hasOwn(emits, key[2].toLowerCase() + key.slice(3)) ||\r\n        hasOwn(emits, key.slice(2)));\r\n}\n\nfunction initProps(instance, rawProps, isStateful, // result of bitwise flag comparison\r\nisSSR = false) {\r\n    const props = {};\r\n    const attrs = {};\r\n    def(attrs, InternalObjectKey, 1);\r\n    setFullProps(instance, rawProps, props, attrs);\r\n    // validation\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        validateProps(props, instance.type);\r\n    }\r\n    if (isStateful) {\r\n        // stateful\r\n        instance.props = isSSR ? props : shallowReactive(props);\r\n    }\r\n    else {\r\n        if (!instance.type.props) {\r\n            // functional w/ optional props, props === attrs\r\n            instance.props = attrs;\r\n        }\r\n        else {\r\n            // functional w/ declared props\r\n            instance.props = props;\r\n        }\r\n    }\r\n    instance.attrs = attrs;\r\n}\r\nfunction updateProps(instance, rawProps, rawPrevProps, optimized) {\r\n    const { props, attrs, vnode: { patchFlag } } = instance;\r\n    const rawCurrentProps = toRaw(props);\r\n    const [options] = normalizePropsOptions(instance.type);\r\n    if ((optimized || patchFlag > 0) && !(patchFlag & 16 /* FULL_PROPS */)) {\r\n        if (patchFlag & 8 /* PROPS */) {\r\n            // Compiler-generated props & no keys change, just set the updated\r\n            // the props.\r\n            const propsToUpdate = instance.vnode.dynamicProps;\r\n            for (let i = 0; i < propsToUpdate.length; i++) {\r\n                const key = propsToUpdate[i];\r\n                // PROPS flag guarantees rawProps to be non-null\r\n                const value = rawProps[key];\r\n                if (options) {\r\n                    // attr / props separation was done on init and will be consistent\r\n                    // in this code path, so just check if attrs have it.\r\n                    if (hasOwn(attrs, key)) {\r\n                        attrs[key] = value;\r\n                    }\r\n                    else {\r\n                        const camelizedKey = camelize(key);\r\n                        props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value);\r\n                    }\r\n                }\r\n                else {\r\n                    attrs[key] = value;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        // full props update.\r\n        setFullProps(instance, rawProps, props, attrs);\r\n        // in case of dynamic props, check if we need to delete keys from\r\n        // the props object\r\n        let kebabKey;\r\n        for (const key in rawCurrentProps) {\r\n            if (!rawProps ||\r\n                // for camelCase\r\n                (!hasOwn(rawProps, key) &&\r\n                    // it's possible the original props was passed in as kebab-case\r\n                    // and converted to camelCase (#955)\r\n                    ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey)))) {\r\n                if (options) {\r\n                    if (rawPrevProps &&\r\n                        // for camelCase\r\n                        (rawPrevProps[key] !== undefined ||\r\n                            // for kebab-case\r\n                            rawPrevProps[kebabKey] !== undefined)) {\r\n                        props[key] = resolvePropValue(options, rawProps || EMPTY_OBJ, key, undefined);\r\n                    }\r\n                }\r\n                else {\r\n                    delete props[key];\r\n                }\r\n            }\r\n        }\r\n        // in the case of functional component w/o props declaration, props and\r\n        // attrs point to the same object so it should already have been updated.\r\n        if (attrs !== rawCurrentProps) {\r\n            for (const key in attrs) {\r\n                if (!rawProps || !hasOwn(rawProps, key)) {\r\n                    delete attrs[key];\r\n                }\r\n            }\r\n        }\r\n    }\r\n    // trigger updates for $attrs in case it's used in component slots\r\n    trigger(instance, \"set\" /* SET */, '$attrs');\r\n    if ((process.env.NODE_ENV !== 'production') && rawProps) {\r\n        validateProps(props, instance.type);\r\n    }\r\n}\r\nfunction setFullProps(instance, rawProps, props, attrs) {\r\n    const [options, needCastKeys] = normalizePropsOptions(instance.type);\r\n    if (rawProps) {\r\n        for (const key in rawProps) {\r\n            const value = rawProps[key];\r\n            // key, ref are reserved and never passed down\r\n            if (isReservedProp(key)) {\r\n                continue;\r\n            }\r\n            // prop option names are camelized during normalization, so to support\r\n            // kebab -> camel conversion here we need to camelize the key.\r\n            let camelKey;\r\n            if (options && hasOwn(options, (camelKey = camelize(key)))) {\r\n                props[camelKey] = value;\r\n            }\r\n            else if (!isEmitListener(instance.type, key)) {\r\n                // Any non-declared (either as a prop or an emitted event) props are put\r\n                // into a separate `attrs` object for spreading. Make sure to preserve\r\n                // original key casing\r\n                attrs[key] = value;\r\n            }\r\n        }\r\n    }\r\n    if (needCastKeys) {\r\n        const rawCurrentProps = toRaw(props);\r\n        for (let i = 0; i < needCastKeys.length; i++) {\r\n            const key = needCastKeys[i];\r\n            props[key] = resolvePropValue(options, rawCurrentProps, key, rawCurrentProps[key]);\r\n        }\r\n    }\r\n}\r\nfunction resolvePropValue(options, props, key, value) {\r\n    const opt = options[key];\r\n    if (opt != null) {\r\n        const hasDefault = hasOwn(opt, 'default');\r\n        // default values\r\n        if (hasDefault && value === undefined) {\r\n            const defaultValue = opt.default;\r\n            value =\r\n                opt.type !== Function && isFunction(defaultValue)\r\n                    ? defaultValue()\r\n                    : defaultValue;\r\n        }\r\n        // boolean casting\r\n        if (opt[0 /* shouldCast */]) {\r\n            if (!hasOwn(props, key) && !hasDefault) {\r\n                value = false;\r\n            }\r\n            else if (opt[1 /* shouldCastTrue */] &&\r\n                (value === '' || value === hyphenate(key))) {\r\n                value = true;\r\n            }\r\n        }\r\n    }\r\n    return value;\r\n}\r\nfunction normalizePropsOptions(comp) {\r\n    if (comp.__props) {\r\n        return comp.__props;\r\n    }\r\n    const raw = comp.props;\r\n    const normalized = {};\r\n    const needCastKeys = [];\r\n    // apply mixin/extends props\r\n    let hasExtends = false;\r\n    if (__VUE_OPTIONS_API__ && !isFunction(comp)) {\r\n        const extendProps = (raw) => {\r\n            const [props, keys] = normalizePropsOptions(raw);\r\n            extend(normalized, props);\r\n            if (keys)\r\n                needCastKeys.push(...keys);\r\n        };\r\n        if (comp.extends) {\r\n            hasExtends = true;\r\n            extendProps(comp.extends);\r\n        }\r\n        if (comp.mixins) {\r\n            hasExtends = true;\r\n            comp.mixins.forEach(extendProps);\r\n        }\r\n    }\r\n    if (!raw && !hasExtends) {\r\n        return (comp.__props = EMPTY_ARR);\r\n    }\r\n    if (isArray(raw)) {\r\n        for (let i = 0; i < raw.length; i++) {\r\n            if ((process.env.NODE_ENV !== 'production') && !isString(raw[i])) {\r\n                warn(`props must be strings when using array syntax.`, raw[i]);\r\n            }\r\n            const normalizedKey = camelize(raw[i]);\r\n            if (validatePropName(normalizedKey)) {\r\n                normalized[normalizedKey] = EMPTY_OBJ;\r\n            }\r\n        }\r\n    }\r\n    else if (raw) {\r\n        if ((process.env.NODE_ENV !== 'production') && !isObject(raw)) {\r\n            warn(`invalid props options`, raw);\r\n        }\r\n        for (const key in raw) {\r\n            const normalizedKey = camelize(key);\r\n            if (validatePropName(normalizedKey)) {\r\n                const opt = raw[key];\r\n                const prop = (normalized[normalizedKey] =\r\n                    isArray(opt) || isFunction(opt) ? { type: opt } : opt);\r\n                if (prop) {\r\n                    const booleanIndex = getTypeIndex(Boolean, prop.type);\r\n                    const stringIndex = getTypeIndex(String, prop.type);\r\n                    prop[0 /* shouldCast */] = booleanIndex > -1;\r\n                    prop[1 /* shouldCastTrue */] =\r\n                        stringIndex < 0 || booleanIndex < stringIndex;\r\n                    // if the prop needs boolean casting or default value\r\n                    if (booleanIndex > -1 || hasOwn(prop, 'default')) {\r\n                        needCastKeys.push(normalizedKey);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    const normalizedEntry = [normalized, needCastKeys];\r\n    comp.__props = normalizedEntry;\r\n    return normalizedEntry;\r\n}\r\n// use function string name to check type constructors\r\n// so that it works across vms / iframes.\r\nfunction getType(ctor) {\r\n    const match = ctor && ctor.toString().match(/^\\s*function (\\w+)/);\r\n    return match ? match[1] : '';\r\n}\r\nfunction isSameType(a, b) {\r\n    return getType(a) === getType(b);\r\n}\r\nfunction getTypeIndex(type, expectedTypes) {\r\n    if (isArray(expectedTypes)) {\r\n        for (let i = 0, len = expectedTypes.length; i < len; i++) {\r\n            if (isSameType(expectedTypes[i], type)) {\r\n                return i;\r\n            }\r\n        }\r\n    }\r\n    else if (isFunction(expectedTypes)) {\r\n        return isSameType(expectedTypes, type) ? 0 : -1;\r\n    }\r\n    return -1;\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction validateProps(props, comp) {\r\n    const rawValues = toRaw(props);\r\n    const options = normalizePropsOptions(comp)[0];\r\n    for (const key in options) {\r\n        let opt = options[key];\r\n        if (opt == null)\r\n            continue;\r\n        validateProp(key, rawValues[key], opt, !hasOwn(rawValues, key));\r\n    }\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction validatePropName(key) {\r\n    if (key[0] !== '$') {\r\n        return true;\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`Invalid prop name: \"${key}\" is a reserved property.`);\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction validateProp(name, value, prop, isAbsent) {\r\n    const { type, required, validator } = prop;\r\n    // required!\r\n    if (required && isAbsent) {\r\n        warn('Missing required prop: \"' + name + '\"');\r\n        return;\r\n    }\r\n    // missing but optional\r\n    if (value == null && !prop.required) {\r\n        return;\r\n    }\r\n    // type check\r\n    if (type != null && type !== true) {\r\n        let isValid = false;\r\n        const types = isArray(type) ? type : [type];\r\n        const expectedTypes = [];\r\n        // value is valid as long as one of the specified types match\r\n        for (let i = 0; i < types.length && !isValid; i++) {\r\n            const { valid, expectedType } = assertType(value, types[i]);\r\n            expectedTypes.push(expectedType || '');\r\n            isValid = valid;\r\n        }\r\n        if (!isValid) {\r\n            warn(getInvalidTypeMessage(name, value, expectedTypes));\r\n            return;\r\n        }\r\n    }\r\n    // custom validator\r\n    if (validator && !validator(value)) {\r\n        warn('Invalid prop: custom validator check failed for prop \"' + name + '\".');\r\n    }\r\n}\r\nconst isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol');\r\n/**\r\n * dev only\r\n */\r\nfunction assertType(value, type) {\r\n    let valid;\r\n    const expectedType = getType(type);\r\n    if (isSimpleType(expectedType)) {\r\n        const t = typeof value;\r\n        valid = t === expectedType.toLowerCase();\r\n        // for primitive wrapper objects\r\n        if (!valid && t === 'object') {\r\n            valid = value instanceof type;\r\n        }\r\n    }\r\n    else if (expectedType === 'Object') {\r\n        valid = toRawType(value) === 'Object';\r\n    }\r\n    else if (expectedType === 'Array') {\r\n        valid = isArray(value);\r\n    }\r\n    else {\r\n        valid = value instanceof type;\r\n    }\r\n    return {\r\n        valid,\r\n        expectedType\r\n    };\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction getInvalidTypeMessage(name, value, expectedTypes) {\r\n    let message = `Invalid prop: type check failed for prop \"${name}\".` +\r\n        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;\r\n    const expectedType = expectedTypes[0];\r\n    const receivedType = toRawType(value);\r\n    const expectedValue = styleValue(value, expectedType);\r\n    const receivedValue = styleValue(value, receivedType);\r\n    // check if we need to specify expected value\r\n    if (expectedTypes.length === 1 &&\r\n        isExplicable(expectedType) &&\r\n        !isBoolean(expectedType, receivedType)) {\r\n        message += ` with value ${expectedValue}`;\r\n    }\r\n    message += `, got ${receivedType} `;\r\n    // check if we need to specify received value\r\n    if (isExplicable(receivedType)) {\r\n        message += `with value ${receivedValue}.`;\r\n    }\r\n    return message;\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction styleValue(value, type) {\r\n    if (type === 'String') {\r\n        return `\"${value}\"`;\r\n    }\r\n    else if (type === 'Number') {\r\n        return `${Number(value)}`;\r\n    }\r\n    else {\r\n        return `${value}`;\r\n    }\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction isExplicable(type) {\r\n    const explicitTypes = ['string', 'number', 'boolean'];\r\n    return explicitTypes.some(elem => type.toLowerCase() === elem);\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction isBoolean(...args) {\r\n    return args.some(elem => elem.toLowerCase() === 'boolean');\r\n}\n\nfunction injectHook(type, hook, target = currentInstance, prepend = false) {\r\n    if (target) {\r\n        const hooks = target[type] || (target[type] = []);\r\n        // cache the error handling wrapper for injected hooks so the same hook\r\n        // can be properly deduped by the scheduler. \"__weh\" stands for \"with error\r\n        // handling\".\r\n        const wrappedHook = hook.__weh ||\r\n            (hook.__weh = (...args) => {\r\n                if (target.isUnmounted) {\r\n                    return;\r\n                }\r\n                // disable tracking inside all lifecycle hooks\r\n                // since they can potentially be called inside effects.\r\n                pauseTracking();\r\n                // Set currentInstance during hook invocation.\r\n                // This assumes the hook does not synchronously trigger other hooks, which\r\n                // can only be false when the user does something really funky.\r\n                setCurrentInstance(target);\r\n                const res = callWithAsyncErrorHandling(hook, target, type, args);\r\n                setCurrentInstance(null);\r\n                resetTracking();\r\n                return res;\r\n            });\r\n        if (prepend) {\r\n            hooks.unshift(wrappedHook);\r\n        }\r\n        else {\r\n            hooks.push(wrappedHook);\r\n        }\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        const apiName = `on${capitalize(ErrorTypeStrings[type].replace(/ hook$/, ''))}`;\r\n        warn(`${apiName} is called when there is no active component instance to be ` +\r\n            `associated with. ` +\r\n            `Lifecycle injection APIs can only be used during execution of setup().` +\r\n            ( ` If you are using async setup(), make sure to register lifecycle ` +\r\n                    `hooks before the first await statement.`\r\n                ));\r\n    }\r\n}\r\nconst createHook = (lifecycle) => (hook, target = currentInstance) => \r\n// post-create lifecycle registrations are noops during SSR\r\n!isInSSRComponentSetup && injectHook(lifecycle, hook, target);\r\nconst onBeforeMount = createHook(\"bm\" /* BEFORE_MOUNT */);\r\nconst onMounted = createHook(\"m\" /* MOUNTED */);\r\nconst onBeforeUpdate = createHook(\"bu\" /* BEFORE_UPDATE */);\r\nconst onUpdated = createHook(\"u\" /* UPDATED */);\r\nconst onBeforeUnmount = createHook(\"bum\" /* BEFORE_UNMOUNT */);\r\nconst onUnmounted = createHook(\"um\" /* UNMOUNTED */);\r\nconst onRenderTriggered = createHook(\"rtg\" /* RENDER_TRIGGERED */);\r\nconst onRenderTracked = createHook(\"rtc\" /* RENDER_TRACKED */);\r\nconst onErrorCaptured = (hook, target = currentInstance) => {\r\n    injectHook(\"ec\" /* ERROR_CAPTURED */, hook, target);\r\n};\n\nfunction useTransitionState() {\r\n    const state = {\r\n        isMounted: false,\r\n        isLeaving: false,\r\n        isUnmounting: false,\r\n        leavingVNodes: new Map()\r\n    };\r\n    onMounted(() => {\r\n        state.isMounted = true;\r\n    });\r\n    onBeforeUnmount(() => {\r\n        state.isUnmounting = true;\r\n    });\r\n    return state;\r\n}\r\nconst BaseTransitionImpl = {\r\n    name: `BaseTransition`,\r\n    props: {\r\n        mode: String,\r\n        appear: Boolean,\r\n        persisted: Boolean,\r\n        // enter\r\n        onBeforeEnter: Function,\r\n        onEnter: Function,\r\n        onAfterEnter: Function,\r\n        onEnterCancelled: Function,\r\n        // leave\r\n        onBeforeLeave: Function,\r\n        onLeave: Function,\r\n        onAfterLeave: Function,\r\n        onLeaveCancelled: Function,\r\n        // appear\r\n        onBeforeAppear: Function,\r\n        onAppear: Function,\r\n        onAfterAppear: Function,\r\n        onAppearCancelled: Function\r\n    },\r\n    setup(props, { slots }) {\r\n        const instance = getCurrentInstance();\r\n        const state = useTransitionState();\r\n        let prevTransitionKey;\r\n        return () => {\r\n            const children = slots.default && getTransitionRawChildren(slots.default(), true);\r\n            if (!children || !children.length) {\r\n                return;\r\n            }\r\n            // warn multiple elements\r\n            if ((process.env.NODE_ENV !== 'production') && children.length > 1) {\r\n                warn('<transition> can only be used on a single element or component. Use ' +\r\n                    '<transition-group> for lists.');\r\n            }\r\n            // there's no need to track reactivity for these props so use the raw\r\n            // props for a bit better perf\r\n            const rawProps = toRaw(props);\r\n            const { mode } = rawProps;\r\n            // check mode\r\n            if ((process.env.NODE_ENV !== 'production') && mode && !['in-out', 'out-in', 'default'].includes(mode)) {\r\n                warn(`invalid <transition> mode: ${mode}`);\r\n            }\r\n            // at this point children has a guaranteed length of 1.\r\n            const child = children[0];\r\n            if (state.isLeaving) {\r\n                return emptyPlaceholder(child);\r\n            }\r\n            // in the case of <transition><keep-alive/></transition>, we need to\r\n            // compare the type of the kept-alive children.\r\n            const innerChild = getKeepAliveChild(child);\r\n            if (!innerChild) {\r\n                return emptyPlaceholder(child);\r\n            }\r\n            const enterHooks = (innerChild.transition = resolveTransitionHooks(innerChild, rawProps, state, instance));\r\n            const oldChild = instance.subTree;\r\n            const oldInnerChild = oldChild && getKeepAliveChild(oldChild);\r\n            let transitionKeyChanged = false;\r\n            const { getTransitionKey } = innerChild.type;\r\n            if (getTransitionKey) {\r\n                const key = getTransitionKey();\r\n                if (prevTransitionKey === undefined) {\r\n                    prevTransitionKey = key;\r\n                }\r\n                else if (key !== prevTransitionKey) {\r\n                    prevTransitionKey = key;\r\n                    transitionKeyChanged = true;\r\n                }\r\n            }\r\n            // handle mode\r\n            if (oldInnerChild &&\r\n                oldInnerChild.type !== Comment &&\r\n                (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {\r\n                const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance);\r\n                // update old tree's hooks in case of dynamic transition\r\n                setTransitionHooks(oldInnerChild, leavingHooks);\r\n                // switching between different views\r\n                if (mode === 'out-in') {\r\n                    state.isLeaving = true;\r\n                    // return placeholder node and queue update when leave finishes\r\n                    leavingHooks.afterLeave = () => {\r\n                        state.isLeaving = false;\r\n                        instance.update();\r\n                    };\r\n                    return emptyPlaceholder(child);\r\n                }\r\n                else if (mode === 'in-out') {\r\n                    leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {\r\n                        const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild);\r\n                        leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;\r\n                        // early removal callback\r\n                        el._leaveCb = () => {\r\n                            earlyRemove();\r\n                            el._leaveCb = undefined;\r\n                            delete enterHooks.delayedLeave;\r\n                        };\r\n                        enterHooks.delayedLeave = delayedLeave;\r\n                    };\r\n                }\r\n            }\r\n            return child;\r\n        };\r\n    }\r\n};\r\n// export the public type for h/tsx inference\r\n// also to avoid inline import() in generated d.ts files\r\nconst BaseTransition = BaseTransitionImpl;\r\nfunction getLeavingNodesForType(state, vnode) {\r\n    const { leavingVNodes } = state;\r\n    let leavingVNodesCache = leavingVNodes.get(vnode.type);\r\n    if (!leavingVNodesCache) {\r\n        leavingVNodesCache = Object.create(null);\r\n        leavingVNodes.set(vnode.type, leavingVNodesCache);\r\n    }\r\n    return leavingVNodesCache;\r\n}\r\n// The transition hooks are attached to the vnode as vnode.transition\r\n// and will be called at appropriate timing in the renderer.\r\nfunction resolveTransitionHooks(vnode, { appear, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled }, state, instance) {\r\n    const key = String(vnode.key);\r\n    const leavingVNodesCache = getLeavingNodesForType(state, vnode);\r\n    const callHook = (hook, args) => {\r\n        hook &&\r\n            callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args);\r\n    };\r\n    const hooks = {\r\n        persisted,\r\n        beforeEnter(el) {\r\n            let hook = onBeforeEnter;\r\n            if (!state.isMounted) {\r\n                if (appear) {\r\n                    hook = onBeforeAppear || onBeforeEnter;\r\n                }\r\n                else {\r\n                    return;\r\n                }\r\n            }\r\n            // for same element (v-show)\r\n            if (el._leaveCb) {\r\n                el._leaveCb(true /* cancelled */);\r\n            }\r\n            // for toggled element with same key (v-if)\r\n            const leavingVNode = leavingVNodesCache[key];\r\n            if (leavingVNode &&\r\n                isSameVNodeType(vnode, leavingVNode) &&\r\n                leavingVNode.el._leaveCb) {\r\n                // force early removal (not cancelled)\r\n                leavingVNode.el._leaveCb();\r\n            }\r\n            callHook(hook, [el]);\r\n        },\r\n        enter(el) {\r\n            let hook = onEnter;\r\n            let afterHook = onAfterEnter;\r\n            let cancelHook = onEnterCancelled;\r\n            if (!state.isMounted) {\r\n                if (appear) {\r\n                    hook = onAppear || onEnter;\r\n                    afterHook = onAfterAppear || onAfterEnter;\r\n                    cancelHook = onAppearCancelled || onEnterCancelled;\r\n                }\r\n                else {\r\n                    return;\r\n                }\r\n            }\r\n            let called = false;\r\n            const done = (el._enterCb = (cancelled) => {\r\n                if (called)\r\n                    return;\r\n                called = true;\r\n                if (cancelled) {\r\n                    callHook(cancelHook, [el]);\r\n                }\r\n                else {\r\n                    callHook(afterHook, [el]);\r\n                }\r\n                if (hooks.delayedLeave) {\r\n                    hooks.delayedLeave();\r\n                }\r\n                el._enterCb = undefined;\r\n            });\r\n            if (hook) {\r\n                hook(el, done);\r\n                if (hook.length <= 1) {\r\n                    done();\r\n                }\r\n            }\r\n            else {\r\n                done();\r\n            }\r\n        },\r\n        leave(el, remove) {\r\n            const key = String(vnode.key);\r\n            if (el._enterCb) {\r\n                el._enterCb(true /* cancelled */);\r\n            }\r\n            if (state.isUnmounting) {\r\n                return remove();\r\n            }\r\n            callHook(onBeforeLeave, [el]);\r\n            let called = false;\r\n            const done = (el._leaveCb = (cancelled) => {\r\n                if (called)\r\n                    return;\r\n                called = true;\r\n                remove();\r\n                if (cancelled) {\r\n                    callHook(onLeaveCancelled, [el]);\r\n                }\r\n                else {\r\n                    callHook(onAfterLeave, [el]);\r\n                }\r\n                el._leaveCb = undefined;\r\n                if (leavingVNodesCache[key] === vnode) {\r\n                    delete leavingVNodesCache[key];\r\n                }\r\n            });\r\n            leavingVNodesCache[key] = vnode;\r\n            if (onLeave) {\r\n                onLeave(el, done);\r\n                if (onLeave.length <= 1) {\r\n                    done();\r\n                }\r\n            }\r\n            else {\r\n                done();\r\n            }\r\n        }\r\n    };\r\n    return hooks;\r\n}\r\n// the placeholder really only handles one special case: KeepAlive\r\n// in the case of a KeepAlive in a leave phase we need to return a KeepAlive\r\n// placeholder with empty content to avoid the KeepAlive instance from being\r\n// unmounted.\r\nfunction emptyPlaceholder(vnode) {\r\n    if (isKeepAlive(vnode)) {\r\n        vnode = cloneVNode(vnode);\r\n        vnode.children = null;\r\n        return vnode;\r\n    }\r\n}\r\nfunction getKeepAliveChild(vnode) {\r\n    return isKeepAlive(vnode)\r\n        ? vnode.children\r\n            ? vnode.children[0]\r\n            : undefined\r\n        : vnode;\r\n}\r\nfunction setTransitionHooks(vnode, hooks) {\r\n    if (vnode.shapeFlag & 6 /* COMPONENT */ && vnode.component) {\r\n        setTransitionHooks(vnode.component.subTree, hooks);\r\n    }\r\n    else {\r\n        vnode.transition = hooks;\r\n    }\r\n}\r\nfunction getTransitionRawChildren(children, keepComment = false) {\r\n    let ret = [];\r\n    let keyedFragmentCount = 0;\r\n    for (let i = 0; i < children.length; i++) {\r\n        const child = children[i];\r\n        // handle fragment children case, e.g. v-for\r\n        if (child.type === Fragment) {\r\n            if (child.patchFlag & 128 /* KEYED_FRAGMENT */)\r\n                keyedFragmentCount++;\r\n            ret = ret.concat(getTransitionRawChildren(child.children, keepComment));\r\n        }\r\n        // comment placeholders should be skipped, e.g. v-if\r\n        else if (keepComment || child.type !== Comment) {\r\n            ret.push(child);\r\n        }\r\n    }\r\n    // #1126 if a transition children list contains multiple sub fragments, these\r\n    // fragments will be merged into a flat children array. Since each v-for\r\n    // fragment may contain different static bindings inside, we need to de-top\r\n    // these children to force full diffs to ensure correct behavior.\r\n    if (keyedFragmentCount > 1) {\r\n        for (let i = 0; i < ret.length; i++) {\r\n            ret[i].patchFlag = -2 /* BAIL */;\r\n        }\r\n    }\r\n    return ret;\r\n}\n\nconst isKeepAlive = (vnode) => vnode.type.__isKeepAlive;\r\nconst KeepAliveImpl = {\r\n    name: `KeepAlive`,\r\n    // Marker for special handling inside the renderer. We are not using a ===\r\n    // check directly on KeepAlive in the renderer, because importing it directly\r\n    // would prevent it from being tree-shaken.\r\n    __isKeepAlive: true,\r\n    inheritRef: true,\r\n    props: {\r\n        include: [String, RegExp, Array],\r\n        exclude: [String, RegExp, Array],\r\n        max: [String, Number]\r\n    },\r\n    setup(props, { slots }) {\r\n        const cache = new Map();\r\n        const keys = new Set();\r\n        let current = null;\r\n        const instance = getCurrentInstance();\r\n        const parentSuspense = instance.suspense;\r\n        // KeepAlive communicates with the instantiated renderer via the\r\n        // ctx where the renderer passes in its internals,\r\n        // and the KeepAlive instance exposes activate/deactivate implementations.\r\n        // The whole point of this is to avoid importing KeepAlive directly in the\r\n        // renderer to facilitate tree-shaking.\r\n        const sharedContext = instance.ctx;\r\n        const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext;\r\n        const storageContainer = createElement('div');\r\n        sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {\r\n            const instance = vnode.component;\r\n            move(vnode, container, anchor, 0 /* ENTER */, parentSuspense);\r\n            // in case props have changed\r\n            patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, optimized);\r\n            queuePostRenderEffect(() => {\r\n                instance.isDeactivated = false;\r\n                if (instance.a) {\r\n                    invokeArrayFns(instance.a);\r\n                }\r\n                const vnodeHook = vnode.props && vnode.props.onVnodeMounted;\r\n                if (vnodeHook) {\r\n                    invokeVNodeHook(vnodeHook, instance.parent, vnode);\r\n                }\r\n            }, parentSuspense);\r\n        };\r\n        sharedContext.deactivate = (vnode) => {\r\n            const instance = vnode.component;\r\n            move(vnode, storageContainer, null, 1 /* LEAVE */, parentSuspense);\r\n            queuePostRenderEffect(() => {\r\n                if (instance.da) {\r\n                    invokeArrayFns(instance.da);\r\n                }\r\n                const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;\r\n                if (vnodeHook) {\r\n                    invokeVNodeHook(vnodeHook, instance.parent, vnode);\r\n                }\r\n                instance.isDeactivated = true;\r\n            }, parentSuspense);\r\n        };\r\n        function unmount(vnode) {\r\n            // reset the shapeFlag so it can be properly unmounted\r\n            resetShapeFlag(vnode);\r\n            _unmount(vnode, instance, parentSuspense);\r\n        }\r\n        function pruneCache(filter) {\r\n            cache.forEach((vnode, key) => {\r\n                const name = getName(vnode.type);\r\n                if (name && (!filter || !filter(name))) {\r\n                    pruneCacheEntry(key);\r\n                }\r\n            });\r\n        }\r\n        function pruneCacheEntry(key) {\r\n            const cached = cache.get(key);\r\n            if (!current || cached.type !== current.type) {\r\n                unmount(cached);\r\n            }\r\n            else if (current) {\r\n                // current active instance should no longer be kept-alive.\r\n                // we can't unmount it now but it might be later, so reset its flag now.\r\n                resetShapeFlag(current);\r\n            }\r\n            cache.delete(key);\r\n            keys.delete(key);\r\n        }\r\n        watch(() => [props.include, props.exclude], ([include, exclude]) => {\r\n            include && pruneCache(name => matches(include, name));\r\n            exclude && pruneCache(name => matches(exclude, name));\r\n        });\r\n        // cache sub tree in beforeMount/Update (i.e. right after the render)\r\n        let pendingCacheKey = null;\r\n        const cacheSubtree = () => {\r\n            // fix #1621, the pendingCacheKey could be 0\r\n            if (pendingCacheKey != null) {\r\n                cache.set(pendingCacheKey, instance.subTree);\r\n            }\r\n        };\r\n        onBeforeMount(cacheSubtree);\r\n        onBeforeUpdate(cacheSubtree);\r\n        onBeforeUnmount(() => {\r\n            cache.forEach(cached => {\r\n                const { subTree, suspense } = instance;\r\n                if (cached.type === subTree.type) {\r\n                    // current instance will be unmounted as part of keep-alive's unmount\r\n                    resetShapeFlag(subTree);\r\n                    // but invoke its deactivated hook here\r\n                    const da = subTree.component.da;\r\n                    da && queuePostRenderEffect(da, suspense);\r\n                    return;\r\n                }\r\n                unmount(cached);\r\n            });\r\n        });\r\n        return () => {\r\n            pendingCacheKey = null;\r\n            if (!slots.default) {\r\n                return null;\r\n            }\r\n            const children = slots.default();\r\n            let vnode = children[0];\r\n            if (children.length > 1) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`KeepAlive should contain exactly one component child.`);\r\n                }\r\n                current = null;\r\n                return children;\r\n            }\r\n            else if (!isVNode(vnode) ||\r\n                !(vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */)) {\r\n                current = null;\r\n                return vnode;\r\n            }\r\n            const comp = vnode.type;\r\n            const name = getName(comp);\r\n            const { include, exclude, max } = props;\r\n            if ((include && (!name || !matches(include, name))) ||\r\n                (exclude && name && matches(exclude, name))) {\r\n                return (current = vnode);\r\n            }\r\n            const key = vnode.key == null ? comp : vnode.key;\r\n            const cachedVNode = cache.get(key);\r\n            // clone vnode if it's reused because we are going to mutate it\r\n            if (vnode.el) {\r\n                vnode = cloneVNode(vnode);\r\n            }\r\n            // #1513 it's possible for the returned vnode to be cloned due to attr\r\n            // fallthrough or scopeId, so the vnode here may not be the final vnode\r\n            // that is mounted. Instead of caching it directly, we store the pending\r\n            // key and cache `instance.subTree` (the normalized vnode) in\r\n            // beforeMount/beforeUpdate hooks.\r\n            pendingCacheKey = key;\r\n            if (cachedVNode) {\r\n                // copy over mounted state\r\n                vnode.el = cachedVNode.el;\r\n                vnode.component = cachedVNode.component;\r\n                if (vnode.transition) {\r\n                    // recursively update transition hooks on subTree\r\n                    setTransitionHooks(vnode, vnode.transition);\r\n                }\r\n                // avoid vnode being mounted as fresh\r\n                vnode.shapeFlag |= 512 /* COMPONENT_KEPT_ALIVE */;\r\n                // make this key the freshest\r\n                keys.delete(key);\r\n                keys.add(key);\r\n            }\r\n            else {\r\n                keys.add(key);\r\n                // prune oldest entry\r\n                if (max && keys.size > parseInt(max, 10)) {\r\n                    pruneCacheEntry(keys.values().next().value);\r\n                }\r\n            }\r\n            // avoid vnode being unmounted\r\n            vnode.shapeFlag |= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;\r\n            current = vnode;\r\n            return vnode;\r\n        };\r\n    }\r\n};\r\n// export the public type for h/tsx inference\r\n// also to avoid inline import() in generated d.ts files\r\nconst KeepAlive = KeepAliveImpl;\r\nfunction getName(comp) {\r\n    return comp.displayName || comp.name;\r\n}\r\nfunction matches(pattern, name) {\r\n    if (isArray(pattern)) {\r\n        return pattern.some((p) => matches(p, name));\r\n    }\r\n    else if (isString(pattern)) {\r\n        return pattern.split(',').indexOf(name) > -1;\r\n    }\r\n    else if (pattern.test) {\r\n        return pattern.test(name);\r\n    }\r\n    /* istanbul ignore next */\r\n    return false;\r\n}\r\nfunction onActivated(hook, target) {\r\n    registerKeepAliveHook(hook, \"a\" /* ACTIVATED */, target);\r\n}\r\nfunction onDeactivated(hook, target) {\r\n    registerKeepAliveHook(hook, \"da\" /* DEACTIVATED */, target);\r\n}\r\nfunction registerKeepAliveHook(hook, type, target = currentInstance) {\r\n    // cache the deactivate branch check wrapper for injected hooks so the same\r\n    // hook can be properly deduped by the scheduler. \"__wdc\" stands for \"with\r\n    // deactivation check\".\r\n    const wrappedHook = hook.__wdc ||\r\n        (hook.__wdc = () => {\r\n            // only fire the hook if the target instance is NOT in a deactivated branch.\r\n            let current = target;\r\n            while (current) {\r\n                if (current.isDeactivated) {\r\n                    return;\r\n                }\r\n                current = current.parent;\r\n            }\r\n            hook();\r\n        });\r\n    injectHook(type, wrappedHook, target);\r\n    // In addition to registering it on the target instance, we walk up the parent\r\n    // chain and register it on all ancestor instances that are keep-alive roots.\r\n    // This avoids the need to walk the entire component tree when invoking these\r\n    // hooks, and more importantly, avoids the need to track child components in\r\n    // arrays.\r\n    if (target) {\r\n        let current = target.parent;\r\n        while (current && current.parent) {\r\n            if (isKeepAlive(current.parent.vnode)) {\r\n                injectToKeepAliveRoot(wrappedHook, type, target, current);\r\n            }\r\n            current = current.parent;\r\n        }\r\n    }\r\n}\r\nfunction injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {\r\n    injectHook(type, hook, keepAliveRoot, true /* prepend */);\r\n    onUnmounted(() => {\r\n        remove(keepAliveRoot[type], hook);\r\n    }, target);\r\n}\r\nfunction resetShapeFlag(vnode) {\r\n    let shapeFlag = vnode.shapeFlag;\r\n    if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {\r\n        shapeFlag -= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;\r\n    }\r\n    if (shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) {\r\n        shapeFlag -= 512 /* COMPONENT_KEPT_ALIVE */;\r\n    }\r\n    vnode.shapeFlag = shapeFlag;\r\n}\n\nconst isInternalKey = (key) => key[0] === '_' || key === '$stable';\r\nconst normalizeSlotValue = (value) => isArray(value)\r\n    ? value.map(normalizeVNode)\r\n    : [normalizeVNode(value)];\r\nconst normalizeSlot = (key, rawSlot, ctx) => withCtx((props) => {\r\n    if ((process.env.NODE_ENV !== 'production') && currentInstance) {\r\n        warn(`Slot \"${key}\" invoked outside of the render function: ` +\r\n            `this will not track dependencies used in the slot. ` +\r\n            `Invoke the slot function inside the render function instead.`);\r\n    }\r\n    return normalizeSlotValue(rawSlot(props));\r\n}, ctx);\r\nconst normalizeObjectSlots = (rawSlots, slots) => {\r\n    const ctx = rawSlots._ctx;\r\n    for (const key in rawSlots) {\r\n        if (isInternalKey(key))\r\n            continue;\r\n        const value = rawSlots[key];\r\n        if (isFunction(value)) {\r\n            slots[key] = normalizeSlot(key, value, ctx);\r\n        }\r\n        else if (value != null) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                warn(`Non-function value encountered for slot \"${key}\". ` +\r\n                    `Prefer function slots for better performance.`);\r\n            }\r\n            const normalized = normalizeSlotValue(value);\r\n            slots[key] = () => normalized;\r\n        }\r\n    }\r\n};\r\nconst normalizeVNodeSlots = (instance, children) => {\r\n    if ((process.env.NODE_ENV !== 'production') && !isKeepAlive(instance.vnode)) {\r\n        warn(`Non-function value encountered for default slot. ` +\r\n            `Prefer function slots for better performance.`);\r\n    }\r\n    const normalized = normalizeSlotValue(children);\r\n    instance.slots.default = () => normalized;\r\n};\r\nconst initSlots = (instance, children) => {\r\n    if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n        const type = children._;\r\n        if (type) {\r\n            instance.slots = children;\r\n            // make compiler marker non-enumerable\r\n            def(children, '_', type);\r\n        }\r\n        else {\r\n            normalizeObjectSlots(children, (instance.slots = {}));\r\n        }\r\n    }\r\n    else {\r\n        instance.slots = {};\r\n        if (children) {\r\n            normalizeVNodeSlots(instance, children);\r\n        }\r\n    }\r\n    def(instance.slots, InternalObjectKey, 1);\r\n};\r\nconst updateSlots = (instance, children) => {\r\n    const { vnode, slots } = instance;\r\n    let needDeletionCheck = true;\r\n    let deletionComparisonTarget = EMPTY_OBJ;\r\n    if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n        const type = children._;\r\n        if (type) {\r\n            // compiled slots.\r\n            if ((process.env.NODE_ENV !== 'production') && isHmrUpdating) {\r\n                // Parent was HMR updated so slot content may have changed.\r\n                // force update slots and mark instance for hmr as well\r\n                extend(slots, children);\r\n            }\r\n            else if (type === 1 /* STABLE */) {\r\n                // compiled AND stable.\r\n                // no need to update, and skip stale slots removal.\r\n                needDeletionCheck = false;\r\n            }\r\n            else {\r\n                // compiled but dynamic (v-if/v-for on slots) - update slots, but skip\r\n                // normalization.\r\n                extend(slots, children);\r\n            }\r\n        }\r\n        else {\r\n            needDeletionCheck = !children.$stable;\r\n            normalizeObjectSlots(children, slots);\r\n        }\r\n        deletionComparisonTarget = children;\r\n    }\r\n    else if (children) {\r\n        // non slot object children (direct value) passed to a component\r\n        normalizeVNodeSlots(instance, children);\r\n        deletionComparisonTarget = { default: 1 };\r\n    }\r\n    // delete stale slots\r\n    if (needDeletionCheck) {\r\n        for (const key in slots) {\r\n            if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {\r\n                delete slots[key];\r\n            }\r\n        }\r\n    }\r\n};\n\n/**\r\nRuntime helper for applying directives to a vnode. Example usage:\r\n\nconst comp = resolveComponent('comp')\r\nconst foo = resolveDirective('foo')\r\nconst bar = resolveDirective('bar')\r\n\nreturn withDirectives(h(comp), [\r\n  [foo, this.x],\r\n  [bar, this.y]\r\n])\r\n*/\r\nconst isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text');\r\nfunction validateDirectiveName(name) {\r\n    if (isBuiltInDirective(name)) {\r\n        warn('Do not use built-in directive ids as custom directive id: ' + name);\r\n    }\r\n}\r\n/**\r\n * Adds directives to a VNode.\r\n */\r\nfunction withDirectives(vnode, directives) {\r\n    const internalInstance = currentRenderingInstance;\r\n    if (internalInstance === null) {\r\n        (process.env.NODE_ENV !== 'production') && warn(`withDirectives can only be used inside render functions.`);\r\n        return vnode;\r\n    }\r\n    const instance = internalInstance.proxy;\r\n    const bindings = vnode.dirs || (vnode.dirs = []);\r\n    for (let i = 0; i < directives.length; i++) {\r\n        let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];\r\n        if (isFunction(dir)) {\r\n            dir = {\r\n                mounted: dir,\r\n                updated: dir\r\n            };\r\n        }\r\n        bindings.push({\r\n            dir,\r\n            instance,\r\n            value,\r\n            oldValue: void 0,\r\n            arg,\r\n            modifiers\r\n        });\r\n    }\r\n    return vnode;\r\n}\r\nfunction invokeDirectiveHook(vnode, prevVNode, instance, name) {\r\n    const bindings = vnode.dirs;\r\n    const oldBindings = prevVNode && prevVNode.dirs;\r\n    for (let i = 0; i < bindings.length; i++) {\r\n        const binding = bindings[i];\r\n        if (oldBindings) {\r\n            binding.oldValue = oldBindings[i].value;\r\n        }\r\n        const hook = binding.dir[name];\r\n        if (hook) {\r\n            callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [\r\n                vnode.el,\r\n                binding,\r\n                vnode,\r\n                prevVNode\r\n            ]);\r\n        }\r\n    }\r\n}\n\nlet devtools;\r\nfunction setDevtoolsHook(hook) {\r\n    devtools = hook;\r\n}\r\nfunction devtoolsInitApp(app, version) {\r\n    // TODO queue if devtools is undefined\r\n    if (!devtools)\r\n        return;\r\n    devtools.emit(\"app:init\" /* APP_INIT */, app, version, {\r\n        Fragment,\r\n        Text,\r\n        Comment,\r\n        Static\r\n    });\r\n}\r\nfunction devtoolsUnmountApp(app) {\r\n    if (!devtools)\r\n        return;\r\n    devtools.emit(\"app:unmount\" /* APP_UNMOUNT */, app);\r\n}\r\nconst devtoolsComponentAdded = /*#__PURE__*/ createDevtoolsHook(\"component:added\" /* COMPONENT_ADDED */);\r\nconst devtoolsComponentUpdated = /*#__PURE__*/ createDevtoolsHook(\"component:updated\" /* COMPONENT_UPDATED */);\r\nconst devtoolsComponentRemoved = /*#__PURE__*/ createDevtoolsHook(\"component:removed\" /* COMPONENT_REMOVED */);\r\nfunction createDevtoolsHook(hook) {\r\n    return (component) => {\r\n        if (!devtools)\r\n            return;\r\n        devtools.emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined);\r\n    };\r\n}\n\nfunction createAppContext() {\r\n    return {\r\n        app: null,\r\n        config: {\r\n            isNativeTag: NO,\r\n            performance: false,\r\n            globalProperties: {},\r\n            optionMergeStrategies: {},\r\n            isCustomElement: NO,\r\n            errorHandler: undefined,\r\n            warnHandler: undefined\r\n        },\r\n        mixins: [],\r\n        components: {},\r\n        directives: {},\r\n        provides: Object.create(null)\r\n    };\r\n}\r\nfunction createAppAPI(render, hydrate) {\r\n    return function createApp(rootComponent, rootProps = null) {\r\n        if (rootProps != null && !isObject(rootProps)) {\r\n            (process.env.NODE_ENV !== 'production') && warn(`root props passed to app.mount() must be an object.`);\r\n            rootProps = null;\r\n        }\r\n        const context = createAppContext();\r\n        const installedPlugins = new Set();\r\n        let isMounted = false;\r\n        const app = (context.app = {\r\n            _component: rootComponent,\r\n            _props: rootProps,\r\n            _container: null,\r\n            _context: context,\r\n            version,\r\n            get config() {\r\n                return context.config;\r\n            },\r\n            set config(v) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`app.config cannot be replaced. Modify individual options instead.`);\r\n                }\r\n            },\r\n            use(plugin, ...options) {\r\n                if (installedPlugins.has(plugin)) {\r\n                    (process.env.NODE_ENV !== 'production') && warn(`Plugin has already been applied to target app.`);\r\n                }\r\n                else if (plugin && isFunction(plugin.install)) {\r\n                    installedPlugins.add(plugin);\r\n                    plugin.install(app, ...options);\r\n                }\r\n                else if (isFunction(plugin)) {\r\n                    installedPlugins.add(plugin);\r\n                    plugin(app, ...options);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`A plugin must either be a function or an object with an \"install\" ` +\r\n                        `function.`);\r\n                }\r\n                return app;\r\n            },\r\n            mixin(mixin) {\r\n                if (__VUE_OPTIONS_API__) {\r\n                    if (!context.mixins.includes(mixin)) {\r\n                        context.mixins.push(mixin);\r\n                    }\r\n                    else if ((process.env.NODE_ENV !== 'production')) {\r\n                        warn('Mixin has already been applied to target app' +\r\n                            (mixin.name ? `: ${mixin.name}` : ''));\r\n                    }\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn('Mixins are only available in builds supporting Options API');\r\n                }\r\n                return app;\r\n            },\r\n            component(name, component) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    validateComponentName(name, context.config);\r\n                }\r\n                if (!component) {\r\n                    return context.components[name];\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && context.components[name]) {\r\n                    warn(`Component \"${name}\" has already been registered in target app.`);\r\n                }\r\n                context.components[name] = component;\r\n                return app;\r\n            },\r\n            directive(name, directive) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    validateDirectiveName(name);\r\n                }\r\n                if (!directive) {\r\n                    return context.directives[name];\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && context.directives[name]) {\r\n                    warn(`Directive \"${name}\" has already been registered in target app.`);\r\n                }\r\n                context.directives[name] = directive;\r\n                return app;\r\n            },\r\n            mount(rootContainer, isHydrate) {\r\n                if (!isMounted) {\r\n                    const vnode = createVNode(rootComponent, rootProps);\r\n                    // store app context on the root VNode.\r\n                    // this will be set on the root instance on initial mount.\r\n                    vnode.appContext = context;\r\n                    // HMR root reload\r\n                    if ((process.env.NODE_ENV !== 'production')) {\r\n                        context.reload = () => {\r\n                            render(cloneVNode(vnode), rootContainer);\r\n                        };\r\n                    }\r\n                    if (isHydrate && hydrate) {\r\n                        hydrate(vnode, rootContainer);\r\n                    }\r\n                    else {\r\n                        render(vnode, rootContainer);\r\n                    }\r\n                    isMounted = true;\r\n                    app._container = rootContainer;\r\n                    rootContainer.__vue_app__ = app;\r\n                    if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n                        devtoolsInitApp(app, version);\r\n                    }\r\n                    return vnode.component.proxy;\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`App has already been mounted.\\n` +\r\n                        `If you want to remount the same app, move your app creation logic ` +\r\n                        `into a factory function and create fresh app instances for each ` +\r\n                        `mount - e.g. \\`const createMyApp = () => createApp(App)\\``);\r\n                }\r\n            },\r\n            unmount() {\r\n                if (isMounted) {\r\n                    render(null, app._container);\r\n                    devtoolsUnmountApp(app);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`Cannot unmount an app that is not mounted.`);\r\n                }\r\n            },\r\n            provide(key, value) {\r\n                if ((process.env.NODE_ENV !== 'production') && key in context.provides) {\r\n                    warn(`App already provides property with key \"${String(key)}\". ` +\r\n                        `It will be overwritten with the new value.`);\r\n                }\r\n                // TypeScript doesn't allow symbols as index type\r\n                // https://github.com/Microsoft/TypeScript/issues/24587\r\n                context.provides[key] = value;\r\n                return app;\r\n            }\r\n        });\r\n        return app;\r\n    };\r\n}\n\nlet hasMismatch = false;\r\nconst isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject';\r\nconst isComment = (node) => node.nodeType === 8 /* COMMENT */;\r\n// Note: hydration is DOM-specific\r\n// But we have to place it in core due to tight coupling with core - splitting\r\n// it out creates a ton of unnecessary complexity.\r\n// Hydration also depends on some renderer internal logic which needs to be\r\n// passed in via arguments.\r\nfunction createHydrationFunctions(rendererInternals) {\r\n    const { mt: mountComponent, p: patch, o: { patchProp, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals;\r\n    const hydrate = (vnode, container) => {\r\n        if ((process.env.NODE_ENV !== 'production') && !container.hasChildNodes()) {\r\n            warn(`Attempting to hydrate existing markup but container is empty. ` +\r\n                `Performing full mount instead.`);\r\n            patch(null, vnode, container);\r\n            return;\r\n        }\r\n        hasMismatch = false;\r\n        hydrateNode(container.firstChild, vnode, null, null);\r\n        flushPostFlushCbs();\r\n        if (hasMismatch && !false) {\r\n            // this error should show up in production\r\n            console.error(`Hydration completed but contains mismatches.`);\r\n        }\r\n    };\r\n    const hydrateNode = (node, vnode, parentComponent, parentSuspense, optimized = false) => {\r\n        const isFragmentStart = isComment(node) && node.data === '[';\r\n        const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, isFragmentStart);\r\n        const { type, ref, shapeFlag } = vnode;\r\n        const domType = node.nodeType;\r\n        vnode.el = node;\r\n        let nextNode = null;\r\n        switch (type) {\r\n            case Text:\r\n                if (domType !== 3 /* TEXT */) {\r\n                    nextNode = onMismatch();\r\n                }\r\n                else {\r\n                    if (node.data !== vnode.children) {\r\n                        hasMismatch = true;\r\n                        (process.env.NODE_ENV !== 'production') &&\r\n                            warn(`Hydration text mismatch:` +\r\n                                `\\n- Client: ${JSON.stringify(node.data)}` +\r\n                                `\\n- Server: ${JSON.stringify(vnode.children)}`);\r\n                        node.data = vnode.children;\r\n                    }\r\n                    nextNode = nextSibling(node);\r\n                }\r\n                break;\r\n            case Comment:\r\n                if (domType !== 8 /* COMMENT */ || isFragmentStart) {\r\n                    nextNode = onMismatch();\r\n                }\r\n                else {\r\n                    nextNode = nextSibling(node);\r\n                }\r\n                break;\r\n            case Static:\r\n                if (domType !== 1 /* ELEMENT */) {\r\n                    nextNode = onMismatch();\r\n                }\r\n                else {\r\n                    // determine anchor, adopt content\r\n                    nextNode = node;\r\n                    // if the static vnode has its content stripped during build,\r\n                    // adopt it from the server-rendered HTML.\r\n                    const needToAdoptContent = !vnode.children.length;\r\n                    for (let i = 0; i < vnode.staticCount; i++) {\r\n                        if (needToAdoptContent)\r\n                            vnode.children += nextNode.outerHTML;\r\n                        if (i === vnode.staticCount - 1) {\r\n                            vnode.anchor = nextNode;\r\n                        }\r\n                        nextNode = nextSibling(nextNode);\r\n                    }\r\n                    return nextNode;\r\n                }\r\n                break;\r\n            case Fragment:\r\n                if (!isFragmentStart) {\r\n                    nextNode = onMismatch();\r\n                }\r\n                else {\r\n                    nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, optimized);\r\n                }\r\n                break;\r\n            default:\r\n                if (shapeFlag & 1 /* ELEMENT */) {\r\n                    if (domType !== 1 /* ELEMENT */ ||\r\n                        vnode.type !== node.tagName.toLowerCase()) {\r\n                        nextNode = onMismatch();\r\n                    }\r\n                    else {\r\n                        nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, optimized);\r\n                    }\r\n                }\r\n                else if (shapeFlag & 6 /* COMPONENT */) {\r\n                    // when setting up the render effect, if the initial vnode already\r\n                    // has .el set, the component will perform hydration instead of mount\r\n                    // on its sub-tree.\r\n                    const container = parentNode(node);\r\n                    const hydrateComponent = () => {\r\n                        mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized);\r\n                    };\r\n                    // async component\r\n                    const loadAsync = vnode.type.__asyncLoader;\r\n                    if (loadAsync) {\r\n                        loadAsync().then(hydrateComponent);\r\n                    }\r\n                    else {\r\n                        hydrateComponent();\r\n                    }\r\n                    // component may be async, so in the case of fragments we cannot rely\r\n                    // on component's rendered output to determine the end of the fragment\r\n                    // instead, we do a lookahead to find the end anchor node.\r\n                    nextNode = isFragmentStart\r\n                        ? locateClosingAsyncAnchor(node)\r\n                        : nextSibling(node);\r\n                }\r\n                else if (shapeFlag & 64 /* TELEPORT */) {\r\n                    if (domType !== 8 /* COMMENT */) {\r\n                        nextNode = onMismatch();\r\n                    }\r\n                    else {\r\n                        nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, optimized, rendererInternals, hydrateChildren);\r\n                    }\r\n                }\r\n                else if ( shapeFlag & 128 /* SUSPENSE */) {\r\n                    nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), optimized, rendererInternals, hydrateNode);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn('Invalid HostVNode type:', type, `(${typeof type})`);\r\n                }\r\n        }\r\n        if (ref != null && parentComponent) {\r\n            setRef(ref, null, parentComponent, parentSuspense, vnode);\r\n        }\r\n        return nextNode;\r\n    };\r\n    const hydrateElement = (el, vnode, parentComponent, parentSuspense, optimized) => {\r\n        optimized = optimized || !!vnode.dynamicChildren;\r\n        const { props, patchFlag, shapeFlag, dirs } = vnode;\r\n        // skip props & children if this is hoisted static nodes\r\n        if (patchFlag !== -1 /* HOISTED */) {\r\n            // props\r\n            if (props) {\r\n                if (!optimized ||\r\n                    (patchFlag & 16 /* FULL_PROPS */ ||\r\n                        patchFlag & 32 /* HYDRATE_EVENTS */)) {\r\n                    for (const key in props) {\r\n                        if (!isReservedProp(key) && isOn(key)) {\r\n                            patchProp(el, key, null, props[key]);\r\n                        }\r\n                    }\r\n                }\r\n                else if (props.onClick) {\r\n                    // Fast path for click listeners (which is most often) to avoid\r\n                    // iterating through props.\r\n                    patchProp(el, 'onClick', null, props.onClick);\r\n                }\r\n            }\r\n            // vnode / directive hooks\r\n            let vnodeHooks;\r\n            if ((vnodeHooks = props && props.onVnodeBeforeMount)) {\r\n                invokeVNodeHook(vnodeHooks, parentComponent, vnode);\r\n            }\r\n            if (dirs) {\r\n                invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount');\r\n            }\r\n            if ((vnodeHooks = props && props.onVnodeMounted) || dirs) {\r\n                queueEffectWithSuspense(() => {\r\n                    vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);\r\n                    dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted');\r\n                }, parentSuspense);\r\n            }\r\n            // children\r\n            if (shapeFlag & 16 /* ARRAY_CHILDREN */ &&\r\n                // skip if element has innerHTML / textContent\r\n                !(props && (props.innerHTML || props.textContent))) {\r\n                let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, optimized);\r\n                let hasWarned = false;\r\n                while (next) {\r\n                    hasMismatch = true;\r\n                    if ((process.env.NODE_ENV !== 'production') && !hasWarned) {\r\n                        warn(`Hydration children mismatch in <${vnode.type}>: ` +\r\n                            `server rendered element contains more child nodes than client vdom.`);\r\n                        hasWarned = true;\r\n                    }\r\n                    // The SSRed DOM contains more nodes than it should. Remove them.\r\n                    const cur = next;\r\n                    next = next.nextSibling;\r\n                    remove(cur);\r\n                }\r\n            }\r\n            else if (shapeFlag & 8 /* TEXT_CHILDREN */) {\r\n                if (el.textContent !== vnode.children) {\r\n                    hasMismatch = true;\r\n                    (process.env.NODE_ENV !== 'production') &&\r\n                        warn(`Hydration text content mismatch in <${vnode.type}>:\\n` +\r\n                            `- Client: ${el.textContent}\\n` +\r\n                            `- Server: ${vnode.children}`);\r\n                    el.textContent = vnode.children;\r\n                }\r\n            }\r\n        }\r\n        return el.nextSibling;\r\n    };\r\n    const hydrateChildren = (node, vnode, container, parentComponent, parentSuspense, optimized) => {\r\n        optimized = optimized || !!vnode.dynamicChildren;\r\n        const children = vnode.children;\r\n        const l = children.length;\r\n        let hasWarned = false;\r\n        for (let i = 0; i < l; i++) {\r\n            const vnode = optimized\r\n                ? children[i]\r\n                : (children[i] = normalizeVNode(children[i]));\r\n            if (node) {\r\n                node = hydrateNode(node, vnode, parentComponent, parentSuspense, optimized);\r\n            }\r\n            else {\r\n                hasMismatch = true;\r\n                if ((process.env.NODE_ENV !== 'production') && !hasWarned) {\r\n                    warn(`Hydration children mismatch in <${container.tagName.toLowerCase()}>: ` +\r\n                        `server rendered element contains fewer child nodes than client vdom.`);\r\n                    hasWarned = true;\r\n                }\r\n                // the SSRed DOM didn't contain enough nodes. Mount the missing ones.\r\n                patch(null, vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container));\r\n            }\r\n        }\r\n        return node;\r\n    };\r\n    const hydrateFragment = (node, vnode, parentComponent, parentSuspense, optimized) => {\r\n        const container = parentNode(node);\r\n        const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, optimized);\r\n        if (next && isComment(next) && next.data === ']') {\r\n            return nextSibling((vnode.anchor = next));\r\n        }\r\n        else {\r\n            // fragment didn't hydrate successfully, since we didn't get a end anchor\r\n            // back. This should have led to node/children mismatch warnings.\r\n            hasMismatch = true;\r\n            // since the anchor is missing, we need to create one and insert it\r\n            insert((vnode.anchor = createComment(`]`)), container, next);\r\n            return next;\r\n        }\r\n    };\r\n    const handleMismatch = (node, vnode, parentComponent, parentSuspense, isFragment) => {\r\n        hasMismatch = true;\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn(`Hydration node mismatch:\\n- Client vnode:`, vnode.type, `\\n- Server rendered DOM:`, node, node.nodeType === 3 /* TEXT */\r\n                ? `(text)`\r\n                : isComment(node) && node.data === '['\r\n                    ? `(start of fragment)`\r\n                    : ``);\r\n        vnode.el = null;\r\n        if (isFragment) {\r\n            // remove excessive fragment nodes\r\n            const end = locateClosingAsyncAnchor(node);\r\n            while (true) {\r\n                const next = nextSibling(node);\r\n                if (next && next !== end) {\r\n                    remove(next);\r\n                }\r\n                else {\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n        const next = nextSibling(node);\r\n        const container = parentNode(node);\r\n        remove(node);\r\n        patch(null, vnode, container, next, parentComponent, parentSuspense, isSVGContainer(container));\r\n        return next;\r\n    };\r\n    const locateClosingAsyncAnchor = (node) => {\r\n        let match = 0;\r\n        while (node) {\r\n            node = nextSibling(node);\r\n            if (node && isComment(node)) {\r\n                if (node.data === '[')\r\n                    match++;\r\n                if (node.data === ']') {\r\n                    if (match === 0) {\r\n                        return nextSibling(node);\r\n                    }\r\n                    else {\r\n                        match--;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return node;\r\n    };\r\n    return [hydrate, hydrateNode];\r\n}\n\nlet supported;\r\nlet perf;\r\nfunction startMeasure(instance, type) {\r\n    if (instance.appContext.config.performance && isSupported()) {\r\n        perf.mark(`vue-${type}-${instance.uid}`);\r\n    }\r\n}\r\nfunction endMeasure(instance, type) {\r\n    if (instance.appContext.config.performance && isSupported()) {\r\n        const startTag = `vue-${type}-${instance.uid}`;\r\n        const endTag = startTag + `:end`;\r\n        perf.mark(endTag);\r\n        perf.measure(`<${formatComponentName(instance, instance.type)}> ${type}`, startTag, endTag);\r\n        perf.clearMarks(startTag);\r\n        perf.clearMarks(endTag);\r\n    }\r\n}\r\nfunction isSupported() {\r\n    if (supported !== undefined) {\r\n        return supported;\r\n    }\r\n    /* eslint-disable no-restricted-globals */\r\n    if (typeof window !== 'undefined' && window.performance) {\r\n        supported = true;\r\n        perf = window.performance;\r\n    }\r\n    else {\r\n        supported = false;\r\n    }\r\n    /* eslint-enable no-restricted-globals */\r\n    return supported;\r\n}\n\n/**\r\n * This is only called in esm-bundler builds.\r\n * It is called when a renderer is created, in `baseCreateRenderer` so that\r\n * importing runtime-core is side-effects free.\r\n *\r\n * istanbul-ignore-next\r\n */\r\nfunction initFeatureFlags() {\r\n    let needWarn = false;\r\n    if (typeof __VUE_OPTIONS_API__ !== 'boolean') {\r\n        needWarn = true;\r\n        getGlobalThis().__VUE_OPTIONS_API__ = true;\r\n    }\r\n    if (typeof __VUE_PROD_DEVTOOLS__ !== 'boolean') {\r\n        needWarn = true;\r\n        getGlobalThis().__VUE_PROD_DEVTOOLS__ = false;\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production') && needWarn) {\r\n        console.warn(`You are running the esm-bundler build of Vue. It is recommended to ` +\r\n            `configure your bundler to explicitly replace feature flag globals ` +\r\n            `with boolean literals to get proper tree-shaking in the final bundle. ` +\r\n            `See http://link.vuejs.org/feature-flags for more details.`);\r\n    }\r\n}\n\nconst prodEffectOptions = {\r\n    scheduler: queueJob\r\n};\r\nfunction createDevEffectOptions(instance) {\r\n    return {\r\n        scheduler: queueJob,\r\n        onTrack: instance.rtc ? e => invokeArrayFns(instance.rtc, e) : void 0,\r\n        onTrigger: instance.rtg ? e => invokeArrayFns(instance.rtg, e) : void 0\r\n    };\r\n}\r\nconst queuePostRenderEffect =  queueEffectWithSuspense\r\n    ;\r\nconst setRef = (rawRef, oldRawRef, parentComponent, parentSuspense, vnode) => {\r\n    let value;\r\n    if (!vnode) {\r\n        value = null;\r\n    }\r\n    else {\r\n        if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {\r\n            value = vnode.component.proxy;\r\n        }\r\n        else {\r\n            value = vnode.el;\r\n        }\r\n    }\r\n    const [owner, ref] = rawRef;\r\n    if ((process.env.NODE_ENV !== 'production') && !owner) {\r\n        warn(`Missing ref owner context. ref cannot be used on hoisted vnodes. ` +\r\n            `A vnode with ref must be created inside the render function.`);\r\n        return;\r\n    }\r\n    const oldRef = oldRawRef && oldRawRef[1];\r\n    const refs = owner.refs === EMPTY_OBJ ? (owner.refs = {}) : owner.refs;\r\n    const setupState = owner.setupState;\r\n    // unset old ref\r\n    if (oldRef != null && oldRef !== ref) {\r\n        if (isString(oldRef)) {\r\n            refs[oldRef] = null;\r\n            if (hasOwn(setupState, oldRef)) {\r\n                queuePostRenderEffect(() => {\r\n                    setupState[oldRef] = null;\r\n                }, parentSuspense);\r\n            }\r\n        }\r\n        else if (isRef(oldRef)) {\r\n            oldRef.value = null;\r\n        }\r\n    }\r\n    if (isString(ref)) {\r\n        refs[ref] = value;\r\n        if (hasOwn(setupState, ref)) {\r\n            queuePostRenderEffect(() => {\r\n                setupState[ref] = value;\r\n            }, parentSuspense);\r\n        }\r\n    }\r\n    else if (isRef(ref)) {\r\n        ref.value = value;\r\n    }\r\n    else if (isFunction(ref)) {\r\n        callWithErrorHandling(ref, parentComponent, 12 /* FUNCTION_REF */, [\r\n            value,\r\n            refs\r\n        ]);\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn('Invalid template ref type:', value, `(${typeof value})`);\r\n    }\r\n};\r\n/**\r\n * The createRenderer function accepts two generic arguments:\r\n * HostNode and HostElement, corresponding to Node and Element types in the\r\n * host environment. For example, for runtime-dom, HostNode would be the DOM\r\n * `Node` interface and HostElement would be the DOM `Element` interface.\r\n *\r\n * Custom renderers can pass in the platform specific types like this:\r\n *\r\n * ``` js\r\n * const { render, createApp } = createRenderer<Node, Element>({\r\n *   patchProp,\r\n *   ...nodeOps\r\n * })\r\n * ```\r\n */\r\nfunction createRenderer(options) {\r\n    return baseCreateRenderer(options);\r\n}\r\n// Separate API for creating hydration-enabled renderer.\r\n// Hydration logic is only used when calling this function, making it\r\n// tree-shakable.\r\nfunction createHydrationRenderer(options) {\r\n    return baseCreateRenderer(options, createHydrationFunctions);\r\n}\r\n// implementation\r\nfunction baseCreateRenderer(options, createHydrationFns) {\r\n    // compile-time feature flags check\r\n    {\r\n        initFeatureFlags();\r\n    }\r\n    const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, forcePatchProp: hostForcePatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent } = options;\r\n    // Note: functions inside this closure should use `const xxx = () => {}`\r\n    // style in order to prevent being inlined by minifiers.\r\n    const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, optimized = false) => {\r\n        // patching & not same type, unmount old tree\r\n        if (n1 && !isSameVNodeType(n1, n2)) {\r\n            anchor = getNextHostNode(n1);\r\n            unmount(n1, parentComponent, parentSuspense, true);\r\n            n1 = null;\r\n        }\r\n        if (n2.patchFlag === -2 /* BAIL */) {\r\n            optimized = false;\r\n            n2.dynamicChildren = null;\r\n        }\r\n        const { type, ref, shapeFlag } = n2;\r\n        switch (type) {\r\n            case Text:\r\n                processText(n1, n2, container, anchor);\r\n                break;\r\n            case Comment:\r\n                processCommentNode(n1, n2, container, anchor);\r\n                break;\r\n            case Static:\r\n                if (n1 == null) {\r\n                    mountStaticNode(n2, container, anchor, isSVG);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    patchStaticNode(n1, n2, container, isSVG);\r\n                }\r\n                break;\r\n            case Fragment:\r\n                processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                break;\r\n            default:\r\n                if (shapeFlag & 1 /* ELEMENT */) {\r\n                    processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                }\r\n                else if (shapeFlag & 6 /* COMPONENT */) {\r\n                    processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                }\r\n                else if (shapeFlag & 64 /* TELEPORT */) {\r\n                    type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);\r\n                }\r\n                else if ( shapeFlag & 128 /* SUSPENSE */) {\r\n                    type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn('Invalid VNode type:', type, `(${typeof type})`);\r\n                }\r\n        }\r\n        // set ref\r\n        if (ref != null && parentComponent) {\r\n            setRef(ref, n1 && n1.ref, parentComponent, parentSuspense, n2);\r\n        }\r\n    };\r\n    const processText = (n1, n2, container, anchor) => {\r\n        if (n1 == null) {\r\n            hostInsert((n2.el = hostCreateText(n2.children)), container, anchor);\r\n        }\r\n        else {\r\n            const el = (n2.el = n1.el);\r\n            if (n2.children !== n1.children) {\r\n                hostSetText(el, n2.children);\r\n            }\r\n        }\r\n    };\r\n    const processCommentNode = (n1, n2, container, anchor) => {\r\n        if (n1 == null) {\r\n            hostInsert((n2.el = hostCreateComment(n2.children || '')), container, anchor);\r\n        }\r\n        else {\r\n            // there's no support for dynamic comments\r\n            n2.el = n1.el;\r\n        }\r\n    };\r\n    const mountStaticNode = (n2, container, anchor, isSVG) => {\r\n        [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG);\r\n    };\r\n    /**\r\n     * Dev / HMR only\r\n     */\r\n    const patchStaticNode = (n1, n2, container, isSVG) => {\r\n        // static nodes are only patched during dev for HMR\r\n        if (n2.children !== n1.children) {\r\n            const anchor = hostNextSibling(n1.anchor);\r\n            // remove existing\r\n            removeStaticNode(n1);\r\n            [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG);\r\n        }\r\n        else {\r\n            n2.el = n1.el;\r\n            n2.anchor = n1.anchor;\r\n        }\r\n    };\r\n    /**\r\n     * Dev / HMR only\r\n     */\r\n    const moveStaticNode = (vnode, container, anchor) => {\r\n        let cur = vnode.el;\r\n        const end = vnode.anchor;\r\n        while (cur && cur !== end) {\r\n            const next = hostNextSibling(cur);\r\n            hostInsert(cur, container, anchor);\r\n            cur = next;\r\n        }\r\n        hostInsert(end, container, anchor);\r\n    };\r\n    /**\r\n     * Dev / HMR only\r\n     */\r\n    const removeStaticNode = (vnode) => {\r\n        let cur = vnode.el;\r\n        while (cur && cur !== vnode.anchor) {\r\n            const next = hostNextSibling(cur);\r\n            hostRemove(cur);\r\n            cur = next;\r\n        }\r\n        hostRemove(vnode.anchor);\r\n    };\r\n    const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        isSVG = isSVG || n2.type === 'svg';\r\n        if (n1 == null) {\r\n            mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n        }\r\n        else {\r\n            patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized);\r\n        }\r\n    };\r\n    const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        let el;\r\n        let vnodeHook;\r\n        const { type, props, shapeFlag, transition, scopeId, patchFlag, dirs } = vnode;\r\n        if (!(process.env.NODE_ENV !== 'production') &&\r\n            vnode.el &&\r\n            hostCloneNode !== undefined &&\r\n            patchFlag === -1 /* HOISTED */) {\r\n            // If a vnode has non-null el, it means it's being reused.\r\n            // Only static vnodes can be reused, so its mounted DOM nodes should be\r\n            // exactly the same, and we can simply do a clone here.\r\n            // only do this in production since cloned trees cannot be HMR updated.\r\n            el = vnode.el = hostCloneNode(vnode.el);\r\n        }\r\n        else {\r\n            el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is);\r\n            // mount children first, since some props may rely on child content\r\n            // being already rendered, e.g. `<select value>`\r\n            if (shapeFlag & 8 /* TEXT_CHILDREN */) {\r\n                hostSetElementText(el, vnode.children);\r\n            }\r\n            else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG && type !== 'foreignObject', optimized || !!vnode.dynamicChildren);\r\n            }\r\n            // props\r\n            if (props) {\r\n                for (const key in props) {\r\n                    if (!isReservedProp(key)) {\r\n                        hostPatchProp(el, key, null, props[key], isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\r\n                    }\r\n                }\r\n                if ((vnodeHook = props.onVnodeBeforeMount)) {\r\n                    invokeVNodeHook(vnodeHook, parentComponent, vnode);\r\n                }\r\n            }\r\n            if (dirs) {\r\n                invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount');\r\n            }\r\n            // scopeId\r\n            if (scopeId) {\r\n                hostSetScopeId(el, scopeId);\r\n            }\r\n            const treeOwnerId = parentComponent && parentComponent.type.__scopeId;\r\n            // vnode's own scopeId and the current patched component's scopeId is\r\n            // different - this is a slot content node.\r\n            if (treeOwnerId && treeOwnerId !== scopeId) {\r\n                hostSetScopeId(el, treeOwnerId + '-s');\r\n            }\r\n            if (transition && !transition.persisted) {\r\n                transition.beforeEnter(el);\r\n            }\r\n        }\r\n        hostInsert(el, container, anchor);\r\n        // #1583 For inside suspense case, enter hook should call when suspense resolved\r\n        const needCallTransitionHooks = !parentSuspense && transition && !transition.persisted;\r\n        if ((vnodeHook = props && props.onVnodeMounted) ||\r\n            needCallTransitionHooks ||\r\n            dirs) {\r\n            queuePostRenderEffect(() => {\r\n                vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);\r\n                needCallTransitionHooks && transition.enter(el);\r\n                dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted');\r\n            }, parentSuspense);\r\n        }\r\n    };\r\n    const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, optimized, start = 0) => {\r\n        for (let i = start; i < children.length; i++) {\r\n            const child = (children[i] = optimized\r\n                ? cloneIfMounted(children[i])\r\n                : normalizeVNode(children[i]));\r\n            patch(null, child, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n        }\r\n    };\r\n    const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        const el = (n2.el = n1.el);\r\n        let { patchFlag, dynamicChildren, dirs } = n2;\r\n        // #1426 take the old vnode's patch flag into account since user may clone a\r\n        // compiler-generated vnode, which de-opts to FULL_PROPS\r\n        patchFlag |= n1.patchFlag & 16 /* FULL_PROPS */;\r\n        const oldProps = n1.props || EMPTY_OBJ;\r\n        const newProps = n2.props || EMPTY_OBJ;\r\n        let vnodeHook;\r\n        if ((vnodeHook = newProps.onVnodeBeforeUpdate)) {\r\n            invokeVNodeHook(vnodeHook, parentComponent, n2, n1);\r\n        }\r\n        if (dirs) {\r\n            invokeDirectiveHook(n2, n1, parentComponent, 'beforeUpdate');\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') && isHmrUpdating) {\r\n            // HMR updated, force full diff\r\n            patchFlag = 0;\r\n            optimized = false;\r\n            dynamicChildren = null;\r\n        }\r\n        if (patchFlag > 0) {\r\n            // the presence of a patchFlag means this element's render code was\r\n            // generated by the compiler and can take the fast path.\r\n            // in this path old node and new node are guaranteed to have the same shape\r\n            // (i.e. at the exact same position in the source template)\r\n            if (patchFlag & 16 /* FULL_PROPS */) {\r\n                // element props contain dynamic keys, full diff needed\r\n                patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);\r\n            }\r\n            else {\r\n                // class\r\n                // this flag is matched when the element has dynamic class bindings.\r\n                if (patchFlag & 2 /* CLASS */) {\r\n                    if (oldProps.class !== newProps.class) {\r\n                        hostPatchProp(el, 'class', null, newProps.class, isSVG);\r\n                    }\r\n                }\r\n                // style\r\n                // this flag is matched when the element has dynamic style bindings\r\n                if (patchFlag & 4 /* STYLE */) {\r\n                    hostPatchProp(el, 'style', oldProps.style, newProps.style, isSVG);\r\n                }\r\n                // props\r\n                // This flag is matched when the element has dynamic prop/attr bindings\r\n                // other than class and style. The keys of dynamic prop/attrs are saved for\r\n                // faster iteration.\r\n                // Note dynamic keys like :[foo]=\"bar\" will cause this optimization to\r\n                // bail out and go through a full diff because we need to unset the old key\r\n                if (patchFlag & 8 /* PROPS */) {\r\n                    // if the flag is present then dynamicProps must be non-null\r\n                    const propsToUpdate = n2.dynamicProps;\r\n                    for (let i = 0; i < propsToUpdate.length; i++) {\r\n                        const key = propsToUpdate[i];\r\n                        const prev = oldProps[key];\r\n                        const next = newProps[key];\r\n                        if (next !== prev ||\r\n                            (hostForcePatchProp && hostForcePatchProp(el, key))) {\r\n                            hostPatchProp(el, key, prev, next, isSVG, n1.children, parentComponent, parentSuspense, unmountChildren);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            // text\r\n            // This flag is matched when the element has only dynamic text children.\r\n            if (patchFlag & 1 /* TEXT */) {\r\n                if (n1.children !== n2.children) {\r\n                    hostSetElementText(el, n2.children);\r\n                }\r\n            }\r\n        }\r\n        else if (!optimized && dynamicChildren == null) {\r\n            // unoptimized, full diff\r\n            patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);\r\n        }\r\n        const areChildrenSVG = isSVG && n2.type !== 'foreignObject';\r\n        if (dynamicChildren) {\r\n            patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, areChildrenSVG);\r\n            if ((process.env.NODE_ENV !== 'production') && parentComponent && parentComponent.type.__hmrId) {\r\n                traverseStaticChildren(n1, n2);\r\n            }\r\n        }\r\n        else if (!optimized) {\r\n            // full diff\r\n            patchChildren(n1, n2, el, null, parentComponent, parentSuspense, areChildrenSVG);\r\n        }\r\n        if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {\r\n            queuePostRenderEffect(() => {\r\n                vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);\r\n                dirs && invokeDirectiveHook(n2, n1, parentComponent, 'updated');\r\n            }, parentSuspense);\r\n        }\r\n    };\r\n    // The fast path for blocks.\r\n    const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG) => {\r\n        for (let i = 0; i < newChildren.length; i++) {\r\n            const oldVNode = oldChildren[i];\r\n            const newVNode = newChildren[i];\r\n            // Determine the container (parent element) for the patch.\r\n            const container = \r\n            // - In the case of a Fragment, we need to provide the actual parent\r\n            // of the Fragment itself so it can move its children.\r\n            oldVNode.type === Fragment ||\r\n                // - In the case of different nodes, there is going to be a replacement\r\n                // which also requires the correct parent container\r\n                !isSameVNodeType(oldVNode, newVNode) ||\r\n                // - In the case of a component, it could contain anything.\r\n                oldVNode.shapeFlag & 6 /* COMPONENT */\r\n                ? hostParentNode(oldVNode.el)\r\n                : // In other cases, the parent container is not actually used so we\r\n                    // just pass the block element here to avoid a DOM parentNode call.\r\n                    fallbackContainer;\r\n            patch(oldVNode, newVNode, container, null, parentComponent, parentSuspense, isSVG, true);\r\n        }\r\n    };\r\n    const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {\r\n        if (oldProps !== newProps) {\r\n            for (const key in newProps) {\r\n                if (isReservedProp(key))\r\n                    continue;\r\n                const next = newProps[key];\r\n                const prev = oldProps[key];\r\n                if (next !== prev ||\r\n                    (hostForcePatchProp && hostForcePatchProp(el, key))) {\r\n                    hostPatchProp(el, key, prev, next, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\r\n                }\r\n            }\r\n            if (oldProps !== EMPTY_OBJ) {\r\n                for (const key in oldProps) {\r\n                    if (!isReservedProp(key) && !(key in newProps)) {\r\n                        hostPatchProp(el, key, oldProps[key], null, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    };\r\n    const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        const fragmentStartAnchor = (n2.el = n1 ? n1.el : hostCreateText(''));\r\n        const fragmentEndAnchor = (n2.anchor = n1 ? n1.anchor : hostCreateText(''));\r\n        let { patchFlag, dynamicChildren } = n2;\r\n        if (patchFlag > 0) {\r\n            optimized = true;\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') && isHmrUpdating) {\r\n            // HMR updated, force full diff\r\n            patchFlag = 0;\r\n            optimized = false;\r\n            dynamicChildren = null;\r\n        }\r\n        if (n1 == null) {\r\n            hostInsert(fragmentStartAnchor, container, anchor);\r\n            hostInsert(fragmentEndAnchor, container, anchor);\r\n            // a fragment can only have array children\r\n            // since they are either generated by the compiler, or implicitly created\r\n            // from arrays.\r\n            mountChildren(n2.children, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);\r\n        }\r\n        else {\r\n            if (patchFlag > 0 &&\r\n                patchFlag & 64 /* STABLE_FRAGMENT */ &&\r\n                dynamicChildren) {\r\n                // a stable fragment (template root or <template v-for>) doesn't need to\r\n                // patch children order, but it may contain dynamicChildren.\r\n                patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, isSVG);\r\n                if ((process.env.NODE_ENV !== 'production') && parentComponent && parentComponent.type.__hmrId) {\r\n                    traverseStaticChildren(n1, n2);\r\n                }\r\n            }\r\n            else {\r\n                // keyed / unkeyed, or manual fragments.\r\n                // for keyed & unkeyed, since they are compiler generated from v-for,\r\n                // each child is guaranteed to be a block so the fragment will never\r\n                // have dynamicChildren.\r\n                patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);\r\n            }\r\n        }\r\n    };\r\n    const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        if (n1 == null) {\r\n            if (n2.shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) {\r\n                parentComponent.ctx.activate(n2, container, anchor, isSVG, optimized);\r\n            }\r\n            else {\r\n                mountComponent(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n            }\r\n        }\r\n        else {\r\n            updateComponent(n1, n2, optimized);\r\n        }\r\n    };\r\n    const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        const instance = (initialVNode.component = createComponentInstance(initialVNode, parentComponent, parentSuspense));\r\n        if ((process.env.NODE_ENV !== 'production') && instance.type.__hmrId) {\r\n            registerHMR(instance);\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            pushWarningContext(initialVNode);\r\n            startMeasure(instance, `mount`);\r\n        }\r\n        // inject renderer internals for keepAlive\r\n        if (isKeepAlive(initialVNode)) {\r\n            instance.ctx.renderer = internals;\r\n        }\r\n        // resolve props and slots for setup context\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            startMeasure(instance, `init`);\r\n        }\r\n        setupComponent(instance);\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            endMeasure(instance, `init`);\r\n        }\r\n        // setup() is async. This component relies on async logic to be resolved\r\n        // before proceeding\r\n        if ( instance.asyncDep) {\r\n            if (!parentSuspense) {\r\n                if ((process.env.NODE_ENV !== 'production'))\r\n                    warn('async setup() is used without a suspense boundary!');\r\n                return;\r\n            }\r\n            parentSuspense.registerDep(instance, setupRenderEffect);\r\n            // Give it a placeholder if this is not hydration\r\n            if (!initialVNode.el) {\r\n                const placeholder = (instance.subTree = createVNode(Comment));\r\n                processCommentNode(null, placeholder, container, anchor);\r\n            }\r\n            return;\r\n        }\r\n        setupRenderEffect(instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized);\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            popWarningContext();\r\n            endMeasure(instance, `mount`);\r\n        }\r\n    };\r\n    const updateComponent = (n1, n2, optimized) => {\r\n        const instance = (n2.component = n1.component);\r\n        if (shouldUpdateComponent(n1, n2, optimized)) {\r\n            if (\r\n                instance.asyncDep &&\r\n                !instance.asyncResolved) {\r\n                // async & still pending - just update props and slots\r\n                // since the component's reactive effect for render isn't set-up yet\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    pushWarningContext(n2);\r\n                }\r\n                updateComponentPreRender(instance, n2, optimized);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    popWarningContext();\r\n                }\r\n                return;\r\n            }\r\n            else {\r\n                // normal update\r\n                instance.next = n2;\r\n                // in case the child component is also queued, remove it to avoid\r\n                // double updating the same child component in the same flush.\r\n                invalidateJob(instance.update);\r\n                // instance.update is the reactive effect runner.\r\n                instance.update();\r\n            }\r\n        }\r\n        else {\r\n            // no update needed. just copy over properties\r\n            n2.component = n1.component;\r\n            n2.el = n1.el;\r\n            instance.vnode = n2;\r\n        }\r\n    };\r\n    const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {\r\n        // create reactive effect for rendering\r\n        instance.update = effect(function componentEffect() {\r\n            if (!instance.isMounted) {\r\n                let vnodeHook;\r\n                const { el, props } = initialVNode;\r\n                const { bm, m, a, parent } = instance;\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    startMeasure(instance, `render`);\r\n                }\r\n                const subTree = (instance.subTree = renderComponentRoot(instance));\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    endMeasure(instance, `render`);\r\n                }\r\n                // beforeMount hook\r\n                if (bm) {\r\n                    invokeArrayFns(bm);\r\n                }\r\n                // onVnodeBeforeMount\r\n                if ((vnodeHook = props && props.onVnodeBeforeMount)) {\r\n                    invokeVNodeHook(vnodeHook, parent, initialVNode);\r\n                }\r\n                if (el && hydrateNode) {\r\n                    if ((process.env.NODE_ENV !== 'production')) {\r\n                        startMeasure(instance, `hydrate`);\r\n                    }\r\n                    // vnode has adopted host node - perform hydration instead of mount.\r\n                    hydrateNode(initialVNode.el, subTree, instance, parentSuspense);\r\n                    if ((process.env.NODE_ENV !== 'production')) {\r\n                        endMeasure(instance, `hydrate`);\r\n                    }\r\n                }\r\n                else {\r\n                    if ((process.env.NODE_ENV !== 'production')) {\r\n                        startMeasure(instance, `patch`);\r\n                    }\r\n                    patch(null, subTree, container, anchor, instance, parentSuspense, isSVG);\r\n                    if ((process.env.NODE_ENV !== 'production')) {\r\n                        endMeasure(instance, `patch`);\r\n                    }\r\n                    initialVNode.el = subTree.el;\r\n                }\r\n                // mounted hook\r\n                if (m) {\r\n                    queuePostRenderEffect(m, parentSuspense);\r\n                }\r\n                // onVnodeMounted\r\n                if ((vnodeHook = props && props.onVnodeMounted)) {\r\n                    queuePostRenderEffect(() => {\r\n                        invokeVNodeHook(vnodeHook, parent, initialVNode);\r\n                    }, parentSuspense);\r\n                }\r\n                // activated hook for keep-alive roots.\r\n                if (a &&\r\n                    initialVNode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {\r\n                    queuePostRenderEffect(a, parentSuspense);\r\n                }\r\n                instance.isMounted = true;\r\n            }\r\n            else {\r\n                // updateComponent\r\n                // This is triggered by mutation of component's own state (next: null)\r\n                // OR parent calling processComponent (next: VNode)\r\n                let { next, bu, u, parent, vnode } = instance;\r\n                let originNext = next;\r\n                let vnodeHook;\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    pushWarningContext(next || instance.vnode);\r\n                }\r\n                if (next) {\r\n                    updateComponentPreRender(instance, next, optimized);\r\n                }\r\n                else {\r\n                    next = vnode;\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    startMeasure(instance, `render`);\r\n                }\r\n                const nextTree = renderComponentRoot(instance);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    endMeasure(instance, `render`);\r\n                }\r\n                const prevTree = instance.subTree;\r\n                instance.subTree = nextTree;\r\n                next.el = vnode.el;\r\n                // beforeUpdate hook\r\n                if (bu) {\r\n                    invokeArrayFns(bu);\r\n                }\r\n                // onVnodeBeforeUpdate\r\n                if ((vnodeHook = next.props && next.props.onVnodeBeforeUpdate)) {\r\n                    invokeVNodeHook(vnodeHook, parent, next, vnode);\r\n                }\r\n                // reset refs\r\n                // only needed if previous patch had refs\r\n                if (instance.refs !== EMPTY_OBJ) {\r\n                    instance.refs = {};\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    startMeasure(instance, `patch`);\r\n                }\r\n                patch(prevTree, nextTree, \r\n                // parent may have changed if it's in a teleport\r\n                hostParentNode(prevTree.el), \r\n                // anchor may have changed if it's in a fragment\r\n                getNextHostNode(prevTree), instance, parentSuspense, isSVG);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    endMeasure(instance, `patch`);\r\n                }\r\n                next.el = nextTree.el;\r\n                if (originNext === null) {\r\n                    // self-triggered update. In case of HOC, update parent component\r\n                    // vnode el. HOC is indicated by parent instance's subTree pointing\r\n                    // to child component's vnode\r\n                    updateHOCHostEl(instance, nextTree.el);\r\n                }\r\n                // updated hook\r\n                if (u) {\r\n                    queuePostRenderEffect(u, parentSuspense);\r\n                }\r\n                // onVnodeUpdated\r\n                if ((vnodeHook = next.props && next.props.onVnodeUpdated)) {\r\n                    queuePostRenderEffect(() => {\r\n                        invokeVNodeHook(vnodeHook, parent, next, vnode);\r\n                    }, parentSuspense);\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n                    devtoolsComponentUpdated(instance);\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    popWarningContext();\r\n                }\r\n            }\r\n        }, (process.env.NODE_ENV !== 'production') ? createDevEffectOptions(instance) : prodEffectOptions);\r\n    };\r\n    const updateComponentPreRender = (instance, nextVNode, optimized) => {\r\n        if ((process.env.NODE_ENV !== 'production') && instance.type.__hmrId) {\r\n            optimized = false;\r\n        }\r\n        nextVNode.component = instance;\r\n        const prevProps = instance.vnode.props;\r\n        instance.vnode = nextVNode;\r\n        instance.next = null;\r\n        updateProps(instance, nextVNode.props, prevProps, optimized);\r\n        updateSlots(instance, nextVNode.children);\r\n    };\r\n    const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized = false) => {\r\n        const c1 = n1 && n1.children;\r\n        const prevShapeFlag = n1 ? n1.shapeFlag : 0;\r\n        const c2 = n2.children;\r\n        const { patchFlag, shapeFlag } = n2;\r\n        // fast path\r\n        if (patchFlag > 0) {\r\n            if (patchFlag & 128 /* KEYED_FRAGMENT */) {\r\n                // this could be either fully-keyed or mixed (some keyed some not)\r\n                // presence of patchFlag means children are guaranteed to be arrays\r\n                patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                return;\r\n            }\r\n            else if (patchFlag & 256 /* UNKEYED_FRAGMENT */) {\r\n                // unkeyed\r\n                patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                return;\r\n            }\r\n        }\r\n        // children has 3 possibilities: text, array or no children.\r\n        if (shapeFlag & 8 /* TEXT_CHILDREN */) {\r\n            // text children fast path\r\n            if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                unmountChildren(c1, parentComponent, parentSuspense);\r\n            }\r\n            if (c2 !== c1) {\r\n                hostSetElementText(container, c2);\r\n            }\r\n        }\r\n        else {\r\n            if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                // prev children was array\r\n                if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                    // two arrays, cannot assume anything, do full diff\r\n                    patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                }\r\n                else {\r\n                    // no new children, just unmount old\r\n                    unmountChildren(c1, parentComponent, parentSuspense, true);\r\n                }\r\n            }\r\n            else {\r\n                // prev children was text OR null\r\n                // new children is array OR null\r\n                if (prevShapeFlag & 8 /* TEXT_CHILDREN */) {\r\n                    hostSetElementText(container, '');\r\n                }\r\n                // mount new if array\r\n                if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                    mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                }\r\n            }\r\n        }\r\n    };\r\n    const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        c1 = c1 || EMPTY_ARR;\r\n        c2 = c2 || EMPTY_ARR;\r\n        const oldLength = c1.length;\r\n        const newLength = c2.length;\r\n        const commonLength = Math.min(oldLength, newLength);\r\n        let i;\r\n        for (i = 0; i < commonLength; i++) {\r\n            const nextChild = (c2[i] = optimized\r\n                ? cloneIfMounted(c2[i])\r\n                : normalizeVNode(c2[i]));\r\n            patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, isSVG, optimized);\r\n        }\r\n        if (oldLength > newLength) {\r\n            // remove old\r\n            unmountChildren(c1, parentComponent, parentSuspense, true, commonLength);\r\n        }\r\n        else {\r\n            // mount new\r\n            mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, commonLength);\r\n        }\r\n    };\r\n    // can be all-keyed or mixed\r\n    const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        let i = 0;\r\n        const l2 = c2.length;\r\n        let e1 = c1.length - 1; // prev ending index\r\n        let e2 = l2 - 1; // next ending index\r\n        // 1. sync from start\r\n        // (a b) c\r\n        // (a b) d e\r\n        while (i <= e1 && i <= e2) {\r\n            const n1 = c1[i];\r\n            const n2 = (c2[i] = optimized\r\n                ? cloneIfMounted(c2[i])\r\n                : normalizeVNode(c2[i]));\r\n            if (isSameVNodeType(n1, n2)) {\r\n                patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, optimized);\r\n            }\r\n            else {\r\n                break;\r\n            }\r\n            i++;\r\n        }\r\n        // 2. sync from end\r\n        // a (b c)\r\n        // d e (b c)\r\n        while (i <= e1 && i <= e2) {\r\n            const n1 = c1[e1];\r\n            const n2 = (c2[e2] = optimized\r\n                ? cloneIfMounted(c2[e2])\r\n                : normalizeVNode(c2[e2]));\r\n            if (isSameVNodeType(n1, n2)) {\r\n                patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, optimized);\r\n            }\r\n            else {\r\n                break;\r\n            }\r\n            e1--;\r\n            e2--;\r\n        }\r\n        // 3. common sequence + mount\r\n        // (a b)\r\n        // (a b) c\r\n        // i = 2, e1 = 1, e2 = 2\r\n        // (a b)\r\n        // c (a b)\r\n        // i = 0, e1 = -1, e2 = 0\r\n        if (i > e1) {\r\n            if (i <= e2) {\r\n                const nextPos = e2 + 1;\r\n                const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;\r\n                while (i <= e2) {\r\n                    patch(null, (c2[i] = optimized\r\n                        ? cloneIfMounted(c2[i])\r\n                        : normalizeVNode(c2[i])), container, anchor, parentComponent, parentSuspense, isSVG);\r\n                    i++;\r\n                }\r\n            }\r\n        }\r\n        // 4. common sequence + unmount\r\n        // (a b) c\r\n        // (a b)\r\n        // i = 2, e1 = 2, e2 = 1\r\n        // a (b c)\r\n        // (b c)\r\n        // i = 0, e1 = 0, e2 = -1\r\n        else if (i > e2) {\r\n            while (i <= e1) {\r\n                unmount(c1[i], parentComponent, parentSuspense, true);\r\n                i++;\r\n            }\r\n        }\r\n        // 5. unknown sequence\r\n        // [i ... e1 + 1]: a b [c d e] f g\r\n        // [i ... e2 + 1]: a b [e d c h] f g\r\n        // i = 2, e1 = 4, e2 = 5\r\n        else {\r\n            const s1 = i; // prev starting index\r\n            const s2 = i; // next starting index\r\n            // 5.1 build key:index map for newChildren\r\n            const keyToNewIndexMap = new Map();\r\n            for (i = s2; i <= e2; i++) {\r\n                const nextChild = (c2[i] = optimized\r\n                    ? cloneIfMounted(c2[i])\r\n                    : normalizeVNode(c2[i]));\r\n                if (nextChild.key != null) {\r\n                    if ((process.env.NODE_ENV !== 'production') && keyToNewIndexMap.has(nextChild.key)) {\r\n                        warn(`Duplicate keys found during update:`, JSON.stringify(nextChild.key), `Make sure keys are unique.`);\r\n                    }\r\n                    keyToNewIndexMap.set(nextChild.key, i);\r\n                }\r\n            }\r\n            // 5.2 loop through old children left to be patched and try to patch\r\n            // matching nodes & remove nodes that are no longer present\r\n            let j;\r\n            let patched = 0;\r\n            const toBePatched = e2 - s2 + 1;\r\n            let moved = false;\r\n            // used to track whether any node has moved\r\n            let maxNewIndexSoFar = 0;\r\n            // works as Map<newIndex, oldIndex>\r\n            // Note that oldIndex is offset by +1\r\n            // and oldIndex = 0 is a special value indicating the new node has\r\n            // no corresponding old node.\r\n            // used for determining longest stable subsequence\r\n            const newIndexToOldIndexMap = new Array(toBePatched);\r\n            for (i = 0; i < toBePatched; i++)\r\n                newIndexToOldIndexMap[i] = 0;\r\n            for (i = s1; i <= e1; i++) {\r\n                const prevChild = c1[i];\r\n                if (patched >= toBePatched) {\r\n                    // all new children have been patched so this can only be a removal\r\n                    unmount(prevChild, parentComponent, parentSuspense, true);\r\n                    continue;\r\n                }\r\n                let newIndex;\r\n                if (prevChild.key != null) {\r\n                    newIndex = keyToNewIndexMap.get(prevChild.key);\r\n                }\r\n                else {\r\n                    // key-less node, try to locate a key-less node of the same type\r\n                    for (j = s2; j <= e2; j++) {\r\n                        if (newIndexToOldIndexMap[j - s2] === 0 &&\r\n                            isSameVNodeType(prevChild, c2[j])) {\r\n                            newIndex = j;\r\n                            break;\r\n                        }\r\n                    }\r\n                }\r\n                if (newIndex === undefined) {\r\n                    unmount(prevChild, parentComponent, parentSuspense, true);\r\n                }\r\n                else {\r\n                    newIndexToOldIndexMap[newIndex - s2] = i + 1;\r\n                    if (newIndex >= maxNewIndexSoFar) {\r\n                        maxNewIndexSoFar = newIndex;\r\n                    }\r\n                    else {\r\n                        moved = true;\r\n                    }\r\n                    patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, isSVG, optimized);\r\n                    patched++;\r\n                }\r\n            }\r\n            // 5.3 move and mount\r\n            // generate longest stable subsequence only when nodes have moved\r\n            const increasingNewIndexSequence = moved\r\n                ? getSequence(newIndexToOldIndexMap)\r\n                : EMPTY_ARR;\r\n            j = increasingNewIndexSequence.length - 1;\r\n            // looping backwards so that we can use last patched node as anchor\r\n            for (i = toBePatched - 1; i >= 0; i--) {\r\n                const nextIndex = s2 + i;\r\n                const nextChild = c2[nextIndex];\r\n                const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;\r\n                if (newIndexToOldIndexMap[i] === 0) {\r\n                    // mount new\r\n                    patch(null, nextChild, container, anchor, parentComponent, parentSuspense, isSVG);\r\n                }\r\n                else if (moved) {\r\n                    // move if:\r\n                    // There is no stable subsequence (e.g. a reverse)\r\n                    // OR current node is not among the stable sequence\r\n                    if (j < 0 || i !== increasingNewIndexSequence[j]) {\r\n                        move(nextChild, container, anchor, 2 /* REORDER */);\r\n                    }\r\n                    else {\r\n                        j--;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    };\r\n    const move = (vnode, container, anchor, moveType, parentSuspense = null) => {\r\n        const { el, type, transition, children, shapeFlag } = vnode;\r\n        if (shapeFlag & 6 /* COMPONENT */) {\r\n            move(vnode.component.subTree, container, anchor, moveType);\r\n            return;\r\n        }\r\n        if ( shapeFlag & 128 /* SUSPENSE */) {\r\n            vnode.suspense.move(container, anchor, moveType);\r\n            return;\r\n        }\r\n        if (shapeFlag & 64 /* TELEPORT */) {\r\n            type.move(vnode, container, anchor, internals);\r\n            return;\r\n        }\r\n        if (type === Fragment) {\r\n            hostInsert(el, container, anchor);\r\n            for (let i = 0; i < children.length; i++) {\r\n                move(children[i], container, anchor, moveType);\r\n            }\r\n            hostInsert(vnode.anchor, container, anchor);\r\n            return;\r\n        }\r\n        // static node move can only happen when force updating HMR\r\n        if ((process.env.NODE_ENV !== 'production') && type === Static) {\r\n            moveStaticNode(vnode, container, anchor);\r\n            return;\r\n        }\r\n        // single nodes\r\n        const needTransition = moveType !== 2 /* REORDER */ &&\r\n            shapeFlag & 1 /* ELEMENT */ &&\r\n            transition;\r\n        if (needTransition) {\r\n            if (moveType === 0 /* ENTER */) {\r\n                transition.beforeEnter(el);\r\n                hostInsert(el, container, anchor);\r\n                queuePostRenderEffect(() => transition.enter(el), parentSuspense);\r\n            }\r\n            else {\r\n                const { leave, delayLeave, afterLeave } = transition;\r\n                const remove = () => hostInsert(el, container, anchor);\r\n                const performLeave = () => {\r\n                    leave(el, () => {\r\n                        remove();\r\n                        afterLeave && afterLeave();\r\n                    });\r\n                };\r\n                if (delayLeave) {\r\n                    delayLeave(el, remove, performLeave);\r\n                }\r\n                else {\r\n                    performLeave();\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            hostInsert(el, container, anchor);\r\n        }\r\n    };\r\n    const unmount = (vnode, parentComponent, parentSuspense, doRemove = false) => {\r\n        const { type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs } = vnode;\r\n        // unset ref\r\n        if (ref != null && parentComponent) {\r\n            setRef(ref, null, parentComponent, parentSuspense, null);\r\n        }\r\n        if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {\r\n            parentComponent.ctx.deactivate(vnode);\r\n            return;\r\n        }\r\n        const shouldInvokeDirs = shapeFlag & 1 /* ELEMENT */ && dirs;\r\n        let vnodeHook;\r\n        if ((vnodeHook = props && props.onVnodeBeforeUnmount)) {\r\n            invokeVNodeHook(vnodeHook, parentComponent, vnode);\r\n        }\r\n        if (shapeFlag & 6 /* COMPONENT */) {\r\n            unmountComponent(vnode.component, parentSuspense, doRemove);\r\n        }\r\n        else {\r\n            if ( shapeFlag & 128 /* SUSPENSE */) {\r\n                vnode.suspense.unmount(parentSuspense, doRemove);\r\n                return;\r\n            }\r\n            if (shouldInvokeDirs) {\r\n                invokeDirectiveHook(vnode, null, parentComponent, 'beforeUnmount');\r\n            }\r\n            if (dynamicChildren &&\r\n                // #1153: fast path should not be taken for non-stable (v-for) fragments\r\n                (type !== Fragment ||\r\n                    (patchFlag > 0 && patchFlag & 64 /* STABLE_FRAGMENT */))) {\r\n                // fast path for block nodes: only need to unmount dynamic children.\r\n                unmountChildren(dynamicChildren, parentComponent, parentSuspense);\r\n            }\r\n            else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                unmountChildren(children, parentComponent, parentSuspense);\r\n            }\r\n            // an unmounted teleport should always remove its children\r\n            if (shapeFlag & 64 /* TELEPORT */) {\r\n                vnode.type.remove(vnode, internals);\r\n            }\r\n            if (doRemove) {\r\n                remove(vnode);\r\n            }\r\n        }\r\n        if ((vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {\r\n            queuePostRenderEffect(() => {\r\n                vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);\r\n                shouldInvokeDirs &&\r\n                    invokeDirectiveHook(vnode, null, parentComponent, 'unmounted');\r\n            }, parentSuspense);\r\n        }\r\n    };\r\n    const remove = vnode => {\r\n        const { type, el, anchor, transition } = vnode;\r\n        if (type === Fragment) {\r\n            removeFragment(el, anchor);\r\n            return;\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') && type === Static) {\r\n            removeStaticNode(vnode);\r\n            return;\r\n        }\r\n        const performRemove = () => {\r\n            hostRemove(el);\r\n            if (transition && !transition.persisted && transition.afterLeave) {\r\n                transition.afterLeave();\r\n            }\r\n        };\r\n        if (vnode.shapeFlag & 1 /* ELEMENT */ &&\r\n            transition &&\r\n            !transition.persisted) {\r\n            const { leave, delayLeave } = transition;\r\n            const performLeave = () => leave(el, performRemove);\r\n            if (delayLeave) {\r\n                delayLeave(vnode.el, performRemove, performLeave);\r\n            }\r\n            else {\r\n                performLeave();\r\n            }\r\n        }\r\n        else {\r\n            performRemove();\r\n        }\r\n    };\r\n    const removeFragment = (cur, end) => {\r\n        // For fragments, directly remove all contained DOM nodes.\r\n        // (fragment child nodes cannot have transition)\r\n        let next;\r\n        while (cur !== end) {\r\n            next = hostNextSibling(cur);\r\n            hostRemove(cur);\r\n            cur = next;\r\n        }\r\n        hostRemove(end);\r\n    };\r\n    const unmountComponent = (instance, parentSuspense, doRemove) => {\r\n        if ((process.env.NODE_ENV !== 'production') && instance.type.__hmrId) {\r\n            unregisterHMR(instance);\r\n        }\r\n        const { bum, effects, update, subTree, um, da, isDeactivated } = instance;\r\n        // beforeUnmount hook\r\n        if (bum) {\r\n            invokeArrayFns(bum);\r\n        }\r\n        if (effects) {\r\n            for (let i = 0; i < effects.length; i++) {\r\n                stop(effects[i]);\r\n            }\r\n        }\r\n        // update may be null if a component is unmounted before its async\r\n        // setup has resolved.\r\n        if (update) {\r\n            stop(update);\r\n            unmount(subTree, instance, parentSuspense, doRemove);\r\n        }\r\n        // unmounted hook\r\n        if (um) {\r\n            queuePostRenderEffect(um, parentSuspense);\r\n        }\r\n        // deactivated hook\r\n        if (da &&\r\n            !isDeactivated &&\r\n            instance.vnode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {\r\n            queuePostRenderEffect(da, parentSuspense);\r\n        }\r\n        queuePostRenderEffect(() => {\r\n            instance.isUnmounted = true;\r\n        }, parentSuspense);\r\n        // A component with async dep inside a pending suspense is unmounted before\r\n        // its async dep resolves. This should remove the dep from the suspense, and\r\n        // cause the suspense to resolve immediately if that was the last dep.\r\n        if (\r\n            parentSuspense &&\r\n            !parentSuspense.isResolved &&\r\n            !parentSuspense.isUnmounted &&\r\n            instance.asyncDep &&\r\n            !instance.asyncResolved) {\r\n            parentSuspense.deps--;\r\n            if (parentSuspense.deps === 0) {\r\n                parentSuspense.resolve();\r\n            }\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n            devtoolsComponentRemoved(instance);\r\n        }\r\n    };\r\n    const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, start = 0) => {\r\n        for (let i = start; i < children.length; i++) {\r\n            unmount(children[i], parentComponent, parentSuspense, doRemove);\r\n        }\r\n    };\r\n    const getNextHostNode = vnode => {\r\n        if (vnode.shapeFlag & 6 /* COMPONENT */) {\r\n            return getNextHostNode(vnode.component.subTree);\r\n        }\r\n        if ( vnode.shapeFlag & 128 /* SUSPENSE */) {\r\n            return vnode.suspense.next();\r\n        }\r\n        return hostNextSibling((vnode.anchor || vnode.el));\r\n    };\r\n    /**\r\n     * #1156\r\n     * When a component is HMR-enabled, we need to make sure that all static nodes\r\n     * inside a block also inherit the DOM element from the previous tree so that\r\n     * HMR updates (which are full updates) can retrieve the element for patching.\r\n     *\r\n     * Dev only.\r\n     */\r\n    const traverseStaticChildren = (n1, n2) => {\r\n        const ch1 = n1.children;\r\n        const ch2 = n2.children;\r\n        if (isArray(ch1) && isArray(ch2)) {\r\n            for (let i = 0; i < ch1.length; i++) {\r\n                // this is only called in the optimized path so array children are\r\n                // guaranteed to be vnodes\r\n                const c1 = ch1[i];\r\n                const c2 = (ch2[i] = cloneIfMounted(ch2[i]));\r\n                if (c2.shapeFlag & 1 /* ELEMENT */ && !c2.dynamicChildren) {\r\n                    if (c2.patchFlag <= 0) {\r\n                        c2.el = c1.el;\r\n                    }\r\n                    traverseStaticChildren(c1, c2);\r\n                }\r\n            }\r\n        }\r\n    };\r\n    const render = (vnode, container) => {\r\n        if (vnode == null) {\r\n            if (container._vnode) {\r\n                unmount(container._vnode, null, null, true);\r\n            }\r\n        }\r\n        else {\r\n            patch(container._vnode || null, vnode, container);\r\n        }\r\n        flushPostFlushCbs();\r\n        container._vnode = vnode;\r\n    };\r\n    const internals = {\r\n        p: patch,\r\n        um: unmount,\r\n        m: move,\r\n        r: remove,\r\n        mt: mountComponent,\r\n        mc: mountChildren,\r\n        pc: patchChildren,\r\n        pbc: patchBlockChildren,\r\n        n: getNextHostNode,\r\n        o: options\r\n    };\r\n    let hydrate;\r\n    let hydrateNode;\r\n    if (createHydrationFns) {\r\n        [hydrate, hydrateNode] = createHydrationFns(internals);\r\n    }\r\n    return {\r\n        render,\r\n        hydrate,\r\n        createApp: createAppAPI(render, hydrate)\r\n    };\r\n}\r\nfunction invokeVNodeHook(hook, instance, vnode, prevVNode = null) {\r\n    callWithAsyncErrorHandling(hook, instance, 7 /* VNODE_HOOK */, [\r\n        vnode,\r\n        prevVNode\r\n    ]);\r\n}\r\n// https://en.wikipedia.org/wiki/Longest_increasing_subsequence\r\nfunction getSequence(arr) {\r\n    const p = arr.slice();\r\n    const result = [0];\r\n    let i, j, u, v, c;\r\n    const len = arr.length;\r\n    for (i = 0; i < len; i++) {\r\n        const arrI = arr[i];\r\n        if (arrI !== 0) {\r\n            j = result[result.length - 1];\r\n            if (arr[j] < arrI) {\r\n                p[i] = j;\r\n                result.push(i);\r\n                continue;\r\n            }\r\n            u = 0;\r\n            v = result.length - 1;\r\n            while (u < v) {\r\n                c = ((u + v) / 2) | 0;\r\n                if (arr[result[c]] < arrI) {\r\n                    u = c + 1;\r\n                }\r\n                else {\r\n                    v = c;\r\n                }\r\n            }\r\n            if (arrI < arr[result[u]]) {\r\n                if (u > 0) {\r\n                    p[i] = result[u - 1];\r\n                }\r\n                result[u] = i;\r\n            }\r\n        }\r\n    }\r\n    u = result.length;\r\n    v = result[u - 1];\r\n    while (u-- > 0) {\r\n        result[u] = v;\r\n        v = p[v];\r\n    }\r\n    return result;\r\n}\n\n// Simple effect.\r\nfunction watchEffect(effect, options) {\r\n    return doWatch(effect, null, options);\r\n}\r\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\n// implementation\r\nfunction watch(source, cb, options) {\r\n    if ((process.env.NODE_ENV !== 'production') && !isFunction(cb)) {\r\n        warn(`\\`watch(fn, options?)\\` signature has been moved to a separate API. ` +\r\n            `Use \\`watchEffect(fn, options?)\\` instead. \\`watch\\` now only ` +\r\n            `supports \\`watch(source, cb, options?) signature.`);\r\n    }\r\n    return doWatch(source, cb, options);\r\n}\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n    if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n        if (immediate !== undefined) {\r\n            warn(`watch() \"immediate\" option is only respected when using the ` +\r\n                `watch(source, callback, options?) signature.`);\r\n        }\r\n        if (deep !== undefined) {\r\n            warn(`watch() \"deep\" option is only respected when using the ` +\r\n                `watch(source, callback, options?) signature.`);\r\n        }\r\n    }\r\n    const warnInvalidSource = (s) => {\r\n        warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n            `a reactive object, or an array of these types.`);\r\n    };\r\n    let getter;\r\n    if (isRef(source)) {\r\n        getter = () => source.value;\r\n    }\r\n    else if (isReactive(source)) {\r\n        getter = () => source;\r\n        deep = true;\r\n    }\r\n    else if (isArray(source)) {\r\n        getter = () => source.map(s => {\r\n            if (isRef(s)) {\r\n                return s.value;\r\n            }\r\n            else if (isReactive(s)) {\r\n                return traverse(s);\r\n            }\r\n            else if (isFunction(s)) {\r\n                return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n            }\r\n            else {\r\n                (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n            }\r\n        });\r\n    }\r\n    else if (isFunction(source)) {\r\n        if (cb) {\r\n            // getter with cb\r\n            getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n        }\r\n        else {\r\n            // no cb -> simple effect\r\n            getter = () => {\r\n                if (instance && instance.isUnmounted) {\r\n                    return;\r\n                }\r\n                if (cleanup) {\r\n                    cleanup();\r\n                }\r\n                return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n            };\r\n        }\r\n    }\r\n    else {\r\n        getter = NOOP;\r\n        (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n    }\r\n    if (cb && deep) {\r\n        const baseGetter = getter;\r\n        getter = () => traverse(baseGetter());\r\n    }\r\n    let cleanup;\r\n    const onInvalidate = (fn) => {\r\n        cleanup = runner.options.onStop = () => {\r\n            callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n        };\r\n    };\r\n    let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n    const job = () => {\r\n        if (!runner.active) {\r\n            return;\r\n        }\r\n        if (cb) {\r\n            // watch(source, cb)\r\n            const newValue = runner();\r\n            if (deep || hasChanged(newValue, oldValue)) {\r\n                // cleanup before running cb again\r\n                if (cleanup) {\r\n                    cleanup();\r\n                }\r\n                callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n                    newValue,\r\n                    // pass undefined as the old value when it's changed for the first time\r\n                    oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n                    onInvalidate\r\n                ]);\r\n                oldValue = newValue;\r\n            }\r\n        }\r\n        else {\r\n            // watchEffect\r\n            runner();\r\n        }\r\n    };\r\n    let scheduler;\r\n    if (flush === 'sync') {\r\n        scheduler = job;\r\n    }\r\n    else if (flush === 'pre') {\r\n        // ensure it's queued before component updates (which have positive ids)\r\n        job.id = -1;\r\n        scheduler = () => {\r\n            if (!instance || instance.isMounted) {\r\n                queueJob(job);\r\n            }\r\n            else {\r\n                // with 'pre' option, the first call must happen before\r\n                // the component is mounted so it is called synchronously.\r\n                job();\r\n            }\r\n        };\r\n    }\r\n    else {\r\n        scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n    }\r\n    const runner = effect(getter, {\r\n        lazy: true,\r\n        onTrack,\r\n        onTrigger,\r\n        scheduler\r\n    });\r\n    recordInstanceBoundEffect(runner);\r\n    // initial run\r\n    if (cb) {\r\n        if (immediate) {\r\n            job();\r\n        }\r\n        else {\r\n            oldValue = runner();\r\n        }\r\n    }\r\n    else {\r\n        runner();\r\n    }\r\n    return () => {\r\n        stop(runner);\r\n        if (instance) {\r\n            remove(instance.effects, runner);\r\n        }\r\n    };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n    const publicThis = this.proxy;\r\n    const getter = isString(source)\r\n        ? () => publicThis[source]\r\n        : source.bind(publicThis);\r\n    return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n    if (!isObject(value) || seen.has(value)) {\r\n        return value;\r\n    }\r\n    seen.add(value);\r\n    if (isArray(value)) {\r\n        for (let i = 0; i < value.length; i++) {\r\n            traverse(value[i], seen);\r\n        }\r\n    }\r\n    else if (value instanceof Map) {\r\n        value.forEach((v, key) => {\r\n            // to register mutation dep for existing keys\r\n            traverse(value.get(key), seen);\r\n        });\r\n    }\r\n    else if (value instanceof Set) {\r\n        value.forEach(v => {\r\n            traverse(v, seen);\r\n        });\r\n    }\r\n    else {\r\n        for (const key in value) {\r\n            traverse(value[key], seen);\r\n        }\r\n    }\r\n    return value;\r\n}\n\nfunction provide(key, value) {\r\n    if (!currentInstance) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            warn(`provide() can only be used inside setup().`);\r\n        }\r\n    }\r\n    else {\r\n        let provides = currentInstance.provides;\r\n        // by default an instance inherits its parent's provides object\r\n        // but when it needs to provide values of its own, it creates its\r\n        // own provides object using parent provides object as prototype.\r\n        // this way in `inject` we can simply look up injections from direct\r\n        // parent and let the prototype chain do the work.\r\n        const parentProvides = currentInstance.parent && currentInstance.parent.provides;\r\n        if (parentProvides === provides) {\r\n            provides = currentInstance.provides = Object.create(parentProvides);\r\n        }\r\n        // TS doesn't allow symbol as index type\r\n        provides[key] = value;\r\n    }\r\n}\r\nfunction inject(key, defaultValue) {\r\n    // fallback to `currentRenderingInstance` so that this can be called in\r\n    // a functional component\r\n    const instance = currentInstance || currentRenderingInstance;\r\n    if (instance) {\r\n        const provides = instance.provides;\r\n        if (key in provides) {\r\n            // TS doesn't allow symbol as index type\r\n            return provides[key];\r\n        }\r\n        else if (arguments.length > 1) {\r\n            return defaultValue;\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production')) {\r\n            warn(`injection \"${String(key)}\" not found.`);\r\n        }\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`inject() can only be used inside setup() or functional components.`);\r\n    }\r\n}\n\nfunction createDuplicateChecker() {\r\n    const cache = Object.create(null);\r\n    return (type, key) => {\r\n        if (cache[key]) {\r\n            warn(`${type} property \"${key}\" is already defined in ${cache[key]}.`);\r\n        }\r\n        else {\r\n            cache[key] = type;\r\n        }\r\n    };\r\n}\r\nfunction applyOptions(instance, options, deferredData = [], deferredWatch = [], asMixin = false) {\r\n    const { \r\n    // composition\r\n    mixins, extends: extendsOptions, \r\n    // state\r\n    data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, \r\n    // assets\r\n    components, directives, \r\n    // lifecycle\r\n    beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeUnmount, unmounted, renderTracked, renderTriggered, errorCaptured } = options;\r\n    const publicThis = instance.proxy;\r\n    const ctx = instance.ctx;\r\n    const globalMixins = instance.appContext.mixins;\r\n    // call it only during dev\r\n    // applyOptions is called non-as-mixin once per instance\r\n    if (!asMixin) {\r\n        callSyncHook('beforeCreate', options, publicThis, globalMixins);\r\n        // global mixins are applied first\r\n        applyMixins(instance, globalMixins, deferredData, deferredWatch);\r\n    }\r\n    // extending a base component...\r\n    if (extendsOptions) {\r\n        applyOptions(instance, extendsOptions, deferredData, deferredWatch, true);\r\n    }\r\n    // local mixins\r\n    if (mixins) {\r\n        applyMixins(instance, mixins, deferredData, deferredWatch);\r\n    }\r\n    const checkDuplicateProperties = (process.env.NODE_ENV !== 'production') ? createDuplicateChecker() : null;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const propsOptions = normalizePropsOptions(options)[0];\r\n        if (propsOptions) {\r\n            for (const key in propsOptions) {\r\n                checkDuplicateProperties(\"Props\" /* PROPS */, key);\r\n            }\r\n        }\r\n    }\r\n    // options initialization order (to be consistent with Vue 2):\r\n    // - props (already done outside of this function)\r\n    // - inject\r\n    // - methods\r\n    // - data (deferred since it relies on `this` access)\r\n    // - computed\r\n    // - watch (deferred since it relies on `this` access)\r\n    if (injectOptions) {\r\n        if (isArray(injectOptions)) {\r\n            for (let i = 0; i < injectOptions.length; i++) {\r\n                const key = injectOptions[i];\r\n                ctx[key] = inject(key);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    checkDuplicateProperties(\"Inject\" /* INJECT */, key);\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            for (const key in injectOptions) {\r\n                const opt = injectOptions[key];\r\n                if (isObject(opt)) {\r\n                    ctx[key] = inject(opt.from, opt.default);\r\n                }\r\n                else {\r\n                    ctx[key] = inject(opt);\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    checkDuplicateProperties(\"Inject\" /* INJECT */, key);\r\n                }\r\n            }\r\n        }\r\n    }\r\n    if (methods) {\r\n        for (const key in methods) {\r\n            const methodHandler = methods[key];\r\n            if (isFunction(methodHandler)) {\r\n                ctx[key] = methodHandler.bind(publicThis);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    checkDuplicateProperties(\"Methods\" /* METHODS */, key);\r\n                }\r\n            }\r\n            else if ((process.env.NODE_ENV !== 'production')) {\r\n                warn(`Method \"${key}\" has type \"${typeof methodHandler}\" in the component definition. ` +\r\n                    `Did you reference the function correctly?`);\r\n            }\r\n        }\r\n    }\r\n    if (dataOptions) {\r\n        if ((process.env.NODE_ENV !== 'production') && !isFunction(dataOptions)) {\r\n            warn(`The data option must be a function. ` +\r\n                `Plain object usage is no longer supported.`);\r\n        }\r\n        if (asMixin) {\r\n            deferredData.push(dataOptions);\r\n        }\r\n        else {\r\n            resolveData(instance, dataOptions, publicThis);\r\n        }\r\n    }\r\n    if (!asMixin) {\r\n        if (deferredData.length) {\r\n            deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis));\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            const rawData = toRaw(instance.data);\r\n            for (const key in rawData) {\r\n                checkDuplicateProperties(\"Data\" /* DATA */, key);\r\n                // expose data on ctx during dev\r\n                if (key[0] !== '$' && key[0] !== '_') {\r\n                    Object.defineProperty(ctx, key, {\r\n                        configurable: true,\r\n                        enumerable: true,\r\n                        get: () => rawData[key],\r\n                        set: NOOP\r\n                    });\r\n                }\r\n            }\r\n        }\r\n    }\r\n    if (computedOptions) {\r\n        for (const key in computedOptions) {\r\n            const opt = computedOptions[key];\r\n            const get = isFunction(opt)\r\n                ? opt.bind(publicThis, publicThis)\r\n                : isFunction(opt.get)\r\n                    ? opt.get.bind(publicThis, publicThis)\r\n                    : NOOP;\r\n            if ((process.env.NODE_ENV !== 'production') && get === NOOP) {\r\n                warn(`Computed property \"${key}\" has no getter.`);\r\n            }\r\n            const set = !isFunction(opt) && isFunction(opt.set)\r\n                ? opt.set.bind(publicThis)\r\n                : (process.env.NODE_ENV !== 'production')\r\n                    ? () => {\r\n                        warn(`Write operation failed: computed property \"${key}\" is readonly.`);\r\n                    }\r\n                    : NOOP;\r\n            const c = computed({\r\n                get,\r\n                set\r\n            });\r\n            Object.defineProperty(ctx, key, {\r\n                enumerable: true,\r\n                configurable: true,\r\n                get: () => c.value,\r\n                set: v => (c.value = v)\r\n            });\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                checkDuplicateProperties(\"Computed\" /* COMPUTED */, key);\r\n            }\r\n        }\r\n    }\r\n    if (watchOptions) {\r\n        deferredWatch.push(watchOptions);\r\n    }\r\n    if (!asMixin && deferredWatch.length) {\r\n        deferredWatch.forEach(watchOptions => {\r\n            for (const key in watchOptions) {\r\n                createWatcher(watchOptions[key], ctx, publicThis, key);\r\n            }\r\n        });\r\n    }\r\n    if (provideOptions) {\r\n        const provides = isFunction(provideOptions)\r\n            ? provideOptions.call(publicThis)\r\n            : provideOptions;\r\n        for (const key in provides) {\r\n            provide(key, provides[key]);\r\n        }\r\n    }\r\n    // asset options\r\n    if (components) {\r\n        extend(instance.components, components);\r\n    }\r\n    if (directives) {\r\n        extend(instance.directives, directives);\r\n    }\r\n    // lifecycle options\r\n    if (!asMixin) {\r\n        callSyncHook('created', options, publicThis, globalMixins);\r\n    }\r\n    if (beforeMount) {\r\n        onBeforeMount(beforeMount.bind(publicThis));\r\n    }\r\n    if (mounted) {\r\n        onMounted(mounted.bind(publicThis));\r\n    }\r\n    if (beforeUpdate) {\r\n        onBeforeUpdate(beforeUpdate.bind(publicThis));\r\n    }\r\n    if (updated) {\r\n        onUpdated(updated.bind(publicThis));\r\n    }\r\n    if (activated) {\r\n        onActivated(activated.bind(publicThis));\r\n    }\r\n    if (deactivated) {\r\n        onDeactivated(deactivated.bind(publicThis));\r\n    }\r\n    if (errorCaptured) {\r\n        onErrorCaptured(errorCaptured.bind(publicThis));\r\n    }\r\n    if (renderTracked) {\r\n        onRenderTracked(renderTracked.bind(publicThis));\r\n    }\r\n    if (renderTriggered) {\r\n        onRenderTriggered(renderTriggered.bind(publicThis));\r\n    }\r\n    if (beforeUnmount) {\r\n        onBeforeUnmount(beforeUnmount.bind(publicThis));\r\n    }\r\n    if (unmounted) {\r\n        onUnmounted(unmounted.bind(publicThis));\r\n    }\r\n}\r\nfunction callSyncHook(name, options, ctx, globalMixins) {\r\n    callHookFromMixins(name, globalMixins, ctx);\r\n    const baseHook = options.extends && options.extends[name];\r\n    if (baseHook) {\r\n        baseHook.call(ctx);\r\n    }\r\n    const mixins = options.mixins;\r\n    if (mixins) {\r\n        callHookFromMixins(name, mixins, ctx);\r\n    }\r\n    const selfHook = options[name];\r\n    if (selfHook) {\r\n        selfHook.call(ctx);\r\n    }\r\n}\r\nfunction callHookFromMixins(name, mixins, ctx) {\r\n    for (let i = 0; i < mixins.length; i++) {\r\n        const fn = mixins[i][name];\r\n        if (fn) {\r\n            fn.call(ctx);\r\n        }\r\n    }\r\n}\r\nfunction applyMixins(instance, mixins, deferredData, deferredWatch) {\r\n    for (let i = 0; i < mixins.length; i++) {\r\n        applyOptions(instance, mixins[i], deferredData, deferredWatch, true);\r\n    }\r\n}\r\nfunction resolveData(instance, dataFn, publicThis) {\r\n    const data = dataFn.call(publicThis, publicThis);\r\n    if ((process.env.NODE_ENV !== 'production') && isPromise(data)) {\r\n        warn(`data() returned a Promise - note data() cannot be async; If you ` +\r\n            `intend to perform data fetching before component renders, use ` +\r\n            `async setup() + <Suspense>.`);\r\n    }\r\n    if (!isObject(data)) {\r\n        (process.env.NODE_ENV !== 'production') && warn(`data() should return an object.`);\r\n    }\r\n    else if (instance.data === EMPTY_OBJ) {\r\n        instance.data = reactive(data);\r\n    }\r\n    else {\r\n        // existing data: this is a mixin or extends.\r\n        extend(instance.data, data);\r\n    }\r\n}\r\nfunction createWatcher(raw, ctx, publicThis, key) {\r\n    const getter = () => publicThis[key];\r\n    if (isString(raw)) {\r\n        const handler = ctx[raw];\r\n        if (isFunction(handler)) {\r\n            watch(getter, handler);\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production')) {\r\n            warn(`Invalid watch handler specified by key \"${raw}\"`, handler);\r\n        }\r\n    }\r\n    else if (isFunction(raw)) {\r\n        watch(getter, raw.bind(publicThis));\r\n    }\r\n    else if (isObject(raw)) {\r\n        if (isArray(raw)) {\r\n            raw.forEach(r => createWatcher(r, ctx, publicThis, key));\r\n        }\r\n        else {\r\n            watch(getter, raw.handler.bind(publicThis), raw);\r\n        }\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`Invalid watch option: \"${key}\"`);\r\n    }\r\n}\r\nfunction resolveMergedOptions(instance) {\r\n    const raw = instance.type;\r\n    const { __merged, mixins, extends: extendsOptions } = raw;\r\n    if (__merged)\r\n        return __merged;\r\n    const globalMixins = instance.appContext.mixins;\r\n    if (!globalMixins.length && !mixins && !extendsOptions)\r\n        return raw;\r\n    const options = {};\r\n    globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n    extendsOptions && mergeOptions(options, extendsOptions, instance);\r\n    mixins && mixins.forEach(m => mergeOptions(options, m, instance));\r\n    mergeOptions(options, raw, instance);\r\n    return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n    const strats = instance.appContext.config.optionMergeStrategies;\r\n    for (const key in from) {\r\n        if (strats && hasOwn(strats, key)) {\r\n            to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n        }\r\n        else if (!hasOwn(to, key)) {\r\n            to[key] = from[key];\r\n        }\r\n    }\r\n}\n\nconst publicPropertiesMap = extend(Object.create(null), {\r\n    $: i => i,\r\n    $el: i => i.vnode.el,\r\n    $data: i => i.data,\r\n    $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n    $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n    $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n    $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n    $parent: i => i.parent && i.parent.proxy,\r\n    $root: i => i.root && i.root.proxy,\r\n    $emit: i => i.emit,\r\n    $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n    $forceUpdate: i => () => queueJob(i.update),\r\n    $nextTick: () => nextTick,\r\n    $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n    get({ _: instance }, key) {\r\n        const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n        // let @vue/reactivity know it should never observe Vue public instances.\r\n        if (key === \"__v_skip\" /* SKIP */) {\r\n            return true;\r\n        }\r\n        // data / props / ctx\r\n        // This getter gets called for every property access on the render context\r\n        // during render and is a major hotspot. The most expensive part of this\r\n        // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n        // access on a plain object, so we use an accessCache object (with null\r\n        // prototype) to memoize what access type a key corresponds to.\r\n        let normalizedProps;\r\n        if (key[0] !== '$') {\r\n            const n = accessCache[key];\r\n            if (n !== undefined) {\r\n                switch (n) {\r\n                    case 0 /* SETUP */:\r\n                        return setupState[key];\r\n                    case 1 /* DATA */:\r\n                        return data[key];\r\n                    case 3 /* CONTEXT */:\r\n                        return ctx[key];\r\n                    case 2 /* PROPS */:\r\n                        return props[key];\r\n                    // default: just fallthrough\r\n                }\r\n            }\r\n            else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n                accessCache[key] = 0 /* SETUP */;\r\n                return setupState[key];\r\n            }\r\n            else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n                accessCache[key] = 1 /* DATA */;\r\n                return data[key];\r\n            }\r\n            else if (\r\n            // only cache other properties when instance has declared (thus stable)\r\n            // props\r\n            (normalizedProps = normalizePropsOptions(type)[0]) &&\r\n                hasOwn(normalizedProps, key)) {\r\n                accessCache[key] = 2 /* PROPS */;\r\n                return props[key];\r\n            }\r\n            else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n                accessCache[key] = 3 /* CONTEXT */;\r\n                return ctx[key];\r\n            }\r\n            else {\r\n                accessCache[key] = 4 /* OTHER */;\r\n            }\r\n        }\r\n        const publicGetter = publicPropertiesMap[key];\r\n        let cssModule, globalProperties;\r\n        // public $xxx properties\r\n        if (publicGetter) {\r\n            if (key === '$attrs') {\r\n                track(instance, \"get\" /* GET */, key);\r\n                (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n            }\r\n            return publicGetter(instance);\r\n        }\r\n        else if (\r\n        // css module (injected by vue-loader)\r\n        (cssModule = type.__cssModules) &&\r\n            (cssModule = cssModule[key])) {\r\n            return cssModule;\r\n        }\r\n        else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n            // user may set custom properties to `this` that start with `$`\r\n            accessCache[key] = 3 /* CONTEXT */;\r\n            return ctx[key];\r\n        }\r\n        else if (\r\n        // global properties\r\n        ((globalProperties = appContext.config.globalProperties),\r\n            hasOwn(globalProperties, key))) {\r\n            return globalProperties[key];\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production') &&\r\n            currentRenderingInstance &&\r\n            // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n            // to infinite warning loop\r\n            key.indexOf('__v') !== 0) {\r\n            if (data !== EMPTY_OBJ && key[0] === '$' && hasOwn(data, key)) {\r\n                warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n                    `character and is not proxied on the render context.`);\r\n            }\r\n            else {\r\n                warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n                    `but is not defined on instance.`);\r\n            }\r\n        }\r\n    },\r\n    set({ _: instance }, key, value) {\r\n        const { data, setupState, ctx } = instance;\r\n        if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n            setupState[key] = value;\r\n        }\r\n        else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n            data[key] = value;\r\n        }\r\n        else if (key in instance.props) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n            return false;\r\n        }\r\n        if (key[0] === '$' && key.slice(1) in instance) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Attempting to mutate public property \"${key}\". ` +\r\n                    `Properties starting with $ are reserved and readonly.`, instance);\r\n            return false;\r\n        }\r\n        else {\r\n            if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n                Object.defineProperty(ctx, key, {\r\n                    enumerable: true,\r\n                    configurable: true,\r\n                    value\r\n                });\r\n            }\r\n            else {\r\n                ctx[key] = value;\r\n            }\r\n        }\r\n        return true;\r\n    },\r\n    has({ _: { data, setupState, accessCache, ctx, type, appContext } }, key) {\r\n        let normalizedProps;\r\n        return (accessCache[key] !== undefined ||\r\n            (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n            (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n            ((normalizedProps = normalizePropsOptions(type)[0]) &&\r\n                hasOwn(normalizedProps, key)) ||\r\n            hasOwn(ctx, key) ||\r\n            hasOwn(publicPropertiesMap, key) ||\r\n            hasOwn(appContext.config.globalProperties, key));\r\n    }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n    PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n        warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n            `The keys will be empty in production mode to avoid performance overhead.`);\r\n        return Reflect.ownKeys(target);\r\n    };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n    get(target, key) {\r\n        // fast path for unscopables when using `with` block\r\n        if (key === Symbol.unscopables) {\r\n            return;\r\n        }\r\n        return PublicInstanceProxyHandlers.get(target, key, target);\r\n    },\r\n    has(_, key) {\r\n        const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n        if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n            warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n        }\r\n        return has;\r\n    }\r\n});\r\n// In dev mode, the proxy target exposes the same properties as seen on `this`\r\n// for easier console inspection. In prod mode it will be an empty object so\r\n// these properties definitions can be skipped.\r\nfunction createRenderContext(instance) {\r\n    const target = {};\r\n    // expose internal instance for proxy handlers\r\n    Object.defineProperty(target, `_`, {\r\n        configurable: true,\r\n        enumerable: false,\r\n        get: () => instance\r\n    });\r\n    // expose public properties\r\n    Object.keys(publicPropertiesMap).forEach(key => {\r\n        Object.defineProperty(target, key, {\r\n            configurable: true,\r\n            enumerable: false,\r\n            get: () => publicPropertiesMap[key](instance),\r\n            // intercepted by the proxy so no need for implementation,\r\n            // but needed to prevent set errors\r\n            set: NOOP\r\n        });\r\n    });\r\n    // expose global properties\r\n    const { globalProperties } = instance.appContext.config;\r\n    Object.keys(globalProperties).forEach(key => {\r\n        Object.defineProperty(target, key, {\r\n            configurable: true,\r\n            enumerable: false,\r\n            get: () => globalProperties[key],\r\n            set: NOOP\r\n        });\r\n    });\r\n    return target;\r\n}\r\n// dev only\r\nfunction exposePropsOnRenderContext(instance) {\r\n    const { ctx, type } = instance;\r\n    const propsOptions = normalizePropsOptions(type)[0];\r\n    if (propsOptions) {\r\n        Object.keys(propsOptions).forEach(key => {\r\n            Object.defineProperty(ctx, key, {\r\n                enumerable: true,\r\n                configurable: true,\r\n                get: () => instance.props[key],\r\n                set: NOOP\r\n            });\r\n        });\r\n    }\r\n}\r\n// dev only\r\nfunction exposeSetupStateOnRenderContext(instance) {\r\n    const { ctx, setupState } = instance;\r\n    Object.keys(toRaw(setupState)).forEach(key => {\r\n        Object.defineProperty(ctx, key, {\r\n            enumerable: true,\r\n            configurable: true,\r\n            get: () => setupState[key],\r\n            set: NOOP\r\n        });\r\n    });\r\n}\n\nconst emptyAppContext = createAppContext();\r\nlet uid = 0;\r\nfunction createComponentInstance(vnode, parent, suspense) {\r\n    // inherit parent app context - or - if root, adopt from root vnode\r\n    const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;\r\n    const instance = {\r\n        uid: uid++,\r\n        vnode,\r\n        parent,\r\n        appContext,\r\n        type: vnode.type,\r\n        root: null,\r\n        next: null,\r\n        subTree: null,\r\n        update: null,\r\n        render: null,\r\n        proxy: null,\r\n        withProxy: null,\r\n        effects: null,\r\n        provides: parent ? parent.provides : Object.create(appContext.provides),\r\n        accessCache: null,\r\n        renderCache: [],\r\n        // state\r\n        ctx: EMPTY_OBJ,\r\n        data: EMPTY_OBJ,\r\n        props: EMPTY_OBJ,\r\n        attrs: EMPTY_OBJ,\r\n        slots: EMPTY_OBJ,\r\n        refs: EMPTY_OBJ,\r\n        setupState: EMPTY_OBJ,\r\n        setupContext: null,\r\n        // per-instance asset storage (mutable during options resolution)\r\n        components: Object.create(appContext.components),\r\n        directives: Object.create(appContext.directives),\r\n        // suspense related\r\n        suspense,\r\n        asyncDep: null,\r\n        asyncResolved: false,\r\n        // lifecycle hooks\r\n        // not using enums here because it results in computed properties\r\n        isMounted: false,\r\n        isUnmounted: false,\r\n        isDeactivated: false,\r\n        bc: null,\r\n        c: null,\r\n        bm: null,\r\n        m: null,\r\n        bu: null,\r\n        u: null,\r\n        um: null,\r\n        bum: null,\r\n        da: null,\r\n        a: null,\r\n        rtg: null,\r\n        rtc: null,\r\n        ec: null,\r\n        emit: null,\r\n        emitted: null\r\n    };\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        instance.ctx = createRenderContext(instance);\r\n    }\r\n    else {\r\n        instance.ctx = { _: instance };\r\n    }\r\n    instance.root = parent ? parent.root : instance;\r\n    instance.emit = emit.bind(null, instance);\r\n    if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n        devtoolsComponentAdded(instance);\r\n    }\r\n    return instance;\r\n}\r\nlet currentInstance = null;\r\nconst getCurrentInstance = () => currentInstance || currentRenderingInstance;\r\nconst setCurrentInstance = (instance) => {\r\n    currentInstance = instance;\r\n};\r\nconst isBuiltInTag = /*#__PURE__*/ makeMap('slot,component');\r\nfunction validateComponentName(name, config) {\r\n    const appIsNativeTag = config.isNativeTag || NO;\r\n    if (isBuiltInTag(name) || appIsNativeTag(name)) {\r\n        warn('Do not use built-in or reserved HTML elements as component id: ' + name);\r\n    }\r\n}\r\nlet isInSSRComponentSetup = false;\r\nfunction setupComponent(instance, isSSR = false) {\r\n    isInSSRComponentSetup = isSSR;\r\n    const { props, children, shapeFlag } = instance.vnode;\r\n    const isStateful = shapeFlag & 4 /* STATEFUL_COMPONENT */;\r\n    initProps(instance, props, isStateful, isSSR);\r\n    initSlots(instance, children);\r\n    const setupResult = isStateful\r\n        ? setupStatefulComponent(instance, isSSR)\r\n        : undefined;\r\n    isInSSRComponentSetup = false;\r\n    return setupResult;\r\n}\r\nfunction setupStatefulComponent(instance, isSSR) {\r\n    const Component = instance.type;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        if (Component.name) {\r\n            validateComponentName(Component.name, instance.appContext.config);\r\n        }\r\n        if (Component.components) {\r\n            const names = Object.keys(Component.components);\r\n            for (let i = 0; i < names.length; i++) {\r\n                validateComponentName(names[i], instance.appContext.config);\r\n            }\r\n        }\r\n        if (Component.directives) {\r\n            const names = Object.keys(Component.directives);\r\n            for (let i = 0; i < names.length; i++) {\r\n                validateDirectiveName(names[i]);\r\n            }\r\n        }\r\n    }\r\n    // 0. create render proxy property access cache\r\n    instance.accessCache = {};\r\n    // 1. create public instance / render proxy\r\n    // also mark it raw so it's never observed\r\n    instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        exposePropsOnRenderContext(instance);\r\n    }\r\n    // 2. call setup()\r\n    const { setup } = Component;\r\n    if (setup) {\r\n        const setupContext = (instance.setupContext =\r\n            setup.length > 1 ? createSetupContext(instance) : null);\r\n        currentInstance = instance;\r\n        pauseTracking();\r\n        const setupResult = callWithErrorHandling(setup, instance, 0 /* SETUP_FUNCTION */, [(process.env.NODE_ENV !== 'production') ? shallowReadonly(instance.props) : instance.props, setupContext]);\r\n        resetTracking();\r\n        currentInstance = null;\r\n        if (isPromise(setupResult)) {\r\n            if (isSSR) {\r\n                // return the promise so server-renderer can wait on it\r\n                return setupResult.then((resolvedResult) => {\r\n                    handleSetupResult(instance, resolvedResult);\r\n                });\r\n            }\r\n            else {\r\n                // async setup returned Promise.\r\n                // bail here and wait for re-entry.\r\n                instance.asyncDep = setupResult;\r\n            }\r\n        }\r\n        else {\r\n            handleSetupResult(instance, setupResult);\r\n        }\r\n    }\r\n    else {\r\n        finishComponentSetup(instance);\r\n    }\r\n}\r\nfunction handleSetupResult(instance, setupResult, isSSR) {\r\n    if (isFunction(setupResult)) {\r\n        // setup returned an inline render function\r\n        instance.render = setupResult;\r\n    }\r\n    else if (isObject(setupResult)) {\r\n        if ((process.env.NODE_ENV !== 'production') && isVNode(setupResult)) {\r\n            warn(`setup() should not return VNodes directly - ` +\r\n                `return a render function instead.`);\r\n        }\r\n        // setup returned bindings.\r\n        // assuming a render function compiled from template is present.\r\n        instance.setupState = reactive(setupResult);\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            exposeSetupStateOnRenderContext(instance);\r\n        }\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production') && setupResult !== undefined) {\r\n        warn(`setup() should return an object. Received: ${setupResult === null ? 'null' : typeof setupResult}`);\r\n    }\r\n    finishComponentSetup(instance);\r\n}\r\nlet compile;\r\n/**\r\n * For runtime-dom to register the compiler.\r\n * Note the exported method uses any to avoid d.ts relying on the compiler types.\r\n */\r\nfunction registerRuntimeCompiler(_compile) {\r\n    compile = _compile;\r\n}\r\nfunction finishComponentSetup(instance, isSSR) {\r\n    const Component = instance.type;\r\n    // template / render function normalization\r\n    if (!instance.render) {\r\n        if (compile && Component.template && !Component.render) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                startMeasure(instance, `compile`);\r\n            }\r\n            Component.render = compile(Component.template, {\r\n                isCustomElement: instance.appContext.config.isCustomElement || NO\r\n            });\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                endMeasure(instance, `compile`);\r\n            }\r\n            Component.render._rc = true;\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') && !Component.render) {\r\n            /* istanbul ignore if */\r\n            if (!compile && Component.template) {\r\n                warn(`Component provided template option but ` +\r\n                    `runtime compilation is not supported in this build of Vue.` +\r\n                    ( ` Configure your bundler to alias \"vue\" to \"vue/dist/vue.esm-bundler.js\".`\r\n                        ) /* should not happen */);\r\n            }\r\n            else {\r\n                warn(`Component is missing template or render function.`);\r\n            }\r\n        }\r\n        instance.render = (Component.render || NOOP);\r\n        // for runtime-compiled render functions using `with` blocks, the render\r\n        // proxy used needs a different `has` handler which is more performant and\r\n        // also only allows a whitelist of globals to fallthrough.\r\n        if (instance.render._rc) {\r\n            instance.withProxy = new Proxy(instance.ctx, RuntimeCompiledPublicInstanceProxyHandlers);\r\n        }\r\n    }\r\n    // support for 2.x options\r\n    if (__VUE_OPTIONS_API__) {\r\n        currentInstance = instance;\r\n        applyOptions(instance, Component);\r\n        currentInstance = null;\r\n    }\r\n}\r\nconst attrHandlers = {\r\n    get: (target, key) => {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            markAttrsAccessed();\r\n        }\r\n        return target[key];\r\n    },\r\n    set: () => {\r\n        warn(`setupContext.attrs is readonly.`);\r\n        return false;\r\n    },\r\n    deleteProperty: () => {\r\n        warn(`setupContext.attrs is readonly.`);\r\n        return false;\r\n    }\r\n};\r\nfunction createSetupContext(instance) {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        // We use getters in dev in case libs like test-utils overwrite instance\r\n        // properties (overwrites should not be done in prod)\r\n        return Object.freeze({\r\n            get attrs() {\r\n                return new Proxy(instance.attrs, attrHandlers);\r\n            },\r\n            get slots() {\r\n                return shallowReadonly(instance.slots);\r\n            },\r\n            get emit() {\r\n                return (event, ...args) => instance.emit(event, ...args);\r\n            }\r\n        });\r\n    }\r\n    else {\r\n        return {\r\n            attrs: instance.attrs,\r\n            slots: instance.slots,\r\n            emit: instance.emit\r\n        };\r\n    }\r\n}\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect) {\r\n    if (currentInstance) {\r\n        (currentInstance.effects || (currentInstance.effects = [])).push(effect);\r\n    }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n    let name = isFunction(Component)\r\n        ? Component.displayName || Component.name\r\n        : Component.name;\r\n    if (!name && Component.__file) {\r\n        const match = Component.__file.match(/([^/\\\\]+)\\.vue$/);\r\n        if (match) {\r\n            name = match[1];\r\n        }\r\n    }\r\n    if (!name && instance && instance.parent) {\r\n        // try to infer the name based on local resolution\r\n        const registry = instance.parent.components;\r\n        for (const key in registry) {\r\n            if (registry[key] === Component) {\r\n                name = key;\r\n                break;\r\n            }\r\n        }\r\n    }\r\n    return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\n\nfunction computed(getterOrOptions) {\r\n    const c = computed$1(getterOrOptions);\r\n    recordInstanceBoundEffect(c.effect);\r\n    return c;\r\n}\n\n// implementation, close to no-op\r\nfunction defineComponent(options) {\r\n    return isFunction(options)\r\n        ? { setup: options, name: options.name }\r\n        : options;\r\n}\n\nfunction defineAsyncComponent(source) {\r\n    if (isFunction(source)) {\r\n        source = { loader: source };\r\n    }\r\n    const { loader, loadingComponent: loadingComponent, errorComponent: errorComponent, delay = 200, timeout, // undefined = never times out\r\n    suspensible = true, onError: userOnError } = source;\r\n    let pendingRequest = null;\r\n    let resolvedComp;\r\n    let retries = 0;\r\n    const retry = () => {\r\n        retries++;\r\n        pendingRequest = null;\r\n        return load();\r\n    };\r\n    const load = () => {\r\n        let thisRequest;\r\n        return (pendingRequest ||\r\n            (thisRequest = pendingRequest = loader()\r\n                .catch(err => {\r\n                err = err instanceof Error ? err : new Error(String(err));\r\n                if (userOnError) {\r\n                    return new Promise((resolve, reject) => {\r\n                        const userRetry = () => resolve(retry());\r\n                        const userFail = () => reject(err);\r\n                        userOnError(err, userRetry, userFail, retries + 1);\r\n                    });\r\n                }\r\n                else {\r\n                    throw err;\r\n                }\r\n            })\r\n                .then((comp) => {\r\n                if (thisRequest !== pendingRequest && pendingRequest) {\r\n                    return pendingRequest;\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && !comp) {\r\n                    warn(`Async component loader resolved to undefined. ` +\r\n                        `If you are using retry(), make sure to return its return value.`);\r\n                }\r\n                // interop module default\r\n                if (comp &&\r\n                    (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) {\r\n                    comp = comp.default;\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && comp && !isObject(comp) && !isFunction(comp)) {\r\n                    throw new Error(`Invalid async component load result: ${comp}`);\r\n                }\r\n                resolvedComp = comp;\r\n                return comp;\r\n            })));\r\n    };\r\n    return defineComponent({\r\n        __asyncLoader: load,\r\n        name: 'AsyncComponentWrapper',\r\n        setup() {\r\n            const instance = currentInstance;\r\n            // already resolved\r\n            if (resolvedComp) {\r\n                return () => createInnerComp(resolvedComp, instance);\r\n            }\r\n            const onError = (err) => {\r\n                pendingRequest = null;\r\n                handleError(err, instance, 13 /* ASYNC_COMPONENT_LOADER */);\r\n            };\r\n            // suspense-controlled or SSR.\r\n            if (( suspensible && instance.suspense) ||\r\n                (false )) {\r\n                return load()\r\n                    .then(comp => {\r\n                    return () => createInnerComp(comp, instance);\r\n                })\r\n                    .catch(err => {\r\n                    onError(err);\r\n                    return () => errorComponent\r\n                        ? createVNode(errorComponent, { error: err })\r\n                        : null;\r\n                });\r\n            }\r\n            const loaded = ref(false);\r\n            const error = ref();\r\n            const delayed = ref(!!delay);\r\n            if (delay) {\r\n                setTimeout(() => {\r\n                    delayed.value = false;\r\n                }, delay);\r\n            }\r\n            if (timeout != null) {\r\n                setTimeout(() => {\r\n                    if (!loaded.value) {\r\n                        const err = new Error(`Async component timed out after ${timeout}ms.`);\r\n                        onError(err);\r\n                        error.value = err;\r\n                    }\r\n                }, timeout);\r\n            }\r\n            load()\r\n                .then(() => {\r\n                loaded.value = true;\r\n            })\r\n                .catch(err => {\r\n                onError(err);\r\n                error.value = err;\r\n            });\r\n            return () => {\r\n                if (loaded.value && resolvedComp) {\r\n                    return createInnerComp(resolvedComp, instance);\r\n                }\r\n                else if (error.value && errorComponent) {\r\n                    return createVNode(errorComponent, {\r\n                        error: error.value\r\n                    });\r\n                }\r\n                else if (loadingComponent && !delayed.value) {\r\n                    return createVNode(loadingComponent);\r\n                }\r\n            };\r\n        }\r\n    });\r\n}\r\nfunction createInnerComp(comp, { vnode: { props, children } }) {\r\n    return createVNode(comp, props, children);\r\n}\n\n// Actual implementation\r\nfunction h(type, propsOrChildren, children) {\r\n    if (arguments.length === 2) {\r\n        if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {\r\n            // single vnode without props\r\n            if (isVNode(propsOrChildren)) {\r\n                return createVNode(type, null, [propsOrChildren]);\r\n            }\r\n            // props without children\r\n            return createVNode(type, propsOrChildren);\r\n        }\r\n        else {\r\n            // omit props\r\n            return createVNode(type, null, propsOrChildren);\r\n        }\r\n    }\r\n    else {\r\n        if (isVNode(children)) {\r\n            children = [children];\r\n        }\r\n        return createVNode(type, propsOrChildren, children);\r\n    }\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\nconst useSSRContext = () => {\r\n    {\r\n        const ctx = inject(ssrContextKey);\r\n        if (!ctx) {\r\n            warn(`Server rendering context not provided. Make sure to only call ` +\r\n                `useSsrContext() conditionally in the server build.`);\r\n        }\r\n        return ctx;\r\n    }\r\n};\n\n/**\r\n * Actual implementation\r\n */\r\nfunction renderList(source, renderItem) {\r\n    let ret;\r\n    if (isArray(source) || isString(source)) {\r\n        ret = new Array(source.length);\r\n        for (let i = 0, l = source.length; i < l; i++) {\r\n            ret[i] = renderItem(source[i], i);\r\n        }\r\n    }\r\n    else if (typeof source === 'number') {\r\n        ret = new Array(source);\r\n        for (let i = 0; i < source; i++) {\r\n            ret[i] = renderItem(i + 1, i);\r\n        }\r\n    }\r\n    else if (isObject(source)) {\r\n        if (source[Symbol.iterator]) {\r\n            ret = Array.from(source, renderItem);\r\n        }\r\n        else {\r\n            const keys = Object.keys(source);\r\n            ret = new Array(keys.length);\r\n            for (let i = 0, l = keys.length; i < l; i++) {\r\n                const key = keys[i];\r\n                ret[i] = renderItem(source[key], key, i);\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        ret = [];\r\n    }\r\n    return ret;\r\n}\n\n/**\r\n * For prefixing keys in v-on=\"obj\" with \"on\"\r\n * @private\r\n */\r\nfunction toHandlers(obj) {\r\n    const ret = {};\r\n    if ((process.env.NODE_ENV !== 'production') && !isObject(obj)) {\r\n        warn(`v-on with no argument expects an object value.`);\r\n        return ret;\r\n    }\r\n    for (const key in obj) {\r\n        ret[`on${capitalize(key)}`] = obj[key];\r\n    }\r\n    return ret;\r\n}\n\n/**\r\n * Compiler runtime helper for rendering `<slot/>`\r\n * @private\r\n */\r\nfunction renderSlot(slots, name, props = {}, \r\n// this is not a user-facing function, so the fallback is always generated by\r\n// the compiler and guaranteed to be a function returning an array\r\nfallback) {\r\n    let slot = slots[name];\r\n    if ((process.env.NODE_ENV !== 'production') && slot && slot.length > 1) {\r\n        warn(`SSR-optimized slot function detected in a non-SSR-optimized render ` +\r\n            `function. You need to mark this component with $dynamic-slots in the ` +\r\n            `parent template.`);\r\n        slot = () => [];\r\n    }\r\n    return (openBlock(),\r\n        createBlock(Fragment, { key: props.key }, slot ? slot(props) : fallback ? fallback() : [], slots._ === 1 /* STABLE */\r\n            ? 64 /* STABLE_FRAGMENT */\r\n            : -2 /* BAIL */));\r\n}\n\n/**\r\n * Compiler runtime helper for creating dynamic slots object\r\n * @private\r\n */\r\nfunction createSlots(slots, dynamicSlots) {\r\n    for (let i = 0; i < dynamicSlots.length; i++) {\r\n        const slot = dynamicSlots[i];\r\n        // array of dynamic slot generated by <template v-for=\"...\" #[...]>\r\n        if (isArray(slot)) {\r\n            for (let j = 0; j < slot.length; j++) {\r\n                slots[slot[j].name] = slot[j].fn;\r\n            }\r\n        }\r\n        else if (slot) {\r\n            // conditional single slot generated by <template v-if=\"...\" #foo>\r\n            slots[slot.name] = slot.fn;\r\n        }\r\n    }\r\n    return slots;\r\n}\n\n// Core API ------------------------------------------------------------------\r\nconst version = \"3.0.0-rc.3\";\r\n/**\r\n * SSR utils for \\@vue/server-renderer. Only exposed in cjs builds.\r\n * @internal\r\n */\r\nconst ssrUtils = ( null);\n\nexport { BaseTransition, Comment, Fragment, KeepAlive, Static, Suspense, Teleport, Text, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, computed, createBlock, createCommentVNode, createHydrationRenderer, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, defineAsyncComponent, defineComponent, devtools, getCurrentInstance, getTransitionRawChildren, h, handleError, inject, isVNode, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onUnmounted, onUpdated, openBlock, popScopeId, provide, pushScopeId, queuePostFlushCb, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, ssrContextKey, ssrUtils, toHandlers, transformVNodeArgs, useSSRContext, useTransitionState, version, warn, watch, watchEffect, withCtx, withDirectives, withScopeId };\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n    const map = Object.create(null);\r\n    const list = str.split(',');\r\n    for (let i = 0; i < list.length; i++) {\r\n        map[list[i]] = true;\r\n    }\r\n    return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\n// Patch flags are optimization hints generated by the compiler.\r\n// when a block with dynamicChildren is encountered during diff, the algorithm\r\n// enters \"optimized mode\". In this mode, we know that the vdom is produced by\r\n// a render function generated by the compiler, so the algorithm only needs to\r\n// handle updates explicitly marked by these patch flags.\r\n// dev only flag -> name mapping\r\nconst PatchFlagNames = {\r\n    [1 /* TEXT */]: `TEXT`,\r\n    [2 /* CLASS */]: `CLASS`,\r\n    [4 /* STYLE */]: `STYLE`,\r\n    [8 /* PROPS */]: `PROPS`,\r\n    [16 /* FULL_PROPS */]: `FULL_PROPS`,\r\n    [32 /* HYDRATE_EVENTS */]: `HYDRATE_EVENTS`,\r\n    [64 /* STABLE_FRAGMENT */]: `STABLE_FRAGMENT`,\r\n    [128 /* KEYED_FRAGMENT */]: `KEYED_FRAGMENT`,\r\n    [256 /* UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`,\r\n    [1024 /* DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`,\r\n    [512 /* NEED_PATCH */]: `NEED_PATCH`,\r\n    [-1 /* HOISTED */]: `HOISTED`,\r\n    [-2 /* BAIL */]: `BAIL`\r\n};\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n    'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n    'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nconst range = 2;\r\nfunction generateCodeFrame(source, start = 0, end = source.length) {\r\n    const lines = source.split(/\\r?\\n/);\r\n    let count = 0;\r\n    const res = [];\r\n    for (let i = 0; i < lines.length; i++) {\r\n        count += lines[i].length + 1;\r\n        if (count >= start) {\r\n            for (let j = i - range; j <= i + range || end > count; j++) {\r\n                if (j < 0 || j >= lines.length)\r\n                    continue;\r\n                const line = j + 1;\r\n                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);\r\n                const lineLength = lines[j].length;\r\n                if (j === i) {\r\n                    // push underline\r\n                    const pad = start - (count - lineLength) + 1;\r\n                    const length = Math.max(1, end > count ? lineLength - pad : end - start);\r\n                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));\r\n                }\r\n                else if (j > i) {\r\n                    if (end > count) {\r\n                        const length = Math.max(Math.min(end - count, lineLength), 1);\r\n                        res.push(`   |  ` + '^'.repeat(length));\r\n                    }\r\n                    count += lineLength + 1;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    }\r\n    return res.join('\\n');\r\n}\n\nconst mockError = () => mockWarn(true);\r\nfunction mockWarn(asError = false) {\r\n    expect.extend({\r\n        toHaveBeenWarned(received) {\r\n            asserted.add(received);\r\n            const passed = warn.mock.calls.some(args => args[0].indexOf(received) > -1);\r\n            if (passed) {\r\n                return {\r\n                    pass: true,\r\n                    message: () => `expected \"${received}\" not to have been warned.`\r\n                };\r\n            }\r\n            else {\r\n                const msgs = warn.mock.calls.map(args => args[0]).join('\\n - ');\r\n                return {\r\n                    pass: false,\r\n                    message: () => `expected \"${received}\" to have been warned.\\n\\nActual messages:\\n\\n - ${msgs}`\r\n                };\r\n            }\r\n        },\r\n        toHaveBeenWarnedLast(received) {\r\n            asserted.add(received);\r\n            const passed = warn.mock.calls[warn.mock.calls.length - 1][0].indexOf(received) > -1;\r\n            if (passed) {\r\n                return {\r\n                    pass: true,\r\n                    message: () => `expected \"${received}\" not to have been warned last.`\r\n                };\r\n            }\r\n            else {\r\n                const msgs = warn.mock.calls.map(args => args[0]).join('\\n - ');\r\n                return {\r\n                    pass: false,\r\n                    message: () => `expected \"${received}\" to have been warned last.\\n\\nActual messages:\\n\\n - ${msgs}`\r\n                };\r\n            }\r\n        },\r\n        toHaveBeenWarnedTimes(received, n) {\r\n            asserted.add(received);\r\n            let found = 0;\r\n            warn.mock.calls.forEach(args => {\r\n                if (args[0].indexOf(received) > -1) {\r\n                    found++;\r\n                }\r\n            });\r\n            if (found === n) {\r\n                return {\r\n                    pass: true,\r\n                    message: () => `expected \"${received}\" to have been warned ${n} times.`\r\n                };\r\n            }\r\n            else {\r\n                return {\r\n                    pass: false,\r\n                    message: () => `expected \"${received}\" to have been warned ${n} times but got ${found}.`\r\n                };\r\n            }\r\n        }\r\n    });\r\n    let warn;\r\n    const asserted = new Set();\r\n    beforeEach(() => {\r\n        asserted.clear();\r\n        warn = jest.spyOn(console, asError ? 'error' : 'warn');\r\n        warn.mockImplementation(() => { });\r\n    });\r\n    afterEach(() => {\r\n        const assertedArray = Array.from(asserted);\r\n        const nonAssertedWarnings = warn.mock.calls\r\n            .map(args => args[0])\r\n            .filter(received => {\r\n            return !assertedArray.some(assertedMsg => {\r\n                return received.indexOf(assertedMsg) > -1;\r\n            });\r\n        });\r\n        warn.mockRestore();\r\n        if (nonAssertedWarnings.length) {\r\n            nonAssertedWarnings.forEach(warning => {\r\n                console.warn(warning);\r\n            });\r\n            throw new Error(`test case threw unexpected warnings.`);\r\n        }\r\n    });\r\n}\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n/**\r\n * The full list is needed during SSR to produce the correct initial markup.\r\n */\r\nconst isBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs +\r\n    `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,` +\r\n    `loop,open,required,reversed,scoped,seamless,` +\r\n    `checked,muted,multiple,selected`);\r\nconst unsafeAttrCharRE = /[>/=\"'\\u0009\\u000a\\u000c\\u0020]/;\r\nconst attrValidationCache = {};\r\nfunction isSSRSafeAttrName(name) {\r\n    if (attrValidationCache.hasOwnProperty(name)) {\r\n        return attrValidationCache[name];\r\n    }\r\n    const isUnsafe = unsafeAttrCharRE.test(name);\r\n    if (isUnsafe) {\r\n        console.error(`unsafe attribute name: ${name}`);\r\n    }\r\n    return (attrValidationCache[name] = !isUnsafe);\r\n}\r\nconst propsToAttrMap = {\r\n    acceptCharset: 'accept-charset',\r\n    className: 'class',\r\n    htmlFor: 'for',\r\n    httpEquiv: 'http-equiv'\r\n};\r\n/**\r\n * CSS properties that accept plain numbers\r\n */\r\nconst isNoUnitNumericStyleProp = /*#__PURE__*/ makeMap(`animation-iteration-count,border-image-outset,border-image-slice,` +\r\n    `border-image-width,box-flex,box-flex-group,box-ordinal-group,column-count,` +\r\n    `columns,flex,flex-grow,flex-positive,flex-shrink,flex-negative,flex-order,` +\r\n    `grid-row,grid-row-end,grid-row-span,grid-row-start,grid-column,` +\r\n    `grid-column-end,grid-column-span,grid-column-start,font-weight,line-clamp,` +\r\n    `line-height,opacity,order,orphans,tab-size,widows,z-index,zoom,` +\r\n    // SVG\r\n    `fill-opacity,flood-opacity,stop-opacity,stroke-dasharray,stroke-dashoffset,` +\r\n    `stroke-miterlimit,stroke-opacity,stroke-width`);\r\n/**\r\n * Known attributes, this is used for stringification of runtime static nodes\r\n * so that we don't stringify bindings that cannot be set from HTML.\r\n * Don't also forget to allow `data-*` and `aria-*`!\r\n * Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes\r\n */\r\nconst isKnownAttr = /*#__PURE__*/ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,` +\r\n    `autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,` +\r\n    `border,buffered,capture,challenge,charset,checked,cite,class,code,` +\r\n    `codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,` +\r\n    `coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,` +\r\n    `disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,` +\r\n    `formaction,formenctype,formmethod,formnovalidate,formtarget,headers,` +\r\n    `height,hidden,high,href,hreflang,http-equiv,icon,id,importance,integrity,` +\r\n    `ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,` +\r\n    `manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,` +\r\n    `open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,` +\r\n    `referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,` +\r\n    `selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,` +\r\n    `start,step,style,summary,tabindex,target,title,translate,type,usemap,` +\r\n    `value,width,wrap`);\n\nfunction normalizeStyle(value) {\r\n    if (isArray(value)) {\r\n        const res = {};\r\n        for (let i = 0; i < value.length; i++) {\r\n            const item = value[i];\r\n            const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n            if (normalized) {\r\n                for (const key in normalized) {\r\n                    res[key] = normalized[key];\r\n                }\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n    else if (isObject(value)) {\r\n        return value;\r\n    }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n    const ret = {};\r\n    cssText.split(listDelimiterRE).forEach(item => {\r\n        if (item) {\r\n            const tmp = item.split(propertyDelimiterRE);\r\n            tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n        }\r\n    });\r\n    return ret;\r\n}\r\nfunction stringifyStyle(styles) {\r\n    let ret = '';\r\n    if (!styles) {\r\n        return ret;\r\n    }\r\n    for (const key in styles) {\r\n        const value = styles[key];\r\n        const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);\r\n        if (isString(value) ||\r\n            (typeof value === 'number' && isNoUnitNumericStyleProp(normalizedKey))) {\r\n            // only render valid values\r\n            ret += `${normalizedKey}:${value};`;\r\n        }\r\n    }\r\n    return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n    let res = '';\r\n    if (isString(value)) {\r\n        res = value;\r\n    }\r\n    else if (isArray(value)) {\r\n        for (let i = 0; i < value.length; i++) {\r\n            res += normalizeClass(value[i]) + ' ';\r\n        }\r\n    }\r\n    else if (isObject(value)) {\r\n        for (const name in value) {\r\n            if (value[name]) {\r\n                res += name + ' ';\r\n            }\r\n        }\r\n    }\r\n    return res.trim();\r\n}\n\n// These tag configs are shared between compiler-dom and runtime-dom, so they\r\n// https://developer.mozilla.org/en-US/docs/Web/HTML/Element\r\nconst HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' +\r\n    'header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,' +\r\n    'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' +\r\n    'data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,' +\r\n    'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' +\r\n    'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' +\r\n    'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' +\r\n    'option,output,progress,select,textarea,details,dialog,menu,' +\r\n    'summary,content,template,blockquote,iframe,tfoot';\r\n// https://developer.mozilla.org/en-US/docs/Web/SVG/Element\r\nconst SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +\r\n    'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +\r\n    'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +\r\n    'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +\r\n    'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +\r\n    'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +\r\n    'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +\r\n    'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +\r\n    'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +\r\n    'text,textPath,title,tspan,unknown,use,view';\r\nconst VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';\r\nconst isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS);\r\nconst isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS);\r\nconst isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS);\n\nconst escapeRE = /[\"'&<>]/;\r\nfunction escapeHtml(string) {\r\n    const str = '' + string;\r\n    const match = escapeRE.exec(str);\r\n    if (!match) {\r\n        return str;\r\n    }\r\n    let html = '';\r\n    let escaped;\r\n    let index;\r\n    let lastIndex = 0;\r\n    for (index = match.index; index < str.length; index++) {\r\n        switch (str.charCodeAt(index)) {\r\n            case 34: // \"\r\n                escaped = '&quot;';\r\n                break;\r\n            case 38: // &\r\n                escaped = '&amp;';\r\n                break;\r\n            case 39: // '\r\n                escaped = '&#39;';\r\n                break;\r\n            case 60: // <\r\n                escaped = '&lt;';\r\n                break;\r\n            case 62: // >\r\n                escaped = '&gt;';\r\n                break;\r\n            default:\r\n                continue;\r\n        }\r\n        if (lastIndex !== index) {\r\n            html += str.substring(lastIndex, index);\r\n        }\r\n        lastIndex = index + 1;\r\n        html += escaped;\r\n    }\r\n    return lastIndex !== index ? html + str.substring(lastIndex, index) : html;\r\n}\r\n// https://www.w3.org/TR/html52/syntax.html#comments\r\nconst commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;\r\nfunction escapeHtmlComment(src) {\r\n    return src.replace(commentStripRE, '');\r\n}\n\nfunction looseCompareArrays(a, b) {\r\n    if (a.length !== b.length)\r\n        return false;\r\n    let equal = true;\r\n    for (let i = 0; equal && i < a.length; i++) {\r\n        equal = looseEqual(a[i], b[i]);\r\n    }\r\n    return equal;\r\n}\r\nfunction looseEqual(a, b) {\r\n    if (a === b)\r\n        return true;\r\n    let aValidType = isDate(a);\r\n    let bValidType = isDate(b);\r\n    if (aValidType || bValidType) {\r\n        return aValidType && bValidType ? a.getTime() === b.getTime() : false;\r\n    }\r\n    aValidType = isArray(a);\r\n    bValidType = isArray(b);\r\n    if (aValidType || bValidType) {\r\n        return aValidType && bValidType ? looseCompareArrays(a, b) : false;\r\n    }\r\n    aValidType = isObject(a);\r\n    bValidType = isObject(b);\r\n    if (aValidType || bValidType) {\r\n        /* istanbul ignore if: this if will probably never be called */\r\n        if (!aValidType || !bValidType) {\r\n            return false;\r\n        }\r\n        const aKeysCount = Object.keys(a).length;\r\n        const bKeysCount = Object.keys(b).length;\r\n        if (aKeysCount !== bKeysCount) {\r\n            return false;\r\n        }\r\n        for (const key in a) {\r\n            const aHasKey = a.hasOwnProperty(key);\r\n            const bHasKey = b.hasOwnProperty(key);\r\n            if ((aHasKey && !bHasKey) ||\r\n                (!aHasKey && bHasKey) ||\r\n                !looseEqual(a[key], b[key])) {\r\n                return false;\r\n            }\r\n        }\r\n    }\r\n    return String(a) === String(b);\r\n}\r\nfunction looseIndexOf(arr, val) {\r\n    return arr.findIndex(item => looseEqual(item, val));\r\n}\n\n/**\r\n * For converting {{ interpolation }} values to displayed strings.\r\n * @private\r\n */\r\nconst toDisplayString = (val) => {\r\n    return val == null\r\n        ? ''\r\n        : isObject(val)\r\n            ? JSON.stringify(val, replacer, 2)\r\n            : String(val);\r\n};\r\nconst replacer = (_key, val) => {\r\n    if (val instanceof Map) {\r\n        return {\r\n            [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => {\r\n                entries[`${key} =>`] = val;\r\n                return entries;\r\n            }, {})\r\n        };\r\n    }\r\n    else if (val instanceof Set) {\r\n        return {\r\n            [`Set(${val.size})`]: [...val.values()]\r\n        };\r\n    }\r\n    else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {\r\n        return String(val);\r\n    }\r\n    return val;\r\n};\n\n/**\r\n * List of @babel/parser plugins that are used for template expression\r\n * transforms and SFC script transforms. By default we enable proposals slated\r\n * for ES2020. This will need to be updated as the spec moves forward.\r\n * Full list at https://babeljs.io/docs/en/next/babel-parser#plugins\r\n */\r\nconst babelParserDefautPlugins = [\r\n    'bigInt',\r\n    'optionalChaining',\r\n    'nullishCoalescingOperator'\r\n];\r\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n    ? Object.freeze({})\r\n    : {};\r\nconst EMPTY_ARR = [];\r\nconst NOOP = () => { };\r\n/**\r\n * Always return false.\r\n */\r\nconst NO = () => false;\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n    const i = arr.indexOf(el);\r\n    if (i > -1) {\r\n        arr.splice(i, 1);\r\n    }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isDate = (val) => val instanceof Date;\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n    return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n    return toTypeString(value).slice(8, -1);\r\n};\r\nconst isPlainObject = (val) => toTypeString(val) === '[object Object]';\r\nconst isReservedProp = /*#__PURE__*/ makeMap('key,ref,' +\r\n    'onVnodeBeforeMount,onVnodeMounted,' +\r\n    'onVnodeBeforeUpdate,onVnodeUpdated,' +\r\n    'onVnodeBeforeUnmount,onVnodeUnmounted');\r\nconst cacheStringFunction = (fn) => {\r\n    const cache = Object.create(null);\r\n    return ((str) => {\r\n        const hit = cache[str];\r\n        return hit || (cache[str] = fn(str));\r\n    });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => {\r\n    return str.replace(hyphenateRE, '-$1').toLowerCase();\r\n});\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => {\r\n    return str.charAt(0).toUpperCase() + str.slice(1);\r\n});\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nconst invokeArrayFns = (fns, arg) => {\r\n    for (let i = 0; i < fns.length; i++) {\r\n        fns[i](arg);\r\n    }\r\n};\r\nconst def = (obj, key, value) => {\r\n    Object.defineProperty(obj, key, {\r\n        configurable: true,\r\n        enumerable: false,\r\n        value\r\n    });\r\n};\r\nconst toNumber = (val) => {\r\n    const n = parseFloat(val);\r\n    return isNaN(n) ? val : n;\r\n};\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n    return (_globalThis ||\r\n        (_globalThis =\r\n            typeof globalThis !== 'undefined'\r\n                ? globalThis\r\n                : typeof self !== 'undefined'\r\n                    ? self\r\n                    : typeof window !== 'undefined'\r\n                        ? window\r\n                        : typeof global !== 'undefined'\r\n                            ? global\r\n                            : {}));\r\n};\n\nexport { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, PatchFlagNames, babelParserDefautPlugins, camelize, capitalize, def, escapeHtml, escapeHtmlComment, extend, generateCodeFrame, getGlobalThis, hasChanged, hasOwn, hyphenate, invokeArrayFns, isArray, isBooleanAttr, isDate, isFunction, isGloballyWhitelisted, isHTMLTag, isKnownAttr, isModelListener, isNoUnitNumericStyleProp, isObject, isOn, isPlainObject, isPromise, isReservedProp, isSSRSafeAttrName, isSVGTag, isSpecialBooleanAttr, isString, isSymbol, isVoidTag, looseEqual, looseIndexOf, makeMap, mockError, mockWarn, normalizeClass, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, stringifyStyle, toDisplayString, toNumber, toRawType, toTypeString };\n","import { camelize, warn, callWithAsyncErrorHandling, getCurrentInstance, onMounted, watchEffect, unref, Fragment, h, BaseTransition, useTransitionState, onUpdated, getTransitionRawChildren, setTransitionHooks, resolveTransitionHooks, createVNode, createRenderer, createHydrationRenderer } from '@vue/runtime-core';\nexport * from '@vue/runtime-core';\nimport { isString, hyphenate, capitalize, isSpecialBooleanAttr, isArray, isOn, isModelListener, isFunction, EMPTY_OBJ, extend, isObject, toNumber, invokeArrayFns, looseIndexOf, looseEqual, isHTMLTag, isSVGTag } from '@vue/shared';\n\nconst svgNS = 'http://www.w3.org/2000/svg';\r\nconst doc = (typeof document !== 'undefined' ? document : null);\r\nlet tempContainer;\r\nlet tempSVGContainer;\r\nconst nodeOps = {\r\n    insert: (child, parent, anchor) => {\r\n        parent.insertBefore(child, anchor || null);\r\n    },\r\n    remove: child => {\r\n        const parent = child.parentNode;\r\n        if (parent) {\r\n            parent.removeChild(child);\r\n        }\r\n    },\r\n    createElement: (tag, isSVG, is) => isSVG\r\n        ? doc.createElementNS(svgNS, tag)\r\n        : doc.createElement(tag, is ? { is } : undefined),\r\n    createText: text => doc.createTextNode(text),\r\n    createComment: text => doc.createComment(text),\r\n    setText: (node, text) => {\r\n        node.nodeValue = text;\r\n    },\r\n    setElementText: (el, text) => {\r\n        el.textContent = text;\r\n    },\r\n    parentNode: node => node.parentNode,\r\n    nextSibling: node => node.nextSibling,\r\n    querySelector: selector => doc.querySelector(selector),\r\n    setScopeId(el, id) {\r\n        el.setAttribute(id, '');\r\n    },\r\n    cloneNode(el) {\r\n        return el.cloneNode(true);\r\n    },\r\n    // __UNSAFE__\r\n    // Reason: innerHTML.\r\n    // Static content here can only come from compiled templates.\r\n    // As long as the user only uses trusted templates, this is safe.\r\n    insertStaticContent(content, parent, anchor, isSVG) {\r\n        const temp = isSVG\r\n            ? tempSVGContainer ||\r\n                (tempSVGContainer = doc.createElementNS(svgNS, 'svg'))\r\n            : tempContainer || (tempContainer = doc.createElement('div'));\r\n        temp.innerHTML = content;\r\n        const first = temp.firstChild;\r\n        let node = first;\r\n        let last = node;\r\n        while (node) {\r\n            last = node;\r\n            nodeOps.insert(node, parent, anchor);\r\n            node = temp.firstChild;\r\n        }\r\n        return [first, last];\r\n    }\r\n};\n\n// compiler should normalize class + :class bindings on the same element\r\n// into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n    if (value == null) {\r\n        value = '';\r\n    }\r\n    if (isSVG) {\r\n        el.setAttribute('class', value);\r\n    }\r\n    else {\r\n        // directly setting className should be faster than setAttribute in theory\r\n        // if this is an element during a transition, take the temporary transition\r\n        // classes into account.\r\n        const transitionClasses = el._vtc;\r\n        if (transitionClasses) {\r\n            value = (value\r\n                ? [value, ...transitionClasses]\r\n                : [...transitionClasses]).join(' ');\r\n        }\r\n        el.className = value;\r\n    }\r\n}\n\nfunction patchStyle(el, prev, next) {\r\n    const style = el.style;\r\n    if (!next) {\r\n        el.removeAttribute('style');\r\n    }\r\n    else if (isString(next)) {\r\n        if (prev !== next) {\r\n            style.cssText = next;\r\n        }\r\n    }\r\n    else {\r\n        for (const key in next) {\r\n            setStyle(style, key, next[key]);\r\n        }\r\n        if (prev && !isString(prev)) {\r\n            for (const key in prev) {\r\n                if (next[key] == null) {\r\n                    setStyle(style, key, '');\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\nconst importantRE = /\\s*!important$/;\r\nfunction setStyle(style, name, val) {\r\n    if (name.startsWith('--')) {\r\n        // custom property definition\r\n        style.setProperty(name, val);\r\n    }\r\n    else {\r\n        const prefixed = autoPrefix(style, name);\r\n        if (importantRE.test(val)) {\r\n            // !important\r\n            style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');\r\n        }\r\n        else {\r\n            style[prefixed] = val;\r\n        }\r\n    }\r\n}\r\nconst prefixes = ['Webkit', 'Moz', 'ms'];\r\nconst prefixCache = {};\r\nfunction autoPrefix(style, rawName) {\r\n    const cached = prefixCache[rawName];\r\n    if (cached) {\r\n        return cached;\r\n    }\r\n    let name = camelize(rawName);\r\n    if (name !== 'filter' && name in style) {\r\n        return (prefixCache[rawName] = name);\r\n    }\r\n    name = capitalize(name);\r\n    for (let i = 0; i < prefixes.length; i++) {\r\n        const prefixed = prefixes[i] + name;\r\n        if (prefixed in style) {\r\n            return (prefixCache[rawName] = prefixed);\r\n        }\r\n    }\r\n    return rawName;\r\n}\n\nconst xlinkNS = 'http://www.w3.org/1999/xlink';\r\nfunction patchAttr(el, key, value, isSVG) {\r\n    if (isSVG && key.startsWith('xlink:')) {\r\n        if (value == null) {\r\n            el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\r\n        }\r\n        else {\r\n            el.setAttributeNS(xlinkNS, key, value);\r\n        }\r\n    }\r\n    else {\r\n        // note we are only checking boolean attributes that don't have a\r\n        // corresponding dom prop of the same name here.\r\n        const isBoolean = isSpecialBooleanAttr(key);\r\n        if (value == null || (isBoolean && value === false)) {\r\n            el.removeAttribute(key);\r\n        }\r\n        else {\r\n            el.setAttribute(key, isBoolean ? '' : value);\r\n        }\r\n    }\r\n}\n\n// __UNSAFE__\r\n// functions. The user is responsible for using them with only trusted content.\r\nfunction patchDOMProp(el, key, value, \r\n// the following args are passed only due to potential innerHTML/textContent\r\n// overriding existing VNodes, in which case the old tree must be properly\r\n// unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n    if (key === 'innerHTML' || key === 'textContent') {\r\n        if (prevChildren) {\r\n            unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n        }\r\n        el[key] = value == null ? '' : value;\r\n        return;\r\n    }\r\n    if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n        // store value as _value as well since\r\n        // non-string values will be stringified.\r\n        el._value = value;\r\n        el.value = value == null ? '' : value;\r\n        return;\r\n    }\r\n    if (value === '' && typeof el[key] === 'boolean') {\r\n        // e.g. <select multiple> compiles to { multiple: '' }\r\n        el[key] = true;\r\n    }\r\n    else if (value == null && typeof el[key] === 'string') {\r\n        // e.g. <div :id=\"null\">\r\n        el[key] = '';\r\n        el.removeAttribute(key);\r\n    }\r\n    else {\r\n        // some properties perform value validation and throw\r\n        try {\r\n            el[key] = value;\r\n        }\r\n        catch (e) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                warn(`Failed setting prop \"${key}\" on <${el.tagName.toLowerCase()}>: ` +\r\n                    `value ${value} is invalid.`, e);\r\n            }\r\n        }\r\n    }\r\n}\n\n// Async edge case fix requires storing an event listener's attach timestamp.\r\nlet _getNow = Date.now;\r\n// Determine what event timestamp the browser is using. Annoyingly, the\r\n// timestamp can either be hi-res (relative to page load) or low-res\r\n// (relative to UNIX epoch), so in order to compare time we have to use the\r\n// same timestamp type when saving the flush timestamp.\r\nif (typeof document !== 'undefined' &&\r\n    _getNow() > document.createEvent('Event').timeStamp) {\r\n    // if the low-res timestamp which is bigger than the event timestamp\r\n    // (which is evaluated AFTER) it means the event is using a hi-res timestamp,\r\n    // and we need to use the hi-res version for event listeners as well.\r\n    _getNow = () => performance.now();\r\n}\r\n// To avoid the overhead of repeatedly calling performance.now(), we cache\r\n// and use the same timestamp for all event listeners attached in the same tick.\r\nlet cachedNow = 0;\r\nconst p = Promise.resolve();\r\nconst reset = () => {\r\n    cachedNow = 0;\r\n};\r\nconst getNow = () => cachedNow || (p.then(reset), (cachedNow = _getNow()));\r\nfunction addEventListener(el, event, handler, options) {\r\n    el.addEventListener(event, handler, options);\r\n}\r\nfunction removeEventListener(el, event, handler, options) {\r\n    el.removeEventListener(event, handler, options);\r\n}\r\nfunction patchEvent(el, rawName, prevValue, nextValue, instance = null) {\r\n    const invoker = prevValue && prevValue.invoker;\r\n    if (nextValue && invoker) {\r\n        prevValue.invoker = null;\r\n        invoker.value = nextValue;\r\n        nextValue.invoker = invoker;\r\n    }\r\n    else {\r\n        const [name, options] = parseName(rawName);\r\n        if (nextValue) {\r\n            addEventListener(el, name, createInvoker(nextValue, instance), options);\r\n        }\r\n        else if (invoker) {\r\n            // remove\r\n            removeEventListener(el, name, invoker, options);\r\n        }\r\n    }\r\n}\r\nconst optionsModifierRE = /(?:Once|Passive|Capture)$/;\r\nfunction parseName(name) {\r\n    let options;\r\n    if (optionsModifierRE.test(name)) {\r\n        options = {};\r\n        let m;\r\n        while ((m = name.match(optionsModifierRE))) {\r\n            name = name.slice(0, name.length - m[0].length);\r\n            options[m[0].toLowerCase()] = true;\r\n        }\r\n    }\r\n    return [name.slice(2).toLowerCase(), options];\r\n}\r\nfunction createInvoker(initialValue, instance) {\r\n    const invoker = (e) => {\r\n        // async edge case #6566: inner click event triggers patch, event handler\r\n        // attached to outer element during patch, and triggered again. This\r\n        // happens because browsers fire microtask ticks between event propagation.\r\n        // the solution is simple: we save the timestamp when a handler is attached,\r\n        // and the handler would only fire if the event passed to it was fired\r\n        // AFTER it was attached.\r\n        const timeStamp = e.timeStamp || _getNow();\r\n        if (timeStamp >= invoker.attached - 1) {\r\n            callWithAsyncErrorHandling(patchStopImmediatePropagation(e, invoker.value), instance, 5 /* NATIVE_EVENT_HANDLER */, [e]);\r\n        }\r\n    };\r\n    invoker.value = initialValue;\r\n    initialValue.invoker = invoker;\r\n    invoker.attached = getNow();\r\n    return invoker;\r\n}\r\nfunction patchStopImmediatePropagation(e, value) {\r\n    if (isArray(value)) {\r\n        const originalStop = e.stopImmediatePropagation;\r\n        e.stopImmediatePropagation = () => {\r\n            originalStop.call(e);\r\n            e._stopped = true;\r\n        };\r\n        return value.map(fn => (e) => !e._stopped && fn(e));\r\n    }\r\n    else {\r\n        return value;\r\n    }\r\n}\n\nconst nativeOnRE = /^on[a-z]/;\r\nconst forcePatchProp = (_, key) => key === 'value';\r\nconst patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {\r\n    switch (key) {\r\n        // special\r\n        case 'class':\r\n            patchClass(el, nextValue, isSVG);\r\n            break;\r\n        case 'style':\r\n            patchStyle(el, prevValue, nextValue);\r\n            break;\r\n        default:\r\n            if (isOn(key)) {\r\n                // ignore v-model listeners\r\n                if (!isModelListener(key)) {\r\n                    patchEvent(el, key, prevValue, nextValue, parentComponent);\r\n                }\r\n            }\r\n            else if (shouldSetAsProp(el, key, nextValue, isSVG)) {\r\n                patchDOMProp(el, key, nextValue, prevChildren, parentComponent, parentSuspense, unmountChildren);\r\n            }\r\n            else {\r\n                // special case for <input v-model type=\"checkbox\"> with\r\n                // :true-value & :false-value\r\n                // store value as dom properties since non-string values will be\r\n                // stringified.\r\n                if (key === 'true-value') {\r\n                    el._trueValue = nextValue;\r\n                }\r\n                else if (key === 'false-value') {\r\n                    el._falseValue = nextValue;\r\n                }\r\n                patchAttr(el, key, nextValue, isSVG);\r\n            }\r\n            break;\r\n    }\r\n};\r\nfunction shouldSetAsProp(el, key, value, isSVG) {\r\n    if (isSVG) {\r\n        // most keys must be set as attribute on svg elements to work\r\n        // ...except innerHTML\r\n        if (key === 'innerHTML') {\r\n            return true;\r\n        }\r\n        // or native onclick with function values\r\n        if (key in el && nativeOnRE.test(key) && isFunction(value)) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n    // spellcheck and draggable are numerated attrs, however their\r\n    // corresponding DOM properties are actually booleans - this leads to\r\n    // setting it with a string \"false\" value leading it to be coerced to\r\n    // `true`, so we need to always treat them as attributes.\r\n    // Note that `contentEditable` doesn't have this problem: its DOM\r\n    // property is also enumerated string values.\r\n    if (key === 'spellcheck' || key === 'draggable') {\r\n        return false;\r\n    }\r\n    // #1526 <input list> must be set as attribute\r\n    if (key === 'list' && el.tagName === 'INPUT') {\r\n        return false;\r\n    }\r\n    // native onclick with string value, must be set as attribute\r\n    if (nativeOnRE.test(key) && isString(value)) {\r\n        return false;\r\n    }\r\n    return key in el;\r\n}\n\nfunction useCssModule(name = '$style') {\r\n    /* istanbul ignore else */\r\n    {\r\n        const instance = getCurrentInstance();\r\n        if (!instance) {\r\n            (process.env.NODE_ENV !== 'production') && warn(`useCssModule must be called inside setup()`);\r\n            return EMPTY_OBJ;\r\n        }\r\n        const modules = instance.type.__cssModules;\r\n        if (!modules) {\r\n            (process.env.NODE_ENV !== 'production') && warn(`Current instance does not have CSS modules injected.`);\r\n            return EMPTY_OBJ;\r\n        }\r\n        const mod = modules[name];\r\n        if (!mod) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Current instance does not have CSS module named \"${name}\".`);\r\n            return EMPTY_OBJ;\r\n        }\r\n        return mod;\r\n    }\r\n}\n\nfunction useCssVars(getter, scoped = false) {\r\n    const instance = getCurrentInstance();\r\n    /* istanbul ignore next */\r\n    if (!instance) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn(`useCssVars is called without current active component instance.`);\r\n        return;\r\n    }\r\n    const prefix = scoped && instance.type.__scopeId\r\n        ? `${instance.type.__scopeId.replace(/^data-v-/, '')}-`\r\n        : ``;\r\n    onMounted(() => {\r\n        watchEffect(() => {\r\n            setVarsOnVNode(instance.subTree, getter(instance.proxy), prefix);\r\n        });\r\n    });\r\n}\r\nfunction setVarsOnVNode(vnode, vars, prefix) {\r\n    // drill down HOCs until it's a non-component vnode\r\n    while (vnode.component) {\r\n        vnode = vnode.component.subTree;\r\n    }\r\n    if (vnode.shapeFlag & 1 /* ELEMENT */ && vnode.el) {\r\n        const style = vnode.el.style;\r\n        for (const key in vars) {\r\n            style.setProperty(`--${prefix}${key}`, unref(vars[key]));\r\n        }\r\n    }\r\n    else if (vnode.type === Fragment) {\r\n        vnode.children.forEach(c => setVarsOnVNode(c, vars, prefix));\r\n    }\r\n}\n\nconst TRANSITION = 'transition';\r\nconst ANIMATION = 'animation';\r\n// DOM Transition is a higher-order-component based on the platform-agnostic\r\n// base Transition component, with DOM-specific logic.\r\nconst Transition = (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots);\r\nTransition.displayName = 'Transition';\r\nconst DOMTransitionPropsValidators = {\r\n    name: String,\r\n    type: String,\r\n    css: {\r\n        type: Boolean,\r\n        default: true\r\n    },\r\n    duration: [String, Number, Object],\r\n    enterFromClass: String,\r\n    enterActiveClass: String,\r\n    enterToClass: String,\r\n    appearFromClass: String,\r\n    appearActiveClass: String,\r\n    appearToClass: String,\r\n    leaveFromClass: String,\r\n    leaveActiveClass: String,\r\n    leaveToClass: String\r\n};\r\nconst TransitionPropsValidators = (Transition.props = /*#__PURE__*/ extend({}, BaseTransition.props, DOMTransitionPropsValidators));\r\nfunction resolveTransitionProps(rawProps) {\r\n    let { name = 'v', type, css = true, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps;\r\n    const baseProps = {};\r\n    for (const key in rawProps) {\r\n        if (!(key in DOMTransitionPropsValidators)) {\r\n            baseProps[key] = rawProps[key];\r\n        }\r\n    }\r\n    if (!css) {\r\n        return baseProps;\r\n    }\r\n    const durations = normalizeDuration(duration);\r\n    const enterDuration = durations && durations[0];\r\n    const leaveDuration = durations && durations[1];\r\n    const { onBeforeEnter, onEnter, onEnterCancelled, onLeave, onLeaveCancelled, onBeforeAppear = onBeforeEnter, onAppear = onEnter, onAppearCancelled = onEnterCancelled } = baseProps;\r\n    const finishEnter = (el, isAppear, done) => {\r\n        removeTransitionClass(el, isAppear ? appearToClass : enterToClass);\r\n        removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);\r\n        done && done();\r\n    };\r\n    const finishLeave = (el, done) => {\r\n        removeTransitionClass(el, leaveToClass);\r\n        removeTransitionClass(el, leaveActiveClass);\r\n        done && done();\r\n    };\r\n    const makeEnterHook = (isAppear) => {\r\n        return (el, done) => {\r\n            const hook = isAppear ? onAppear : onEnter;\r\n            const resolve = () => finishEnter(el, isAppear, done);\r\n            hook && hook(el, resolve);\r\n            nextFrame(() => {\r\n                removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);\r\n                addTransitionClass(el, isAppear ? appearToClass : enterToClass);\r\n                if (!(hook && hook.length > 1)) {\r\n                    if (enterDuration) {\r\n                        setTimeout(resolve, enterDuration);\r\n                    }\r\n                    else {\r\n                        whenTransitionEnds(el, type, resolve);\r\n                    }\r\n                }\r\n            });\r\n        };\r\n    };\r\n    return extend(baseProps, {\r\n        onBeforeEnter(el) {\r\n            onBeforeEnter && onBeforeEnter(el);\r\n            addTransitionClass(el, enterActiveClass);\r\n            addTransitionClass(el, enterFromClass);\r\n        },\r\n        onBeforeAppear(el) {\r\n            onBeforeAppear && onBeforeAppear(el);\r\n            addTransitionClass(el, appearActiveClass);\r\n            addTransitionClass(el, appearFromClass);\r\n        },\r\n        onEnter: makeEnterHook(false),\r\n        onAppear: makeEnterHook(true),\r\n        onLeave(el, done) {\r\n            const resolve = () => finishLeave(el, done);\r\n            addTransitionClass(el, leaveActiveClass);\r\n            addTransitionClass(el, leaveFromClass);\r\n            nextFrame(() => {\r\n                removeTransitionClass(el, leaveFromClass);\r\n                addTransitionClass(el, leaveToClass);\r\n                if (!(onLeave && onLeave.length > 1)) {\r\n                    if (leaveDuration) {\r\n                        setTimeout(resolve, leaveDuration);\r\n                    }\r\n                    else {\r\n                        whenTransitionEnds(el, type, resolve);\r\n                    }\r\n                }\r\n            });\r\n            onLeave && onLeave(el, resolve);\r\n        },\r\n        onEnterCancelled(el) {\r\n            finishEnter(el, false);\r\n            onEnterCancelled && onEnterCancelled(el);\r\n        },\r\n        onAppearCancelled(el) {\r\n            finishEnter(el, true);\r\n            onAppearCancelled && onAppearCancelled(el);\r\n        },\r\n        onLeaveCancelled(el) {\r\n            finishLeave(el);\r\n            onLeaveCancelled && onLeaveCancelled(el);\r\n        }\r\n    });\r\n}\r\nfunction normalizeDuration(duration) {\r\n    if (duration == null) {\r\n        return null;\r\n    }\r\n    else if (isObject(duration)) {\r\n        return [NumberOf(duration.enter), NumberOf(duration.leave)];\r\n    }\r\n    else {\r\n        const n = NumberOf(duration);\r\n        return [n, n];\r\n    }\r\n}\r\nfunction NumberOf(val) {\r\n    const res = toNumber(val);\r\n    if ((process.env.NODE_ENV !== 'production'))\r\n        validateDuration(res);\r\n    return res;\r\n}\r\nfunction validateDuration(val) {\r\n    if (typeof val !== 'number') {\r\n        warn(`<transition> explicit duration is not a valid number - ` +\r\n            `got ${JSON.stringify(val)}.`);\r\n    }\r\n    else if (isNaN(val)) {\r\n        warn(`<transition> explicit duration is NaN - ` +\r\n            'the duration expression might be incorrect.');\r\n    }\r\n}\r\nfunction addTransitionClass(el, cls) {\r\n    cls.split(/\\s+/).forEach(c => c && el.classList.add(c));\r\n    (el._vtc ||\r\n        (el._vtc = new Set())).add(cls);\r\n}\r\nfunction removeTransitionClass(el, cls) {\r\n    cls.split(/\\s+/).forEach(c => c && el.classList.remove(c));\r\n    const { _vtc } = el;\r\n    if (_vtc) {\r\n        _vtc.delete(cls);\r\n        if (!_vtc.size) {\r\n            el._vtc = undefined;\r\n        }\r\n    }\r\n}\r\nfunction nextFrame(cb) {\r\n    requestAnimationFrame(() => {\r\n        requestAnimationFrame(cb);\r\n    });\r\n}\r\nfunction whenTransitionEnds(el, expectedType, cb) {\r\n    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);\r\n    if (!type) {\r\n        return cb();\r\n    }\r\n    const endEvent = type + 'end';\r\n    let ended = 0;\r\n    const end = () => {\r\n        el.removeEventListener(endEvent, onEnd);\r\n        cb();\r\n    };\r\n    const onEnd = (e) => {\r\n        if (e.target === el) {\r\n            if (++ended >= propCount) {\r\n                end();\r\n            }\r\n        }\r\n    };\r\n    setTimeout(() => {\r\n        if (ended < propCount) {\r\n            end();\r\n        }\r\n    }, timeout + 1);\r\n    el.addEventListener(endEvent, onEnd);\r\n}\r\nfunction getTransitionInfo(el, expectedType) {\r\n    const styles = window.getComputedStyle(el);\r\n    // JSDOM may return undefined for transition properties\r\n    const getStyleProperties = (key) => (styles[key] || '').split(', ');\r\n    const transitionDelays = getStyleProperties(TRANSITION + 'Delay');\r\n    const transitionDurations = getStyleProperties(TRANSITION + 'Duration');\r\n    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);\r\n    const animationDelays = getStyleProperties(ANIMATION + 'Delay');\r\n    const animationDurations = getStyleProperties(ANIMATION + 'Duration');\r\n    const animationTimeout = getTimeout(animationDelays, animationDurations);\r\n    let type = null;\r\n    let timeout = 0;\r\n    let propCount = 0;\r\n    /* istanbul ignore if */\r\n    if (expectedType === TRANSITION) {\r\n        if (transitionTimeout > 0) {\r\n            type = TRANSITION;\r\n            timeout = transitionTimeout;\r\n            propCount = transitionDurations.length;\r\n        }\r\n    }\r\n    else if (expectedType === ANIMATION) {\r\n        if (animationTimeout > 0) {\r\n            type = ANIMATION;\r\n            timeout = animationTimeout;\r\n            propCount = animationDurations.length;\r\n        }\r\n    }\r\n    else {\r\n        timeout = Math.max(transitionTimeout, animationTimeout);\r\n        type =\r\n            timeout > 0\r\n                ? transitionTimeout > animationTimeout\r\n                    ? TRANSITION\r\n                    : ANIMATION\r\n                : null;\r\n        propCount = type\r\n            ? type === TRANSITION\r\n                ? transitionDurations.length\r\n                : animationDurations.length\r\n            : 0;\r\n    }\r\n    const hasTransform = type === TRANSITION &&\r\n        /\\b(transform|all)(,|$)/.test(styles[TRANSITION + 'Property']);\r\n    return {\r\n        type,\r\n        timeout,\r\n        propCount,\r\n        hasTransform\r\n    };\r\n}\r\nfunction getTimeout(delays, durations) {\r\n    while (delays.length < durations.length) {\r\n        delays = delays.concat(delays);\r\n    }\r\n    return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));\r\n}\r\n// Old versions of Chromium (below 61.0.3163.100) formats floating pointer\r\n// numbers in a locale-dependent way, using a comma instead of a dot.\r\n// If comma is not replaced with a dot, the input will be rounded down\r\n// (i.e. acting as a floor function) causing unexpected behaviors\r\nfunction toMs(s) {\r\n    return Number(s.slice(0, -1).replace(',', '.')) * 1000;\r\n}\n\nfunction toRaw(observed) {\r\n    return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\n\nconst positionMap = new WeakMap();\r\nconst newPositionMap = new WeakMap();\r\nconst TransitionGroupImpl = {\r\n    name: 'TransitionGroup',\r\n    props: /*#__PURE__*/ extend({}, TransitionPropsValidators, {\r\n        tag: String,\r\n        moveClass: String\r\n    }),\r\n    setup(props, { slots }) {\r\n        const instance = getCurrentInstance();\r\n        const state = useTransitionState();\r\n        let prevChildren;\r\n        let children;\r\n        onUpdated(() => {\r\n            // children is guaranteed to exist after initial render\r\n            if (!prevChildren.length) {\r\n                return;\r\n            }\r\n            const moveClass = props.moveClass || `${props.name || 'v'}-move`;\r\n            if (!hasCSSTransform(prevChildren[0].el, instance.vnode.el, moveClass)) {\r\n                return;\r\n            }\r\n            // we divide the work into three loops to avoid mixing DOM reads and writes\r\n            // in each iteration - which helps prevent layout thrashing.\r\n            prevChildren.forEach(callPendingCbs);\r\n            prevChildren.forEach(recordPosition);\r\n            const movedChildren = prevChildren.filter(applyTranslation);\r\n            // force reflow to put everything in position\r\n            forceReflow();\r\n            movedChildren.forEach(c => {\r\n                const el = c.el;\r\n                const style = el.style;\r\n                addTransitionClass(el, moveClass);\r\n                style.transform = style.webkitTransform = style.transitionDuration = '';\r\n                const cb = (el._moveCb = (e) => {\r\n                    if (e && e.target !== el) {\r\n                        return;\r\n                    }\r\n                    if (!e || /transform$/.test(e.propertyName)) {\r\n                        el.removeEventListener('transitionend', cb);\r\n                        el._moveCb = null;\r\n                        removeTransitionClass(el, moveClass);\r\n                    }\r\n                });\r\n                el.addEventListener('transitionend', cb);\r\n            });\r\n        });\r\n        return () => {\r\n            const rawProps = toRaw(props);\r\n            const cssTransitionProps = resolveTransitionProps(rawProps);\r\n            const tag = rawProps.tag || Fragment;\r\n            prevChildren = children;\r\n            children = slots.default ? getTransitionRawChildren(slots.default()) : [];\r\n            for (let i = 0; i < children.length; i++) {\r\n                const child = children[i];\r\n                if (child.key != null) {\r\n                    setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`<TransitionGroup> children must be keyed.`);\r\n                }\r\n            }\r\n            if (prevChildren) {\r\n                for (let i = 0; i < prevChildren.length; i++) {\r\n                    const child = prevChildren[i];\r\n                    setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));\r\n                    positionMap.set(child, child.el.getBoundingClientRect());\r\n                }\r\n            }\r\n            return createVNode(tag, null, children);\r\n        };\r\n    }\r\n};\r\nconst TransitionGroup = TransitionGroupImpl;\r\nfunction callPendingCbs(c) {\r\n    const el = c.el;\r\n    if (el._moveCb) {\r\n        el._moveCb();\r\n    }\r\n    if (el._enterCb) {\r\n        el._enterCb();\r\n    }\r\n}\r\nfunction recordPosition(c) {\r\n    newPositionMap.set(c, c.el.getBoundingClientRect());\r\n}\r\nfunction applyTranslation(c) {\r\n    const oldPos = positionMap.get(c);\r\n    const newPos = newPositionMap.get(c);\r\n    const dx = oldPos.left - newPos.left;\r\n    const dy = oldPos.top - newPos.top;\r\n    if (dx || dy) {\r\n        const s = c.el.style;\r\n        s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;\r\n        s.transitionDuration = '0s';\r\n        return c;\r\n    }\r\n}\r\n// this is put in a dedicated function to avoid the line from being treeshaken\r\nfunction forceReflow() {\r\n    return document.body.offsetHeight;\r\n}\r\nfunction hasCSSTransform(el, root, moveClass) {\r\n    // Detect whether an element with the move class applied has\r\n    // CSS transitions. Since the element may be inside an entering\r\n    // transition at this very moment, we make a clone of it and remove\r\n    // all other transition classes applied to ensure only the move class\r\n    // is applied.\r\n    const clone = el.cloneNode();\r\n    if (el._vtc) {\r\n        el._vtc.forEach(cls => {\r\n            cls.split(/\\s+/).forEach(c => c && clone.classList.remove(c));\r\n        });\r\n    }\r\n    moveClass.split(/\\s+/).forEach(c => c && clone.classList.add(c));\r\n    clone.style.display = 'none';\r\n    const container = (root.nodeType === 1\r\n        ? root\r\n        : root.parentNode);\r\n    container.appendChild(clone);\r\n    const { hasTransform } = getTransitionInfo(clone);\r\n    container.removeChild(clone);\r\n    return hasTransform;\r\n}\n\nconst getModelAssigner = (vnode) => {\r\n    const fn = vnode.props['onUpdate:modelValue'];\r\n    return isArray(fn) ? value => invokeArrayFns(fn, value) : fn;\r\n};\r\nfunction onCompositionStart(e) {\r\n    e.target.composing = true;\r\n}\r\nfunction onCompositionEnd(e) {\r\n    const target = e.target;\r\n    if (target.composing) {\r\n        target.composing = false;\r\n        trigger(target, 'input');\r\n    }\r\n}\r\nfunction trigger(el, type) {\r\n    const e = document.createEvent('HTMLEvents');\r\n    e.initEvent(type, true, true);\r\n    el.dispatchEvent(e);\r\n}\r\n// We are exporting the v-model runtime directly as vnode hooks so that it can\r\n// be tree-shaken in case v-model is never used.\r\nconst vModelText = {\r\n    beforeMount(el, { value, modifiers: { lazy, trim, number } }, vnode) {\r\n        el.value = value == null ? '' : value;\r\n        el._assign = getModelAssigner(vnode);\r\n        const castToNumber = number || el.type === 'number';\r\n        addEventListener(el, lazy ? 'change' : 'input', e => {\r\n            if (e.target.composing)\r\n                return;\r\n            let domValue = el.value;\r\n            if (trim) {\r\n                domValue = domValue.trim();\r\n            }\r\n            else if (castToNumber) {\r\n                domValue = toNumber(domValue);\r\n            }\r\n            el._assign(domValue);\r\n        });\r\n        if (trim) {\r\n            addEventListener(el, 'change', () => {\r\n                el.value = el.value.trim();\r\n            });\r\n        }\r\n        if (!lazy) {\r\n            addEventListener(el, 'compositionstart', onCompositionStart);\r\n            addEventListener(el, 'compositionend', onCompositionEnd);\r\n            // Safari < 10.2 & UIWebView doesn't fire compositionend when\r\n            // switching focus before confirming composition choice\r\n            // this also fixes the issue where some browsers e.g. iOS Chrome\r\n            // fires \"change\" instead of \"input\" on autocomplete.\r\n            addEventListener(el, 'change', onCompositionEnd);\r\n        }\r\n    },\r\n    beforeUpdate(el, { value, modifiers: { trim, number } }, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        if (document.activeElement === el) {\r\n            if (trim && el.value.trim() === value) {\r\n                return;\r\n            }\r\n            if ((number || el.type === 'number') && toNumber(el.value) === value) {\r\n                return;\r\n            }\r\n        }\r\n        el.value = value == null ? '' : value;\r\n    }\r\n};\r\nconst vModelCheckbox = {\r\n    beforeMount(el, binding, vnode) {\r\n        setChecked(el, binding, vnode);\r\n        el._assign = getModelAssigner(vnode);\r\n        addEventListener(el, 'change', () => {\r\n            const modelValue = el._modelValue;\r\n            const elementValue = getValue(el);\r\n            const checked = el.checked;\r\n            const assign = el._assign;\r\n            if (isArray(modelValue)) {\r\n                const index = looseIndexOf(modelValue, elementValue);\r\n                const found = index !== -1;\r\n                if (checked && !found) {\r\n                    assign(modelValue.concat(elementValue));\r\n                }\r\n                else if (!checked && found) {\r\n                    const filtered = [...modelValue];\r\n                    filtered.splice(index, 1);\r\n                    assign(filtered);\r\n                }\r\n            }\r\n            else {\r\n                assign(getCheckboxValue(el, checked));\r\n            }\r\n        });\r\n    },\r\n    beforeUpdate(el, binding, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        setChecked(el, binding, vnode);\r\n    }\r\n};\r\nfunction setChecked(el, { value, oldValue }, vnode) {\r\n    el._modelValue = value;\r\n    if (isArray(value)) {\r\n        el.checked = looseIndexOf(value, vnode.props.value) > -1;\r\n    }\r\n    else if (value !== oldValue) {\r\n        el.checked = looseEqual(value, getCheckboxValue(el, true));\r\n    }\r\n}\r\nconst vModelRadio = {\r\n    beforeMount(el, { value }, vnode) {\r\n        el.checked = looseEqual(value, vnode.props.value);\r\n        el._assign = getModelAssigner(vnode);\r\n        addEventListener(el, 'change', () => {\r\n            el._assign(getValue(el));\r\n        });\r\n    },\r\n    beforeUpdate(el, { value, oldValue }, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        if (value !== oldValue) {\r\n            el.checked = looseEqual(value, vnode.props.value);\r\n        }\r\n    }\r\n};\r\nconst vModelSelect = {\r\n    // use mounted & updated because <select> relies on its children <option>s.\r\n    mounted(el, { value }, vnode) {\r\n        setSelected(el, value);\r\n        el._assign = getModelAssigner(vnode);\r\n        addEventListener(el, 'change', () => {\r\n            const selectedVal = Array.prototype.filter\r\n                .call(el.options, (o) => o.selected)\r\n                .map(getValue);\r\n            el._assign(el.multiple ? selectedVal : selectedVal[0]);\r\n        });\r\n    },\r\n    beforeUpdate(el, _binding, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n    },\r\n    updated(el, { value }) {\r\n        setSelected(el, value);\r\n    }\r\n};\r\nfunction setSelected(el, value) {\r\n    const isMultiple = el.multiple;\r\n    if (isMultiple && !isArray(value)) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn(`<select multiple v-model> expects an Array value for its binding, ` +\r\n                `but got ${Object.prototype.toString.call(value).slice(8, -1)}.`);\r\n        return;\r\n    }\r\n    for (let i = 0, l = el.options.length; i < l; i++) {\r\n        const option = el.options[i];\r\n        const optionValue = getValue(option);\r\n        if (isMultiple) {\r\n            option.selected = looseIndexOf(value, optionValue) > -1;\r\n        }\r\n        else {\r\n            if (looseEqual(getValue(option), value)) {\r\n                el.selectedIndex = i;\r\n                return;\r\n            }\r\n        }\r\n    }\r\n    if (!isMultiple) {\r\n        el.selectedIndex = -1;\r\n    }\r\n}\r\n// retrieve raw value set via :value bindings\r\nfunction getValue(el) {\r\n    return '_value' in el ? el._value : el.value;\r\n}\r\n// retrieve raw value for true-value and false-value set via :true-value or :false-value bindings\r\nfunction getCheckboxValue(el, checked) {\r\n    const key = checked ? '_trueValue' : '_falseValue';\r\n    return key in el ? el[key] : checked;\r\n}\r\nconst vModelDynamic = {\r\n    beforeMount(el, binding, vnode) {\r\n        callModelHook(el, binding, vnode, null, 'beforeMount');\r\n    },\r\n    mounted(el, binding, vnode) {\r\n        callModelHook(el, binding, vnode, null, 'mounted');\r\n    },\r\n    beforeUpdate(el, binding, vnode, prevVNode) {\r\n        callModelHook(el, binding, vnode, prevVNode, 'beforeUpdate');\r\n    },\r\n    updated(el, binding, vnode, prevVNode) {\r\n        callModelHook(el, binding, vnode, prevVNode, 'updated');\r\n    }\r\n};\r\nfunction callModelHook(el, binding, vnode, prevVNode, hook) {\r\n    let modelToUse;\r\n    switch (el.tagName) {\r\n        case 'SELECT':\r\n            modelToUse = vModelSelect;\r\n            break;\r\n        case 'TEXTAREA':\r\n            modelToUse = vModelText;\r\n            break;\r\n        default:\r\n            switch (el.type) {\r\n                case 'checkbox':\r\n                    modelToUse = vModelCheckbox;\r\n                    break;\r\n                case 'radio':\r\n                    modelToUse = vModelRadio;\r\n                    break;\r\n                default:\r\n                    modelToUse = vModelText;\r\n            }\r\n    }\r\n    const fn = modelToUse[hook];\r\n    fn && fn(el, binding, vnode, prevVNode);\r\n}\n\nconst systemModifiers = ['ctrl', 'shift', 'alt', 'meta'];\r\nconst modifierGuards = {\r\n    stop: e => e.stopPropagation(),\r\n    prevent: e => e.preventDefault(),\r\n    self: e => e.target !== e.currentTarget,\r\n    ctrl: e => !e.ctrlKey,\r\n    shift: e => !e.shiftKey,\r\n    alt: e => !e.altKey,\r\n    meta: e => !e.metaKey,\r\n    left: e => 'button' in e && e.button !== 0,\r\n    middle: e => 'button' in e && e.button !== 1,\r\n    right: e => 'button' in e && e.button !== 2,\r\n    exact: (e, modifiers) => systemModifiers.some(m => e[`${m}Key`] && !modifiers.includes(m))\r\n};\r\n/**\r\n * @private\r\n */\r\nconst withModifiers = (fn, modifiers) => {\r\n    return (event, ...args) => {\r\n        for (let i = 0; i < modifiers.length; i++) {\r\n            const guard = modifierGuards[modifiers[i]];\r\n            if (guard && guard(event, modifiers))\r\n                return;\r\n        }\r\n        return fn(event, ...args);\r\n    };\r\n};\r\n// Kept for 2.x compat.\r\n// Note: IE11 compat for `spacebar` and `del` is removed for now.\r\nconst keyNames = {\r\n    esc: 'escape',\r\n    space: ' ',\r\n    up: 'arrow-up',\r\n    left: 'arrow-left',\r\n    right: 'arrow-right',\r\n    down: 'arrow-down',\r\n    delete: 'backspace'\r\n};\r\n/**\r\n * @private\r\n */\r\nconst withKeys = (fn, modifiers) => {\r\n    return (event) => {\r\n        if (!('key' in event))\r\n            return;\r\n        const eventKey = hyphenate(event.key);\r\n        if (\r\n        // None of the provided key modifiers match the current event key\r\n        !modifiers.some(k => k === eventKey || keyNames[k] === eventKey)) {\r\n            return;\r\n        }\r\n        return fn(event);\r\n    };\r\n};\n\nconst vShow = {\r\n    beforeMount(el, { value }, { transition }) {\r\n        el._vod = el.style.display === 'none' ? '' : el.style.display;\r\n        if (transition && value) {\r\n            transition.beforeEnter(el);\r\n        }\r\n        else {\r\n            setDisplay(el, value);\r\n        }\r\n    },\r\n    mounted(el, { value }, { transition }) {\r\n        if (transition && value) {\r\n            transition.enter(el);\r\n        }\r\n    },\r\n    updated(el, { value, oldValue }, { transition }) {\r\n        if (!value === !oldValue)\r\n            return;\r\n        if (transition) {\r\n            if (value) {\r\n                transition.beforeEnter(el);\r\n                setDisplay(el, true);\r\n                transition.enter(el);\r\n            }\r\n            else {\r\n                transition.leave(el, () => {\r\n                    setDisplay(el, false);\r\n                });\r\n            }\r\n        }\r\n        else {\r\n            setDisplay(el, value);\r\n        }\r\n    },\r\n    beforeUnmount(el, { value }) {\r\n        setDisplay(el, value);\r\n    }\r\n};\r\nfunction setDisplay(el, value) {\r\n    el.style.display = value ? el._vod : 'none';\r\n}\n\nconst rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps);\r\n// lazy create the renderer - this makes core renderer logic tree-shakable\r\n// in case the user only imports reactivity utilities from Vue.\r\nlet renderer;\r\nlet enabledHydration = false;\r\nfunction ensureRenderer() {\r\n    return renderer || (renderer = createRenderer(rendererOptions));\r\n}\r\nfunction ensureHydrationRenderer() {\r\n    renderer = enabledHydration\r\n        ? renderer\r\n        : createHydrationRenderer(rendererOptions);\r\n    enabledHydration = true;\r\n    return renderer;\r\n}\r\n// use explicit type casts here to avoid import() calls in rolled-up d.ts\r\nconst render = ((...args) => {\r\n    ensureRenderer().render(...args);\r\n});\r\nconst hydrate = ((...args) => {\r\n    ensureHydrationRenderer().hydrate(...args);\r\n});\r\nconst createApp = ((...args) => {\r\n    const app = ensureRenderer().createApp(...args);\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        injectNativeTagCheck(app);\r\n    }\r\n    const { mount } = app;\r\n    app.mount = (containerOrSelector) => {\r\n        const container = normalizeContainer(containerOrSelector);\r\n        if (!container)\r\n            return;\r\n        const component = app._component;\r\n        if (!isFunction(component) && !component.render && !component.template) {\r\n            component.template = container.innerHTML;\r\n        }\r\n        // clear content before mounting\r\n        container.innerHTML = '';\r\n        const proxy = mount(container);\r\n        container.removeAttribute('v-cloak');\r\n        container.setAttribute('data-v-app', '');\r\n        return proxy;\r\n    };\r\n    return app;\r\n});\r\nconst createSSRApp = ((...args) => {\r\n    const app = ensureHydrationRenderer().createApp(...args);\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        injectNativeTagCheck(app);\r\n    }\r\n    const { mount } = app;\r\n    app.mount = (containerOrSelector) => {\r\n        const container = normalizeContainer(containerOrSelector);\r\n        if (container) {\r\n            return mount(container, true);\r\n        }\r\n    };\r\n    return app;\r\n});\r\nfunction injectNativeTagCheck(app) {\r\n    // Inject `isNativeTag`\r\n    // this is used for component name validation (dev only)\r\n    Object.defineProperty(app.config, 'isNativeTag', {\r\n        value: (tag) => isHTMLTag(tag) || isSVGTag(tag),\r\n        writable: false\r\n    });\r\n}\r\nfunction normalizeContainer(container) {\r\n    if (isString(container)) {\r\n        const res = document.querySelector(container);\r\n        if ((process.env.NODE_ENV !== 'production') && !res) {\r\n            warn(`Failed to mount app: mount target selector returned null.`);\r\n        }\r\n        return res;\r\n    }\r\n    return container;\r\n}\n\nexport { Transition, TransitionGroup, createApp, createSSRApp, hydrate, render, useCssModule, useCssVars, vModelCheckbox, vModelDynamic, vModelRadio, vModelSelect, vModelText, vShow, withKeys, withModifiers };\n","/*!\n  * vue-router v4.0.0-beta.2\n  * (c) 2020 Eduardo San Martin Morote\n  * @license MIT\n  */\nimport { getCurrentInstance, warn as warn$1, inject, computed, unref, defineComponent, reactive, h, provide, ref, shallowRef, nextTick } from 'vue';\n\nconst hasSymbol = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\r\nconst PolySymbol = (name) => \r\n// vr = vue router\r\nhasSymbol\r\n    ? Symbol( '[vue-router]: ' + name )\r\n    : ( '[vue-router]: ' ) + name;\r\n// rvlm = Router View Location Matched\r\nconst matchedRouteKey = PolySymbol( 'router view location matched' );\r\n// rvd = Router View Depth\r\nconst viewDepthKey = PolySymbol( 'router view depth' );\r\n// r = router\r\nconst routerKey = PolySymbol( 'router' );\r\n// rt = route location\r\nconst routeLocationKey = PolySymbol( 'route location' );\n\nconst isBrowser = typeof window !== 'undefined';\n\nfunction isESModule(obj) {\r\n    return obj.__esModule || (hasSymbol && obj[Symbol.toStringTag] === 'Module');\r\n}\r\nconst assign = Object.assign;\r\nfunction applyToParams(fn, params) {\r\n    const newParams = {};\r\n    for (const key in params) {\r\n        const value = params[key];\r\n        newParams[key] = Array.isArray(value) ? value.map(fn) : fn(value);\r\n    }\r\n    return newParams;\r\n}\r\nlet noop = () => { };\n\nconst TRAILING_SLASH_RE = /\\/$/;\r\nconst removeTrailingSlash = (path) => path.replace(TRAILING_SLASH_RE, '');\r\n/**\r\n * Transforms an URI into a normalized history location\r\n *\r\n * @param parseQuery\r\n * @param location - URI to normalize\r\n * @param currentLocation - current absolute location. Allows resolving relative\r\n * paths. Must start with `/`. Defaults to `/`\r\n * @returns a normalized history location\r\n */\r\nfunction parseURL(parseQuery, location, currentLocation = '/') {\r\n    let path, query = {}, searchString = '', hash = '';\r\n    // Could use URL and URLSearchParams but IE 11 doesn't support it\r\n    const searchPos = location.indexOf('?');\r\n    const hashPos = location.indexOf('#', searchPos > -1 ? searchPos : 0);\r\n    if (searchPos > -1) {\r\n        path = location.slice(0, searchPos);\r\n        searchString = location.slice(searchPos + 1, hashPos > -1 ? hashPos : location.length);\r\n        query = parseQuery(searchString);\r\n    }\r\n    if (hashPos > -1) {\r\n        path = path || location.slice(0, hashPos);\r\n        // keep the # character\r\n        hash = location.slice(hashPos, location.length);\r\n    }\r\n    // no search and no query\r\n    path = path != null ? path : location;\r\n    // empty path means a relative query or hash `?foo=f`, `#thing`\r\n    if (!path) {\r\n        path = currentLocation + path;\r\n    }\r\n    else if (path[0] !== '/') {\r\n        // relative to current location. Currently we only support simple relative\r\n        // but no `..`, `.`, or complex like `../.././..`. We will always leave the\r\n        // leading slash so we can safely append path\r\n        path = currentLocation.replace(/[^\\/]*$/, '') + path;\r\n    }\r\n    return {\r\n        fullPath: path + (searchString && '?') + searchString + hash,\r\n        path,\r\n        query,\r\n        hash,\r\n    };\r\n}\r\n/**\r\n * Stringifies a URL object\r\n *\r\n * @param stringifyQuery\r\n * @param location\r\n */\r\nfunction stringifyURL(stringifyQuery, location) {\r\n    let query = location.query ? stringifyQuery(location.query) : '';\r\n    return location.path + (query && '?') + query + (location.hash || '');\r\n}\r\n/**\r\n * Strips off the base from the beginning of a location.pathname in a non\r\n * case-sensitive way.\r\n *\r\n * @param pathname - location.pathname\r\n * @param base - base to strip off\r\n */\r\nfunction stripBase(pathname, base) {\r\n    // no base or base is not found at the beginning\r\n    if (!base || pathname.toLowerCase().indexOf(base.toLowerCase()))\r\n        return pathname;\r\n    return pathname.slice(base.length) || '/';\r\n}\r\n/**\r\n * Checks if two RouteLocation are equal. This means that both locations are\r\n * pointing towards the same {@link RouteRecord} and that all `params`, `query`\r\n * parameters and `hash` are the same\r\n *\r\n * @param a first {@link RouteLocation}\r\n * @param b second {@link RouteLocation}\r\n */\r\nfunction isSameRouteLocation(stringifyQuery, a, b) {\r\n    let aLastIndex = a.matched.length - 1;\r\n    let bLastIndex = b.matched.length - 1;\r\n    return (aLastIndex > -1 &&\r\n        aLastIndex === bLastIndex &&\r\n        isSameRouteRecord(a.matched[aLastIndex], b.matched[bLastIndex]) &&\r\n        isSameRouteLocationParams(a.params, b.params) &&\r\n        stringifyQuery(a.query) === stringifyQuery(b.query) &&\r\n        a.hash === b.hash);\r\n}\r\n/**\r\n * Check if two `RouteRecords` are equal. Takes into account aliases: they are\r\n * considered equal to the `RouteRecord` they are aliasing.\r\n *\r\n * @param a first {@link RouteRecord}\r\n * @param b second {@link RouteRecord}\r\n */\r\nfunction isSameRouteRecord(a, b) {\r\n    // since the original record has an undefined value for aliasOf\r\n    // but all aliases point to the original record, this will always compare\r\n    // the original record\r\n    return (a.aliasOf || a) === (b.aliasOf || b);\r\n}\r\nfunction isSameRouteLocationParams(a, b) {\r\n    if (Object.keys(a).length !== Object.keys(b).length)\r\n        return false;\r\n    for (let key in a) {\r\n        if (!isSameRouteLocationParamsValue(a[key], b[key]))\r\n            return false;\r\n    }\r\n    return true;\r\n}\r\nfunction isSameRouteLocationParamsValue(a, b) {\r\n    return Array.isArray(a)\r\n        ? isEquivalentArray(a, b)\r\n        : Array.isArray(b)\r\n            ? isEquivalentArray(b, a)\r\n            : a === b;\r\n}\r\n/**\r\n * Check if two arrays are the same or if an array with one single entry is the\r\n * same as another primitive value. Used to check query and parameters\r\n *\r\n * @param a array of values\r\n * @param b array of values or a single value\r\n */\r\nfunction isEquivalentArray(a, b) {\r\n    return Array.isArray(b)\r\n        ? a.length === b.length && a.every((value, i) => value === b[i])\r\n        : a.length === 1 && a[0] === b;\r\n}\n\nvar NavigationType;\r\n(function (NavigationType) {\r\n    NavigationType[\"pop\"] = \"pop\";\r\n    NavigationType[\"push\"] = \"push\";\r\n})(NavigationType || (NavigationType = {}));\r\nvar NavigationDirection;\r\n(function (NavigationDirection) {\r\n    NavigationDirection[\"back\"] = \"back\";\r\n    NavigationDirection[\"forward\"] = \"forward\";\r\n    NavigationDirection[\"unknown\"] = \"\";\r\n})(NavigationDirection || (NavigationDirection = {}));\r\n/**\r\n * Starting location for Histories\r\n */\r\nconst START = '';\r\n// Generic utils\r\n/**\r\n * Normalizes a base by removing any trailing slash and reading the base tag if\r\n * present.\r\n *\r\n * @param base - base to normalize\r\n */\r\nfunction normalizeBase(base) {\r\n    if (!base) {\r\n        if (isBrowser) {\r\n            // respect <base> tag\r\n            const baseEl = document.querySelector('base');\r\n            base = (baseEl && baseEl.getAttribute('href')) || '/';\r\n            // strip full URL origin\r\n            base = base.replace(/^\\w+:\\/\\/[^\\/]+/, '');\r\n        }\r\n        else {\r\n            base = '/';\r\n        }\r\n    }\r\n    // ensure leading slash when it was removed by the regex above avoid leading\r\n    // slash with hash because the file could be read from the disk like file://\r\n    // and the leading slash would cause problems\r\n    if (base[0] !== '/' && base[0] !== '#')\r\n        base = '/' + base;\r\n    // remove the trailing slash so all other method can just do `base + fullPath`\r\n    // to build an href\r\n    return removeTrailingSlash(base);\r\n}\r\n// remove any character before the hash\r\nconst BEFORE_HASH_RE = /^[^#]+#/;\r\nfunction createHref(base, location) {\r\n    return base.replace(BEFORE_HASH_RE, '#') + location;\r\n}\n\nfunction warn(msg, ...args) {\r\n    console.warn('[Vue Router warn]: ' + msg, ...args);\r\n}\n\nfunction getElementPosition(el, offset) {\r\n    const docRect = document.documentElement.getBoundingClientRect();\r\n    const elRect = el.getBoundingClientRect();\r\n    return {\r\n        behavior: offset.behavior,\r\n        left: elRect.left - docRect.left - (offset.left || 0),\r\n        top: elRect.top - docRect.top - (offset.top || 0),\r\n    };\r\n}\r\nconst computeScrollPosition = () => ({\r\n    left: window.pageXOffset,\r\n    top: window.pageYOffset,\r\n});\r\nfunction scrollToPosition(position) {\r\n    let scrollToOptions;\r\n    if ('el' in position) {\r\n        let positionEl = position.el;\r\n        const isIdSelector = typeof positionEl === 'string' && positionEl.startsWith('#');\r\n        /**\r\n         * `id`s can accept pretty much any characters, including CSS combinators\r\n         * like `>` or `~`. It's still possible to retrieve elements using\r\n         * `document.getElementById('~')` but it needs to be escaped when using\r\n         * `document.querySelector('#\\\\~')` for it to be valid. The only\r\n         * requirements for `id`s are them to be unique on the page and to not be\r\n         * empty (`id=\"\"`). Because of that, when passing an id selector, it should\r\n         * be properly escaped for it to work with `querySelector`. We could check\r\n         * for the id selector to be simple (no CSS combinators `+ >~`) but that\r\n         * would make things inconsistent since they are valid characters for an\r\n         * `id` but would need to be escaped when using `querySelector`, breaking\r\n         * their usage and ending up in no selector returned. Selectors need to be\r\n         * escaped:\r\n         *\r\n         * - `#1-thing` becomes `#\\31 -thing`\r\n         * - `#with~symbols` becomes `#with\\\\~symbols`\r\n         *\r\n         * - More information about  the topic can be found at\r\n         *   https://mathiasbynens.be/notes/html5-id-class.\r\n         * - Practical example: https://mathiasbynens.be/demo/html5-id\r\n         */\r\n        if ( typeof position.el === 'string') {\r\n            if (!isIdSelector || !document.getElementById(position.el.slice(1))) {\r\n                try {\r\n                    let foundEl = document.querySelector(position.el);\r\n                    if (isIdSelector && foundEl) {\r\n                        warn(`The selector \"${position.el}\" should be passed as \"el: document.querySelector('${position.el}')\" because it starts with \"#\".`);\r\n                        // return to avoid other warnings\r\n                        return;\r\n                    }\r\n                }\r\n                catch {\r\n                    warn(`The selector \"${position.el}\" is invalid. If you are using an id selector, make sure to escape it. You can find more information about escaping characters in selectors at https://mathiasbynens.be/notes/css-escapes or use CSS.escape (https://developer.mozilla.org/en-US/docs/Web/API/CSS/escape).`);\r\n                    // return to avoid other warnings\r\n                    return;\r\n                }\r\n            }\r\n        }\r\n        const el = typeof positionEl === 'string'\r\n            ? isIdSelector\r\n                ? document.getElementById(positionEl.slice(1))\r\n                : document.querySelector(positionEl)\r\n            : positionEl;\r\n        if (!el) {\r\n             warn(`Couldn't find element using selector \"${position.el}\"`);\r\n            return;\r\n        }\r\n        scrollToOptions = getElementPosition(el, position);\r\n    }\r\n    else {\r\n        scrollToOptions = position;\r\n    }\r\n    if ('scrollBehavior' in document.documentElement.style)\r\n        window.scrollTo(scrollToOptions);\r\n    else {\r\n        window.scrollTo(scrollToOptions.left != null ? scrollToOptions.left : window.pageXOffset, scrollToOptions.top != null ? scrollToOptions.top : window.pageYOffset);\r\n    }\r\n}\r\nfunction getScrollKey(path, delta) {\r\n    const position = history.state ? history.state.position - delta : -1;\r\n    return position + path;\r\n}\r\nconst scrollPositions = new Map();\r\nfunction saveScrollPosition(key, scrollPosition) {\r\n    scrollPositions.set(key, scrollPosition);\r\n}\r\nfunction getSavedScrollPosition(key) {\r\n    const scroll = scrollPositions.get(key);\r\n    // consume it so it's not used again\r\n    scrollPositions.delete(key);\r\n    return scroll;\r\n}\r\n// TODO: RFC about how to save scroll position\r\n/**\r\n * ScrollBehavior instance used by the router to compute and restore the scroll\r\n * position when navigating.\r\n */\r\n// export interface ScrollHandler<ScrollPositionEntry extends HistoryStateValue, ScrollPosition extends ScrollPositionEntry> {\r\n//   // returns a scroll position that can be saved in history\r\n//   compute(): ScrollPositionEntry\r\n//   // can take an extended ScrollPositionEntry\r\n//   scroll(position: ScrollPosition): void\r\n// }\r\n// export const scrollHandler: ScrollHandler<ScrollPosition> = {\r\n//   compute: computeScroll,\r\n//   scroll: scrollToPosition,\r\n// }\n\nlet createBaseLocation = () => location.protocol + '//' + location.host;\r\n/**\r\n * Creates a normalized history location from a window.location object\r\n * @param location\r\n */\r\nfunction createCurrentLocation(base, location) {\r\n    const { pathname, search, hash } = location;\r\n    // allows hash based url\r\n    const hashPos = base.indexOf('#');\r\n    if (hashPos > -1) {\r\n        // prepend the starting slash to hash so the url starts with /#\r\n        let pathFromHash = hash.slice(1);\r\n        if (pathFromHash[0] !== '/')\r\n            pathFromHash = '/' + pathFromHash;\r\n        return stripBase(pathFromHash, '');\r\n    }\r\n    const path = stripBase(pathname, base);\r\n    return path + search + hash;\r\n}\r\nfunction useHistoryListeners(base, historyState, currentLocation, replace) {\r\n    let listeners = [];\r\n    let teardowns = [];\r\n    // TODO: should it be a stack? a Dict. Check if the popstate listener\r\n    // can trigger twice\r\n    let pauseState = null;\r\n    const popStateHandler = ({ state, }) => {\r\n        const to = createCurrentLocation(base, location);\r\n        const from = currentLocation.value;\r\n        const fromState = historyState.value;\r\n        let delta = 0;\r\n        if (state) {\r\n            currentLocation.value = to;\r\n            historyState.value = state;\r\n            // ignore the popstate and reset the pauseState\r\n            if (pauseState && pauseState === from) {\r\n                pauseState = null;\r\n                return;\r\n            }\r\n            delta = fromState ? state.position - fromState.position : 0;\r\n        }\r\n        else {\r\n            replace(to);\r\n        }\r\n        // console.log({ deltaFromCurrent })\r\n        // Here we could also revert the navigation by calling history.go(-delta)\r\n        // this listener will have to be adapted to not trigger again and to wait for the url\r\n        // to be updated before triggering the listeners. Some kind of validation function would also\r\n        // need to be passed to the listeners so the navigation can be accepted\r\n        // call all listeners\r\n        listeners.forEach(listener => {\r\n            listener(currentLocation.value, from, {\r\n                delta,\r\n                type: NavigationType.pop,\r\n                direction: delta\r\n                    ? delta > 0\r\n                        ? NavigationDirection.forward\r\n                        : NavigationDirection.back\r\n                    : NavigationDirection.unknown,\r\n            });\r\n        });\r\n    };\r\n    function pauseListeners() {\r\n        pauseState = currentLocation.value;\r\n    }\r\n    function listen(callback) {\r\n        // setup the listener and prepare teardown callbacks\r\n        listeners.push(callback);\r\n        const teardown = () => {\r\n            const index = listeners.indexOf(callback);\r\n            if (index > -1)\r\n                listeners.splice(index, 1);\r\n        };\r\n        teardowns.push(teardown);\r\n        return teardown;\r\n    }\r\n    function beforeUnloadListener() {\r\n        const { history } = window;\r\n        if (!history.state)\r\n            return;\r\n        history.replaceState(assign({}, history.state, { scroll: computeScrollPosition() }), '');\r\n    }\r\n    function destroy() {\r\n        for (const teardown of teardowns)\r\n            teardown();\r\n        teardowns = [];\r\n        window.removeEventListener('popstate', popStateHandler);\r\n        window.removeEventListener('beforeunload', beforeUnloadListener);\r\n    }\r\n    // setup the listeners and prepare teardown callbacks\r\n    window.addEventListener('popstate', popStateHandler);\r\n    window.addEventListener('beforeunload', beforeUnloadListener);\r\n    return {\r\n        pauseListeners,\r\n        listen,\r\n        destroy,\r\n    };\r\n}\r\n/**\r\n * Creates a state object\r\n */\r\nfunction buildState(back, current, forward, replaced = false, computeScroll = false) {\r\n    return {\r\n        back,\r\n        current,\r\n        forward,\r\n        replaced,\r\n        position: window.history.length,\r\n        scroll: computeScroll ? computeScrollPosition() : null,\r\n    };\r\n}\r\nfunction useHistoryStateNavigation(base) {\r\n    const { history, location } = window;\r\n    // private variables\r\n    let currentLocation = {\r\n        value: createCurrentLocation(base, location),\r\n    };\r\n    let historyState = { value: history.state };\r\n    // build current history entry as this is a fresh navigation\r\n    if (!historyState.value) {\r\n        changeLocation(currentLocation.value, {\r\n            back: null,\r\n            current: currentLocation.value,\r\n            forward: null,\r\n            // the length is off by one, we need to decrease it\r\n            position: history.length - 1,\r\n            replaced: true,\r\n            // don't add a scroll as the user may have an anchor and we want\r\n            // scrollBehavior to be triggered without a saved position\r\n            scroll: null,\r\n        }, true);\r\n    }\r\n    function changeLocation(to, state, replace) {\r\n        const url = createBaseLocation() +\r\n            // preserve any existing query when base has a hash\r\n            (base.indexOf('#') > -1 && location.search\r\n                ? location.pathname + location.search + '#'\r\n                : base) +\r\n            to;\r\n        try {\r\n            // BROWSER QUIRK\r\n            // NOTE: Safari throws a SecurityError when calling this function 100 times in 30 seconds\r\n            history[replace ? 'replaceState' : 'pushState'](state, '', url);\r\n            historyState.value = state;\r\n        }\r\n        catch (err) {\r\n            warn('Error with push/replace State', err);\r\n            // Force the navigation, this also resets the call count\r\n            location[replace ? 'replace' : 'assign'](url);\r\n        }\r\n    }\r\n    function replace(to, data) {\r\n        const state = assign({}, history.state, buildState(historyState.value.back, \r\n        // keep back and forward entries but override current position\r\n        to, historyState.value.forward, true), data, { position: historyState.value.position });\r\n        changeLocation(to, state, true);\r\n        currentLocation.value = to;\r\n    }\r\n    function push(to, data) {\r\n        // Add to current entry the information of where we are going\r\n        // as well as saving the current position\r\n        const currentState = assign({}, history.state, {\r\n            forward: to,\r\n            scroll: computeScrollPosition(),\r\n        });\r\n        changeLocation(currentState.current, currentState, true);\r\n        const state = assign({}, buildState(currentLocation.value, to, null), {\r\n            position: currentState.position + 1,\r\n        }, data);\r\n        changeLocation(to, state, false);\r\n        currentLocation.value = to;\r\n    }\r\n    return {\r\n        location: currentLocation,\r\n        state: historyState,\r\n        push,\r\n        replace,\r\n    };\r\n}\r\nfunction createWebHistory(base) {\r\n    base = normalizeBase(base);\r\n    const historyNavigation = useHistoryStateNavigation(base);\r\n    const historyListeners = useHistoryListeners(base, historyNavigation.state, historyNavigation.location, historyNavigation.replace);\r\n    function go(delta, triggerListeners = true) {\r\n        if (!triggerListeners)\r\n            historyListeners.pauseListeners();\r\n        history.go(delta);\r\n    }\r\n    const routerHistory = assign({\r\n        // it's overridden right after\r\n        location: '',\r\n        base,\r\n        go,\r\n        createHref: createHref.bind(null, base),\r\n    }, historyNavigation, historyListeners);\r\n    Object.defineProperty(routerHistory, 'location', {\r\n        get: () => historyNavigation.location.value,\r\n    });\r\n    Object.defineProperty(routerHistory, 'state', {\r\n        get: () => historyNavigation.state.value,\r\n    });\r\n    return routerHistory;\r\n}\n\n// TODO: verify base is working for SSR\r\n/**\r\n * Creates a in-memory based history. The main purpose of this history is to handle SSR. It starts in a special location that is nowhere.\r\n * It's up to the user to replace that location with the starter location.\r\n * @param base - Base applied to all urls, defaults to '/'\r\n * @returns a history object that can be passed to the router constructor\r\n */\r\nfunction createMemoryHistory(base = '') {\r\n    let listeners = [];\r\n    let queue = [START];\r\n    let position = 0;\r\n    function setLocation(location) {\r\n        position++;\r\n        if (position === queue.length) {\r\n            // we are at the end, we can simply append a new entry\r\n            queue.push(location);\r\n        }\r\n        else {\r\n            // we are in the middle, we remove everything from here in the queue\r\n            queue.splice(position);\r\n            queue.push(location);\r\n        }\r\n    }\r\n    function triggerListeners(to, from, { direction, delta }) {\r\n        const info = {\r\n            direction,\r\n            delta,\r\n            type: NavigationType.pop,\r\n        };\r\n        for (let callback of listeners) {\r\n            callback(to, from, info);\r\n        }\r\n    }\r\n    const routerHistory = {\r\n        // rewritten by Object.defineProperty\r\n        location: START,\r\n        state: {},\r\n        base,\r\n        createHref: createHref.bind(null, base),\r\n        replace(to) {\r\n            // remove current entry and decrement position\r\n            queue.splice(position--, 1);\r\n            setLocation(to);\r\n        },\r\n        push(to, data) {\r\n            setLocation(to);\r\n        },\r\n        listen(callback) {\r\n            listeners.push(callback);\r\n            return () => {\r\n                const index = listeners.indexOf(callback);\r\n                if (index > -1)\r\n                    listeners.splice(index, 1);\r\n            };\r\n        },\r\n        destroy() {\r\n            listeners = [];\r\n        },\r\n        go(delta, shouldTrigger = true) {\r\n            const from = this.location;\r\n            const direction = \r\n            // we are considering delta === 0 going forward, but in abstract mode\r\n            // using 0 for the delta doesn't make sense like it does in html5 where\r\n            // it reloads the page\r\n            delta < 0 ? NavigationDirection.back : NavigationDirection.forward;\r\n            position = Math.max(0, Math.min(position + delta, queue.length - 1));\r\n            if (shouldTrigger) {\r\n                triggerListeners(this.location, from, {\r\n                    direction,\r\n                    delta,\r\n                });\r\n            }\r\n        },\r\n    };\r\n    Object.defineProperty(routerHistory, 'location', {\r\n        get: () => queue[position],\r\n    });\r\n    return routerHistory;\r\n}\n\n/**\r\n * Creates a hash history.\r\n *\r\n * @param base - optional base to provide. Defaults to `location.pathname` or\r\n * `/` if at root. If there is a `base` tag in the `head`, its value will be\r\n * **ignored**.\r\n *\r\n * @example\r\n * ```js\r\n * // at https://example.com/folder\r\n * createWebHashHistory() // gives a url of `https://example.com/folder#`\r\n * createWebHashHistory('/folder/') // gives a url of `https://example.com/folder/#`\r\n * // if the `#` is provided in the base, it won't be added by `createWebHashHistory`\r\n * createWebHashHistory('/folder/#/app/') // gives a url of `https://example.com/folder/#/app/`\r\n * // you should avoid doing this because it changes the original url and breaks copying urls\r\n * createWebHashHistory('/other-folder/') // gives a url of `https://example.com/other-folder/#`\r\n *\r\n * // at file:///usr/etc/folder/index.html\r\n * // for locations with no `host`, the base is ignored\r\n * createWebHashHistory('/iAmIgnored') // gives a url of `file:///usr/etc/folder/index.html#`\r\n * ```\r\n */\r\nfunction createWebHashHistory(base) {\r\n    // Make sure this implementation is fine in terms of encoding, specially for IE11\r\n    // for `file://`, directly use the pathname and ignore the base\r\n    // location.pathname contains an initial `/` even at the root: `https://example.com`\r\n    base = location.host ? base || location.pathname : location.pathname;\r\n    // allow the user to provide a `#` in the middle: `/base/#/app`\r\n    if (base.indexOf('#') < 0)\r\n        base += '#';\r\n    if ( !base.endsWith('#/') && !base.endsWith('#')) {\r\n        warn(`A hash base must end with a \"#\":\\n\"${base}\" should be \"${base.replace(/#.*$/, '#')}\".`);\r\n    }\r\n    return createWebHistory(base);\r\n}\n\n/**\r\n * Encoding Rules ␣ = Space Path: ␣ \" < > # ? { } Query: ␣ \" < > # & = Hash: ␣ \"\r\n * < > `\r\n *\r\n * On top of that, the RFC3986 (https://tools.ietf.org/html/rfc3986#section-2.2)\r\n * defines some extra characters to be encoded. Most browsers do not encode them\r\n * in encodeURI https://github.com/whatwg/url/issues/369, so it may be safer to\r\n * also encode `!'()*`. Leaving unencoded only ASCII alphanumeric(`a-zA-Z0-9`)\r\n * plus `-._~`. This extra safety should be applied to query by patching the\r\n * string returned by encodeURIComponent encodeURI also encodes `[\\]^`. `\\`\r\n * should be encoded to avoid ambiguity. Browsers (IE, FF, C) transform a `\\`\r\n * into a `/` if directly typed in. The _backtick_ (`````) should also be\r\n * encoded everywhere because some browsers like FF encode it when directly\r\n * written while others don't. Safari and IE don't encode ``\"<>{}``` in hash.\r\n */\r\n// const EXTRA_RESERVED_RE = /[!'()*]/g\r\n// const encodeReservedReplacer = (c: string) => '%' + c.charCodeAt(0).toString(16)\r\nconst HASH_RE = /#/g; // %23\r\nconst AMPERSAND_RE = /&/g; // %26\r\nconst SLASH_RE = /\\//g; // %2F\r\nconst EQUAL_RE = /=/g; // %3D\r\nconst IM_RE = /\\?/g; // %3F\r\nconst ENC_BRACKET_OPEN_RE = /%5B/g; // [\r\nconst ENC_BRACKET_CLOSE_RE = /%5D/g; // ]\r\nconst ENC_CARET_RE = /%5E/g; // ^\r\nconst ENC_BACKTICK_RE = /%60/g; // `\r\nconst ENC_CURLY_OPEN_RE = /%7B/g; // {\r\nconst ENC_PIPE_RE = /%7C/g; // |\r\nconst ENC_CURLY_CLOSE_RE = /%7D/g; // }\r\n/**\r\n * Encode characters that need to be encoded on the path, search and hash\r\n * sections of the URL.\r\n *\r\n * @internal\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction commonEncode(text) {\r\n    return encodeURI('' + text)\r\n        .replace(ENC_PIPE_RE, '|')\r\n        .replace(ENC_BRACKET_OPEN_RE, '[')\r\n        .replace(ENC_BRACKET_CLOSE_RE, ']');\r\n}\r\n/**\r\n * Encode characters that need to be encoded on the hash section of the URL.\r\n *\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction encodeHash(text) {\r\n    return commonEncode(text)\r\n        .replace(ENC_CURLY_OPEN_RE, '{')\r\n        .replace(ENC_CURLY_CLOSE_RE, '}')\r\n        .replace(ENC_CARET_RE, '^');\r\n}\r\n/**\r\n * Encode characters that need to be encoded query keys and values on the query\r\n * section of the URL.\r\n *\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction encodeQueryProperty(text) {\r\n    return commonEncode(text)\r\n        .replace(HASH_RE, '%23')\r\n        .replace(AMPERSAND_RE, '%26')\r\n        .replace(EQUAL_RE, '%3D')\r\n        .replace(ENC_BACKTICK_RE, '`')\r\n        .replace(ENC_CURLY_OPEN_RE, '{')\r\n        .replace(ENC_CURLY_CLOSE_RE, '}')\r\n        .replace(ENC_CARET_RE, '^');\r\n}\r\n/**\r\n * Encode characters that need to be encoded on the path section of the URL.\r\n *\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction encodePath(text) {\r\n    return commonEncode(text).replace(HASH_RE, '%23').replace(IM_RE, '%3F');\r\n}\r\n/**\r\n * Encode characters that need to be encoded on the path section of the URL as a\r\n * param. This function encodes everything {@link encodePath} does plus the\r\n * slash (`/`) character.\r\n *\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction encodeParam(text) {\r\n    return encodePath(text).replace(SLASH_RE, '%2F');\r\n}\r\n/**\r\n * Decode text using `decodeURIComponent`. Returns the original text if it\r\n * fails.\r\n *\r\n * @param text - string to decode\r\n * @returns decoded string\r\n */\r\nfunction decode(text) {\r\n    try {\r\n        return decodeURIComponent('' + text);\r\n    }\r\n    catch (err) {\r\n         warn(`Error decoding \"${text}\". Using original value`);\r\n    }\r\n    return '' + text;\r\n}\n\n/**\r\n * Transforms a queryString into a {@link LocationQuery} object. Accept both, a\r\n * version with the leading `?` and without Should work as URLSearchParams\r\n *\r\n * @param search - search string to parse\r\n * @returns a query object\r\n */\r\nfunction parseQuery(search) {\r\n    const query = {};\r\n    // avoid creating an object with an empty key and empty value\r\n    // because of split('&')\r\n    if (search === '' || search === '?')\r\n        return query;\r\n    const hasLeadingIM = search[0] === '?';\r\n    const searchParams = (hasLeadingIM ? search.slice(1) : search).split('&');\r\n    for (let i = 0; i < searchParams.length; ++i) {\r\n        let [key, rawValue] = searchParams[i].split('=');\r\n        key = decode(key);\r\n        // avoid decoding null\r\n        let value = rawValue == null ? null : decode(rawValue);\r\n        if (key in query) {\r\n            // an extra variable for ts types\r\n            let currentValue = query[key];\r\n            if (!Array.isArray(currentValue)) {\r\n                currentValue = query[key] = [currentValue];\r\n            }\r\n            currentValue.push(value);\r\n        }\r\n        else {\r\n            query[key] = value;\r\n        }\r\n    }\r\n    return query;\r\n}\r\n/**\r\n * Stringifies a {@link LocationQueryRaw} object. Like `URLSearchParams`, it\r\n * doesn't prepend a `?`\r\n *\r\n * @param query - query object to stringify\r\n * @returns string version of the query without the leading `?`\r\n */\r\nfunction stringifyQuery(query) {\r\n    let search = '';\r\n    for (let key in query) {\r\n        if (search.length)\r\n            search += '&';\r\n        const value = query[key];\r\n        key = encodeQueryProperty(key);\r\n        if (value == null) {\r\n            // only null adds the value\r\n            if (value !== undefined)\r\n                search += key;\r\n            continue;\r\n        }\r\n        // keep null values\r\n        let values = Array.isArray(value)\r\n            ? value.map(v => v && encodeQueryProperty(v))\r\n            : [value && encodeQueryProperty(value)];\r\n        for (let i = 0; i < values.length; i++) {\r\n            // only append & with i > 0\r\n            search += (i ? '&' : '') + key;\r\n            if (values[i] != null)\r\n                search += ('=' + values[i]);\r\n        }\r\n    }\r\n    return search;\r\n}\r\n/**\r\n * Transforms a {@link LocationQueryRaw} into a {@link LocationQuery} by casting\r\n * numbers into strings, removing keys with an undefined value and replacing\r\n * undefined with null in arrays\r\n *\r\n * @param query - query object to normalize\r\n * @returns a normalized query object\r\n */\r\nfunction normalizeQuery(query) {\r\n    const normalizedQuery = {};\r\n    for (let key in query) {\r\n        let value = query[key];\r\n        if (value !== undefined) {\r\n            normalizedQuery[key] = Array.isArray(value)\r\n                ? value.map(v => (v == null ? null : '' + v))\r\n                : value == null\r\n                    ? value\r\n                    : '' + value;\r\n        }\r\n    }\r\n    return normalizedQuery;\r\n}\n\nfunction isRouteLocation(route) {\r\n    return typeof route === 'string' || (route && typeof route === 'object');\r\n}\r\nfunction isRouteName(name) {\r\n    return typeof name === 'string' || typeof name === 'symbol';\r\n}\n\nconst START_LOCATION_NORMALIZED = {\r\n    path: '/',\r\n    name: undefined,\r\n    params: {},\r\n    query: {},\r\n    hash: '',\r\n    fullPath: '/',\r\n    matched: [],\r\n    meta: {},\r\n    redirectedFrom: undefined,\r\n};\n\nconst NavigationFailureSymbol = PolySymbol( 'navigation failure' );\r\nvar NavigationFailureType;\r\n(function (NavigationFailureType) {\r\n    NavigationFailureType[NavigationFailureType[\"aborted\"] = 4] = \"aborted\";\r\n    NavigationFailureType[NavigationFailureType[\"cancelled\"] = 8] = \"cancelled\";\r\n    NavigationFailureType[NavigationFailureType[\"duplicated\"] = 16] = \"duplicated\";\r\n})(NavigationFailureType || (NavigationFailureType = {}));\r\n// DEV only debug messages\r\nconst ErrorTypeMessages = {\r\n    [1 /* MATCHER_NOT_FOUND */]({ location, currentLocation }) {\r\n        return `No match for\\n ${JSON.stringify(location)}${currentLocation\r\n            ? '\\nwhile being at\\n' + JSON.stringify(currentLocation)\r\n            : ''}`;\r\n    },\r\n    [2 /* NAVIGATION_GUARD_REDIRECT */]({ from, to, }) {\r\n        return `Redirected from \"${from.fullPath}\" to \"${stringifyRoute(to)}\" via a navigation guard.`;\r\n    },\r\n    [4 /* NAVIGATION_ABORTED */]({ from, to }) {\r\n        return `Navigation aborted from \"${from.fullPath}\" to \"${to.fullPath}\" via a navigation guard.`;\r\n    },\r\n    [8 /* NAVIGATION_CANCELLED */]({ from, to }) {\r\n        return `Navigation cancelled from \"${from.fullPath}\" to \"${to.fullPath}\" with a new navigation.`;\r\n    },\r\n    [16 /* NAVIGATION_DUPLICATED */]({ from, to }) {\r\n        return `Avoided redundant navigation to current location: \"${from.fullPath}\".`;\r\n    },\r\n};\r\nfunction createRouterError(type, params) {\r\n    {\r\n        return assign(new Error(ErrorTypeMessages[type](params)), {\r\n            type,\r\n            [NavigationFailureSymbol]: true,\r\n        }, params);\r\n    }\r\n}\r\nfunction isNavigationFailure(error, type) {\r\n    return (error instanceof Error &&\r\n        NavigationFailureSymbol in error &&\r\n        (type == null || !!(error.type & type)));\r\n}\r\nconst propertiesToLog = ['params', 'query', 'hash'];\r\nfunction stringifyRoute(to) {\r\n    if (typeof to === 'string')\r\n        return to;\r\n    if ('path' in to)\r\n        return to.path;\r\n    const location = {};\r\n    for (const key of propertiesToLog) {\r\n        if (key in to)\r\n            location[key] = to[key];\r\n    }\r\n    return JSON.stringify(location, null, 2);\r\n}\n\n// default pattern for a param: non greedy everything but /\r\nconst BASE_PARAM_PATTERN = '[^/]+?';\r\nconst BASE_PATH_PARSER_OPTIONS = {\r\n    sensitive: false,\r\n    strict: false,\r\n    start: true,\r\n    end: true,\r\n};\r\n// Special Regex characters that must be escaped in static tokens\r\nconst REGEX_CHARS_RE = /[.+*?^${}()[\\]/\\\\]/g;\r\n/**\r\n * Creates a path parser from an array of Segments (a segment is an array of Tokens)\r\n *\r\n * @param segments - array of segments returned by tokenizePath\r\n * @param extraOptions - optional options for the regexp\r\n * @returns a PathParser\r\n */\r\nfunction tokensToParser(segments, extraOptions) {\r\n    const options = assign({}, BASE_PATH_PARSER_OPTIONS, extraOptions);\r\n    // the amount of scores is the same as the length of segments except for the root segment \"/\"\r\n    let score = [];\r\n    // the regexp as a string\r\n    let pattern = options.start ? '^' : '';\r\n    // extracted keys\r\n    const keys = [];\r\n    for (const segment of segments) {\r\n        // the root segment needs special treatment\r\n        const segmentScores = segment.length ? [] : [90 /* Root */];\r\n        // allow trailing slash\r\n        if (options.strict && !segment.length)\r\n            pattern += '/';\r\n        for (let tokenIndex = 0; tokenIndex < segment.length; tokenIndex++) {\r\n            const token = segment[tokenIndex];\r\n            // resets the score if we are inside a sub segment /:a-other-:b\r\n            let subSegmentScore = 40 /* Segment */ +\r\n                (options.sensitive ? 0.25 /* BonusCaseSensitive */ : 0);\r\n            if (token.type === 0 /* Static */) {\r\n                // prepend the slash if we are starting a new segment\r\n                if (!tokenIndex)\r\n                    pattern += '/';\r\n                pattern += token.value.replace(REGEX_CHARS_RE, '\\\\$&');\r\n                subSegmentScore += 40 /* Static */;\r\n            }\r\n            else if (token.type === 1 /* Param */) {\r\n                const { value, repeatable, optional, regexp } = token;\r\n                keys.push({\r\n                    name: value,\r\n                    repeatable,\r\n                    optional,\r\n                });\r\n                const re = regexp ? regexp : BASE_PARAM_PATTERN;\r\n                // the user provided a custom regexp /:id(\\\\d+)\r\n                if (re !== BASE_PARAM_PATTERN) {\r\n                    subSegmentScore += 10 /* BonusCustomRegExp */;\r\n                    // make sure the regexp is valid before using it\r\n                    try {\r\n                        new RegExp(`(${re})`);\r\n                    }\r\n                    catch (err) {\r\n                        throw new Error(`Invalid custom RegExp for param \"${value}\" (${re}): ` +\r\n                            err.message);\r\n                    }\r\n                }\r\n                // when we repeat we must take care of the repeating leading slash\r\n                let subPattern = repeatable ? `((?:${re})(?:/(?:${re}))*)` : `(${re})`;\r\n                // prepend the slash if we are starting a new segment\r\n                if (!tokenIndex)\r\n                    subPattern = optional ? `(?:/${subPattern})` : '/' + subPattern;\r\n                if (optional)\r\n                    subPattern += '?';\r\n                pattern += subPattern;\r\n                subSegmentScore += 20 /* Dynamic */;\r\n                if (optional)\r\n                    subSegmentScore += -8 /* BonusOptional */;\r\n                if (repeatable)\r\n                    subSegmentScore += -20 /* BonusRepeatable */;\r\n                if (re === '.*')\r\n                    subSegmentScore += -50 /* BonusWildcard */;\r\n            }\r\n            segmentScores.push(subSegmentScore);\r\n        }\r\n        // an empty array like /home/ -> [[{home}], []]\r\n        // if (!segment.length) pattern += '/'\r\n        score.push(segmentScores);\r\n    }\r\n    // only apply the strict bonus to the last score\r\n    if (options.strict && options.end) {\r\n        const i = score.length - 1;\r\n        score[i][score[i].length - 1] += 0.7000000000000001 /* BonusStrict */;\r\n    }\r\n    // TODO: dev only warn double trailing slash\r\n    if (!options.strict)\r\n        pattern += '/?';\r\n    if (options.end)\r\n        pattern += '$';\r\n    // allow paths like /dynamic to only match dynamic or dynamic/... but not dynamic_something_else\r\n    else if (options.strict)\r\n        pattern += '(?:/|$)';\r\n    const re = new RegExp(pattern, options.sensitive ? '' : 'i');\r\n    function parse(path) {\r\n        const match = path.match(re);\r\n        const params = {};\r\n        if (!match)\r\n            return null;\r\n        for (let i = 1; i < match.length; i++) {\r\n            const value = match[i] || '';\r\n            const key = keys[i - 1];\r\n            params[key.name] = value && key.repeatable ? value.split('/') : value;\r\n        }\r\n        return params;\r\n    }\r\n    function stringify(params) {\r\n        let path = '';\r\n        // for optional parameters to allow to be empty\r\n        let avoidDuplicatedSlash = false;\r\n        for (const segment of segments) {\r\n            if (!avoidDuplicatedSlash || path[path.length - 1] !== '/')\r\n                path += '/';\r\n            avoidDuplicatedSlash = false;\r\n            for (const token of segment) {\r\n                if (token.type === 0 /* Static */) {\r\n                    path += token.value;\r\n                }\r\n                else if (token.type === 1 /* Param */) {\r\n                    const { value, repeatable, optional } = token;\r\n                    const param = value in params ? params[value] : '';\r\n                    if (Array.isArray(param) && !repeatable)\r\n                        throw new Error(`Provided param \"${value}\" is an array but it is not repeatable (* or + modifiers)`);\r\n                    const text = Array.isArray(param) ? param.join('/') : param;\r\n                    if (!text) {\r\n                        // do not append a slash on the next iteration\r\n                        if (optional)\r\n                            avoidDuplicatedSlash = true;\r\n                        else\r\n                            throw new Error(`Missing required param \"${value}\"`);\r\n                    }\r\n                    path += text;\r\n                }\r\n            }\r\n        }\r\n        return path;\r\n    }\r\n    return {\r\n        re,\r\n        score,\r\n        keys,\r\n        parse,\r\n        stringify,\r\n    };\r\n}\r\n/**\r\n * Compares an array of numbers as used in PathParser.score and returns a\r\n * number. This function can be used to `sort` an array\r\n * @param a - first array of numbers\r\n * @param b - second array of numbers\r\n * @returns 0 if both are equal, < 0 if a should be sorted first, > 0 if b\r\n * should be sorted first\r\n */\r\nfunction compareScoreArray(a, b) {\r\n    let i = 0;\r\n    while (i < a.length && i < b.length) {\r\n        const diff = b[i] - a[i];\r\n        // only keep going if diff === 0\r\n        if (diff)\r\n            return diff;\r\n        i++;\r\n    }\r\n    // if the last subsegment was Static, the shorter segments should be sorted first\r\n    // otherwise sort the longest segment first\r\n    if (a.length < b.length) {\r\n        return a.length === 1 && a[0] === 40 /* Static */ + 40 /* Segment */\r\n            ? -1\r\n            : 1;\r\n    }\r\n    else if (a.length > b.length) {\r\n        return b.length === 1 && b[0] === 40 /* Static */ + 40 /* Segment */\r\n            ? 1\r\n            : -1;\r\n    }\r\n    return 0;\r\n}\r\n/**\r\n * Compare function that can be used with `sort` to sort an array of PathParser\r\n * @param a - first PathParser\r\n * @param b - second PathParser\r\n * @returns 0 if both are equal, < 0 if a should be sorted first, > 0 if b\r\n */\r\nfunction comparePathParserScore(a, b) {\r\n    let i = 0;\r\n    const aScore = a.score;\r\n    const bScore = b.score;\r\n    while (i < aScore.length && i < bScore.length) {\r\n        const comp = compareScoreArray(aScore[i], bScore[i]);\r\n        // do not return if both are equal\r\n        if (comp)\r\n            return comp;\r\n        i++;\r\n    }\r\n    // if a and b share the same score entries but b has more, sort b first\r\n    return bScore.length - aScore.length;\r\n    // this is the ternary version\r\n    // return aScore.length < bScore.length\r\n    //   ? 1\r\n    //   : aScore.length > bScore.length\r\n    //   ? -1\r\n    //   : 0\r\n}\n\nconst ROOT_TOKEN = {\r\n    type: 0 /* Static */,\r\n    value: '',\r\n};\r\nconst VALID_PARAM_RE = /[a-zA-Z0-9_]/;\r\n// After some profiling, the cache seems to be unnecessary because tokenizePath\r\n// (the slowest part of adding a route) is very fast\r\n// const tokenCache = new Map<string, Token[][]>()\r\nfunction tokenizePath(path) {\r\n    if (!path)\r\n        return [[]];\r\n    if (path === '/')\r\n        return [[ROOT_TOKEN]];\r\n    // remove the leading slash\r\n    if (path[0] !== '/')\r\n        throw new Error('A non-empty path must start with \"/\"');\r\n    // if (tokenCache.has(path)) return tokenCache.get(path)!\r\n    function crash(message) {\r\n        throw new Error(`ERR (${state})/\"${buffer}\": ${message}`);\r\n    }\r\n    let state = 0 /* Static */;\r\n    let previousState = state;\r\n    const tokens = [];\r\n    // the segment will always be valid because we get into the initial state\r\n    // with the leading /\r\n    let segment;\r\n    function finalizeSegment() {\r\n        if (segment)\r\n            tokens.push(segment);\r\n        segment = [];\r\n    }\r\n    // index on the path\r\n    let i = 0;\r\n    // char at index\r\n    let char;\r\n    // buffer of the value read\r\n    let buffer = '';\r\n    // custom regexp for a param\r\n    let customRe = '';\r\n    function consumeBuffer() {\r\n        if (!buffer)\r\n            return;\r\n        if (state === 0 /* Static */) {\r\n            segment.push({\r\n                type: 0 /* Static */,\r\n                value: buffer,\r\n            });\r\n        }\r\n        else if (state === 1 /* Param */ ||\r\n            state === 2 /* ParamRegExp */ ||\r\n            state === 3 /* ParamRegExpEnd */) {\r\n            if (segment.length > 1 && (char === '*' || char === '+'))\r\n                crash(`A repeatable param (${buffer}) must be alone in its segment. eg: '/:ids+.`);\r\n            segment.push({\r\n                type: 1 /* Param */,\r\n                value: buffer,\r\n                regexp: customRe,\r\n                repeatable: char === '*' || char === '+',\r\n                optional: char === '*' || char === '?',\r\n            });\r\n        }\r\n        else {\r\n            crash('Invalid state to consume buffer');\r\n        }\r\n        buffer = '';\r\n    }\r\n    function addCharToBuffer() {\r\n        buffer += char;\r\n    }\r\n    while (i < path.length) {\r\n        char = path[i++];\r\n        if (char === '\\\\' && state !== 2 /* ParamRegExp */) {\r\n            previousState = state;\r\n            state = 4 /* EscapeNext */;\r\n            continue;\r\n        }\r\n        switch (state) {\r\n            case 0 /* Static */:\r\n                if (char === '/') {\r\n                    if (buffer) {\r\n                        consumeBuffer();\r\n                    }\r\n                    finalizeSegment();\r\n                }\r\n                else if (char === ':') {\r\n                    consumeBuffer();\r\n                    state = 1 /* Param */;\r\n                }\r\n                else {\r\n                    addCharToBuffer();\r\n                }\r\n                break;\r\n            case 4 /* EscapeNext */:\r\n                addCharToBuffer();\r\n                state = previousState;\r\n                break;\r\n            case 1 /* Param */:\r\n                if (char === '(') {\r\n                    state = 2 /* ParamRegExp */;\r\n                    customRe = '';\r\n                }\r\n                else if (VALID_PARAM_RE.test(char)) {\r\n                    addCharToBuffer();\r\n                }\r\n                else {\r\n                    consumeBuffer();\r\n                    state = 0 /* Static */;\r\n                    // go back one character if we were not modifying\r\n                    if (char !== '*' && char !== '?' && char !== '+')\r\n                        i--;\r\n                }\r\n                break;\r\n            case 2 /* ParamRegExp */:\r\n                if (char === ')') {\r\n                    // handle the escaped )\r\n                    if (customRe[customRe.length - 1] == '\\\\')\r\n                        customRe = customRe.slice(0, -1) + char;\r\n                    else\r\n                        state = 3 /* ParamRegExpEnd */;\r\n                }\r\n                else {\r\n                    customRe += char;\r\n                }\r\n                break;\r\n            case 3 /* ParamRegExpEnd */:\r\n                // same as finalizing a param\r\n                consumeBuffer();\r\n                state = 0 /* Static */;\r\n                // go back one character if we were not modifying\r\n                if (char !== '*' && char !== '?' && char !== '+')\r\n                    i--;\r\n                break;\r\n            default:\r\n                crash('Unknown state');\r\n                break;\r\n        }\r\n    }\r\n    if (state === 2 /* ParamRegExp */)\r\n        crash(`Unfinished custom RegExp for param \"${buffer}\"`);\r\n    consumeBuffer();\r\n    finalizeSegment();\r\n    // tokenCache.set(path, tokens)\r\n    return tokens;\r\n}\n\nfunction createRouteRecordMatcher(record, parent, options) {\r\n    const parser = tokensToParser(tokenizePath(record.path), options);\r\n    // warn against params with the same name\r\n    {\r\n        const existingKeys = new Set();\r\n        for (const key of parser.keys) {\r\n            if (existingKeys.has(key.name))\r\n                warn(`Found duplicated params with name \"${key.name}\" for path \"${record.path}\". Only the last one will be available on \"$route.params\".`);\r\n            existingKeys.add(key.name);\r\n        }\r\n    }\r\n    const matcher = assign(parser, {\r\n        record,\r\n        parent,\r\n        // these needs to be populated by the parent\r\n        children: [],\r\n        alias: [],\r\n    });\r\n    if (parent) {\r\n        // both are aliases or both are not aliases\r\n        // we don't want to mix them because the order is used when\r\n        // passing originalRecord in Matcher.addRoute\r\n        if (!matcher.record.aliasOf === !parent.record.aliasOf)\r\n            parent.children.push(matcher);\r\n    }\r\n    return matcher;\r\n}\n\nfunction createRouterMatcher(routes, globalOptions) {\r\n    // normalized ordered array of matchers\r\n    const matchers = [];\r\n    const matcherMap = new Map();\r\n    globalOptions = mergeOptions({ strict: false, end: true, sensitive: false }, globalOptions);\r\n    function getRecordMatcher(name) {\r\n        return matcherMap.get(name);\r\n    }\r\n    function addRoute(record, parent, originalRecord) {\r\n        // used later on to remove by name\r\n        let isRootAdd = !originalRecord;\r\n        let mainNormalizedRecord = normalizeRouteRecord(record);\r\n        // we might be the child of an alias\r\n        mainNormalizedRecord.aliasOf = originalRecord && originalRecord.record;\r\n        const options = mergeOptions(globalOptions, record);\r\n        // generate an array of records to correctly handle aliases\r\n        const normalizedRecords = [\r\n            mainNormalizedRecord,\r\n        ];\r\n        if ('alias' in record) {\r\n            const aliases = typeof record.alias === 'string' ? [record.alias] : record.alias;\r\n            for (const alias of aliases) {\r\n                normalizedRecords.push(assign({}, mainNormalizedRecord, {\r\n                    // this allows us to hold a copy of the `components` option\r\n                    // so that async components cache is hold on the original record\r\n                    components: originalRecord\r\n                        ? originalRecord.record.components\r\n                        : mainNormalizedRecord.components,\r\n                    path: alias,\r\n                    // we might be the child of an alias\r\n                    aliasOf: originalRecord\r\n                        ? originalRecord.record\r\n                        : mainNormalizedRecord,\r\n                }));\r\n            }\r\n        }\r\n        let matcher;\r\n        let originalMatcher;\r\n        for (const normalizedRecord of normalizedRecords) {\r\n            let { path } = normalizedRecord;\r\n            // Build up the path for nested routes if the child isn't an absolute\r\n            // route. Only add the / delimiter if the child path isn't empty and if the\r\n            // parent path doesn't have a trailing slash\r\n            if (parent && path[0] !== '/') {\r\n                let parentPath = parent.record.path;\r\n                let connectingSlash = parentPath[parentPath.length - 1] === '/' ? '' : '/';\r\n                normalizedRecord.path =\r\n                    parent.record.path + (path && connectingSlash + path);\r\n            }\r\n            // create the object before hand so it can be passed to children\r\n            matcher = createRouteRecordMatcher(normalizedRecord, parent, options);\r\n            if ( parent && path[0] === '/')\r\n                checkMissingParamsInAbsolutePath(matcher, parent);\r\n            // if we are an alias we must tell the original record that we exist\r\n            // so we can be removed\r\n            if (originalRecord) {\r\n                originalRecord.alias.push(matcher);\r\n                {\r\n                    checkSameParams(originalRecord, matcher);\r\n                }\r\n            }\r\n            else {\r\n                // otherwise, the first record is the original and others are aliases\r\n                originalMatcher = originalMatcher || matcher;\r\n                if (originalMatcher !== matcher)\r\n                    originalMatcher.alias.push(matcher);\r\n                // remove the route if named and only for the top record (avoid in nested calls)\r\n                // this works because the original record is the first one\r\n                if (isRootAdd && record.name && !isAliasRecord(matcher))\r\n                    removeRoute(record.name);\r\n            }\r\n            if ('children' in mainNormalizedRecord) {\r\n                let children = mainNormalizedRecord.children;\r\n                for (let i = 0; i < children.length; i++) {\r\n                    addRoute(children[i], matcher, originalRecord && originalRecord.children[i]);\r\n                }\r\n            }\r\n            // if there was no original record, then the first one was not an alias and all\r\n            // other alias (if any) need to reference this record when adding children\r\n            originalRecord = originalRecord || matcher;\r\n            insertMatcher(matcher);\r\n        }\r\n        return originalMatcher\r\n            ? () => {\r\n                // since other matchers are aliases, they should be removed by the original matcher\r\n                removeRoute(originalMatcher);\r\n            }\r\n            : noop;\r\n    }\r\n    function removeRoute(matcherRef) {\r\n        if (isRouteName(matcherRef)) {\r\n            const matcher = matcherMap.get(matcherRef);\r\n            if (matcher) {\r\n                matcherMap.delete(matcherRef);\r\n                matchers.splice(matchers.indexOf(matcher), 1);\r\n                matcher.children.forEach(removeRoute);\r\n                matcher.alias.forEach(removeRoute);\r\n            }\r\n        }\r\n        else {\r\n            let index = matchers.indexOf(matcherRef);\r\n            if (index > -1) {\r\n                matchers.splice(index, 1);\r\n                if (matcherRef.record.name)\r\n                    matcherMap.delete(matcherRef.record.name);\r\n                matcherRef.children.forEach(removeRoute);\r\n                matcherRef.alias.forEach(removeRoute);\r\n            }\r\n        }\r\n    }\r\n    function getRoutes() {\r\n        return matchers;\r\n    }\r\n    function insertMatcher(matcher) {\r\n        let i = 0;\r\n        // console.log('i is', { i })\r\n        while (i < matchers.length &&\r\n            comparePathParserScore(matcher, matchers[i]) >= 0)\r\n            i++;\r\n        // console.log('END i is', { i })\r\n        // while (i < matchers.length && matcher.score <= matchers[i].score) i++\r\n        matchers.splice(i, 0, matcher);\r\n        // only add the original record to the name map\r\n        if (matcher.record.name && !isAliasRecord(matcher))\r\n            matcherMap.set(matcher.record.name, matcher);\r\n    }\r\n    /**\r\n     * Resolves a location. Gives access to the route record that corresponds to the actual path as well as filling the corresponding params objects\r\n     *\r\n     * @param location - MatcherLocationRaw to resolve to a url\r\n     * @param currentLocation - MatcherLocation of the current location\r\n     */\r\n    function resolve(location, currentLocation) {\r\n        let matcher;\r\n        let params = {};\r\n        let path;\r\n        let name;\r\n        if ('name' in location && location.name) {\r\n            matcher = matcherMap.get(location.name);\r\n            if (!matcher)\r\n                throw createRouterError(1 /* MATCHER_NOT_FOUND */, {\r\n                    location,\r\n                });\r\n            name = matcher.record.name;\r\n            params = assign(\r\n            // paramsFromLocation is a new object\r\n            paramsFromLocation(currentLocation.params, matcher.keys.map(k => k.name)), location.params);\r\n            // throws if cannot be stringified\r\n            path = matcher.stringify(params);\r\n        }\r\n        else if ('path' in location) {\r\n            // no need to resolve the path with the matcher as it was provided\r\n            // this also allows the user to control the encoding\r\n            path = location.path;\r\n            if ( path[0] !== '/') {\r\n                warn(`The Matcher cannot resolve relative paths but received \"${path}\". Unless you directly called \\`matcher.resolve(\"${path}\")\\`, this is probably a bug in vue-router. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-router-next.`);\r\n            }\r\n            matcher = matchers.find(m => m.re.test(path));\r\n            // matcher should have a value after the loop\r\n            if (matcher) {\r\n                // TODO: dev warning of unused params if provided\r\n                params = matcher.parse(path);\r\n                name = matcher.record.name;\r\n            }\r\n            // location is a relative path\r\n        }\r\n        else {\r\n            // match by name or path of current route\r\n            matcher = currentLocation.name\r\n                ? matcherMap.get(currentLocation.name)\r\n                : matchers.find(m => m.re.test(currentLocation.path));\r\n            if (!matcher)\r\n                throw createRouterError(1 /* MATCHER_NOT_FOUND */, {\r\n                    location,\r\n                    currentLocation,\r\n                });\r\n            name = matcher.record.name;\r\n            // since we are navigating to the same location, we don't need to pick the\r\n            // params like when `name` is provided\r\n            params = assign({}, currentLocation.params, location.params);\r\n            path = matcher.stringify(params);\r\n        }\r\n        const matched = [];\r\n        let parentMatcher = matcher;\r\n        while (parentMatcher) {\r\n            // reversed order so parents are at the beginning\r\n            matched.unshift(parentMatcher.record);\r\n            parentMatcher = parentMatcher.parent;\r\n        }\r\n        return {\r\n            name,\r\n            path,\r\n            params,\r\n            matched,\r\n            meta: mergeMetaFields(matched),\r\n        };\r\n    }\r\n    // add initial routes\r\n    routes.forEach(route => addRoute(route));\r\n    return { addRoute, resolve, removeRoute, getRoutes, getRecordMatcher };\r\n}\r\nfunction paramsFromLocation(params, keys) {\r\n    let newParams = {};\r\n    for (let key of keys) {\r\n        if (key in params)\r\n            newParams[key] = params[key];\r\n    }\r\n    return newParams;\r\n}\r\n/**\r\n * Normalizes a RouteRecordRaw. Creates a copy\r\n *\r\n * @param record\r\n * @returns the normalized version\r\n */\r\nfunction normalizeRouteRecord(record) {\r\n    return {\r\n        path: record.path,\r\n        redirect: record.redirect,\r\n        name: record.name,\r\n        meta: record.meta || {},\r\n        aliasOf: undefined,\r\n        beforeEnter: record.beforeEnter,\r\n        props: normalizeRecordProps(record),\r\n        children: record.children || [],\r\n        instances: {},\r\n        leaveGuards: [],\r\n        updateGuards: [],\r\n        enterCallbacks: {},\r\n        components: 'components' in record\r\n            ? record.components || {}\r\n            : { default: record.component },\r\n    };\r\n}\r\n/**\r\n * Normalize the optional `props` in a record to always be an object similar to\r\n * components. Also accept a boolean for components.\r\n * @param record\r\n */\r\nfunction normalizeRecordProps(record) {\r\n    const propsObject = {};\r\n    // props does not exist on redirect records but we can set false directly\r\n    const props = record.props || false;\r\n    if ('component' in record) {\r\n        propsObject.default = props;\r\n    }\r\n    else {\r\n        // NOTE: we could also allow a function to be applied to every component.\r\n        // Would need user feedback for use cases\r\n        for (let name in record.components)\r\n            propsObject[name] = typeof props === 'boolean' ? props : props[name];\r\n    }\r\n    return propsObject;\r\n}\r\n/**\r\n * Checks if a record or any of its parent is an alias\r\n * @param record\r\n */\r\nfunction isAliasRecord(record) {\r\n    while (record) {\r\n        if (record.record.aliasOf)\r\n            return true;\r\n        record = record.parent;\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * Merge meta fields of an array of records\r\n *\r\n * @param matched array of matched records\r\n */\r\nfunction mergeMetaFields(matched) {\r\n    return matched.reduce((meta, record) => assign(meta, record.meta), {});\r\n}\r\nfunction mergeOptions(defaults, partialOptions) {\r\n    let options = {};\r\n    for (let key in defaults) {\r\n        options[key] =\r\n            key in partialOptions ? partialOptions[key] : defaults[key];\r\n    }\r\n    return options;\r\n}\r\nfunction isSameParam(a, b) {\r\n    return (a.name === b.name &&\r\n        a.optional === b.optional &&\r\n        a.repeatable === b.repeatable);\r\n}\r\nfunction checkSameParams(a, b) {\r\n    for (let key of a.keys) {\r\n        if (!b.keys.find(isSameParam.bind(null, key)))\r\n            return warn(`Alias \"${b.record.path}\" and the original record: \"${a.record.path}\" should have the exact same param named \"${key.name}\"`);\r\n    }\r\n    for (let key of b.keys) {\r\n        if (!a.keys.find(isSameParam.bind(null, key)))\r\n            return warn(`Alias \"${b.record.path}\" and the original record: \"${a.record.path}\" should have the exact same param named \"${key.name}\"`);\r\n    }\r\n}\r\nfunction checkMissingParamsInAbsolutePath(record, parent) {\r\n    for (let key of parent.keys) {\r\n        if (!record.keys.find(isSameParam.bind(null, key)))\r\n            return warn(`Absolute path \"${record.record.path}\" should have the exact same param named \"${key.name}\" as its parent \"${parent.record.path}\".`);\r\n    }\r\n}\n\n/**\r\n * Create a list of callbacks that can be reset. Used to create before and after navigation guards list\r\n */\r\nfunction useCallbacks() {\r\n    let handlers = [];\r\n    function add(handler) {\r\n        handlers.push(handler);\r\n        return () => {\r\n            const i = handlers.indexOf(handler);\r\n            if (i > -1)\r\n                handlers.splice(i, 1);\r\n        };\r\n    }\r\n    function reset() {\r\n        handlers = [];\r\n    }\r\n    return {\r\n        add,\r\n        list: () => handlers,\r\n        reset,\r\n    };\r\n}\n\n/**\r\n * Add a navigation guard that triggers whenever the current location is\r\n * left. Similarly to {@link beforeRouteLeave}, it has access to the\r\n * component instance as `this`.\r\n *\r\n * @param leaveGuard - {@link NavigationGuard}\r\n */\r\nfunction onBeforeRouteLeave(leaveGuard) {\r\n    const instance = getCurrentInstance();\r\n    if (!instance) {\r\n        \r\n            warn$1('onBeforeRouteLeave must be called at the top of a setup function');\r\n        return;\r\n    }\r\n    const activeRecord = inject(matchedRouteKey, {}).value;\r\n    if (!activeRecord) {\r\n        \r\n            warn$1('onBeforeRouteLeave must be called at the top of a setup function');\r\n        return;\r\n    }\r\n    activeRecord.leaveGuards.push(\r\n    // @ts-ignore do we even want to allow that? Passing the context in a composition api hook doesn't make sense\r\n    leaveGuard.bind(instance.proxy));\r\n}\r\n/**\r\n * Add a navigation guard that triggers whenever the current location is\r\n * updated. Similarly to {@link beforeRouteUpdate}, it has access to the\r\n * component instance as `this`.\r\n *\r\n * @param updateGuard - {@link NavigationGuard}\r\n */\r\nfunction onBeforeRouteUpdate(updateGuard) {\r\n    const instance = getCurrentInstance();\r\n    if (!instance) {\r\n        \r\n            warn$1('onBeforeRouteUpdate must be called at the top of a setup function');\r\n        return;\r\n    }\r\n    const activeRecord = inject(matchedRouteKey, {}).value;\r\n    if (!activeRecord) {\r\n        \r\n            warn$1('onBeforeRouteUpdate must be called at the top of a setup function');\r\n        return;\r\n    }\r\n    activeRecord.updateGuards.push(\r\n    // @ts-ignore do we even want to allow that? Passing the context in a composition api hook doesn't make sense\r\n    updateGuard.bind(instance.proxy));\r\n}\r\nfunction guardToPromiseFn(guard, to, from, record, name) {\r\n    // keep a reference to the enterCallbackArray to prevent pushing callbacks if a new navigation took place\r\n    const enterCallbackArray = record &&\r\n        // name is defined if record is because of the function overload\r\n        (record.enterCallbacks[name] = record.enterCallbacks[name] || []);\r\n    return () => new Promise((resolve, reject) => {\r\n        const next = (valid) => {\r\n            if (valid === false)\r\n                reject(createRouterError(4 /* NAVIGATION_ABORTED */, {\r\n                    from,\r\n                    to,\r\n                }));\r\n            else if (valid instanceof Error) {\r\n                reject(valid);\r\n            }\r\n            else if (isRouteLocation(valid)) {\r\n                reject(createRouterError(2 /* NAVIGATION_GUARD_REDIRECT */, {\r\n                    from: to,\r\n                    to: valid,\r\n                }));\r\n            }\r\n            else {\r\n                if (enterCallbackArray &&\r\n                    // since enterCallbackArray is truthy, both record and name also are\r\n                    record.enterCallbacks[name] === enterCallbackArray &&\r\n                    typeof valid === 'function')\r\n                    enterCallbackArray.push(valid);\r\n                resolve();\r\n            }\r\n        };\r\n        // wrapping with Promise.resolve allows it to work with both async and sync guards\r\n        let guardCall = Promise.resolve(guard.call(record && record.instances[name], to, from,  canOnlyBeCalledOnce(next, to, from) ));\r\n        if (guard.length < 3)\r\n            guardCall.then(next);\r\n        guardCall.catch(err => reject(err));\r\n    });\r\n}\r\nfunction canOnlyBeCalledOnce(next, to, from) {\r\n    let called = 0;\r\n    return function () {\r\n        if (called++ === 1)\r\n            warn$1(`The \"next\" callback was called more than once in one navigation guard when going from \"${from.fullPath}\" to \"${to.fullPath}\". It should be called exactly one time in each navigation guard. This will fail in production.`);\r\n        if (called === 1)\r\n            next.apply(null, arguments);\r\n    };\r\n}\r\nfunction extractComponentsGuards(matched, guardType, to, from) {\r\n    const guards = [];\r\n    for (const record of matched) {\r\n        for (const name in record.components) {\r\n            let rawComponent = record.components[name];\r\n            // warn if user wrote import('/component.vue') instead of () => import('./component.vue')\r\n            if ( 'then' in rawComponent) {\r\n                warn$1(`Component \"${name}\" in record with path \"${record.path}\" is a Promise instead of a function that returns a Promise. Did you write \"import('./MyPage.vue')\" instead of \"() => import('./MyPage.vue')\"? This will break in production if not fixed.`);\r\n                let promise = rawComponent;\r\n                rawComponent = () => promise;\r\n            }\r\n            // skip update and leave guards if the route component is not mounted\r\n            if (guardType !== 'beforeRouteEnter' && !record.instances[name])\r\n                continue;\r\n            if (isRouteComponent(rawComponent)) {\r\n                // __vccOpts is added by vue-class-component and contain the regular options\r\n                let options = rawComponent.__vccOpts || rawComponent;\r\n                const guard = options[guardType];\r\n                guard && guards.push(guardToPromiseFn(guard, to, from, record, name));\r\n            }\r\n            else {\r\n                // start requesting the chunk already\r\n                let componentPromise = rawComponent();\r\n                if ( !('catch' in componentPromise)) {\r\n                    warn$1(`Component \"${name}\" in record with path \"${record.path}\" is a function that does not return a Promise. If you were passing a functional component, make sure to add a \"displayName\" to the component. This will break in production if not fixed.`);\r\n                    componentPromise = Promise.resolve(componentPromise);\r\n                }\r\n                else {\r\n                    componentPromise = componentPromise.catch(() => null);\r\n                }\r\n                guards.push(() => componentPromise.then(resolved => {\r\n                    if (!resolved)\r\n                        return Promise.reject(new Error(`Couldn't resolve component \"${name}\" for the following record with path \"${record.path}\"`));\r\n                    const resolvedComponent = isESModule(resolved)\r\n                        ? resolved.default\r\n                        : resolved;\r\n                    // replace the function with the resolved component\r\n                    record.components[name] = resolvedComponent;\r\n                    // @ts-ignore: the options types are not propagated to Component\r\n                    const guard = resolvedComponent[guardType];\r\n                    return guard && guardToPromiseFn(guard, to, from, record, name)();\r\n                }));\r\n            }\r\n        }\r\n    }\r\n    return guards;\r\n}\r\n/**\r\n * Allows differentiating lazy components from functional components and vue-class-component\r\n * @param component\r\n */\r\nfunction isRouteComponent(component) {\r\n    return (typeof component === 'object' ||\r\n        'displayName' in component ||\r\n        'props' in component ||\r\n        '__vccOpts' in component);\r\n}\n\n// TODO: we could allow currentRoute as a prop to expose `isActive` and\r\n// `isExactActive` behavior should go through an RFC\r\nfunction useLink(props) {\r\n    const router = inject(routerKey);\r\n    const currentRoute = inject(routeLocationKey);\r\n    const route = computed(() => router.resolve(unref(props.to)));\r\n    const activeRecordIndex = computed(() => {\r\n        let { matched } = route.value;\r\n        let { length } = matched;\r\n        const routeMatched = matched[length - 1];\r\n        let currentMatched = currentRoute.matched;\r\n        if (!routeMatched || !currentMatched.length)\r\n            return -1;\r\n        let index = currentMatched.findIndex(isSameRouteRecord.bind(null, routeMatched));\r\n        if (index > -1)\r\n            return index;\r\n        // possible parent record\r\n        let parentRecordPath = getOriginalPath(matched[length - 2]);\r\n        return (\r\n        // we are dealing with nested routes\r\n        length > 1 &&\r\n            // if the have the same path, this link is referring to the empty child\r\n            // are we currently are on a different child of the same parent\r\n            getOriginalPath(routeMatched) === parentRecordPath &&\r\n            // avoid comparing the child with its parent\r\n            currentMatched[currentMatched.length - 1].path !== parentRecordPath\r\n            ? currentMatched.findIndex(isSameRouteRecord.bind(null, matched[length - 2]))\r\n            : index);\r\n    });\r\n    const isActive = computed(() => activeRecordIndex.value > -1 &&\r\n        includesParams(currentRoute.params, route.value.params));\r\n    const isExactActive = computed(() => activeRecordIndex.value > -1 &&\r\n        activeRecordIndex.value === currentRoute.matched.length - 1 &&\r\n        isSameRouteLocationParams(currentRoute.params, route.value.params));\r\n    function navigate(e = {}) {\r\n        if (guardEvent(e))\r\n            return router[unref(props.replace) ? 'replace' : 'push'](unref(props.to));\r\n        return Promise.resolve();\r\n    }\r\n    return {\r\n        route,\r\n        href: computed(() => route.value.href),\r\n        isActive,\r\n        isExactActive,\r\n        navigate,\r\n    };\r\n}\r\nconst RouterLinkImpl = defineComponent({\r\n    name: 'RouterLink',\r\n    props: {\r\n        to: {\r\n            type: [String, Object],\r\n            required: true,\r\n        },\r\n        activeClass: String,\r\n        // inactiveClass: String,\r\n        exactActiveClass: String,\r\n        custom: Boolean,\r\n    },\r\n    setup(props, { slots, attrs }) {\r\n        const link = reactive(useLink(props));\r\n        const { options } = inject(routerKey);\r\n        const elClass = computed(() => ({\r\n            [getLinkClass(props.activeClass, options.linkActiveClass, 'router-link-active')]: link.isActive,\r\n            // [getLinkClass(\r\n            //   props.inactiveClass,\r\n            //   options.linkInactiveClass,\r\n            //   'router-link-inactive'\r\n            // )]: !link.isExactActive,\r\n            [getLinkClass(props.exactActiveClass, options.linkExactActiveClass, 'router-link-exact-active')]: link.isExactActive,\r\n        }));\r\n        return () => {\r\n            const children = slots.default && slots.default(link);\r\n            return props.custom\r\n                ? children\r\n                : h('a', assign({\r\n                    'aria-current': link.isExactActive ? 'page' : null,\r\n                    onClick: link.navigate,\r\n                    href: link.href,\r\n                }, attrs, {\r\n                    class: elClass.value,\r\n                }), children);\r\n        };\r\n    },\r\n});\r\n// export the public type for h/tsx inference\r\n// also to avoid inline import() in generated d.ts files\r\nconst RouterLink = RouterLinkImpl;\r\nfunction guardEvent(e) {\r\n    // don't redirect with control keys\r\n    if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey)\r\n        return;\r\n    // don't redirect when preventDefault called\r\n    if (e.defaultPrevented)\r\n        return;\r\n    // don't redirect on right click\r\n    if (e.button !== undefined && e.button !== 0)\r\n        return;\r\n    // don't redirect if `target=\"_blank\"`\r\n    // @ts-ignore getAttribute does exist\r\n    if (e.currentTarget && e.currentTarget.getAttribute) {\r\n        // @ts-ignore getAttribute exists\r\n        const target = e.currentTarget.getAttribute('target');\r\n        if (/\\b_blank\\b/i.test(target))\r\n            return;\r\n    }\r\n    // this may be a Weex event which doesn't have this method\r\n    if (e.preventDefault)\r\n        e.preventDefault();\r\n    return true;\r\n}\r\nfunction includesParams(outer, inner) {\r\n    for (let key in inner) {\r\n        let innerValue = inner[key];\r\n        let outerValue = outer[key];\r\n        if (typeof innerValue === 'string') {\r\n            if (innerValue !== outerValue)\r\n                return false;\r\n        }\r\n        else {\r\n            if (!Array.isArray(outerValue) ||\r\n                outerValue.length !== innerValue.length ||\r\n                innerValue.some((value, i) => value !== outerValue[i]))\r\n                return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\n/**\r\n * Get the original path value of a record by following its aliasOf\r\n * @param record\r\n */\r\nfunction getOriginalPath(record) {\r\n    return record ? (record.aliasOf ? record.aliasOf.path : record.path) : '';\r\n}\r\n/**\r\n * Utility class to get the active class based on defaults.\r\n * @param propClass\r\n * @param globalClass\r\n * @param defaultClass\r\n */\r\nlet getLinkClass = (propClass, globalClass, defaultClass) => propClass != null\r\n    ? propClass\r\n    : globalClass != null\r\n        ? globalClass\r\n        : defaultClass;\n\nconst RouterViewImpl = defineComponent({\r\n    name: 'RouterView',\r\n    props: {\r\n        name: {\r\n            type: String,\r\n            default: 'default',\r\n        },\r\n        route: Object,\r\n    },\r\n    setup(props, { attrs, slots }) {\r\n         warnDeprecatedUsage();\r\n        const route = inject(routeLocationKey);\r\n        const depth = inject(viewDepthKey, 0);\r\n        const matchedRouteRef = computed(() => (props.route || route).matched[depth]);\r\n        provide(viewDepthKey, depth + 1);\r\n        provide(matchedRouteKey, matchedRouteRef);\r\n        const viewRef = ref();\r\n        return () => {\r\n            const matchedRoute = matchedRouteRef.value;\r\n            if (!matchedRoute) {\r\n                return null;\r\n            }\r\n            const ViewComponent = matchedRoute.components[props.name];\r\n            if (!ViewComponent) {\r\n                return null;\r\n            }\r\n            // props from route configration\r\n            const routePropsOption = matchedRoute.props[props.name];\r\n            const routeProps = routePropsOption\r\n                ? routePropsOption === true\r\n                    ? route.params\r\n                    : typeof routePropsOption === 'function'\r\n                        ? routePropsOption(route)\r\n                        : routePropsOption\r\n                : null;\r\n            // we need the value at the time we render because when we unmount, we\r\n            // navigated to a different location so the value is different\r\n            const currentName = props.name;\r\n            const onVnodeMounted = () => {\r\n                matchedRoute.instances[currentName] = viewRef.value;\r\n                (matchedRoute.enterCallbacks[currentName] || []).forEach(callback => callback(viewRef.value));\r\n            };\r\n            const onVnodeUnmounted = () => {\r\n                // remove the instance reference to prevent leak\r\n                matchedRoute.instances[currentName] = null;\r\n            };\r\n            const component = h(ViewComponent, assign({}, routeProps, attrs, {\r\n                onVnodeMounted,\r\n                onVnodeUnmounted,\r\n                ref: viewRef,\r\n            }));\r\n            return (\r\n            // pass the vnode to the slot as a prop.\r\n            // h and <component :is=\"...\"> both accept vnodes\r\n            slots.default\r\n                ? slots.default({ Component: component, route: matchedRoute })\r\n                : component);\r\n        };\r\n    },\r\n});\r\n// export the public type for h/tsx inference\r\n// also to avoid inline import() in generated d.ts files\r\nconst RouterView = RouterViewImpl;\r\n// warn against deprecated usage with <transition> & <keep-alive>\r\n// due to functional component being no longer eager in Vue 3\r\nfunction warnDeprecatedUsage() {\r\n    const instance = getCurrentInstance();\r\n    const parentName = instance.parent && instance.parent.type.name;\r\n    if (parentName &&\r\n        (parentName === 'KeepAlive' || parentName.includes('Transition'))) {\r\n        const comp = parentName === 'KeepAlive' ? 'keep-alive' : 'transition';\r\n        warn(`<router-view> can no longer be used directly inside <transition> or <keep-alive>.\\n` +\r\n            `Use slot props instead:\\n\\n` +\r\n            `<router-view v-slot=\"{ Component }\">\\n` +\r\n            `  <${comp}>\\n` +\r\n            `    <component :is=\"Component\" />\\n` +\r\n            `  </${comp}>\\n` +\r\n            `</router-view>`);\r\n    }\r\n}\n\n/**\r\n * Create a Router instance that can be used on a Vue app.\r\n *\r\n * @param options - {@link RouterOptions}\r\n */\r\nfunction createRouter(options) {\r\n    const matcher = createRouterMatcher(options.routes, options);\r\n    let parseQuery$1 = options.parseQuery || parseQuery;\r\n    let stringifyQuery$1 = options.stringifyQuery || stringifyQuery;\r\n    let { scrollBehavior } = options;\r\n    let routerHistory = options.history;\r\n    const beforeGuards = useCallbacks();\r\n    const beforeResolveGuards = useCallbacks();\r\n    const afterGuards = useCallbacks();\r\n    const currentRoute = shallowRef(START_LOCATION_NORMALIZED);\r\n    let pendingLocation = START_LOCATION_NORMALIZED;\r\n    // leave the scrollRestoration if no scrollBehavior is provided\r\n    if (isBrowser && scrollBehavior && 'scrollRestoration' in history) {\r\n        history.scrollRestoration = 'manual';\r\n    }\r\n    const normalizeParams = applyToParams.bind(null, paramValue => '' + paramValue);\r\n    const encodeParams = applyToParams.bind(null, encodeParam);\r\n    const decodeParams = applyToParams.bind(null, decode);\r\n    function addRoute(parentOrRoute, route) {\r\n        let parent;\r\n        let record;\r\n        if (isRouteName(parentOrRoute)) {\r\n            parent = matcher.getRecordMatcher(parentOrRoute);\r\n            record = route;\r\n        }\r\n        else {\r\n            record = parentOrRoute;\r\n        }\r\n        return matcher.addRoute(record, parent);\r\n    }\r\n    function removeRoute(name) {\r\n        let recordMatcher = matcher.getRecordMatcher(name);\r\n        if (recordMatcher) {\r\n            matcher.removeRoute(recordMatcher);\r\n        }\r\n        else {\r\n            warn(`Cannot remove non-existent route \"${String(name)}\"`);\r\n        }\r\n    }\r\n    function getRoutes() {\r\n        return matcher.getRoutes().map(routeMatcher => routeMatcher.record);\r\n    }\r\n    function hasRoute(name) {\r\n        return !!matcher.getRecordMatcher(name);\r\n    }\r\n    function resolve(rawLocation, currentLocation) {\r\n        // const objectLocation = routerLocationAsObject(rawLocation)\r\n        currentLocation = currentLocation || currentRoute.value;\r\n        if (typeof rawLocation === 'string') {\r\n            let locationNormalized = parseURL(parseQuery$1, rawLocation, currentLocation.path);\r\n            let matchedRoute = matcher.resolve({ path: locationNormalized.path }, currentLocation);\r\n            let href = routerHistory.createHref(locationNormalized.fullPath);\r\n            {\r\n                if (href.startsWith('//'))\r\n                    warn(`Location \"${rawLocation}\" resolved to \"${href}\". A resolved location cannot start with multiple slashes.`);\r\n                else if (!matchedRoute.matched.length) {\r\n                    warn(`No match found for location with path \"${rawLocation}\"`);\r\n                }\r\n            }\r\n            // locationNormalized is always a new object\r\n            return assign(locationNormalized, matchedRoute, {\r\n                params: decodeParams(matchedRoute.params),\r\n                redirectedFrom: undefined,\r\n                href,\r\n            });\r\n        }\r\n        let matcherLocation;\r\n        // path could be relative in object as well\r\n        if ('path' in rawLocation) {\r\n            if (\r\n                'params' in rawLocation &&\r\n                !('name' in rawLocation) &&\r\n                Object.keys(rawLocation.params).length) {\r\n                warn(`Path \"${rawLocation.path}\" was passed with params but they will be ignored. Use a named route alongside params instead.`);\r\n            }\r\n            matcherLocation = assign({}, rawLocation, {\r\n                path: parseURL(parseQuery$1, rawLocation.path, currentLocation.path).path,\r\n            });\r\n        }\r\n        else {\r\n            matcherLocation = assign({}, rawLocation, {\r\n                params: encodeParams(rawLocation.params),\r\n            });\r\n        }\r\n        let matchedRoute = matcher.resolve(matcherLocation, currentLocation);\r\n        const hash = encodeHash(rawLocation.hash || '');\r\n        if ( hash && !hash.startsWith('#')) {\r\n            warn(`A \\`hash\\` should always start with the character \"#\". Replace \"${hash}\" with \"#${hash}\".`);\r\n        }\r\n        // put back the unencoded params as given by the user (avoid the cost of decoding them)\r\n        matchedRoute.params =\r\n            'params' in rawLocation\r\n                ? normalizeParams(rawLocation.params)\r\n                : decodeParams(matchedRoute.params);\r\n        const fullPath = stringifyURL(stringifyQuery$1, assign({}, rawLocation, {\r\n            hash,\r\n            path: matchedRoute.path,\r\n        }));\r\n        let href = routerHistory.createHref(fullPath);\r\n        {\r\n            if (href.startsWith('//'))\r\n                warn(`Location \"${rawLocation}\" resolved to \"${href}\". A resolved location cannot start with multiple slashes.`);\r\n            else if (!matchedRoute.matched.length) {\r\n                warn(`No match found for location with path \"${'path' in rawLocation ? rawLocation.path : rawLocation}\"`);\r\n            }\r\n        }\r\n        return assign({\r\n            fullPath,\r\n            // keep the hash encoded so fullPath is effectively path + encodedQuery +\r\n            // hash\r\n            hash,\r\n            query: \r\n            // if the user is using a custom query lib like qs, we might have\r\n            // nested objects, so we keep the query as is, meaning it can contain\r\n            // numbers at `$route.query`, but at the point, the user will have to\r\n            // use their own type anyway.\r\n            // https://github.com/vuejs/vue-router-next/issues/328#issuecomment-649481567\r\n            stringifyQuery$1 === stringifyQuery\r\n                ? normalizeQuery(rawLocation.query)\r\n                : rawLocation.query,\r\n        }, matchedRoute, {\r\n            redirectedFrom: undefined,\r\n            href,\r\n        });\r\n    }\r\n    function locationAsObject(to) {\r\n        return typeof to === 'string' ? { path: to } : assign({}, to);\r\n    }\r\n    function checkCanceledNavigation(to, from) {\r\n        if (pendingLocation !== to) {\r\n            return createRouterError(8 /* NAVIGATION_CANCELLED */, {\r\n                from,\r\n                to,\r\n            });\r\n        }\r\n    }\r\n    function push(to) {\r\n        return pushWithRedirect(to);\r\n    }\r\n    function replace(to) {\r\n        return push(assign(locationAsObject(to), { replace: true }));\r\n    }\r\n    function pushWithRedirect(to, redirectedFrom) {\r\n        const targetLocation = (pendingLocation = resolve(to));\r\n        const from = currentRoute.value;\r\n        const data = to.state;\r\n        const force = to.force;\r\n        // to could be a string where `replace` is a function\r\n        const replace = to.replace === true;\r\n        const lastMatched = targetLocation.matched[targetLocation.matched.length - 1];\r\n        if (lastMatched && lastMatched.redirect) {\r\n            const { redirect } = lastMatched;\r\n            // transform it into an object to pass the original RouteLocaleOptions\r\n            let newTargetLocation = locationAsObject(typeof redirect === 'function' ? redirect(targetLocation) : redirect);\r\n            if (\r\n                !('path' in newTargetLocation) &&\r\n                !('name' in newTargetLocation)) {\r\n                warn(`Invalid redirect found:\\n${JSON.stringify(newTargetLocation, null, 2)}\\n when navigating to \"${targetLocation.fullPath}\". A redirect must contain a name or path. This will break in production.`);\r\n                return Promise.reject(new Error('Invalid redirect'));\r\n            }\r\n            return pushWithRedirect(assign({}, \r\n            // having a path here would be a problem with relative locations but\r\n            // at the same time it doesn't make sense for a redirect to be\r\n            // relative (no name, no path) because it would create an infinite\r\n            // loop. Since newTargetLocation must either have a `path` or a\r\n            // `name`, this will never happen\r\n            targetLocation, newTargetLocation, {\r\n                state: data,\r\n                force,\r\n                replace,\r\n            }), \r\n            // keep original redirectedFrom if it exists\r\n            redirectedFrom || targetLocation);\r\n        }\r\n        // if it was a redirect we already called `pushWithRedirect` above\r\n        const toLocation = targetLocation;\r\n        toLocation.redirectedFrom = redirectedFrom;\r\n        let failure;\r\n        if (!force && isSameRouteLocation(stringifyQuery$1, from, targetLocation)) {\r\n            failure = createRouterError(16 /* NAVIGATION_DUPLICATED */, { to: toLocation, from });\r\n            // trigger scroll to allow scrolling to the same anchor\r\n            handleScroll(from, from, \r\n            // this is a push, the only way for it to be triggered from a\r\n            // history.listen is with a redirect, which makes it become a pus\r\n            true, \r\n            // This cannot be the first navigation because the initial location\r\n            // cannot be manually navigated to\r\n            false);\r\n        }\r\n        return (failure ? Promise.resolve(failure) : navigate(toLocation, from))\r\n            .catch((error) => {\r\n            if (isNavigationFailure(error, 4 /* NAVIGATION_ABORTED */ |\r\n                8 /* NAVIGATION_CANCELLED */ |\r\n                2 /* NAVIGATION_GUARD_REDIRECT */)) {\r\n                return error;\r\n            }\r\n            // unknown error, rejects\r\n            return triggerError(error);\r\n        })\r\n            .then((failure) => {\r\n            if (failure) {\r\n                if (isNavigationFailure(failure, 2 /* NAVIGATION_GUARD_REDIRECT */))\r\n                    // preserve the original redirectedFrom if any\r\n                    return pushWithRedirect(\r\n                    // keep options\r\n                    assign(locationAsObject(failure.to), {\r\n                        state: data,\r\n                        force,\r\n                        replace,\r\n                    }), redirectedFrom || toLocation);\r\n            }\r\n            else {\r\n                // if we fail we don't finalize the navigation\r\n                failure = finalizeNavigation(toLocation, from, true, replace, data);\r\n            }\r\n            triggerAfterEach(toLocation, from, failure);\r\n            return failure;\r\n        });\r\n    }\r\n    /**\r\n     * Helper to reject and skip all navigation guards if a new navigation happened\r\n     * @param to\r\n     * @param from\r\n     */\r\n    function checkCanceledNavigationAndReject(to, from) {\r\n        const error = checkCanceledNavigation(to, from);\r\n        return error ? Promise.reject(error) : Promise.resolve();\r\n    }\r\n    // TODO: refactor the whole before guards by internally using router.beforeEach\r\n    function navigate(to, from) {\r\n        let guards;\r\n        // all components here have been resolved once because we are leaving\r\n        guards = extractComponentsGuards(from.matched.filter(record => to.matched.indexOf(record) < 0).reverse(), 'beforeRouteLeave', to, from);\r\n        const [leavingRecords, updatingRecords,] = extractChangingRecords(to, from);\r\n        for (const record of leavingRecords) {\r\n            for (const guard of record.leaveGuards) {\r\n                guards.push(guardToPromiseFn(guard, to, from));\r\n            }\r\n        }\r\n        const canceledNavigationCheck = checkCanceledNavigationAndReject.bind(null, to, from);\r\n        guards.push(canceledNavigationCheck);\r\n        // run the queue of per route beforeRouteLeave guards\r\n        return (runGuardQueue(guards)\r\n            .then(() => {\r\n            // check global guards beforeEach\r\n            guards = [];\r\n            for (const guard of beforeGuards.list()) {\r\n                guards.push(guardToPromiseFn(guard, to, from));\r\n            }\r\n            guards.push(canceledNavigationCheck);\r\n            return runGuardQueue(guards);\r\n        })\r\n            .then(() => {\r\n            // check in components beforeRouteUpdate\r\n            guards = extractComponentsGuards(to.matched.filter(record => from.matched.indexOf(record) > -1), 'beforeRouteUpdate', to, from);\r\n            for (const record of updatingRecords) {\r\n                for (const guard of record.updateGuards) {\r\n                    guards.push(guardToPromiseFn(guard, to, from));\r\n                }\r\n            }\r\n            guards.push(canceledNavigationCheck);\r\n            // run the queue of per route beforeEnter guards\r\n            return runGuardQueue(guards);\r\n        })\r\n            .then(() => {\r\n            // check the route beforeEnter\r\n            guards = [];\r\n            for (const record of to.matched) {\r\n                // do not trigger beforeEnter on reused views\r\n                if (record.beforeEnter && from.matched.indexOf(record) < 0) {\r\n                    if (Array.isArray(record.beforeEnter)) {\r\n                        for (const beforeEnter of record.beforeEnter)\r\n                            guards.push(guardToPromiseFn(beforeEnter, to, from));\r\n                    }\r\n                    else {\r\n                        guards.push(guardToPromiseFn(record.beforeEnter, to, from));\r\n                    }\r\n                }\r\n            }\r\n            guards.push(canceledNavigationCheck);\r\n            // run the queue of per route beforeEnter guards\r\n            return runGuardQueue(guards);\r\n        })\r\n            .then(() => {\r\n            // NOTE: at this point to.matched is normalized and does not contain any () => Promise<Component>\r\n            // clear existing enterCallbacks, these are added by extractComponentsGuards\r\n            to.matched.forEach(record => (record.enterCallbacks = {}));\r\n            // check in-component beforeRouteEnter\r\n            guards = extractComponentsGuards(\r\n            // the type doesn't matter as we are comparing an object per reference\r\n            to.matched.filter(record => from.matched.indexOf(record) < 0), 'beforeRouteEnter', to, from);\r\n            guards.push(canceledNavigationCheck);\r\n            // run the queue of per route beforeEnter guards\r\n            return runGuardQueue(guards);\r\n        })\r\n            .then(() => {\r\n            // check global guards beforeResolve\r\n            guards = [];\r\n            for (const guard of beforeResolveGuards.list()) {\r\n                guards.push(guardToPromiseFn(guard, to, from));\r\n            }\r\n            guards.push(canceledNavigationCheck);\r\n            return runGuardQueue(guards);\r\n        })\r\n            // catch any navigation canceled\r\n            .catch(err => isNavigationFailure(err, 8 /* NAVIGATION_CANCELLED */)\r\n            ? err\r\n            : Promise.reject(err)));\r\n    }\r\n    function triggerAfterEach(to, from, failure) {\r\n        // navigation is confirmed, call afterGuards\r\n        // TODO: wrap with error handlers\r\n        for (const guard of afterGuards.list())\r\n            guard(to, from, failure);\r\n    }\r\n    /**\r\n     * - Cleans up any navigation guards\r\n     * - Changes the url if necessary\r\n     * - Calls the scrollBehavior\r\n     */\r\n    function finalizeNavigation(toLocation, from, isPush, replace, data) {\r\n        // a more recent navigation took place\r\n        const error = checkCanceledNavigation(toLocation, from);\r\n        if (error)\r\n            return error;\r\n        const [leavingRecords] = extractChangingRecords(toLocation, from);\r\n        for (const record of leavingRecords) {\r\n            // remove registered guards from removed matched records\r\n            record.leaveGuards = [];\r\n            record.updateGuards = [];\r\n            // free the references\r\n            record.instances = {};\r\n            record.enterCallbacks = {};\r\n        }\r\n        // only consider as push if it's not the first navigation\r\n        const isFirstNavigation = from === START_LOCATION_NORMALIZED;\r\n        const state = !isBrowser ? {} : history.state;\r\n        // change URL only if the user did a push/replace and if it's not the initial navigation because\r\n        // it's just reflecting the url\r\n        if (isPush) {\r\n            // on the initial navigation, we want to reuse the scroll position from\r\n            // history state if it exists\r\n            if (replace || isFirstNavigation)\r\n                routerHistory.replace(toLocation.fullPath, assign({\r\n                    scroll: isFirstNavigation && state && state.scroll,\r\n                }, data));\r\n            else\r\n                routerHistory.push(toLocation.fullPath, data);\r\n        }\r\n        // accept current navigation\r\n        currentRoute.value = toLocation;\r\n        handleScroll(toLocation, from, isPush, isFirstNavigation);\r\n        markAsReady();\r\n    }\r\n    let removeHistoryListener;\r\n    // attach listener to history to trigger navigations\r\n    function setupListeners() {\r\n        removeHistoryListener = routerHistory.listen((to, _from, info) => {\r\n            // cannot be a redirect route because it was in history\r\n            const toLocation = resolve(to);\r\n            pendingLocation = toLocation;\r\n            const from = currentRoute.value;\r\n            // TODO: should be moved to web history?\r\n            if (isBrowser) {\r\n                saveScrollPosition(getScrollKey(from.fullPath, info.delta), computeScrollPosition());\r\n            }\r\n            navigate(toLocation, from)\r\n                .catch((error) => {\r\n                if (isNavigationFailure(error, 4 /* NAVIGATION_ABORTED */ | 8 /* NAVIGATION_CANCELLED */)) {\r\n                    return error;\r\n                }\r\n                if (isNavigationFailure(error, 2 /* NAVIGATION_GUARD_REDIRECT */)) {\r\n                    // do not restore history on unknown direction\r\n                    if (info.delta)\r\n                        routerHistory.go(-info.delta, false);\r\n                    // the error is already handled by router.push we just want to avoid\r\n                    // logging the error\r\n                    pushWithRedirect(error.to, toLocation\r\n                    // avoid an uncaught rejection\r\n                    ).catch(noop);\r\n                    // avoid the then branch\r\n                    return Promise.reject();\r\n                }\r\n                // do not restore history on unknown direction\r\n                if (info.delta)\r\n                    routerHistory.go(-info.delta, false);\r\n                // unrecognized error, transfer to the global handler\r\n                return triggerError(error);\r\n            })\r\n                .then((failure) => {\r\n                failure =\r\n                    failure ||\r\n                        finalizeNavigation(\r\n                        // after navigation, all matched components are resolved\r\n                        toLocation, from, false);\r\n                // revert the navigation\r\n                if (failure && info.delta)\r\n                    routerHistory.go(-info.delta, false);\r\n                triggerAfterEach(toLocation, from, failure);\r\n            })\r\n                .catch(noop);\r\n        });\r\n    }\r\n    // Initialization and Errors\r\n    let readyHandlers = useCallbacks();\r\n    let errorHandlers = useCallbacks();\r\n    let ready;\r\n    /**\r\n     * Trigger errorHandlers added via onError and throws the error as well\r\n     * @param error - error to throw\r\n     * @returns the error as a rejected promise\r\n     */\r\n    function triggerError(error) {\r\n        markAsReady(error);\r\n        errorHandlers.list().forEach(handler => handler(error));\r\n        return Promise.reject(error);\r\n    }\r\n    /**\r\n     * Returns a Promise that resolves or reject when the router has finished its\r\n     * initial navigation. This will be automatic on client but requires an\r\n     * explicit `router.push` call on the server. This behavior can change\r\n     * depending on the history implementation used e.g. the defaults history\r\n     * implementation (client only) triggers this automatically but the memory one\r\n     * (should be used on server) doesn't\r\n     */\r\n    function isReady() {\r\n        if (ready && currentRoute.value !== START_LOCATION_NORMALIZED)\r\n            return Promise.resolve();\r\n        return new Promise((resolve, reject) => {\r\n            readyHandlers.add([resolve, reject]);\r\n        });\r\n    }\r\n    /**\r\n     * Mark the router as ready, resolving the promised returned by isReady(). Can\r\n     * only be called once, otherwise does nothing.\r\n     * @param err - optional error\r\n     */\r\n    function markAsReady(err) {\r\n        if (ready)\r\n            return;\r\n        ready = true;\r\n        setupListeners();\r\n        readyHandlers\r\n            .list()\r\n            .forEach(([resolve, reject]) => (err ? reject(err) : resolve()));\r\n        readyHandlers.reset();\r\n    }\r\n    // Scroll behavior\r\n    function handleScroll(to, from, isPush, isFirstNavigation) {\r\n        if (!isBrowser || !scrollBehavior)\r\n            return Promise.resolve();\r\n        let scrollPosition = (!isPush && getSavedScrollPosition(getScrollKey(to.fullPath, 0))) ||\r\n            ((isFirstNavigation || !isPush) &&\r\n                history.state &&\r\n                history.state.scroll) ||\r\n            null;\r\n        return nextTick()\r\n            .then(() => scrollBehavior(to, from, scrollPosition))\r\n            .then(position => position && scrollToPosition(position))\r\n            .catch(triggerError);\r\n    }\r\n    function go(delta) {\r\n        return new Promise((resolve, reject) => {\r\n            let removeError = errorHandlers.add(err => {\r\n                removeError();\r\n                removeAfterEach();\r\n                reject(err);\r\n            });\r\n            let removeAfterEach = afterGuards.add((_to, _from, failure) => {\r\n                removeError();\r\n                removeAfterEach();\r\n                resolve(failure);\r\n            });\r\n            routerHistory.go(delta);\r\n        });\r\n    }\r\n    let started;\r\n    const installedApps = new Set();\r\n    const router = {\r\n        currentRoute,\r\n        addRoute,\r\n        removeRoute,\r\n        hasRoute,\r\n        getRoutes,\r\n        resolve,\r\n        options,\r\n        push,\r\n        replace,\r\n        go,\r\n        back: () => go(-1),\r\n        forward: () => go(1),\r\n        beforeEach: beforeGuards.add,\r\n        beforeResolve: beforeResolveGuards.add,\r\n        afterEach: afterGuards.add,\r\n        onError: errorHandlers.add,\r\n        isReady,\r\n        install(app) {\r\n            const router = this;\r\n            app.component('RouterLink', RouterLink);\r\n            app.component('RouterView', RouterView);\r\n            app.config.globalProperties.$router = router;\r\n            Object.defineProperty(app.config.globalProperties, '$route', {\r\n                get: () => unref(currentRoute),\r\n            });\r\n            // this initial navigation is only necessary on client, on server it doesn't\r\n            // make sense because it will create an extra unnecessary navigation and could\r\n            // lead to problems\r\n            if (isBrowser &&\r\n                // used for the initial navigation client side to avoid pushing\r\n                // multiple times when the router is used in multiple apps\r\n                !started &&\r\n                currentRoute.value === START_LOCATION_NORMALIZED) {\r\n                // see above\r\n                started = true;\r\n                push(routerHistory.location).catch(err => {\r\n                    warn('Unexpected error when starting the router:', err);\r\n                });\r\n            }\r\n            const reactiveRoute = {};\r\n            for (let key in START_LOCATION_NORMALIZED) {\r\n                // @ts-ignore: the key matches\r\n                reactiveRoute[key] = computed(() => currentRoute.value[key]);\r\n            }\r\n            app.provide(routerKey, router);\r\n            app.provide(routeLocationKey, reactive(reactiveRoute));\r\n            let unmountApp = app.unmount;\r\n            installedApps.add(app);\r\n            app.unmount = function () {\r\n                installedApps.delete(app);\r\n                if (installedApps.size < 1) {\r\n                    removeHistoryListener();\r\n                    currentRoute.value = START_LOCATION_NORMALIZED;\r\n                    started = false;\r\n                    ready = false;\r\n                }\r\n                unmountApp.call(this, arguments);\r\n            };\r\n        },\r\n    };\r\n    return router;\r\n}\r\nfunction runGuardQueue(guards) {\r\n    return guards.reduce((promise, guard) => promise.then(() => guard()), Promise.resolve());\r\n}\r\nfunction extractChangingRecords(to, from) {\r\n    const leavingRecords = [];\r\n    const updatingRecords = [];\r\n    const enteringRecords = [];\r\n    const len = Math.max(from.matched.length, to.matched.length);\r\n    for (let i = 0; i < len; i++) {\r\n        const recordFrom = from.matched[i];\r\n        if (recordFrom) {\r\n            if (to.matched.indexOf(recordFrom) < 0)\r\n                leavingRecords.push(recordFrom);\r\n            else\r\n                updatingRecords.push(recordFrom);\r\n        }\r\n        const recordTo = to.matched[i];\r\n        if (recordTo) {\r\n            // the type doesn't matter because we are comparing per reference\r\n            if (from.matched.indexOf(recordTo) < 0)\r\n                enteringRecords.push(recordTo);\r\n        }\r\n    }\r\n    return [leavingRecords, updatingRecords, enteringRecords];\r\n}\n\nfunction useRouter() {\r\n    return inject(routerKey);\r\n}\r\nfunction useRoute() {\r\n    return inject(routeLocationKey);\r\n}\n\nexport { NavigationFailureType, RouterLink, RouterView, START_LOCATION_NORMALIZED as START_LOCATION, createMemoryHistory, createRouter, createWebHashHistory, createWebHistory, isNavigationFailure, onBeforeRouteLeave, onBeforeRouteUpdate, parseQuery, stringifyQuery, useLink, useRoute, useRouter };\n","import { EMPTY_OBJ, isArray, isSymbol, extend, hasOwn, isObject, hasChanged, capitalize, toRawType, def, makeMap, isFunction, NOOP } from '@vue/shared';\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n    return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n    if (isEffect(fn)) {\r\n        fn = fn.raw;\r\n    }\r\n    const effect = createReactiveEffect(fn, options);\r\n    if (!options.lazy) {\r\n        effect();\r\n    }\r\n    return effect;\r\n}\r\nfunction stop(effect) {\r\n    if (effect.active) {\r\n        cleanup(effect);\r\n        if (effect.options.onStop) {\r\n            effect.options.onStop();\r\n        }\r\n        effect.active = false;\r\n    }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n    const effect = function reactiveEffect() {\r\n        if (!effect.active) {\r\n            return options.scheduler ? undefined : fn();\r\n        }\r\n        if (!effectStack.includes(effect)) {\r\n            cleanup(effect);\r\n            try {\r\n                enableTracking();\r\n                effectStack.push(effect);\r\n                activeEffect = effect;\r\n                return fn();\r\n            }\r\n            finally {\r\n                effectStack.pop();\r\n                resetTracking();\r\n                activeEffect = effectStack[effectStack.length - 1];\r\n            }\r\n        }\r\n    };\r\n    effect.id = uid++;\r\n    effect._isEffect = true;\r\n    effect.active = true;\r\n    effect.raw = fn;\r\n    effect.deps = [];\r\n    effect.options = options;\r\n    return effect;\r\n}\r\nfunction cleanup(effect) {\r\n    const { deps } = effect;\r\n    if (deps.length) {\r\n        for (let i = 0; i < deps.length; i++) {\r\n            deps[i].delete(effect);\r\n        }\r\n        deps.length = 0;\r\n    }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n    trackStack.push(shouldTrack);\r\n    shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n    trackStack.push(shouldTrack);\r\n    shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n    const last = trackStack.pop();\r\n    shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n    if (!shouldTrack || activeEffect === undefined) {\r\n        return;\r\n    }\r\n    let depsMap = targetMap.get(target);\r\n    if (!depsMap) {\r\n        targetMap.set(target, (depsMap = new Map()));\r\n    }\r\n    let dep = depsMap.get(key);\r\n    if (!dep) {\r\n        depsMap.set(key, (dep = new Set()));\r\n    }\r\n    if (!dep.has(activeEffect)) {\r\n        dep.add(activeEffect);\r\n        activeEffect.deps.push(dep);\r\n        if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n            activeEffect.options.onTrack({\r\n                effect: activeEffect,\r\n                target,\r\n                type,\r\n                key\r\n            });\r\n        }\r\n    }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n    const depsMap = targetMap.get(target);\r\n    if (!depsMap) {\r\n        // never been tracked\r\n        return;\r\n    }\r\n    const effects = new Set();\r\n    const add = (effectsToAdd) => {\r\n        if (effectsToAdd) {\r\n            effectsToAdd.forEach(effect => {\r\n                if (effect !== activeEffect || !shouldTrack) {\r\n                    effects.add(effect);\r\n                }\r\n            });\r\n        }\r\n    };\r\n    if (type === \"clear\" /* CLEAR */) {\r\n        // collection being cleared\r\n        // trigger all effects for target\r\n        depsMap.forEach(add);\r\n    }\r\n    else if (key === 'length' && isArray(target)) {\r\n        depsMap.forEach((dep, key) => {\r\n            if (key === 'length' || key >= newValue) {\r\n                add(dep);\r\n            }\r\n        });\r\n    }\r\n    else {\r\n        // schedule runs for SET | ADD | DELETE\r\n        if (key !== void 0) {\r\n            add(depsMap.get(key));\r\n        }\r\n        // also run for iteration key on ADD | DELETE | Map.SET\r\n        const isAddOrDelete = type === \"add\" /* ADD */ ||\r\n            (type === \"delete\" /* DELETE */ && !isArray(target));\r\n        if (isAddOrDelete ||\r\n            (type === \"set\" /* SET */ && target instanceof Map)) {\r\n            add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY));\r\n        }\r\n        if (isAddOrDelete && target instanceof Map) {\r\n            add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n        }\r\n    }\r\n    const run = (effect) => {\r\n        if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n            effect.options.onTrigger({\r\n                effect,\r\n                target,\r\n                key,\r\n                type,\r\n                newValue,\r\n                oldValue,\r\n                oldTarget\r\n            });\r\n        }\r\n        if (effect.options.scheduler) {\r\n            effect.options.scheduler(effect);\r\n        }\r\n        else {\r\n            effect();\r\n        }\r\n    };\r\n    effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n    .map(key => Symbol[key])\r\n    .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n    arrayInstrumentations[key] = function (...args) {\r\n        const arr = toRaw(this);\r\n        for (let i = 0, l = this.length; i < l; i++) {\r\n            track(arr, \"get\" /* GET */, i + '');\r\n        }\r\n        // we run the method using the original args first (which may be reactive)\r\n        const res = arr[key](...args);\r\n        if (res === -1 || res === false) {\r\n            // if that didn't work, run it again using raw values.\r\n            return arr[key](...args.map(toRaw));\r\n        }\r\n        else {\r\n            return res;\r\n        }\r\n    };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n    return function get(target, key, receiver) {\r\n        if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n            return !isReadonly;\r\n        }\r\n        else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n            return isReadonly;\r\n        }\r\n        else if (key === \"__v_raw\" /* RAW */ &&\r\n            receiver ===\r\n                (isReadonly\r\n                    ? target[\"__v_readonly\" /* READONLY */]\r\n                    : target[\"__v_reactive\" /* REACTIVE */])) {\r\n            return target;\r\n        }\r\n        const targetIsArray = isArray(target);\r\n        if (targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n            return Reflect.get(arrayInstrumentations, key, receiver);\r\n        }\r\n        const res = Reflect.get(target, key, receiver);\r\n        if (isSymbol(key)\r\n            ? builtInSymbols.has(key)\r\n            : key === `__proto__` || key === `__v_isRef`) {\r\n            return res;\r\n        }\r\n        if (!isReadonly) {\r\n            track(target, \"get\" /* GET */, key);\r\n        }\r\n        if (shallow) {\r\n            return res;\r\n        }\r\n        if (isRef(res)) {\r\n            // ref unwrapping, only for Objects, not for Arrays.\r\n            return targetIsArray ? res : res.value;\r\n        }\r\n        if (isObject(res)) {\r\n            // Convert returned value into a proxy as well. we do the isObject check\r\n            // here to avoid invalid value warning. Also need to lazy access readonly\r\n            // and reactive here to avoid circular dependency.\r\n            return isReadonly ? readonly(res) : reactive(res);\r\n        }\r\n        return res;\r\n    };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n    return function set(target, key, value, receiver) {\r\n        const oldValue = target[key];\r\n        if (!shallow) {\r\n            value = toRaw(value);\r\n            if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n                oldValue.value = value;\r\n                return true;\r\n            }\r\n        }\r\n        const hadKey = hasOwn(target, key);\r\n        const result = Reflect.set(target, key, value, receiver);\r\n        // don't trigger if target is something up in the prototype chain of original\r\n        if (target === toRaw(receiver)) {\r\n            if (!hadKey) {\r\n                trigger(target, \"add\" /* ADD */, key, value);\r\n            }\r\n            else if (hasChanged(value, oldValue)) {\r\n                trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n            }\r\n        }\r\n        return result;\r\n    };\r\n}\r\nfunction deleteProperty(target, key) {\r\n    const hadKey = hasOwn(target, key);\r\n    const oldValue = target[key];\r\n    const result = Reflect.deleteProperty(target, key);\r\n    if (result && hadKey) {\r\n        trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction has(target, key) {\r\n    const result = Reflect.has(target, key);\r\n    track(target, \"has\" /* HAS */, key);\r\n    return result;\r\n}\r\nfunction ownKeys(target) {\r\n    track(target, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n    return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n    get,\r\n    set,\r\n    deleteProperty,\r\n    has,\r\n    ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n    get: readonlyGet,\r\n    has,\r\n    ownKeys,\r\n    set(target, key) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n        }\r\n        return true;\r\n    },\r\n    deleteProperty(target, key) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n        }\r\n        return true;\r\n    }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n    get: shallowGet,\r\n    set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n    get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, wrap) {\r\n    target = toRaw(target);\r\n    const rawKey = toRaw(key);\r\n    if (key !== rawKey) {\r\n        track(target, \"get\" /* GET */, key);\r\n    }\r\n    track(target, \"get\" /* GET */, rawKey);\r\n    const { has, get } = getProto(target);\r\n    if (has.call(target, key)) {\r\n        return wrap(get.call(target, key));\r\n    }\r\n    else if (has.call(target, rawKey)) {\r\n        return wrap(get.call(target, rawKey));\r\n    }\r\n}\r\nfunction has$1(key) {\r\n    const target = toRaw(this);\r\n    const rawKey = toRaw(key);\r\n    if (key !== rawKey) {\r\n        track(target, \"has\" /* HAS */, key);\r\n    }\r\n    track(target, \"has\" /* HAS */, rawKey);\r\n    const has = getProto(target).has;\r\n    return has.call(target, key) || has.call(target, rawKey);\r\n}\r\nfunction size(target) {\r\n    target = toRaw(target);\r\n    track(target, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n    return Reflect.get(getProto(target), 'size', target);\r\n}\r\nfunction add(value) {\r\n    value = toRaw(value);\r\n    const target = toRaw(this);\r\n    const proto = getProto(target);\r\n    const hadKey = proto.has.call(target, value);\r\n    const result = proto.add.call(target, value);\r\n    if (!hadKey) {\r\n        trigger(target, \"add\" /* ADD */, value, value);\r\n    }\r\n    return result;\r\n}\r\nfunction set$1(key, value) {\r\n    value = toRaw(value);\r\n    const target = toRaw(this);\r\n    const { has, get, set } = getProto(target);\r\n    let hadKey = has.call(target, key);\r\n    if (!hadKey) {\r\n        key = toRaw(key);\r\n        hadKey = has.call(target, key);\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        checkIdentityKeys(target, has, key);\r\n    }\r\n    const oldValue = get.call(target, key);\r\n    const result = set.call(target, key, value);\r\n    if (!hadKey) {\r\n        trigger(target, \"add\" /* ADD */, key, value);\r\n    }\r\n    else if (hasChanged(value, oldValue)) {\r\n        trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction deleteEntry(key) {\r\n    const target = toRaw(this);\r\n    const { has, get, delete: del } = getProto(target);\r\n    let hadKey = has.call(target, key);\r\n    if (!hadKey) {\r\n        key = toRaw(key);\r\n        hadKey = has.call(target, key);\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        checkIdentityKeys(target, has, key);\r\n    }\r\n    const oldValue = get ? get.call(target, key) : undefined;\r\n    // forward the operation before queueing reactions\r\n    const result = del.call(target, key);\r\n    if (hadKey) {\r\n        trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction clear() {\r\n    const target = toRaw(this);\r\n    const hadItems = target.size !== 0;\r\n    const oldTarget = (process.env.NODE_ENV !== 'production')\r\n        ? target instanceof Map\r\n            ? new Map(target)\r\n            : new Set(target)\r\n        : undefined;\r\n    // forward the operation before queueing reactions\r\n    const result = getProto(target).clear.call(target);\r\n    if (hadItems) {\r\n        trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n    }\r\n    return result;\r\n}\r\nfunction createForEach(isReadonly, shallow) {\r\n    return function forEach(callback, thisArg) {\r\n        const observed = this;\r\n        const target = toRaw(observed);\r\n        const wrap = isReadonly ? toReadonly : shallow ? toShallow : toReactive;\r\n        !isReadonly && track(target, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n        // important: create sure the callback is\r\n        // 1. invoked with the reactive map as `this` and 3rd arg\r\n        // 2. the value received should be a corresponding reactive/readonly.\r\n        function wrappedCallback(value, key) {\r\n            return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n        }\r\n        return getProto(target).forEach.call(target, wrappedCallback);\r\n    };\r\n}\r\nfunction createIterableMethod(method, isReadonly, shallow) {\r\n    return function (...args) {\r\n        const target = toRaw(this);\r\n        const isMap = target instanceof Map;\r\n        const isPair = method === 'entries' || (method === Symbol.iterator && isMap);\r\n        const isKeyOnly = method === 'keys' && isMap;\r\n        const innerIterator = getProto(target)[method].apply(target, args);\r\n        const wrap = isReadonly ? toReadonly : shallow ? toShallow : toReactive;\r\n        !isReadonly &&\r\n            track(target, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n        // return a wrapped iterator which returns observed versions of the\r\n        // values emitted from the real iterator\r\n        return {\r\n            // iterator protocol\r\n            next() {\r\n                const { value, done } = innerIterator.next();\r\n                return done\r\n                    ? { value, done }\r\n                    : {\r\n                        value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n                        done\r\n                    };\r\n            },\r\n            // iterable protocol\r\n            [Symbol.iterator]() {\r\n                return this;\r\n            }\r\n        };\r\n    };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n    return function (...args) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n            console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n        }\r\n        return type === \"delete\" /* DELETE */ ? false : this;\r\n    };\r\n}\r\nconst mutableInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, toReactive);\r\n    },\r\n    get size() {\r\n        return size(this);\r\n    },\r\n    has: has$1,\r\n    add,\r\n    set: set$1,\r\n    delete: deleteEntry,\r\n    clear,\r\n    forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, toShallow);\r\n    },\r\n    get size() {\r\n        return size(this);\r\n    },\r\n    has: has$1,\r\n    add,\r\n    set: set$1,\r\n    delete: deleteEntry,\r\n    clear,\r\n    forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, toReadonly);\r\n    },\r\n    get size() {\r\n        return size(this);\r\n    },\r\n    has: has$1,\r\n    add: createReadonlyMethod(\"add\" /* ADD */),\r\n    set: createReadonlyMethod(\"set\" /* SET */),\r\n    delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n    clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n    forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n    mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n    readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n    shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n    const instrumentations = shallow\r\n        ? shallowInstrumentations\r\n        : isReadonly\r\n            ? readonlyInstrumentations\r\n            : mutableInstrumentations;\r\n    return (target, key, receiver) => {\r\n        if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n            return !isReadonly;\r\n        }\r\n        else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n            return isReadonly;\r\n        }\r\n        else if (key === \"__v_raw\" /* RAW */) {\r\n            return target;\r\n        }\r\n        return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n            ? instrumentations\r\n            : target, key, receiver);\r\n    };\r\n}\r\nconst mutableCollectionHandlers = {\r\n    get: createInstrumentationGetter(false, false)\r\n};\r\nconst shallowCollectionHandlers = {\r\n    get: createInstrumentationGetter(false, true)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n    get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n    const rawKey = toRaw(key);\r\n    if (rawKey !== key && has.call(target, rawKey)) {\r\n        const type = toRawType(target);\r\n        console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n            `versions of the same object${type === `Map` ? `as keys` : ``}, ` +\r\n            `which can lead to inconsistencies. ` +\r\n            `Avoid differentiating between the raw and reactive versions ` +\r\n            `of an object and only use the reactive version if possible.`);\r\n    }\r\n}\n\nconst collectionTypes = new Set([Set, Map, WeakMap, WeakSet]);\r\nconst isObservableType = /*#__PURE__*/ makeMap('Object,Array,Map,Set,WeakMap,WeakSet');\r\nconst canObserve = (value) => {\r\n    return (!value[\"__v_skip\" /* SKIP */] &&\r\n        isObservableType(toRawType(value)) &&\r\n        !Object.isFrozen(value));\r\n};\r\nfunction reactive(target) {\r\n    // if trying to observe a readonly proxy, return the readonly version.\r\n    if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n        return target;\r\n    }\r\n    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n// Return a reactive-copy of the original object, where only the root level\r\n// properties are reactive, and does NOT unwrap refs nor recursively convert\r\n// returned properties.\r\nfunction shallowReactive(target) {\r\n    return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers);\r\n}\r\nfunction readonly(target) {\r\n    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n// Return a reactive-copy of the original object, where only the root level\r\n// properties are readonly, and does NOT unwrap refs nor recursively convert\r\n// returned properties.\r\n// This is used for creating the props proxy object for stateful components.\r\nfunction shallowReadonly(target) {\r\n    return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n    if (!isObject(target)) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`value cannot be made reactive: ${String(target)}`);\r\n        }\r\n        return target;\r\n    }\r\n    // target is already a Proxy, return it.\r\n    // exception: calling readonly() on a reactive object\r\n    if (target[\"__v_raw\" /* RAW */] &&\r\n        !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n        return target;\r\n    }\r\n    // target already has corresponding Proxy\r\n    const reactiveFlag = isReadonly\r\n        ? \"__v_readonly\" /* READONLY */\r\n        : \"__v_reactive\" /* REACTIVE */;\r\n    if (hasOwn(target, reactiveFlag)) {\r\n        return target[reactiveFlag];\r\n    }\r\n    // only a whitelist of value types can be observed.\r\n    if (!canObserve(target)) {\r\n        return target;\r\n    }\r\n    const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers);\r\n    def(target, reactiveFlag, observed);\r\n    return observed;\r\n}\r\nfunction isReactive(value) {\r\n    if (isReadonly(value)) {\r\n        return isReactive(value[\"__v_raw\" /* RAW */]);\r\n    }\r\n    return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n    return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n    return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n    return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction markRaw(value) {\r\n    def(value, \"__v_skip\" /* SKIP */, true);\r\n    return value;\r\n}\n\nconst convert = (val) => isObject(val) ? reactive(val) : val;\r\nfunction isRef(r) {\r\n    return r ? r.__v_isRef === true : false;\r\n}\r\nfunction ref(value) {\r\n    return createRef(value);\r\n}\r\nfunction shallowRef(value) {\r\n    return createRef(value, true);\r\n}\r\nfunction createRef(rawValue, shallow = false) {\r\n    if (isRef(rawValue)) {\r\n        return rawValue;\r\n    }\r\n    let value = shallow ? rawValue : convert(rawValue);\r\n    const r = {\r\n        __v_isRef: true,\r\n        get value() {\r\n            track(r, \"get\" /* GET */, 'value');\r\n            return value;\r\n        },\r\n        set value(newVal) {\r\n            if (hasChanged(toRaw(newVal), rawValue)) {\r\n                rawValue = newVal;\r\n                value = shallow ? newVal : convert(newVal);\r\n                trigger(r, \"set\" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? { newValue: newVal } : void 0);\r\n            }\r\n        }\r\n    };\r\n    return r;\r\n}\r\nfunction triggerRef(ref) {\r\n    trigger(ref, \"set\" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? { newValue: ref.value } : void 0);\r\n}\r\nfunction unref(ref) {\r\n    return isRef(ref) ? ref.value : ref;\r\n}\r\nfunction customRef(factory) {\r\n    const { get, set } = factory(() => track(r, \"get\" /* GET */, 'value'), () => trigger(r, \"set\" /* SET */, 'value'));\r\n    const r = {\r\n        __v_isRef: true,\r\n        get value() {\r\n            return get();\r\n        },\r\n        set value(v) {\r\n            set(v);\r\n        }\r\n    };\r\n    return r;\r\n}\r\nfunction toRefs(object) {\r\n    if ((process.env.NODE_ENV !== 'production') && !isProxy(object)) {\r\n        console.warn(`toRefs() expects a reactive object but received a plain one.`);\r\n    }\r\n    const ret = {};\r\n    for (const key in object) {\r\n        ret[key] = toRef(object, key);\r\n    }\r\n    return ret;\r\n}\r\nfunction toRef(object, key) {\r\n    return {\r\n        __v_isRef: true,\r\n        get value() {\r\n            return object[key];\r\n        },\r\n        set value(newVal) {\r\n            object[key] = newVal;\r\n        }\r\n    };\r\n}\n\nfunction computed(getterOrOptions) {\r\n    let getter;\r\n    let setter;\r\n    if (isFunction(getterOrOptions)) {\r\n        getter = getterOrOptions;\r\n        setter = (process.env.NODE_ENV !== 'production')\r\n            ? () => {\r\n                console.warn('Write operation failed: computed value is readonly');\r\n            }\r\n            : NOOP;\r\n    }\r\n    else {\r\n        getter = getterOrOptions.get;\r\n        setter = getterOrOptions.set;\r\n    }\r\n    let dirty = true;\r\n    let value;\r\n    let computed;\r\n    const runner = effect(getter, {\r\n        lazy: true,\r\n        scheduler: () => {\r\n            if (!dirty) {\r\n                dirty = true;\r\n                trigger(computed, \"set\" /* SET */, 'value');\r\n            }\r\n        }\r\n    });\r\n    computed = {\r\n        __v_isRef: true,\r\n        [\"__v_isReadonly\" /* IS_READONLY */]: isFunction(getterOrOptions) || !getterOrOptions.set,\r\n        // expose effect so computed can be stopped\r\n        effect: runner,\r\n        get value() {\r\n            if (dirty) {\r\n                value = runner();\r\n                dirty = false;\r\n            }\r\n            track(computed, \"get\" /* GET */, 'value');\r\n            return value;\r\n        },\r\n        set value(newValue) {\r\n            setter(newValue);\r\n        }\r\n    };\r\n    return computed;\r\n}\n\nexport { ITERATE_KEY, computed, customRef, effect, enableTracking, isProxy, isReactive, isReadonly, isRef, markRaw, pauseTracking, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n"],"sourceRoot":""}