{"version":3,"sources":["webpack:///./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js"],"names":["stack","warn","msg","args","instance","length","component","appWarnHandler","appContext","config","warnHandler","trace","getComponentTrace","callWithErrorHandling","join","proxy","map","vnode","formatComponentName","type","warnArgs","push","formatTrace","console","currentVNode","normalizedStack","last","recurseCount","parentInstance","parent","logs","forEach","entry","i","formatTraceEntry","postfix","isRoot","open","close","props","formatProps","res","keys","Object","slice","key","formatProp","value","raw","JSON","stringify","name","fn","err","handleError","callWithAsyncErrorHandling","catch","values","throwInDev","contextVNode","cur","exposedInstance","errorInfo","errorCapturedHooks","ec","appErrorHandler","errorHandler","logError","error","isFlushing","isFlushPending","queue","flushIndex","pendingPreFlushCbs","activePreFlushCbs","preFlushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","Promise","resolve","currentFlushPromise","currentPreFlushParentJob","nextTick","p","then","this","bind","findInsertionIndex","job","start","end","jobId","getId","middle","middleJobId","queueJob","includes","allowRecurse","pos","splice","queueFlush","flushJobs","invalidateJob","indexOf","queueCb","cb","activeQueue","pendingQueue","index","queuePreFlushCb","queuePostFlushCb","flushPreFlushCbs","seen","parentJob","Set","flushPostFlushCbs","deduped","sort","a","b","id","Infinity","Map","devtools","setDevtoolsHook","hook","emit","event","rawArgs","isModelListener","startsWith","modelArg","modifiersKey","number","trim","handlerName","handler","onceHandler","emitted","normalizeEmitsOptions","comp","asMixin","deopt","undefined","__emits","emits","normalized","hasExtends","extendEmits","normalizedFromExtend","mixins","extends","isEmitListener","options","replace","toLowerCase","isRenderingCompiledSlot","setCompiledSlotRendering","n","renderSlot","slots","fallback","noSlotted","slot","openBlock","validSlotContent","ensureValidVNode","rendered","createBlock","Fragment","_","scopeId","slotScopeIds","vnodes","some","child","isVNode","Comment","children","currentRenderingInstance","currentScopeId","setCurrentRenderingInstance","prev","__scopeId","pushScopeId","popScopeId","withScopeId","_id","withCtx","ctx","renderFnWithContext","prevInstance","closeBlock","_c","renderComponentRoot","Component","withProxy","propsOptions","attrs","render","renderCache","data","setupState","result","fallthroughAttrs","shapeFlag","proxyToUse","normalizeVNode","call","getFunctionalFallthrough","root","inheritAttrs","filterModelListeners","cloneVNode","dirs","concat","transition","blockStack","createVNode","filterSingleRoot","singleRoot","shouldUpdateComponent","prevVNode","nextVNode","optimized","prevProps","prevChildren","nextProps","nextChildren","patchFlag","emitsOptions","$stable","hasPropsChanged","dynamicProps","nextKeys","updateHOCHostEl","el","subTree","isSuspense","__isSuspense","SuspenseImpl","n1","n2","container","anchor","parentComponent","parentSuspense","isSVG","rendererInternals","mountSuspense","patchSuspense","hydrate","hydrateSuspense","create","createSuspenseBoundary","Suspense","patch","o","createElement","hiddenContainer","suspense","pendingBranch","ssContent","deps","ssFallback","setActiveBranch","um","unmount","newBranch","newFallback","activeBranch","isInFallback","isHydrating","isSameVNodeType","pendingId","effects","onPending","timeout","setTimeout","m","move","next","parentNode","remove","isUnmounted","resume","delayEnter","mode","afterLeave","hasUnresolvedAncestor","onResolve","fallbackVNode","onFallback","mountFallback","setupRenderEffect","isInPendingSuspense","hydratedEl","asyncDep","asyncSetupResult","suspenseId","asyncResolved","handleSetupResult","placeholder","doRemove","node","hydrateNode","document","normalizeSuspenseChildren","content","normalizeSuspenseSlot","default","s","singleChild","queueEffectWithSuspense","branch","initProps","rawProps","isStateful","isSSR","InternalObjectKey","propsDefaults","setFullProps","updateProps","rawPrevProps","rawCurrentProps","kebabKey","resolvePropValue","propsToUpdate","camelizedKey","needCastKeys","camelKey","opt","hasDefault","defaultValue","Function","setCurrentInstance","normalizePropsOptions","__props","extendProps","normalizedKey","validatePropName","prop","booleanIndex","getTypeIndex","Boolean","stringIndex","String","getType","ctor","match","toString","isSameType","expectedTypes","findIndex","t","injectHook","target","currentInstance","prepend","hooks","wrappedHook","__weh","unshift","createHook","lifecycle","isInSSRComponentSetup","onBeforeMount","onMounted","onBeforeUpdate","onUpdated","onBeforeUnmount","onUnmounted","onRenderTriggered","onRenderTracked","onErrorCaptured","watchEffect","effect","doWatch","INITIAL_WATCHER_VALUE","watch","source","immediate","deep","flush","onTrack","onTrigger","getter","cleanup","forceTrigger","_shallow","traverse","onInvalidate","baseGetter","runner","onStop","oldValue","active","newValue","scheduler","queuePostRenderEffect","isMounted","lazy","recordInstanceBoundEffect","instanceWatch","publicThis","has","add","v","useTransitionState","state","isLeaving","isUnmounting","leavingVNodes","TransitionHookValidator","Array","BaseTransitionImpl","appear","persisted","onBeforeEnter","onEnter","onAfterEnter","onEnterCancelled","onBeforeLeave","onLeave","onAfterLeave","onLeaveCancelled","onBeforeAppear","onAppear","onAfterAppear","onAppearCancelled","getCurrentInstance","prevTransitionKey","getTransitionRawChildren","emptyPlaceholder","innerChild","getKeepAliveChild","enterHooks","resolveTransitionHooks","setTransitionHooks","oldChild","oldInnerChild","transitionKeyChanged","getTransitionKey","leavingHooks","update","delayLeave","earlyRemove","delayedLeave","leavingVNodesCache","getLeavingNodesForType","_leaveCb","BaseTransition","get","set","callHook","leavingVNode","afterHook","cancelHook","called","done","_enterCb","cancelled","isKeepAlive","clone","keepComment","ret","keyedFragmentCount","__isKeepAlive","KeepAliveImpl","include","RegExp","exclude","max","Number","sharedContext","renderer","cache","current","_unmount","storageContainer","resetShapeFlag","pruneCache","filter","getComponentName","pruneCacheEntry","cached","delete","activate","isDeactivated","vnodeHook","onVnodeMounted","invokeVNodeHook","deactivate","da","onVnodeUnmounted","matches","pendingCacheKey","cacheSubtree","getInnerChild","rawVNode","cachedVNode","size","parseInt","KeepAlive","pattern","split","test","onActivated","registerKeepAliveHook","onDeactivated","__wdc","injectToKeepAliveRoot","keepAliveRoot","injected","isInternalKey","normalizeSlotValue","normalizeSlot","rawSlot","normalizeObjectSlots","rawSlots","_ctx","normalizeVNodeSlots","initSlots","updateSlots","needDeletionCheck","deletionComparisonTarget","withDirectives","directives","internalInstance","bindings","dir","arg","modifiers","mounted","updated","invokeDirectiveHook","oldBindings","binding","createAppContext","app","isNativeTag","performance","globalProperties","optionMergeStrategies","isCustomElement","components","provides","uid","createAppAPI","rootComponent","rootProps","context","installedPlugins","_uid","_component","_props","_container","_context","version","plugin","install","mixin","directive","rootContainer","isHydrate","__vue_app__","hasMismatch","isSVGContainer","namespaceURI","tagName","isComment","nodeType","createHydrationFunctions","mt","mountComponent","patchProp","nextSibling","insert","createComment","firstChild","isFragmentStart","onMismatch","handleMismatch","ref","domType","nextNode","Text","Static","needToAdoptContent","staticCount","outerHTML","hydrateFragment","hydrateElement","hydrateComponent","loadAsync","__asyncLoader","locateClosingAsyncAnchor","hydrateChildren","setRef","dynamicChildren","onClick","vnodeHooks","onVnodeBeforeMount","innerHTML","textContent","parentVNode","l","fragmentSlotScopeIds","isFragment","initFeatureFlags","defineComponent","setup","isAsyncWrapper","defineAsyncComponent","loader","loadingComponent","errorComponent","delay","suspensible","onError","userOnError","resolvedComp","pendingRequest","retries","retry","load","thisRequest","Error","reject","userRetry","userFail","__esModule","Symbol","toStringTag","createInnerComp","loaded","delayed","prodEffectOptions","rawRef","oldRawRef","r","exposed","owner","oldRef","refs","doSet","createRenderer","baseCreateRenderer","createHydrationRenderer","createHydrationFns","hostInsert","hostRemove","hostPatchProp","forcePatchProp","hostForcePatchProp","hostCreateElement","createText","hostCreateText","hostCreateComment","setText","hostSetText","setElementText","hostSetElementText","hostParentNode","hostNextSibling","setScopeId","hostSetScopeId","cloneNode","hostCloneNode","insertStaticContent","hostInsertStaticContent","getNextHostNode","processText","processCommentNode","mountStaticNode","processFragment","processElement","processComponent","process","internals","moveStaticNode","removeStaticNode","mountElement","patchElement","is","mountChildren","unmountChildren","needCallTransitionHooks","beforeEnter","enter","cloneIfMounted","oldProps","newProps","onVnodeBeforeUpdate","patchProps","class","style","areChildrenSVG","patchBlockChildren","patchChildren","onVnodeUpdated","oldChildren","newChildren","fallbackContainer","oldVNode","newVNode","fragmentStartAnchor","fragmentEndAnchor","traverseStaticChildren","updateComponent","initialVNode","createComponentInstance","setupComponent","registerDep","updateComponentPreRender","bu","u","originNext","nextTree","prevTree","bm","scopedInitialVNode","c1","prevShapeFlag","c2","patchKeyedChildren","patchUnkeyedChildren","oldLength","newLength","commonLength","Math","min","nextChild","parentAnchor","l2","e1","e2","nextPos","s1","s2","keyToNewIndexMap","j","patched","toBePatched","moved","maxNewIndexSoFar","newIndexToOldIndexMap","prevChild","newIndex","increasingNewIndexSequence","getSequence","nextIndex","moveType","needTransition","leave","performLeave","shouldInvokeDirs","onVnodeBeforeUnmount","unmountComponent","removeFragment","performRemove","bum","_vnode","mc","pc","pbc","createApp","shallow","ch1","ch2","arr","c","len","arrI","isTeleport","__isTeleport","isTeleportDisabled","disabled","isTargetSVG","SVGElement","resolveTarget","select","targetSelector","to","TeleportImpl","querySelector","mainAnchor","targetAnchor","mount","wasDisabled","currentContainer","currentAnchor","moveTeleport","nextTarget","hydrateTeleport","isReorder","targetNode","_lpa","Teleport","COMPONENTS","DIRECTIVES","resolveComponent","maybeSelfReference","resolveAsset","NULL_DYNAMIC_COMPONENT","resolveDynamicComponent","resolveDirective","warnMissing","selfName","registry","currentBlock","disableTracking","pop","vnodeArgsTransformer","shouldTrack","setBlockTracking","__v_isVNode","transformVNodeArgs","transformer","normalizeKey","normalizeRef","_createVNode","isBlockNode","cloned","normalizeChildren","isClassComponent","__vccOpts","klass","extraProps","mergeRef","mergedProps","mergeProps","createTextVNode","text","flag","createStaticVNode","numberOfNodes","createCommentVNode","asBlock","slotFlag","toMerge","existing","incoming","provide","parentProvides","inject","treatDefaultAsFactory","arguments","shouldCacheAccess","applyOptions","deferredData","deferredWatch","deferredProvide","extendsOptions","dataOptions","computed","computedOptions","methods","watchOptions","provideOptions","injectOptions","beforeMount","beforeUpdate","activated","deactivated","beforeDestroy","beforeUnmount","destroyed","unmounted","renderTracked","renderTriggered","errorCaptured","expose","globalMixins","callSyncHook","applyMixins","from","methodHandler","dataFn","resolveData","defineProperty","enumerable","configurable","createWatcher","Reflect","ownKeys","callHookWithMixinAndExtends","base","selfHook","createPathGetter","path","segments","resolveMergedOptions","__merged","mergeOptions","strats","getPublicInstance","isStatefulComponent","publicPropertiesMap","$","$el","$data","$props","$attrs","$slots","$refs","$parent","$root","$emit","$options","$forceUpdate","$nextTick","$watch","PublicInstanceProxyHandlers","accessCache","normalizedProps","publicGetter","cssModule","__cssModules","RuntimeCompiledPublicInstanceProxyHandlers","unscopables","emptyAppContext","uid$1","setupContext","bc","rtg","rtc","compile","setupResult","setupStatefulComponent","Proxy","createSetupContext","resolvedResult","e","finishComponentSetup","isRuntimeOnly","registerRuntimeCompiler","_compile","template","delimiters","_rc","classifyRE","classify","str","toUpperCase","displayName","__file","inferFromRegistry","getterOrOptions","defineProps","defineEmit","useContext","h","propsOrChildren","prototype","ssrContextKey","useSSRContext","initCustomFormatter","renderList","renderItem","iterator","toHandlers","obj","createSlots","dynamicSlots","ssrUtils"],"mappings":"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","file":"js/chunk-vendors~5ea1a303.2618804f.js","sourcesContent":["import { pauseTracking, resetTracking, isRef, toRaw, shallowReactive, trigger, isReactive, effect, stop, ref, isProxy, proxyRefs, toRef, reactive, shallowReadonly, track, computed as computed$1, isReadonly } from '@vue/reactivity';\nexport { customRef, isProxy, isReactive, isReadonly, isRef, markRaw, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref } from '@vue/reactivity';\nimport { isString, isFunction, isPromise, isArray, extend, EMPTY_OBJ, toHandlerKey, toNumber, hyphenate, camelize, isOn, hasOwn, isModelListener, def, isReservedProp, EMPTY_ARR, isObject, capitalize, toRawType, makeMap, remove, NOOP, hasChanged, isSet, isMap, invokeArrayFns, NO, getGlobalThis, normalizeClass, normalizeStyle, isGloballyWhitelisted } from '@vue/shared';\nexport { camelize, capitalize, toDisplayString, toHandlerKey } 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, throwInDev = true) {\r\n    const contextVNode = instance ? instance.vnode : null;\r\n    if (instance) {\r\n        let cur = instance.parent;\r\n        // the exposed instance is the render proxy to keep it consistent with 2.x\r\n        const exposedInstance = instance.proxy;\r\n        // in production the hook receives only the error code\r\n        const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n        while (cur) {\r\n            const errorCapturedHooks = cur.ec;\r\n            if (errorCapturedHooks) {\r\n                for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n                    if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n                        return;\r\n                    }\r\n                }\r\n            }\r\n            cur = cur.parent;\r\n        }\r\n        // app-level handling\r\n        const appErrorHandler = instance.appContext.config.errorHandler;\r\n        if (appErrorHandler) {\r\n            callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n            return;\r\n        }\r\n    }\r\n    logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const info = ErrorTypeStrings[type];\r\n        if (contextVNode) {\r\n            pushWarningContext(contextVNode);\r\n        }\r\n        warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n        if (contextVNode) {\r\n            popWarningContext();\r\n        }\r\n        // crash in dev by default so it's more noticeable\r\n        if (throwInDev) {\r\n            throw err;\r\n        }\r\n        else {\r\n            console.error(err);\r\n        }\r\n    }\r\n    else {\r\n        // recover in prod to reduce the impact on end-user\r\n        console.error(err);\r\n    }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n    const p = currentFlushPromise || resolvedPromise;\r\n    return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\n// #2768\r\n// Use binary-search to find a suitable position in the queue,\r\n// so that the queue maintains the increasing order of job's id,\r\n// which can prevent the job from being skipped and also can avoid repeated patching.\r\nfunction findInsertionIndex(job) {\r\n    // the start index should be `flushIndex + 1`\r\n    let start = flushIndex + 1;\r\n    let end = queue.length;\r\n    const jobId = getId(job);\r\n    while (start < end) {\r\n        const middle = (start + end) >>> 1;\r\n        const middleJobId = getId(queue[middle]);\r\n        middleJobId < jobId ? (start = middle + 1) : (end = middle);\r\n    }\r\n    return start;\r\n}\r\nfunction queueJob(job) {\r\n    // the dedupe search uses the startIndex argument of Array.includes()\r\n    // by default the search index includes the current job that is being run\r\n    // so it cannot recursively trigger itself again.\r\n    // if the job is a watch() callback, the search will start with a +1 index to\r\n    // allow it recursively trigger itself - it is the user's responsibility to\r\n    // ensure it doesn't end up in an infinite loop.\r\n    if ((!queue.length ||\r\n        !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n        job !== currentPreFlushParentJob) {\r\n        const pos = findInsertionIndex(job);\r\n        if (pos > -1) {\r\n            queue.splice(pos, 0, job);\r\n        }\r\n        else {\r\n            queue.push(job);\r\n        }\r\n        queueFlush();\r\n    }\r\n}\r\nfunction queueFlush() {\r\n    if (!isFlushing && !isFlushPending) {\r\n        isFlushPending = true;\r\n        currentFlushPromise = resolvedPromise.then(flushJobs);\r\n    }\r\n}\r\nfunction invalidateJob(job) {\r\n    const i = queue.indexOf(job);\r\n    if (i > flushIndex) {\r\n        queue.splice(i, 1);\r\n    }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n    if (!isArray(cb)) {\r\n        if (!activeQueue ||\r\n            !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n            pendingQueue.push(cb);\r\n        }\r\n    }\r\n    else {\r\n        // if cb is an array, it is a component lifecycle hook which can only be\r\n        // triggered by a job, which is already deduped in the main queue, so\r\n        // we can skip duplicate check here to improve perf\r\n        pendingQueue.push(...cb);\r\n    }\r\n    queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n    queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n    queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n    if (pendingPreFlushCbs.length) {\r\n        currentPreFlushParentJob = parentJob;\r\n        activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n        pendingPreFlushCbs.length = 0;\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            seen = seen || new Map();\r\n        }\r\n        for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n            }\r\n            activePreFlushCbs[preFlushIndex]();\r\n        }\r\n        activePreFlushCbs = null;\r\n        preFlushIndex = 0;\r\n        currentPreFlushParentJob = null;\r\n        // recursively flush until it drains\r\n        flushPreFlushCbs(seen, parentJob);\r\n    }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n    if (pendingPostFlushCbs.length) {\r\n        const deduped = [...new Set(pendingPostFlushCbs)];\r\n        pendingPostFlushCbs.length = 0;\r\n        // #1947 already has active queue, nested flushPostFlushCbs call\r\n        if (activePostFlushCbs) {\r\n            activePostFlushCbs.push(...deduped);\r\n            return;\r\n        }\r\n        activePostFlushCbs = deduped;\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            seen = seen || new Map();\r\n        }\r\n        activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n        for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n            }\r\n            activePostFlushCbs[postFlushIndex]();\r\n        }\r\n        activePostFlushCbs = null;\r\n        postFlushIndex = 0;\r\n    }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n    isFlushPending = false;\r\n    isFlushing = true;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        seen = seen || new Map();\r\n    }\r\n    flushPreFlushCbs(seen);\r\n    // Sort queue before flush.\r\n    // This ensures that:\r\n    // 1. Components are updated from parent to child. (because parent is always\r\n    //    created before the child so its render effect will have smaller\r\n    //    priority number)\r\n    // 2. If a component is unmounted during a parent component's update,\r\n    //    its update can be skipped.\r\n    queue.sort((a, b) => getId(a) - getId(b));\r\n    try {\r\n        for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n            const job = queue[flushIndex];\r\n            if (job) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    checkRecursiveUpdates(seen, job);\r\n                }\r\n                callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n            }\r\n        }\r\n    }\r\n    finally {\r\n        flushIndex = 0;\r\n        queue.length = 0;\r\n        flushPostFlushCbs(seen);\r\n        isFlushing = false;\r\n        currentFlushPromise = null;\r\n        // some postFlushCb queued jobs!\r\n        // keep flushing until it drains.\r\n        if (queue.length || pendingPostFlushCbs.length) {\r\n            flushJobs(seen);\r\n        }\r\n    }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n    if (!seen.has(fn)) {\r\n        seen.set(fn, 1);\r\n    }\r\n    else {\r\n        const count = seen.get(fn);\r\n        if (count > RECURSION_LIMIT) {\r\n            throw new Error(`Maximum recursive updates exceeded. ` +\r\n                `This means you have a reactive effect that is mutating its own ` +\r\n                `dependencies and thus recursively triggering itself. Possible sources ` +\r\n                `include component template, render function, updated hook or ` +\r\n                `watcher source function.`);\r\n        }\r\n        else {\r\n            seen.set(fn, count + 1);\r\n        }\r\n    }\r\n}\n\n/* eslint-disable no-restricted-globals */\r\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, instance.type);\r\n        record = map.get(id);\r\n    }\r\n    record.instances.add(instance);\r\n}\r\nfunction unregisterHMR(instance) {\r\n    map.get(instance.type.__hmrId).instances.delete(instance);\r\n}\r\nfunction createRecord(id, component) {\r\n    if (!component) {\r\n        warn(`HMR API usage is out of date.\\n` +\r\n            `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +\r\n            `dependency that handles Vue SFC compilation.`);\r\n        component = {};\r\n    }\r\n    if (map.has(id)) {\r\n        return false;\r\n    }\r\n    map.set(id, {\r\n        component: isClassComponent(component) ? component.__vccOpts : component,\r\n        instances: new Set()\r\n    });\r\n    return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n    const record = map.get(id);\r\n    if (!record)\r\n        return;\r\n    if (newRender)\r\n        record.component.render = newRender;\r\n    // Array.from creates a snapshot which avoids the set being mutated during\r\n    // updates\r\n    Array.from(record.instances).forEach(instance => {\r\n        if (newRender) {\r\n            instance.render = newRender;\r\n        }\r\n        instance.renderCache = [];\r\n        // 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    const { component, instances } = record;\r\n    if (!hmrDirtyComponents.has(component)) {\r\n        // 1. Update existing comp definition to match new one\r\n        newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;\r\n        extend(component, newComp);\r\n        for (const key in component) {\r\n            if (!(key in newComp)) {\r\n                delete component[key];\r\n            }\r\n        }\r\n        // 2. Mark component dirty. This forces the renderer to replace the component\r\n        // on patch.\r\n        hmrDirtyComponents.add(component);\r\n        // 3. Make sure to unmark the component after the reload.\r\n        queuePostFlushCb(() => {\r\n            hmrDirtyComponents.delete(component);\r\n        });\r\n    }\r\n    Array.from(instances).forEach(instance => {\r\n        if (instance.parent) {\r\n            // 4. Force the parent instance to re-render. This will cause all updated\r\n            // components to be unmounted and re-mounted. Queue the update so that we\r\n            // don't end up forcing the same parent to re-render multiple times.\r\n            queueJob(instance.parent.update);\r\n        }\r\n        else if (instance.appContext.reload) {\r\n            // root instance mounted via createApp() has a reload method\r\n            instance.appContext.reload();\r\n        }\r\n        else if (typeof window !== 'undefined') {\r\n            // root instance inside tree created via raw render(). Force reload.\r\n            window.location.reload();\r\n        }\r\n        else {\r\n            console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n        }\r\n    });\r\n}\r\nfunction tryWrap(fn) {\r\n    return (id, arg) => {\r\n        try {\r\n            return fn(id, arg);\r\n        }\r\n        catch (e) {\r\n            console.error(e);\r\n            console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n                `Full reload required.`);\r\n        }\r\n    };\r\n}\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__*/ createDevtoolsComponentHook(\"component:added\" /* COMPONENT_ADDED */);\r\nconst devtoolsComponentUpdated = /*#__PURE__*/ createDevtoolsComponentHook(\"component:updated\" /* COMPONENT_UPDATED */);\r\nconst devtoolsComponentRemoved = /*#__PURE__*/ createDevtoolsComponentHook(\"component:removed\" /* COMPONENT_REMOVED */);\r\nfunction createDevtoolsComponentHook(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, component);\r\n    };\r\n}\r\nfunction devtoolsComponentEmit(component, event, params) {\r\n    if (!devtools)\r\n        return;\r\n    devtools.emit(\"component:emit\" /* COMPONENT_EMIT */, component.appContext.app, component, event, params);\r\n}\n\nfunction emit(instance, event, ...rawArgs) {\r\n    const props = instance.vnode.props || EMPTY_OBJ;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const { emitsOptions, propsOptions: [propsOptions] } = instance;\r\n        if (emitsOptions) {\r\n            if (!(event in emitsOptions)) {\r\n                if (!propsOptions || !(toHandlerKey(event) in propsOptions)) {\r\n                    warn(`Component emitted event \"${event}\" but it is neither declared in ` +\r\n                        `the emits option nor as an \"${toHandlerKey(event)}\" prop.`);\r\n                }\r\n            }\r\n            else {\r\n                const validator = emitsOptions[event];\r\n                if (isFunction(validator)) {\r\n                    const isValid = validator(...rawArgs);\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 args = rawArgs;\r\n    const isModelListener = event.startsWith('update:');\r\n    // for v-model update:xxx events, apply modifiers on args\r\n    const modelArg = isModelListener && event.slice(7);\r\n    if (modelArg && modelArg in props) {\r\n        const modifiersKey = `${modelArg === 'modelValue' ? 'model' : modelArg}Modifiers`;\r\n        const { number, trim } = props[modifiersKey] || EMPTY_OBJ;\r\n        if (trim) {\r\n            args = rawArgs.map(a => a.trim());\r\n        }\r\n        else if (number) {\r\n            args = rawArgs.map(toNumber);\r\n        }\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n        devtoolsComponentEmit(instance, event, args);\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const lowerCaseEvent = event.toLowerCase();\r\n        if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) {\r\n            warn(`Event \"${lowerCaseEvent}\" is emitted in component ` +\r\n                `${formatComponentName(instance, instance.type)} but the handler is registered for \"${event}\". ` +\r\n                `Note that HTML attributes are case-insensitive and you cannot use ` +\r\n                `v-on to listen to camelCase events when using in-DOM templates. ` +\r\n                `You should probably use \"${hyphenate(event)}\" instead of \"${event}\".`);\r\n        }\r\n    }\r\n    let handlerName;\r\n    let handler = props[(handlerName = toHandlerKey(event))] ||\r\n        // also try camelCase event handler (#2249)\r\n        props[(handlerName = toHandlerKey(camelize(event)))];\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 && isModelListener) {\r\n        handler = props[(handlerName = toHandlerKey(hyphenate(event)))];\r\n    }\r\n    if (handler) {\r\n        callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);\r\n    }\r\n    const onceHandler = props[handlerName + `Once`];\r\n    if (onceHandler) {\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        callWithAsyncErrorHandling(onceHandler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);\r\n    }\r\n}\r\nfunction normalizeEmitsOptions(comp, appContext, asMixin = false) {\r\n    if (!appContext.deopt && comp.__emits !== undefined) {\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        const extendEmits = (raw) => {\r\n            const normalizedFromExtend = normalizeEmitsOptions(raw, appContext, true);\r\n            if (normalizedFromExtend) {\r\n                hasExtends = true;\r\n                extend(normalized, normalizedFromExtend);\r\n            }\r\n        };\r\n        if (!asMixin && appContext.mixins.length) {\r\n            appContext.mixins.forEach(extendEmits);\r\n        }\r\n        if (comp.extends) {\r\n            extendEmits(comp.extends);\r\n        }\r\n        if (comp.mixins) {\r\n            comp.mixins.forEach(extendEmits);\r\n        }\r\n    }\r\n    if (!raw && !hasExtends) {\r\n        return (comp.__emits = null);\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(options, key) {\r\n    if (!options || !isOn(key)) {\r\n        return false;\r\n    }\r\n    key = key.slice(2).replace(/Once$/, '');\r\n    return (hasOwn(options, key[0].toLowerCase() + key.slice(1)) ||\r\n        hasOwn(options, hyphenate(key)) ||\r\n        hasOwn(options, key));\r\n}\n\nlet isRenderingCompiledSlot = 0;\r\nconst setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);\r\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, noSlotted) {\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    // a compiled slot disables block tracking by default to avoid manual\r\n    // invocation interfering with template-based block tracking, but in\r\n    // `renderSlot` we can be sure that it's template-based so we can force\r\n    // enable it.\r\n    isRenderingCompiledSlot++;\r\n    openBlock();\r\n    const validSlotContent = slot && ensureValidVNode(slot(props));\r\n    const rendered = createBlock(Fragment, { key: props.key || `_${name}` }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 /* STABLE */\r\n        ? 64 /* STABLE_FRAGMENT */\r\n        : -2 /* BAIL */);\r\n    if (!noSlotted && rendered.scopeId) {\r\n        rendered.slotScopeIds = [rendered.scopeId + '-s'];\r\n    }\r\n    isRenderingCompiledSlot--;\r\n    return rendered;\r\n}\r\nfunction ensureValidVNode(vnodes) {\r\n    return vnodes.some(child => {\r\n        if (!isVNode(child))\r\n            return true;\r\n        if (child.type === Comment)\r\n            return false;\r\n        if (child.type === Fragment &&\r\n            !ensureValidVNode(child.children))\r\n            return false;\r\n        return true;\r\n    })\r\n        ? vnodes\r\n        : null;\r\n}\n\n/**\r\n * mark the current rendering instance for asset resolution (e.g.\r\n * resolveComponent, resolveDirective) during render\r\n */\r\nlet currentRenderingInstance = null;\r\nlet currentScopeId = null;\r\n/**\r\n * Note: rendering calls maybe nested. The function returns the parent rendering\r\n * instance if present, which should be restored after the render is done:\r\n *\r\n * ```js\r\n * const prev = setCurrentRenderingInstance(i)\r\n * // ...render\r\n * setCurrentRenderingInstance(prev)\r\n * ```\r\n */\r\nfunction setCurrentRenderingInstance(instance) {\r\n    const prev = currentRenderingInstance;\r\n    currentRenderingInstance = instance;\r\n    currentScopeId = (instance && instance.type.__scopeId) || null;\r\n    return prev;\r\n}\r\n/**\r\n * Set scope id when creating hoisted vnodes.\r\n * @private compiler helper\r\n */\r\nfunction pushScopeId(id) {\r\n    currentScopeId = id;\r\n}\r\n/**\r\n * Technically we no longer need this after 3.0.8 but we need to keep the same\r\n * API for backwards compat w/ code generated by compilers.\r\n * @private\r\n */\r\nfunction popScopeId() {\r\n    currentScopeId = null;\r\n}\r\n/**\r\n * Only for backwards compat\r\n * @private\r\n */\r\nconst withScopeId = (_id) => withCtx;\r\n/**\r\n * Wrap a slot function to memoize current rendering instance\r\n * @private compiler helper\r\n */\r\nfunction withCtx(fn, ctx = currentRenderingInstance) {\r\n    if (!ctx)\r\n        return fn;\r\n    const renderFnWithContext = (...args) => {\r\n        // If a user calls a compiled slot inside a template expression (#1745), it\r\n        // can mess up block tracking, so by default we need to push a null block to\r\n        // avoid that. This isn't necessary if rendering a compiled `<slot>`.\r\n        if (!isRenderingCompiledSlot) {\r\n            openBlock(true /* null block that disables tracking */);\r\n        }\r\n        const prevInstance = setCurrentRenderingInstance(ctx);\r\n        const res = fn(...args);\r\n        setCurrentRenderingInstance(prevInstance);\r\n        if (!isRenderingCompiledSlot) {\r\n            closeBlock();\r\n        }\r\n        return res;\r\n    };\r\n    // mark this as a compiled slot function.\r\n    // this is used in vnode.ts -> normalizeChildren() to set the slot\r\n    // rendering flag.\r\n    renderFnWithContext._c = true;\r\n    return renderFnWithContext;\r\n}\n\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\n */\r\nlet accessedAttrs = false;\r\nfunction markAttrsAccessed() {\r\n    accessedAttrs = true;\r\n}\r\nfunction renderComponentRoot(instance) {\r\n    const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, data, setupState, ctx } = instance;\r\n    let result;\r\n    const prev = setCurrentRenderingInstance(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            result.patchFlag > 0 &&\r\n            result.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */) {\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 (propsOptions && keys.some(isModelListener)) {\r\n                        // If a v-model listener (onUpdate:xxx) has a corresponding declared\r\n                        // prop, it indicates this component expects to handle v-model and\r\n                        // it should not fallthrough.\r\n                        // related: #1543, #1643, #1989\r\n                        fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);\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 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 = root.dirs ? root.dirs.concat(vnode.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        blockStack.length = 0;\r\n        handleError(err, instance, 1 /* RENDER_FUNCTION */);\r\n        result = createVNode(Comment);\r\n    }\r\n    setCurrentRenderingInstance(prev);\r\n    return result;\r\n}\r\n/**\r\n * dev only\r\n * In dev mode, template root level comments are rendered, which turns the\r\n * template into a fragment root, but we need to locate the single element\r\n * root for attrs and scope id processing.\r\n */\r\nconst getChildRoot = (vnode) => {\r\n    const rawChildren = vnode.children;\r\n    const dynamicChildren = vnode.dynamicChildren;\r\n    const childRoot = filterSingleRoot(rawChildren);\r\n    if (!childRoot) {\r\n        return [vnode, undefined];\r\n    }\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 (dynamicChildren) {\r\n            if (dynamicIndex > -1) {\r\n                dynamicChildren[dynamicIndex] = updatedRoot;\r\n            }\r\n            else if (updatedRoot.patchFlag > 0) {\r\n                vnode.dynamicChildren = [...dynamicChildren, updatedRoot];\r\n            }\r\n        }\r\n    };\r\n    return [normalizeVNode(childRoot), setRoot];\r\n};\r\nfunction filterSingleRoot(children) {\r\n    let singleRoot;\r\n    for (let i = 0; i < children.length; i++) {\r\n        const child = children[i];\r\n        if (isVNode(child)) {\r\n            // ignore user comment\r\n            if (child.type !== Comment || child.children === 'v-if') {\r\n                if (singleRoot) {\r\n                    // has more than 1 non-comment child, return now\r\n                    return;\r\n                }\r\n                else {\r\n                    singleRoot = child;\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            return;\r\n        }\r\n    }\r\n    return singleRoot;\r\n}\r\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, props) => {\r\n    const res = {};\r\n    for (const key in attrs) {\r\n        if (!isModelListener(key) || !(key.slice(9) in props)) {\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, component } = prevVNode;\r\n    const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;\r\n    const emits = component.emitsOptions;\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, emits);\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                    !isEmitListener(emits, 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, emits);\r\n    }\r\n    return false;\r\n}\r\nfunction hasPropsChanged(prevProps, nextProps, emitsOptions) {\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            !isEmitListener(emitsOptions, 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    name: 'Suspense',\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, slotScopeIds, 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, slotScopeIds, optimized, rendererInternals);\r\n        }\r\n        else {\r\n            patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, rendererInternals);\r\n        }\r\n    },\r\n    hydrate: hydrateSuspense,\r\n    create: createSuspenseBoundary\r\n};\r\n// Force-casted public typing for h and TSX props inference\r\nconst Suspense = (SuspenseImpl\r\n    );\r\nfunction mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {\r\n    const { p: patch, o: { createElement } } = rendererInternals;\r\n    const hiddenContainer = createElement('div');\r\n    const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals));\r\n    // start mounting the content subtree in an off-dom container\r\n    patch(null, (suspense.pendingBranch = vnode.ssContent), hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds);\r\n    // now check if we have encountered any async deps\r\n    if (suspense.deps > 0) {\r\n        // has async\r\n        // mount the fallback tree\r\n        patch(null, vnode.ssFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context\r\n        isSVG, slotScopeIds);\r\n        setActiveBranch(suspense, vnode.ssFallback);\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, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {\r\n    const suspense = (n2.suspense = n1.suspense);\r\n    suspense.vnode = n2;\r\n    n2.el = n1.el;\r\n    const newBranch = n2.ssContent;\r\n    const newFallback = n2.ssFallback;\r\n    const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;\r\n    if (pendingBranch) {\r\n        suspense.pendingBranch = newBranch;\r\n        if (isSameVNodeType(newBranch, pendingBranch)) {\r\n            // same root type but content may have changed.\r\n            patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);\r\n            if (suspense.deps <= 0) {\r\n                suspense.resolve();\r\n            }\r\n            else if (isInFallback) {\r\n                patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context\r\n                isSVG, slotScopeIds, optimized);\r\n                setActiveBranch(suspense, newFallback);\r\n            }\r\n        }\r\n        else {\r\n            // toggled before pending tree is resolved\r\n            suspense.pendingId++;\r\n            if (isHydrating) {\r\n                // if toggled before hydration is finished, the current DOM tree is\r\n                // no longer valid. set it as the active branch so it will be unmounted\r\n                // when resolved\r\n                suspense.isHydrating = false;\r\n                suspense.activeBranch = pendingBranch;\r\n            }\r\n            else {\r\n                unmount(pendingBranch, parentComponent, suspense);\r\n            }\r\n            // increment pending ID. this is used to invalidate async callbacks\r\n            // reset suspense state\r\n            suspense.deps = 0;\r\n            // discard effects from pending branch\r\n            suspense.effects.length = 0;\r\n            // discard previous container\r\n            suspense.hiddenContainer = createElement('div');\r\n            if (isInFallback) {\r\n                // already in fallback state\r\n                patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);\r\n                if (suspense.deps <= 0) {\r\n                    suspense.resolve();\r\n                }\r\n                else {\r\n                    patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context\r\n                    isSVG, slotScopeIds, optimized);\r\n                    setActiveBranch(suspense, newFallback);\r\n                }\r\n            }\r\n            else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {\r\n                // toggled \"back\" to current active branch\r\n                patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized);\r\n                // force resolve\r\n                suspense.resolve(true);\r\n            }\r\n            else {\r\n                // switched to a 3rd branch\r\n                patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);\r\n                if (suspense.deps <= 0) {\r\n                    suspense.resolve();\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {\r\n            // root did not change, just normal patch\r\n            patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized);\r\n            setActiveBranch(suspense, newBranch);\r\n        }\r\n        else {\r\n            // root node toggled\r\n            // invoke @pending event\r\n            const onPending = n2.props && n2.props.onPending;\r\n            if (isFunction(onPending)) {\r\n                onPending();\r\n            }\r\n            // mount pending branch in off-dom container\r\n            suspense.pendingBranch = newBranch;\r\n            suspense.pendingId++;\r\n            patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);\r\n            if (suspense.deps <= 0) {\r\n                // incoming branch has no async deps, resolve now.\r\n                suspense.resolve();\r\n            }\r\n            else {\r\n                const { timeout, pendingId } = suspense;\r\n                if (timeout > 0) {\r\n                    setTimeout(() => {\r\n                        if (suspense.pendingId === pendingId) {\r\n                            suspense.fallback(newFallback);\r\n                        }\r\n                    }, timeout);\r\n                }\r\n                else if (timeout === 0) {\r\n                    suspense.fallback(newFallback);\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\nlet hasWarned = false;\r\nfunction createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, 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, remove } } = rendererInternals;\r\n    const timeout = toNumber(vnode.props && vnode.props.timeout);\r\n    const suspense = {\r\n        vnode,\r\n        parent,\r\n        parentComponent,\r\n        isSVG,\r\n        container,\r\n        hiddenContainer,\r\n        anchor,\r\n        deps: 0,\r\n        pendingId: 0,\r\n        timeout: typeof timeout === 'number' ? timeout : -1,\r\n        activeBranch: null,\r\n        pendingBranch: null,\r\n        isInFallback: true,\r\n        isHydrating,\r\n        isUnmounted: false,\r\n        effects: [],\r\n        resolve(resume = false) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                if (!resume && !suspense.pendingBranch) {\r\n                    throw new Error(`suspense.resolve() is called without a pending branch.`);\r\n                }\r\n                if (suspense.isUnmounted) {\r\n                    throw new Error(`suspense.resolve() is called on an already unmounted suspense boundary.`);\r\n                }\r\n            }\r\n            const { vnode, activeBranch, pendingBranch, pendingId, effects, parentComponent, container } = suspense;\r\n            if (suspense.isHydrating) {\r\n                suspense.isHydrating = false;\r\n            }\r\n            else if (!resume) {\r\n                const delayEnter = activeBranch &&\r\n                    pendingBranch.transition &&\r\n                    pendingBranch.transition.mode === 'out-in';\r\n                if (delayEnter) {\r\n                    activeBranch.transition.afterLeave = () => {\r\n                        if (pendingId === suspense.pendingId) {\r\n                            move(pendingBranch, container, anchor, 0 /* ENTER */);\r\n                        }\r\n                    };\r\n                }\r\n                // this is initial anchor on mount\r\n                let { anchor } = suspense;\r\n                // unmount current active tree\r\n                if (activeBranch) {\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(activeBranch);\r\n                    unmount(activeBranch, parentComponent, suspense, true);\r\n                }\r\n                if (!delayEnter) {\r\n                    // move content from off-dom container to actual container\r\n                    move(pendingBranch, container, anchor, 0 /* ENTER */);\r\n                }\r\n            }\r\n            setActiveBranch(suspense, pendingBranch);\r\n            suspense.pendingBranch = null;\r\n            suspense.isInFallback = false;\r\n            // flush buffered effects\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.pendingBranch) {\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.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        fallback(fallbackVNode) {\r\n            if (!suspense.pendingBranch) {\r\n                return;\r\n            }\r\n            const { vnode, activeBranch, parentComponent, container, isSVG } = suspense;\r\n            // invoke @fallback event\r\n            const onFallback = vnode.props && vnode.props.onFallback;\r\n            if (isFunction(onFallback)) {\r\n                onFallback();\r\n            }\r\n            const anchor = next(activeBranch);\r\n            const mountFallback = () => {\r\n                if (!suspense.isInFallback) {\r\n                    return;\r\n                }\r\n                // mount the fallback tree\r\n                patch(null, fallbackVNode, container, anchor, parentComponent, null, // fallback tree will not have suspense context\r\n                isSVG, slotScopeIds, optimized);\r\n                setActiveBranch(suspense, fallbackVNode);\r\n            };\r\n            const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === 'out-in';\r\n            if (delayEnter) {\r\n                activeBranch.transition.afterLeave = mountFallback;\r\n            }\r\n            // unmount current active branch\r\n            unmount(activeBranch, parentComponent, null, // no suspense so unmount hooks fire now\r\n            true // shouldRemove\r\n            );\r\n            suspense.isInFallback = true;\r\n            if (!delayEnter) {\r\n                mountFallback();\r\n            }\r\n        },\r\n        move(container, anchor, type) {\r\n            suspense.activeBranch &&\r\n                move(suspense.activeBranch, container, anchor, type);\r\n            suspense.container = container;\r\n        },\r\n        next() {\r\n            return suspense.activeBranch && next(suspense.activeBranch);\r\n        },\r\n        registerDep(instance, setupRenderEffect) {\r\n            const isInPendingSuspense = !!suspense.pendingBranch;\r\n            if (isInPendingSuspense) {\r\n                suspense.deps++;\r\n            }\r\n            const hydratedEl = instance.vnode.el;\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 ||\r\n                    suspense.isUnmounted ||\r\n                    suspense.pendingId !== instance.suspenseId) {\r\n                    return;\r\n                }\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, false);\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                const placeholder = !hydratedEl && instance.subTree.el;\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                parentNode(hydratedEl || 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                if (placeholder) {\r\n                    remove(placeholder);\r\n                }\r\n                updateHOCHostEl(instance, vnode.el);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    popWarningContext();\r\n                }\r\n                // only decrease deps count if suspense is not already resolved\r\n                if (isInPendingSuspense && --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            if (suspense.activeBranch) {\r\n                unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove);\r\n            }\r\n            if (suspense.pendingBranch) {\r\n                unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove);\r\n            }\r\n        }\r\n    };\r\n    return suspense;\r\n}\r\nfunction hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, 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, slotScopeIds, 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.pendingBranch = vnode.ssContent), parentComponent, suspense, slotScopeIds, 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    let content;\r\n    let fallback;\r\n    if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n        content = normalizeSuspenseSlot(children.default);\r\n        fallback = normalizeSuspenseSlot(children.fallback);\r\n    }\r\n    else {\r\n        content = normalizeSuspenseSlot(children);\r\n        fallback = normalizeVNode(null);\r\n    }\r\n    return {\r\n        content,\r\n        fallback\r\n    };\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n    if (isFunction(s)) {\r\n        s = s();\r\n    }\r\n    if (isArray(s)) {\r\n        const singleChild = filterSingleRoot(s);\r\n        if ((process.env.NODE_ENV !== 'production') && !singleChild) {\r\n            warn(`<Suspense> slots expect a single root node.`);\r\n        }\r\n        s = singleChild;\r\n    }\r\n    return normalizeVNode(s);\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n    if (suspense && suspense.pendingBranch) {\r\n        if (isArray(fn)) {\r\n            suspense.effects.push(...fn);\r\n        }\r\n        else {\r\n            suspense.effects.push(fn);\r\n        }\r\n    }\r\n    else {\r\n        queuePostFlushCb(fn);\r\n    }\r\n}\r\nfunction setActiveBranch(suspense, branch) {\r\n    suspense.activeBranch = branch;\r\n    const { vnode, parentComponent } = suspense;\r\n    const el = (vnode.el = branch.el);\r\n    // in case suspense is the root node of a component,\r\n    // recursively update the HOC el\r\n    if (parentComponent && parentComponent.subTree === vnode) {\r\n        parentComponent.vnode.el = el;\r\n        updateHOCHostEl(parentComponent, el);\r\n    }\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    instance.propsDefaults = Object.create(null);\r\n    setFullProps(instance, rawProps, props, attrs);\r\n    // validation\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        validateProps(rawProps || {}, props, instance);\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] = instance.propsOptions;\r\n    if (\r\n    // always force full diff in dev\r\n    // - #1942 if hmr is enabled with sfc component\r\n    // - vite#872 non-sfc component used by sfc component\r\n    !((process.env.NODE_ENV !== 'production') &&\r\n        (instance.type.__hmrId ||\r\n            (instance.parent && instance.parent.type.__hmrId))) &&\r\n        (optimized || patchFlag > 0) &&\r\n        !(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, instance);\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, instance);\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')) {\r\n        validateProps(rawProps || {}, props, instance);\r\n    }\r\n}\r\nfunction setFullProps(instance, rawProps, props, attrs) {\r\n    const [options, needCastKeys] = instance.propsOptions;\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.emitsOptions, 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], instance);\r\n        }\r\n    }\r\n}\r\nfunction resolvePropValue(options, props, key, value, instance) {\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            if (opt.type !== Function && isFunction(defaultValue)) {\r\n                const { propsDefaults } = instance;\r\n                if (key in propsDefaults) {\r\n                    value = propsDefaults[key];\r\n                }\r\n                else {\r\n                    setCurrentInstance(instance);\r\n                    value = propsDefaults[key] = defaultValue(props);\r\n                    setCurrentInstance(null);\r\n                }\r\n            }\r\n            else {\r\n                value = defaultValue;\r\n            }\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, appContext, asMixin = false) {\r\n    if (!appContext.deopt && 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            hasExtends = true;\r\n            const [props, keys] = normalizePropsOptions(raw, appContext, true);\r\n            extend(normalized, props);\r\n            if (keys)\r\n                needCastKeys.push(...keys);\r\n        };\r\n        if (!asMixin && appContext.mixins.length) {\r\n            appContext.mixins.forEach(extendProps);\r\n        }\r\n        if (comp.extends) {\r\n            extendProps(comp.extends);\r\n        }\r\n        if (comp.mixins) {\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    return (comp.__props = [normalized, needCastKeys]);\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// 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        return expectedTypes.findIndex(t => isSameType(t, type));\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(rawProps, props, instance) {\r\n    const resolvedValues = toRaw(props);\r\n    const options = instance.propsOptions[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, resolvedValues[key], opt, !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key)));\r\n    }\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,BigInt');\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 = isObject(value);\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        return wrappedHook;\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        const apiName = toHandlerKey(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\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    let forceTrigger = false;\r\n    if (isRef(source)) {\r\n        getter = () => source.value;\r\n        forceTrigger = !!source._shallow;\r\n    }\r\n    else if (isReactive(source)) {\r\n        getter = () => source;\r\n        deep = true;\r\n    }\r\n    else if (isArray(source)) {\r\n        getter = () => source.map(s => {\r\n            if (isRef(s)) {\r\n                return s.value;\r\n            }\r\n            else if (isReactive(s)) {\r\n                return traverse(s);\r\n            }\r\n            else if (isFunction(s)) {\r\n                return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */, [\r\n                    instance && instance.proxy\r\n                ]);\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                instance && instance.proxy\r\n            ]);\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 callWithAsyncErrorHandling(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    let onInvalidate = (fn) => {\r\n        cleanup = runner.options.onStop = () => {\r\n            callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n        };\r\n    };\r\n    let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n    const job = () => {\r\n        if (!runner.active) {\r\n            return;\r\n        }\r\n        if (cb) {\r\n            // watch(source, cb)\r\n            const newValue = runner();\r\n            if (deep || forceTrigger || hasChanged(newValue, oldValue)) {\r\n                // cleanup before running cb again\r\n                if (cleanup) {\r\n                    cleanup();\r\n                }\r\n                callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n                    newValue,\r\n                    // pass undefined as the old value when it's changed for the first time\r\n                    oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n                    onInvalidate\r\n                ]);\r\n                oldValue = newValue;\r\n            }\r\n        }\r\n        else {\r\n            // watchEffect\r\n            runner();\r\n        }\r\n    };\r\n    // important: mark the job as a watcher callback so that scheduler knows\r\n    // it is allowed to self-trigger (#1727)\r\n    job.allowRecurse = !!cb;\r\n    let scheduler;\r\n    if (flush === 'sync') {\r\n        scheduler = job;\r\n    }\r\n    else if (flush === 'post') {\r\n        scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n    }\r\n    else {\r\n        // default: 'pre'\r\n        scheduler = () => {\r\n            if (!instance || instance.isMounted) {\r\n                queuePreFlushCb(job);\r\n            }\r\n            else {\r\n                // with 'pre' option, the first call must happen before\r\n                // the component is mounted so it is called synchronously.\r\n                job();\r\n            }\r\n        };\r\n    }\r\n    const runner = effect(getter, {\r\n        lazy: true,\r\n        onTrack,\r\n        onTrigger,\r\n        scheduler\r\n    });\r\n    recordInstanceBoundEffect(runner, instance);\r\n    // initial run\r\n    if (cb) {\r\n        if (immediate) {\r\n            job();\r\n        }\r\n        else {\r\n            oldValue = runner();\r\n        }\r\n    }\r\n    else if (flush === 'post') {\r\n        queuePostRenderEffect(runner, instance && instance.suspense);\r\n    }\r\n    else {\r\n        runner();\r\n    }\r\n    return () => {\r\n        stop(runner);\r\n        if (instance) {\r\n            remove(instance.effects, runner);\r\n        }\r\n    };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n    const publicThis = this.proxy;\r\n    const getter = isString(source)\r\n        ? () => publicThis[source]\r\n        : source.bind(publicThis);\r\n    return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n    if (!isObject(value) || seen.has(value)) {\r\n        return value;\r\n    }\r\n    seen.add(value);\r\n    if (isRef(value)) {\r\n        traverse(value.value, seen);\r\n    }\r\n    else if (isArray(value)) {\r\n        for (let i = 0; i < value.length; i++) {\r\n            traverse(value[i], seen);\r\n        }\r\n    }\r\n    else if (isSet(value) || isMap(value)) {\r\n        value.forEach((v) => {\r\n            traverse(v, seen);\r\n        });\r\n    }\r\n    else {\r\n        for (const key in value) {\r\n            traverse(value[key], seen);\r\n        }\r\n    }\r\n    return value;\r\n}\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 TransitionHookValidator = [Function, Array];\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: TransitionHookValidator,\r\n        onEnter: TransitionHookValidator,\r\n        onAfterEnter: TransitionHookValidator,\r\n        onEnterCancelled: TransitionHookValidator,\r\n        // leave\r\n        onBeforeLeave: TransitionHookValidator,\r\n        onLeave: TransitionHookValidator,\r\n        onAfterLeave: TransitionHookValidator,\r\n        onLeaveCancelled: TransitionHookValidator,\r\n        // appear\r\n        onBeforeAppear: TransitionHookValidator,\r\n        onAppear: TransitionHookValidator,\r\n        onAfterAppear: TransitionHookValidator,\r\n        onAppearCancelled: TransitionHookValidator\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 = resolveTransitionHooks(innerChild, rawProps, state, instance);\r\n            setTransitionHooks(innerChild, enterHooks);\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' && innerChild.type !== Comment) {\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, props, state, instance) {\r\n    const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props;\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        mode,\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        clone(vnode) {\r\n            return resolveTransitionHooks(vnode, props, state, instance);\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 if (vnode.shapeFlag & 128 /* SUSPENSE */) {\r\n        vnode.ssContent.transition = hooks.clone(vnode.ssContent);\r\n        vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);\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-op\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    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 instance = getCurrentInstance();\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        // if the internal renderer is not registered, it indicates that this is server-side rendering,\r\n        // for KeepAlive, we just need to render its children\r\n        if (!sharedContext.renderer) {\r\n            return slots.default;\r\n        }\r\n        const cache = new Map();\r\n        const keys = new Set();\r\n        let current = null;\r\n        const parentSuspense = instance.suspense;\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, vnode.slotScopeIds, 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 = getComponentName(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        // prune cache on include/exclude prop change\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        // prune post-render after `current` has been updated\r\n        { flush: 'post', deep: true });\r\n        // cache sub tree after 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, getInnerChild(instance.subTree));\r\n            }\r\n        };\r\n        onMounted(cacheSubtree);\r\n        onUpdated(cacheSubtree);\r\n        onBeforeUnmount(() => {\r\n            cache.forEach(cached => {\r\n                const { subTree, suspense } = instance;\r\n                const vnode = getInnerChild(subTree);\r\n                if (cached.type === vnode.type) {\r\n                    // current instance will be unmounted as part of keep-alive's unmount\r\n                    resetShapeFlag(vnode);\r\n                    // but invoke its deactivated hook here\r\n                    const da = vnode.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            const rawVNode = 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(rawVNode) ||\r\n                (!(rawVNode.shapeFlag & 4 /* STATEFUL_COMPONENT */) &&\r\n                    !(rawVNode.shapeFlag & 128 /* SUSPENSE */))) {\r\n                current = null;\r\n                return rawVNode;\r\n            }\r\n            let vnode = getInnerChild(rawVNode);\r\n            const comp = vnode.type;\r\n            const name = getComponentName(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                current = vnode;\r\n                return rawVNode;\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                if (rawVNode.shapeFlag & 128 /* SUSPENSE */) {\r\n                    rawVNode.ssContent = vnode;\r\n                }\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 rawVNode;\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 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 wraps the original for error handling, so make sure to remove\r\n    // the wrapped version.\r\n    const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */);\r\n    onUnmounted(() => {\r\n        remove(keepAliveRoot[type], injected);\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}\r\nfunction getInnerChild(vnode) {\r\n    return vnode.shapeFlag & 128 /* SUSPENSE */ ? vnode.ssContent : vnode;\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, optimized) => {\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 (optimized && 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                // #2893\r\n                // when rendering the optimized slots by manually written render function,\r\n                // we need to delete the `slots._` flag if necessary to make subsequent updates reliable,\r\n                // i.e. let the `renderSlot` create the bailed Fragment\r\n                if (!optimized && type === 1 /* STABLE */) {\r\n                    delete slots._;\r\n                }\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\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\nlet uid = 0;\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            _uid: uid++,\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                        // global mixin with props/emits de-optimizes props/emits\r\n                        // normalization caching.\r\n                        if (mixin.props || mixin.emits) {\r\n                            context.deopt = true;\r\n                        }\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, isSVG) {\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, isSVG);\r\n                        };\r\n                    }\r\n                    if (isHydrate && hydrate) {\r\n                        hydrate(vnode, rootContainer);\r\n                    }\r\n                    else {\r\n                        render(vnode, rootContainer, isSVG);\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                    if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n                        devtoolsUnmountApp(app);\r\n                    }\r\n                    delete app._container.__vue_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, 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, slotScopeIds, optimized = false) => {\r\n        const isFragmentStart = isComment(node) && node.data === '[';\r\n        const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, 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, slotScopeIds, 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.toLowerCase() !==\r\n                            node.tagName.toLowerCase()) {\r\n                        nextNode = onMismatch();\r\n                    }\r\n                    else {\r\n                        nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, 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                    vnode.slotScopeIds = slotScopeIds;\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, slotScopeIds, 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)), slotScopeIds, 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) {\r\n            setRef(ref, null, parentSuspense, vnode);\r\n        }\r\n        return nextNode;\r\n    };\r\n    const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, 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            if (dirs) {\r\n                invokeDirectiveHook(vnode, null, parentComponent, 'created');\r\n            }\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, slotScopeIds, 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, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {\r\n        optimized = optimized || !!parentVNode.dynamicChildren;\r\n        const children = parentVNode.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, slotScopeIds, optimized);\r\n            }\r\n            else if (vnode.type === Text && !vnode.children) {\r\n                continue;\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), slotScopeIds);\r\n            }\r\n        }\r\n        return node;\r\n    };\r\n    const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {\r\n        const { slotScopeIds: fragmentSlotScopeIds } = vnode;\r\n        if (fragmentSlotScopeIds) {\r\n            slotScopeIds = slotScopeIds\r\n                ? slotScopeIds.concat(fragmentSlotScopeIds)\r\n                : fragmentSlotScopeIds;\r\n        }\r\n        const container = parentNode(node);\r\n        const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, slotScopeIds, 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, slotScopeIds, 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), slotScopeIds);\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\n// implementation, close to no-op\r\nfunction defineComponent(options) {\r\n    return isFunction(options) ? { setup: options, name: options.name } : options;\r\n}\n\nconst isAsyncWrapper = (i) => !!i.type.__asyncLoader;\r\nfunction defineAsyncComponent(source) {\r\n    if (isFunction(source)) {\r\n        source = { loader: source };\r\n    }\r\n    const { loader, loadingComponent, 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 */, !errorComponent /* do not throw in dev if user provided error component */);\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, {\r\n                            error: err\r\n                        })\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 && !error.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: { ref, props, children } }) {\r\n    const vnode = createVNode(comp, props, children);\r\n    // ensure inner component inherits the async wrapper's ref owner\r\n    vnode.ref = ref;\r\n    return vnode;\r\n}\n\nconst prodEffectOptions = {\r\n    scheduler: queueJob,\r\n    // #1801, #2043 component render effects should allow recursive updates\r\n    allowRecurse: true\r\n};\r\nfunction createDevEffectOptions(instance) {\r\n    return {\r\n        scheduler: queueJob,\r\n        allowRecurse: true,\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, parentSuspense, vnode) => {\r\n    if (isArray(rawRef)) {\r\n        rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode));\r\n        return;\r\n    }\r\n    let value;\r\n    if (!vnode) {\r\n        // means unmount\r\n        value = null;\r\n    }\r\n    else if (isAsyncWrapper(vnode)) {\r\n        // when mounting async components, nothing needs to be done,\r\n        // because the template ref is forwarded to inner component\r\n        return;\r\n    }\r\n    else if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {\r\n        value = vnode.component.exposed || vnode.component.proxy;\r\n    }\r\n    else {\r\n        value = vnode.el;\r\n    }\r\n    const { i: owner, r: 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.r;\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                setupState[oldRef] = null;\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        const doSet = () => {\r\n            refs[ref] = value;\r\n            if (hasOwn(setupState, ref)) {\r\n                setupState[ref] = value;\r\n            }\r\n        };\r\n        // #1789: for non-null values, set them after render\r\n        // null values means this is unmount and it should not overwrite another\r\n        // ref with the same key\r\n        if (value) {\r\n            doSet.id = -1;\r\n            queuePostRenderEffect(doSet, parentSuspense);\r\n        }\r\n        else {\r\n            doSet();\r\n        }\r\n    }\r\n    else if (isRef(ref)) {\r\n        const doSet = () => {\r\n            ref.value = value;\r\n        };\r\n        if (value) {\r\n            doSet.id = -1;\r\n            queuePostRenderEffect(doSet, parentSuspense);\r\n        }\r\n        else {\r\n            doSet();\r\n        }\r\n    }\r\n    else if (isFunction(ref)) {\r\n        callWithErrorHandling(ref, owner, 12 /* FUNCTION_REF */, [value, refs]);\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    if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n        const target = getGlobalThis();\r\n        target.__VUE__ = true;\r\n        setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\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, slotScopeIds = null, 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, slotScopeIds, optimized);\r\n                break;\r\n            default:\r\n                if (shapeFlag & 1 /* ELEMENT */) {\r\n                    processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\r\n                }\r\n                else if (shapeFlag & 6 /* COMPONENT */) {\r\n                    processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\r\n                }\r\n                else if (shapeFlag & 64 /* TELEPORT */) {\r\n                    type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals);\r\n                }\r\n                else if (shapeFlag & 128 /* SUSPENSE */) {\r\n                    type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, 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, 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    const moveStaticNode = ({ el, anchor }, container, nextSibling) => {\r\n        let next;\r\n        while (el && el !== anchor) {\r\n            next = hostNextSibling(el);\r\n            hostInsert(el, container, nextSibling);\r\n            el = next;\r\n        }\r\n        hostInsert(anchor, container, nextSibling);\r\n    };\r\n    const removeStaticNode = ({ el, anchor }) => {\r\n        let next;\r\n        while (el && el !== anchor) {\r\n            next = hostNextSibling(el);\r\n            hostRemove(el);\r\n            el = next;\r\n        }\r\n        hostRemove(anchor);\r\n    };\r\n    const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {\r\n        isSVG = isSVG || n2.type === 'svg';\r\n        if (n1 == null) {\r\n            mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\r\n        }\r\n        else {\r\n            patchElement(n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\r\n        }\r\n    };\r\n    const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {\r\n        let el;\r\n        let vnodeHook;\r\n        const { type, props, shapeFlag, transition, 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, props);\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', slotScopeIds, optimized || !!vnode.dynamicChildren);\r\n            }\r\n            if (dirs) {\r\n                invokeDirectiveHook(vnode, null, parentComponent, 'created');\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            // scopeId\r\n            setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n            Object.defineProperty(el, '__vnode', {\r\n                value: vnode,\r\n                enumerable: false\r\n            });\r\n            Object.defineProperty(el, '__vueParentComponent', {\r\n                value: parentComponent,\r\n                enumerable: false\r\n            });\r\n        }\r\n        if (dirs) {\r\n            invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount');\r\n        }\r\n        // #1583 For inside suspense + suspense not resolved case, enter hook should call when suspense resolved\r\n        // #1689 For inside suspense + suspense resolved case, just call it\r\n        const needCallTransitionHooks = (!parentSuspense || (parentSuspense && !parentSuspense.pendingBranch)) &&\r\n            transition &&\r\n            !transition.persisted;\r\n        if (needCallTransitionHooks) {\r\n            transition.beforeEnter(el);\r\n        }\r\n        hostInsert(el, container, anchor);\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 setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {\r\n        if (scopeId) {\r\n            hostSetScopeId(el, scopeId);\r\n        }\r\n        if (slotScopeIds) {\r\n            for (let i = 0; i < slotScopeIds.length; i++) {\r\n                hostSetScopeId(el, slotScopeIds[i]);\r\n            }\r\n        }\r\n        if (parentComponent) {\r\n            let subTree = parentComponent.subTree;\r\n            if ((process.env.NODE_ENV !== 'production') &&\r\n                subTree.patchFlag > 0 &&\r\n                subTree.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */) {\r\n                subTree =\r\n                    filterSingleRoot(subTree.children) || subTree;\r\n            }\r\n            if (vnode === subTree) {\r\n                const parentVNode = parentComponent.vnode;\r\n                setScopeId(el, parentVNode, parentVNode.scopeId, parentVNode.slotScopeIds, parentComponent.parent);\r\n            }\r\n        }\r\n    };\r\n    const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, optimized, slotScopeIds, 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, slotScopeIds);\r\n        }\r\n    };\r\n    const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, 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, slotScopeIds);\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, slotScopeIds, false);\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, slotScopeIds) => {\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                oldVNode.shapeFlag & 64 /* TELEPORT */\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, slotScopeIds, 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                // empty string is not valid prop\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, slotScopeIds, 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, slotScopeIds: fragmentSlotScopeIds } = n2;\r\n        if (patchFlag > 0) {\r\n            optimized = true;\r\n        }\r\n        // check if this is a slot fragment with :slotted scope ids\r\n        if (fragmentSlotScopeIds) {\r\n            slotScopeIds = slotScopeIds\r\n                ? slotScopeIds.concat(fragmentSlotScopeIds)\r\n                : fragmentSlotScopeIds;\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, slotScopeIds, optimized);\r\n        }\r\n        else {\r\n            if (patchFlag > 0 &&\r\n                patchFlag & 64 /* STABLE_FRAGMENT */ &&\r\n                dynamicChildren &&\r\n                // #2715 the previous fragment could've been a BAILed one as a result\r\n                // of renderSlot() with no valid children\r\n                n1.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, slotScopeIds);\r\n                if ((process.env.NODE_ENV !== 'production') && parentComponent && parentComponent.type.__hmrId) {\r\n                    traverseStaticChildren(n1, n2);\r\n                }\r\n                else if (\r\n                // #2080 if the stable fragment has a key, it's a <template v-for> that may\r\n                //  get moved around. Make sure all root level vnodes inherit el.\r\n                // #2134 or if it's a component root, it may also get moved around\r\n                // as the component is being moved.\r\n                n2.key != null ||\r\n                    (parentComponent && n2 === parentComponent.subTree)) {\r\n                    traverseStaticChildren(n1, n2, true /* shallow */);\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, slotScopeIds, optimized);\r\n            }\r\n        }\r\n    };\r\n    const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {\r\n        n2.slotScopeIds = slotScopeIds;\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            parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect);\r\n            // Give it a placeholder if this is not hydration\r\n            // TODO handle self-defined fallback\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 (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, parent } = instance;\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                // render\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                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, null);\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                    const scopedInitialVNode = initialVNode;\r\n                    queuePostRenderEffect(() => {\r\n                        invokeVNodeHook(vnodeHook, parent, scopedInitialVNode);\r\n                    }, parentSuspense);\r\n                }\r\n                // activated hook for keep-alive roots.\r\n                // #1742 activated hook must be accessed after first render\r\n                // since the hook may be injected by a child keep-alive\r\n                const { a } = instance;\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                if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n                    devtoolsComponentAdded(instance);\r\n                }\r\n                // #2458: deference mount-only object parameters to prevent memleaks\r\n                initialVNode = container = anchor = null;\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                    next.el = vnode.el;\r\n                    updateComponentPreRender(instance, next, optimized);\r\n                }\r\n                else {\r\n                    next = vnode;\r\n                }\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                // render\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                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        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, optimized);\r\n        pauseTracking();\r\n        // props update may have triggered pre-flush watchers.\r\n        // flush them before the render update.\r\n        flushPreFlushCbs(undefined, instance.update);\r\n        resetTracking();\r\n    };\r\n    const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, 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, slotScopeIds, 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, slotScopeIds, 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, slotScopeIds, 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, slotScopeIds, optimized);\r\n                }\r\n            }\r\n        }\r\n    };\r\n    const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, 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, slotScopeIds, optimized);\r\n        }\r\n        if (oldLength > newLength) {\r\n            // remove old\r\n            unmountChildren(c1, parentComponent, parentSuspense, true, false, commonLength);\r\n        }\r\n        else {\r\n            // mount new\r\n            mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, 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, slotScopeIds, 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, slotScopeIds, 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, slotScopeIds, 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, slotScopeIds, optimized);\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, slotScopeIds, 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, slotScopeIds, optimized);\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        if (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, optimized = false) => {\r\n        const { type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs } = vnode;\r\n        // unset ref\r\n        if (ref != null) {\r\n            setRef(ref, null, 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 (shapeFlag & 64 /* TELEPORT */) {\r\n                vnode.type.remove(vnode, parentComponent, parentSuspense, optimized, internals, doRemove);\r\n            }\r\n            else 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, false, true);\r\n            }\r\n            else if ((type === Fragment &&\r\n                (patchFlag & 128 /* KEYED_FRAGMENT */ ||\r\n                    patchFlag & 256 /* UNKEYED_FRAGMENT */)) ||\r\n                (!optimized && shapeFlag & 16 /* ARRAY_CHILDREN */)) {\r\n                unmountChildren(children, parentComponent, parentSuspense);\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 (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 } = 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        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 (parentSuspense &&\r\n            parentSuspense.pendingBranch &&\r\n            !parentSuspense.isUnmounted &&\r\n            instance.asyncDep &&\r\n            !instance.asyncResolved &&\r\n            instance.suspenseId === parentSuspense.pendingId) {\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, optimized = false, start = 0) => {\r\n        for (let i = start; i < children.length; i++) {\r\n            unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);\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    const render = (vnode, container, isSVG) => {\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, null, null, null, isSVG);\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/**\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 * #2080\r\n * Inside keyed `template` fragment static children, if a fragment is moved,\r\n * the children will always moved so that need inherit el form previous nodes\r\n * to ensure correct moved position.\r\n */\r\nfunction traverseStaticChildren(n1, n2, shallow = false) {\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            let c2 = ch2[i];\r\n            if (c2.shapeFlag & 1 /* ELEMENT */ && !c2.dynamicChildren) {\r\n                if (c2.patchFlag <= 0 || c2.patchFlag === 32 /* HYDRATE_EVENTS */) {\r\n                    c2 = ch2[i] = cloneIfMounted(ch2[i]);\r\n                    c2.el = c1.el;\r\n                }\r\n                if (!shallow)\r\n                    traverseStaticChildren(c1, c2);\r\n            }\r\n            // also inherit for comment nodes, but not placeholders (e.g. v-if which\r\n            // would have received .el during block patch)\r\n            if ((process.env.NODE_ENV !== 'production') && c2.type === Comment && !c2.el) {\r\n                c2.el = c1.el;\r\n            }\r\n        }\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\nconst isTeleport = (type) => type.__isTeleport;\r\nconst isTeleportDisabled = (props) => props && (props.disabled || props.disabled === '');\r\nconst isTargetSVG = (target) => typeof SVGElement !== 'undefined' && target instanceof SVGElement;\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 && !isTeleportDisabled(props)) {\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, slotScopeIds, 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        // #3302\r\n        // HMR updated, force full diff\r\n        if ((process.env.NODE_ENV !== 'production') && isHmrUpdating) {\r\n            optimized = false;\r\n            n2.dynamicChildren = null;\r\n        }\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                // #2652 we could be teleporting from a non-SVG tree into an SVG tree\r\n                isSVG = isSVG || isTargetSVG(target);\r\n            }\r\n            else if ((process.env.NODE_ENV !== 'production') && !disabled) {\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, slotScopeIds, 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            isSVG = isSVG || isTargetSVG(target);\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, slotScopeIds);\r\n                // even in block tree mode we need to make sure all root-level nodes\r\n                // in the teleport inherit previous DOM references so that they can\r\n                // be moved in future patches.\r\n                traverseStaticChildren(n1, n2, true);\r\n            }\r\n            else if (!optimized) {\r\n                patchChildren(n1, n2, currentContainer, currentAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, false);\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, parentComponent, parentSuspense, optimized, { um: unmount, o: { remove: hostRemove } }, doRemove) {\r\n        const { shapeFlag, children, anchor, targetAnchor, target, props } = vnode;\r\n        if (target) {\r\n            hostRemove(targetAnchor);\r\n        }\r\n        // an unmounted teleport should always remove its children if not disabled\r\n        if (doRemove || !isTeleportDisabled(props)) {\r\n            hostRemove(anchor);\r\n            if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                for (let i = 0; i < children.length; i++) {\r\n                    unmount(children[i], parentComponent, parentSuspense, true, optimized);\r\n                }\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, slotScopeIds, 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, slotScopeIds, 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, slotScopeIds, 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, maybeSelfReference) {\r\n    return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || 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, maybeSelfReference = false) {\r\n    const instance = currentRenderingInstance || currentInstance;\r\n    if (instance) {\r\n        const Component = instance.type;\r\n        // explicit self name has highest priority\r\n        if (type === COMPONENTS) {\r\n            const selfName = getComponentName(Component);\r\n            if (selfName &&\r\n                (selfName === name ||\r\n                    selfName === camelize(name) ||\r\n                    selfName === capitalize(camelize(name)))) {\r\n                return Component;\r\n            }\r\n        }\r\n        const res = \r\n        // local registration\r\n        // check instance[type] first for components with mixin or extends.\r\n        resolve(instance[type] || Component[type], name) ||\r\n            // global registration\r\n            resolve(instance.appContext[type], name);\r\n        if (!res && maybeSelfReference) {\r\n            // fallback to implicit self-reference\r\n            return Component;\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}\r\nfunction resolve(registry, name) {\r\n    return (registry &&\r\n        (registry[name] ||\r\n            registry[camelize(name)] ||\r\n            registry[capitalize(camelize(name))]));\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\nfunction closeBlock() {\r\n    blockStack.pop();\r\n    currentBlock = blockStack[blockStack.length - 1] || 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    closeBlock();\r\n    // a block is always going to be patched, so track it as a child of its\r\n    // parent block\r\n    if (shouldTrack > 0 && 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        ? isString(ref) || isRef(ref) || isFunction(ref)\r\n            ? { i: currentRenderingInstance, r: ref }\r\n            : ref\r\n        : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n    ? createVNodeWithArgsTransform\r\n    : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n    if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n        if ((process.env.NODE_ENV !== 'production') && !type) {\r\n            warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n        }\r\n        type = Comment;\r\n    }\r\n    if (isVNode(type)) {\r\n        // createVNode receiving an existing vnode. This happens in cases like\r\n        // <component :is=\"vnode\"/>\r\n        // #2078 make sure to merge refs during the clone instead of overwriting it\r\n        const cloned = cloneVNode(type, props, true /* mergeRef: true */);\r\n        if (children) {\r\n            normalizeChildren(cloned, children);\r\n        }\r\n        return cloned;\r\n    }\r\n    // class component normalization.\r\n    if (isClassComponent(type)) {\r\n        type = type.__vccOpts;\r\n    }\r\n    // class & style normalization.\r\n    if (props) {\r\n        // for reactive or proxy objects, we need to clone it to enable mutation.\r\n        if (isProxy(props) || InternalObjectKey in props) {\r\n            props = extend({}, props);\r\n        }\r\n        let { class: klass, style } = props;\r\n        if (klass && !isString(klass)) {\r\n            props.class = normalizeClass(klass);\r\n        }\r\n        if (isObject(style)) {\r\n            // reactive state objects need to be cloned since they are likely to be\r\n            // mutated\r\n            if (isProxy(style) && !isArray(style)) {\r\n                style = extend({}, style);\r\n            }\r\n            props.style = normalizeStyle(style);\r\n        }\r\n    }\r\n    // encode the vnode type information into a bitmap\r\n    const shapeFlag = isString(type)\r\n        ? 1 /* ELEMENT */\r\n        : isSuspense(type)\r\n            ? 128 /* SUSPENSE */\r\n            : isTeleport(type)\r\n                ? 64 /* TELEPORT */\r\n                : isObject(type)\r\n                    ? 4 /* STATEFUL_COMPONENT */\r\n                    : isFunction(type)\r\n                        ? 2 /* FUNCTIONAL_COMPONENT */\r\n                        : 0;\r\n    if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n        type = toRaw(type);\r\n        warn(`Vue received a Component which was made a reactive object. This can ` +\r\n            `lead to unnecessary performance overhead, and should be avoided by ` +\r\n            `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n            `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n    }\r\n    const vnode = {\r\n        __v_isVNode: true,\r\n        [\"__v_skip\" /* SKIP */]: true,\r\n        type,\r\n        props,\r\n        key: props && normalizeKey(props),\r\n        ref: props && normalizeRef(props),\r\n        scopeId: currentScopeId,\r\n        slotScopeIds: null,\r\n        children: null,\r\n        component: null,\r\n        suspense: null,\r\n        ssContent: null,\r\n        ssFallback: null,\r\n        dirs: null,\r\n        transition: null,\r\n        el: null,\r\n        anchor: null,\r\n        target: null,\r\n        targetAnchor: null,\r\n        staticCount: 0,\r\n        shapeFlag,\r\n        patchFlag,\r\n        dynamicProps,\r\n        dynamicChildren: null,\r\n        appContext: null\r\n    };\r\n    // validate key\r\n    if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n        warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n    }\r\n    normalizeChildren(vnode, children);\r\n    // normalize suspense children\r\n    if (shapeFlag & 128 /* SUSPENSE */) {\r\n        const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n        vnode.ssContent = content;\r\n        vnode.ssFallback = fallback;\r\n    }\r\n    if (shouldTrack > 0 &&\r\n        // avoid a block node from tracking itself\r\n        !isBlockNode &&\r\n        // has current parent block\r\n        currentBlock &&\r\n        // presence of a patch flag indicates this node needs patching on updates.\r\n        // component nodes also should always be patched, because even if the\r\n        // component doesn't need to update, it needs to persist the instance on to\r\n        // the next vnode so that it can be properly unmounted later.\r\n        (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n        // the EVENTS flag is only for hydration and if it is the only flag, the\r\n        // vnode should not be considered dynamic due to handler caching.\r\n        patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n        currentBlock.push(vnode);\r\n    }\r\n    return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\r\n    // This is intentionally NOT using spread or extend to avoid the runtime\r\n    // key enumeration cost.\r\n    const { props, ref, patchFlag, children } = vnode;\r\n    const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\r\n    return {\r\n        __v_isVNode: true,\r\n        [\"__v_skip\" /* SKIP */]: true,\r\n        type: vnode.type,\r\n        props: mergedProps,\r\n        key: mergedProps && normalizeKey(mergedProps),\r\n        ref: extraProps && extraProps.ref\r\n            ? // #2078 in the case of <component :is=\"vnode\" ref=\"extra\"/>\r\n                // if the vnode itself already has a ref, cloneVNode will need to merge\r\n                // the refs so the single vnode can be set on multiple refs\r\n                mergeRef && ref\r\n                    ? isArray(ref)\r\n                        ? ref.concat(normalizeRef(extraProps))\r\n                        : [ref, normalizeRef(extraProps)]\r\n                    : normalizeRef(extraProps)\r\n            : ref,\r\n        scopeId: vnode.scopeId,\r\n        slotScopeIds: vnode.slotScopeIds,\r\n        children: (process.env.NODE_ENV !== 'production') && patchFlag === -1 /* HOISTED */ && isArray(children)\r\n            ? children.map(deepCloneVNode)\r\n            : children,\r\n        target: vnode.target,\r\n        targetAnchor: vnode.targetAnchor,\r\n        staticCount: vnode.staticCount,\r\n        shapeFlag: vnode.shapeFlag,\r\n        // if the vnode is cloned with extra props, we can no longer assume its\r\n        // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n        // note: perserve flag for fragments since they use the flag for children\r\n        // fast paths only.\r\n        patchFlag: extraProps && vnode.type !== Fragment\r\n            ? patchFlag === -1 // hoisted node\r\n                ? 16 /* FULL_PROPS */\r\n                : patchFlag | 16 /* FULL_PROPS */\r\n            : patchFlag,\r\n        dynamicProps: vnode.dynamicProps,\r\n        dynamicChildren: vnode.dynamicChildren,\r\n        appContext: vnode.appContext,\r\n        dirs: vnode.dirs,\r\n        transition: vnode.transition,\r\n        // These should technically only be non-null on mounted VNodes. However,\r\n        // they *should* be copied for kept-alive vnodes. So we just always copy\r\n        // them since them being non-null during a mount doesn't affect the logic as\r\n        // they will simply be overwritten.\r\n        component: vnode.component,\r\n        suspense: vnode.suspense,\r\n        ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\r\n        ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\r\n        el: vnode.el,\r\n        anchor: vnode.anchor\r\n    };\r\n}\r\n/**\r\n * Dev only, for HMR of hoisted vnodes reused in v-for\r\n * https://github.com/vitejs/vite/issues/2022\r\n */\r\nfunction deepCloneVNode(vnode) {\r\n    const cloned = cloneVNode(vnode);\r\n    if (isArray(vnode.children)) {\r\n        cloned.children = vnode.children.map(deepCloneVNode);\r\n    }\r\n    return cloned;\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        if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {\r\n            // Normalize slot to plain children for plain element and Teleport\r\n            const slot = children.default;\r\n            if (slot) {\r\n                // _c marker is added by withCtx() indicating this is a compiled slot\r\n                slot._c && setCompiledSlotRendering(1);\r\n                normalizeChildren(vnode, slot());\r\n                slot._c && setCompiledSlotRendering(-1);\r\n            }\r\n            return;\r\n        }\r\n        else {\r\n            type = 32 /* SLOTS_CHILDREN */;\r\n            const slotFlag = children._;\r\n            if (!slotFlag && !(InternalObjectKey in children)) {\r\n                children._ctx = currentRenderingInstance;\r\n            }\r\n            else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n                // a child component receives forwarded slots from the parent.\r\n                // its slot type is determined by its parent's slot type.\r\n                if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n                    children._ = 2 /* DYNAMIC */;\r\n                    vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n                }\r\n                else {\r\n                    children._ = 1 /* STABLE */;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else if (isFunction(children)) {\r\n        children = { default: children, _ctx: currentRenderingInstance };\r\n        type = 32 /* SLOTS_CHILDREN */;\r\n    }\r\n    else {\r\n        children = String(children);\r\n        // force teleport children to array so it can be moved around\r\n        if (shapeFlag & 64 /* TELEPORT */) {\r\n            type = 16 /* ARRAY_CHILDREN */;\r\n            children = [createTextVNode(children)];\r\n        }\r\n        else {\r\n            type = 8 /* TEXT_CHILDREN */;\r\n        }\r\n    }\r\n    vnode.children = children;\r\n    vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n    const ret = extend({}, args[0]);\r\n    for (let i = 1; i < args.length; i++) {\r\n        const toMerge = args[i];\r\n        for (const key in toMerge) {\r\n            if (key === 'class') {\r\n                if (ret.class !== toMerge.class) {\r\n                    ret.class = normalizeClass([ret.class, toMerge.class]);\r\n                }\r\n            }\r\n            else if (key === 'style') {\r\n                ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n            }\r\n            else if (isOn(key)) {\r\n                const existing = ret[key];\r\n                const incoming = toMerge[key];\r\n                if (existing !== incoming) {\r\n                    ret[key] = existing\r\n                        ? [].concat(existing, toMerge[key])\r\n                        : incoming;\r\n                }\r\n            }\r\n            else if (key !== '') {\r\n                ret[key] = toMerge[key];\r\n            }\r\n        }\r\n    }\r\n    return ret;\r\n}\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, treatDefaultAsFactory = false) {\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        // #2400\r\n        // to support `app.use` plugins,\r\n        // fallback to appContext's `provides` if the intance is at root\r\n        const provides = instance.parent == null\r\n            ? instance.vnode.appContext && instance.vnode.appContext.provides\r\n            : instance.parent.provides;\r\n        if (provides && 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 treatDefaultAsFactory && isFunction(defaultValue)\r\n                ? defaultValue()\r\n                : 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\nlet shouldCacheAccess = true;\r\nfunction applyOptions(instance, options, deferredData = [], deferredWatch = [], deferredProvide = [], 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, beforeDestroy, beforeUnmount, destroyed, unmounted, render, renderTracked, renderTriggered, errorCaptured, \r\n    // public API\r\n    expose } = options;\r\n    const publicThis = instance.proxy;\r\n    const ctx = instance.ctx;\r\n    const globalMixins = instance.appContext.mixins;\r\n    if (asMixin && render && instance.render === NOOP) {\r\n        instance.render = render;\r\n    }\r\n    // applyOptions is called non-as-mixin once per instance\r\n    if (!asMixin) {\r\n        shouldCacheAccess = false;\r\n        callSyncHook('beforeCreate', \"bc\" /* BEFORE_CREATE */, options, instance, globalMixins);\r\n        shouldCacheAccess = true;\r\n        // global mixins are applied first\r\n        applyMixins(instance, globalMixins, deferredData, deferredWatch, deferredProvide);\r\n    }\r\n    // extending a base component...\r\n    if (extendsOptions) {\r\n        applyOptions(instance, extendsOptions, deferredData, deferredWatch, deferredProvide, true);\r\n    }\r\n    // local mixins\r\n    if (mixins) {\r\n        applyMixins(instance, mixins, deferredData, deferredWatch, deferredProvide);\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] = instance.propsOptions;\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 || key, opt.default, true /* treat default function as factory */);\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                // In dev mode, we use the `createRenderContext` function to define methods to the proxy target,\r\n                // and those are read-only but reconfigurable, so it needs to be redefined here\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    Object.defineProperty(ctx, key, {\r\n                        value: methodHandler.bind(publicThis),\r\n                        configurable: true,\r\n                        enumerable: true,\r\n                        writable: true\r\n                    });\r\n                }\r\n                else {\r\n                    ctx[key] = methodHandler.bind(publicThis);\r\n                }\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 (!asMixin) {\r\n        if (deferredData.length) {\r\n            deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis));\r\n        }\r\n        if (dataOptions) {\r\n            // @ts-ignore dataOptions is not fully type safe\r\n            resolveData(instance, dataOptions, 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    else if (dataOptions) {\r\n        deferredData.push(dataOptions);\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        deferredProvide.push(provideOptions);\r\n    }\r\n    if (!asMixin && deferredProvide.length) {\r\n        deferredProvide.forEach(provideOptions => {\r\n            const provides = isFunction(provideOptions)\r\n                ? provideOptions.call(publicThis)\r\n                : provideOptions;\r\n            Reflect.ownKeys(provides).forEach(key => {\r\n                provide(key, provides[key]);\r\n            });\r\n        });\r\n    }\r\n    // asset options.\r\n    // To reduce memory usage, only components with mixins or extends will have\r\n    // resolved asset registry attached to instance.\r\n    if (asMixin) {\r\n        if (components) {\r\n            extend(instance.components ||\r\n                (instance.components = extend({}, instance.type.components)), components);\r\n        }\r\n        if (directives) {\r\n            extend(instance.directives ||\r\n                (instance.directives = extend({}, instance.type.directives)), directives);\r\n        }\r\n    }\r\n    // lifecycle options\r\n    if (!asMixin) {\r\n        callSyncHook('created', \"c\" /* CREATED */, options, instance, 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 ((process.env.NODE_ENV !== 'production') && beforeDestroy) {\r\n        warn(`\\`beforeDestroy\\` has been renamed to \\`beforeUnmount\\`.`);\r\n    }\r\n    if (beforeUnmount) {\r\n        onBeforeUnmount(beforeUnmount.bind(publicThis));\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production') && destroyed) {\r\n        warn(`\\`destroyed\\` has been renamed to \\`unmounted\\`.`);\r\n    }\r\n    if (unmounted) {\r\n        onUnmounted(unmounted.bind(publicThis));\r\n    }\r\n    if (isArray(expose)) {\r\n        if (!asMixin) {\r\n            if (expose.length) {\r\n                const exposed = instance.exposed || (instance.exposed = proxyRefs({}));\r\n                expose.forEach(key => {\r\n                    exposed[key] = toRef(publicThis, key);\r\n                });\r\n            }\r\n            else if (!instance.exposed) {\r\n                instance.exposed = EMPTY_OBJ;\r\n            }\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production')) {\r\n            warn(`The \\`expose\\` option is ignored when used in mixins.`);\r\n        }\r\n    }\r\n}\r\nfunction callSyncHook(name, type, options, instance, globalMixins) {\r\n    for (let i = 0; i < globalMixins.length; i++) {\r\n        callHookWithMixinAndExtends(name, type, globalMixins[i], instance);\r\n    }\r\n    callHookWithMixinAndExtends(name, type, options, instance);\r\n}\r\nfunction callHookWithMixinAndExtends(name, type, options, instance) {\r\n    const { extends: base, mixins } = options;\r\n    const selfHook = options[name];\r\n    if (base) {\r\n        callHookWithMixinAndExtends(name, type, base, instance);\r\n    }\r\n    if (mixins) {\r\n        for (let i = 0; i < mixins.length; i++) {\r\n            callHookWithMixinAndExtends(name, type, mixins[i], instance);\r\n        }\r\n    }\r\n    if (selfHook) {\r\n        callWithAsyncErrorHandling(selfHook.bind(instance.proxy), instance, type);\r\n    }\r\n}\r\nfunction applyMixins(instance, mixins, deferredData, deferredWatch, deferredProvide) {\r\n    for (let i = 0; i < mixins.length; i++) {\r\n        applyOptions(instance, mixins[i], deferredData, deferredWatch, deferredProvide, true);\r\n    }\r\n}\r\nfunction resolveData(instance, dataFn, publicThis) {\r\n    if ((process.env.NODE_ENV !== 'production') && !isFunction(dataFn)) {\r\n        warn(`The data option must be a function. ` +\r\n            `Plain object usage is no longer supported.`);\r\n    }\r\n    shouldCacheAccess = false;\r\n    const data = dataFn.call(publicThis, publicThis);\r\n    shouldCacheAccess = true;\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 = key.includes('.')\r\n        ? createPathGetter(publicThis, key)\r\n        : () => 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            const handler = isFunction(raw.handler)\r\n                ? raw.handler.bind(publicThis)\r\n                : ctx[raw.handler];\r\n            if (isFunction(handler)) {\r\n                watch(getter, handler, raw);\r\n            }\r\n            else if ((process.env.NODE_ENV !== 'production')) {\r\n                warn(`Invalid watch handler specified by key \"${raw.handler}\"`, handler);\r\n            }\r\n        }\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`Invalid watch option: \"${key}\"`, raw);\r\n    }\r\n}\r\nfunction createPathGetter(ctx, path) {\r\n    const segments = path.split('.');\r\n    return () => {\r\n        let cur = ctx;\r\n        for (let i = 0; i < segments.length && cur; i++) {\r\n            cur = cur[segments[i]];\r\n        }\r\n        return cur;\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    mergeOptions(options, raw, instance);\r\n    return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n    const strats = instance.appContext.config.optionMergeStrategies;\r\n    const { mixins, extends: extendsOptions } = from;\r\n    extendsOptions && mergeOptions(to, extendsOptions, instance);\r\n    mixins &&\r\n        mixins.forEach((m) => mergeOptions(to, m, instance));\r\n    for (const key in from) {\r\n        if (strats && hasOwn(strats, key)) {\r\n            to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n        }\r\n        else {\r\n            to[key] = from[key];\r\n        }\r\n    }\r\n}\n\n/**\r\n * #2437 In Vue 3, functional components do not have a public instance proxy but\r\n * they exist in the internal parent chain. For code that relies on traversing\r\n * public $parent chains, skip functional ones and go to the parent instead.\r\n */\r\nconst getPublicInstance = (i) => {\r\n    if (!i)\r\n        return null;\r\n    if (isStatefulComponent(i))\r\n        return i.exposed ? i.exposed : i.proxy;\r\n    return getPublicInstance(i.parent);\r\n};\r\nconst publicPropertiesMap = extend(Object.create(null), {\r\n    $: i => i,\r\n    $el: i => i.vnode.el,\r\n    $data: i => i.data,\r\n    $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n    $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n    $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n    $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n    $parent: i => getPublicInstance(i.parent),\r\n    $root: i => getPublicInstance(i.root),\r\n    $emit: i => i.emit,\r\n    $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n    $forceUpdate: i => () => queueJob(i.update),\r\n    $nextTick: i => nextTick.bind(i.proxy),\r\n    $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n    get({ _: instance }, key) {\r\n        const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n        // let @vue/reactivity know it should never observe Vue public instances.\r\n        if (key === \"__v_skip\" /* SKIP */) {\r\n            return true;\r\n        }\r\n        // for internal formatters to know that this is a Vue instance\r\n        if ((process.env.NODE_ENV !== 'production') && key === '__isVue') {\r\n            return true;\r\n        }\r\n        // data / props / ctx\r\n        // This getter gets called for every property access on the render context\r\n        // during render and is a major hotspot. The most expensive part of this\r\n        // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n        // access on a plain object, so we use an accessCache object (with null\r\n        // prototype) to memoize what access type a key corresponds to.\r\n        let normalizedProps;\r\n        if (key[0] !== '$') {\r\n            const n = accessCache[key];\r\n            if (n !== undefined) {\r\n                switch (n) {\r\n                    case 0 /* SETUP */:\r\n                        return setupState[key];\r\n                    case 1 /* DATA */:\r\n                        return data[key];\r\n                    case 3 /* CONTEXT */:\r\n                        return ctx[key];\r\n                    case 2 /* PROPS */:\r\n                        return props[key];\r\n                    // default: just fallthrough\r\n                }\r\n            }\r\n            else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n                accessCache[key] = 0 /* SETUP */;\r\n                return setupState[key];\r\n            }\r\n            else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n                accessCache[key] = 1 /* DATA */;\r\n                return data[key];\r\n            }\r\n            else if (\r\n            // only cache other properties when instance has declared (thus stable)\r\n            // props\r\n            (normalizedProps = instance.propsOptions[0]) &&\r\n                hasOwn(normalizedProps, key)) {\r\n                accessCache[key] = 2 /* PROPS */;\r\n                return props[key];\r\n            }\r\n            else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n                accessCache[key] = 3 /* CONTEXT */;\r\n                return ctx[key];\r\n            }\r\n            else if (!__VUE_OPTIONS_API__ || shouldCacheAccess) {\r\n                accessCache[key] = 4 /* OTHER */;\r\n            }\r\n        }\r\n        const publicGetter = publicPropertiesMap[key];\r\n        let cssModule, globalProperties;\r\n        // public $xxx properties\r\n        if (publicGetter) {\r\n            if (key === '$attrs') {\r\n                track(instance, \"get\" /* GET */, key);\r\n                (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n            }\r\n            return publicGetter(instance);\r\n        }\r\n        else if (\r\n        // css module (injected by vue-loader)\r\n        (cssModule = type.__cssModules) &&\r\n            (cssModule = cssModule[key])) {\r\n            return cssModule;\r\n        }\r\n        else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n            // user may set custom properties to `this` that start with `$`\r\n            accessCache[key] = 3 /* CONTEXT */;\r\n            return ctx[key];\r\n        }\r\n        else if (\r\n        // global properties\r\n        ((globalProperties = appContext.config.globalProperties),\r\n            hasOwn(globalProperties, key))) {\r\n            return globalProperties[key];\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production') &&\r\n            currentRenderingInstance &&\r\n            (!isString(key) ||\r\n                // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n                // to infinite warning loop\r\n                key.indexOf('__v') !== 0)) {\r\n            if (data !== EMPTY_OBJ &&\r\n                (key[0] === '$' || key[0] === '_') &&\r\n                hasOwn(data, key)) {\r\n                warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n                    `character (\"$\" or \"_\") and is not proxied on the render context.`);\r\n            }\r\n            else if (instance === currentRenderingInstance) {\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 (hasOwn(instance.props, key)) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n            return false;\r\n        }\r\n        if (key[0] === '$' && key.slice(1) in instance) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Attempting to mutate public property \"${key}\". ` +\r\n                    `Properties starting with $ are reserved and readonly.`, instance);\r\n            return false;\r\n        }\r\n        else {\r\n            if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n                Object.defineProperty(ctx, key, {\r\n                    enumerable: true,\r\n                    configurable: true,\r\n                    value\r\n                });\r\n            }\r\n            else {\r\n                ctx[key] = value;\r\n            }\r\n        }\r\n        return true;\r\n    },\r\n    has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\r\n        let normalizedProps;\r\n        return (accessCache[key] !== undefined ||\r\n            (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n            (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n            ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||\r\n            hasOwn(ctx, key) ||\r\n            hasOwn(publicPropertiesMap, key) ||\r\n            hasOwn(appContext.config.globalProperties, key));\r\n    }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n    PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n        warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n            `The keys will be empty in production mode to avoid performance overhead.`);\r\n        return Reflect.ownKeys(target);\r\n    };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n    get(target, key) {\r\n        // fast path for unscopables when using `with` block\r\n        if (key === Symbol.unscopables) {\r\n            return;\r\n        }\r\n        return PublicInstanceProxyHandlers.get(target, key, target);\r\n    },\r\n    has(_, key) {\r\n        const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n        if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n            warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n        }\r\n        return has;\r\n    }\r\n});\r\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, propsOptions: [propsOptions] } = instance;\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        if (key[0] === '$' || key[0] === '_') {\r\n            warn(`setup() return property ${JSON.stringify(key)} should not start with \"$\" or \"_\" ` +\r\n                `which are reserved prefixes for Vue internals.`);\r\n            return;\r\n        }\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$1 = 0;\r\nfunction createComponentInstance(vnode, parent, suspense) {\r\n    const type = vnode.type;\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$1++,\r\n        vnode,\r\n        type,\r\n        parent,\r\n        appContext,\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        exposed: 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        // local resovled assets\r\n        components: null,\r\n        directives: null,\r\n        // resolved props and emits options\r\n        propsOptions: normalizePropsOptions(type, appContext),\r\n        emitsOptions: normalizeEmitsOptions(type, appContext),\r\n        // emit\r\n        emit: null,\r\n        emitted: null,\r\n        // props default value\r\n        propsDefaults: EMPTY_OBJ,\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        // suspense related\r\n        suspense,\r\n        suspenseId: suspense ? suspense.pendingId : 0,\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    };\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    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\nfunction isStatefulComponent(instance) {\r\n    return instance.vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */;\r\n}\r\nlet isInSSRComponentSetup = false;\r\nfunction setupComponent(instance, isSSR = false) {\r\n    isInSSRComponentSetup = isSSR;\r\n    const { props, children } = instance.vnode;\r\n    const isStateful = isStatefulComponent(instance);\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 = Object.create(null);\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\r\n                    .then((resolvedResult) => {\r\n                    handleSetupResult(instance, resolvedResult, isSSR);\r\n                })\r\n                    .catch(e => {\r\n                    handleError(e, instance, 0 /* SETUP_FUNCTION */);\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, isSSR);\r\n        }\r\n    }\r\n    else {\r\n        finishComponentSetup(instance, isSSR);\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        {\r\n            instance.render = setupResult;\r\n        }\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        if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n            instance.devtoolsRawSetupState = setupResult;\r\n        }\r\n        instance.setupState = proxyRefs(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, isSSR);\r\n}\r\nlet compile;\r\n// dev only\r\nconst isRuntimeOnly = () => !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        // could be set from setup()\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,\r\n                delimiters: Component.delimiters\r\n            });\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                endMeasure(instance, `compile`);\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        pauseTracking();\r\n        applyOptions(instance, Component);\r\n        resetTracking();\r\n        currentInstance = null;\r\n    }\r\n    // warn missing template/render\r\n    // the runtime compilation of template in SSR is done by server-render\r\n    if ((process.env.NODE_ENV !== 'production') && !Component.render && instance.render === NOOP && !isSSR) {\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}\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    const expose = exposed => {\r\n        if ((process.env.NODE_ENV !== 'production') && instance.exposed) {\r\n            warn(`expose() should be called only once per setup().`);\r\n        }\r\n        instance.exposed = proxyRefs(exposed);\r\n    };\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            expose\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            expose\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, instance = currentInstance) {\r\n    if (instance) {\r\n        (instance.effects || (instance.effects = [])).push(effect);\r\n    }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\nfunction getComponentName(Component) {\r\n    return isFunction(Component)\r\n        ? Component.displayName || Component.name\r\n        : Component.name;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n    let name = getComponentName(Component);\r\n    if (!name && Component.__file) {\r\n        const match = Component.__file.match(/([^/\\\\]+)\\.\\w+$/);\r\n        if (match) {\r\n            name = match[1];\r\n        }\r\n    }\r\n    if (!name && instance && instance.parent) {\r\n        // try to infer the name based on reverse resolution\r\n        const inferFromRegistry = (registry) => {\r\n            for (const key in registry) {\r\n                if (registry[key] === Component) {\r\n                    return key;\r\n                }\r\n            }\r\n        };\r\n        name =\r\n            inferFromRegistry(instance.components ||\r\n                instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n    }\r\n    return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\r\nfunction isClassComponent(value) {\r\n    return isFunction(value) && '__vccOpts' in value;\r\n}\n\nfunction computed(getterOrOptions) {\r\n    const c = computed$1(getterOrOptions);\r\n    recordInstanceBoundEffect(c.effect);\r\n    return c;\r\n}\n\n// implementation\r\nfunction defineProps() {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`defineProps() is a compiler-hint helper that is only usable inside ` +\r\n            `<script setup> of a single file component. Its arguments should be ` +\r\n            `compiled away and passing it at runtime has no effect.`);\r\n    }\r\n    return null;\r\n}\r\n// implementation\r\nfunction defineEmit() {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`defineEmit() is a compiler-hint helper that is only usable inside ` +\r\n            `<script setup> of a single file component. Its arguments should be ` +\r\n            `compiled away and passing it at runtime has no effect.`);\r\n    }\r\n    return null;\r\n}\r\nfunction useContext() {\r\n    const i = getCurrentInstance();\r\n    if ((process.env.NODE_ENV !== 'production') && !i) {\r\n        warn(`useContext() called without active instance.`);\r\n    }\r\n    return i.setupContext || (i.setupContext = createSetupContext(i));\r\n}\n\n// Actual implementation\r\nfunction h(type, propsOrChildren, children) {\r\n    const l = arguments.length;\r\n    if (l === 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 (l > 3) {\r\n            children = Array.prototype.slice.call(arguments, 2);\r\n        }\r\n        else if (l === 3 && 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\nfunction initCustomFormatter() {\r\n    /* eslint-disable no-restricted-globals */\r\n    if (!(process.env.NODE_ENV !== 'production') || typeof window === 'undefined') {\r\n        return;\r\n    }\r\n    const vueStyle = { style: 'color:#3ba776' };\r\n    const numberStyle = { style: 'color:#0b1bc9' };\r\n    const stringStyle = { style: 'color:#b62e24' };\r\n    const keywordStyle = { style: 'color:#9d288c' };\r\n    // custom formatter for Chrome\r\n    // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html\r\n    const formatter = {\r\n        header(obj) {\r\n            // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup\r\n            if (!isObject(obj)) {\r\n                return null;\r\n            }\r\n            if (obj.__isVue) {\r\n                return ['div', vueStyle, `VueInstance`];\r\n            }\r\n            else if (isRef(obj)) {\r\n                return [\r\n                    'div',\r\n                    {},\r\n                    ['span', vueStyle, genRefFlag(obj)],\r\n                    '<',\r\n                    formatValue(obj.value),\r\n                    `>`\r\n                ];\r\n            }\r\n            else if (isReactive(obj)) {\r\n                return [\r\n                    'div',\r\n                    {},\r\n                    ['span', vueStyle, 'Reactive'],\r\n                    '<',\r\n                    formatValue(obj),\r\n                    `>${isReadonly(obj) ? ` (readonly)` : ``}`\r\n                ];\r\n            }\r\n            else if (isReadonly(obj)) {\r\n                return [\r\n                    'div',\r\n                    {},\r\n                    ['span', vueStyle, 'Readonly'],\r\n                    '<',\r\n                    formatValue(obj),\r\n                    '>'\r\n                ];\r\n            }\r\n            return null;\r\n        },\r\n        hasBody(obj) {\r\n            return obj && obj.__isVue;\r\n        },\r\n        body(obj) {\r\n            if (obj && obj.__isVue) {\r\n                return [\r\n                    'div',\r\n                    {},\r\n                    ...formatInstance(obj.$)\r\n                ];\r\n            }\r\n        }\r\n    };\r\n    function formatInstance(instance) {\r\n        const blocks = [];\r\n        if (instance.type.props && instance.props) {\r\n            blocks.push(createInstanceBlock('props', toRaw(instance.props)));\r\n        }\r\n        if (instance.setupState !== EMPTY_OBJ) {\r\n            blocks.push(createInstanceBlock('setup', instance.setupState));\r\n        }\r\n        if (instance.data !== EMPTY_OBJ) {\r\n            blocks.push(createInstanceBlock('data', toRaw(instance.data)));\r\n        }\r\n        const computed = extractKeys(instance, 'computed');\r\n        if (computed) {\r\n            blocks.push(createInstanceBlock('computed', computed));\r\n        }\r\n        const injected = extractKeys(instance, 'inject');\r\n        if (injected) {\r\n            blocks.push(createInstanceBlock('injected', injected));\r\n        }\r\n        blocks.push([\r\n            'div',\r\n            {},\r\n            [\r\n                'span',\r\n                {\r\n                    style: keywordStyle.style + ';opacity:0.66'\r\n                },\r\n                '$ (internal): '\r\n            ],\r\n            ['object', { object: instance }]\r\n        ]);\r\n        return blocks;\r\n    }\r\n    function createInstanceBlock(type, target) {\r\n        target = extend({}, target);\r\n        if (!Object.keys(target).length) {\r\n            return ['span', {}];\r\n        }\r\n        return [\r\n            'div',\r\n            { style: 'line-height:1.25em;margin-bottom:0.6em' },\r\n            [\r\n                'div',\r\n                {\r\n                    style: 'color:#476582'\r\n                },\r\n                type\r\n            ],\r\n            [\r\n                'div',\r\n                {\r\n                    style: 'padding-left:1.25em'\r\n                },\r\n                ...Object.keys(target).map(key => {\r\n                    return [\r\n                        'div',\r\n                        {},\r\n                        ['span', keywordStyle, key + ': '],\r\n                        formatValue(target[key], false)\r\n                    ];\r\n                })\r\n            ]\r\n        ];\r\n    }\r\n    function formatValue(v, asRaw = true) {\r\n        if (typeof v === 'number') {\r\n            return ['span', numberStyle, v];\r\n        }\r\n        else if (typeof v === 'string') {\r\n            return ['span', stringStyle, JSON.stringify(v)];\r\n        }\r\n        else if (typeof v === 'boolean') {\r\n            return ['span', keywordStyle, v];\r\n        }\r\n        else if (isObject(v)) {\r\n            return ['object', { object: asRaw ? toRaw(v) : v }];\r\n        }\r\n        else {\r\n            return ['span', stringStyle, String(v)];\r\n        }\r\n    }\r\n    function extractKeys(instance, type) {\r\n        const Comp = instance.type;\r\n        if (isFunction(Comp)) {\r\n            return;\r\n        }\r\n        const extracted = {};\r\n        for (const key in instance.ctx) {\r\n            if (isKeyOfType(Comp, key, type)) {\r\n                extracted[key] = instance.ctx[key];\r\n            }\r\n        }\r\n        return extracted;\r\n    }\r\n    function isKeyOfType(Comp, key, type) {\r\n        const opts = Comp[type];\r\n        if ((isArray(opts) && opts.includes(key)) ||\r\n            (isObject(opts) && key in opts)) {\r\n            return true;\r\n        }\r\n        if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {\r\n            return true;\r\n        }\r\n        if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {\r\n            return true;\r\n        }\r\n    }\r\n    function genRefFlag(v) {\r\n        if (v._shallow) {\r\n            return `ShallowRef`;\r\n        }\r\n        if (v.effect) {\r\n            return `ComputedRef`;\r\n        }\r\n        return `Ref`;\r\n    }\r\n    if (window.devtoolsFormatters) {\r\n        window.devtoolsFormatters.push(formatter);\r\n    }\r\n    else {\r\n        window.devtoolsFormatters = [formatter];\r\n    }\r\n}\n\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        if ((process.env.NODE_ENV !== 'production') && !Number.isInteger(source)) {\r\n            warn(`The v-for range expect an integer value but got ${source}.`);\r\n            return [];\r\n        }\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[toHandlerKey(key)] = obj[key];\r\n    }\r\n    return ret;\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.11\";\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, defineEmit, defineProps, devtools, getCurrentInstance, getTransitionRawChildren, h, handleError, initCustomFormatter, inject, isRuntimeOnly, 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, useContext, useSSRContext, useTransitionState, version, warn, watch, watchEffect, withCtx, withDirectives, withScopeId };\n"],"sourceRoot":""}