{"version":3,"sources":["webpack://nanissa-cs/./node_modules/@heroicons/vue/outline/esm/MailIcon.js","webpack://nanissa-cs/./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js","webpack://nanissa-cs/./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js","webpack://nanissa-cs/./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js","webpack://nanissa-cs/./node_modules/@vue/shared/dist/shared.esm-bundler.js","webpack://nanissa-cs/./node_modules/alpinejs/dist/alpine.js","webpack://nanissa-cs/./node_modules/register-service-worker/index.js","webpack://nanissa-cs/./node_modules/vue-router/dist/vue-router.esm-bundler.js"],"names":["render","_ctx","_cache","xmlns","fill","viewBox","stroke","d","targetMap","WeakMap","effectStack","activeEffect","ITERATE_KEY","Symbol","MAP_KEY_ITERATE_KEY","isEffect","fn","_isEffect","effect","options","raw","createReactiveEffect","lazy","stop","active","cleanup","onStop","uid","scheduler","undefined","includes","enableTracking","push","pop","resetTracking","length","id","allowRecurse","deps","i","delete","shouldTrack","trackStack","pauseTracking","last","track","target","type","key","depsMap","get","set","Map","dep","Set","has","add","trigger","newValue","oldValue","oldTarget","effects","effectsToAdd","forEach","run","isNonTrackableKeys","builtInSymbols","Object","getOwnPropertyNames","map","filter","createGetter","shallowGet","readonlyGet","shallowReadonlyGet","arrayInstrumentations","isReadonly","shallow","receiver","shallowReadonlyMap","readonlyMap","shallowReactiveMap","reactiveMap","targetIsArray","Reflect","res","isRef","shouldUnwrap","value","readonly","reactive","method","Array","prototype","args","arr","toRaw","this","l","apply","createSetter","shallowSet","hadKey","Number","result","deleteProperty","ownKeys","mutableHandlers","readonlyHandlers","shallowReactiveHandlers","toReactive","toReadonly","toShallow","getProto","v","getPrototypeOf","get$1","isShallow","rawTarget","rawKey","wrap","call","has$1","size","proto","set$1","deleteEntry","clear","hadItems","createForEach","callback","thisArg","observed","createIterableMethod","targetIsMap","isPair","iterator","isKeyOnly","innerIterator","done","next","createReadonlyMethod","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","shallowReadonlyInstrumentations","iteratorMethods","createInstrumentationGetter","instrumentations","mutableCollectionHandlers","shallowCollectionHandlers","readonlyCollectionHandlers","targetTypeMap","rawType","getTargetType","isExtensible","createReactiveObject","shallowReactive","baseHandlers","collectionHandlers","proxyMap","existingProxy","targetType","proxy","Proxy","isReactive","isProxy","convert","val","r","Boolean","__v_isRef","ref","createRef","shallowRef","RefImpl","_rawValue","_shallow","_value","newVal","rawValue","unref","shallowUnwrapHandlers","proxyRefs","objectWithRefs","ObjectRefImpl","_object","_key","toRef","object","ComputedRefImpl","getter","_setter","_dirty","self","computed","getterOrOptions","setter","callWithErrorHandling","instance","err","handleError","callWithAsyncErrorHandling","catch","values","throwInDev","contextVNode","vnode","cur","parent","exposedInstance","errorInfo","errorCapturedHooks","ec","appErrorHandler","appContext","config","errorHandler","logError","console","error","isFlushing","isFlushPending","queue","flushIndex","pendingPreFlushCbs","activePreFlushCbs","preFlushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","Promise","resolve","currentFlushPromise","currentPreFlushParentJob","nextTick","p","then","bind","findInsertionIndex","job","start","end","jobId","getId","middle","middleJobId","queueJob","pos","splice","queueFlush","flushJobs","invalidateJob","indexOf","queueCb","cb","activeQueue","pendingQueue","index","queuePreFlushCb","queuePostFlushCb","flushPreFlushCbs","seen","parentJob","flushPostFlushCbs","deduped","sort","a","b","Infinity","emit","event","rawArgs","props","isModelListener","startsWith","modelArg","slice","modifiersKey","number","trim","handlerName","handler","onceHandler","emitted","normalizeEmitsOptions","comp","asMixin","deopt","__emits","emits","normalized","hasExtends","extendEmits","normalizedFromExtend","mixins","extends","isEmitListener","replace","toLowerCase","isRenderingCompiledSlot","setCompiledSlotRendering","n","currentRenderingInstance","currentScopeId","setCurrentRenderingInstance","prev","__scopeId","pushScopeId","popScopeId","withScopeId","_id","withCtx","ctx","renderFnWithContext","openBlock","prevInstance","closeBlock","_c","renderComponentRoot","Component","withProxy","propsOptions","slots","attrs","renderCache","data","setupState","fallthroughAttrs","shapeFlag","proxyToUse","normalizeVNode","getFunctionalFallthrough","root","inheritAttrs","keys","some","filterModelListeners","cloneVNode","dirs","concat","transition","blockStack","createVNode","Comment","filterSingleRoot","children","singleRoot","child","isVNode","shouldUpdateComponent","prevVNode","nextVNode","optimized","prevProps","prevChildren","component","nextProps","nextChildren","patchFlag","emitsOptions","$stable","hasPropsChanged","dynamicProps","nextKeys","updateHOCHostEl","el","subTree","isSuspense","__isSuspense","normalizeSuspenseChildren","content","fallback","normalizeSuspenseSlot","default","s","singleChild","queueEffectWithSuspense","suspense","pendingBranch","initProps","rawProps","isStateful","isSSR","InternalObjectKey","propsDefaults","create","setFullProps","updateProps","rawPrevProps","rawCurrentProps","kebabKey","resolvePropValue","propsToUpdate","camelizedKey","needCastKeys","camelKey","opt","hasDefault","defaultValue","Function","setCurrentInstance","normalizePropsOptions","__props","extendProps","normalizedKey","validatePropName","prop","booleanIndex","getTypeIndex","stringIndex","String","getType","ctor","match","toString","isSameType","expectedTypes","findIndex","t","injectHook","hook","currentInstance","prepend","hooks","wrappedHook","__weh","isUnmounted","unshift","createHook","lifecycle","isInSSRComponentSetup","onBeforeMount","onMounted","onBeforeUpdate","onUpdated","onBeforeUnmount","onUnmounted","onRenderTriggered","onRenderTracked","onErrorCaptured","INITIAL_WATCHER_VALUE","watch","source","doWatch","immediate","deep","flush","onTrack","onTrigger","forceTrigger","traverse","onInvalidate","baseGetter","runner","queuePostRenderEffect","isMounted","recordInstanceBoundEffect","instanceWatch","publicThis","useTransitionState","state","isLeaving","isUnmounting","leavingVNodes","TransitionHookValidator","BaseTransitionImpl","name","mode","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","isSameVNodeType","leavingHooks","afterLeave","update","delayLeave","earlyRemove","delayedLeave","leavingVNodesCache","getLeavingNodesForType","_leaveCb","BaseTransition","callHook","leavingVNode","afterHook","cancelHook","called","_enterCb","cancelled","remove","isKeepAlive","ssContent","clone","ssFallback","keepComment","ret","keyedFragmentCount","Fragment","__isKeepAlive","RegExp","matches","pattern","split","test","onActivated","registerKeepAliveHook","onDeactivated","__wdc","current","isDeactivated","injectToKeepAliveRoot","keepAliveRoot","injected","resetShapeFlag","getInnerChild","isInternalKey","normalizeSlotValue","normalizeSlot","rawSlot","normalizeObjectSlots","rawSlots","normalizeVNodeSlots","initSlots","_","updateSlots","needDeletionCheck","deletionComparisonTarget","withDirectives","directives","internalInstance","bindings","dir","arg","modifiers","mounted","updated","invokeDirectiveHook","oldBindings","binding","createAppContext","app","isNativeTag","NO","performance","globalProperties","optionMergeStrategies","isCustomElement","warnHandler","components","provides","createAppAPI","hydrate","rootComponent","rootProps","context","installedPlugins","_uid","_component","_props","_container","_context","version","plugin","install","mixin","directive","rootContainer","isHydrate","isSVG","__vue_app__","initFeatureFlags","defineComponent","setup","isAsyncWrapper","__asyncLoader","prodEffectOptions","setRef","rawRef","oldRawRef","parentSuspense","exposed","owner","oldRef","refs","doSet","createRenderer","baseCreateRenderer","createHydrationFns","insert","hostInsert","hostRemove","patchProp","hostPatchProp","forcePatchProp","hostForcePatchProp","createElement","hostCreateElement","createText","hostCreateText","createComment","hostCreateComment","setText","hostSetText","setElementText","hostSetElementText","parentNode","hostParentNode","nextSibling","hostNextSibling","setScopeId","hostSetScopeId","cloneNode","hostCloneNode","insertStaticContent","hostInsertStaticContent","patch","n1","n2","container","anchor","parentComponent","slotScopeIds","getNextHostNode","unmount","dynamicChildren","Text","processText","processCommentNode","Static","mountStaticNode","processFragment","processElement","processComponent","process","internals","moveStaticNode","removeStaticNode","mountElement","patchElement","vnodeHook","is","mountChildren","unmountChildren","onVnodeBeforeMount","invokeVNodeHook","scopeId","needCallTransitionHooks","beforeEnter","onVnodeMounted","enter","parentVNode","cloneIfMounted","oldProps","newProps","onVnodeBeforeUpdate","patchProps","class","style","areChildrenSVG","patchBlockChildren","patchChildren","onVnodeUpdated","oldChildren","newChildren","fallbackContainer","oldVNode","newVNode","fragmentStartAnchor","fragmentEndAnchor","fragmentSlotScopeIds","traverseStaticChildren","activate","mountComponent","updateComponent","initialVNode","createComponentInstance","renderer","setupComponent","asyncDep","registerDep","setupRenderEffect","placeholder","asyncResolved","updateComponentPreRender","bu","u","originNext","nextTree","prevTree","bm","m","hydrateNode","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","move","moveType","needTransition","leave","performLeave","doRemove","deactivate","shouldInvokeDirs","onVnodeBeforeUnmount","unmountComponent","onVnodeUnmounted","removeFragment","performRemove","bum","um","suspenseId","pendingId","_vnode","mt","mc","pc","pbc","o","createApp","ch1","ch2","c","len","arrI","isTeleport","__isTeleport","COMPONENTS","resolveComponent","maybeSelfReference","resolveAsset","NULL_DYNAMIC_COMPONENT","warnMissing","selfName","getComponentName","registry","currentBlock","disableTracking","createBlock","__v_isVNode","normalizeKey","normalizeRef","_createVNode","isBlockNode","cloned","normalizeChildren","isClassComponent","__vccOpts","klass","targetAnchor","staticCount","extraProps","mergeRef","mergedProps","mergeProps","createTextVNode","text","flag","slot","slotFlag","toMerge","existing","incoming","provide","parentProvides","inject","treatDefaultAsFactory","arguments","shouldCacheAccess","applyOptions","deferredData","deferredWatch","deferredProvide","extendsOptions","dataOptions","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","callHookWithMixinAndExtends","base","selfHook","createPathGetter","path","segments","resolveMergedOptions","__merged","mergeOptions","to","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","da","rtg","rtc","compile","setupResult","setupStatefulComponent","createSetupContext","resolvedResult","handleSetupResult","e","finishComponentSetup","template","delimiters","_rc","displayName","h","propsOrChildren","svgNS","doc","document","tempContainer","tempSVGContainer","nodeOps","insertBefore","removeChild","tag","createElementNS","multiple","setAttribute","createTextNode","node","nodeValue","textContent","querySelector","selector","temp","innerHTML","first","firstChild","patchClass","transitionClasses","_vtc","join","className","patchStyle","display","cssText","setStyle","removeAttribute","importantRE","setProperty","prefixed","autoPrefix","prefixes","prefixCache","rawName","cached","xlinkNS","patchAttr","removeAttributeNS","setAttributeNS","isBoolean","patchDOMProp","tagName","_getNow","Date","now","skipTimestampCheck","window","createEvent","timeStamp","ffMatch","navigator","userAgent","cachedNow","reset","getNow","addEventListener","removeEventListener","patchEvent","prevValue","nextValue","invokers","_vei","existingInvoker","parseName","invoker","createInvoker","optionsModifierRE","initialValue","attached","patchStopImmediatePropagation","originalStop","stopImmediatePropagation","_stopped","nativeOnRE","shouldSetAsProp","_trueValue","_falseValue","TRANSITION","ANIMATION","Transition","resolveTransitionProps","DOMTransitionPropsValidators","css","duration","enterFromClass","enterActiveClass","enterToClass","appearFromClass","appearActiveClass","appearToClass","leaveFromClass","leaveActiveClass","leaveToClass","baseProps","durations","normalizeDuration","enterDuration","leaveDuration","finishEnter","isAppear","removeTransitionClass","finishLeave","makeEnterHook","nextFrame","addTransitionClass","whenTransitionEnds","forceReflow","NumberOf","cls","classList","requestAnimationFrame","endId","expectedType","explicitTimeout","_endId","resolveIfNotStale","setTimeout","timeout","propCount","getTransitionInfo","endEvent","ended","onEnd","styles","getComputedStyle","getStyleProperties","transitionDelays","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationDurations","animationTimeout","max","hasTransform","delays","toMs","body","offsetHeight","vShow","_vod","setDisplay","rendererOptions","ensureRenderer","mount","containerOrSelector","normalizeContainer","SVGElement","Element","makeMap","str","expectsLowerCase","list","GLOBALS_WHITE_LISTED","isGloballyWhitelisted","specialBooleanAttrs","isSpecialBooleanAttr","normalizeStyle","isArray","item","isString","parseStringStyle","isObject","listDelimiterRE","propertyDelimiterRE","tmp","normalizeClass","looseCompareArrays","equal","looseEqual","aValidType","isDate","bValidType","getTime","aKeysCount","bKeysCount","aHasKey","hasOwnProperty","bHasKey","looseIndexOf","EMPTY_OBJ","EMPTY_ARR","NOOP","onRE","isOn","extend","assign","hasOwn","isMap","toTypeString","isSet","isFunction","isSymbol","isPromise","objectToString","toRawType","isIntegerKey","parseInt","isReservedProp","cacheStringFunction","cache","hit","camelizeRE","camelize","toUpperCase","hyphenateRE","hyphenate","capitalize","charAt","toHandlerKey","hasChanged","invokeArrayFns","fns","def","obj","toNumber","parseFloat","isNaN","global","factory","module","exports","_defineProperty","writable","enumerableOnly","getOwnPropertySymbols","symbols","sym","getOwnPropertyDescriptor","_objectSpread2","getOwnPropertyDescriptors","defineProperties","domReady","readyState","arrayUnique","array","isTesting","checkedAttrLooseCompare","valueA","valueB","warnIfMalformedTemplate","warn","childElementCount","kebabCase","subject","camelCase","char","walk","firstElementChild","nextElementSibling","debounce","func","wait","later","clearTimeout","expression","tryCatch","saferEval","dataContext","additionalHelperVariables","saferEvalNoReturn","AsyncFunction","async","constructor","methodReference","xAttrRE","isXAttr","attr","replaceAtAndColonWithStandardSyntax","getXAttrs","attributes","parseHtmlAttribute","spreadDirective","spreadObject","entries","sortDirectives","directiveOrder","typeA","typeB","normalizedName","typeMatch","valueMatch","isBooleanAttr","attrName","booleanAttributes","convertClassStringToArray","filterFn","TRANSITION_TYPE_IN","TRANSITION_TYPE_OUT","TRANSITION_CANCELLED","transitionIn","show","reject","forceSkip","__x_transition","showAttr","settingBothSidesOfTransition","transitionHelperIn","transitionClassesIn","transitionOut","hide","transitionHelperOut","transitionClassesOut","showCallback","styleValues","modifierValue","origin","opacity","scale","second","transitionHelper","hideCallback","isNumeric","hook1","hook2","cancel","opacityCache","transformCache","transform","transformOriginCache","transformOrigin","noModifiers","transitionOpacity","transitionScale","stages","transitionProperty","transitionDuration","transitionTimingFunction","ensureStringExpression","evaluateReturnExpression","find","enterStart","enterEnd","leaveStart","leaveEnd","classesDuring","classesStart","classesEnd","originalClasses","__x_original_classes","finish","once","isConnected","during","animationDuration","handleForDirective","templateEl","initialUpdate","extraVars","iteratorNames","parseForExpression","items","evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement","currentEl","iterationScopeVariables","getIterationScopeVariables","currentKey","generateKeyForIteration","nextEl","lookAheadForMatchingKeyedElementAndMoveItIfFound","__x_for_key","__x_for","updateElements","addElementInLoopAfterCurrentEl","initializeElements","removeAnyLeftOverElementsFromPreviousUpdate","forIteratorRE","stripParensRE","forAliasRE","inMatch","iteratorMatch","collection","scopeVariables","bindKeyAttribute","ifAttribute","importNode","parentElement","tmpNextEl","nextElementFromOldLoop","nextElementFromOldLoopImmutable","handleAttributeBindingDirective","attrType","Alpine","ignoreFocusedForValueBinding","activeElement","isSameNode","checked","updateSelect","keysSortedByBooleanValue","classNames","newClasses","setIfChanged","getAttribute","arrayWrappedValue","option","selected","handleTextDirective","output","handleHtmlDirective","handleShowDirective","__x_is_shown","removeProperty","handle","showDirectiveLastElement","contains","executeAndClearRemainingShowDirectiveStack","showDirectiveStack","handleIfDirective","expressionResult","elementHasAlreadyBeenAdded","__x_inserted_me","registerListener","passive","listenerTarget","offsetWidth","runListenerHandler","isKeyEvent","isListeningForASpecificKeyThatHasntBeenPressed","preventDefault","stopPropagation","returnValue","nextModifier","evaluateCommandExpression","keyModifiers","debounceIndex","keyToModifier","systemKeyModifiers","selectedSystemKeyModifiers","modifier","activelyPressedKeyModifiers","registerModelListener","listenerExpression","rightSideOfExpression","generateModelAssignmentFunction","hasAttribute","currentValue","CustomEvent","detail","safeParseNumber","selectedOptions","ObjectCreate","ObjectDefineProperty","ObjectDefineProperties","preventExtensions","ArrayPush","ArrayConcat","ArrayMap","isUndefined","proxyToValueMap","registerProxy","unwrap","replicaOrAny","wrapValue","membrane","valueIsObservable","getProxy","unwrapDescriptor","descriptor","lockShadowTarget","shadowTarget","originalTarget","targetKeys","wrapDescriptor","ReactiveProxyHandler","valueObserved","valueMutated","argArray","newTarget","shadowIsExtensible","targetIsExtensible","desc","shadowDescriptor","originalDescriptor","wrapReadOnlyValue","getReadOnlyProxy","ReadOnlyHandler","createShadowTarget","ObjectDotPrototype","defaultValueIsObservable","defaultValueObserved","defaultValueMutated","defaultValueDistortion","getValue","unwrapProxy","ReactiveMembrane","valueDistortion","objectGraph","unwrappedValue","distorted","getReactiveState","readOnly","distortedValue","reactiveState","reactiveHandler","readOnlyHandler","mutationCallback","unwrap$1","observable","unwrappedData","copy","componentForClone","dataAttr","dataExpression","initExpression","dataExtras","canonicalComponentElementReference","magicProperties","unobservedData","getUnobservedData","wrapDataInObservable","initReturnedCallback","getRefsProxy","nextTickStack","watchers","property","onBeforeComponentInitializeds","pauseReactivity","listenForNewElementsToInitialize","onComponentInitializeds","updateDom","fullDotNotationKey","dotNotationParts","reduce","comparisonData","part","initializeComponentCallback","__x","rootEl","walkAndSkipNestedComponents","initializeElement","executeAndClearNextTickStack","shouldRegisterListeners","registerListeners","resolveBoundAttributes","updateElement","shift","reverse","promiseChain","promise","finishElement","$dispatch","getDispatchFunction","dispatchEvent","bubbles","targetNode","observerOptions","childList","subtree","observer","MutationObserver","mutations","closestParentComponent","closest","attributeName","xAttr","rawData","addedNodes","nodeType","observe","refObj","pauseMutationObserver","discoverComponents","initializeComponent","discoverUninitializedComponents","listenForNewUninitializedComponentsAtRunTime","rootEls","querySelectorAll","newEl","addMagicProperty","onComponentInitialized","onBeforeComponentInitialized","deferLoadingAlpine","waitWindowLoad","isLocalhost","location","hostname","register","swUrl","registrationOptions","checkValidServiceWorker","serviceWorker","ready","registration","registerValidSW","onLine","waiting","onupdatefound","installingWorker","installing","onstatechange","controller","fetch","response","status","Error","unregister","headers","hasSymbol","toStringTag","PolySymbol","matchedRouteKey","viewDepthKey","routerKey","routeLocationKey","routerViewLocationKey","isBrowser","isESModule","__esModule","applyToParams","params","newParams","noop","TRAILING_SLASH_RE","removeTrailingSlash","parseURL","parseQuery","currentLocation","query","searchString","hash","searchPos","hashPos","resolveRelativePath","fullPath","stringifyURL","stringifyQuery","stripBase","pathname","isSameRouteLocation","aLastIndex","matched","bLastIndex","isSameRouteRecord","isSameRouteLocationParams","aliasOf","isSameRouteLocationParamsValue","isEquivalentArray","every","fromSegments","toSegments","toPosition","segment","position","NavigationType","NavigationDirection","normalizeBase","baseEl","BEFORE_HASH_RE","createHref","getElementPosition","offset","docRect","documentElement","getBoundingClientRect","elRect","behavior","left","top","computeScrollPosition","pageXOffset","pageYOffset","scrollToPosition","scrollToOptions","positionEl","isIdSelector","getElementById","scrollTo","getScrollKey","delta","history","scrollPositions","saveScrollPosition","scrollPosition","getSavedScrollPosition","scroll","createBaseLocation","protocol","host","createCurrentLocation","search","pathFromHash","useHistoryListeners","historyState","listeners","teardowns","pauseState","popStateHandler","fromState","listener","direction","forward","back","unknown","pauseListeners","listen","teardown","beforeUnloadListener","replaceState","destroy","buildState","replaced","computeScroll","useHistoryStateNavigation","changeLocation","hashIndex","url","currentState","createWebHistory","historyNavigation","historyListeners","go","triggerListeners","routerHistory","isRouteLocation","route","isRouteName","START_LOCATION_NORMALIZED","meta","redirectedFrom","NavigationFailureSymbol","NavigationFailureType","createRouterError","isNavigationFailure","BASE_PARAM_PATTERN","BASE_PATH_PARSER_OPTIONS","sensitive","strict","REGEX_CHARS_RE","tokensToParser","extraOptions","score","segmentScores","tokenIndex","token","subSegmentScore","repeatable","optional","regexp","re","message","subPattern","parse","stringify","avoidDuplicatedSlash","endsWith","param","compareScoreArray","diff","comparePathParserScore","aScore","bScore","ROOT_TOKEN","VALID_PARAM_RE","tokenizePath","crash","buffer","previousState","tokens","finalizeSegment","customRe","consumeBuffer","addCharToBuffer","createRouteRecordMatcher","record","parser","matcher","alias","createRouterMatcher","routes","globalOptions","matchers","matcherMap","getRecordMatcher","addRoute","originalRecord","isRootAdd","mainNormalizedRecord","normalizeRouteRecord","normalizedRecords","aliases","originalMatcher","normalizedRecord","parentPath","connectingSlash","isAliasRecord","removeRoute","insertMatcher","matcherRef","getRoutes","paramsFromLocation","k","parentMatcher","mergeMetaFields","redirect","normalizeRecordProps","instances","leaveGuards","updateGuards","enterCallbacks","propsObject","defaults","partialOptions","HASH_RE","AMPERSAND_RE","SLASH_RE","EQUAL_RE","IM_RE","PLUS_RE","ENC_BRACKET_OPEN_RE","ENC_BRACKET_CLOSE_RE","ENC_CARET_RE","ENC_BACKTICK_RE","ENC_CURLY_OPEN_RE","ENC_PIPE_RE","ENC_CURLY_CLOSE_RE","ENC_SPACE_RE","commonEncode","encodeURI","encodeHash","encodeQueryValue","encodeQueryKey","encodePath","encodeParam","decode","decodeURIComponent","hasLeadingIM","searchParams","searchParam","eqPos","normalizeQuery","normalizedQuery","useCallbacks","handlers","guardToPromiseFn","guard","enterCallbackArray","valid","guardReturn","guardCall","extractComponentsGuards","guardType","guards","rawComponent","isRouteComponent","componentPromise","resolved","resolvedComponent","useLink","router","currentRoute","activeRecordIndex","routeMatched","currentMatched","parentRecordPath","getOriginalPath","isActive","includesParams","isExactActive","navigate","guardEvent","href","RouterLinkImpl","required","activeClass","exactActiveClass","custom","ariaCurrentValue","link","elClass","getLinkClass","linkActiveClass","linkExactActiveClass","onClick","RouterLink","metaKey","altKey","ctrlKey","shiftKey","defaultPrevented","button","currentTarget","outer","inner","innerValue","outerValue","propClass","globalClass","defaultClass","RouterViewImpl","injectedRoute","routeToDisplay","depth","matchedRouteRef","viewRef","oldInstance","oldName","matchedRoute","ViewComponent","currentName","routePropsOption","routeProps","slotContent","RouterView","createRouter","parseQuery$1","stringifyQuery$1","beforeGuards","beforeResolveGuards","afterGuards","pendingLocation","scrollBehavior","scrollRestoration","normalizeParams","paramValue","encodeParams","decodeParams","parentOrRoute","recordMatcher","routeMatcher","hasRoute","rawLocation","locationNormalized","matcherLocation","locationAsObject","checkCanceledNavigation","pushWithRedirect","handleRedirectRecord","lastMatched","newTargetLocation","targetLocation","force","shouldRedirect","toLocation","failure","handleScroll","triggerError","finalizeNavigation","triggerAfterEach","checkCanceledNavigationAndReject","leavingRecords","updatingRecords","enteringRecords","extractChangingRecords","canceledNavigationCheck","runGuardQueue","isPush","isFirstNavigation","markAsReady","removeHistoryListener","setupListeners","_from","info","readyHandlers","errorHandlers","isReady","started","installedApps","beforeEach","beforeResolve","afterEach","onError","$router","reactiveRoute","unmountApp","recordFrom","recordTo"],"mappings":"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","file":"js/chunk-vendors.3fa8c33f.js","sourcesContent":["import { createVNode as _createVNode, openBlock as _openBlock, createBlock as _createBlock } from \"vue\"\n\nexport default function render(_ctx, _cache) {\n  return (_openBlock(), _createBlock(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    fill: \"none\",\n    viewBox: \"0 0 24 24\",\n    stroke: \"currentColor\"\n  }, [\n    _createVNode(\"path\", {\n      \"stroke-linecap\": \"round\",\n      \"stroke-linejoin\": \"round\",\n      \"stroke-width\": \"2\",\n      d: \"M3 8l7.89 5.26a2 2 0 002.22 0L21 8M5 19h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v10a2 2 0 002 2z\"\n    })\n  ]))\n}","import { EMPTY_OBJ, isArray, isMap, isIntegerKey, isSymbol, extend, hasOwn, isObject, hasChanged, makeMap, capitalize, toRawType, def, isFunction, NOOP } from '@vue/shared';\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n    return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n    if (isEffect(fn)) {\r\n        fn = fn.raw;\r\n    }\r\n    const effect = createReactiveEffect(fn, options);\r\n    if (!options.lazy) {\r\n        effect();\r\n    }\r\n    return effect;\r\n}\r\nfunction stop(effect) {\r\n    if (effect.active) {\r\n        cleanup(effect);\r\n        if (effect.options.onStop) {\r\n            effect.options.onStop();\r\n        }\r\n        effect.active = false;\r\n    }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n    const effect = function reactiveEffect() {\r\n        if (!effect.active) {\r\n            return options.scheduler ? undefined : fn();\r\n        }\r\n        if (!effectStack.includes(effect)) {\r\n            cleanup(effect);\r\n            try {\r\n                enableTracking();\r\n                effectStack.push(effect);\r\n                activeEffect = effect;\r\n                return fn();\r\n            }\r\n            finally {\r\n                effectStack.pop();\r\n                resetTracking();\r\n                activeEffect = effectStack[effectStack.length - 1];\r\n            }\r\n        }\r\n    };\r\n    effect.id = uid++;\r\n    effect.allowRecurse = !!options.allowRecurse;\r\n    effect._isEffect = true;\r\n    effect.active = true;\r\n    effect.raw = fn;\r\n    effect.deps = [];\r\n    effect.options = options;\r\n    return effect;\r\n}\r\nfunction cleanup(effect) {\r\n    const { deps } = effect;\r\n    if (deps.length) {\r\n        for (let i = 0; i < deps.length; i++) {\r\n            deps[i].delete(effect);\r\n        }\r\n        deps.length = 0;\r\n    }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n    trackStack.push(shouldTrack);\r\n    shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n    trackStack.push(shouldTrack);\r\n    shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n    const last = trackStack.pop();\r\n    shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n    if (!shouldTrack || activeEffect === undefined) {\r\n        return;\r\n    }\r\n    let depsMap = targetMap.get(target);\r\n    if (!depsMap) {\r\n        targetMap.set(target, (depsMap = new Map()));\r\n    }\r\n    let dep = depsMap.get(key);\r\n    if (!dep) {\r\n        depsMap.set(key, (dep = new Set()));\r\n    }\r\n    if (!dep.has(activeEffect)) {\r\n        dep.add(activeEffect);\r\n        activeEffect.deps.push(dep);\r\n        if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n            activeEffect.options.onTrack({\r\n                effect: activeEffect,\r\n                target,\r\n                type,\r\n                key\r\n            });\r\n        }\r\n    }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n    const depsMap = targetMap.get(target);\r\n    if (!depsMap) {\r\n        // never been tracked\r\n        return;\r\n    }\r\n    const effects = new Set();\r\n    const add = (effectsToAdd) => {\r\n        if (effectsToAdd) {\r\n            effectsToAdd.forEach(effect => {\r\n                if (effect !== activeEffect || effect.allowRecurse) {\r\n                    effects.add(effect);\r\n                }\r\n            });\r\n        }\r\n    };\r\n    if (type === \"clear\" /* CLEAR */) {\r\n        // collection being cleared\r\n        // trigger all effects for target\r\n        depsMap.forEach(add);\r\n    }\r\n    else if (key === 'length' && isArray(target)) {\r\n        depsMap.forEach((dep, key) => {\r\n            if (key === 'length' || key >= newValue) {\r\n                add(dep);\r\n            }\r\n        });\r\n    }\r\n    else {\r\n        // schedule runs for SET | ADD | DELETE\r\n        if (key !== void 0) {\r\n            add(depsMap.get(key));\r\n        }\r\n        // also run for iteration key on ADD | DELETE | Map.SET\r\n        switch (type) {\r\n            case \"add\" /* ADD */:\r\n                if (!isArray(target)) {\r\n                    add(depsMap.get(ITERATE_KEY));\r\n                    if (isMap(target)) {\r\n                        add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n                    }\r\n                }\r\n                else if (isIntegerKey(key)) {\r\n                    // new index added to array -> length changes\r\n                    add(depsMap.get('length'));\r\n                }\r\n                break;\r\n            case \"delete\" /* DELETE */:\r\n                if (!isArray(target)) {\r\n                    add(depsMap.get(ITERATE_KEY));\r\n                    if (isMap(target)) {\r\n                        add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n                    }\r\n                }\r\n                break;\r\n            case \"set\" /* SET */:\r\n                if (isMap(target)) {\r\n                    add(depsMap.get(ITERATE_KEY));\r\n                }\r\n                break;\r\n        }\r\n    }\r\n    const run = (effect) => {\r\n        if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n            effect.options.onTrigger({\r\n                effect,\r\n                target,\r\n                key,\r\n                type,\r\n                newValue,\r\n                oldValue,\r\n                oldTarget\r\n            });\r\n        }\r\n        if (effect.options.scheduler) {\r\n            effect.options.scheduler(effect);\r\n        }\r\n        else {\r\n            effect();\r\n        }\r\n    };\r\n    effects.forEach(run);\r\n}\n\nconst isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);\r\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n    .map(key => Symbol[key])\r\n    .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n    const method = Array.prototype[key];\r\n    arrayInstrumentations[key] = function (...args) {\r\n        const arr = toRaw(this);\r\n        for (let i = 0, l = this.length; i < l; i++) {\r\n            track(arr, \"get\" /* GET */, i + '');\r\n        }\r\n        // we run the method using the original args first (which may be reactive)\r\n        const res = method.apply(arr, args);\r\n        if (res === -1 || res === false) {\r\n            // if that didn't work, run it again using raw values.\r\n            return method.apply(arr, args.map(toRaw));\r\n        }\r\n        else {\r\n            return res;\r\n        }\r\n    };\r\n});\r\n['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n    const method = Array.prototype[key];\r\n    arrayInstrumentations[key] = function (...args) {\r\n        pauseTracking();\r\n        const res = method.apply(this, args);\r\n        resetTracking();\r\n        return res;\r\n    };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n    return function get(target, key, receiver) {\r\n        if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n            return !isReadonly;\r\n        }\r\n        else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n            return isReadonly;\r\n        }\r\n        else if (key === \"__v_raw\" /* RAW */ &&\r\n            receiver ===\r\n                (isReadonly\r\n                    ? shallow\r\n                        ? shallowReadonlyMap\r\n                        : readonlyMap\r\n                    : shallow\r\n                        ? shallowReactiveMap\r\n                        : reactiveMap).get(target)) {\r\n            return target;\r\n        }\r\n        const targetIsArray = isArray(target);\r\n        if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n            return Reflect.get(arrayInstrumentations, key, receiver);\r\n        }\r\n        const res = Reflect.get(target, key, receiver);\r\n        if (isSymbol(key)\r\n            ? builtInSymbols.has(key)\r\n            : isNonTrackableKeys(key)) {\r\n            return res;\r\n        }\r\n        if (!isReadonly) {\r\n            track(target, \"get\" /* GET */, key);\r\n        }\r\n        if (shallow) {\r\n            return res;\r\n        }\r\n        if (isRef(res)) {\r\n            // ref unwrapping - does not apply for Array + integer key.\r\n            const shouldUnwrap = !targetIsArray || !isIntegerKey(key);\r\n            return shouldUnwrap ? res.value : res;\r\n        }\r\n        if (isObject(res)) {\r\n            // Convert returned value into a proxy as well. we do the isObject check\r\n            // here to avoid invalid value warning. Also need to lazy access readonly\r\n            // and reactive here to avoid circular dependency.\r\n            return isReadonly ? readonly(res) : reactive(res);\r\n        }\r\n        return res;\r\n    };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n    return function set(target, key, value, receiver) {\r\n        let oldValue = target[key];\r\n        if (!shallow) {\r\n            value = toRaw(value);\r\n            oldValue = toRaw(oldValue);\r\n            if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n                oldValue.value = value;\r\n                return true;\r\n            }\r\n        }\r\n        const hadKey = isArray(target) && isIntegerKey(key)\r\n            ? Number(key) < target.length\r\n            : hasOwn(target, key);\r\n        const result = Reflect.set(target, key, value, receiver);\r\n        // don't trigger if target is something up in the prototype chain of original\r\n        if (target === toRaw(receiver)) {\r\n            if (!hadKey) {\r\n                trigger(target, \"add\" /* ADD */, key, value);\r\n            }\r\n            else if (hasChanged(value, oldValue)) {\r\n                trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n            }\r\n        }\r\n        return result;\r\n    };\r\n}\r\nfunction deleteProperty(target, key) {\r\n    const hadKey = hasOwn(target, key);\r\n    const oldValue = target[key];\r\n    const result = Reflect.deleteProperty(target, key);\r\n    if (result && hadKey) {\r\n        trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction has(target, key) {\r\n    const result = Reflect.has(target, key);\r\n    if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n        track(target, \"has\" /* HAS */, key);\r\n    }\r\n    return result;\r\n}\r\nfunction ownKeys(target) {\r\n    track(target, \"iterate\" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);\r\n    return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n    get,\r\n    set,\r\n    deleteProperty,\r\n    has,\r\n    ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n    get: readonlyGet,\r\n    set(target, key) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n        }\r\n        return true;\r\n    },\r\n    deleteProperty(target, key) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n        }\r\n        return true;\r\n    }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n    get: shallowGet,\r\n    set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n    get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n    // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n    // of the value\r\n    target = target[\"__v_raw\" /* RAW */];\r\n    const rawTarget = toRaw(target);\r\n    const rawKey = toRaw(key);\r\n    if (key !== rawKey) {\r\n        !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n    }\r\n    !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n    const { has } = getProto(rawTarget);\r\n    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;\r\n    if (has.call(rawTarget, key)) {\r\n        return wrap(target.get(key));\r\n    }\r\n    else if (has.call(rawTarget, rawKey)) {\r\n        return wrap(target.get(rawKey));\r\n    }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n    const target = this[\"__v_raw\" /* RAW */];\r\n    const rawTarget = toRaw(target);\r\n    const rawKey = toRaw(key);\r\n    if (key !== rawKey) {\r\n        !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n    }\r\n    !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n    return key === rawKey\r\n        ? target.has(key)\r\n        : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n    target = target[\"__v_raw\" /* RAW */];\r\n    !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n    return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n    value = toRaw(value);\r\n    const target = toRaw(this);\r\n    const proto = getProto(target);\r\n    const hadKey = proto.has.call(target, value);\r\n    if (!hadKey) {\r\n        target.add(value);\r\n        trigger(target, \"add\" /* ADD */, value, value);\r\n    }\r\n    return this;\r\n}\r\nfunction set$1(key, value) {\r\n    value = toRaw(value);\r\n    const target = toRaw(this);\r\n    const { has, get } = getProto(target);\r\n    let hadKey = has.call(target, key);\r\n    if (!hadKey) {\r\n        key = toRaw(key);\r\n        hadKey = has.call(target, key);\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        checkIdentityKeys(target, has, key);\r\n    }\r\n    const oldValue = get.call(target, key);\r\n    target.set(key, value);\r\n    if (!hadKey) {\r\n        trigger(target, \"add\" /* ADD */, key, value);\r\n    }\r\n    else if (hasChanged(value, oldValue)) {\r\n        trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n    }\r\n    return this;\r\n}\r\nfunction deleteEntry(key) {\r\n    const target = toRaw(this);\r\n    const { has, get } = getProto(target);\r\n    let hadKey = has.call(target, key);\r\n    if (!hadKey) {\r\n        key = toRaw(key);\r\n        hadKey = has.call(target, key);\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        checkIdentityKeys(target, has, key);\r\n    }\r\n    const oldValue = get ? get.call(target, key) : undefined;\r\n    // forward the operation before queueing reactions\r\n    const result = target.delete(key);\r\n    if (hadKey) {\r\n        trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction clear() {\r\n    const target = toRaw(this);\r\n    const hadItems = target.size !== 0;\r\n    const oldTarget = (process.env.NODE_ENV !== 'production')\r\n        ? isMap(target)\r\n            ? new Map(target)\r\n            : new Set(target)\r\n        : undefined;\r\n    // forward the operation before queueing reactions\r\n    const result = target.clear();\r\n    if (hadItems) {\r\n        trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n    }\r\n    return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n    return function forEach(callback, thisArg) {\r\n        const observed = this;\r\n        const target = observed[\"__v_raw\" /* RAW */];\r\n        const rawTarget = toRaw(target);\r\n        const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;\r\n        !isReadonly && track(rawTarget, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n        return target.forEach((value, key) => {\r\n            // important: make sure the callback is\r\n            // 1. invoked with the reactive map as `this` and 3rd arg\r\n            // 2. the value received should be a corresponding reactive/readonly.\r\n            return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n        });\r\n    };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n    return function (...args) {\r\n        const target = this[\"__v_raw\" /* RAW */];\r\n        const rawTarget = toRaw(target);\r\n        const targetIsMap = isMap(rawTarget);\r\n        const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);\r\n        const isKeyOnly = method === 'keys' && targetIsMap;\r\n        const innerIterator = target[method](...args);\r\n        const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;\r\n        !isReadonly &&\r\n            track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n        // return a wrapped iterator which returns observed versions of the\r\n        // values emitted from the real iterator\r\n        return {\r\n            // iterator protocol\r\n            next() {\r\n                const { value, done } = innerIterator.next();\r\n                return done\r\n                    ? { value, done }\r\n                    : {\r\n                        value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n                        done\r\n                    };\r\n            },\r\n            // iterable protocol\r\n            [Symbol.iterator]() {\r\n                return this;\r\n            }\r\n        };\r\n    };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n    return function (...args) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n            console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n        }\r\n        return type === \"delete\" /* DELETE */ ? false : this;\r\n    };\r\n}\r\nconst mutableInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key);\r\n    },\r\n    get size() {\r\n        return size(this);\r\n    },\r\n    has: has$1,\r\n    add,\r\n    set: set$1,\r\n    delete: deleteEntry,\r\n    clear,\r\n    forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, false, true);\r\n    },\r\n    get size() {\r\n        return size(this);\r\n    },\r\n    has: has$1,\r\n    add,\r\n    set: set$1,\r\n    delete: deleteEntry,\r\n    clear,\r\n    forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, true);\r\n    },\r\n    get size() {\r\n        return size(this, true);\r\n    },\r\n    has(key) {\r\n        return has$1.call(this, key, true);\r\n    },\r\n    add: createReadonlyMethod(\"add\" /* ADD */),\r\n    set: createReadonlyMethod(\"set\" /* SET */),\r\n    delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n    clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n    forEach: createForEach(true, false)\r\n};\r\nconst shallowReadonlyInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, true, true);\r\n    },\r\n    get size() {\r\n        return size(this, true);\r\n    },\r\n    has(key) {\r\n        return has$1.call(this, key, true);\r\n    },\r\n    add: createReadonlyMethod(\"add\" /* ADD */),\r\n    set: createReadonlyMethod(\"set\" /* SET */),\r\n    delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n    clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n    forEach: createForEach(true, true)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n    mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n    readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n    shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n    shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n    const instrumentations = shallow\r\n        ? isReadonly\r\n            ? shallowReadonlyInstrumentations\r\n            : shallowInstrumentations\r\n        : isReadonly\r\n            ? readonlyInstrumentations\r\n            : mutableInstrumentations;\r\n    return (target, key, receiver) => {\r\n        if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n            return !isReadonly;\r\n        }\r\n        else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n            return isReadonly;\r\n        }\r\n        else if (key === \"__v_raw\" /* RAW */) {\r\n            return target;\r\n        }\r\n        return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n            ? instrumentations\r\n            : target, key, receiver);\r\n    };\r\n}\r\nconst mutableCollectionHandlers = {\r\n    get: createInstrumentationGetter(false, false)\r\n};\r\nconst shallowCollectionHandlers = {\r\n    get: createInstrumentationGetter(false, true)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n    get: createInstrumentationGetter(true, false)\r\n};\r\nconst shallowReadonlyCollectionHandlers = {\r\n    get: createInstrumentationGetter(true, true)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n    const rawKey = toRaw(key);\r\n    if (rawKey !== key && has.call(target, rawKey)) {\r\n        const type = toRawType(target);\r\n        console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n            `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +\r\n            `which can lead to inconsistencies. ` +\r\n            `Avoid differentiating between the raw and reactive versions ` +\r\n            `of an object and only use the reactive version if possible.`);\r\n    }\r\n}\n\nconst reactiveMap = new WeakMap();\r\nconst shallowReactiveMap = new WeakMap();\r\nconst readonlyMap = new WeakMap();\r\nconst shallowReadonlyMap = new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n    switch (rawType) {\r\n        case 'Object':\r\n        case 'Array':\r\n            return 1 /* COMMON */;\r\n        case 'Map':\r\n        case 'Set':\r\n        case 'WeakMap':\r\n        case 'WeakSet':\r\n            return 2 /* COLLECTION */;\r\n        default:\r\n            return 0 /* INVALID */;\r\n    }\r\n}\r\nfunction getTargetType(value) {\r\n    return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n        ? 0 /* INVALID */\r\n        : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n    // if trying to observe a readonly proxy, return the readonly version.\r\n    if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n        return target;\r\n    }\r\n    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);\r\n}\r\n/**\r\n * Return a shallowly-reactive copy of the original object, where only the root\r\n * level properties are reactive. It also does not auto-unwrap refs (even at the\r\n * root level).\r\n */\r\nfunction shallowReactive(target) {\r\n    return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);\r\n}\r\n/**\r\n * Creates a readonly copy of the original object. Note the returned copy is not\r\n * made reactive, but `readonly` can be called on an already reactive object.\r\n */\r\nfunction readonly(target) {\r\n    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);\r\n}\r\n/**\r\n * Returns a reactive-copy of the original object, where only the root level\r\n * properties are readonly, and does NOT unwrap refs nor recursively convert\r\n * returned properties.\r\n * This is used for creating the props proxy object for stateful components.\r\n */\r\nfunction shallowReadonly(target) {\r\n    return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {\r\n    if (!isObject(target)) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`value cannot be made reactive: ${String(target)}`);\r\n        }\r\n        return target;\r\n    }\r\n    // target is already a Proxy, return it.\r\n    // exception: calling readonly() on a reactive object\r\n    if (target[\"__v_raw\" /* RAW */] &&\r\n        !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n        return target;\r\n    }\r\n    // target already has corresponding Proxy\r\n    const existingProxy = proxyMap.get(target);\r\n    if (existingProxy) {\r\n        return existingProxy;\r\n    }\r\n    // only a whitelist of value types can be observed.\r\n    const targetType = getTargetType(target);\r\n    if (targetType === 0 /* INVALID */) {\r\n        return target;\r\n    }\r\n    const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n    proxyMap.set(target, proxy);\r\n    return proxy;\r\n}\r\nfunction isReactive(value) {\r\n    if (isReadonly(value)) {\r\n        return isReactive(value[\"__v_raw\" /* RAW */]);\r\n    }\r\n    return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n    return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n    return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n    return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction markRaw(value) {\r\n    def(value, \"__v_skip\" /* SKIP */, true);\r\n    return value;\r\n}\n\nconst convert = (val) => isObject(val) ? reactive(val) : val;\r\nfunction isRef(r) {\r\n    return Boolean(r && r.__v_isRef === true);\r\n}\r\nfunction ref(value) {\r\n    return createRef(value);\r\n}\r\nfunction shallowRef(value) {\r\n    return createRef(value, true);\r\n}\r\nclass RefImpl {\r\n    constructor(_rawValue, _shallow = false) {\r\n        this._rawValue = _rawValue;\r\n        this._shallow = _shallow;\r\n        this.__v_isRef = true;\r\n        this._value = _shallow ? _rawValue : convert(_rawValue);\r\n    }\r\n    get value() {\r\n        track(toRaw(this), \"get\" /* GET */, 'value');\r\n        return this._value;\r\n    }\r\n    set value(newVal) {\r\n        if (hasChanged(toRaw(newVal), this._rawValue)) {\r\n            this._rawValue = newVal;\r\n            this._value = this._shallow ? newVal : convert(newVal);\r\n            trigger(toRaw(this), \"set\" /* SET */, 'value', newVal);\r\n        }\r\n    }\r\n}\r\nfunction createRef(rawValue, shallow = false) {\r\n    if (isRef(rawValue)) {\r\n        return rawValue;\r\n    }\r\n    return new RefImpl(rawValue, shallow);\r\n}\r\nfunction triggerRef(ref) {\r\n    trigger(toRaw(ref), \"set\" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? ref.value : void 0);\r\n}\r\nfunction unref(ref) {\r\n    return isRef(ref) ? ref.value : ref;\r\n}\r\nconst shallowUnwrapHandlers = {\r\n    get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),\r\n    set: (target, key, value, receiver) => {\r\n        const oldValue = target[key];\r\n        if (isRef(oldValue) && !isRef(value)) {\r\n            oldValue.value = value;\r\n            return true;\r\n        }\r\n        else {\r\n            return Reflect.set(target, key, value, receiver);\r\n        }\r\n    }\r\n};\r\nfunction proxyRefs(objectWithRefs) {\r\n    return isReactive(objectWithRefs)\r\n        ? objectWithRefs\r\n        : new Proxy(objectWithRefs, shallowUnwrapHandlers);\r\n}\r\nclass CustomRefImpl {\r\n    constructor(factory) {\r\n        this.__v_isRef = true;\r\n        const { get, set } = factory(() => track(this, \"get\" /* GET */, 'value'), () => trigger(this, \"set\" /* SET */, 'value'));\r\n        this._get = get;\r\n        this._set = set;\r\n    }\r\n    get value() {\r\n        return this._get();\r\n    }\r\n    set value(newVal) {\r\n        this._set(newVal);\r\n    }\r\n}\r\nfunction customRef(factory) {\r\n    return new CustomRefImpl(factory);\r\n}\r\nfunction toRefs(object) {\r\n    if ((process.env.NODE_ENV !== 'production') && !isProxy(object)) {\r\n        console.warn(`toRefs() expects a reactive object but received a plain one.`);\r\n    }\r\n    const ret = isArray(object) ? new Array(object.length) : {};\r\n    for (const key in object) {\r\n        ret[key] = toRef(object, key);\r\n    }\r\n    return ret;\r\n}\r\nclass ObjectRefImpl {\r\n    constructor(_object, _key) {\r\n        this._object = _object;\r\n        this._key = _key;\r\n        this.__v_isRef = true;\r\n    }\r\n    get value() {\r\n        return this._object[this._key];\r\n    }\r\n    set value(newVal) {\r\n        this._object[this._key] = newVal;\r\n    }\r\n}\r\nfunction toRef(object, key) {\r\n    return isRef(object[key])\r\n        ? object[key]\r\n        : new ObjectRefImpl(object, key);\r\n}\n\nclass ComputedRefImpl {\r\n    constructor(getter, _setter, isReadonly) {\r\n        this._setter = _setter;\r\n        this._dirty = true;\r\n        this.__v_isRef = true;\r\n        this.effect = effect(getter, {\r\n            lazy: true,\r\n            scheduler: () => {\r\n                if (!this._dirty) {\r\n                    this._dirty = true;\r\n                    trigger(toRaw(this), \"set\" /* SET */, 'value');\r\n                }\r\n            }\r\n        });\r\n        this[\"__v_isReadonly\" /* IS_READONLY */] = isReadonly;\r\n    }\r\n    get value() {\r\n        // the computed ref may get wrapped by other proxies e.g. readonly() #3376\r\n        const self = toRaw(this);\r\n        if (self._dirty) {\r\n            self._value = this.effect();\r\n            self._dirty = false;\r\n        }\r\n        track(self, \"get\" /* GET */, 'value');\r\n        return self._value;\r\n    }\r\n    set value(newValue) {\r\n        this._setter(newValue);\r\n    }\r\n}\r\nfunction computed(getterOrOptions) {\r\n    let getter;\r\n    let setter;\r\n    if (isFunction(getterOrOptions)) {\r\n        getter = getterOrOptions;\r\n        setter = (process.env.NODE_ENV !== 'production')\r\n            ? () => {\r\n                console.warn('Write operation failed: computed value is readonly');\r\n            }\r\n            : NOOP;\r\n    }\r\n    else {\r\n        getter = getterOrOptions.get;\r\n        setter = getterOrOptions.set;\r\n    }\r\n    return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);\r\n}\n\nexport { ITERATE_KEY, computed, customRef, effect, enableTracking, isProxy, isReactive, isReadonly, isRef, markRaw, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };\n","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","import { camelize, warn, callWithAsyncErrorHandling, getCurrentInstance, onMounted, watchEffect, onUpdated, Fragment, h, BaseTransition, useTransitionState, toRaw, getTransitionRawChildren, setTransitionHooks, resolveTransitionHooks, createVNode, createRenderer, isRuntimeOnly, createHydrationRenderer } from '@vue/runtime-core';\nexport * from '@vue/runtime-core';\nimport { isString, isArray, hyphenate, capitalize, isSpecialBooleanAttr, isOn, isModelListener, isFunction, EMPTY_OBJ, extend, isObject, toNumber, invokeArrayFns, looseIndexOf, isSet, looseEqual, isHTMLTag, isSVGTag } from '@vue/shared';\n\nconst svgNS = 'http://www.w3.org/2000/svg';\r\nconst doc = (typeof document !== 'undefined' ? document : null);\r\nlet tempContainer;\r\nlet tempSVGContainer;\r\nconst nodeOps = {\r\n    insert: (child, parent, anchor) => {\r\n        parent.insertBefore(child, anchor || null);\r\n    },\r\n    remove: child => {\r\n        const parent = child.parentNode;\r\n        if (parent) {\r\n            parent.removeChild(child);\r\n        }\r\n    },\r\n    createElement: (tag, isSVG, is, props) => {\r\n        const el = isSVG\r\n            ? doc.createElementNS(svgNS, tag)\r\n            : doc.createElement(tag, is ? { is } : undefined);\r\n        if (tag === 'select' && props && props.multiple != null) {\r\n            el.setAttribute('multiple', props.multiple);\r\n        }\r\n        return el;\r\n    },\r\n    createText: text => doc.createTextNode(text),\r\n    createComment: text => doc.createComment(text),\r\n    setText: (node, text) => {\r\n        node.nodeValue = text;\r\n    },\r\n    setElementText: (el, text) => {\r\n        el.textContent = text;\r\n    },\r\n    parentNode: node => node.parentNode,\r\n    nextSibling: node => node.nextSibling,\r\n    querySelector: selector => doc.querySelector(selector),\r\n    setScopeId(el, id) {\r\n        el.setAttribute(id, '');\r\n    },\r\n    cloneNode(el) {\r\n        const cloned = el.cloneNode(true);\r\n        // #3072\r\n        // - in `patchDOMProp`, we store the actual value in the `el._value` property.\r\n        // - normally, elements using `:value` bindings will not be hoisted, but if\r\n        //   the bound value is a constant, e.g. `:value=\"true\"` - they do get\r\n        //   hoisted.\r\n        // - in production, hoisted nodes are cloned when subsequent inserts, but\r\n        //   cloneNode() does not copy the custom property we attached.\r\n        // - This may need to account for other custom DOM properties we attach to\r\n        //   elements in addition to `_value` in the future.\r\n        if (`_value` in el) {\r\n            cloned._value = el._value;\r\n        }\r\n        return cloned;\r\n    },\r\n    // __UNSAFE__\r\n    // Reason: innerHTML.\r\n    // Static content here can only come from compiled templates.\r\n    // As long as the user only uses trusted templates, this is safe.\r\n    insertStaticContent(content, parent, anchor, isSVG) {\r\n        const temp = isSVG\r\n            ? tempSVGContainer ||\r\n                (tempSVGContainer = doc.createElementNS(svgNS, 'svg'))\r\n            : tempContainer || (tempContainer = doc.createElement('div'));\r\n        temp.innerHTML = content;\r\n        const first = temp.firstChild;\r\n        let node = first;\r\n        let last = node;\r\n        while (node) {\r\n            last = node;\r\n            nodeOps.insert(node, parent, anchor);\r\n            node = temp.firstChild;\r\n        }\r\n        return [first, last];\r\n    }\r\n};\n\n// compiler should normalize class + :class bindings on the same element\r\n// into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n    if (value == null) {\r\n        value = '';\r\n    }\r\n    if (isSVG) {\r\n        el.setAttribute('class', value);\r\n    }\r\n    else {\r\n        // directly setting className should be faster than setAttribute in theory\r\n        // if this is an element during a transition, take the temporary transition\r\n        // classes into account.\r\n        const transitionClasses = el._vtc;\r\n        if (transitionClasses) {\r\n            value = (value\r\n                ? [value, ...transitionClasses]\r\n                : [...transitionClasses]).join(' ');\r\n        }\r\n        el.className = value;\r\n    }\r\n}\n\nfunction patchStyle(el, prev, next) {\r\n    const style = el.style;\r\n    if (!next) {\r\n        el.removeAttribute('style');\r\n    }\r\n    else if (isString(next)) {\r\n        if (prev !== next) {\r\n            const current = style.display;\r\n            style.cssText = next;\r\n            // indicates that the `display` of the element is controlled by `v-show`,\r\n            // so we always keep the current `display` value regardless of the `style` value,\r\n            // thus handing over control to `v-show`.\r\n            if ('_vod' in el) {\r\n                style.display = current;\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        for (const key in next) {\r\n            setStyle(style, key, next[key]);\r\n        }\r\n        if (prev && !isString(prev)) {\r\n            for (const key in prev) {\r\n                if (next[key] == null) {\r\n                    setStyle(style, key, '');\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\nconst importantRE = /\\s*!important$/;\r\nfunction setStyle(style, name, val) {\r\n    if (isArray(val)) {\r\n        val.forEach(v => setStyle(style, name, v));\r\n    }\r\n    else {\r\n        if (name.startsWith('--')) {\r\n            // custom property definition\r\n            style.setProperty(name, val);\r\n        }\r\n        else {\r\n            const prefixed = autoPrefix(style, name);\r\n            if (importantRE.test(val)) {\r\n                // !important\r\n                style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');\r\n            }\r\n            else {\r\n                style[prefixed] = val;\r\n            }\r\n        }\r\n    }\r\n}\r\nconst prefixes = ['Webkit', 'Moz', 'ms'];\r\nconst prefixCache = {};\r\nfunction autoPrefix(style, rawName) {\r\n    const cached = prefixCache[rawName];\r\n    if (cached) {\r\n        return cached;\r\n    }\r\n    let name = camelize(rawName);\r\n    if (name !== 'filter' && name in style) {\r\n        return (prefixCache[rawName] = name);\r\n    }\r\n    name = capitalize(name);\r\n    for (let i = 0; i < prefixes.length; i++) {\r\n        const prefixed = prefixes[i] + name;\r\n        if (prefixed in style) {\r\n            return (prefixCache[rawName] = prefixed);\r\n        }\r\n    }\r\n    return rawName;\r\n}\n\nconst xlinkNS = 'http://www.w3.org/1999/xlink';\r\nfunction patchAttr(el, key, value, isSVG) {\r\n    if (isSVG && key.startsWith('xlink:')) {\r\n        if (value == null) {\r\n            el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\r\n        }\r\n        else {\r\n            el.setAttributeNS(xlinkNS, key, value);\r\n        }\r\n    }\r\n    else {\r\n        // note we are only checking boolean attributes that don't have a\r\n        // corresponding dom prop of the same name here.\r\n        const isBoolean = isSpecialBooleanAttr(key);\r\n        if (value == null || (isBoolean && value === false)) {\r\n            el.removeAttribute(key);\r\n        }\r\n        else {\r\n            el.setAttribute(key, isBoolean ? '' : value);\r\n        }\r\n    }\r\n}\n\n// __UNSAFE__\r\n// functions. The user is responsible for using them with only trusted content.\r\nfunction patchDOMProp(el, key, value, \r\n// the following args are passed only due to potential innerHTML/textContent\r\n// overriding existing VNodes, in which case the old tree must be properly\r\n// unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n    if (key === 'innerHTML' || key === 'textContent') {\r\n        if (prevChildren) {\r\n            unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n        }\r\n        el[key] = value == null ? '' : value;\r\n        return;\r\n    }\r\n    if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n        // store value as _value as well since\r\n        // non-string values will be stringified.\r\n        el._value = value;\r\n        const newValue = value == null ? '' : value;\r\n        if (el.value !== newValue) {\r\n            el.value = newValue;\r\n        }\r\n        return;\r\n    }\r\n    if (value === '' || value == null) {\r\n        const type = typeof el[key];\r\n        if (value === '' && type === 'boolean') {\r\n            // e.g. <select multiple> compiles to { multiple: '' }\r\n            el[key] = true;\r\n            return;\r\n        }\r\n        else if (value == null && type === 'string') {\r\n            // e.g. <div :id=\"null\">\r\n            el[key] = '';\r\n            el.removeAttribute(key);\r\n            return;\r\n        }\r\n        else if (type === 'number') {\r\n            // e.g. <img :width=\"null\">\r\n            el[key] = 0;\r\n            el.removeAttribute(key);\r\n            return;\r\n        }\r\n    }\r\n    // some properties perform value validation and throw\r\n    try {\r\n        el[key] = value;\r\n    }\r\n    catch (e) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            warn(`Failed setting prop \"${key}\" on <${el.tagName.toLowerCase()}>: ` +\r\n                `value ${value} is invalid.`, e);\r\n        }\r\n    }\r\n}\n\n// Async edge case fix requires storing an event listener's attach timestamp.\r\nlet _getNow = Date.now;\r\nlet skipTimestampCheck = false;\r\nif (typeof window !== 'undefined') {\r\n    // Determine what event timestamp the browser is using. Annoyingly, the\r\n    // timestamp can either be hi-res (relative to page load) or low-res\r\n    // (relative to UNIX epoch), so in order to compare time we have to use the\r\n    // same timestamp type when saving the flush timestamp.\r\n    if (_getNow() > document.createEvent('Event').timeStamp) {\r\n        // if the low-res timestamp which is bigger than the event timestamp\r\n        // (which is evaluated AFTER) it means the event is using a hi-res timestamp,\r\n        // and we need to use the hi-res version for event listeners as well.\r\n        _getNow = () => performance.now();\r\n    }\r\n    // #3485: Firefox <= 53 has incorrect Event.timeStamp implementation\r\n    // and does not fire microtasks in between event propagation, so safe to exclude.\r\n    const ffMatch = navigator.userAgent.match(/firefox\\/(\\d+)/i);\r\n    skipTimestampCheck = !!(ffMatch && Number(ffMatch[1]) <= 53);\r\n}\r\n// To avoid the overhead of repeatedly calling performance.now(), we cache\r\n// and use the same timestamp for all event listeners attached in the same tick.\r\nlet cachedNow = 0;\r\nconst p = Promise.resolve();\r\nconst reset = () => {\r\n    cachedNow = 0;\r\n};\r\nconst getNow = () => cachedNow || (p.then(reset), (cachedNow = _getNow()));\r\nfunction addEventListener(el, event, handler, options) {\r\n    el.addEventListener(event, handler, options);\r\n}\r\nfunction removeEventListener(el, event, handler, options) {\r\n    el.removeEventListener(event, handler, options);\r\n}\r\nfunction patchEvent(el, rawName, prevValue, nextValue, instance = null) {\r\n    // vei = vue event invokers\r\n    const invokers = el._vei || (el._vei = {});\r\n    const existingInvoker = invokers[rawName];\r\n    if (nextValue && existingInvoker) {\r\n        // patch\r\n        existingInvoker.value = nextValue;\r\n    }\r\n    else {\r\n        const [name, options] = parseName(rawName);\r\n        if (nextValue) {\r\n            // add\r\n            const invoker = (invokers[rawName] = createInvoker(nextValue, instance));\r\n            addEventListener(el, name, invoker, options);\r\n        }\r\n        else if (existingInvoker) {\r\n            // remove\r\n            removeEventListener(el, name, existingInvoker, options);\r\n            invokers[rawName] = undefined;\r\n        }\r\n    }\r\n}\r\nconst optionsModifierRE = /(?:Once|Passive|Capture)$/;\r\nfunction parseName(name) {\r\n    let options;\r\n    if (optionsModifierRE.test(name)) {\r\n        options = {};\r\n        let m;\r\n        while ((m = name.match(optionsModifierRE))) {\r\n            name = name.slice(0, name.length - m[0].length);\r\n            options[m[0].toLowerCase()] = true;\r\n        }\r\n    }\r\n    return [hyphenate(name.slice(2)), options];\r\n}\r\nfunction createInvoker(initialValue, instance) {\r\n    const invoker = (e) => {\r\n        // async edge case #6566: inner click event triggers patch, event handler\r\n        // attached to outer element during patch, and triggered again. This\r\n        // happens because browsers fire microtask ticks between event propagation.\r\n        // the solution is simple: we save the timestamp when a handler is attached,\r\n        // and the handler would only fire if the event passed to it was fired\r\n        // AFTER it was attached.\r\n        const timeStamp = e.timeStamp || _getNow();\r\n        if (skipTimestampCheck || timeStamp >= invoker.attached - 1) {\r\n            callWithAsyncErrorHandling(patchStopImmediatePropagation(e, invoker.value), instance, 5 /* NATIVE_EVENT_HANDLER */, [e]);\r\n        }\r\n    };\r\n    invoker.value = initialValue;\r\n    invoker.attached = getNow();\r\n    return invoker;\r\n}\r\nfunction patchStopImmediatePropagation(e, value) {\r\n    if (isArray(value)) {\r\n        const originalStop = e.stopImmediatePropagation;\r\n        e.stopImmediatePropagation = () => {\r\n            originalStop.call(e);\r\n            e._stopped = true;\r\n        };\r\n        return value.map(fn => (e) => !e._stopped && fn(e));\r\n    }\r\n    else {\r\n        return value;\r\n    }\r\n}\n\nconst nativeOnRE = /^on[a-z]/;\r\nconst forcePatchProp = (_, key) => key === 'value';\r\nconst patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {\r\n    switch (key) {\r\n        // special\r\n        case 'class':\r\n            patchClass(el, nextValue, isSVG);\r\n            break;\r\n        case 'style':\r\n            patchStyle(el, prevValue, nextValue);\r\n            break;\r\n        default:\r\n            if (isOn(key)) {\r\n                // ignore v-model listeners\r\n                if (!isModelListener(key)) {\r\n                    patchEvent(el, key, prevValue, nextValue, parentComponent);\r\n                }\r\n            }\r\n            else if (shouldSetAsProp(el, key, nextValue, isSVG)) {\r\n                patchDOMProp(el, key, nextValue, prevChildren, parentComponent, parentSuspense, unmountChildren);\r\n            }\r\n            else {\r\n                // special case for <input v-model type=\"checkbox\"> with\r\n                // :true-value & :false-value\r\n                // store value as dom properties since non-string values will be\r\n                // stringified.\r\n                if (key === 'true-value') {\r\n                    el._trueValue = nextValue;\r\n                }\r\n                else if (key === 'false-value') {\r\n                    el._falseValue = nextValue;\r\n                }\r\n                patchAttr(el, key, nextValue, isSVG);\r\n            }\r\n            break;\r\n    }\r\n};\r\nfunction shouldSetAsProp(el, key, value, isSVG) {\r\n    if (isSVG) {\r\n        // most keys must be set as attribute on svg elements to work\r\n        // ...except innerHTML\r\n        if (key === 'innerHTML') {\r\n            return true;\r\n        }\r\n        // or native onclick with function values\r\n        if (key in el && nativeOnRE.test(key) && isFunction(value)) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n    // spellcheck and draggable are numerated attrs, however their\r\n    // corresponding DOM properties are actually booleans - this leads to\r\n    // setting it with a string \"false\" value leading it to be coerced to\r\n    // `true`, so we need to always treat them as attributes.\r\n    // Note that `contentEditable` doesn't have this problem: its DOM\r\n    // property is also enumerated string values.\r\n    if (key === 'spellcheck' || key === 'draggable') {\r\n        return false;\r\n    }\r\n    // #1787, #2840 form property on form elements is readonly and must be set as\r\n    // attribute.\r\n    if (key === 'form') {\r\n        return false;\r\n    }\r\n    // #1526 <input list> must be set as attribute\r\n    if (key === 'list' && el.tagName === 'INPUT') {\r\n        return false;\r\n    }\r\n    // #2766 <textarea type> must be set as attribute\r\n    if (key === 'type' && el.tagName === 'TEXTAREA') {\r\n        return false;\r\n    }\r\n    // native onclick with string value, must be set as attribute\r\n    if (nativeOnRE.test(key) && isString(value)) {\r\n        return false;\r\n    }\r\n    return key in el;\r\n}\n\nfunction useCssModule(name = '$style') {\r\n    /* istanbul ignore else */\r\n    {\r\n        const instance = getCurrentInstance();\r\n        if (!instance) {\r\n            (process.env.NODE_ENV !== 'production') && warn(`useCssModule must be called inside setup()`);\r\n            return EMPTY_OBJ;\r\n        }\r\n        const modules = instance.type.__cssModules;\r\n        if (!modules) {\r\n            (process.env.NODE_ENV !== 'production') && warn(`Current instance does not have CSS modules injected.`);\r\n            return EMPTY_OBJ;\r\n        }\r\n        const mod = modules[name];\r\n        if (!mod) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Current instance does not have CSS module named \"${name}\".`);\r\n            return EMPTY_OBJ;\r\n        }\r\n        return mod;\r\n    }\r\n}\n\n/**\r\n * Runtime helper for SFC's CSS variable injection feature.\r\n * @private\r\n */\r\nfunction useCssVars(getter) {\r\n    const instance = getCurrentInstance();\r\n    /* istanbul ignore next */\r\n    if (!instance) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn(`useCssVars is called without current active component instance.`);\r\n        return;\r\n    }\r\n    const setVars = () => setVarsOnVNode(instance.subTree, getter(instance.proxy));\r\n    onMounted(() => watchEffect(setVars, { flush: 'post' }));\r\n    onUpdated(setVars);\r\n}\r\nfunction setVarsOnVNode(vnode, vars) {\r\n    if (vnode.shapeFlag & 128 /* SUSPENSE */) {\r\n        const suspense = vnode.suspense;\r\n        vnode = suspense.activeBranch;\r\n        if (suspense.pendingBranch && !suspense.isHydrating) {\r\n            suspense.effects.push(() => {\r\n                setVarsOnVNode(suspense.activeBranch, vars);\r\n            });\r\n        }\r\n    }\r\n    // drill down HOCs until it's a non-component vnode\r\n    while (vnode.component) {\r\n        vnode = vnode.component.subTree;\r\n    }\r\n    if (vnode.shapeFlag & 1 /* ELEMENT */ && vnode.el) {\r\n        const style = vnode.el.style;\r\n        for (const key in vars) {\r\n            style.setProperty(`--${key}`, vars[key]);\r\n        }\r\n    }\r\n    else if (vnode.type === Fragment) {\r\n        vnode.children.forEach(c => setVarsOnVNode(c, vars));\r\n    }\r\n}\n\nconst TRANSITION = 'transition';\r\nconst ANIMATION = 'animation';\r\n// DOM Transition is a higher-order-component based on the platform-agnostic\r\n// base Transition component, with DOM-specific logic.\r\nconst Transition = (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots);\r\nTransition.displayName = 'Transition';\r\nconst DOMTransitionPropsValidators = {\r\n    name: String,\r\n    type: String,\r\n    css: {\r\n        type: Boolean,\r\n        default: true\r\n    },\r\n    duration: [String, Number, Object],\r\n    enterFromClass: String,\r\n    enterActiveClass: String,\r\n    enterToClass: String,\r\n    appearFromClass: String,\r\n    appearActiveClass: String,\r\n    appearToClass: String,\r\n    leaveFromClass: String,\r\n    leaveActiveClass: String,\r\n    leaveToClass: String\r\n};\r\nconst TransitionPropsValidators = (Transition.props = /*#__PURE__*/ extend({}, BaseTransition.props, DOMTransitionPropsValidators));\r\nfunction resolveTransitionProps(rawProps) {\r\n    let { name = 'v', type, css = true, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps;\r\n    const baseProps = {};\r\n    for (const key in rawProps) {\r\n        if (!(key in DOMTransitionPropsValidators)) {\r\n            baseProps[key] = rawProps[key];\r\n        }\r\n    }\r\n    if (!css) {\r\n        return baseProps;\r\n    }\r\n    const durations = normalizeDuration(duration);\r\n    const enterDuration = durations && durations[0];\r\n    const leaveDuration = durations && durations[1];\r\n    const { onBeforeEnter, onEnter, onEnterCancelled, onLeave, onLeaveCancelled, onBeforeAppear = onBeforeEnter, onAppear = onEnter, onAppearCancelled = onEnterCancelled } = baseProps;\r\n    const finishEnter = (el, isAppear, done) => {\r\n        removeTransitionClass(el, isAppear ? appearToClass : enterToClass);\r\n        removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);\r\n        done && done();\r\n    };\r\n    const finishLeave = (el, done) => {\r\n        removeTransitionClass(el, leaveToClass);\r\n        removeTransitionClass(el, leaveActiveClass);\r\n        done && done();\r\n    };\r\n    const makeEnterHook = (isAppear) => {\r\n        return (el, done) => {\r\n            const hook = isAppear ? onAppear : onEnter;\r\n            const resolve = () => finishEnter(el, isAppear, done);\r\n            hook && hook(el, resolve);\r\n            nextFrame(() => {\r\n                removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);\r\n                addTransitionClass(el, isAppear ? appearToClass : enterToClass);\r\n                if (!(hook && hook.length > 1)) {\r\n                    whenTransitionEnds(el, type, enterDuration, resolve);\r\n                }\r\n            });\r\n        };\r\n    };\r\n    return extend(baseProps, {\r\n        onBeforeEnter(el) {\r\n            onBeforeEnter && onBeforeEnter(el);\r\n            addTransitionClass(el, enterFromClass);\r\n            addTransitionClass(el, enterActiveClass);\r\n        },\r\n        onBeforeAppear(el) {\r\n            onBeforeAppear && onBeforeAppear(el);\r\n            addTransitionClass(el, appearFromClass);\r\n            addTransitionClass(el, appearActiveClass);\r\n        },\r\n        onEnter: makeEnterHook(false),\r\n        onAppear: makeEnterHook(true),\r\n        onLeave(el, done) {\r\n            const resolve = () => finishLeave(el, done);\r\n            addTransitionClass(el, leaveFromClass);\r\n            // force reflow so *-leave-from classes immediately take effect (#2593)\r\n            forceReflow();\r\n            addTransitionClass(el, leaveActiveClass);\r\n            nextFrame(() => {\r\n                removeTransitionClass(el, leaveFromClass);\r\n                addTransitionClass(el, leaveToClass);\r\n                if (!(onLeave && onLeave.length > 1)) {\r\n                    whenTransitionEnds(el, type, leaveDuration, resolve);\r\n                }\r\n            });\r\n            onLeave && onLeave(el, resolve);\r\n        },\r\n        onEnterCancelled(el) {\r\n            finishEnter(el, false);\r\n            onEnterCancelled && onEnterCancelled(el);\r\n        },\r\n        onAppearCancelled(el) {\r\n            finishEnter(el, true);\r\n            onAppearCancelled && onAppearCancelled(el);\r\n        },\r\n        onLeaveCancelled(el) {\r\n            finishLeave(el);\r\n            onLeaveCancelled && onLeaveCancelled(el);\r\n        }\r\n    });\r\n}\r\nfunction normalizeDuration(duration) {\r\n    if (duration == null) {\r\n        return null;\r\n    }\r\n    else if (isObject(duration)) {\r\n        return [NumberOf(duration.enter), NumberOf(duration.leave)];\r\n    }\r\n    else {\r\n        const n = NumberOf(duration);\r\n        return [n, n];\r\n    }\r\n}\r\nfunction NumberOf(val) {\r\n    const res = toNumber(val);\r\n    if ((process.env.NODE_ENV !== 'production'))\r\n        validateDuration(res);\r\n    return res;\r\n}\r\nfunction validateDuration(val) {\r\n    if (typeof val !== 'number') {\r\n        warn(`<transition> explicit duration is not a valid number - ` +\r\n            `got ${JSON.stringify(val)}.`);\r\n    }\r\n    else if (isNaN(val)) {\r\n        warn(`<transition> explicit duration is NaN - ` +\r\n            'the duration expression might be incorrect.');\r\n    }\r\n}\r\nfunction addTransitionClass(el, cls) {\r\n    cls.split(/\\s+/).forEach(c => c && el.classList.add(c));\r\n    (el._vtc ||\r\n        (el._vtc = new Set())).add(cls);\r\n}\r\nfunction removeTransitionClass(el, cls) {\r\n    cls.split(/\\s+/).forEach(c => c && el.classList.remove(c));\r\n    const { _vtc } = el;\r\n    if (_vtc) {\r\n        _vtc.delete(cls);\r\n        if (!_vtc.size) {\r\n            el._vtc = undefined;\r\n        }\r\n    }\r\n}\r\nfunction nextFrame(cb) {\r\n    requestAnimationFrame(() => {\r\n        requestAnimationFrame(cb);\r\n    });\r\n}\r\nlet endId = 0;\r\nfunction whenTransitionEnds(el, expectedType, explicitTimeout, resolve) {\r\n    const id = (el._endId = ++endId);\r\n    const resolveIfNotStale = () => {\r\n        if (id === el._endId) {\r\n            resolve();\r\n        }\r\n    };\r\n    if (explicitTimeout) {\r\n        return setTimeout(resolveIfNotStale, explicitTimeout);\r\n    }\r\n    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);\r\n    if (!type) {\r\n        return resolve();\r\n    }\r\n    const endEvent = type + 'end';\r\n    let ended = 0;\r\n    const end = () => {\r\n        el.removeEventListener(endEvent, onEnd);\r\n        resolveIfNotStale();\r\n    };\r\n    const onEnd = (e) => {\r\n        if (e.target === el && ++ended >= propCount) {\r\n            end();\r\n        }\r\n    };\r\n    setTimeout(() => {\r\n        if (ended < propCount) {\r\n            end();\r\n        }\r\n    }, timeout + 1);\r\n    el.addEventListener(endEvent, onEnd);\r\n}\r\nfunction getTransitionInfo(el, expectedType) {\r\n    const styles = window.getComputedStyle(el);\r\n    // JSDOM may return undefined for transition properties\r\n    const getStyleProperties = (key) => (styles[key] || '').split(', ');\r\n    const transitionDelays = getStyleProperties(TRANSITION + 'Delay');\r\n    const transitionDurations = getStyleProperties(TRANSITION + 'Duration');\r\n    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);\r\n    const animationDelays = getStyleProperties(ANIMATION + 'Delay');\r\n    const animationDurations = getStyleProperties(ANIMATION + 'Duration');\r\n    const animationTimeout = getTimeout(animationDelays, animationDurations);\r\n    let type = null;\r\n    let timeout = 0;\r\n    let propCount = 0;\r\n    /* istanbul ignore if */\r\n    if (expectedType === TRANSITION) {\r\n        if (transitionTimeout > 0) {\r\n            type = TRANSITION;\r\n            timeout = transitionTimeout;\r\n            propCount = transitionDurations.length;\r\n        }\r\n    }\r\n    else if (expectedType === ANIMATION) {\r\n        if (animationTimeout > 0) {\r\n            type = ANIMATION;\r\n            timeout = animationTimeout;\r\n            propCount = animationDurations.length;\r\n        }\r\n    }\r\n    else {\r\n        timeout = Math.max(transitionTimeout, animationTimeout);\r\n        type =\r\n            timeout > 0\r\n                ? transitionTimeout > animationTimeout\r\n                    ? TRANSITION\r\n                    : ANIMATION\r\n                : null;\r\n        propCount = type\r\n            ? type === TRANSITION\r\n                ? transitionDurations.length\r\n                : animationDurations.length\r\n            : 0;\r\n    }\r\n    const hasTransform = type === TRANSITION &&\r\n        /\\b(transform|all)(,|$)/.test(styles[TRANSITION + 'Property']);\r\n    return {\r\n        type,\r\n        timeout,\r\n        propCount,\r\n        hasTransform\r\n    };\r\n}\r\nfunction getTimeout(delays, durations) {\r\n    while (delays.length < durations.length) {\r\n        delays = delays.concat(delays);\r\n    }\r\n    return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));\r\n}\r\n// Old versions of Chromium (below 61.0.3163.100) formats floating pointer\r\n// numbers in a locale-dependent way, using a comma instead of a dot.\r\n// If comma is not replaced with a dot, the input will be rounded down\r\n// (i.e. acting as a floor function) causing unexpected behaviors\r\nfunction toMs(s) {\r\n    return Number(s.slice(0, -1).replace(',', '.')) * 1000;\r\n}\r\n// synchronously force layout to put elements into a certain state\r\nfunction forceReflow() {\r\n    return document.body.offsetHeight;\r\n}\n\nconst positionMap = new WeakMap();\r\nconst newPositionMap = new WeakMap();\r\nconst TransitionGroupImpl = {\r\n    name: 'TransitionGroup',\r\n    props: /*#__PURE__*/ extend({}, TransitionPropsValidators, {\r\n        tag: String,\r\n        moveClass: String\r\n    }),\r\n    setup(props, { slots }) {\r\n        const instance = getCurrentInstance();\r\n        const state = useTransitionState();\r\n        let prevChildren;\r\n        let children;\r\n        onUpdated(() => {\r\n            // children is guaranteed to exist after initial render\r\n            if (!prevChildren.length) {\r\n                return;\r\n            }\r\n            const moveClass = props.moveClass || `${props.name || 'v'}-move`;\r\n            if (!hasCSSTransform(prevChildren[0].el, instance.vnode.el, moveClass)) {\r\n                return;\r\n            }\r\n            // we divide the work into three loops to avoid mixing DOM reads and writes\r\n            // in each iteration - which helps prevent layout thrashing.\r\n            prevChildren.forEach(callPendingCbs);\r\n            prevChildren.forEach(recordPosition);\r\n            const movedChildren = prevChildren.filter(applyTranslation);\r\n            // force reflow to put everything in position\r\n            forceReflow();\r\n            movedChildren.forEach(c => {\r\n                const el = c.el;\r\n                const style = el.style;\r\n                addTransitionClass(el, moveClass);\r\n                style.transform = style.webkitTransform = style.transitionDuration = '';\r\n                const cb = (el._moveCb = (e) => {\r\n                    if (e && e.target !== el) {\r\n                        return;\r\n                    }\r\n                    if (!e || /transform$/.test(e.propertyName)) {\r\n                        el.removeEventListener('transitionend', cb);\r\n                        el._moveCb = null;\r\n                        removeTransitionClass(el, moveClass);\r\n                    }\r\n                });\r\n                el.addEventListener('transitionend', cb);\r\n            });\r\n        });\r\n        return () => {\r\n            const rawProps = toRaw(props);\r\n            const cssTransitionProps = resolveTransitionProps(rawProps);\r\n            const tag = rawProps.tag || Fragment;\r\n            prevChildren = children;\r\n            children = slots.default ? getTransitionRawChildren(slots.default()) : [];\r\n            for (let i = 0; i < children.length; i++) {\r\n                const child = children[i];\r\n                if (child.key != null) {\r\n                    setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`<TransitionGroup> children must be keyed.`);\r\n                }\r\n            }\r\n            if (prevChildren) {\r\n                for (let i = 0; i < prevChildren.length; i++) {\r\n                    const child = prevChildren[i];\r\n                    setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));\r\n                    positionMap.set(child, child.el.getBoundingClientRect());\r\n                }\r\n            }\r\n            return createVNode(tag, null, children);\r\n        };\r\n    }\r\n};\r\nconst TransitionGroup = TransitionGroupImpl;\r\nfunction callPendingCbs(c) {\r\n    const el = c.el;\r\n    if (el._moveCb) {\r\n        el._moveCb();\r\n    }\r\n    if (el._enterCb) {\r\n        el._enterCb();\r\n    }\r\n}\r\nfunction recordPosition(c) {\r\n    newPositionMap.set(c, c.el.getBoundingClientRect());\r\n}\r\nfunction applyTranslation(c) {\r\n    const oldPos = positionMap.get(c);\r\n    const newPos = newPositionMap.get(c);\r\n    const dx = oldPos.left - newPos.left;\r\n    const dy = oldPos.top - newPos.top;\r\n    if (dx || dy) {\r\n        const s = c.el.style;\r\n        s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;\r\n        s.transitionDuration = '0s';\r\n        return c;\r\n    }\r\n}\r\nfunction hasCSSTransform(el, root, moveClass) {\r\n    // Detect whether an element with the move class applied has\r\n    // CSS transitions. Since the element may be inside an entering\r\n    // transition at this very moment, we make a clone of it and remove\r\n    // all other transition classes applied to ensure only the move class\r\n    // is applied.\r\n    const clone = el.cloneNode();\r\n    if (el._vtc) {\r\n        el._vtc.forEach(cls => {\r\n            cls.split(/\\s+/).forEach(c => c && clone.classList.remove(c));\r\n        });\r\n    }\r\n    moveClass.split(/\\s+/).forEach(c => c && clone.classList.add(c));\r\n    clone.style.display = 'none';\r\n    const container = (root.nodeType === 1\r\n        ? root\r\n        : root.parentNode);\r\n    container.appendChild(clone);\r\n    const { hasTransform } = getTransitionInfo(clone);\r\n    container.removeChild(clone);\r\n    return hasTransform;\r\n}\n\nconst getModelAssigner = (vnode) => {\r\n    const fn = vnode.props['onUpdate:modelValue'];\r\n    return isArray(fn) ? value => invokeArrayFns(fn, value) : fn;\r\n};\r\nfunction onCompositionStart(e) {\r\n    e.target.composing = true;\r\n}\r\nfunction onCompositionEnd(e) {\r\n    const target = e.target;\r\n    if (target.composing) {\r\n        target.composing = false;\r\n        trigger(target, 'input');\r\n    }\r\n}\r\nfunction trigger(el, type) {\r\n    const e = document.createEvent('HTMLEvents');\r\n    e.initEvent(type, true, true);\r\n    el.dispatchEvent(e);\r\n}\r\n// We are exporting the v-model runtime directly as vnode hooks so that it can\r\n// be tree-shaken in case v-model is never used.\r\nconst vModelText = {\r\n    created(el, { modifiers: { lazy, trim, number } }, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        const castToNumber = number || el.type === 'number';\r\n        addEventListener(el, lazy ? 'change' : 'input', e => {\r\n            if (e.target.composing)\r\n                return;\r\n            let domValue = el.value;\r\n            if (trim) {\r\n                domValue = domValue.trim();\r\n            }\r\n            else if (castToNumber) {\r\n                domValue = toNumber(domValue);\r\n            }\r\n            el._assign(domValue);\r\n        });\r\n        if (trim) {\r\n            addEventListener(el, 'change', () => {\r\n                el.value = el.value.trim();\r\n            });\r\n        }\r\n        if (!lazy) {\r\n            addEventListener(el, 'compositionstart', onCompositionStart);\r\n            addEventListener(el, 'compositionend', onCompositionEnd);\r\n            // Safari < 10.2 & UIWebView doesn't fire compositionend when\r\n            // switching focus before confirming composition choice\r\n            // this also fixes the issue where some browsers e.g. iOS Chrome\r\n            // fires \"change\" instead of \"input\" on autocomplete.\r\n            addEventListener(el, 'change', onCompositionEnd);\r\n        }\r\n    },\r\n    // set value on mounted so it's after min/max for type=\"range\"\r\n    mounted(el, { value }) {\r\n        el.value = value == null ? '' : value;\r\n    },\r\n    beforeUpdate(el, { value, modifiers: { trim, number } }, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        // avoid clearing unresolved text. #2302\r\n        if (el.composing)\r\n            return;\r\n        if (document.activeElement === el) {\r\n            if (trim && el.value.trim() === value) {\r\n                return;\r\n            }\r\n            if ((number || el.type === 'number') && toNumber(el.value) === value) {\r\n                return;\r\n            }\r\n        }\r\n        const newValue = value == null ? '' : value;\r\n        if (el.value !== newValue) {\r\n            el.value = newValue;\r\n        }\r\n    }\r\n};\r\nconst vModelCheckbox = {\r\n    created(el, _, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        addEventListener(el, 'change', () => {\r\n            const modelValue = el._modelValue;\r\n            const elementValue = getValue(el);\r\n            const checked = el.checked;\r\n            const assign = el._assign;\r\n            if (isArray(modelValue)) {\r\n                const index = looseIndexOf(modelValue, elementValue);\r\n                const found = index !== -1;\r\n                if (checked && !found) {\r\n                    assign(modelValue.concat(elementValue));\r\n                }\r\n                else if (!checked && found) {\r\n                    const filtered = [...modelValue];\r\n                    filtered.splice(index, 1);\r\n                    assign(filtered);\r\n                }\r\n            }\r\n            else if (isSet(modelValue)) {\r\n                const cloned = new Set(modelValue);\r\n                if (checked) {\r\n                    cloned.add(elementValue);\r\n                }\r\n                else {\r\n                    cloned.delete(elementValue);\r\n                }\r\n                assign(cloned);\r\n            }\r\n            else {\r\n                assign(getCheckboxValue(el, checked));\r\n            }\r\n        });\r\n    },\r\n    // set initial checked on mount to wait for true-value/false-value\r\n    mounted: setChecked,\r\n    beforeUpdate(el, binding, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        setChecked(el, binding, vnode);\r\n    }\r\n};\r\nfunction setChecked(el, { value, oldValue }, vnode) {\r\n    el._modelValue = value;\r\n    if (isArray(value)) {\r\n        el.checked = looseIndexOf(value, vnode.props.value) > -1;\r\n    }\r\n    else if (isSet(value)) {\r\n        el.checked = value.has(vnode.props.value);\r\n    }\r\n    else if (value !== oldValue) {\r\n        el.checked = looseEqual(value, getCheckboxValue(el, true));\r\n    }\r\n}\r\nconst vModelRadio = {\r\n    created(el, { value }, vnode) {\r\n        el.checked = looseEqual(value, vnode.props.value);\r\n        el._assign = getModelAssigner(vnode);\r\n        addEventListener(el, 'change', () => {\r\n            el._assign(getValue(el));\r\n        });\r\n    },\r\n    beforeUpdate(el, { value, oldValue }, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        if (value !== oldValue) {\r\n            el.checked = looseEqual(value, vnode.props.value);\r\n        }\r\n    }\r\n};\r\nconst vModelSelect = {\r\n    created(el, { value, modifiers: { number } }, vnode) {\r\n        const isSetModel = isSet(value);\r\n        addEventListener(el, 'change', () => {\r\n            const selectedVal = Array.prototype.filter\r\n                .call(el.options, (o) => o.selected)\r\n                .map((o) => number ? toNumber(getValue(o)) : getValue(o));\r\n            el._assign(el.multiple\r\n                ? isSetModel\r\n                    ? new Set(selectedVal)\r\n                    : selectedVal\r\n                : selectedVal[0]);\r\n        });\r\n        el._assign = getModelAssigner(vnode);\r\n    },\r\n    // set value in mounted & updated because <select> relies on its children\r\n    // <option>s.\r\n    mounted(el, { value }) {\r\n        setSelected(el, value);\r\n    },\r\n    beforeUpdate(el, _binding, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n    },\r\n    updated(el, { value }) {\r\n        setSelected(el, value);\r\n    }\r\n};\r\nfunction setSelected(el, value) {\r\n    const isMultiple = el.multiple;\r\n    if (isMultiple && !isArray(value) && !isSet(value)) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn(`<select multiple v-model> expects an Array or Set value for its binding, ` +\r\n                `but got ${Object.prototype.toString.call(value).slice(8, -1)}.`);\r\n        return;\r\n    }\r\n    for (let i = 0, l = el.options.length; i < l; i++) {\r\n        const option = el.options[i];\r\n        const optionValue = getValue(option);\r\n        if (isMultiple) {\r\n            if (isArray(value)) {\r\n                option.selected = looseIndexOf(value, optionValue) > -1;\r\n            }\r\n            else {\r\n                option.selected = value.has(optionValue);\r\n            }\r\n        }\r\n        else {\r\n            if (looseEqual(getValue(option), value)) {\r\n                el.selectedIndex = i;\r\n                return;\r\n            }\r\n        }\r\n    }\r\n    if (!isMultiple) {\r\n        el.selectedIndex = -1;\r\n    }\r\n}\r\n// retrieve raw value set via :value bindings\r\nfunction getValue(el) {\r\n    return '_value' in el ? el._value : el.value;\r\n}\r\n// retrieve raw value for true-value and false-value set via :true-value or :false-value bindings\r\nfunction getCheckboxValue(el, checked) {\r\n    const key = checked ? '_trueValue' : '_falseValue';\r\n    return key in el ? el[key] : checked;\r\n}\r\nconst vModelDynamic = {\r\n    created(el, binding, vnode) {\r\n        callModelHook(el, binding, vnode, null, 'created');\r\n    },\r\n    mounted(el, binding, vnode) {\r\n        callModelHook(el, binding, vnode, null, 'mounted');\r\n    },\r\n    beforeUpdate(el, binding, vnode, prevVNode) {\r\n        callModelHook(el, binding, vnode, prevVNode, 'beforeUpdate');\r\n    },\r\n    updated(el, binding, vnode, prevVNode) {\r\n        callModelHook(el, binding, vnode, prevVNode, 'updated');\r\n    }\r\n};\r\nfunction callModelHook(el, binding, vnode, prevVNode, hook) {\r\n    let modelToUse;\r\n    switch (el.tagName) {\r\n        case 'SELECT':\r\n            modelToUse = vModelSelect;\r\n            break;\r\n        case 'TEXTAREA':\r\n            modelToUse = vModelText;\r\n            break;\r\n        default:\r\n            switch (vnode.props && vnode.props.type) {\r\n                case 'checkbox':\r\n                    modelToUse = vModelCheckbox;\r\n                    break;\r\n                case 'radio':\r\n                    modelToUse = vModelRadio;\r\n                    break;\r\n                default:\r\n                    modelToUse = vModelText;\r\n            }\r\n    }\r\n    const fn = modelToUse[hook];\r\n    fn && fn(el, binding, vnode, prevVNode);\r\n}\n\nconst systemModifiers = ['ctrl', 'shift', 'alt', 'meta'];\r\nconst modifierGuards = {\r\n    stop: e => e.stopPropagation(),\r\n    prevent: e => e.preventDefault(),\r\n    self: e => e.target !== e.currentTarget,\r\n    ctrl: e => !e.ctrlKey,\r\n    shift: e => !e.shiftKey,\r\n    alt: e => !e.altKey,\r\n    meta: e => !e.metaKey,\r\n    left: e => 'button' in e && e.button !== 0,\r\n    middle: e => 'button' in e && e.button !== 1,\r\n    right: e => 'button' in e && e.button !== 2,\r\n    exact: (e, modifiers) => systemModifiers.some(m => e[`${m}Key`] && !modifiers.includes(m))\r\n};\r\n/**\r\n * @private\r\n */\r\nconst withModifiers = (fn, modifiers) => {\r\n    return (event, ...args) => {\r\n        for (let i = 0; i < modifiers.length; i++) {\r\n            const guard = modifierGuards[modifiers[i]];\r\n            if (guard && guard(event, modifiers))\r\n                return;\r\n        }\r\n        return fn(event, ...args);\r\n    };\r\n};\r\n// Kept for 2.x compat.\r\n// Note: IE11 compat for `spacebar` and `del` is removed for now.\r\nconst keyNames = {\r\n    esc: 'escape',\r\n    space: ' ',\r\n    up: 'arrow-up',\r\n    left: 'arrow-left',\r\n    right: 'arrow-right',\r\n    down: 'arrow-down',\r\n    delete: 'backspace'\r\n};\r\n/**\r\n * @private\r\n */\r\nconst withKeys = (fn, modifiers) => {\r\n    return (event) => {\r\n        if (!('key' in event))\r\n            return;\r\n        const eventKey = hyphenate(event.key);\r\n        if (\r\n        // None of the provided key modifiers match the current event key\r\n        !modifiers.some(k => k === eventKey || keyNames[k] === eventKey)) {\r\n            return;\r\n        }\r\n        return fn(event);\r\n    };\r\n};\n\nconst vShow = {\r\n    beforeMount(el, { value }, { transition }) {\r\n        el._vod = el.style.display === 'none' ? '' : el.style.display;\r\n        if (transition && value) {\r\n            transition.beforeEnter(el);\r\n        }\r\n        else {\r\n            setDisplay(el, value);\r\n        }\r\n    },\r\n    mounted(el, { value }, { transition }) {\r\n        if (transition && value) {\r\n            transition.enter(el);\r\n        }\r\n    },\r\n    updated(el, { value, oldValue }, { transition }) {\r\n        if (!value === !oldValue)\r\n            return;\r\n        if (transition) {\r\n            if (value) {\r\n                transition.beforeEnter(el);\r\n                setDisplay(el, true);\r\n                transition.enter(el);\r\n            }\r\n            else {\r\n                transition.leave(el, () => {\r\n                    setDisplay(el, false);\r\n                });\r\n            }\r\n        }\r\n        else {\r\n            setDisplay(el, value);\r\n        }\r\n    },\r\n    beforeUnmount(el, { value }) {\r\n        setDisplay(el, value);\r\n    }\r\n};\r\nfunction setDisplay(el, value) {\r\n    el.style.display = value ? el._vod : 'none';\r\n}\n\nconst rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps);\r\n// lazy create the renderer - this makes core renderer logic tree-shakable\r\n// in case the user only imports reactivity utilities from Vue.\r\nlet renderer;\r\nlet enabledHydration = false;\r\nfunction ensureRenderer() {\r\n    return renderer || (renderer = createRenderer(rendererOptions));\r\n}\r\nfunction ensureHydrationRenderer() {\r\n    renderer = enabledHydration\r\n        ? renderer\r\n        : createHydrationRenderer(rendererOptions);\r\n    enabledHydration = true;\r\n    return renderer;\r\n}\r\n// use explicit type casts here to avoid import() calls in rolled-up d.ts\r\nconst render = ((...args) => {\r\n    ensureRenderer().render(...args);\r\n});\r\nconst hydrate = ((...args) => {\r\n    ensureHydrationRenderer().hydrate(...args);\r\n});\r\nconst createApp = ((...args) => {\r\n    const app = ensureRenderer().createApp(...args);\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        injectNativeTagCheck(app);\r\n        injectCustomElementCheck(app);\r\n    }\r\n    const { mount } = app;\r\n    app.mount = (containerOrSelector) => {\r\n        const container = normalizeContainer(containerOrSelector);\r\n        if (!container)\r\n            return;\r\n        const component = app._component;\r\n        if (!isFunction(component) && !component.render && !component.template) {\r\n            component.template = container.innerHTML;\r\n        }\r\n        // clear content before mounting\r\n        container.innerHTML = '';\r\n        const proxy = mount(container, false, container instanceof SVGElement);\r\n        if (container instanceof Element) {\r\n            container.removeAttribute('v-cloak');\r\n            container.setAttribute('data-v-app', '');\r\n        }\r\n        return proxy;\r\n    };\r\n    return app;\r\n});\r\nconst createSSRApp = ((...args) => {\r\n    const app = ensureHydrationRenderer().createApp(...args);\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        injectNativeTagCheck(app);\r\n        injectCustomElementCheck(app);\r\n    }\r\n    const { mount } = app;\r\n    app.mount = (containerOrSelector) => {\r\n        const container = normalizeContainer(containerOrSelector);\r\n        if (container) {\r\n            return mount(container, true, container instanceof SVGElement);\r\n        }\r\n    };\r\n    return app;\r\n});\r\nfunction injectNativeTagCheck(app) {\r\n    // Inject `isNativeTag`\r\n    // this is used for component name validation (dev only)\r\n    Object.defineProperty(app.config, 'isNativeTag', {\r\n        value: (tag) => isHTMLTag(tag) || isSVGTag(tag),\r\n        writable: false\r\n    });\r\n}\r\n// dev only\r\nfunction injectCustomElementCheck(app) {\r\n    if (isRuntimeOnly()) {\r\n        const value = app.config.isCustomElement;\r\n        Object.defineProperty(app.config, 'isCustomElement', {\r\n            get() {\r\n                return value;\r\n            },\r\n            set() {\r\n                warn(`The \\`isCustomElement\\` config option is only respected when using the runtime compiler.` +\r\n                    `If you are using the runtime-only build, \\`isCustomElement\\` must be passed to \\`@vue/compiler-dom\\` in the build setup instead` +\r\n                    `- for example, via the \\`compilerOptions\\` option in vue-loader: https://vue-loader.vuejs.org/options.html#compileroptions.`);\r\n            }\r\n        });\r\n    }\r\n}\r\nfunction normalizeContainer(container) {\r\n    if (isString(container)) {\r\n        const res = document.querySelector(container);\r\n        if ((process.env.NODE_ENV !== 'production') && !res) {\r\n            warn(`Failed to mount app: mount target selector \"${container}\" returned null.`);\r\n        }\r\n        return res;\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production') &&\r\n        container instanceof window.ShadowRoot &&\r\n        container.mode === 'closed') {\r\n        warn(`mounting on a ShadowRoot with \\`{mode: \"closed\"}\\` may lead to unpredictable bugs`);\r\n    }\r\n    return container;\r\n}\n\nexport { Transition, TransitionGroup, createApp, createSSRApp, hydrate, render, useCssModule, useCssVars, vModelCheckbox, vModelDynamic, vModelRadio, vModelSelect, vModelText, vShow, withKeys, withModifiers };\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n    const map = Object.create(null);\r\n    const list = str.split(',');\r\n    for (let i = 0; i < list.length; i++) {\r\n        map[list[i]] = true;\r\n    }\r\n    return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\n/**\r\n * dev only flag -> name mapping\r\n */\r\nconst PatchFlagNames = {\r\n    [1 /* TEXT */]: `TEXT`,\r\n    [2 /* CLASS */]: `CLASS`,\r\n    [4 /* STYLE */]: `STYLE`,\r\n    [8 /* PROPS */]: `PROPS`,\r\n    [16 /* FULL_PROPS */]: `FULL_PROPS`,\r\n    [32 /* HYDRATE_EVENTS */]: `HYDRATE_EVENTS`,\r\n    [64 /* STABLE_FRAGMENT */]: `STABLE_FRAGMENT`,\r\n    [128 /* KEYED_FRAGMENT */]: `KEYED_FRAGMENT`,\r\n    [256 /* UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`,\r\n    [512 /* NEED_PATCH */]: `NEED_PATCH`,\r\n    [1024 /* DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`,\r\n    [2048 /* DEV_ROOT_FRAGMENT */]: `DEV_ROOT_FRAGMENT`,\r\n    [-1 /* HOISTED */]: `HOISTED`,\r\n    [-2 /* BAIL */]: `BAIL`\r\n};\n\n/**\r\n * Dev only\r\n */\r\nconst slotFlagsText = {\r\n    [1 /* STABLE */]: 'STABLE',\r\n    [2 /* DYNAMIC */]: 'DYNAMIC',\r\n    [3 /* FORWARDED */]: 'FORWARDED'\r\n};\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n    'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n    'Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nconst range = 2;\r\nfunction generateCodeFrame(source, start = 0, end = source.length) {\r\n    const lines = source.split(/\\r?\\n/);\r\n    let count = 0;\r\n    const res = [];\r\n    for (let i = 0; i < lines.length; i++) {\r\n        count += lines[i].length + 1;\r\n        if (count >= start) {\r\n            for (let j = i - range; j <= i + range || end > count; j++) {\r\n                if (j < 0 || j >= lines.length)\r\n                    continue;\r\n                const line = j + 1;\r\n                res.push(`${line}${' '.repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`);\r\n                const lineLength = lines[j].length;\r\n                if (j === i) {\r\n                    // push underline\r\n                    const pad = start - (count - lineLength) + 1;\r\n                    const length = Math.max(1, end > count ? lineLength - pad : end - start);\r\n                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));\r\n                }\r\n                else if (j > i) {\r\n                    if (end > count) {\r\n                        const length = Math.max(Math.min(end - count, lineLength), 1);\r\n                        res.push(`   |  ` + '^'.repeat(length));\r\n                    }\r\n                    count += lineLength + 1;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    }\r\n    return res.join('\\n');\r\n}\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n/**\r\n * The full list is needed during SSR to produce the correct initial markup.\r\n */\r\nconst isBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs +\r\n    `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,` +\r\n    `loop,open,required,reversed,scoped,seamless,` +\r\n    `checked,muted,multiple,selected`);\r\nconst unsafeAttrCharRE = /[>/=\"'\\u0009\\u000a\\u000c\\u0020]/;\r\nconst attrValidationCache = {};\r\nfunction isSSRSafeAttrName(name) {\r\n    if (attrValidationCache.hasOwnProperty(name)) {\r\n        return attrValidationCache[name];\r\n    }\r\n    const isUnsafe = unsafeAttrCharRE.test(name);\r\n    if (isUnsafe) {\r\n        console.error(`unsafe attribute name: ${name}`);\r\n    }\r\n    return (attrValidationCache[name] = !isUnsafe);\r\n}\r\nconst propsToAttrMap = {\r\n    acceptCharset: 'accept-charset',\r\n    className: 'class',\r\n    htmlFor: 'for',\r\n    httpEquiv: 'http-equiv'\r\n};\r\n/**\r\n * CSS properties that accept plain numbers\r\n */\r\nconst isNoUnitNumericStyleProp = /*#__PURE__*/ makeMap(`animation-iteration-count,border-image-outset,border-image-slice,` +\r\n    `border-image-width,box-flex,box-flex-group,box-ordinal-group,column-count,` +\r\n    `columns,flex,flex-grow,flex-positive,flex-shrink,flex-negative,flex-order,` +\r\n    `grid-row,grid-row-end,grid-row-span,grid-row-start,grid-column,` +\r\n    `grid-column-end,grid-column-span,grid-column-start,font-weight,line-clamp,` +\r\n    `line-height,opacity,order,orphans,tab-size,widows,z-index,zoom,` +\r\n    // SVG\r\n    `fill-opacity,flood-opacity,stop-opacity,stroke-dasharray,stroke-dashoffset,` +\r\n    `stroke-miterlimit,stroke-opacity,stroke-width`);\r\n/**\r\n * Known attributes, this is used for stringification of runtime static nodes\r\n * so that we don't stringify bindings that cannot be set from HTML.\r\n * Don't also forget to allow `data-*` and `aria-*`!\r\n * Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes\r\n */\r\nconst isKnownAttr = /*#__PURE__*/ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,` +\r\n    `autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,` +\r\n    `border,buffered,capture,challenge,charset,checked,cite,class,code,` +\r\n    `codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,` +\r\n    `coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,` +\r\n    `disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,` +\r\n    `formaction,formenctype,formmethod,formnovalidate,formtarget,headers,` +\r\n    `height,hidden,high,href,hreflang,http-equiv,icon,id,importance,integrity,` +\r\n    `ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,` +\r\n    `manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,` +\r\n    `open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,` +\r\n    `referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,` +\r\n    `selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,` +\r\n    `start,step,style,summary,tabindex,target,title,translate,type,usemap,` +\r\n    `value,width,wrap`);\n\nfunction normalizeStyle(value) {\r\n    if (isArray(value)) {\r\n        const res = {};\r\n        for (let i = 0; i < value.length; i++) {\r\n            const item = value[i];\r\n            const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n            if (normalized) {\r\n                for (const key in normalized) {\r\n                    res[key] = normalized[key];\r\n                }\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n    else if (isObject(value)) {\r\n        return value;\r\n    }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n    const ret = {};\r\n    cssText.split(listDelimiterRE).forEach(item => {\r\n        if (item) {\r\n            const tmp = item.split(propertyDelimiterRE);\r\n            tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n        }\r\n    });\r\n    return ret;\r\n}\r\nfunction stringifyStyle(styles) {\r\n    let ret = '';\r\n    if (!styles) {\r\n        return ret;\r\n    }\r\n    for (const key in styles) {\r\n        const value = styles[key];\r\n        const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);\r\n        if (isString(value) ||\r\n            (typeof value === 'number' && isNoUnitNumericStyleProp(normalizedKey))) {\r\n            // only render valid values\r\n            ret += `${normalizedKey}:${value};`;\r\n        }\r\n    }\r\n    return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n    let res = '';\r\n    if (isString(value)) {\r\n        res = value;\r\n    }\r\n    else if (isArray(value)) {\r\n        for (let i = 0; i < value.length; i++) {\r\n            const normalized = normalizeClass(value[i]);\r\n            if (normalized) {\r\n                res += normalized + ' ';\r\n            }\r\n        }\r\n    }\r\n    else if (isObject(value)) {\r\n        for (const name in value) {\r\n            if (value[name]) {\r\n                res += name + ' ';\r\n            }\r\n        }\r\n    }\r\n    return res.trim();\r\n}\n\n// These tag configs are shared between compiler-dom and runtime-dom, so they\r\n// https://developer.mozilla.org/en-US/docs/Web/HTML/Element\r\nconst HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' +\r\n    'header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,' +\r\n    'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' +\r\n    'data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,' +\r\n    'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' +\r\n    'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' +\r\n    'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' +\r\n    'option,output,progress,select,textarea,details,dialog,menu,' +\r\n    'summary,template,blockquote,iframe,tfoot';\r\n// https://developer.mozilla.org/en-US/docs/Web/SVG/Element\r\nconst SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +\r\n    'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +\r\n    'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +\r\n    'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +\r\n    'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +\r\n    'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +\r\n    'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +\r\n    'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +\r\n    'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +\r\n    'text,textPath,title,tspan,unknown,use,view';\r\nconst VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';\r\nconst isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS);\r\nconst isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS);\r\nconst isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS);\n\nconst escapeRE = /[\"'&<>]/;\r\nfunction escapeHtml(string) {\r\n    const str = '' + string;\r\n    const match = escapeRE.exec(str);\r\n    if (!match) {\r\n        return str;\r\n    }\r\n    let html = '';\r\n    let escaped;\r\n    let index;\r\n    let lastIndex = 0;\r\n    for (index = match.index; index < str.length; index++) {\r\n        switch (str.charCodeAt(index)) {\r\n            case 34: // \"\r\n                escaped = '&quot;';\r\n                break;\r\n            case 38: // &\r\n                escaped = '&amp;';\r\n                break;\r\n            case 39: // '\r\n                escaped = '&#39;';\r\n                break;\r\n            case 60: // <\r\n                escaped = '&lt;';\r\n                break;\r\n            case 62: // >\r\n                escaped = '&gt;';\r\n                break;\r\n            default:\r\n                continue;\r\n        }\r\n        if (lastIndex !== index) {\r\n            html += str.substring(lastIndex, index);\r\n        }\r\n        lastIndex = index + 1;\r\n        html += escaped;\r\n    }\r\n    return lastIndex !== index ? html + str.substring(lastIndex, index) : html;\r\n}\r\n// https://www.w3.org/TR/html52/syntax.html#comments\r\nconst commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;\r\nfunction escapeHtmlComment(src) {\r\n    return src.replace(commentStripRE, '');\r\n}\n\nfunction looseCompareArrays(a, b) {\r\n    if (a.length !== b.length)\r\n        return false;\r\n    let equal = true;\r\n    for (let i = 0; equal && i < a.length; i++) {\r\n        equal = looseEqual(a[i], b[i]);\r\n    }\r\n    return equal;\r\n}\r\nfunction looseEqual(a, b) {\r\n    if (a === b)\r\n        return true;\r\n    let aValidType = isDate(a);\r\n    let bValidType = isDate(b);\r\n    if (aValidType || bValidType) {\r\n        return aValidType && bValidType ? a.getTime() === b.getTime() : false;\r\n    }\r\n    aValidType = isArray(a);\r\n    bValidType = isArray(b);\r\n    if (aValidType || bValidType) {\r\n        return aValidType && bValidType ? looseCompareArrays(a, b) : false;\r\n    }\r\n    aValidType = isObject(a);\r\n    bValidType = isObject(b);\r\n    if (aValidType || bValidType) {\r\n        /* istanbul ignore if: this if will probably never be called */\r\n        if (!aValidType || !bValidType) {\r\n            return false;\r\n        }\r\n        const aKeysCount = Object.keys(a).length;\r\n        const bKeysCount = Object.keys(b).length;\r\n        if (aKeysCount !== bKeysCount) {\r\n            return false;\r\n        }\r\n        for (const key in a) {\r\n            const aHasKey = a.hasOwnProperty(key);\r\n            const bHasKey = b.hasOwnProperty(key);\r\n            if ((aHasKey && !bHasKey) ||\r\n                (!aHasKey && bHasKey) ||\r\n                !looseEqual(a[key], b[key])) {\r\n                return false;\r\n            }\r\n        }\r\n    }\r\n    return String(a) === String(b);\r\n}\r\nfunction looseIndexOf(arr, val) {\r\n    return arr.findIndex(item => looseEqual(item, val));\r\n}\n\n/**\r\n * For converting {{ interpolation }} values to displayed strings.\r\n * @private\r\n */\r\nconst toDisplayString = (val) => {\r\n    return val == null\r\n        ? ''\r\n        : isObject(val)\r\n            ? JSON.stringify(val, replacer, 2)\r\n            : String(val);\r\n};\r\nconst replacer = (_key, val) => {\r\n    if (isMap(val)) {\r\n        return {\r\n            [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => {\r\n                entries[`${key} =>`] = val;\r\n                return entries;\r\n            }, {})\r\n        };\r\n    }\r\n    else if (isSet(val)) {\r\n        return {\r\n            [`Set(${val.size})`]: [...val.values()]\r\n        };\r\n    }\r\n    else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {\r\n        return String(val);\r\n    }\r\n    return val;\r\n};\n\n/**\r\n * List of @babel/parser plugins that are used for template expression\r\n * transforms and SFC script transforms. By default we enable proposals slated\r\n * for ES2020. This will need to be updated as the spec moves forward.\r\n * Full list at https://babeljs.io/docs/en/next/babel-parser#plugins\r\n */\r\nconst babelParserDefaultPlugins = [\r\n    'bigInt',\r\n    'optionalChaining',\r\n    'nullishCoalescingOperator'\r\n];\r\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n    ? Object.freeze({})\r\n    : {};\r\nconst EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst NOOP = () => { };\r\n/**\r\n * Always return false.\r\n */\r\nconst NO = () => false;\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n    const i = arr.indexOf(el);\r\n    if (i > -1) {\r\n        arr.splice(i, 1);\r\n    }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === '[object Map]';\r\nconst isSet = (val) => toTypeString(val) === '[object Set]';\r\nconst isDate = (val) => val instanceof Date;\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n    return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n    // extract \"RawType\" from strings like \"[object RawType]\"\r\n    return toTypeString(value).slice(8, -1);\r\n};\r\nconst isPlainObject = (val) => toTypeString(val) === '[object Object]';\r\nconst isIntegerKey = (key) => isString(key) &&\r\n    key !== 'NaN' &&\r\n    key[0] !== '-' &&\r\n    '' + parseInt(key, 10) === key;\r\nconst isReservedProp = /*#__PURE__*/ makeMap(\r\n// the leading comma is intentional so empty string \"\" is also included\r\n',key,ref,' +\r\n    'onVnodeBeforeMount,onVnodeMounted,' +\r\n    'onVnodeBeforeUpdate,onVnodeUpdated,' +\r\n    'onVnodeBeforeUnmount,onVnodeUnmounted');\r\nconst cacheStringFunction = (fn) => {\r\n    const cache = Object.create(null);\r\n    return ((str) => {\r\n        const hit = cache[str];\r\n        return hit || (cache[str] = fn(str));\r\n    });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase());\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\r\n/**\r\n * @private\r\n */\r\nconst toHandlerKey = cacheStringFunction((str) => (str ? `on${capitalize(str)}` : ``));\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nconst invokeArrayFns = (fns, arg) => {\r\n    for (let i = 0; i < fns.length; i++) {\r\n        fns[i](arg);\r\n    }\r\n};\r\nconst def = (obj, key, value) => {\r\n    Object.defineProperty(obj, key, {\r\n        configurable: true,\r\n        enumerable: false,\r\n        value\r\n    });\r\n};\r\nconst toNumber = (val) => {\r\n    const n = parseFloat(val);\r\n    return isNaN(n) ? val : n;\r\n};\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n    return (_globalThis ||\r\n        (_globalThis =\r\n            typeof globalThis !== 'undefined'\r\n                ? globalThis\r\n                : typeof self !== 'undefined'\r\n                    ? self\r\n                    : typeof window !== 'undefined'\r\n                        ? window\r\n                        : typeof global !== 'undefined'\r\n                            ? global\r\n                            : {}));\r\n};\n\nexport { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, PatchFlagNames, babelParserDefaultPlugins, camelize, capitalize, def, escapeHtml, escapeHtmlComment, extend, generateCodeFrame, getGlobalThis, hasChanged, hasOwn, hyphenate, invokeArrayFns, isArray, isBooleanAttr, isDate, isFunction, isGloballyWhitelisted, isHTMLTag, isIntegerKey, isKnownAttr, isMap, isModelListener, isNoUnitNumericStyleProp, isObject, isOn, isPlainObject, isPromise, isReservedProp, isSSRSafeAttrName, isSVGTag, isSet, isSpecialBooleanAttr, isString, isSymbol, isVoidTag, looseEqual, looseIndexOf, makeMap, normalizeClass, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, slotFlagsText, stringifyStyle, toDisplayString, toHandlerKey, toNumber, toRawType, toTypeString };\n","(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = global || self, global.Alpine = factory());\n}(this, (function () { 'use strict';\n\n  function _defineProperty(obj, key, value) {\n    if (key in obj) {\n      Object.defineProperty(obj, key, {\n        value: value,\n        enumerable: true,\n        configurable: true,\n        writable: true\n      });\n    } else {\n      obj[key] = value;\n    }\n\n    return obj;\n  }\n\n  function ownKeys(object, enumerableOnly) {\n    var keys = Object.keys(object);\n\n    if (Object.getOwnPropertySymbols) {\n      var symbols = Object.getOwnPropertySymbols(object);\n      if (enumerableOnly) symbols = symbols.filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n      });\n      keys.push.apply(keys, symbols);\n    }\n\n    return keys;\n  }\n\n  function _objectSpread2(target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i] != null ? arguments[i] : {};\n\n      if (i % 2) {\n        ownKeys(Object(source), true).forEach(function (key) {\n          _defineProperty(target, key, source[key]);\n        });\n      } else if (Object.getOwnPropertyDescriptors) {\n        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n      } else {\n        ownKeys(Object(source)).forEach(function (key) {\n          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n        });\n      }\n    }\n\n    return target;\n  }\n\n  // Thanks @stimulus:\n  // https://github.com/stimulusjs/stimulus/blob/master/packages/%40stimulus/core/src/application.ts\n  function domReady() {\n    return new Promise(resolve => {\n      if (document.readyState == \"loading\") {\n        document.addEventListener(\"DOMContentLoaded\", resolve);\n      } else {\n        resolve();\n      }\n    });\n  }\n  function arrayUnique(array) {\n    return Array.from(new Set(array));\n  }\n  function isTesting() {\n    return navigator.userAgent.includes(\"Node.js\") || navigator.userAgent.includes(\"jsdom\");\n  }\n  function checkedAttrLooseCompare(valueA, valueB) {\n    return valueA == valueB;\n  }\n  function warnIfMalformedTemplate(el, directive) {\n    if (el.tagName.toLowerCase() !== 'template') {\n      console.warn(`Alpine: [${directive}] directive should only be added to <template> tags. See https://github.com/alpinejs/alpine#${directive}`);\n    } else if (el.content.childElementCount !== 1) {\n      console.warn(`Alpine: <template> tag with [${directive}] encountered with an unexpected number of root elements. Make sure <template> has a single root element. `);\n    }\n  }\n  function kebabCase(subject) {\n    return subject.replace(/([a-z])([A-Z])/g, '$1-$2').replace(/[_\\s]/, '-').toLowerCase();\n  }\n  function camelCase(subject) {\n    return subject.toLowerCase().replace(/-(\\w)/g, (match, char) => char.toUpperCase());\n  }\n  function walk(el, callback) {\n    if (callback(el) === false) return;\n    let node = el.firstElementChild;\n\n    while (node) {\n      walk(node, callback);\n      node = node.nextElementSibling;\n    }\n  }\n  function debounce(func, wait) {\n    var timeout;\n    return function () {\n      var context = this,\n          args = arguments;\n\n      var later = function later() {\n        timeout = null;\n        func.apply(context, args);\n      };\n\n      clearTimeout(timeout);\n      timeout = setTimeout(later, wait);\n    };\n  }\n\n  const handleError = (el, expression, error) => {\n    console.warn(`Alpine Error: \"${error}\"\\n\\nExpression: \"${expression}\"\\nElement:`, el);\n\n    if (!isTesting()) {\n      Object.assign(error, {\n        el,\n        expression\n      });\n      throw error;\n    }\n  };\n\n  function tryCatch(cb, {\n    el,\n    expression\n  }) {\n    try {\n      const value = cb();\n      return value instanceof Promise ? value.catch(e => handleError(el, expression, e)) : value;\n    } catch (e) {\n      handleError(el, expression, e);\n    }\n  }\n\n  function saferEval(el, expression, dataContext, additionalHelperVariables = {}) {\n    return tryCatch(() => {\n      if (typeof expression === 'function') {\n        return expression.call(dataContext);\n      }\n\n      return new Function(['$data', ...Object.keys(additionalHelperVariables)], `var __alpine_result; with($data) { __alpine_result = ${expression} }; return __alpine_result`)(dataContext, ...Object.values(additionalHelperVariables));\n    }, {\n      el,\n      expression\n    });\n  }\n  function saferEvalNoReturn(el, expression, dataContext, additionalHelperVariables = {}) {\n    return tryCatch(() => {\n      if (typeof expression === 'function') {\n        return Promise.resolve(expression.call(dataContext, additionalHelperVariables['$event']));\n      }\n\n      let AsyncFunction = Function;\n      /* MODERN-ONLY:START */\n\n      AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;\n      /* MODERN-ONLY:END */\n      // For the cases when users pass only a function reference to the caller: `x-on:click=\"foo\"`\n      // Where \"foo\" is a function. Also, we'll pass the function the event instance when we call it.\n\n      if (Object.keys(dataContext).includes(expression)) {\n        let methodReference = new Function(['dataContext', ...Object.keys(additionalHelperVariables)], `with(dataContext) { return ${expression} }`)(dataContext, ...Object.values(additionalHelperVariables));\n\n        if (typeof methodReference === 'function') {\n          return Promise.resolve(methodReference.call(dataContext, additionalHelperVariables['$event']));\n        } else {\n          return Promise.resolve();\n        }\n      }\n\n      return Promise.resolve(new AsyncFunction(['dataContext', ...Object.keys(additionalHelperVariables)], `with(dataContext) { ${expression} }`)(dataContext, ...Object.values(additionalHelperVariables)));\n    }, {\n      el,\n      expression\n    });\n  }\n  const xAttrRE = /^x-(on|bind|data|text|html|model|if|for|show|cloak|transition|ref|spread)\\b/;\n  function isXAttr(attr) {\n    const name = replaceAtAndColonWithStandardSyntax(attr.name);\n    return xAttrRE.test(name);\n  }\n  function getXAttrs(el, component, type) {\n    let directives = Array.from(el.attributes).filter(isXAttr).map(parseHtmlAttribute); // Get an object of directives from x-spread.\n\n    let spreadDirective = directives.filter(directive => directive.type === 'spread')[0];\n\n    if (spreadDirective) {\n      let spreadObject = saferEval(el, spreadDirective.expression, component.$data); // Add x-spread directives to the pile of existing directives.\n\n      directives = directives.concat(Object.entries(spreadObject).map(([name, value]) => parseHtmlAttribute({\n        name,\n        value\n      })));\n    }\n\n    if (type) return directives.filter(i => i.type === type);\n    return sortDirectives(directives);\n  }\n\n  function sortDirectives(directives) {\n    let directiveOrder = ['bind', 'model', 'show', 'catch-all'];\n    return directives.sort((a, b) => {\n      let typeA = directiveOrder.indexOf(a.type) === -1 ? 'catch-all' : a.type;\n      let typeB = directiveOrder.indexOf(b.type) === -1 ? 'catch-all' : b.type;\n      return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);\n    });\n  }\n\n  function parseHtmlAttribute({\n    name,\n    value\n  }) {\n    const normalizedName = replaceAtAndColonWithStandardSyntax(name);\n    const typeMatch = normalizedName.match(xAttrRE);\n    const valueMatch = normalizedName.match(/:([a-zA-Z0-9\\-:]+)/);\n    const modifiers = normalizedName.match(/\\.[^.\\]]+(?=[^\\]]*$)/g) || [];\n    return {\n      type: typeMatch ? typeMatch[1] : null,\n      value: valueMatch ? valueMatch[1] : null,\n      modifiers: modifiers.map(i => i.replace('.', '')),\n      expression: value\n    };\n  }\n  function isBooleanAttr(attrName) {\n    // As per HTML spec table https://html.spec.whatwg.org/multipage/indices.html#attributes-3:boolean-attribute\n    // Array roughly ordered by estimated usage\n    const booleanAttributes = ['disabled', 'checked', 'required', 'readonly', 'hidden', 'open', 'selected', 'autofocus', 'itemscope', 'multiple', 'novalidate', 'allowfullscreen', 'allowpaymentrequest', 'formnovalidate', 'autoplay', 'controls', 'loop', 'muted', 'playsinline', 'default', 'ismap', 'reversed', 'async', 'defer', 'nomodule'];\n    return booleanAttributes.includes(attrName);\n  }\n  function replaceAtAndColonWithStandardSyntax(name) {\n    if (name.startsWith('@')) {\n      return name.replace('@', 'x-on:');\n    } else if (name.startsWith(':')) {\n      return name.replace(':', 'x-bind:');\n    }\n\n    return name;\n  }\n  function convertClassStringToArray(classList, filterFn = Boolean) {\n    return classList.split(' ').filter(filterFn);\n  }\n  const TRANSITION_TYPE_IN = 'in';\n  const TRANSITION_TYPE_OUT = 'out';\n  const TRANSITION_CANCELLED = 'cancelled';\n  function transitionIn(el, show, reject, component, forceSkip = false) {\n    // We don't want to transition on the initial page load.\n    if (forceSkip) return show();\n\n    if (el.__x_transition && el.__x_transition.type === TRANSITION_TYPE_IN) {\n      // there is already a similar transition going on, this was probably triggered by\n      // a change in a different property, let's just leave the previous one doing its job\n      return;\n    }\n\n    const attrs = getXAttrs(el, component, 'transition');\n    const showAttr = getXAttrs(el, component, 'show')[0]; // If this is triggered by a x-show.transition.\n\n    if (showAttr && showAttr.modifiers.includes('transition')) {\n      let modifiers = showAttr.modifiers; // If x-show.transition.out, we'll skip the \"in\" transition.\n\n      if (modifiers.includes('out') && !modifiers.includes('in')) return show();\n      const settingBothSidesOfTransition = modifiers.includes('in') && modifiers.includes('out'); // If x-show.transition.in...out... only use \"in\" related modifiers for this transition.\n\n      modifiers = settingBothSidesOfTransition ? modifiers.filter((i, index) => index < modifiers.indexOf('out')) : modifiers;\n      transitionHelperIn(el, modifiers, show, reject); // Otherwise, we can assume x-transition:enter.\n    } else if (attrs.some(attr => ['enter', 'enter-start', 'enter-end'].includes(attr.value))) {\n      transitionClassesIn(el, component, attrs, show, reject);\n    } else {\n      // If neither, just show that damn thing.\n      show();\n    }\n  }\n  function transitionOut(el, hide, reject, component, forceSkip = false) {\n    // We don't want to transition on the initial page load.\n    if (forceSkip) return hide();\n\n    if (el.__x_transition && el.__x_transition.type === TRANSITION_TYPE_OUT) {\n      // there is already a similar transition going on, this was probably triggered by\n      // a change in a different property, let's just leave the previous one doing its job\n      return;\n    }\n\n    const attrs = getXAttrs(el, component, 'transition');\n    const showAttr = getXAttrs(el, component, 'show')[0];\n\n    if (showAttr && showAttr.modifiers.includes('transition')) {\n      let modifiers = showAttr.modifiers;\n      if (modifiers.includes('in') && !modifiers.includes('out')) return hide();\n      const settingBothSidesOfTransition = modifiers.includes('in') && modifiers.includes('out');\n      modifiers = settingBothSidesOfTransition ? modifiers.filter((i, index) => index > modifiers.indexOf('out')) : modifiers;\n      transitionHelperOut(el, modifiers, settingBothSidesOfTransition, hide, reject);\n    } else if (attrs.some(attr => ['leave', 'leave-start', 'leave-end'].includes(attr.value))) {\n      transitionClassesOut(el, component, attrs, hide, reject);\n    } else {\n      hide();\n    }\n  }\n  function transitionHelperIn(el, modifiers, showCallback, reject) {\n    // Default values inspired by: https://material.io/design/motion/speed.html#duration\n    const styleValues = {\n      duration: modifierValue(modifiers, 'duration', 150),\n      origin: modifierValue(modifiers, 'origin', 'center'),\n      first: {\n        opacity: 0,\n        scale: modifierValue(modifiers, 'scale', 95)\n      },\n      second: {\n        opacity: 1,\n        scale: 100\n      }\n    };\n    transitionHelper(el, modifiers, showCallback, () => {}, reject, styleValues, TRANSITION_TYPE_IN);\n  }\n  function transitionHelperOut(el, modifiers, settingBothSidesOfTransition, hideCallback, reject) {\n    // Make the \"out\" transition .5x slower than the \"in\". (Visually better)\n    // HOWEVER, if they explicitly set a duration for the \"out\" transition,\n    // use that.\n    const duration = settingBothSidesOfTransition ? modifierValue(modifiers, 'duration', 150) : modifierValue(modifiers, 'duration', 150) / 2;\n    const styleValues = {\n      duration: duration,\n      origin: modifierValue(modifiers, 'origin', 'center'),\n      first: {\n        opacity: 1,\n        scale: 100\n      },\n      second: {\n        opacity: 0,\n        scale: modifierValue(modifiers, 'scale', 95)\n      }\n    };\n    transitionHelper(el, modifiers, () => {}, hideCallback, reject, styleValues, TRANSITION_TYPE_OUT);\n  }\n\n  function modifierValue(modifiers, key, fallback) {\n    // If the modifier isn't present, use the default.\n    if (modifiers.indexOf(key) === -1) return fallback; // If it IS present, grab the value after it: x-show.transition.duration.500ms\n\n    const rawValue = modifiers[modifiers.indexOf(key) + 1];\n    if (!rawValue) return fallback;\n\n    if (key === 'scale') {\n      // Check if the very next value is NOT a number and return the fallback.\n      // If x-show.transition.scale, we'll use the default scale value.\n      // That is how a user opts out of the opacity transition.\n      if (!isNumeric(rawValue)) return fallback;\n    }\n\n    if (key === 'duration') {\n      // Support x-show.transition.duration.500ms && duration.500\n      let match = rawValue.match(/([0-9]+)ms/);\n      if (match) return match[1];\n    }\n\n    if (key === 'origin') {\n      // Support chaining origin directions: x-show.transition.top.right\n      if (['top', 'right', 'left', 'center', 'bottom'].includes(modifiers[modifiers.indexOf(key) + 2])) {\n        return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(' ');\n      }\n    }\n\n    return rawValue;\n  }\n\n  function transitionHelper(el, modifiers, hook1, hook2, reject, styleValues, type) {\n    // clear the previous transition if exists to avoid caching the wrong styles\n    if (el.__x_transition) {\n      el.__x_transition.cancel && el.__x_transition.cancel();\n    } // If the user set these style values, we'll put them back when we're done with them.\n\n\n    const opacityCache = el.style.opacity;\n    const transformCache = el.style.transform;\n    const transformOriginCache = el.style.transformOrigin; // If no modifiers are present: x-show.transition, we'll default to both opacity and scale.\n\n    const noModifiers = !modifiers.includes('opacity') && !modifiers.includes('scale');\n    const transitionOpacity = noModifiers || modifiers.includes('opacity');\n    const transitionScale = noModifiers || modifiers.includes('scale'); // These are the explicit stages of a transition (same stages for in and for out).\n    // This way you can get a birds eye view of the hooks, and the differences\n    // between them.\n\n    const stages = {\n      start() {\n        if (transitionOpacity) el.style.opacity = styleValues.first.opacity;\n        if (transitionScale) el.style.transform = `scale(${styleValues.first.scale / 100})`;\n      },\n\n      during() {\n        if (transitionScale) el.style.transformOrigin = styleValues.origin;\n        el.style.transitionProperty = [transitionOpacity ? `opacity` : ``, transitionScale ? `transform` : ``].join(' ').trim();\n        el.style.transitionDuration = `${styleValues.duration / 1000}s`;\n        el.style.transitionTimingFunction = `cubic-bezier(0.4, 0.0, 0.2, 1)`;\n      },\n\n      show() {\n        hook1();\n      },\n\n      end() {\n        if (transitionOpacity) el.style.opacity = styleValues.second.opacity;\n        if (transitionScale) el.style.transform = `scale(${styleValues.second.scale / 100})`;\n      },\n\n      hide() {\n        hook2();\n      },\n\n      cleanup() {\n        if (transitionOpacity) el.style.opacity = opacityCache;\n        if (transitionScale) el.style.transform = transformCache;\n        if (transitionScale) el.style.transformOrigin = transformOriginCache;\n        el.style.transitionProperty = null;\n        el.style.transitionDuration = null;\n        el.style.transitionTimingFunction = null;\n      }\n\n    };\n    transition(el, stages, type, reject);\n  }\n\n  const ensureStringExpression = (expression, el, component) => {\n    return typeof expression === 'function' ? component.evaluateReturnExpression(el, expression) : expression;\n  };\n\n  function transitionClassesIn(el, component, directives, showCallback, reject) {\n    const enter = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'enter') || {\n      expression: ''\n    }).expression, el, component));\n    const enterStart = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'enter-start') || {\n      expression: ''\n    }).expression, el, component));\n    const enterEnd = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'enter-end') || {\n      expression: ''\n    }).expression, el, component));\n    transitionClasses(el, enter, enterStart, enterEnd, showCallback, () => {}, TRANSITION_TYPE_IN, reject);\n  }\n  function transitionClassesOut(el, component, directives, hideCallback, reject) {\n    const leave = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'leave') || {\n      expression: ''\n    }).expression, el, component));\n    const leaveStart = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'leave-start') || {\n      expression: ''\n    }).expression, el, component));\n    const leaveEnd = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'leave-end') || {\n      expression: ''\n    }).expression, el, component));\n    transitionClasses(el, leave, leaveStart, leaveEnd, () => {}, hideCallback, TRANSITION_TYPE_OUT, reject);\n  }\n  function transitionClasses(el, classesDuring, classesStart, classesEnd, hook1, hook2, type, reject) {\n    // clear the previous transition if exists to avoid caching the wrong classes\n    if (el.__x_transition) {\n      el.__x_transition.cancel && el.__x_transition.cancel();\n    }\n\n    const originalClasses = el.__x_original_classes || [];\n    const stages = {\n      start() {\n        el.classList.add(...classesStart);\n      },\n\n      during() {\n        el.classList.add(...classesDuring);\n      },\n\n      show() {\n        hook1();\n      },\n\n      end() {\n        // Don't remove classes that were in the original class attribute.\n        el.classList.remove(...classesStart.filter(i => !originalClasses.includes(i)));\n        el.classList.add(...classesEnd);\n      },\n\n      hide() {\n        hook2();\n      },\n\n      cleanup() {\n        el.classList.remove(...classesDuring.filter(i => !originalClasses.includes(i)));\n        el.classList.remove(...classesEnd.filter(i => !originalClasses.includes(i)));\n      }\n\n    };\n    transition(el, stages, type, reject);\n  }\n  function transition(el, stages, type, reject) {\n    const finish = once(() => {\n      stages.hide(); // Adding an \"isConnected\" check, in case the callback\n      // removed the element from the DOM.\n\n      if (el.isConnected) {\n        stages.cleanup();\n      }\n\n      delete el.__x_transition;\n    });\n    el.__x_transition = {\n      // Set transition type so we can avoid clearing transition if the direction is the same\n      type: type,\n      // create a callback for the last stages of the transition so we can call it\n      // from different point and early terminate it. Once will ensure that function\n      // is only called one time.\n      cancel: once(() => {\n        reject(TRANSITION_CANCELLED);\n        finish();\n      }),\n      finish,\n      // This store the next animation frame so we can cancel it\n      nextFrame: null\n    };\n    stages.start();\n    stages.during();\n    el.__x_transition.nextFrame = requestAnimationFrame(() => {\n      // Note: Safari's transitionDuration property will list out comma separated transition durations\n      // for every single transition property. Let's grab the first one and call it a day.\n      let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, '').replace('s', '')) * 1000;\n\n      if (duration === 0) {\n        duration = Number(getComputedStyle(el).animationDuration.replace('s', '')) * 1000;\n      }\n\n      stages.show();\n      el.__x_transition.nextFrame = requestAnimationFrame(() => {\n        stages.end();\n        setTimeout(el.__x_transition.finish, duration);\n      });\n    });\n  }\n  function isNumeric(subject) {\n    return !Array.isArray(subject) && !isNaN(subject);\n  } // Thanks @vuejs\n  // https://github.com/vuejs/vue/blob/4de4649d9637262a9b007720b59f80ac72a5620c/src/shared/util.js\n\n  function once(callback) {\n    let called = false;\n    return function () {\n      if (!called) {\n        called = true;\n        callback.apply(this, arguments);\n      }\n    };\n  }\n\n  function handleForDirective(component, templateEl, expression, initialUpdate, extraVars) {\n    warnIfMalformedTemplate(templateEl, 'x-for');\n    let iteratorNames = typeof expression === 'function' ? parseForExpression(component.evaluateReturnExpression(templateEl, expression)) : parseForExpression(expression);\n    let items = evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement(component, templateEl, iteratorNames, extraVars); // As we walk the array, we'll also walk the DOM (updating/creating as we go).\n\n    let currentEl = templateEl;\n    items.forEach((item, index) => {\n      let iterationScopeVariables = getIterationScopeVariables(iteratorNames, item, index, items, extraVars());\n      let currentKey = generateKeyForIteration(component, templateEl, index, iterationScopeVariables);\n      let nextEl = lookAheadForMatchingKeyedElementAndMoveItIfFound(currentEl.nextElementSibling, currentKey); // If we haven't found a matching key, insert the element at the current position.\n\n      if (!nextEl) {\n        nextEl = addElementInLoopAfterCurrentEl(templateEl, currentEl); // And transition it in if it's not the first page load.\n\n        transitionIn(nextEl, () => {}, () => {}, component, initialUpdate);\n        nextEl.__x_for = iterationScopeVariables;\n        component.initializeElements(nextEl, () => nextEl.__x_for); // Otherwise update the element we found.\n      } else {\n        // Temporarily remove the key indicator to allow the normal \"updateElements\" to work.\n        delete nextEl.__x_for_key;\n        nextEl.__x_for = iterationScopeVariables;\n        component.updateElements(nextEl, () => nextEl.__x_for);\n      }\n\n      currentEl = nextEl;\n      currentEl.__x_for_key = currentKey;\n    });\n    removeAnyLeftOverElementsFromPreviousUpdate(currentEl, component);\n  } // This was taken from VueJS 2.* core. Thanks Vue!\n\n  function parseForExpression(expression) {\n    let forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/;\n    let stripParensRE = /^\\(|\\)$/g;\n    let forAliasRE = /([\\s\\S]*?)\\s+(?:in|of)\\s+([\\s\\S]*)/;\n    let inMatch = String(expression).match(forAliasRE);\n    if (!inMatch) return;\n    let res = {};\n    res.items = inMatch[2].trim();\n    let item = inMatch[1].trim().replace(stripParensRE, '');\n    let iteratorMatch = item.match(forIteratorRE);\n\n    if (iteratorMatch) {\n      res.item = item.replace(forIteratorRE, '').trim();\n      res.index = iteratorMatch[1].trim();\n\n      if (iteratorMatch[2]) {\n        res.collection = iteratorMatch[2].trim();\n      }\n    } else {\n      res.item = item;\n    }\n\n    return res;\n  }\n\n  function getIterationScopeVariables(iteratorNames, item, index, items, extraVars) {\n    // We must create a new object, so each iteration has a new scope\n    let scopeVariables = extraVars ? _objectSpread2({}, extraVars) : {};\n    scopeVariables[iteratorNames.item] = item;\n    if (iteratorNames.index) scopeVariables[iteratorNames.index] = index;\n    if (iteratorNames.collection) scopeVariables[iteratorNames.collection] = items;\n    return scopeVariables;\n  }\n\n  function generateKeyForIteration(component, el, index, iterationScopeVariables) {\n    let bindKeyAttribute = getXAttrs(el, component, 'bind').filter(attr => attr.value === 'key')[0]; // If the dev hasn't specified a key, just return the index of the iteration.\n\n    if (!bindKeyAttribute) return index;\n    return component.evaluateReturnExpression(el, bindKeyAttribute.expression, () => iterationScopeVariables);\n  }\n\n  function evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement(component, el, iteratorNames, extraVars) {\n    let ifAttribute = getXAttrs(el, component, 'if')[0];\n\n    if (ifAttribute && !component.evaluateReturnExpression(el, ifAttribute.expression)) {\n      return [];\n    }\n\n    let items = component.evaluateReturnExpression(el, iteratorNames.items, extraVars); // This adds support for the `i in n` syntax.\n\n    if (isNumeric(items) && items >= 0) {\n      items = Array.from(Array(items).keys(), i => i + 1);\n    }\n\n    return items;\n  }\n\n  function addElementInLoopAfterCurrentEl(templateEl, currentEl) {\n    let clone = document.importNode(templateEl.content, true);\n    currentEl.parentElement.insertBefore(clone, currentEl.nextElementSibling);\n    return currentEl.nextElementSibling;\n  }\n\n  function lookAheadForMatchingKeyedElementAndMoveItIfFound(nextEl, currentKey) {\n    if (!nextEl) return; // If we are already past the x-for generated elements, we don't need to look ahead.\n\n    if (nextEl.__x_for_key === undefined) return; // If the the key's DO match, no need to look ahead.\n\n    if (nextEl.__x_for_key === currentKey) return nextEl; // If they don't, we'll look ahead for a match.\n    // If we find it, we'll move it to the current position in the loop.\n\n    let tmpNextEl = nextEl;\n\n    while (tmpNextEl) {\n      if (tmpNextEl.__x_for_key === currentKey) {\n        return tmpNextEl.parentElement.insertBefore(tmpNextEl, nextEl);\n      }\n\n      tmpNextEl = tmpNextEl.nextElementSibling && tmpNextEl.nextElementSibling.__x_for_key !== undefined ? tmpNextEl.nextElementSibling : false;\n    }\n  }\n\n  function removeAnyLeftOverElementsFromPreviousUpdate(currentEl, component) {\n    var nextElementFromOldLoop = currentEl.nextElementSibling && currentEl.nextElementSibling.__x_for_key !== undefined ? currentEl.nextElementSibling : false;\n\n    while (nextElementFromOldLoop) {\n      let nextElementFromOldLoopImmutable = nextElementFromOldLoop;\n      let nextSibling = nextElementFromOldLoop.nextElementSibling;\n      transitionOut(nextElementFromOldLoop, () => {\n        nextElementFromOldLoopImmutable.remove();\n      }, () => {}, component);\n      nextElementFromOldLoop = nextSibling && nextSibling.__x_for_key !== undefined ? nextSibling : false;\n    }\n  }\n\n  function handleAttributeBindingDirective(component, el, attrName, expression, extraVars, attrType, modifiers) {\n    var value = component.evaluateReturnExpression(el, expression, extraVars);\n\n    if (attrName === 'value') {\n      if (Alpine.ignoreFocusedForValueBinding && document.activeElement.isSameNode(el)) return; // If nested model key is undefined, set the default value to empty string.\n\n      if (value === undefined && String(expression).match(/\\./)) {\n        value = '';\n      }\n\n      if (el.type === 'radio') {\n        // Set radio value from x-bind:value, if no \"value\" attribute exists.\n        // If there are any initial state values, radio will have a correct\n        // \"checked\" value since x-bind:value is processed before x-model.\n        if (el.attributes.value === undefined && attrType === 'bind') {\n          el.value = value;\n        } else if (attrType !== 'bind') {\n          el.checked = checkedAttrLooseCompare(el.value, value);\n        }\n      } else if (el.type === 'checkbox') {\n        // If we are explicitly binding a string to the :value, set the string,\n        // If the value is a boolean, leave it alone, it will be set to \"on\"\n        // automatically.\n        if (typeof value !== 'boolean' && ![null, undefined].includes(value) && attrType === 'bind') {\n          el.value = String(value);\n        } else if (attrType !== 'bind') {\n          if (Array.isArray(value)) {\n            // I'm purposely not using Array.includes here because it's\n            // strict, and because of Numeric/String mis-casting, I\n            // want the \"includes\" to be \"fuzzy\".\n            el.checked = value.some(val => checkedAttrLooseCompare(val, el.value));\n          } else {\n            el.checked = !!value;\n          }\n        }\n      } else if (el.tagName === 'SELECT') {\n        updateSelect(el, value);\n      } else {\n        if (el.value === value) return;\n        el.value = value;\n      }\n    } else if (attrName === 'class') {\n      if (Array.isArray(value)) {\n        const originalClasses = el.__x_original_classes || [];\n        el.setAttribute('class', arrayUnique(originalClasses.concat(value)).join(' '));\n      } else if (typeof value === 'object') {\n        // Sorting the keys / class names by their boolean value will ensure that\n        // anything that evaluates to `false` and needs to remove classes is run first.\n        const keysSortedByBooleanValue = Object.keys(value).sort((a, b) => value[a] - value[b]);\n        keysSortedByBooleanValue.forEach(classNames => {\n          if (value[classNames]) {\n            convertClassStringToArray(classNames).forEach(className => el.classList.add(className));\n          } else {\n            convertClassStringToArray(classNames).forEach(className => el.classList.remove(className));\n          }\n        });\n      } else {\n        const originalClasses = el.__x_original_classes || [];\n        const newClasses = value ? convertClassStringToArray(value) : [];\n        el.setAttribute('class', arrayUnique(originalClasses.concat(newClasses)).join(' '));\n      }\n    } else {\n      attrName = modifiers.includes('camel') ? camelCase(attrName) : attrName; // If an attribute's bound value is null, undefined or false, remove the attribute\n\n      if ([null, undefined, false].includes(value)) {\n        el.removeAttribute(attrName);\n      } else {\n        isBooleanAttr(attrName) ? setIfChanged(el, attrName, attrName) : setIfChanged(el, attrName, value);\n      }\n    }\n  }\n\n  function setIfChanged(el, attrName, value) {\n    if (el.getAttribute(attrName) != value) {\n      el.setAttribute(attrName, value);\n    }\n  }\n\n  function updateSelect(el, value) {\n    const arrayWrappedValue = [].concat(value).map(value => {\n      return value + '';\n    });\n    Array.from(el.options).forEach(option => {\n      option.selected = arrayWrappedValue.includes(option.value || option.text);\n    });\n  }\n\n  function handleTextDirective(el, output, expression) {\n    // If nested model key is undefined, set the default value to empty string.\n    if (output === undefined && String(expression).match(/\\./)) {\n      output = '';\n    }\n\n    el.textContent = output;\n  }\n\n  function handleHtmlDirective(component, el, expression, extraVars) {\n    el.innerHTML = component.evaluateReturnExpression(el, expression, extraVars);\n  }\n\n  function handleShowDirective(component, el, value, modifiers, initialUpdate = false) {\n    const hide = () => {\n      el.style.display = 'none';\n      el.__x_is_shown = false;\n    };\n\n    const show = () => {\n      if (el.style.length === 1 && el.style.display === 'none') {\n        el.removeAttribute('style');\n      } else {\n        el.style.removeProperty('display');\n      }\n\n      el.__x_is_shown = true;\n    };\n\n    if (initialUpdate === true) {\n      if (value) {\n        show();\n      } else {\n        hide();\n      }\n\n      return;\n    }\n\n    const handle = (resolve, reject) => {\n      if (value) {\n        if (el.style.display === 'none' || el.__x_transition) {\n          transitionIn(el, () => {\n            show();\n          }, reject, component);\n        }\n\n        resolve(() => {});\n      } else {\n        if (el.style.display !== 'none') {\n          transitionOut(el, () => {\n            resolve(() => {\n              hide();\n            });\n          }, reject, component);\n        } else {\n          resolve(() => {});\n        }\n      }\n    }; // The working of x-show is a bit complex because we need to\n    // wait for any child transitions to finish before hiding\n    // some element. Also, this has to be done recursively.\n    // If x-show.immediate, foregoe the waiting.\n\n\n    if (modifiers.includes('immediate')) {\n      handle(finish => finish(), () => {});\n      return;\n    } // x-show is encountered during a DOM tree walk. If an element\n    // we encounter is NOT a child of another x-show element we\n    // can execute the previous x-show stack (if one exists).\n\n\n    if (component.showDirectiveLastElement && !component.showDirectiveLastElement.contains(el)) {\n      component.executeAndClearRemainingShowDirectiveStack();\n    }\n\n    component.showDirectiveStack.push(handle);\n    component.showDirectiveLastElement = el;\n  }\n\n  function handleIfDirective(component, el, expressionResult, initialUpdate, extraVars) {\n    warnIfMalformedTemplate(el, 'x-if');\n    const elementHasAlreadyBeenAdded = el.nextElementSibling && el.nextElementSibling.__x_inserted_me === true;\n\n    if (expressionResult && (!elementHasAlreadyBeenAdded || el.__x_transition)) {\n      const clone = document.importNode(el.content, true);\n      el.parentElement.insertBefore(clone, el.nextElementSibling);\n      transitionIn(el.nextElementSibling, () => {}, () => {}, component, initialUpdate);\n      component.initializeElements(el.nextElementSibling, extraVars);\n      el.nextElementSibling.__x_inserted_me = true;\n    } else if (!expressionResult && elementHasAlreadyBeenAdded) {\n      transitionOut(el.nextElementSibling, () => {\n        el.nextElementSibling.remove();\n      }, () => {}, component, initialUpdate);\n    }\n  }\n\n  function registerListener(component, el, event, modifiers, expression, extraVars = {}) {\n    const options = {\n      passive: modifiers.includes('passive')\n    };\n\n    if (modifiers.includes('camel')) {\n      event = camelCase(event);\n    }\n\n    let handler, listenerTarget;\n\n    if (modifiers.includes('away')) {\n      listenerTarget = document;\n\n      handler = e => {\n        // Don't do anything if the click came from the element or within it.\n        if (el.contains(e.target)) return; // Don't do anything if this element isn't currently visible.\n\n        if (el.offsetWidth < 1 && el.offsetHeight < 1) return; // Now that we are sure the element is visible, AND the click\n        // is from outside it, let's run the expression.\n\n        runListenerHandler(component, expression, e, extraVars);\n\n        if (modifiers.includes('once')) {\n          document.removeEventListener(event, handler, options);\n        }\n      };\n    } else {\n      listenerTarget = modifiers.includes('window') ? window : modifiers.includes('document') ? document : el;\n\n      handler = e => {\n        // Remove this global event handler if the element that declared it\n        // has been removed. It's now stale.\n        if (listenerTarget === window || listenerTarget === document) {\n          if (!document.body.contains(el)) {\n            listenerTarget.removeEventListener(event, handler, options);\n            return;\n          }\n        }\n\n        if (isKeyEvent(event)) {\n          if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) {\n            return;\n          }\n        }\n\n        if (modifiers.includes('prevent')) e.preventDefault();\n        if (modifiers.includes('stop')) e.stopPropagation(); // If the .self modifier isn't present, or if it is present and\n        // the target element matches the element we are registering the\n        // event on, run the handler\n\n        if (!modifiers.includes('self') || e.target === el) {\n          const returnValue = runListenerHandler(component, expression, e, extraVars);\n          returnValue.then(value => {\n            if (value === false) {\n              e.preventDefault();\n            } else {\n              if (modifiers.includes('once')) {\n                listenerTarget.removeEventListener(event, handler, options);\n              }\n            }\n          });\n        }\n      };\n    }\n\n    if (modifiers.includes('debounce')) {\n      let nextModifier = modifiers[modifiers.indexOf('debounce') + 1] || 'invalid-wait';\n      let wait = isNumeric(nextModifier.split('ms')[0]) ? Number(nextModifier.split('ms')[0]) : 250;\n      handler = debounce(handler, wait);\n    }\n\n    listenerTarget.addEventListener(event, handler, options);\n  }\n\n  function runListenerHandler(component, expression, e, extraVars) {\n    return component.evaluateCommandExpression(e.target, expression, () => {\n      return _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        '$event': e\n      });\n    });\n  }\n\n  function isKeyEvent(event) {\n    return ['keydown', 'keyup'].includes(event);\n  }\n\n  function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) {\n    let keyModifiers = modifiers.filter(i => {\n      return !['window', 'document', 'prevent', 'stop'].includes(i);\n    });\n\n    if (keyModifiers.includes('debounce')) {\n      let debounceIndex = keyModifiers.indexOf('debounce');\n      keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || 'invalid-wait').split('ms')[0]) ? 2 : 1);\n    } // If no modifier is specified, we'll call it a press.\n\n\n    if (keyModifiers.length === 0) return false; // If one is passed, AND it matches the key pressed, we'll call it a press.\n\n    if (keyModifiers.length === 1 && keyModifiers[0] === keyToModifier(e.key)) return false; // The user is listening for key combinations.\n\n    const systemKeyModifiers = ['ctrl', 'shift', 'alt', 'meta', 'cmd', 'super'];\n    const selectedSystemKeyModifiers = systemKeyModifiers.filter(modifier => keyModifiers.includes(modifier));\n    keyModifiers = keyModifiers.filter(i => !selectedSystemKeyModifiers.includes(i));\n\n    if (selectedSystemKeyModifiers.length > 0) {\n      const activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter(modifier => {\n        // Alias \"cmd\" and \"super\" to \"meta\"\n        if (modifier === 'cmd' || modifier === 'super') modifier = 'meta';\n        return e[`${modifier}Key`];\n      }); // If all the modifiers selected are pressed, ...\n\n      if (activelyPressedKeyModifiers.length === selectedSystemKeyModifiers.length) {\n        // AND the remaining key is pressed as well. It's a press.\n        if (keyModifiers[0] === keyToModifier(e.key)) return false;\n      }\n    } // We'll call it NOT a valid keypress.\n\n\n    return true;\n  }\n\n  function keyToModifier(key) {\n    switch (key) {\n      case '/':\n        return 'slash';\n\n      case ' ':\n      case 'Spacebar':\n        return 'space';\n\n      default:\n        return key && kebabCase(key);\n    }\n  }\n\n  function registerModelListener(component, el, modifiers, expression, extraVars) {\n    // If the element we are binding to is a select, a radio, or checkbox\n    // we'll listen for the change event instead of the \"input\" event.\n    var event = el.tagName.toLowerCase() === 'select' || ['checkbox', 'radio'].includes(el.type) || modifiers.includes('lazy') ? 'change' : 'input';\n    const listenerExpression = `${expression} = rightSideOfExpression($event, ${expression})`;\n    registerListener(component, el, event, modifiers, listenerExpression, () => {\n      return _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        rightSideOfExpression: generateModelAssignmentFunction(el, modifiers, expression)\n      });\n    });\n  }\n\n  function generateModelAssignmentFunction(el, modifiers, expression) {\n    if (el.type === 'radio') {\n      // Radio buttons only work properly when they share a name attribute.\n      // People might assume we take care of that for them, because\n      // they already set a shared \"x-model\" attribute.\n      if (!el.hasAttribute('name')) el.setAttribute('name', expression);\n    }\n\n    return (event, currentValue) => {\n      // Check for event.detail due to an issue where IE11 handles other events as a CustomEvent.\n      if (event instanceof CustomEvent && event.detail) {\n        return event.detail;\n      } else if (el.type === 'checkbox') {\n        // If the data we are binding to is an array, toggle its value inside the array.\n        if (Array.isArray(currentValue)) {\n          const newValue = modifiers.includes('number') ? safeParseNumber(event.target.value) : event.target.value;\n          return event.target.checked ? currentValue.concat([newValue]) : currentValue.filter(el => !checkedAttrLooseCompare(el, newValue));\n        } else {\n          return event.target.checked;\n        }\n      } else if (el.tagName.toLowerCase() === 'select' && el.multiple) {\n        return modifiers.includes('number') ? Array.from(event.target.selectedOptions).map(option => {\n          const rawValue = option.value || option.text;\n          return safeParseNumber(rawValue);\n        }) : Array.from(event.target.selectedOptions).map(option => {\n          return option.value || option.text;\n        });\n      } else {\n        const rawValue = event.target.value;\n        return modifiers.includes('number') ? safeParseNumber(rawValue) : modifiers.includes('trim') ? rawValue.trim() : rawValue;\n      }\n    };\n  }\n\n  function safeParseNumber(rawValue) {\n    const number = rawValue ? parseFloat(rawValue) : null;\n    return isNumeric(number) ? number : rawValue;\n  }\n\n  /**\n   * Copyright (C) 2017 salesforce.com, inc.\n   */\n  const { isArray } = Array;\n  const { getPrototypeOf, create: ObjectCreate, defineProperty: ObjectDefineProperty, defineProperties: ObjectDefineProperties, isExtensible, getOwnPropertyDescriptor, getOwnPropertyNames, getOwnPropertySymbols, preventExtensions, hasOwnProperty, } = Object;\n  const { push: ArrayPush, concat: ArrayConcat, map: ArrayMap, } = Array.prototype;\n  function isUndefined(obj) {\n      return obj === undefined;\n  }\n  function isFunction(obj) {\n      return typeof obj === 'function';\n  }\n  function isObject(obj) {\n      return typeof obj === 'object';\n  }\n  const proxyToValueMap = new WeakMap();\n  function registerProxy(proxy, value) {\n      proxyToValueMap.set(proxy, value);\n  }\n  const unwrap = (replicaOrAny) => proxyToValueMap.get(replicaOrAny) || replicaOrAny;\n\n  function wrapValue(membrane, value) {\n      return membrane.valueIsObservable(value) ? membrane.getProxy(value) : value;\n  }\n  /**\n   * Unwrap property descriptors will set value on original descriptor\n   * We only need to unwrap if value is specified\n   * @param descriptor external descrpitor provided to define new property on original value\n   */\n  function unwrapDescriptor(descriptor) {\n      if (hasOwnProperty.call(descriptor, 'value')) {\n          descriptor.value = unwrap(descriptor.value);\n      }\n      return descriptor;\n  }\n  function lockShadowTarget(membrane, shadowTarget, originalTarget) {\n      const targetKeys = ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));\n      targetKeys.forEach((key) => {\n          let descriptor = getOwnPropertyDescriptor(originalTarget, key);\n          // We do not need to wrap the descriptor if configurable\n          // Because we can deal with wrapping it when user goes through\n          // Get own property descriptor. There is also a chance that this descriptor\n          // could change sometime in the future, so we can defer wrapping\n          // until we need to\n          if (!descriptor.configurable) {\n              descriptor = wrapDescriptor(membrane, descriptor, wrapValue);\n          }\n          ObjectDefineProperty(shadowTarget, key, descriptor);\n      });\n      preventExtensions(shadowTarget);\n  }\n  class ReactiveProxyHandler {\n      constructor(membrane, value) {\n          this.originalTarget = value;\n          this.membrane = membrane;\n      }\n      get(shadowTarget, key) {\n          const { originalTarget, membrane } = this;\n          const value = originalTarget[key];\n          const { valueObserved } = membrane;\n          valueObserved(originalTarget, key);\n          return membrane.getProxy(value);\n      }\n      set(shadowTarget, key, value) {\n          const { originalTarget, membrane: { valueMutated } } = this;\n          const oldValue = originalTarget[key];\n          if (oldValue !== value) {\n              originalTarget[key] = value;\n              valueMutated(originalTarget, key);\n          }\n          else if (key === 'length' && isArray(originalTarget)) {\n              // fix for issue #236: push will add the new index, and by the time length\n              // is updated, the internal length is already equal to the new length value\n              // therefore, the oldValue is equal to the value. This is the forking logic\n              // to support this use case.\n              valueMutated(originalTarget, key);\n          }\n          return true;\n      }\n      deleteProperty(shadowTarget, key) {\n          const { originalTarget, membrane: { valueMutated } } = this;\n          delete originalTarget[key];\n          valueMutated(originalTarget, key);\n          return true;\n      }\n      apply(shadowTarget, thisArg, argArray) {\n          /* No op */\n      }\n      construct(target, argArray, newTarget) {\n          /* No op */\n      }\n      has(shadowTarget, key) {\n          const { originalTarget, membrane: { valueObserved } } = this;\n          valueObserved(originalTarget, key);\n          return key in originalTarget;\n      }\n      ownKeys(shadowTarget) {\n          const { originalTarget } = this;\n          return ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));\n      }\n      isExtensible(shadowTarget) {\n          const shadowIsExtensible = isExtensible(shadowTarget);\n          if (!shadowIsExtensible) {\n              return shadowIsExtensible;\n          }\n          const { originalTarget, membrane } = this;\n          const targetIsExtensible = isExtensible(originalTarget);\n          if (!targetIsExtensible) {\n              lockShadowTarget(membrane, shadowTarget, originalTarget);\n          }\n          return targetIsExtensible;\n      }\n      setPrototypeOf(shadowTarget, prototype) {\n      }\n      getPrototypeOf(shadowTarget) {\n          const { originalTarget } = this;\n          return getPrototypeOf(originalTarget);\n      }\n      getOwnPropertyDescriptor(shadowTarget, key) {\n          const { originalTarget, membrane } = this;\n          const { valueObserved } = this.membrane;\n          // keys looked up via hasOwnProperty need to be reactive\n          valueObserved(originalTarget, key);\n          let desc = getOwnPropertyDescriptor(originalTarget, key);\n          if (isUndefined(desc)) {\n              return desc;\n          }\n          const shadowDescriptor = getOwnPropertyDescriptor(shadowTarget, key);\n          if (!isUndefined(shadowDescriptor)) {\n              return shadowDescriptor;\n          }\n          // Note: by accessing the descriptor, the key is marked as observed\n          // but access to the value, setter or getter (if available) cannot observe\n          // mutations, just like regular methods, in which case we just do nothing.\n          desc = wrapDescriptor(membrane, desc, wrapValue);\n          if (!desc.configurable) {\n              // If descriptor from original target is not configurable,\n              // We must copy the wrapped descriptor over to the shadow target.\n              // Otherwise, proxy will throw an invariant error.\n              // This is our last chance to lock the value.\n              // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor#Invariants\n              ObjectDefineProperty(shadowTarget, key, desc);\n          }\n          return desc;\n      }\n      preventExtensions(shadowTarget) {\n          const { originalTarget, membrane } = this;\n          lockShadowTarget(membrane, shadowTarget, originalTarget);\n          preventExtensions(originalTarget);\n          return true;\n      }\n      defineProperty(shadowTarget, key, descriptor) {\n          const { originalTarget, membrane } = this;\n          const { valueMutated } = membrane;\n          const { configurable } = descriptor;\n          // We have to check for value in descriptor\n          // because Object.freeze(proxy) calls this method\n          // with only { configurable: false, writeable: false }\n          // Additionally, method will only be called with writeable:false\n          // if the descriptor has a value, as opposed to getter/setter\n          // So we can just check if writable is present and then see if\n          // value is present. This eliminates getter and setter descriptors\n          if (hasOwnProperty.call(descriptor, 'writable') && !hasOwnProperty.call(descriptor, 'value')) {\n              const originalDescriptor = getOwnPropertyDescriptor(originalTarget, key);\n              descriptor.value = originalDescriptor.value;\n          }\n          ObjectDefineProperty(originalTarget, key, unwrapDescriptor(descriptor));\n          if (configurable === false) {\n              ObjectDefineProperty(shadowTarget, key, wrapDescriptor(membrane, descriptor, wrapValue));\n          }\n          valueMutated(originalTarget, key);\n          return true;\n      }\n  }\n\n  function wrapReadOnlyValue(membrane, value) {\n      return membrane.valueIsObservable(value) ? membrane.getReadOnlyProxy(value) : value;\n  }\n  class ReadOnlyHandler {\n      constructor(membrane, value) {\n          this.originalTarget = value;\n          this.membrane = membrane;\n      }\n      get(shadowTarget, key) {\n          const { membrane, originalTarget } = this;\n          const value = originalTarget[key];\n          const { valueObserved } = membrane;\n          valueObserved(originalTarget, key);\n          return membrane.getReadOnlyProxy(value);\n      }\n      set(shadowTarget, key, value) {\n          return false;\n      }\n      deleteProperty(shadowTarget, key) {\n          return false;\n      }\n      apply(shadowTarget, thisArg, argArray) {\n          /* No op */\n      }\n      construct(target, argArray, newTarget) {\n          /* No op */\n      }\n      has(shadowTarget, key) {\n          const { originalTarget, membrane: { valueObserved } } = this;\n          valueObserved(originalTarget, key);\n          return key in originalTarget;\n      }\n      ownKeys(shadowTarget) {\n          const { originalTarget } = this;\n          return ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));\n      }\n      setPrototypeOf(shadowTarget, prototype) {\n      }\n      getOwnPropertyDescriptor(shadowTarget, key) {\n          const { originalTarget, membrane } = this;\n          const { valueObserved } = membrane;\n          // keys looked up via hasOwnProperty need to be reactive\n          valueObserved(originalTarget, key);\n          let desc = getOwnPropertyDescriptor(originalTarget, key);\n          if (isUndefined(desc)) {\n              return desc;\n          }\n          const shadowDescriptor = getOwnPropertyDescriptor(shadowTarget, key);\n          if (!isUndefined(shadowDescriptor)) {\n              return shadowDescriptor;\n          }\n          // Note: by accessing the descriptor, the key is marked as observed\n          // but access to the value or getter (if available) cannot be observed,\n          // just like regular methods, in which case we just do nothing.\n          desc = wrapDescriptor(membrane, desc, wrapReadOnlyValue);\n          if (hasOwnProperty.call(desc, 'set')) {\n              desc.set = undefined; // readOnly membrane does not allow setters\n          }\n          if (!desc.configurable) {\n              // If descriptor from original target is not configurable,\n              // We must copy the wrapped descriptor over to the shadow target.\n              // Otherwise, proxy will throw an invariant error.\n              // This is our last chance to lock the value.\n              // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor#Invariants\n              ObjectDefineProperty(shadowTarget, key, desc);\n          }\n          return desc;\n      }\n      preventExtensions(shadowTarget) {\n          return false;\n      }\n      defineProperty(shadowTarget, key, descriptor) {\n          return false;\n      }\n  }\n  function createShadowTarget(value) {\n      let shadowTarget = undefined;\n      if (isArray(value)) {\n          shadowTarget = [];\n      }\n      else if (isObject(value)) {\n          shadowTarget = {};\n      }\n      return shadowTarget;\n  }\n  const ObjectDotPrototype = Object.prototype;\n  function defaultValueIsObservable(value) {\n      // intentionally checking for null\n      if (value === null) {\n          return false;\n      }\n      // treat all non-object types, including undefined, as non-observable values\n      if (typeof value !== 'object') {\n          return false;\n      }\n      if (isArray(value)) {\n          return true;\n      }\n      const proto = getPrototypeOf(value);\n      return (proto === ObjectDotPrototype || proto === null || getPrototypeOf(proto) === null);\n  }\n  const defaultValueObserved = (obj, key) => {\n      /* do nothing */\n  };\n  const defaultValueMutated = (obj, key) => {\n      /* do nothing */\n  };\n  const defaultValueDistortion = (value) => value;\n  function wrapDescriptor(membrane, descriptor, getValue) {\n      const { set, get } = descriptor;\n      if (hasOwnProperty.call(descriptor, 'value')) {\n          descriptor.value = getValue(membrane, descriptor.value);\n      }\n      else {\n          if (!isUndefined(get)) {\n              descriptor.get = function () {\n                  // invoking the original getter with the original target\n                  return getValue(membrane, get.call(unwrap(this)));\n              };\n          }\n          if (!isUndefined(set)) {\n              descriptor.set = function (value) {\n                  // At this point we don't have a clear indication of whether\n                  // or not a valid mutation will occur, we don't have the key,\n                  // and we are not sure why and how they are invoking this setter.\n                  // Nevertheless we preserve the original semantics by invoking the\n                  // original setter with the original target and the unwrapped value\n                  set.call(unwrap(this), membrane.unwrapProxy(value));\n              };\n          }\n      }\n      return descriptor;\n  }\n  class ReactiveMembrane {\n      constructor(options) {\n          this.valueDistortion = defaultValueDistortion;\n          this.valueMutated = defaultValueMutated;\n          this.valueObserved = defaultValueObserved;\n          this.valueIsObservable = defaultValueIsObservable;\n          this.objectGraph = new WeakMap();\n          if (!isUndefined(options)) {\n              const { valueDistortion, valueMutated, valueObserved, valueIsObservable } = options;\n              this.valueDistortion = isFunction(valueDistortion) ? valueDistortion : defaultValueDistortion;\n              this.valueMutated = isFunction(valueMutated) ? valueMutated : defaultValueMutated;\n              this.valueObserved = isFunction(valueObserved) ? valueObserved : defaultValueObserved;\n              this.valueIsObservable = isFunction(valueIsObservable) ? valueIsObservable : defaultValueIsObservable;\n          }\n      }\n      getProxy(value) {\n          const unwrappedValue = unwrap(value);\n          const distorted = this.valueDistortion(unwrappedValue);\n          if (this.valueIsObservable(distorted)) {\n              const o = this.getReactiveState(unwrappedValue, distorted);\n              // when trying to extract the writable version of a readonly\n              // we return the readonly.\n              return o.readOnly === value ? value : o.reactive;\n          }\n          return distorted;\n      }\n      getReadOnlyProxy(value) {\n          value = unwrap(value);\n          const distorted = this.valueDistortion(value);\n          if (this.valueIsObservable(distorted)) {\n              return this.getReactiveState(value, distorted).readOnly;\n          }\n          return distorted;\n      }\n      unwrapProxy(p) {\n          return unwrap(p);\n      }\n      getReactiveState(value, distortedValue) {\n          const { objectGraph, } = this;\n          let reactiveState = objectGraph.get(distortedValue);\n          if (reactiveState) {\n              return reactiveState;\n          }\n          const membrane = this;\n          reactiveState = {\n              get reactive() {\n                  const reactiveHandler = new ReactiveProxyHandler(membrane, distortedValue);\n                  // caching the reactive proxy after the first time it is accessed\n                  const proxy = new Proxy(createShadowTarget(distortedValue), reactiveHandler);\n                  registerProxy(proxy, value);\n                  ObjectDefineProperty(this, 'reactive', { value: proxy });\n                  return proxy;\n              },\n              get readOnly() {\n                  const readOnlyHandler = new ReadOnlyHandler(membrane, distortedValue);\n                  // caching the readOnly proxy after the first time it is accessed\n                  const proxy = new Proxy(createShadowTarget(distortedValue), readOnlyHandler);\n                  registerProxy(proxy, value);\n                  ObjectDefineProperty(this, 'readOnly', { value: proxy });\n                  return proxy;\n              }\n          };\n          objectGraph.set(distortedValue, reactiveState);\n          return reactiveState;\n      }\n  }\n  /** version: 0.26.0 */\n\n  function wrap(data, mutationCallback) {\n\n    let membrane = new ReactiveMembrane({\n      valueMutated(target, key) {\n        mutationCallback(target, key);\n      }\n\n    });\n    return {\n      data: membrane.getProxy(data),\n      membrane: membrane\n    };\n  }\n  function unwrap$1(membrane, observable) {\n    let unwrappedData = membrane.unwrapProxy(observable);\n    let copy = {};\n    Object.keys(unwrappedData).forEach(key => {\n      if (['$el', '$refs', '$nextTick', '$watch'].includes(key)) return;\n      copy[key] = unwrappedData[key];\n    });\n    return copy;\n  }\n\n  class Component {\n    constructor(el, componentForClone = null) {\n      this.$el = el;\n      const dataAttr = this.$el.getAttribute('x-data');\n      const dataExpression = dataAttr === '' ? '{}' : dataAttr;\n      const initExpression = this.$el.getAttribute('x-init');\n      let dataExtras = {\n        $el: this.$el\n      };\n      let canonicalComponentElementReference = componentForClone ? componentForClone.$el : this.$el;\n      Object.entries(Alpine.magicProperties).forEach(([name, callback]) => {\n        Object.defineProperty(dataExtras, `$${name}`, {\n          get: function get() {\n            return callback(canonicalComponentElementReference);\n          }\n        });\n      });\n      this.unobservedData = componentForClone ? componentForClone.getUnobservedData() : saferEval(el, dataExpression, dataExtras);\n      // Construct a Proxy-based observable. This will be used to handle reactivity.\n\n      let {\n        membrane,\n        data\n      } = this.wrapDataInObservable(this.unobservedData);\n      this.$data = data;\n      this.membrane = membrane; // After making user-supplied data methods reactive, we can now add\n      // our magic properties to the original data for access.\n\n      this.unobservedData.$el = this.$el;\n      this.unobservedData.$refs = this.getRefsProxy();\n      this.nextTickStack = [];\n\n      this.unobservedData.$nextTick = callback => {\n        this.nextTickStack.push(callback);\n      };\n\n      this.watchers = {};\n\n      this.unobservedData.$watch = (property, callback) => {\n        if (!this.watchers[property]) this.watchers[property] = [];\n        this.watchers[property].push(callback);\n      };\n      /* MODERN-ONLY:START */\n      // We remove this piece of code from the legacy build.\n      // In IE11, we have already defined our helpers at this point.\n      // Register custom magic properties.\n\n\n      Object.entries(Alpine.magicProperties).forEach(([name, callback]) => {\n        Object.defineProperty(this.unobservedData, `$${name}`, {\n          get: function get() {\n            return callback(canonicalComponentElementReference, this.$el);\n          }\n        });\n      });\n      /* MODERN-ONLY:END */\n\n      this.showDirectiveStack = [];\n      this.showDirectiveLastElement;\n      componentForClone || Alpine.onBeforeComponentInitializeds.forEach(callback => callback(this));\n      var initReturnedCallback; // If x-init is present AND we aren't cloning (skip x-init on clone)\n\n      if (initExpression && !componentForClone) {\n        // We want to allow data manipulation, but not trigger DOM updates just yet.\n        // We haven't even initialized the elements with their Alpine bindings. I mean c'mon.\n        this.pauseReactivity = true;\n        initReturnedCallback = this.evaluateReturnExpression(this.$el, initExpression);\n        this.pauseReactivity = false;\n      } // Register all our listeners and set all our attribute bindings.\n      // If we're cloning a component, the third parameter ensures no duplicate\n      // event listeners are registered (the mutation observer will take care of them)\n\n\n      this.initializeElements(this.$el, () => {}, componentForClone); // Use mutation observer to detect new elements being added within this component at run-time.\n      // Alpine's just so darn flexible amirite?\n\n      this.listenForNewElementsToInitialize();\n\n      if (typeof initReturnedCallback === 'function') {\n        // Run the callback returned from the \"x-init\" hook to allow the user to do stuff after\n        // Alpine's got it's grubby little paws all over everything.\n        initReturnedCallback.call(this.$data);\n      }\n\n      componentForClone || setTimeout(() => {\n        Alpine.onComponentInitializeds.forEach(callback => callback(this));\n      }, 0);\n    }\n\n    getUnobservedData() {\n      return unwrap$1(this.membrane, this.$data);\n    }\n\n    wrapDataInObservable(data) {\n      var self = this;\n      let updateDom = debounce(function () {\n        self.updateElements(self.$el);\n      }, 0);\n      return wrap(data, (target, key) => {\n        if (self.watchers[key]) {\n          // If there's a watcher for this specific key, run it.\n          self.watchers[key].forEach(callback => callback(target[key]));\n        } else if (Array.isArray(target)) {\n          // Arrays are special cases, if any of the items change, we consider the array as mutated.\n          Object.keys(self.watchers).forEach(fullDotNotationKey => {\n            let dotNotationParts = fullDotNotationKey.split('.'); // Ignore length mutations since they would result in duplicate calls.\n            // For example, when calling push, we would get a mutation for the item's key\n            // and a second mutation for the length property.\n\n            if (key === 'length') return;\n            dotNotationParts.reduce((comparisonData, part) => {\n              if (Object.is(target, comparisonData[part])) {\n                self.watchers[fullDotNotationKey].forEach(callback => callback(target));\n              }\n\n              return comparisonData[part];\n            }, self.unobservedData);\n          });\n        } else {\n          // Let's walk through the watchers with \"dot-notation\" (foo.bar) and see\n          // if this mutation fits any of them.\n          Object.keys(self.watchers).filter(i => i.includes('.')).forEach(fullDotNotationKey => {\n            let dotNotationParts = fullDotNotationKey.split('.'); // If this dot-notation watcher's last \"part\" doesn't match the current\n            // key, then skip it early for performance reasons.\n\n            if (key !== dotNotationParts[dotNotationParts.length - 1]) return; // Now, walk through the dot-notation \"parts\" recursively to find\n            // a match, and call the watcher if one's found.\n\n            dotNotationParts.reduce((comparisonData, part) => {\n              if (Object.is(target, comparisonData)) {\n                // Run the watchers.\n                self.watchers[fullDotNotationKey].forEach(callback => callback(target[key]));\n              }\n\n              return comparisonData[part];\n            }, self.unobservedData);\n          });\n        } // Don't react to data changes for cases like the `x-created` hook.\n\n\n        if (self.pauseReactivity) return;\n        updateDom();\n      });\n    }\n\n    walkAndSkipNestedComponents(el, callback, initializeComponentCallback = () => {}) {\n      walk(el, el => {\n        // We've hit a component.\n        if (el.hasAttribute('x-data')) {\n          // If it's not the current one.\n          if (!el.isSameNode(this.$el)) {\n            // Initialize it if it's not.\n            if (!el.__x) initializeComponentCallback(el); // Now we'll let that sub-component deal with itself.\n\n            return false;\n          }\n        }\n\n        return callback(el);\n      });\n    }\n\n    initializeElements(rootEl, extraVars = () => {}, componentForClone = false) {\n      this.walkAndSkipNestedComponents(rootEl, el => {\n        // Don't touch spawns from for loop\n        if (el.__x_for_key !== undefined) return false; // Don't touch spawns from if directives\n\n        if (el.__x_inserted_me !== undefined) return false;\n        this.initializeElement(el, extraVars, componentForClone ? false : true);\n      }, el => {\n        if (!componentForClone) el.__x = new Component(el);\n      });\n      this.executeAndClearRemainingShowDirectiveStack();\n      this.executeAndClearNextTickStack(rootEl);\n    }\n\n    initializeElement(el, extraVars, shouldRegisterListeners = true) {\n      // To support class attribute merging, we have to know what the element's\n      // original class attribute looked like for reference.\n      if (el.hasAttribute('class') && getXAttrs(el, this).length > 0) {\n        el.__x_original_classes = convertClassStringToArray(el.getAttribute('class'));\n      }\n\n      shouldRegisterListeners && this.registerListeners(el, extraVars);\n      this.resolveBoundAttributes(el, true, extraVars);\n    }\n\n    updateElements(rootEl, extraVars = () => {}) {\n      this.walkAndSkipNestedComponents(rootEl, el => {\n        // Don't touch spawns from for loop (and check if the root is actually a for loop in a parent, don't skip it.)\n        if (el.__x_for_key !== undefined && !el.isSameNode(this.$el)) return false;\n        this.updateElement(el, extraVars);\n      }, el => {\n        el.__x = new Component(el);\n      });\n      this.executeAndClearRemainingShowDirectiveStack();\n      this.executeAndClearNextTickStack(rootEl);\n    }\n\n    executeAndClearNextTickStack(el) {\n      // Skip spawns from alpine directives\n      if (el === this.$el && this.nextTickStack.length > 0) {\n        // We run the tick stack after the next frame to allow any\n        // running transitions to pass the initial show stage.\n        requestAnimationFrame(() => {\n          while (this.nextTickStack.length > 0) {\n            this.nextTickStack.shift()();\n          }\n        });\n      }\n    }\n\n    executeAndClearRemainingShowDirectiveStack() {\n      // The goal here is to start all the x-show transitions\n      // and build a nested promise chain so that elements\n      // only hide when the children are finished hiding.\n      this.showDirectiveStack.reverse().map(handler => {\n        return new Promise((resolve, reject) => {\n          handler(resolve, reject);\n        });\n      }).reduce((promiseChain, promise) => {\n        return promiseChain.then(() => {\n          return promise.then(finishElement => {\n            finishElement();\n          });\n        });\n      }, Promise.resolve(() => {})).catch(e => {\n        if (e !== TRANSITION_CANCELLED) throw e;\n      }); // We've processed the handler stack. let's clear it.\n\n      this.showDirectiveStack = [];\n      this.showDirectiveLastElement = undefined;\n    }\n\n    updateElement(el, extraVars) {\n      this.resolveBoundAttributes(el, false, extraVars);\n    }\n\n    registerListeners(el, extraVars) {\n      getXAttrs(el, this).forEach(({\n        type,\n        value,\n        modifiers,\n        expression\n      }) => {\n        switch (type) {\n          case 'on':\n            registerListener(this, el, value, modifiers, expression, extraVars);\n            break;\n\n          case 'model':\n            registerModelListener(this, el, modifiers, expression, extraVars);\n            break;\n        }\n      });\n    }\n\n    resolveBoundAttributes(el, initialUpdate = false, extraVars) {\n      let attrs = getXAttrs(el, this);\n      attrs.forEach(({\n        type,\n        value,\n        modifiers,\n        expression\n      }) => {\n        switch (type) {\n          case 'model':\n            handleAttributeBindingDirective(this, el, 'value', expression, extraVars, type, modifiers);\n            break;\n\n          case 'bind':\n            // The :key binding on an x-for is special, ignore it.\n            if (el.tagName.toLowerCase() === 'template' && value === 'key') return;\n            handleAttributeBindingDirective(this, el, value, expression, extraVars, type, modifiers);\n            break;\n\n          case 'text':\n            var output = this.evaluateReturnExpression(el, expression, extraVars);\n            handleTextDirective(el, output, expression);\n            break;\n\n          case 'html':\n            handleHtmlDirective(this, el, expression, extraVars);\n            break;\n\n          case 'show':\n            var output = this.evaluateReturnExpression(el, expression, extraVars);\n            handleShowDirective(this, el, output, modifiers, initialUpdate);\n            break;\n\n          case 'if':\n            // If this element also has x-for on it, don't process x-if.\n            // We will let the \"x-for\" directive handle the \"if\"ing.\n            if (attrs.some(i => i.type === 'for')) return;\n            var output = this.evaluateReturnExpression(el, expression, extraVars);\n            handleIfDirective(this, el, output, initialUpdate, extraVars);\n            break;\n\n          case 'for':\n            handleForDirective(this, el, expression, initialUpdate, extraVars);\n            break;\n\n          case 'cloak':\n            el.removeAttribute('x-cloak');\n            break;\n        }\n      });\n    }\n\n    evaluateReturnExpression(el, expression, extraVars = () => {}) {\n      return saferEval(el, expression, this.$data, _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        $dispatch: this.getDispatchFunction(el)\n      }));\n    }\n\n    evaluateCommandExpression(el, expression, extraVars = () => {}) {\n      return saferEvalNoReturn(el, expression, this.$data, _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        $dispatch: this.getDispatchFunction(el)\n      }));\n    }\n\n    getDispatchFunction(el) {\n      return (event, detail = {}) => {\n        el.dispatchEvent(new CustomEvent(event, {\n          detail,\n          bubbles: true\n        }));\n      };\n    }\n\n    listenForNewElementsToInitialize() {\n      const targetNode = this.$el;\n      const observerOptions = {\n        childList: true,\n        attributes: true,\n        subtree: true\n      };\n      const observer = new MutationObserver(mutations => {\n        for (let i = 0; i < mutations.length; i++) {\n          // Filter out mutations triggered from child components.\n          const closestParentComponent = mutations[i].target.closest('[x-data]');\n          if (!(closestParentComponent && closestParentComponent.isSameNode(this.$el))) continue;\n\n          if (mutations[i].type === 'attributes' && mutations[i].attributeName === 'x-data') {\n            const xAttr = mutations[i].target.getAttribute('x-data') || '{}';\n            const rawData = saferEval(this.$el, xAttr, {\n              $el: this.$el\n            });\n            Object.keys(rawData).forEach(key => {\n              if (this.$data[key] !== rawData[key]) {\n                this.$data[key] = rawData[key];\n              }\n            });\n          }\n\n          if (mutations[i].addedNodes.length > 0) {\n            mutations[i].addedNodes.forEach(node => {\n              if (node.nodeType !== 1 || node.__x_inserted_me) return;\n\n              if (node.matches('[x-data]') && !node.__x) {\n                node.__x = new Component(node);\n                return;\n              }\n\n              this.initializeElements(node);\n            });\n          }\n        }\n      });\n      observer.observe(targetNode, observerOptions);\n    }\n\n    getRefsProxy() {\n      var self = this;\n      var refObj = {};\n      // One of the goals of this is to not hold elements in memory, but rather re-evaluate\n      // the DOM when the system needs something from it. This way, the framework is flexible and\n      // friendly to outside DOM changes from libraries like Vue/Livewire.\n      // For this reason, I'm using an \"on-demand\" proxy to fake a \"$refs\" object.\n\n      return new Proxy(refObj, {\n        get(object, property) {\n          if (property === '$isAlpineProxy') return true;\n          var ref; // We can't just query the DOM because it's hard to filter out refs in\n          // nested components.\n\n          self.walkAndSkipNestedComponents(self.$el, el => {\n            if (el.hasAttribute('x-ref') && el.getAttribute('x-ref') === property) {\n              ref = el;\n            }\n          });\n          return ref;\n        }\n\n      });\n    }\n\n  }\n\n  const Alpine = {\n    version: \"2.8.2\",\n    pauseMutationObserver: false,\n    magicProperties: {},\n    onComponentInitializeds: [],\n    onBeforeComponentInitializeds: [],\n    ignoreFocusedForValueBinding: false,\n    start: async function start() {\n      if (!isTesting()) {\n        await domReady();\n      }\n\n      this.discoverComponents(el => {\n        this.initializeComponent(el);\n      }); // It's easier and more performant to just support Turbolinks than listen\n      // to MutationObserver mutations at the document level.\n\n      document.addEventListener(\"turbolinks:load\", () => {\n        this.discoverUninitializedComponents(el => {\n          this.initializeComponent(el);\n        });\n      });\n      this.listenForNewUninitializedComponentsAtRunTime();\n    },\n    discoverComponents: function discoverComponents(callback) {\n      const rootEls = document.querySelectorAll('[x-data]');\n      rootEls.forEach(rootEl => {\n        callback(rootEl);\n      });\n    },\n    discoverUninitializedComponents: function discoverUninitializedComponents(callback, el = null) {\n      const rootEls = (el || document).querySelectorAll('[x-data]');\n      Array.from(rootEls).filter(el => el.__x === undefined).forEach(rootEl => {\n        callback(rootEl);\n      });\n    },\n    listenForNewUninitializedComponentsAtRunTime: function listenForNewUninitializedComponentsAtRunTime() {\n      const targetNode = document.querySelector('body');\n      const observerOptions = {\n        childList: true,\n        attributes: true,\n        subtree: true\n      };\n      const observer = new MutationObserver(mutations => {\n        if (this.pauseMutationObserver) return;\n\n        for (let i = 0; i < mutations.length; i++) {\n          if (mutations[i].addedNodes.length > 0) {\n            mutations[i].addedNodes.forEach(node => {\n              // Discard non-element nodes (like line-breaks)\n              if (node.nodeType !== 1) return; // Discard any changes happening within an existing component.\n              // They will take care of themselves.\n\n              if (node.parentElement && node.parentElement.closest('[x-data]')) return;\n              this.discoverUninitializedComponents(el => {\n                this.initializeComponent(el);\n              }, node.parentElement);\n            });\n          }\n        }\n      });\n      observer.observe(targetNode, observerOptions);\n    },\n    initializeComponent: function initializeComponent(el) {\n      if (!el.__x) {\n        // Wrap in a try/catch so that we don't prevent other components\n        // from initializing when one component contains an error.\n        try {\n          el.__x = new Component(el);\n        } catch (error) {\n          setTimeout(() => {\n            throw error;\n          }, 0);\n        }\n      }\n    },\n    clone: function clone(component, newEl) {\n      if (!newEl.__x) {\n        newEl.__x = new Component(newEl, component);\n      }\n    },\n    addMagicProperty: function addMagicProperty(name, callback) {\n      this.magicProperties[name] = callback;\n    },\n    onComponentInitialized: function onComponentInitialized(callback) {\n      this.onComponentInitializeds.push(callback);\n    },\n    onBeforeComponentInitialized: function onBeforeComponentInitialized(callback) {\n      this.onBeforeComponentInitializeds.push(callback);\n    }\n  };\n\n  if (!isTesting()) {\n    window.Alpine = Alpine;\n\n    if (window.deferLoadingAlpine) {\n      window.deferLoadingAlpine(function () {\n        window.Alpine.start();\n      });\n    } else {\n      window.Alpine.start();\n    }\n  }\n\n  return Alpine;\n\n})));\n","// Register a service worker to serve assets from local cache.\n\n// This lets the app load faster on subsequent visits in production, and gives\n// it offline capabilities. However, it also means that developers (and users)\n// will only see deployed updates on the \"N+1\" visit to a page, since previously\n// cached resources are updated in the background.\n\nvar isLocalhost = function () { return Boolean(\n  window.location.hostname === 'localhost' ||\n    // [::1] is the IPv6 localhost address.\n    window.location.hostname === '[::1]' ||\n    // 127.0.0.1/8 is considered localhost for IPv4.\n    window.location.hostname.match(\n      /^127(?:\\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/\n    )\n); }\n\nvar waitWindowLoad\n// https://github.com/yyx990803/register-service-worker/pull/33#discussion_r394181861\nif (typeof window !== 'undefined') {\n  // Typically, a browser that supports `serviceWorker` should also have supported\n  // `Promise`. But as this package can be used in environments without service\n  // worker support (in that case it would do nothing), there's a chance that\n  // `Promise` does not exist. So we must check for its existence first.\n  if (typeof Promise !== 'undefined') {\n    waitWindowLoad = new Promise(function (resolve) { return window.addEventListener('load', resolve); })\n  } else {\n    waitWindowLoad = { then: function (cb) { return window.addEventListener('load', cb); } }\n  }\n}\n\nexport function register (swUrl, hooks) {\n  if ( hooks === void 0 ) hooks = {};\n\n  var registrationOptions = hooks.registrationOptions; if ( registrationOptions === void 0 ) registrationOptions = {};\n  delete hooks.registrationOptions\n\n  var emit = function (hook) {\n    var args = [], len = arguments.length - 1;\n    while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];\n\n    if (hooks && hooks[hook]) {\n      hooks[hook].apply(hooks, args)\n    }\n  }\n\n  if ('serviceWorker' in navigator) {\n    waitWindowLoad.then(function () {\n      if (isLocalhost()) {\n        // This is running on localhost. Lets check if a service worker still exists or not.\n        checkValidServiceWorker(swUrl, emit, registrationOptions)\n        navigator.serviceWorker.ready.then(function (registration) {\n          emit('ready', registration)\n        }).catch(function (error) { return handleError(emit, error); })\n      } else {\n        // Is not local host. Just register service worker\n        registerValidSW(swUrl, emit, registrationOptions)\n        navigator.serviceWorker.ready.then(function (registration) {\n          emit('ready', registration)\n        }).catch(function (error) { return handleError(emit, error); })\n      }\n    })\n  }\n}\n\nfunction handleError (emit, error) {\n  if (!navigator.onLine) {\n    emit('offline')\n  }\n  emit('error', error)\n}\n\nfunction registerValidSW (swUrl, emit, registrationOptions) {\n  navigator.serviceWorker\n    .register(swUrl, registrationOptions)\n    .then(function (registration) {\n      emit('registered', registration)\n      if (registration.waiting) {\n        emit('updated', registration)\n        return\n      }\n      registration.onupdatefound = function () {\n        emit('updatefound', registration)\n        var installingWorker = registration.installing\n        installingWorker.onstatechange = function () {\n          if (installingWorker.state === 'installed') {\n            if (navigator.serviceWorker.controller) {\n              // At this point, the old content will have been purged and\n              // the fresh content will have been added to the cache.\n              // It's the perfect time to display a \"New content is\n              // available; please refresh.\" message in your web app.\n              emit('updated', registration)\n            } else {\n              // At this point, everything has been precached.\n              // It's the perfect time to display a\n              // \"Content is cached for offline use.\" message.\n              emit('cached', registration)\n            }\n          }\n        }\n      }\n    })\n    .catch(function (error) { return handleError(emit, error); })\n}\n\nfunction checkValidServiceWorker (swUrl, emit, registrationOptions) {\n  // Check if the service worker can be found.\n  fetch(swUrl)\n    .then(function (response) {\n      // Ensure service worker exists, and that we really are getting a JS file.\n      if (response.status === 404) {\n        // No service worker found.\n        emit('error', new Error((\"Service worker not found at \" + swUrl)))\n        unregister()\n      } else if (response.headers.get('content-type').indexOf('javascript') === -1) {\n        emit('error', new Error(\n          \"Expected \" + swUrl + \" to have javascript content-type, \" +\n          \"but received \" + (response.headers.get('content-type'))))\n        unregister()\n      } else {\n        // Service worker found. Proceed as normal.\n        registerValidSW(swUrl, emit, registrationOptions)\n      }\n    })\n    .catch(function (error) { return handleError(emit, error); })\n}\n\nexport function unregister () {\n  if ('serviceWorker' in navigator) {\n    navigator.serviceWorker.ready.then(function (registration) {\n      registration.unregister()\n    }).catch(function (error) { return handleError(emit, error); })\n  }\n}\n","/*!\n  * vue-router v4.0.6\n  * (c) 2021 Eduardo San Martin Morote\n  * @license MIT\n  */\nimport { getCurrentInstance, inject, onUnmounted, onDeactivated, onActivated, computed, unref, defineComponent, reactive, watchEffect, h, provide, ref, watch, shallowRef, nextTick } from 'vue';\n\nconst hasSymbol = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\r\nconst PolySymbol = (name) => \r\n// vr = vue router\r\nhasSymbol\r\n    ? Symbol((process.env.NODE_ENV !== 'production') ? '[vue-router]: ' + name : name)\r\n    : ((process.env.NODE_ENV !== 'production') ? '[vue-router]: ' : '_vr_') + name;\r\n// rvlm = Router View Location Matched\r\n/**\r\n * RouteRecord being rendered by the closest ancestor Router View. Used for\r\n * `onBeforeRouteUpdate` and `onBeforeRouteLeave`. rvlm stands for Router View\r\n * Location Matched\r\n *\r\n * @internal\r\n */\r\nconst matchedRouteKey = /*#__PURE__*/ PolySymbol((process.env.NODE_ENV !== 'production') ? 'router view location matched' : 'rvlm');\r\n/**\r\n * Allows overriding the router view depth to control which component in\r\n * `matched` is rendered. rvd stands for Router View Depth\r\n *\r\n * @internal\r\n */\r\nconst viewDepthKey = /*#__PURE__*/ PolySymbol((process.env.NODE_ENV !== 'production') ? 'router view depth' : 'rvd');\r\n/**\r\n * Allows overriding the router instance returned by `useRouter` in tests. r\r\n * stands for router\r\n *\r\n * @internal\r\n */\r\nconst routerKey = /*#__PURE__*/ PolySymbol((process.env.NODE_ENV !== 'production') ? 'router' : 'r');\r\n/**\r\n * Allows overriding the current route returned by `useRoute` in tests. rl\r\n * stands for route location\r\n *\r\n * @internal\r\n */\r\nconst routeLocationKey = /*#__PURE__*/ PolySymbol((process.env.NODE_ENV !== 'production') ? 'route location' : 'rl');\r\n/**\r\n * Allows overriding the current route used by router-view. Internally this is\r\n * used when the `route` prop is passed.\r\n *\r\n * @internal\r\n */\r\nconst routerViewLocationKey = /*#__PURE__*/ PolySymbol((process.env.NODE_ENV !== 'production') ? 'router view location' : 'rvl');\n\nconst isBrowser = typeof window !== 'undefined';\n\nfunction isESModule(obj) {\r\n    return obj.__esModule || (hasSymbol && obj[Symbol.toStringTag] === 'Module');\r\n}\r\nconst assign = Object.assign;\r\nfunction applyToParams(fn, params) {\r\n    const newParams = {};\r\n    for (const key in params) {\r\n        const value = params[key];\r\n        newParams[key] = Array.isArray(value) ? value.map(fn) : fn(value);\r\n    }\r\n    return newParams;\r\n}\r\nlet noop = () => { };\n\nfunction warn(msg) {\r\n    // avoid using ...args as it breaks in older Edge builds\r\n    const args = Array.from(arguments).slice(1);\r\n    console.warn.apply(console, ['[Vue Router warn]: ' + msg].concat(args));\r\n}\n\nconst TRAILING_SLASH_RE = /\\/$/;\r\nconst removeTrailingSlash = (path) => path.replace(TRAILING_SLASH_RE, '');\r\n/**\r\n * Transforms an URI into a normalized history location\r\n *\r\n * @param parseQuery\r\n * @param location - URI to normalize\r\n * @param currentLocation - current absolute location. Allows resolving relative\r\n * paths. Must start with `/`. Defaults to `/`\r\n * @returns a normalized history location\r\n */\r\nfunction parseURL(parseQuery, location, currentLocation = '/') {\r\n    let path, query = {}, searchString = '', hash = '';\r\n    // Could use URL and URLSearchParams but IE 11 doesn't support it\r\n    const searchPos = location.indexOf('?');\r\n    const hashPos = location.indexOf('#', searchPos > -1 ? searchPos : 0);\r\n    if (searchPos > -1) {\r\n        path = location.slice(0, searchPos);\r\n        searchString = location.slice(searchPos + 1, hashPos > -1 ? hashPos : location.length);\r\n        query = parseQuery(searchString);\r\n    }\r\n    if (hashPos > -1) {\r\n        path = path || location.slice(0, hashPos);\r\n        // keep the # character\r\n        hash = location.slice(hashPos, location.length);\r\n    }\r\n    // no search and no query\r\n    path = resolveRelativePath(path != null ? path : location, currentLocation);\r\n    // empty path means a relative query or hash `?foo=f`, `#thing`\r\n    return {\r\n        fullPath: path + (searchString && '?') + searchString + hash,\r\n        path,\r\n        query,\r\n        hash,\r\n    };\r\n}\r\n/**\r\n * Stringifies a URL object\r\n *\r\n * @param stringifyQuery\r\n * @param location\r\n */\r\nfunction stringifyURL(stringifyQuery, location) {\r\n    let query = location.query ? stringifyQuery(location.query) : '';\r\n    return location.path + (query && '?') + query + (location.hash || '');\r\n}\r\n/**\r\n * Strips off the base from the beginning of a location.pathname in a non\r\n * case-sensitive way.\r\n *\r\n * @param pathname - location.pathname\r\n * @param base - base to strip off\r\n */\r\nfunction stripBase(pathname, base) {\r\n    // no base or base is not found at the beginning\r\n    if (!base || pathname.toLowerCase().indexOf(base.toLowerCase()))\r\n        return pathname;\r\n    return pathname.slice(base.length) || '/';\r\n}\r\n/**\r\n * Checks if two RouteLocation are equal. This means that both locations are\r\n * pointing towards the same {@link RouteRecord} and that all `params`, `query`\r\n * parameters and `hash` are the same\r\n *\r\n * @param a - first {@link RouteLocation}\r\n * @param b - second {@link RouteLocation}\r\n */\r\nfunction isSameRouteLocation(stringifyQuery, a, b) {\r\n    let aLastIndex = a.matched.length - 1;\r\n    let bLastIndex = b.matched.length - 1;\r\n    return (aLastIndex > -1 &&\r\n        aLastIndex === bLastIndex &&\r\n        isSameRouteRecord(a.matched[aLastIndex], b.matched[bLastIndex]) &&\r\n        isSameRouteLocationParams(a.params, b.params) &&\r\n        stringifyQuery(a.query) === stringifyQuery(b.query) &&\r\n        a.hash === b.hash);\r\n}\r\n/**\r\n * Check if two `RouteRecords` are equal. Takes into account aliases: they are\r\n * considered equal to the `RouteRecord` they are aliasing.\r\n *\r\n * @param a - first {@link RouteRecord}\r\n * @param b - second {@link RouteRecord}\r\n */\r\nfunction isSameRouteRecord(a, b) {\r\n    // since the original record has an undefined value for aliasOf\r\n    // but all aliases point to the original record, this will always compare\r\n    // the original record\r\n    return (a.aliasOf || a) === (b.aliasOf || b);\r\n}\r\nfunction isSameRouteLocationParams(a, b) {\r\n    if (Object.keys(a).length !== Object.keys(b).length)\r\n        return false;\r\n    for (let key in a) {\r\n        if (!isSameRouteLocationParamsValue(a[key], b[key]))\r\n            return false;\r\n    }\r\n    return true;\r\n}\r\nfunction isSameRouteLocationParamsValue(a, b) {\r\n    return Array.isArray(a)\r\n        ? isEquivalentArray(a, b)\r\n        : Array.isArray(b)\r\n            ? isEquivalentArray(b, a)\r\n            : a === b;\r\n}\r\n/**\r\n * Check if two arrays are the same or if an array with one single entry is the\r\n * same as another primitive value. Used to check query and parameters\r\n *\r\n * @param a - array of values\r\n * @param b - array of values or a single value\r\n */\r\nfunction isEquivalentArray(a, b) {\r\n    return Array.isArray(b)\r\n        ? a.length === b.length && a.every((value, i) => value === b[i])\r\n        : a.length === 1 && a[0] === b;\r\n}\r\n/**\r\n * Resolves a relative path that starts with `.`.\r\n *\r\n * @param to - path location we are resolving\r\n * @param from - currentLocation.path, should start with `/`\r\n */\r\nfunction resolveRelativePath(to, from) {\r\n    if (to.startsWith('/'))\r\n        return to;\r\n    if ((process.env.NODE_ENV !== 'production') && !from.startsWith('/')) {\r\n        warn(`Cannot resolve a relative location without an absolute path. Trying to resolve \"${to}\" from \"${from}\". It should look like \"/${from}\".`);\r\n        return to;\r\n    }\r\n    if (!to)\r\n        return from;\r\n    const fromSegments = from.split('/');\r\n    const toSegments = to.split('/');\r\n    let position = fromSegments.length - 1;\r\n    let toPosition;\r\n    let segment;\r\n    for (toPosition = 0; toPosition < toSegments.length; toPosition++) {\r\n        segment = toSegments[toPosition];\r\n        // can't go below zero\r\n        if (position === 1 || segment === '.')\r\n            continue;\r\n        if (segment === '..')\r\n            position--;\r\n        // found something that is not relative path\r\n        else\r\n            break;\r\n    }\r\n    return (fromSegments.slice(0, position).join('/') +\r\n        '/' +\r\n        toSegments\r\n            .slice(toPosition - (toPosition === toSegments.length ? 1 : 0))\r\n            .join('/'));\r\n}\n\nvar NavigationType;\r\n(function (NavigationType) {\r\n    NavigationType[\"pop\"] = \"pop\";\r\n    NavigationType[\"push\"] = \"push\";\r\n})(NavigationType || (NavigationType = {}));\r\nvar NavigationDirection;\r\n(function (NavigationDirection) {\r\n    NavigationDirection[\"back\"] = \"back\";\r\n    NavigationDirection[\"forward\"] = \"forward\";\r\n    NavigationDirection[\"unknown\"] = \"\";\r\n})(NavigationDirection || (NavigationDirection = {}));\r\n/**\r\n * Starting location for Histories\r\n */\r\nconst START = '';\r\n// Generic utils\r\n/**\r\n * Normalizes a base by removing any trailing slash and reading the base tag if\r\n * present.\r\n *\r\n * @param base - base to normalize\r\n */\r\nfunction normalizeBase(base) {\r\n    if (!base) {\r\n        if (isBrowser) {\r\n            // respect <base> tag\r\n            const baseEl = document.querySelector('base');\r\n            base = (baseEl && baseEl.getAttribute('href')) || '/';\r\n            // strip full URL origin\r\n            base = base.replace(/^\\w+:\\/\\/[^\\/]+/, '');\r\n        }\r\n        else {\r\n            base = '/';\r\n        }\r\n    }\r\n    // ensure leading slash when it was removed by the regex above avoid leading\r\n    // slash with hash because the file could be read from the disk like file://\r\n    // and the leading slash would cause problems\r\n    if (base[0] !== '/' && base[0] !== '#')\r\n        base = '/' + base;\r\n    // remove the trailing slash so all other method can just do `base + fullPath`\r\n    // to build an href\r\n    return removeTrailingSlash(base);\r\n}\r\n// remove any character before the hash\r\nconst BEFORE_HASH_RE = /^[^#]+#/;\r\nfunction createHref(base, location) {\r\n    return base.replace(BEFORE_HASH_RE, '#') + location;\r\n}\n\nfunction getElementPosition(el, offset) {\r\n    const docRect = document.documentElement.getBoundingClientRect();\r\n    const elRect = el.getBoundingClientRect();\r\n    return {\r\n        behavior: offset.behavior,\r\n        left: elRect.left - docRect.left - (offset.left || 0),\r\n        top: elRect.top - docRect.top - (offset.top || 0),\r\n    };\r\n}\r\nconst computeScrollPosition = () => ({\r\n    left: window.pageXOffset,\r\n    top: window.pageYOffset,\r\n});\r\nfunction scrollToPosition(position) {\r\n    let scrollToOptions;\r\n    if ('el' in position) {\r\n        let positionEl = position.el;\r\n        const isIdSelector = typeof positionEl === 'string' && positionEl.startsWith('#');\r\n        /**\r\n         * `id`s can accept pretty much any characters, including CSS combinators\r\n         * like `>` or `~`. It's still possible to retrieve elements using\r\n         * `document.getElementById('~')` but it needs to be escaped when using\r\n         * `document.querySelector('#\\\\~')` for it to be valid. The only\r\n         * requirements for `id`s are them to be unique on the page and to not be\r\n         * empty (`id=\"\"`). Because of that, when passing an id selector, it should\r\n         * be properly escaped for it to work with `querySelector`. We could check\r\n         * for the id selector to be simple (no CSS combinators `+ >~`) but that\r\n         * would make things inconsistent since they are valid characters for an\r\n         * `id` but would need to be escaped when using `querySelector`, breaking\r\n         * their usage and ending up in no selector returned. Selectors need to be\r\n         * escaped:\r\n         *\r\n         * - `#1-thing` becomes `#\\31 -thing`\r\n         * - `#with~symbols` becomes `#with\\\\~symbols`\r\n         *\r\n         * - More information about  the topic can be found at\r\n         *   https://mathiasbynens.be/notes/html5-id-class.\r\n         * - Practical example: https://mathiasbynens.be/demo/html5-id\r\n         */\r\n        if ((process.env.NODE_ENV !== 'production') && typeof position.el === 'string') {\r\n            if (!isIdSelector || !document.getElementById(position.el.slice(1))) {\r\n                try {\r\n                    let foundEl = document.querySelector(position.el);\r\n                    if (isIdSelector && foundEl) {\r\n                        warn(`The selector \"${position.el}\" should be passed as \"el: document.querySelector('${position.el}')\" because it starts with \"#\".`);\r\n                        // return to avoid other warnings\r\n                        return;\r\n                    }\r\n                }\r\n                catch (err) {\r\n                    warn(`The selector \"${position.el}\" is invalid. If you are using an id selector, make sure to escape it. You can find more information about escaping characters in selectors at https://mathiasbynens.be/notes/css-escapes or use CSS.escape (https://developer.mozilla.org/en-US/docs/Web/API/CSS/escape).`);\r\n                    // return to avoid other warnings\r\n                    return;\r\n                }\r\n            }\r\n        }\r\n        const el = typeof positionEl === 'string'\r\n            ? isIdSelector\r\n                ? document.getElementById(positionEl.slice(1))\r\n                : document.querySelector(positionEl)\r\n            : positionEl;\r\n        if (!el) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Couldn't find element using selector \"${position.el}\" returned by scrollBehavior.`);\r\n            return;\r\n        }\r\n        scrollToOptions = getElementPosition(el, position);\r\n    }\r\n    else {\r\n        scrollToOptions = position;\r\n    }\r\n    if ('scrollBehavior' in document.documentElement.style)\r\n        window.scrollTo(scrollToOptions);\r\n    else {\r\n        window.scrollTo(scrollToOptions.left != null ? scrollToOptions.left : window.pageXOffset, scrollToOptions.top != null ? scrollToOptions.top : window.pageYOffset);\r\n    }\r\n}\r\nfunction getScrollKey(path, delta) {\r\n    const position = history.state ? history.state.position - delta : -1;\r\n    return position + path;\r\n}\r\nconst scrollPositions = new Map();\r\nfunction saveScrollPosition(key, scrollPosition) {\r\n    scrollPositions.set(key, scrollPosition);\r\n}\r\nfunction getSavedScrollPosition(key) {\r\n    const scroll = scrollPositions.get(key);\r\n    // consume it so it's not used again\r\n    scrollPositions.delete(key);\r\n    return scroll;\r\n}\r\n// TODO: RFC about how to save scroll position\r\n/**\r\n * ScrollBehavior instance used by the router to compute and restore the scroll\r\n * position when navigating.\r\n */\r\n// export interface ScrollHandler<ScrollPositionEntry extends HistoryStateValue, ScrollPosition extends ScrollPositionEntry> {\r\n//   // returns a scroll position that can be saved in history\r\n//   compute(): ScrollPositionEntry\r\n//   // can take an extended ScrollPositionEntry\r\n//   scroll(position: ScrollPosition): void\r\n// }\r\n// export const scrollHandler: ScrollHandler<ScrollPosition> = {\r\n//   compute: computeScroll,\r\n//   scroll: scrollToPosition,\r\n// }\n\nlet createBaseLocation = () => location.protocol + '//' + location.host;\r\n/**\r\n * Creates a normalized history location from a window.location object\r\n * @param location -\r\n */\r\nfunction createCurrentLocation(base, location) {\r\n    const { pathname, search, hash } = location;\r\n    // allows hash based url\r\n    const hashPos = base.indexOf('#');\r\n    if (hashPos > -1) {\r\n        // prepend the starting slash to hash so the url starts with /#\r\n        let pathFromHash = hash.slice(1);\r\n        if (pathFromHash[0] !== '/')\r\n            pathFromHash = '/' + pathFromHash;\r\n        return stripBase(pathFromHash, '');\r\n    }\r\n    const path = stripBase(pathname, base);\r\n    return path + search + hash;\r\n}\r\nfunction useHistoryListeners(base, historyState, currentLocation, replace) {\r\n    let listeners = [];\r\n    let teardowns = [];\r\n    // TODO: should it be a stack? a Dict. Check if the popstate listener\r\n    // can trigger twice\r\n    let pauseState = null;\r\n    const popStateHandler = ({ state, }) => {\r\n        const to = createCurrentLocation(base, location);\r\n        const from = currentLocation.value;\r\n        const fromState = historyState.value;\r\n        let delta = 0;\r\n        if (state) {\r\n            currentLocation.value = to;\r\n            historyState.value = state;\r\n            // ignore the popstate and reset the pauseState\r\n            if (pauseState && pauseState === from) {\r\n                pauseState = null;\r\n                return;\r\n            }\r\n            delta = fromState ? state.position - fromState.position : 0;\r\n        }\r\n        else {\r\n            replace(to);\r\n        }\r\n        // console.log({ deltaFromCurrent })\r\n        // Here we could also revert the navigation by calling history.go(-delta)\r\n        // this listener will have to be adapted to not trigger again and to wait for the url\r\n        // to be updated before triggering the listeners. Some kind of validation function would also\r\n        // need to be passed to the listeners so the navigation can be accepted\r\n        // call all listeners\r\n        listeners.forEach(listener => {\r\n            listener(currentLocation.value, from, {\r\n                delta,\r\n                type: NavigationType.pop,\r\n                direction: delta\r\n                    ? delta > 0\r\n                        ? NavigationDirection.forward\r\n                        : NavigationDirection.back\r\n                    : NavigationDirection.unknown,\r\n            });\r\n        });\r\n    };\r\n    function pauseListeners() {\r\n        pauseState = currentLocation.value;\r\n    }\r\n    function listen(callback) {\r\n        // setup the listener and prepare teardown callbacks\r\n        listeners.push(callback);\r\n        const teardown = () => {\r\n            const index = listeners.indexOf(callback);\r\n            if (index > -1)\r\n                listeners.splice(index, 1);\r\n        };\r\n        teardowns.push(teardown);\r\n        return teardown;\r\n    }\r\n    function beforeUnloadListener() {\r\n        const { history } = window;\r\n        if (!history.state)\r\n            return;\r\n        history.replaceState(assign({}, history.state, { scroll: computeScrollPosition() }), '');\r\n    }\r\n    function destroy() {\r\n        for (const teardown of teardowns)\r\n            teardown();\r\n        teardowns = [];\r\n        window.removeEventListener('popstate', popStateHandler);\r\n        window.removeEventListener('beforeunload', beforeUnloadListener);\r\n    }\r\n    // setup the listeners and prepare teardown callbacks\r\n    window.addEventListener('popstate', popStateHandler);\r\n    window.addEventListener('beforeunload', beforeUnloadListener);\r\n    return {\r\n        pauseListeners,\r\n        listen,\r\n        destroy,\r\n    };\r\n}\r\n/**\r\n * Creates a state object\r\n */\r\nfunction buildState(back, current, forward, replaced = false, computeScroll = false) {\r\n    return {\r\n        back,\r\n        current,\r\n        forward,\r\n        replaced,\r\n        position: window.history.length,\r\n        scroll: computeScroll ? computeScrollPosition() : null,\r\n    };\r\n}\r\nfunction useHistoryStateNavigation(base) {\r\n    const { history, location } = window;\r\n    // private variables\r\n    let currentLocation = {\r\n        value: createCurrentLocation(base, location),\r\n    };\r\n    let historyState = { value: history.state };\r\n    // build current history entry as this is a fresh navigation\r\n    if (!historyState.value) {\r\n        changeLocation(currentLocation.value, {\r\n            back: null,\r\n            current: currentLocation.value,\r\n            forward: null,\r\n            // the length is off by one, we need to decrease it\r\n            position: history.length - 1,\r\n            replaced: true,\r\n            // don't add a scroll as the user may have an anchor and we want\r\n            // scrollBehavior to be triggered without a saved position\r\n            scroll: null,\r\n        }, true);\r\n    }\r\n    function changeLocation(to, state, replace) {\r\n        /**\r\n         * if a base tag is provided and we are on a normal domain, we have to\r\n         * respect the provided `base` attribute because pushState() will use it and\r\n         * potentially erase anything before the `#` like at\r\n         * https://github.com/vuejs/vue-router-next/issues/685 where a base of\r\n         * `/folder/#` but a base of `/` would erase the `/folder/` section. If\r\n         * there is no host, the `<base>` tag makes no sense and if there isn't a\r\n         * base tag we can just use everything after the `#`.\r\n         */\r\n        const hashIndex = base.indexOf('#');\r\n        const url = hashIndex > -1\r\n            ? (location.host && document.querySelector('base')\r\n                ? base\r\n                : base.slice(hashIndex)) + to\r\n            : createBaseLocation() + base + to;\r\n        try {\r\n            // BROWSER QUIRK\r\n            // NOTE: Safari throws a SecurityError when calling this function 100 times in 30 seconds\r\n            history[replace ? 'replaceState' : 'pushState'](state, '', url);\r\n            historyState.value = state;\r\n        }\r\n        catch (err) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                warn('Error with push/replace State', err);\r\n            }\r\n            else {\r\n                console.error(err);\r\n            }\r\n            // Force the navigation, this also resets the call count\r\n            location[replace ? 'replace' : 'assign'](url);\r\n        }\r\n    }\r\n    function replace(to, data) {\r\n        const state = assign({}, history.state, buildState(historyState.value.back, \r\n        // keep back and forward entries but override current position\r\n        to, historyState.value.forward, true), data, { position: historyState.value.position });\r\n        changeLocation(to, state, true);\r\n        currentLocation.value = to;\r\n    }\r\n    function push(to, data) {\r\n        // Add to current entry the information of where we are going\r\n        // as well as saving the current position\r\n        const currentState = assign({}, \r\n        // use current history state to gracefully handle a wrong call to\r\n        // history.replaceState\r\n        // https://github.com/vuejs/vue-router-next/issues/366\r\n        historyState.value, history.state, {\r\n            forward: to,\r\n            scroll: computeScrollPosition(),\r\n        });\r\n        if ((process.env.NODE_ENV !== 'production') && !history.state) {\r\n            warn(`history.state seems to have been manually replaced without preserving the necessary values. Make sure to preserve existing history state if you are manually calling history.replaceState:\\n\\n` +\r\n                `history.replaceState(history.state, '', url)\\n\\n` +\r\n                `You can find more information at https://next.router.vuejs.org/guide/migration/#usage-of-history-state.`);\r\n        }\r\n        changeLocation(currentState.current, currentState, true);\r\n        const state = assign({}, buildState(currentLocation.value, to, null), { position: currentState.position + 1 }, data);\r\n        changeLocation(to, state, false);\r\n        currentLocation.value = to;\r\n    }\r\n    return {\r\n        location: currentLocation,\r\n        state: historyState,\r\n        push,\r\n        replace,\r\n    };\r\n}\r\n/**\r\n * Creates an HTML5 history. Most common history for single page applications.\r\n *\r\n * @param base -\r\n */\r\nfunction createWebHistory(base) {\r\n    base = normalizeBase(base);\r\n    const historyNavigation = useHistoryStateNavigation(base);\r\n    const historyListeners = useHistoryListeners(base, historyNavigation.state, historyNavigation.location, historyNavigation.replace);\r\n    function go(delta, triggerListeners = true) {\r\n        if (!triggerListeners)\r\n            historyListeners.pauseListeners();\r\n        history.go(delta);\r\n    }\r\n    const routerHistory = assign({\r\n        // it's overridden right after\r\n        location: '',\r\n        base,\r\n        go,\r\n        createHref: createHref.bind(null, base),\r\n    }, historyNavigation, historyListeners);\r\n    Object.defineProperty(routerHistory, 'location', {\r\n        get: () => historyNavigation.location.value,\r\n    });\r\n    Object.defineProperty(routerHistory, 'state', {\r\n        get: () => historyNavigation.state.value,\r\n    });\r\n    return routerHistory;\r\n}\n\n/**\r\n * Creates a in-memory based history. The main purpose of this history is to handle SSR. It starts in a special location that is nowhere.\r\n * It's up to the user to replace that location with the starter location by either calling `router.push` or `router.replace`.\r\n *\r\n * @param base - Base applied to all urls, defaults to '/'\r\n * @returns a history object that can be passed to the router constructor\r\n */\r\nfunction createMemoryHistory(base = '') {\r\n    let listeners = [];\r\n    let queue = [START];\r\n    let position = 0;\r\n    function setLocation(location) {\r\n        position++;\r\n        if (position === queue.length) {\r\n            // we are at the end, we can simply append a new entry\r\n            queue.push(location);\r\n        }\r\n        else {\r\n            // we are in the middle, we remove everything from here in the queue\r\n            queue.splice(position);\r\n            queue.push(location);\r\n        }\r\n    }\r\n    function triggerListeners(to, from, { direction, delta }) {\r\n        const info = {\r\n            direction,\r\n            delta,\r\n            type: NavigationType.pop,\r\n        };\r\n        for (let callback of listeners) {\r\n            callback(to, from, info);\r\n        }\r\n    }\r\n    const routerHistory = {\r\n        // rewritten by Object.defineProperty\r\n        location: START,\r\n        state: {},\r\n        base,\r\n        createHref: createHref.bind(null, base),\r\n        replace(to) {\r\n            // remove current entry and decrement position\r\n            queue.splice(position--, 1);\r\n            setLocation(to);\r\n        },\r\n        push(to, data) {\r\n            setLocation(to);\r\n        },\r\n        listen(callback) {\r\n            listeners.push(callback);\r\n            return () => {\r\n                const index = listeners.indexOf(callback);\r\n                if (index > -1)\r\n                    listeners.splice(index, 1);\r\n            };\r\n        },\r\n        destroy() {\r\n            listeners = [];\r\n        },\r\n        go(delta, shouldTrigger = true) {\r\n            const from = this.location;\r\n            const direction = \r\n            // we are considering delta === 0 going forward, but in abstract mode\r\n            // using 0 for the delta doesn't make sense like it does in html5 where\r\n            // it reloads the page\r\n            delta < 0 ? NavigationDirection.back : NavigationDirection.forward;\r\n            position = Math.max(0, Math.min(position + delta, queue.length - 1));\r\n            if (shouldTrigger) {\r\n                triggerListeners(this.location, from, {\r\n                    direction,\r\n                    delta,\r\n                });\r\n            }\r\n        },\r\n    };\r\n    Object.defineProperty(routerHistory, 'location', {\r\n        get: () => queue[position],\r\n    });\r\n    return routerHistory;\r\n}\n\n/**\r\n * Creates a hash history. Useful for web applications with no host (e.g.\r\n * `file://`) or when configuring a server to handle any URL is not possible.\r\n *\r\n * @param base - optional base to provide. Defaults to `location.pathname +\r\n * location.search` If there is a `<base>` tag in the `head`, its value will be\r\n * ignored in favor of this parameter **but note it affects all the\r\n * history.pushState() calls**, meaning that if you use a `<base>` tag, it's\r\n * `href` value **has to match this parameter** (ignoring anything after the\r\n * `#`).\r\n *\r\n * @example\r\n * ```js\r\n * // at https://example.com/folder\r\n * createWebHashHistory() // gives a url of `https://example.com/folder#`\r\n * createWebHashHistory('/folder/') // gives a url of `https://example.com/folder/#`\r\n * // if the `#` is provided in the base, it won't be added by `createWebHashHistory`\r\n * createWebHashHistory('/folder/#/app/') // gives a url of `https://example.com/folder/#/app/`\r\n * // you should avoid doing this because it changes the original url and breaks copying urls\r\n * createWebHashHistory('/other-folder/') // gives a url of `https://example.com/other-folder/#`\r\n *\r\n * // at file:///usr/etc/folder/index.html\r\n * // for locations with no `host`, the base is ignored\r\n * createWebHashHistory('/iAmIgnored') // gives a url of `file:///usr/etc/folder/index.html#`\r\n * ```\r\n */\r\nfunction createWebHashHistory(base) {\r\n    // Make sure this implementation is fine in terms of encoding, specially for IE11\r\n    // for `file://`, directly use the pathname and ignore the base\r\n    // location.pathname contains an initial `/` even at the root: `https://example.com`\r\n    base = location.host ? base || location.pathname + location.search : '';\r\n    // allow the user to provide a `#` in the middle: `/base/#/app`\r\n    if (base.indexOf('#') < 0)\r\n        base += '#';\r\n    if ((process.env.NODE_ENV !== 'production') && !base.endsWith('#/') && !base.endsWith('#')) {\r\n        warn(`A hash base must end with a \"#\":\\n\"${base}\" should be \"${base.replace(/#.*$/, '#')}\".`);\r\n    }\r\n    return createWebHistory(base);\r\n}\n\nfunction isRouteLocation(route) {\r\n    return typeof route === 'string' || (route && typeof route === 'object');\r\n}\r\nfunction isRouteName(name) {\r\n    return typeof name === 'string' || typeof name === 'symbol';\r\n}\n\n/**\r\n * Initial route location where the router is. Can be used in navigation guards\r\n * to differentiate the initial navigation.\r\n *\r\n * @example\r\n * ```js\r\n * import { START_LOCATION } from 'vue-router'\r\n *\r\n * router.beforeEach((to, from) => {\r\n *   if (from === START_LOCATION) {\r\n *     // initial navigation\r\n *   }\r\n * })\r\n * ```\r\n */\r\nconst START_LOCATION_NORMALIZED = {\r\n    path: '/',\r\n    name: undefined,\r\n    params: {},\r\n    query: {},\r\n    hash: '',\r\n    fullPath: '/',\r\n    matched: [],\r\n    meta: {},\r\n    redirectedFrom: undefined,\r\n};\n\nconst NavigationFailureSymbol = /*#__PURE__*/ PolySymbol((process.env.NODE_ENV !== 'production') ? 'navigation failure' : 'nf');\r\n/**\r\n * Enumeration with all possible types for navigation failures. Can be passed to\r\n * {@link isNavigationFailure} to check for specific failures.\r\n */\r\nvar NavigationFailureType;\r\n(function (NavigationFailureType) {\r\n    /**\r\n     * An aborted navigation is a navigation that failed because a navigation\r\n     * guard returned `false` or called `next(false)`\r\n     */\r\n    NavigationFailureType[NavigationFailureType[\"aborted\"] = 4] = \"aborted\";\r\n    /**\r\n     * A cancelled navigation is a navigation that failed because a more recent\r\n     * navigation finished started (not necessarily finished).\r\n     */\r\n    NavigationFailureType[NavigationFailureType[\"cancelled\"] = 8] = \"cancelled\";\r\n    /**\r\n     * A duplicated navigation is a navigation that failed because it was\r\n     * initiated while already being at the exact same location.\r\n     */\r\n    NavigationFailureType[NavigationFailureType[\"duplicated\"] = 16] = \"duplicated\";\r\n})(NavigationFailureType || (NavigationFailureType = {}));\r\n// DEV only debug messages\r\nconst ErrorTypeMessages = {\r\n    [1 /* MATCHER_NOT_FOUND */]({ location, currentLocation }) {\r\n        return `No match for\\n ${JSON.stringify(location)}${currentLocation\r\n            ? '\\nwhile being at\\n' + JSON.stringify(currentLocation)\r\n            : ''}`;\r\n    },\r\n    [2 /* NAVIGATION_GUARD_REDIRECT */]({ from, to, }) {\r\n        return `Redirected from \"${from.fullPath}\" to \"${stringifyRoute(to)}\" via a navigation guard.`;\r\n    },\r\n    [4 /* NAVIGATION_ABORTED */]({ from, to }) {\r\n        return `Navigation aborted from \"${from.fullPath}\" to \"${to.fullPath}\" via a navigation guard.`;\r\n    },\r\n    [8 /* NAVIGATION_CANCELLED */]({ from, to }) {\r\n        return `Navigation cancelled from \"${from.fullPath}\" to \"${to.fullPath}\" with a new navigation.`;\r\n    },\r\n    [16 /* NAVIGATION_DUPLICATED */]({ from, to }) {\r\n        return `Avoided redundant navigation to current location: \"${from.fullPath}\".`;\r\n    },\r\n};\r\nfunction createRouterError(type, params) {\r\n    if ((process.env.NODE_ENV !== 'production') || !true) {\r\n        return assign(new Error(ErrorTypeMessages[type](params)), {\r\n            type,\r\n            [NavigationFailureSymbol]: true,\r\n        }, params);\r\n    }\r\n    else {\r\n        return assign(new Error(), {\r\n            type,\r\n            [NavigationFailureSymbol]: true,\r\n        }, params);\r\n    }\r\n}\r\nfunction isNavigationFailure(error, type) {\r\n    return (error instanceof Error &&\r\n        NavigationFailureSymbol in error &&\r\n        (type == null || !!(error.type & type)));\r\n}\r\nconst propertiesToLog = ['params', 'query', 'hash'];\r\nfunction stringifyRoute(to) {\r\n    if (typeof to === 'string')\r\n        return to;\r\n    if ('path' in to)\r\n        return to.path;\r\n    const location = {};\r\n    for (const key of propertiesToLog) {\r\n        if (key in to)\r\n            location[key] = to[key];\r\n    }\r\n    return JSON.stringify(location, null, 2);\r\n}\n\n// default pattern for a param: non greedy everything but /\r\nconst BASE_PARAM_PATTERN = '[^/]+?';\r\nconst BASE_PATH_PARSER_OPTIONS = {\r\n    sensitive: false,\r\n    strict: false,\r\n    start: true,\r\n    end: true,\r\n};\r\n// Special Regex characters that must be escaped in static tokens\r\nconst REGEX_CHARS_RE = /[.+*?^${}()[\\]/\\\\]/g;\r\n/**\r\n * Creates a path parser from an array of Segments (a segment is an array of Tokens)\r\n *\r\n * @param segments - array of segments returned by tokenizePath\r\n * @param extraOptions - optional options for the regexp\r\n * @returns a PathParser\r\n */\r\nfunction tokensToParser(segments, extraOptions) {\r\n    const options = assign({}, BASE_PATH_PARSER_OPTIONS, extraOptions);\r\n    // the amount of scores is the same as the length of segments except for the root segment \"/\"\r\n    let score = [];\r\n    // the regexp as a string\r\n    let pattern = options.start ? '^' : '';\r\n    // extracted keys\r\n    const keys = [];\r\n    for (const segment of segments) {\r\n        // the root segment needs special treatment\r\n        const segmentScores = segment.length ? [] : [90 /* Root */];\r\n        // allow trailing slash\r\n        if (options.strict && !segment.length)\r\n            pattern += '/';\r\n        for (let tokenIndex = 0; tokenIndex < segment.length; tokenIndex++) {\r\n            const token = segment[tokenIndex];\r\n            // resets the score if we are inside a sub segment /:a-other-:b\r\n            let subSegmentScore = 40 /* Segment */ +\r\n                (options.sensitive ? 0.25 /* BonusCaseSensitive */ : 0);\r\n            if (token.type === 0 /* Static */) {\r\n                // prepend the slash if we are starting a new segment\r\n                if (!tokenIndex)\r\n                    pattern += '/';\r\n                pattern += token.value.replace(REGEX_CHARS_RE, '\\\\$&');\r\n                subSegmentScore += 40 /* Static */;\r\n            }\r\n            else if (token.type === 1 /* Param */) {\r\n                const { value, repeatable, optional, regexp } = token;\r\n                keys.push({\r\n                    name: value,\r\n                    repeatable,\r\n                    optional,\r\n                });\r\n                const re = regexp ? regexp : BASE_PARAM_PATTERN;\r\n                // the user provided a custom regexp /:id(\\\\d+)\r\n                if (re !== BASE_PARAM_PATTERN) {\r\n                    subSegmentScore += 10 /* BonusCustomRegExp */;\r\n                    // make sure the regexp is valid before using it\r\n                    try {\r\n                        new RegExp(`(${re})`);\r\n                    }\r\n                    catch (err) {\r\n                        throw new Error(`Invalid custom RegExp for param \"${value}\" (${re}): ` +\r\n                            err.message);\r\n                    }\r\n                }\r\n                // when we repeat we must take care of the repeating leading slash\r\n                let subPattern = repeatable ? `((?:${re})(?:/(?:${re}))*)` : `(${re})`;\r\n                // prepend the slash if we are starting a new segment\r\n                if (!tokenIndex)\r\n                    subPattern =\r\n                        // avoid an optional / if there are more segments e.g. /:p?-static\r\n                        // or /:p?-:p2\r\n                        optional && segment.length < 2\r\n                            ? `(?:/${subPattern})`\r\n                            : '/' + subPattern;\r\n                if (optional)\r\n                    subPattern += '?';\r\n                pattern += subPattern;\r\n                subSegmentScore += 20 /* Dynamic */;\r\n                if (optional)\r\n                    subSegmentScore += -8 /* BonusOptional */;\r\n                if (repeatable)\r\n                    subSegmentScore += -20 /* BonusRepeatable */;\r\n                if (re === '.*')\r\n                    subSegmentScore += -50 /* BonusWildcard */;\r\n            }\r\n            segmentScores.push(subSegmentScore);\r\n        }\r\n        // an empty array like /home/ -> [[{home}], []]\r\n        // if (!segment.length) pattern += '/'\r\n        score.push(segmentScores);\r\n    }\r\n    // only apply the strict bonus to the last score\r\n    if (options.strict && options.end) {\r\n        const i = score.length - 1;\r\n        score[i][score[i].length - 1] += 0.7000000000000001 /* BonusStrict */;\r\n    }\r\n    // TODO: dev only warn double trailing slash\r\n    if (!options.strict)\r\n        pattern += '/?';\r\n    if (options.end)\r\n        pattern += '$';\r\n    // allow paths like /dynamic to only match dynamic or dynamic/... but not dynamic_something_else\r\n    else if (options.strict)\r\n        pattern += '(?:/|$)';\r\n    const re = new RegExp(pattern, options.sensitive ? '' : 'i');\r\n    function parse(path) {\r\n        const match = path.match(re);\r\n        const params = {};\r\n        if (!match)\r\n            return null;\r\n        for (let i = 1; i < match.length; i++) {\r\n            const value = match[i] || '';\r\n            const key = keys[i - 1];\r\n            params[key.name] = value && key.repeatable ? value.split('/') : value;\r\n        }\r\n        return params;\r\n    }\r\n    function stringify(params) {\r\n        let path = '';\r\n        // for optional parameters to allow to be empty\r\n        let avoidDuplicatedSlash = false;\r\n        for (const segment of segments) {\r\n            if (!avoidDuplicatedSlash || !path.endsWith('/'))\r\n                path += '/';\r\n            avoidDuplicatedSlash = false;\r\n            for (const token of segment) {\r\n                if (token.type === 0 /* Static */) {\r\n                    path += token.value;\r\n                }\r\n                else if (token.type === 1 /* Param */) {\r\n                    const { value, repeatable, optional } = token;\r\n                    const param = value in params ? params[value] : '';\r\n                    if (Array.isArray(param) && !repeatable)\r\n                        throw new Error(`Provided param \"${value}\" is an array but it is not repeatable (* or + modifiers)`);\r\n                    const text = Array.isArray(param) ? param.join('/') : param;\r\n                    if (!text) {\r\n                        if (optional) {\r\n                            // if we have more than one optional param like /:a?-static we\r\n                            // don't need to care about the optional param\r\n                            if (segment.length < 2) {\r\n                                // remove the last slash as we could be at the end\r\n                                if (path.endsWith('/'))\r\n                                    path = path.slice(0, -1);\r\n                                // do not append a slash on the next iteration\r\n                                else\r\n                                    avoidDuplicatedSlash = true;\r\n                            }\r\n                        }\r\n                        else\r\n                            throw new Error(`Missing required param \"${value}\"`);\r\n                    }\r\n                    path += text;\r\n                }\r\n            }\r\n        }\r\n        return path;\r\n    }\r\n    return {\r\n        re,\r\n        score,\r\n        keys,\r\n        parse,\r\n        stringify,\r\n    };\r\n}\r\n/**\r\n * Compares an array of numbers as used in PathParser.score and returns a\r\n * number. This function can be used to `sort` an array\r\n * @param a - first array of numbers\r\n * @param b - second array of numbers\r\n * @returns 0 if both are equal, < 0 if a should be sorted first, > 0 if b\r\n * should be sorted first\r\n */\r\nfunction compareScoreArray(a, b) {\r\n    let i = 0;\r\n    while (i < a.length && i < b.length) {\r\n        const diff = b[i] - a[i];\r\n        // only keep going if diff === 0\r\n        if (diff)\r\n            return diff;\r\n        i++;\r\n    }\r\n    // if the last subsegment was Static, the shorter segments should be sorted first\r\n    // otherwise sort the longest segment first\r\n    if (a.length < b.length) {\r\n        return a.length === 1 && a[0] === 40 /* Static */ + 40 /* Segment */\r\n            ? -1\r\n            : 1;\r\n    }\r\n    else if (a.length > b.length) {\r\n        return b.length === 1 && b[0] === 40 /* Static */ + 40 /* Segment */\r\n            ? 1\r\n            : -1;\r\n    }\r\n    return 0;\r\n}\r\n/**\r\n * Compare function that can be used with `sort` to sort an array of PathParser\r\n * @param a - first PathParser\r\n * @param b - second PathParser\r\n * @returns 0 if both are equal, < 0 if a should be sorted first, > 0 if b\r\n */\r\nfunction comparePathParserScore(a, b) {\r\n    let i = 0;\r\n    const aScore = a.score;\r\n    const bScore = b.score;\r\n    while (i < aScore.length && i < bScore.length) {\r\n        const comp = compareScoreArray(aScore[i], bScore[i]);\r\n        // do not return if both are equal\r\n        if (comp)\r\n            return comp;\r\n        i++;\r\n    }\r\n    // if a and b share the same score entries but b has more, sort b first\r\n    return bScore.length - aScore.length;\r\n    // this is the ternary version\r\n    // return aScore.length < bScore.length\r\n    //   ? 1\r\n    //   : aScore.length > bScore.length\r\n    //   ? -1\r\n    //   : 0\r\n}\n\nconst ROOT_TOKEN = {\r\n    type: 0 /* Static */,\r\n    value: '',\r\n};\r\nconst VALID_PARAM_RE = /[a-zA-Z0-9_]/;\r\n// After some profiling, the cache seems to be unnecessary because tokenizePath\r\n// (the slowest part of adding a route) is very fast\r\n// const tokenCache = new Map<string, Token[][]>()\r\nfunction tokenizePath(path) {\r\n    if (!path)\r\n        return [[]];\r\n    if (path === '/')\r\n        return [[ROOT_TOKEN]];\r\n    if (!path.startsWith('/')) {\r\n        throw new Error((process.env.NODE_ENV !== 'production')\r\n            ? `Route paths should start with a \"/\": \"${path}\" should be \"/${path}\".`\r\n            : `Invalid path \"${path}\"`);\r\n    }\r\n    // if (tokenCache.has(path)) return tokenCache.get(path)!\r\n    function crash(message) {\r\n        throw new Error(`ERR (${state})/\"${buffer}\": ${message}`);\r\n    }\r\n    let state = 0 /* Static */;\r\n    let previousState = state;\r\n    const tokens = [];\r\n    // the segment will always be valid because we get into the initial state\r\n    // with the leading /\r\n    let segment;\r\n    function finalizeSegment() {\r\n        if (segment)\r\n            tokens.push(segment);\r\n        segment = [];\r\n    }\r\n    // index on the path\r\n    let i = 0;\r\n    // char at index\r\n    let char;\r\n    // buffer of the value read\r\n    let buffer = '';\r\n    // custom regexp for a param\r\n    let customRe = '';\r\n    function consumeBuffer() {\r\n        if (!buffer)\r\n            return;\r\n        if (state === 0 /* Static */) {\r\n            segment.push({\r\n                type: 0 /* Static */,\r\n                value: buffer,\r\n            });\r\n        }\r\n        else if (state === 1 /* Param */ ||\r\n            state === 2 /* ParamRegExp */ ||\r\n            state === 3 /* ParamRegExpEnd */) {\r\n            if (segment.length > 1 && (char === '*' || char === '+'))\r\n                crash(`A repeatable param (${buffer}) must be alone in its segment. eg: '/:ids+.`);\r\n            segment.push({\r\n                type: 1 /* Param */,\r\n                value: buffer,\r\n                regexp: customRe,\r\n                repeatable: char === '*' || char === '+',\r\n                optional: char === '*' || char === '?',\r\n            });\r\n        }\r\n        else {\r\n            crash('Invalid state to consume buffer');\r\n        }\r\n        buffer = '';\r\n    }\r\n    function addCharToBuffer() {\r\n        buffer += char;\r\n    }\r\n    while (i < path.length) {\r\n        char = path[i++];\r\n        if (char === '\\\\' && state !== 2 /* ParamRegExp */) {\r\n            previousState = state;\r\n            state = 4 /* EscapeNext */;\r\n            continue;\r\n        }\r\n        switch (state) {\r\n            case 0 /* Static */:\r\n                if (char === '/') {\r\n                    if (buffer) {\r\n                        consumeBuffer();\r\n                    }\r\n                    finalizeSegment();\r\n                }\r\n                else if (char === ':') {\r\n                    consumeBuffer();\r\n                    state = 1 /* Param */;\r\n                }\r\n                else {\r\n                    addCharToBuffer();\r\n                }\r\n                break;\r\n            case 4 /* EscapeNext */:\r\n                addCharToBuffer();\r\n                state = previousState;\r\n                break;\r\n            case 1 /* Param */:\r\n                if (char === '(') {\r\n                    state = 2 /* ParamRegExp */;\r\n                }\r\n                else if (VALID_PARAM_RE.test(char)) {\r\n                    addCharToBuffer();\r\n                }\r\n                else {\r\n                    consumeBuffer();\r\n                    state = 0 /* Static */;\r\n                    // go back one character if we were not modifying\r\n                    if (char !== '*' && char !== '?' && char !== '+')\r\n                        i--;\r\n                }\r\n                break;\r\n            case 2 /* ParamRegExp */:\r\n                // TODO: is it worth handling nested regexp? like :p(?:prefix_([^/]+)_suffix)\r\n                // it already works by escaping the closing )\r\n                // https://paths.esm.dev/?p=AAMeJbiAwQEcDKbAoAAkP60PG2R6QAvgNaA6AFACM2ABuQBB#\r\n                // is this really something people need since you can also write\r\n                // /prefix_:p()_suffix\r\n                if (char === ')') {\r\n                    // handle the escaped )\r\n                    if (customRe[customRe.length - 1] == '\\\\')\r\n                        customRe = customRe.slice(0, -1) + char;\r\n                    else\r\n                        state = 3 /* ParamRegExpEnd */;\r\n                }\r\n                else {\r\n                    customRe += char;\r\n                }\r\n                break;\r\n            case 3 /* ParamRegExpEnd */:\r\n                // same as finalizing a param\r\n                consumeBuffer();\r\n                state = 0 /* Static */;\r\n                // go back one character if we were not modifying\r\n                if (char !== '*' && char !== '?' && char !== '+')\r\n                    i--;\r\n                customRe = '';\r\n                break;\r\n            default:\r\n                crash('Unknown state');\r\n                break;\r\n        }\r\n    }\r\n    if (state === 2 /* ParamRegExp */)\r\n        crash(`Unfinished custom RegExp for param \"${buffer}\"`);\r\n    consumeBuffer();\r\n    finalizeSegment();\r\n    // tokenCache.set(path, tokens)\r\n    return tokens;\r\n}\n\nfunction createRouteRecordMatcher(record, parent, options) {\r\n    const parser = tokensToParser(tokenizePath(record.path), options);\r\n    // warn against params with the same name\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const existingKeys = new Set();\r\n        for (const key of parser.keys) {\r\n            if (existingKeys.has(key.name))\r\n                warn(`Found duplicated params with name \"${key.name}\" for path \"${record.path}\". Only the last one will be available on \"$route.params\".`);\r\n            existingKeys.add(key.name);\r\n        }\r\n    }\r\n    const matcher = assign(parser, {\r\n        record,\r\n        parent,\r\n        // these needs to be populated by the parent\r\n        children: [],\r\n        alias: [],\r\n    });\r\n    if (parent) {\r\n        // both are aliases or both are not aliases\r\n        // we don't want to mix them because the order is used when\r\n        // passing originalRecord in Matcher.addRoute\r\n        if (!matcher.record.aliasOf === !parent.record.aliasOf)\r\n            parent.children.push(matcher);\r\n    }\r\n    return matcher;\r\n}\n\n/**\r\n * Creates a Router Matcher.\r\n *\r\n * @internal\r\n * @param routes - array of initial routes\r\n * @param globalOptions - global route options\r\n */\r\nfunction createRouterMatcher(routes, globalOptions) {\r\n    // normalized ordered array of matchers\r\n    const matchers = [];\r\n    const matcherMap = new Map();\r\n    globalOptions = mergeOptions({ strict: false, end: true, sensitive: false }, globalOptions);\r\n    function getRecordMatcher(name) {\r\n        return matcherMap.get(name);\r\n    }\r\n    function addRoute(record, parent, originalRecord) {\r\n        // used later on to remove by name\r\n        let isRootAdd = !originalRecord;\r\n        let mainNormalizedRecord = normalizeRouteRecord(record);\r\n        // we might be the child of an alias\r\n        mainNormalizedRecord.aliasOf = originalRecord && originalRecord.record;\r\n        const options = mergeOptions(globalOptions, record);\r\n        // generate an array of records to correctly handle aliases\r\n        const normalizedRecords = [\r\n            mainNormalizedRecord,\r\n        ];\r\n        if ('alias' in record) {\r\n            const aliases = typeof record.alias === 'string' ? [record.alias] : record.alias;\r\n            for (const alias of aliases) {\r\n                normalizedRecords.push(assign({}, mainNormalizedRecord, {\r\n                    // this allows us to hold a copy of the `components` option\r\n                    // so that async components cache is hold on the original record\r\n                    components: originalRecord\r\n                        ? originalRecord.record.components\r\n                        : mainNormalizedRecord.components,\r\n                    path: alias,\r\n                    // we might be the child of an alias\r\n                    aliasOf: originalRecord\r\n                        ? originalRecord.record\r\n                        : mainNormalizedRecord,\r\n                    // the aliases are always of the same kind as the original since they\r\n                    // are defined on the same record\r\n                }));\r\n            }\r\n        }\r\n        let matcher;\r\n        let originalMatcher;\r\n        for (const normalizedRecord of normalizedRecords) {\r\n            let { path } = normalizedRecord;\r\n            // Build up the path for nested routes if the child isn't an absolute\r\n            // route. Only add the / delimiter if the child path isn't empty and if the\r\n            // parent path doesn't have a trailing slash\r\n            if (parent && path[0] !== '/') {\r\n                let parentPath = parent.record.path;\r\n                let connectingSlash = parentPath[parentPath.length - 1] === '/' ? '' : '/';\r\n                normalizedRecord.path =\r\n                    parent.record.path + (path && connectingSlash + path);\r\n            }\r\n            if ((process.env.NODE_ENV !== 'production') && normalizedRecord.path === '*') {\r\n                throw new Error('Catch all routes (\"*\") must now be defined using a param with a custom regexp.\\n' +\r\n                    'See more at https://next.router.vuejs.org/guide/migration/#removed-star-or-catch-all-routes.');\r\n            }\r\n            // create the object before hand so it can be passed to children\r\n            matcher = createRouteRecordMatcher(normalizedRecord, parent, options);\r\n            if ((process.env.NODE_ENV !== 'production') && parent && path[0] === '/')\r\n                checkMissingParamsInAbsolutePath(matcher, parent);\r\n            // if we are an alias we must tell the original record that we exist\r\n            // so we can be removed\r\n            if (originalRecord) {\r\n                originalRecord.alias.push(matcher);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    checkSameParams(originalRecord, matcher);\r\n                }\r\n            }\r\n            else {\r\n                // otherwise, the first record is the original and others are aliases\r\n                originalMatcher = originalMatcher || matcher;\r\n                if (originalMatcher !== matcher)\r\n                    originalMatcher.alias.push(matcher);\r\n                // remove the route if named and only for the top record (avoid in nested calls)\r\n                // this works because the original record is the first one\r\n                if (isRootAdd && record.name && !isAliasRecord(matcher))\r\n                    removeRoute(record.name);\r\n            }\r\n            if ('children' in mainNormalizedRecord) {\r\n                let children = mainNormalizedRecord.children;\r\n                for (let i = 0; i < children.length; i++) {\r\n                    addRoute(children[i], matcher, originalRecord && originalRecord.children[i]);\r\n                }\r\n            }\r\n            // if there was no original record, then the first one was not an alias and all\r\n            // other alias (if any) need to reference this record when adding children\r\n            originalRecord = originalRecord || matcher;\r\n            // TODO: add normalized records for more flexibility\r\n            // if (parent && isAliasRecord(originalRecord)) {\r\n            //   parent.children.push(originalRecord)\r\n            // }\r\n            insertMatcher(matcher);\r\n        }\r\n        return originalMatcher\r\n            ? () => {\r\n                // since other matchers are aliases, they should be removed by the original matcher\r\n                removeRoute(originalMatcher);\r\n            }\r\n            : noop;\r\n    }\r\n    function removeRoute(matcherRef) {\r\n        if (isRouteName(matcherRef)) {\r\n            const matcher = matcherMap.get(matcherRef);\r\n            if (matcher) {\r\n                matcherMap.delete(matcherRef);\r\n                matchers.splice(matchers.indexOf(matcher), 1);\r\n                matcher.children.forEach(removeRoute);\r\n                matcher.alias.forEach(removeRoute);\r\n            }\r\n        }\r\n        else {\r\n            let index = matchers.indexOf(matcherRef);\r\n            if (index > -1) {\r\n                matchers.splice(index, 1);\r\n                if (matcherRef.record.name)\r\n                    matcherMap.delete(matcherRef.record.name);\r\n                matcherRef.children.forEach(removeRoute);\r\n                matcherRef.alias.forEach(removeRoute);\r\n            }\r\n        }\r\n    }\r\n    function getRoutes() {\r\n        return matchers;\r\n    }\r\n    function insertMatcher(matcher) {\r\n        let i = 0;\r\n        // console.log('i is', { i })\r\n        while (i < matchers.length &&\r\n            comparePathParserScore(matcher, matchers[i]) >= 0)\r\n            i++;\r\n        // console.log('END i is', { i })\r\n        // while (i < matchers.length && matcher.score <= matchers[i].score) i++\r\n        matchers.splice(i, 0, matcher);\r\n        // only add the original record to the name map\r\n        if (matcher.record.name && !isAliasRecord(matcher))\r\n            matcherMap.set(matcher.record.name, matcher);\r\n    }\r\n    function resolve(location, currentLocation) {\r\n        let matcher;\r\n        let params = {};\r\n        let path;\r\n        let name;\r\n        if ('name' in location && location.name) {\r\n            matcher = matcherMap.get(location.name);\r\n            if (!matcher)\r\n                throw createRouterError(1 /* MATCHER_NOT_FOUND */, {\r\n                    location,\r\n                });\r\n            name = matcher.record.name;\r\n            params = assign(\r\n            // paramsFromLocation is a new object\r\n            paramsFromLocation(currentLocation.params, \r\n            // only keep params that exist in the resolved location\r\n            // TODO: only keep optional params coming from a parent record\r\n            matcher.keys.filter(k => !k.optional).map(k => k.name)), location.params);\r\n            // throws if cannot be stringified\r\n            path = matcher.stringify(params);\r\n        }\r\n        else if ('path' in location) {\r\n            // no need to resolve the path with the matcher as it was provided\r\n            // this also allows the user to control the encoding\r\n            path = location.path;\r\n            if ((process.env.NODE_ENV !== 'production') && !path.startsWith('/')) {\r\n                warn(`The Matcher cannot resolve relative paths but received \"${path}\". Unless you directly called \\`matcher.resolve(\"${path}\")\\`, this is probably a bug in vue-router. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-router-next.`);\r\n            }\r\n            matcher = matchers.find(m => m.re.test(path));\r\n            // matcher should have a value after the loop\r\n            if (matcher) {\r\n                // TODO: dev warning of unused params if provided\r\n                // we know the matcher works because we tested the regexp\r\n                params = matcher.parse(path);\r\n                name = matcher.record.name;\r\n            }\r\n            // location is a relative path\r\n        }\r\n        else {\r\n            // match by name or path of current route\r\n            matcher = currentLocation.name\r\n                ? matcherMap.get(currentLocation.name)\r\n                : matchers.find(m => m.re.test(currentLocation.path));\r\n            if (!matcher)\r\n                throw createRouterError(1 /* MATCHER_NOT_FOUND */, {\r\n                    location,\r\n                    currentLocation,\r\n                });\r\n            name = matcher.record.name;\r\n            // since we are navigating to the same location, we don't need to pick the\r\n            // params like when `name` is provided\r\n            params = assign({}, currentLocation.params, location.params);\r\n            path = matcher.stringify(params);\r\n        }\r\n        const matched = [];\r\n        let parentMatcher = matcher;\r\n        while (parentMatcher) {\r\n            // reversed order so parents are at the beginning\r\n            matched.unshift(parentMatcher.record);\r\n            parentMatcher = parentMatcher.parent;\r\n        }\r\n        return {\r\n            name,\r\n            path,\r\n            params,\r\n            matched,\r\n            meta: mergeMetaFields(matched),\r\n        };\r\n    }\r\n    // add initial routes\r\n    routes.forEach(route => addRoute(route));\r\n    return { addRoute, resolve, removeRoute, getRoutes, getRecordMatcher };\r\n}\r\nfunction paramsFromLocation(params, keys) {\r\n    let newParams = {};\r\n    for (let key of keys) {\r\n        if (key in params)\r\n            newParams[key] = params[key];\r\n    }\r\n    return newParams;\r\n}\r\n/**\r\n * Normalizes a RouteRecordRaw. Creates a copy\r\n *\r\n * @param record\r\n * @returns the normalized version\r\n */\r\nfunction normalizeRouteRecord(record) {\r\n    return {\r\n        path: record.path,\r\n        redirect: record.redirect,\r\n        name: record.name,\r\n        meta: record.meta || {},\r\n        aliasOf: undefined,\r\n        beforeEnter: record.beforeEnter,\r\n        props: normalizeRecordProps(record),\r\n        children: record.children || [],\r\n        instances: {},\r\n        leaveGuards: new Set(),\r\n        updateGuards: new Set(),\r\n        enterCallbacks: {},\r\n        components: 'components' in record\r\n            ? record.components || {}\r\n            : { default: record.component },\r\n    };\r\n}\r\n/**\r\n * Normalize the optional `props` in a record to always be an object similar to\r\n * components. Also accept a boolean for components.\r\n * @param record\r\n */\r\nfunction normalizeRecordProps(record) {\r\n    const propsObject = {};\r\n    // props does not exist on redirect records but we can set false directly\r\n    const props = record.props || false;\r\n    if ('component' in record) {\r\n        propsObject.default = props;\r\n    }\r\n    else {\r\n        // NOTE: we could also allow a function to be applied to every component.\r\n        // Would need user feedback for use cases\r\n        for (let name in record.components)\r\n            propsObject[name] = typeof props === 'boolean' ? props : props[name];\r\n    }\r\n    return propsObject;\r\n}\r\n/**\r\n * Checks if a record or any of its parent is an alias\r\n * @param record\r\n */\r\nfunction isAliasRecord(record) {\r\n    while (record) {\r\n        if (record.record.aliasOf)\r\n            return true;\r\n        record = record.parent;\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * Merge meta fields of an array of records\r\n *\r\n * @param matched - array of matched records\r\n */\r\nfunction mergeMetaFields(matched) {\r\n    return matched.reduce((meta, record) => assign(meta, record.meta), {});\r\n}\r\nfunction mergeOptions(defaults, partialOptions) {\r\n    let options = {};\r\n    for (let key in defaults) {\r\n        options[key] =\r\n            key in partialOptions ? partialOptions[key] : defaults[key];\r\n    }\r\n    return options;\r\n}\r\nfunction isSameParam(a, b) {\r\n    return (a.name === b.name &&\r\n        a.optional === b.optional &&\r\n        a.repeatable === b.repeatable);\r\n}\r\n/**\r\n * Check if a path and its alias have the same required params\r\n *\r\n * @param a - original record\r\n * @param b - alias record\r\n */\r\nfunction checkSameParams(a, b) {\r\n    for (let key of a.keys) {\r\n        if (!key.optional && !b.keys.find(isSameParam.bind(null, key)))\r\n            return warn(`Alias \"${b.record.path}\" and the original record: \"${a.record.path}\" should have the exact same param named \"${key.name}\"`);\r\n    }\r\n    for (let key of b.keys) {\r\n        if (!key.optional && !a.keys.find(isSameParam.bind(null, key)))\r\n            return warn(`Alias \"${b.record.path}\" and the original record: \"${a.record.path}\" should have the exact same param named \"${key.name}\"`);\r\n    }\r\n}\r\nfunction checkMissingParamsInAbsolutePath(record, parent) {\r\n    for (let key of parent.keys) {\r\n        if (!record.keys.find(isSameParam.bind(null, key)))\r\n            return warn(`Absolute path \"${record.record.path}\" should have the exact same param named \"${key.name}\" as its parent \"${parent.record.path}\".`);\r\n    }\r\n}\n\n/**\r\n * Encoding Rules ␣ = Space Path: ␣ \" < > # ? { } Query: ␣ \" < > # & = Hash: ␣ \"\r\n * < > `\r\n *\r\n * On top of that, the RFC3986 (https://tools.ietf.org/html/rfc3986#section-2.2)\r\n * defines some extra characters to be encoded. Most browsers do not encode them\r\n * in encodeURI https://github.com/whatwg/url/issues/369, so it may be safer to\r\n * also encode `!'()*`. Leaving unencoded only ASCII alphanumeric(`a-zA-Z0-9`)\r\n * plus `-._~`. This extra safety should be applied to query by patching the\r\n * string returned by encodeURIComponent encodeURI also encodes `[\\]^`. `\\`\r\n * should be encoded to avoid ambiguity. Browsers (IE, FF, C) transform a `\\`\r\n * into a `/` if directly typed in. The _backtick_ (`````) should also be\r\n * encoded everywhere because some browsers like FF encode it when directly\r\n * written while others don't. Safari and IE don't encode ``\"<>{}``` in hash.\r\n */\r\n// const EXTRA_RESERVED_RE = /[!'()*]/g\r\n// const encodeReservedReplacer = (c: string) => '%' + c.charCodeAt(0).toString(16)\r\nconst HASH_RE = /#/g; // %23\r\nconst AMPERSAND_RE = /&/g; // %26\r\nconst SLASH_RE = /\\//g; // %2F\r\nconst EQUAL_RE = /=/g; // %3D\r\nconst IM_RE = /\\?/g; // %3F\r\nconst PLUS_RE = /\\+/g; // %2B\r\n/**\r\n * NOTE: It's not clear to me if we should encode the + symbol in queries, it\r\n * seems to be less flexible than not doing so and I can't find out the legacy\r\n * systems requiring this for regular requests like text/html. In the standard,\r\n * the encoding of the plus character is only mentioned for\r\n * application/x-www-form-urlencoded\r\n * (https://url.spec.whatwg.org/#urlencoded-parsing) and most browsers seems lo\r\n * leave the plus character as is in queries. To be more flexible, we allow the\r\n * plus character on the query but it can also be manually encoded by the user.\r\n *\r\n * Resources:\r\n * - https://url.spec.whatwg.org/#urlencoded-parsing\r\n * - https://stackoverflow.com/questions/1634271/url-encoding-the-space-character-or-20\r\n */\r\nconst ENC_BRACKET_OPEN_RE = /%5B/g; // [\r\nconst ENC_BRACKET_CLOSE_RE = /%5D/g; // ]\r\nconst ENC_CARET_RE = /%5E/g; // ^\r\nconst ENC_BACKTICK_RE = /%60/g; // `\r\nconst ENC_CURLY_OPEN_RE = /%7B/g; // {\r\nconst ENC_PIPE_RE = /%7C/g; // |\r\nconst ENC_CURLY_CLOSE_RE = /%7D/g; // }\r\nconst ENC_SPACE_RE = /%20/g; // }\r\n/**\r\n * Encode characters that need to be encoded on the path, search and hash\r\n * sections of the URL.\r\n *\r\n * @internal\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction commonEncode(text) {\r\n    return encodeURI('' + text)\r\n        .replace(ENC_PIPE_RE, '|')\r\n        .replace(ENC_BRACKET_OPEN_RE, '[')\r\n        .replace(ENC_BRACKET_CLOSE_RE, ']');\r\n}\r\n/**\r\n * Encode characters that need to be encoded on the hash section of the URL.\r\n *\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction encodeHash(text) {\r\n    return commonEncode(text)\r\n        .replace(ENC_CURLY_OPEN_RE, '{')\r\n        .replace(ENC_CURLY_CLOSE_RE, '}')\r\n        .replace(ENC_CARET_RE, '^');\r\n}\r\n/**\r\n * Encode characters that need to be encoded query values on the query\r\n * section of the URL.\r\n *\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction encodeQueryValue(text) {\r\n    return (commonEncode(text)\r\n        // Encode the space as +, encode the + to differentiate it from the space\r\n        .replace(PLUS_RE, '%2B')\r\n        .replace(ENC_SPACE_RE, '+')\r\n        .replace(HASH_RE, '%23')\r\n        .replace(AMPERSAND_RE, '%26')\r\n        .replace(ENC_BACKTICK_RE, '`')\r\n        .replace(ENC_CURLY_OPEN_RE, '{')\r\n        .replace(ENC_CURLY_CLOSE_RE, '}')\r\n        .replace(ENC_CARET_RE, '^'));\r\n}\r\n/**\r\n * Like `encodeQueryValue` but also encodes the `=` character.\r\n *\r\n * @param text - string to encode\r\n */\r\nfunction encodeQueryKey(text) {\r\n    return encodeQueryValue(text).replace(EQUAL_RE, '%3D');\r\n}\r\n/**\r\n * Encode characters that need to be encoded on the path section of the URL.\r\n *\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction encodePath(text) {\r\n    return commonEncode(text).replace(HASH_RE, '%23').replace(IM_RE, '%3F');\r\n}\r\n/**\r\n * Encode characters that need to be encoded on the path section of the URL as a\r\n * param. This function encodes everything {@link encodePath} does plus the\r\n * slash (`/`) character.\r\n *\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction encodeParam(text) {\r\n    return encodePath(text).replace(SLASH_RE, '%2F');\r\n}\r\n/**\r\n * Decode text using `decodeURIComponent`. Returns the original text if it\r\n * fails.\r\n *\r\n * @param text - string to decode\r\n * @returns decoded string\r\n */\r\nfunction decode(text) {\r\n    try {\r\n        return decodeURIComponent('' + text);\r\n    }\r\n    catch (err) {\r\n        (process.env.NODE_ENV !== 'production') && warn(`Error decoding \"${text}\". Using original value`);\r\n    }\r\n    return '' + text;\r\n}\n\n/**\r\n * Transforms a queryString into a {@link LocationQuery} object. Accept both, a\r\n * version with the leading `?` and without Should work as URLSearchParams\r\n\n * @internal\r\n *\r\n * @param search - search string to parse\r\n * @returns a query object\r\n */\r\nfunction parseQuery(search) {\r\n    const query = {};\r\n    // avoid creating an object with an empty key and empty value\r\n    // because of split('&')\r\n    if (search === '' || search === '?')\r\n        return query;\r\n    const hasLeadingIM = search[0] === '?';\r\n    const searchParams = (hasLeadingIM ? search.slice(1) : search).split('&');\r\n    for (let i = 0; i < searchParams.length; ++i) {\r\n        // pre decode the + into space\r\n        const searchParam = searchParams[i].replace(PLUS_RE, ' ');\r\n        // allow the = character\r\n        let eqPos = searchParam.indexOf('=');\r\n        let key = decode(eqPos < 0 ? searchParam : searchParam.slice(0, eqPos));\r\n        let value = eqPos < 0 ? null : decode(searchParam.slice(eqPos + 1));\r\n        if (key in query) {\r\n            // an extra variable for ts types\r\n            let currentValue = query[key];\r\n            if (!Array.isArray(currentValue)) {\r\n                currentValue = query[key] = [currentValue];\r\n            }\r\n            currentValue.push(value);\r\n        }\r\n        else {\r\n            query[key] = value;\r\n        }\r\n    }\r\n    return query;\r\n}\r\n/**\r\n * Stringifies a {@link LocationQueryRaw} object. Like `URLSearchParams`, it\r\n * doesn't prepend a `?`\r\n *\r\n * @internal\r\n *\r\n * @param query - query object to stringify\r\n * @returns string version of the query without the leading `?`\r\n */\r\nfunction stringifyQuery(query) {\r\n    let search = '';\r\n    for (let key in query) {\r\n        if (search.length)\r\n            search += '&';\r\n        const value = query[key];\r\n        key = encodeQueryKey(key);\r\n        if (value == null) {\r\n            // only null adds the value\r\n            if (value !== undefined)\r\n                search += key;\r\n            continue;\r\n        }\r\n        // keep null values\r\n        let values = Array.isArray(value)\r\n            ? value.map(v => v && encodeQueryValue(v))\r\n            : [value && encodeQueryValue(value)];\r\n        for (let i = 0; i < values.length; i++) {\r\n            // only append & with i > 0\r\n            search += (i ? '&' : '') + key;\r\n            if (values[i] != null)\r\n                search += ('=' + values[i]);\r\n        }\r\n    }\r\n    return search;\r\n}\r\n/**\r\n * Transforms a {@link LocationQueryRaw} into a {@link LocationQuery} by casting\r\n * numbers into strings, removing keys with an undefined value and replacing\r\n * undefined with null in arrays\r\n *\r\n * @param query - query object to normalize\r\n * @returns a normalized query object\r\n */\r\nfunction normalizeQuery(query) {\r\n    const normalizedQuery = {};\r\n    for (let key in query) {\r\n        let value = query[key];\r\n        if (value !== undefined) {\r\n            normalizedQuery[key] = Array.isArray(value)\r\n                ? value.map(v => (v == null ? null : '' + v))\r\n                : value == null\r\n                    ? value\r\n                    : '' + value;\r\n        }\r\n    }\r\n    return normalizedQuery;\r\n}\n\n/**\r\n * Create a list of callbacks that can be reset. Used to create before and after navigation guards list\r\n */\r\nfunction useCallbacks() {\r\n    let handlers = [];\r\n    function add(handler) {\r\n        handlers.push(handler);\r\n        return () => {\r\n            const i = handlers.indexOf(handler);\r\n            if (i > -1)\r\n                handlers.splice(i, 1);\r\n        };\r\n    }\r\n    function reset() {\r\n        handlers = [];\r\n    }\r\n    return {\r\n        add,\r\n        list: () => handlers,\r\n        reset,\r\n    };\r\n}\n\nfunction registerGuard(record, name, guard) {\r\n    const removeFromList = () => {\r\n        record[name].delete(guard);\r\n    };\r\n    onUnmounted(removeFromList);\r\n    onDeactivated(removeFromList);\r\n    onActivated(() => {\r\n        record[name].add(guard);\r\n    });\r\n    record[name].add(guard);\r\n}\r\n/**\r\n * Add a navigation guard that triggers whenever the component for the current\r\n * location is about to be left. Similar to {@link beforeRouteLeave} but can be\r\n * used in any component. The guard is removed when the component is unmounted.\r\n *\r\n * @param leaveGuard - {@link NavigationGuard}\r\n */\r\nfunction onBeforeRouteLeave(leaveGuard) {\r\n    if ((process.env.NODE_ENV !== 'production') && !getCurrentInstance()) {\r\n        warn('getCurrentInstance() returned null. onBeforeRouteLeave() must be called at the top of a setup function');\r\n        return;\r\n    }\r\n    const activeRecord = inject(matchedRouteKey, {}).value;\r\n    if (!activeRecord) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn('No active route record was found. Are you missing a <router-view> component?');\r\n        return;\r\n    }\r\n    registerGuard(activeRecord, 'leaveGuards', leaveGuard);\r\n}\r\n/**\r\n * Add a navigation guard that triggers whenever the current location is about\r\n * to be updated. Similar to {@link beforeRouteUpdate} but can be used in any\r\n * component. The guard is removed when the component is unmounted.\r\n *\r\n * @param updateGuard - {@link NavigationGuard}\r\n */\r\nfunction onBeforeRouteUpdate(updateGuard) {\r\n    if ((process.env.NODE_ENV !== 'production') && !getCurrentInstance()) {\r\n        warn('getCurrentInstance() returned null. onBeforeRouteUpdate() must be called at the top of a setup function');\r\n        return;\r\n    }\r\n    const activeRecord = inject(matchedRouteKey, {}).value;\r\n    if (!activeRecord) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn('No active route record was found. Are you missing a <router-view> component?');\r\n        return;\r\n    }\r\n    registerGuard(activeRecord, 'updateGuards', updateGuard);\r\n}\r\nfunction guardToPromiseFn(guard, to, from, record, name) {\r\n    // keep a reference to the enterCallbackArray to prevent pushing callbacks if a new navigation took place\r\n    const enterCallbackArray = record &&\r\n        // name is defined if record is because of the function overload\r\n        (record.enterCallbacks[name] = record.enterCallbacks[name] || []);\r\n    return () => new Promise((resolve, reject) => {\r\n        const next = (valid) => {\r\n            if (valid === false)\r\n                reject(createRouterError(4 /* NAVIGATION_ABORTED */, {\r\n                    from,\r\n                    to,\r\n                }));\r\n            else if (valid instanceof Error) {\r\n                reject(valid);\r\n            }\r\n            else if (isRouteLocation(valid)) {\r\n                reject(createRouterError(2 /* NAVIGATION_GUARD_REDIRECT */, {\r\n                    from: to,\r\n                    to: valid,\r\n                }));\r\n            }\r\n            else {\r\n                if (enterCallbackArray &&\r\n                    // since enterCallbackArray is truthy, both record and name also are\r\n                    record.enterCallbacks[name] === enterCallbackArray &&\r\n                    typeof valid === 'function')\r\n                    enterCallbackArray.push(valid);\r\n                resolve();\r\n            }\r\n        };\r\n        // wrapping with Promise.resolve allows it to work with both async and sync guards\r\n        const guardReturn = guard.call(record && record.instances[name], to, from, (process.env.NODE_ENV !== 'production') ? canOnlyBeCalledOnce(next, to, from) : next);\r\n        let guardCall = Promise.resolve(guardReturn);\r\n        if (guard.length < 3)\r\n            guardCall = guardCall.then(next);\r\n        if ((process.env.NODE_ENV !== 'production') && guard.length > 2) {\r\n            const message = `The \"next\" callback was never called inside of ${guard.name ? '\"' + guard.name + '\"' : ''}:\\n${guard.toString()}\\n. If you are returning a value instead of calling \"next\", make sure to remove the \"next\" parameter from your function.`;\r\n            if (typeof guardReturn === 'object' && 'then' in guardReturn) {\r\n                guardCall = guardCall.then(resolvedValue => {\r\n                    // @ts-ignore: _called is added at canOnlyBeCalledOnce\r\n                    if (!next._called) {\r\n                        warn(message);\r\n                        return Promise.reject(new Error('Invalid navigation guard'));\r\n                    }\r\n                    return resolvedValue;\r\n                });\r\n                // TODO: test me!\r\n            }\r\n            else if (guardReturn !== undefined) {\r\n                // @ts-ignore: _called is added at canOnlyBeCalledOnce\r\n                if (!next._called) {\r\n                    warn(message);\r\n                    reject(new Error('Invalid navigation guard'));\r\n                    return;\r\n                }\r\n            }\r\n        }\r\n        guardCall.catch(err => reject(err));\r\n    });\r\n}\r\nfunction canOnlyBeCalledOnce(next, to, from) {\r\n    let called = 0;\r\n    return function () {\r\n        if (called++ === 1)\r\n            warn(`The \"next\" callback was called more than once in one navigation guard when going from \"${from.fullPath}\" to \"${to.fullPath}\". It should be called exactly one time in each navigation guard. This will fail in production.`);\r\n        // @ts-ignore: we put it in the original one because it's easier to check\r\n        next._called = true;\r\n        if (called === 1)\r\n            next.apply(null, arguments);\r\n    };\r\n}\r\nfunction extractComponentsGuards(matched, guardType, to, from) {\r\n    const guards = [];\r\n    for (const record of matched) {\r\n        for (const name in record.components) {\r\n            let rawComponent = record.components[name];\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                if (!rawComponent ||\r\n                    (typeof rawComponent !== 'object' &&\r\n                        typeof rawComponent !== 'function')) {\r\n                    warn(`Component \"${name}\" in record with path \"${record.path}\" is not` +\r\n                        ` a valid component. Received \"${String(rawComponent)}\".`);\r\n                    // throw to ensure we stop here but warn to ensure the message isn't\r\n                    // missed by the user\r\n                    throw new Error('Invalid route component');\r\n                }\r\n                else if ('then' in rawComponent) {\r\n                    // warn if user wrote import('/component.vue') instead of () =>\r\n                    // import('./component.vue')\r\n                    warn(`Component \"${name}\" in record with path \"${record.path}\" is a ` +\r\n                        `Promise instead of a function that returns a Promise. Did you ` +\r\n                        `write \"import('./MyPage.vue')\" instead of ` +\r\n                        `\"() => import('./MyPage.vue')\" ? This will break in ` +\r\n                        `production if not fixed.`);\r\n                    let promise = rawComponent;\r\n                    rawComponent = () => promise;\r\n                }\r\n                else if (rawComponent.__asyncLoader &&\r\n                    // warn only once per component\r\n                    !rawComponent.__warnedDefineAsync) {\r\n                    rawComponent.__warnedDefineAsync = true;\r\n                    warn(`Component \"${name}\" in record with path \"${record.path}\" is defined ` +\r\n                        `using \"defineAsyncComponent()\". ` +\r\n                        `Write \"() => import('./MyPage.vue')\" instead of ` +\r\n                        `\"defineAsyncComponent(() => import('./MyPage.vue'))\".`);\r\n                }\r\n            }\r\n            // skip update and leave guards if the route component is not mounted\r\n            if (guardType !== 'beforeRouteEnter' && !record.instances[name])\r\n                continue;\r\n            if (isRouteComponent(rawComponent)) {\r\n                // __vccOpts is added by vue-class-component and contain the regular options\r\n                let options = rawComponent.__vccOpts || rawComponent;\r\n                const guard = options[guardType];\r\n                guard && guards.push(guardToPromiseFn(guard, to, from, record, name));\r\n            }\r\n            else {\r\n                // start requesting the chunk already\r\n                let componentPromise = rawComponent();\r\n                if ((process.env.NODE_ENV !== 'production') && !('catch' in componentPromise)) {\r\n                    warn(`Component \"${name}\" in record with path \"${record.path}\" is a function that does not return a Promise. If you were passing a functional component, make sure to add a \"displayName\" to the component. This will break in production if not fixed.`);\r\n                    componentPromise = Promise.resolve(componentPromise);\r\n                }\r\n                else {\r\n                    // display the error if any\r\n                    componentPromise = componentPromise.catch(console.error);\r\n                }\r\n                guards.push(() => componentPromise.then(resolved => {\r\n                    if (!resolved)\r\n                        return Promise.reject(new Error(`Couldn't resolve component \"${name}\" at \"${record.path}\"`));\r\n                    const resolvedComponent = isESModule(resolved)\r\n                        ? resolved.default\r\n                        : resolved;\r\n                    // replace the function with the resolved component\r\n                    record.components[name] = resolvedComponent;\r\n                    // __vccOpts is added by vue-class-component and contain the regular options\r\n                    let options = resolvedComponent.__vccOpts || resolvedComponent;\r\n                    const guard = options[guardType];\r\n                    return guard && guardToPromiseFn(guard, to, from, record, name)();\r\n                }));\r\n            }\r\n        }\r\n    }\r\n    return guards;\r\n}\r\n/**\r\n * Allows differentiating lazy components from functional components and vue-class-component\r\n * @param component\r\n */\r\nfunction isRouteComponent(component) {\r\n    return (typeof component === 'object' ||\r\n        'displayName' in component ||\r\n        'props' in component ||\r\n        '__vccOpts' in component);\r\n}\n\n// TODO: we could allow currentRoute as a prop to expose `isActive` and\r\n// `isExactActive` behavior should go through an RFC\r\nfunction useLink(props) {\r\n    const router = inject(routerKey);\r\n    const currentRoute = inject(routeLocationKey);\r\n    const route = computed(() => router.resolve(unref(props.to)));\r\n    const activeRecordIndex = computed(() => {\r\n        let { matched } = route.value;\r\n        let { length } = matched;\r\n        const routeMatched = matched[length - 1];\r\n        let currentMatched = currentRoute.matched;\r\n        if (!routeMatched || !currentMatched.length)\r\n            return -1;\r\n        let index = currentMatched.findIndex(isSameRouteRecord.bind(null, routeMatched));\r\n        if (index > -1)\r\n            return index;\r\n        // possible parent record\r\n        let parentRecordPath = getOriginalPath(matched[length - 2]);\r\n        return (\r\n        // we are dealing with nested routes\r\n        length > 1 &&\r\n            // if the parent and matched route have the same path, this link is\r\n            // referring to the empty child. Or we currently are on a different\r\n            // child of the same parent\r\n            getOriginalPath(routeMatched) === parentRecordPath &&\r\n            // avoid comparing the child with its parent\r\n            currentMatched[currentMatched.length - 1].path !== parentRecordPath\r\n            ? currentMatched.findIndex(isSameRouteRecord.bind(null, matched[length - 2]))\r\n            : index);\r\n    });\r\n    const isActive = computed(() => activeRecordIndex.value > -1 &&\r\n        includesParams(currentRoute.params, route.value.params));\r\n    const isExactActive = computed(() => activeRecordIndex.value > -1 &&\r\n        activeRecordIndex.value === currentRoute.matched.length - 1 &&\r\n        isSameRouteLocationParams(currentRoute.params, route.value.params));\r\n    function navigate(e = {}) {\r\n        if (guardEvent(e))\r\n            return router[unref(props.replace) ? 'replace' : 'push'](unref(props.to));\r\n        return Promise.resolve();\r\n    }\r\n    return {\r\n        route,\r\n        href: computed(() => route.value.href),\r\n        isActive,\r\n        isExactActive,\r\n        navigate,\r\n    };\r\n}\r\nconst RouterLinkImpl = /*#__PURE__*/ defineComponent({\r\n    name: 'RouterLink',\r\n    props: {\r\n        to: {\r\n            type: [String, Object],\r\n            required: true,\r\n        },\r\n        replace: Boolean,\r\n        activeClass: String,\r\n        // inactiveClass: String,\r\n        exactActiveClass: String,\r\n        custom: Boolean,\r\n        ariaCurrentValue: {\r\n            type: String,\r\n            default: 'page',\r\n        },\r\n    },\r\n    setup(props, { slots }) {\r\n        const link = reactive(useLink(props));\r\n        const { options } = inject(routerKey);\r\n        const elClass = computed(() => ({\r\n            [getLinkClass(props.activeClass, options.linkActiveClass, 'router-link-active')]: link.isActive,\r\n            // [getLinkClass(\r\n            //   props.inactiveClass,\r\n            //   options.linkInactiveClass,\r\n            //   'router-link-inactive'\r\n            // )]: !link.isExactActive,\r\n            [getLinkClass(props.exactActiveClass, options.linkExactActiveClass, 'router-link-exact-active')]: link.isExactActive,\r\n        }));\r\n        if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) && true) {\r\n            const instance = getCurrentInstance();\r\n            watchEffect(() => {\r\n                if (!instance)\r\n                    return;\r\n                instance.__vrl_route = link.route;\r\n            }, { flush: 'post' });\r\n            watchEffect(() => {\r\n                if (!instance)\r\n                    return;\r\n                instance.__vrl_active = link.isActive;\r\n                instance.__vrl_exactActive = link.isExactActive;\r\n            }, { flush: 'post' });\r\n        }\r\n        return () => {\r\n            const children = slots.default && slots.default(link);\r\n            return props.custom\r\n                ? children\r\n                : h('a', {\r\n                    'aria-current': link.isExactActive\r\n                        ? props.ariaCurrentValue\r\n                        : null,\r\n                    href: link.href,\r\n                    // this would override user added attrs but Vue will still add\r\n                    // the listener so we end up triggering both\r\n                    onClick: link.navigate,\r\n                    class: elClass.value,\r\n                }, children);\r\n        };\r\n    },\r\n});\r\n// export the public type for h/tsx inference\r\n// also to avoid inline import() in generated d.ts files\r\n/**\r\n * Component to render a link that triggers a navigation on click.\r\n */\r\nconst RouterLink = RouterLinkImpl;\r\nfunction guardEvent(e) {\r\n    // don't redirect with control keys\r\n    if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey)\r\n        return;\r\n    // don't redirect when preventDefault called\r\n    if (e.defaultPrevented)\r\n        return;\r\n    // don't redirect on right click\r\n    if (e.button !== undefined && e.button !== 0)\r\n        return;\r\n    // don't redirect if `target=\"_blank\"`\r\n    // @ts-ignore getAttribute does exist\r\n    if (e.currentTarget && e.currentTarget.getAttribute) {\r\n        // @ts-ignore getAttribute exists\r\n        const target = e.currentTarget.getAttribute('target');\r\n        if (/\\b_blank\\b/i.test(target))\r\n            return;\r\n    }\r\n    // this may be a Weex event which doesn't have this method\r\n    if (e.preventDefault)\r\n        e.preventDefault();\r\n    return true;\r\n}\r\nfunction includesParams(outer, inner) {\r\n    for (let key in inner) {\r\n        let innerValue = inner[key];\r\n        let outerValue = outer[key];\r\n        if (typeof innerValue === 'string') {\r\n            if (innerValue !== outerValue)\r\n                return false;\r\n        }\r\n        else {\r\n            if (!Array.isArray(outerValue) ||\r\n                outerValue.length !== innerValue.length ||\r\n                innerValue.some((value, i) => value !== outerValue[i]))\r\n                return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\n/**\r\n * Get the original path value of a record by following its aliasOf\r\n * @param record\r\n */\r\nfunction getOriginalPath(record) {\r\n    return record ? (record.aliasOf ? record.aliasOf.path : record.path) : '';\r\n}\r\n/**\r\n * Utility class to get the active class based on defaults.\r\n * @param propClass\r\n * @param globalClass\r\n * @param defaultClass\r\n */\r\nconst getLinkClass = (propClass, globalClass, defaultClass) => propClass != null\r\n    ? propClass\r\n    : globalClass != null\r\n        ? globalClass\r\n        : defaultClass;\n\nconst RouterViewImpl = /*#__PURE__*/ defineComponent({\r\n    name: 'RouterView',\r\n    // #674 we manually inherit them\r\n    inheritAttrs: false,\r\n    props: {\r\n        name: {\r\n            type: String,\r\n            default: 'default',\r\n        },\r\n        route: Object,\r\n    },\r\n    setup(props, { attrs, slots }) {\r\n        (process.env.NODE_ENV !== 'production') && warnDeprecatedUsage();\r\n        const injectedRoute = inject(routerViewLocationKey);\r\n        const routeToDisplay = computed(() => props.route || injectedRoute.value);\r\n        const depth = inject(viewDepthKey, 0);\r\n        const matchedRouteRef = computed(() => routeToDisplay.value.matched[depth]);\r\n        provide(viewDepthKey, depth + 1);\r\n        provide(matchedRouteKey, matchedRouteRef);\r\n        provide(routerViewLocationKey, routeToDisplay);\r\n        const viewRef = ref();\r\n        // watch at the same time the component instance, the route record we are\r\n        // rendering, and the name\r\n        watch(() => [viewRef.value, matchedRouteRef.value, props.name], ([instance, to, name], [oldInstance, from, oldName]) => {\r\n            // copy reused instances\r\n            if (to) {\r\n                // this will update the instance for new instances as well as reused\r\n                // instances when navigating to a new route\r\n                to.instances[name] = instance;\r\n                // the component instance is reused for a different route or name so\r\n                // we copy any saved update or leave guards. With async setup, the\r\n                // mounting component will mount before the matchedRoute changes,\r\n                // making instance === oldInstance, so we check if guards have been\r\n                // added before. This works because we remove guards when\r\n                // unmounting/deactivating components\r\n                if (from && from !== to && instance && instance === oldInstance) {\r\n                    if (!to.leaveGuards.size) {\r\n                        to.leaveGuards = from.leaveGuards;\r\n                    }\r\n                    if (!to.updateGuards.size) {\r\n                        to.updateGuards = from.updateGuards;\r\n                    }\r\n                }\r\n            }\r\n            // trigger beforeRouteEnter next callbacks\r\n            if (instance &&\r\n                to &&\r\n                // if there is no instance but to and from are the same this might be\r\n                // the first visit\r\n                (!from || !isSameRouteRecord(to, from) || !oldInstance)) {\r\n                (to.enterCallbacks[name] || []).forEach(callback => callback(instance));\r\n            }\r\n        }, { flush: 'post' });\r\n        return () => {\r\n            const route = routeToDisplay.value;\r\n            const matchedRoute = matchedRouteRef.value;\r\n            const ViewComponent = matchedRoute && matchedRoute.components[props.name];\r\n            // we need the value at the time we render because when we unmount, we\r\n            // navigated to a different location so the value is different\r\n            const currentName = props.name;\r\n            if (!ViewComponent) {\r\n                return normalizeSlot(slots.default, { Component: ViewComponent, route });\r\n            }\r\n            // props from route configuration\r\n            const routePropsOption = matchedRoute.props[props.name];\r\n            const routeProps = routePropsOption\r\n                ? routePropsOption === true\r\n                    ? route.params\r\n                    : typeof routePropsOption === 'function'\r\n                        ? routePropsOption(route)\r\n                        : routePropsOption\r\n                : null;\r\n            const onVnodeUnmounted = vnode => {\r\n                // remove the instance reference to prevent leak\r\n                if (vnode.component.isUnmounted) {\r\n                    matchedRoute.instances[currentName] = null;\r\n                }\r\n            };\r\n            const component = h(ViewComponent, assign({}, routeProps, attrs, {\r\n                onVnodeUnmounted,\r\n                ref: viewRef,\r\n            }));\r\n            return (\r\n            // pass the vnode to the slot as a prop.\r\n            // h and <component :is=\"...\"> both accept vnodes\r\n            normalizeSlot(slots.default, { Component: component, route }) ||\r\n                component);\r\n        };\r\n    },\r\n});\r\nfunction normalizeSlot(slot, data) {\r\n    if (!slot)\r\n        return null;\r\n    const slotContent = slot(data);\r\n    return slotContent.length === 1 ? slotContent[0] : slotContent;\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\n/**\r\n * Component to display the current route the user is at.\r\n */\r\nconst RouterView = RouterViewImpl;\r\n// warn against deprecated usage with <transition> & <keep-alive>\r\n// due to functional component being no longer eager in Vue 3\r\nfunction warnDeprecatedUsage() {\r\n    const instance = getCurrentInstance();\r\n    const parentName = instance.parent && instance.parent.type.name;\r\n    if (parentName &&\r\n        (parentName === 'KeepAlive' || parentName.includes('Transition'))) {\r\n        const comp = parentName === 'KeepAlive' ? 'keep-alive' : 'transition';\r\n        warn(`<router-view> can no longer be used directly inside <transition> or <keep-alive>.\\n` +\r\n            `Use slot props instead:\\n\\n` +\r\n            `<router-view v-slot=\"{ Component }\">\\n` +\r\n            `  <${comp}>\\n` +\r\n            `    <component :is=\"Component\" />\\n` +\r\n            `  </${comp}>\\n` +\r\n            `</router-view>`);\r\n    }\r\n}\n\nfunction getDevtoolsGlobalHook() {\n    return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;\n}\nfunction getTarget() {\n    // @ts-ignore\n    return typeof navigator !== 'undefined'\n        ? window\n        : typeof global !== 'undefined'\n            ? global\n            : {};\n}\n\nconst HOOK_SETUP = 'devtools-plugin:setup';\n\nfunction setupDevtoolsPlugin(pluginDescriptor, setupFn) {\n    const hook = getDevtoolsGlobalHook();\n    if (hook) {\n        hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);\n    }\n    else {\n        const target = getTarget();\n        const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];\n        list.push({\n            pluginDescriptor,\n            setupFn\n        });\n    }\n}\n\nfunction formatRouteLocation(routeLocation, tooltip) {\r\n    const copy = assign({}, routeLocation, {\r\n        // remove variables that can contain vue instances\r\n        matched: routeLocation.matched.map(matched => omit(matched, ['instances', 'children', 'aliasOf'])),\r\n    });\r\n    return {\r\n        _custom: {\r\n            type: null,\r\n            readOnly: true,\r\n            display: routeLocation.fullPath,\r\n            tooltip,\r\n            value: copy,\r\n        },\r\n    };\r\n}\r\nfunction formatDisplay(display) {\r\n    return {\r\n        _custom: {\r\n            display,\r\n        },\r\n    };\r\n}\r\n// to support multiple router instances\r\nlet routerId = 0;\r\nfunction addDevtools(app, router, matcher) {\r\n    // Take over router.beforeEach and afterEach\r\n    // make sure we are not registering the devtool twice\r\n    if (router.__hasDevtools)\r\n        return;\r\n    router.__hasDevtools = true;\r\n    // increment to support multiple router instances\r\n    const id = routerId++;\r\n    setupDevtoolsPlugin({\r\n        id: 'org.vuejs.router' + (id ? '.' + id : ''),\r\n        label: 'Vue Router',\r\n        packageName: 'vue-router',\r\n        homepage: 'https://next.router.vuejs.org/',\r\n        logo: 'https://vuejs.org/images/icons/favicon-96x96.png',\r\n        componentStateTypes: ['Routing'],\r\n        app,\r\n    }, api => {\r\n        // display state added by the router\r\n        api.on.inspectComponent((payload, ctx) => {\r\n            if (payload.instanceData) {\r\n                payload.instanceData.state.push({\r\n                    type: 'Routing',\r\n                    key: '$route',\r\n                    editable: false,\r\n                    value: formatRouteLocation(router.currentRoute.value, 'Current Route'),\r\n                });\r\n            }\r\n        });\r\n        // mark router-link as active\r\n        api.on.visitComponentTree(({ treeNode: node, componentInstance }) => {\r\n            if (node.name === 'RouterLink') {\r\n                if (componentInstance.__vrl_route) {\r\n                    node.tags.push({\r\n                        label: componentInstance.__vrl_route.path,\r\n                        textColor: 0,\r\n                        backgroundColor: ORANGE_400,\r\n                    });\r\n                }\r\n                if (componentInstance.__vrl_exactActive) {\r\n                    node.tags.push({\r\n                        label: 'exact',\r\n                        textColor: 0,\r\n                        backgroundColor: LIME_500,\r\n                    });\r\n                }\r\n                if (componentInstance.__vrl_active) {\r\n                    node.tags.push({\r\n                        label: 'active',\r\n                        textColor: 0,\r\n                        backgroundColor: BLUE_600,\r\n                    });\r\n                }\r\n            }\r\n        });\r\n        watch(router.currentRoute, () => {\r\n            // refresh active state\r\n            refreshRoutesView();\r\n            api.notifyComponentUpdate();\r\n            api.sendInspectorTree(routerInspectorId);\r\n        });\r\n        const navigationsLayerId = 'router:navigations:' + id;\r\n        api.addTimelineLayer({\r\n            id: navigationsLayerId,\r\n            label: `Router${id ? ' ' + id : ''} Navigations`,\r\n            color: 0x40a8c4,\r\n        });\r\n        // const errorsLayerId = 'router:errors'\r\n        // api.addTimelineLayer({\r\n        //   id: errorsLayerId,\r\n        //   label: 'Router Errors',\r\n        //   color: 0xea5455,\r\n        // })\r\n        router.onError(error => {\r\n            api.addTimelineEvent({\r\n                layerId: navigationsLayerId,\r\n                event: {\r\n                    title: 'Error',\r\n                    subtitle: 'An uncaught error happened during navigation',\r\n                    logType: 'error',\r\n                    time: Date.now(),\r\n                    data: { error },\r\n                },\r\n            });\r\n        });\r\n        // attached to `meta` and used to group events\r\n        let navigationId = 0;\r\n        router.beforeEach((to, from) => {\r\n            const data = {\r\n                guard: formatDisplay('beforeEach'),\r\n                from: formatRouteLocation(from, 'Current Location during this navigation'),\r\n                to: formatRouteLocation(to, 'Target location'),\r\n            };\r\n            // Used to group navigations together, hide from devtools\r\n            Object.defineProperty(to.meta, '__navigationId', {\r\n                value: navigationId++,\r\n            });\r\n            api.addTimelineEvent({\r\n                layerId: navigationsLayerId,\r\n                event: {\r\n                    time: Date.now(),\r\n                    title: 'Start of navigation',\r\n                    data,\r\n                    groupId: to.meta.__navigationId,\r\n                },\r\n            });\r\n        });\r\n        router.afterEach((to, from, failure) => {\r\n            const data = {\r\n                guard: formatDisplay('afterEach'),\r\n            };\r\n            if (failure) {\r\n                data.failure = {\r\n                    _custom: {\r\n                        type: Error,\r\n                        readOnly: true,\r\n                        display: failure ? failure.message : '',\r\n                        tooltip: 'Navigation Failure',\r\n                        value: failure,\r\n                    },\r\n                };\r\n                data.status = formatDisplay('❌');\r\n            }\r\n            else {\r\n                data.status = formatDisplay('✅');\r\n            }\r\n            // we set here to have the right order\r\n            data.from = formatRouteLocation(from, 'Current Location during this navigation');\r\n            data.to = formatRouteLocation(to, 'Target location');\r\n            api.addTimelineEvent({\r\n                layerId: navigationsLayerId,\r\n                event: {\r\n                    title: 'End of navigation',\r\n                    time: Date.now(),\r\n                    data,\r\n                    logType: failure ? 'warning' : 'default',\r\n                    groupId: to.meta.__navigationId,\r\n                },\r\n            });\r\n        });\r\n        /**\r\n         * Inspector of Existing routes\r\n         */\r\n        const routerInspectorId = 'router-inspector:' + id;\r\n        api.addInspector({\r\n            id: routerInspectorId,\r\n            label: 'Routes' + (id ? ' ' + id : ''),\r\n            icon: 'book',\r\n            treeFilterPlaceholder: 'Search routes',\r\n        });\r\n        function refreshRoutesView() {\r\n            // the routes view isn't active\r\n            if (!activeRoutesPayload)\r\n                return;\r\n            const payload = activeRoutesPayload;\r\n            // children routes will appear as nested\r\n            let routes = matcher.getRoutes().filter(route => !route.parent);\r\n            // reset match state to false\r\n            routes.forEach(resetMatchStateOnRouteRecord);\r\n            // apply a match state if there is a payload\r\n            if (payload.filter) {\r\n                routes = routes.filter(route => \r\n                // save matches state based on the payload\r\n                isRouteMatching(route, payload.filter.toLowerCase()));\r\n            }\r\n            // mark active routes\r\n            routes.forEach(route => markRouteRecordActive(route, router.currentRoute.value));\r\n            payload.rootNodes = routes.map(formatRouteRecordForInspector);\r\n        }\r\n        let activeRoutesPayload;\r\n        api.on.getInspectorTree(payload => {\r\n            activeRoutesPayload = payload;\r\n            if (payload.app === app && payload.inspectorId === routerInspectorId) {\r\n                refreshRoutesView();\r\n            }\r\n        });\r\n        /**\r\n         * Display information about the currently selected route record\r\n         */\r\n        api.on.getInspectorState(payload => {\r\n            if (payload.app === app && payload.inspectorId === routerInspectorId) {\r\n                const routes = matcher.getRoutes();\r\n                const route = routes.find(route => route.record.__vd_id === payload.nodeId);\r\n                if (route) {\r\n                    payload.state = {\r\n                        options: formatRouteRecordMatcherForStateInspector(route),\r\n                    };\r\n                }\r\n            }\r\n        });\r\n        api.sendInspectorTree(routerInspectorId);\r\n        api.sendInspectorState(routerInspectorId);\r\n    });\r\n}\r\nfunction modifierForKey(key) {\r\n    if (key.optional) {\r\n        return key.repeatable ? '*' : '?';\r\n    }\r\n    else {\r\n        return key.repeatable ? '+' : '';\r\n    }\r\n}\r\nfunction formatRouteRecordMatcherForStateInspector(route) {\r\n    const { record } = route;\r\n    const fields = [\r\n        { editable: false, key: 'path', value: record.path },\r\n    ];\r\n    if (record.name != null) {\r\n        fields.push({\r\n            editable: false,\r\n            key: 'name',\r\n            value: record.name,\r\n        });\r\n    }\r\n    fields.push({ editable: false, key: 'regexp', value: route.re });\r\n    if (route.keys.length) {\r\n        fields.push({\r\n            editable: false,\r\n            key: 'keys',\r\n            value: {\r\n                _custom: {\r\n                    type: null,\r\n                    readOnly: true,\r\n                    display: route.keys\r\n                        .map(key => `${key.name}${modifierForKey(key)}`)\r\n                        .join(' '),\r\n                    tooltip: 'Param keys',\r\n                    value: route.keys,\r\n                },\r\n            },\r\n        });\r\n    }\r\n    if (record.redirect != null) {\r\n        fields.push({\r\n            editable: false,\r\n            key: 'redirect',\r\n            value: record.redirect,\r\n        });\r\n    }\r\n    if (route.alias.length) {\r\n        fields.push({\r\n            editable: false,\r\n            key: 'aliases',\r\n            value: route.alias.map(alias => alias.record.path),\r\n        });\r\n    }\r\n    fields.push({\r\n        key: 'score',\r\n        editable: false,\r\n        value: {\r\n            _custom: {\r\n                type: null,\r\n                readOnly: true,\r\n                display: route.score.map(score => score.join(', ')).join(' | '),\r\n                tooltip: 'Score used to sort routes',\r\n                value: route.score,\r\n            },\r\n        },\r\n    });\r\n    return fields;\r\n}\r\n/**\r\n * Extracted from tailwind palette\r\n */\r\nconst PINK_500 = 0xec4899;\r\nconst BLUE_600 = 0x2563eb;\r\nconst LIME_500 = 0x84cc16;\r\nconst CYAN_400 = 0x22d3ee;\r\nconst ORANGE_400 = 0xfb923c;\r\n// const GRAY_100 = 0xf4f4f5\r\nconst DARK = 0x666666;\r\nfunction formatRouteRecordForInspector(route) {\r\n    const tags = [];\r\n    const { record } = route;\r\n    if (record.name != null) {\r\n        tags.push({\r\n            label: String(record.name),\r\n            textColor: 0,\r\n            backgroundColor: CYAN_400,\r\n        });\r\n    }\r\n    if (record.aliasOf) {\r\n        tags.push({\r\n            label: 'alias',\r\n            textColor: 0,\r\n            backgroundColor: ORANGE_400,\r\n        });\r\n    }\r\n    if (route.__vd_match) {\r\n        tags.push({\r\n            label: 'matches',\r\n            textColor: 0,\r\n            backgroundColor: PINK_500,\r\n        });\r\n    }\r\n    if (route.__vd_exactActive) {\r\n        tags.push({\r\n            label: 'exact',\r\n            textColor: 0,\r\n            backgroundColor: LIME_500,\r\n        });\r\n    }\r\n    if (route.__vd_active) {\r\n        tags.push({\r\n            label: 'active',\r\n            textColor: 0,\r\n            backgroundColor: BLUE_600,\r\n        });\r\n    }\r\n    if (record.redirect) {\r\n        tags.push({\r\n            label: 'redirect: ' +\r\n                (typeof record.redirect === 'string' ? record.redirect : 'Object'),\r\n            textColor: 0xffffff,\r\n            backgroundColor: DARK,\r\n        });\r\n    }\r\n    // add an id to be able to select it. Using the `path` is not possible because\r\n    // empty path children would collide with their parents\r\n    let id = String(routeRecordId++);\r\n    record.__vd_id = id;\r\n    return {\r\n        id,\r\n        label: record.path,\r\n        tags,\r\n        children: route.children.map(formatRouteRecordForInspector),\r\n    };\r\n}\r\n//  incremental id for route records and inspector state\r\nlet routeRecordId = 0;\r\nconst EXTRACT_REGEXP_RE = /^\\/(.*)\\/([a-z]*)$/;\r\nfunction markRouteRecordActive(route, currentRoute) {\r\n    // no route will be active if matched is empty\r\n    // reset the matching state\r\n    const isExactActive = currentRoute.matched.length &&\r\n        isSameRouteRecord(currentRoute.matched[currentRoute.matched.length - 1], route.record);\r\n    route.__vd_exactActive = route.__vd_active = isExactActive;\r\n    if (!isExactActive) {\r\n        route.__vd_active = currentRoute.matched.some(match => isSameRouteRecord(match, route.record));\r\n    }\r\n    route.children.forEach(childRoute => markRouteRecordActive(childRoute, currentRoute));\r\n}\r\nfunction resetMatchStateOnRouteRecord(route) {\r\n    route.__vd_match = false;\r\n    route.children.forEach(resetMatchStateOnRouteRecord);\r\n}\r\nfunction isRouteMatching(route, filter) {\r\n    const found = String(route.re).match(EXTRACT_REGEXP_RE);\r\n    route.__vd_match = false;\r\n    if (!found || found.length < 3) {\r\n        return false;\r\n    }\r\n    // use a regexp without $ at the end to match nested routes better\r\n    const nonEndingRE = new RegExp(found[1].replace(/\\$$/, ''), found[2]);\r\n    if (nonEndingRE.test(filter)) {\r\n        // mark children as matches\r\n        route.children.forEach(child => isRouteMatching(child, filter));\r\n        // exception case: `/`\r\n        if (route.record.path !== '/' || filter === '/') {\r\n            route.__vd_match = route.re.test(filter);\r\n            return true;\r\n        }\r\n        // hide the / route\r\n        return false;\r\n    }\r\n    const path = route.record.path.toLowerCase();\r\n    const decodedPath = decode(path);\r\n    // also allow partial matching on the path\r\n    if (!filter.startsWith('/') &&\r\n        (decodedPath.includes(filter) || path.includes(filter)))\r\n        return true;\r\n    if (decodedPath.startsWith(filter) || path.startsWith(filter))\r\n        return true;\r\n    if (route.record.name && String(route.record.name).includes(filter))\r\n        return true;\r\n    return route.children.some(child => isRouteMatching(child, filter));\r\n}\r\nfunction omit(obj, keys) {\r\n    const ret = {};\r\n    for (let key in obj) {\r\n        if (!keys.includes(key)) {\r\n            // @ts-ignore\r\n            ret[key] = obj[key];\r\n        }\r\n    }\r\n    return ret;\r\n}\n\n/**\r\n * Creates a Router instance that can be used by a Vue app.\r\n *\r\n * @param options - {@link RouterOptions}\r\n */\r\nfunction createRouter(options) {\r\n    const matcher = createRouterMatcher(options.routes, options);\r\n    let parseQuery$1 = options.parseQuery || parseQuery;\r\n    let stringifyQuery$1 = options.stringifyQuery || stringifyQuery;\r\n    let routerHistory = options.history;\r\n    if ((process.env.NODE_ENV !== 'production') && !routerHistory)\r\n        throw new Error('Provide the \"history\" option when calling \"createRouter()\":' +\r\n            ' https://next.router.vuejs.org/api/#history.');\r\n    const beforeGuards = useCallbacks();\r\n    const beforeResolveGuards = useCallbacks();\r\n    const afterGuards = useCallbacks();\r\n    const currentRoute = shallowRef(START_LOCATION_NORMALIZED);\r\n    let pendingLocation = START_LOCATION_NORMALIZED;\r\n    // leave the scrollRestoration if no scrollBehavior is provided\r\n    if (isBrowser && options.scrollBehavior && 'scrollRestoration' in history) {\r\n        history.scrollRestoration = 'manual';\r\n    }\r\n    const normalizeParams = applyToParams.bind(null, paramValue => '' + paramValue);\r\n    const encodeParams = applyToParams.bind(null, encodeParam);\r\n    const decodeParams = applyToParams.bind(null, decode);\r\n    function addRoute(parentOrRoute, route) {\r\n        let parent;\r\n        let record;\r\n        if (isRouteName(parentOrRoute)) {\r\n            parent = matcher.getRecordMatcher(parentOrRoute);\r\n            record = route;\r\n        }\r\n        else {\r\n            record = parentOrRoute;\r\n        }\r\n        return matcher.addRoute(record, parent);\r\n    }\r\n    function removeRoute(name) {\r\n        let recordMatcher = matcher.getRecordMatcher(name);\r\n        if (recordMatcher) {\r\n            matcher.removeRoute(recordMatcher);\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production')) {\r\n            warn(`Cannot remove non-existent route \"${String(name)}\"`);\r\n        }\r\n    }\r\n    function getRoutes() {\r\n        return matcher.getRoutes().map(routeMatcher => routeMatcher.record);\r\n    }\r\n    function hasRoute(name) {\r\n        return !!matcher.getRecordMatcher(name);\r\n    }\r\n    function resolve(rawLocation, currentLocation) {\r\n        // const objectLocation = routerLocationAsObject(rawLocation)\r\n        // we create a copy to modify it later\r\n        currentLocation = assign({}, currentLocation || currentRoute.value);\r\n        if (typeof rawLocation === 'string') {\r\n            let locationNormalized = parseURL(parseQuery$1, rawLocation, currentLocation.path);\r\n            let matchedRoute = matcher.resolve({ path: locationNormalized.path }, currentLocation);\r\n            let href = routerHistory.createHref(locationNormalized.fullPath);\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                if (href.startsWith('//'))\r\n                    warn(`Location \"${rawLocation}\" resolved to \"${href}\". A resolved location cannot start with multiple slashes.`);\r\n                else if (!matchedRoute.matched.length) {\r\n                    warn(`No match found for location with path \"${rawLocation}\"`);\r\n                }\r\n            }\r\n            // locationNormalized is always a new object\r\n            return assign(locationNormalized, matchedRoute, {\r\n                params: decodeParams(matchedRoute.params),\r\n                hash: decode(locationNormalized.hash),\r\n                redirectedFrom: undefined,\r\n                href,\r\n            });\r\n        }\r\n        let matcherLocation;\r\n        // path could be relative in object as well\r\n        if ('path' in rawLocation) {\r\n            if ((process.env.NODE_ENV !== 'production') &&\r\n                'params' in rawLocation &&\r\n                !('name' in rawLocation) &&\r\n                Object.keys(rawLocation.params).length) {\r\n                warn(`Path \"${rawLocation.path}\" was passed with params but they will be ignored. Use a named route alongside params instead.`);\r\n            }\r\n            matcherLocation = assign({}, rawLocation, {\r\n                path: parseURL(parseQuery$1, rawLocation.path, currentLocation.path).path,\r\n            });\r\n        }\r\n        else {\r\n            // pass encoded values to the matcher so it can produce encoded path and fullPath\r\n            matcherLocation = assign({}, rawLocation, {\r\n                params: encodeParams(rawLocation.params),\r\n            });\r\n            // current location params are decoded, we need to encode them in case the\r\n            // matcher merges the params\r\n            currentLocation.params = encodeParams(currentLocation.params);\r\n        }\r\n        let matchedRoute = matcher.resolve(matcherLocation, currentLocation);\r\n        const hash = rawLocation.hash || '';\r\n        if ((process.env.NODE_ENV !== 'production') && hash && !hash.startsWith('#')) {\r\n            warn(`A \\`hash\\` should always start with the character \"#\". Replace \"${hash}\" with \"#${hash}\".`);\r\n        }\r\n        // decoding them) the matcher might have merged current location params so\r\n        // we need to run the decoding again\r\n        matchedRoute.params = normalizeParams(decodeParams(matchedRoute.params));\r\n        const fullPath = stringifyURL(stringifyQuery$1, assign({}, rawLocation, {\r\n            hash: encodeHash(hash),\r\n            path: matchedRoute.path,\r\n        }));\r\n        let href = routerHistory.createHref(fullPath);\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            if (href.startsWith('//')) {\r\n                warn(`Location \"${rawLocation}\" resolved to \"${href}\". A resolved location cannot start with multiple slashes.`);\r\n            }\r\n            else if (!matchedRoute.matched.length) {\r\n                warn(`No match found for location with path \"${'path' in rawLocation ? rawLocation.path : rawLocation}\"`);\r\n            }\r\n        }\r\n        return assign({\r\n            fullPath,\r\n            // keep the hash encoded so fullPath is effectively path + encodedQuery +\r\n            // hash\r\n            hash,\r\n            query: \r\n            // if the user is using a custom query lib like qs, we might have\r\n            // nested objects, so we keep the query as is, meaning it can contain\r\n            // numbers at `$route.query`, but at the point, the user will have to\r\n            // use their own type anyway.\r\n            // https://github.com/vuejs/vue-router-next/issues/328#issuecomment-649481567\r\n            stringifyQuery$1 === stringifyQuery\r\n                ? normalizeQuery(rawLocation.query)\r\n                : rawLocation.query,\r\n        }, matchedRoute, {\r\n            redirectedFrom: undefined,\r\n            href,\r\n        });\r\n    }\r\n    function locationAsObject(to) {\r\n        return typeof to === 'string'\r\n            ? parseURL(parseQuery$1, to, currentRoute.value.path)\r\n            : assign({}, to);\r\n    }\r\n    function checkCanceledNavigation(to, from) {\r\n        if (pendingLocation !== to) {\r\n            return createRouterError(8 /* NAVIGATION_CANCELLED */, {\r\n                from,\r\n                to,\r\n            });\r\n        }\r\n    }\r\n    function push(to) {\r\n        return pushWithRedirect(to);\r\n    }\r\n    function replace(to) {\r\n        return push(assign(locationAsObject(to), { replace: true }));\r\n    }\r\n    function handleRedirectRecord(to) {\r\n        const lastMatched = to.matched[to.matched.length - 1];\r\n        if (lastMatched && lastMatched.redirect) {\r\n            const { redirect } = lastMatched;\r\n            let newTargetLocation = typeof redirect === 'function' ? redirect(to) : redirect;\r\n            if (typeof newTargetLocation === 'string') {\r\n                newTargetLocation =\r\n                    newTargetLocation.indexOf('?') > -1 ||\r\n                        newTargetLocation.indexOf('#') > -1\r\n                        ? (newTargetLocation = locationAsObject(newTargetLocation))\r\n                        : { path: newTargetLocation };\r\n            }\r\n            if ((process.env.NODE_ENV !== 'production') &&\r\n                !('path' in newTargetLocation) &&\r\n                !('name' in newTargetLocation)) {\r\n                warn(`Invalid redirect found:\\n${JSON.stringify(newTargetLocation, null, 2)}\\n when navigating to \"${to.fullPath}\". A redirect must contain a name or path. This will break in production.`);\r\n                throw new Error('Invalid redirect');\r\n            }\r\n            return assign({\r\n                query: to.query,\r\n                hash: to.hash,\r\n                params: to.params,\r\n            }, newTargetLocation);\r\n        }\r\n    }\r\n    function pushWithRedirect(to, redirectedFrom) {\r\n        const targetLocation = (pendingLocation = resolve(to));\r\n        const from = currentRoute.value;\r\n        const data = to.state;\r\n        const force = to.force;\r\n        // to could be a string where `replace` is a function\r\n        const replace = to.replace === true;\r\n        const shouldRedirect = handleRedirectRecord(targetLocation);\r\n        if (shouldRedirect)\r\n            return pushWithRedirect(assign(locationAsObject(shouldRedirect), {\r\n                state: data,\r\n                force,\r\n                replace,\r\n            }), \r\n            // keep original redirectedFrom if it exists\r\n            redirectedFrom || targetLocation);\r\n        // if it was a redirect we already called `pushWithRedirect` above\r\n        const toLocation = targetLocation;\r\n        toLocation.redirectedFrom = redirectedFrom;\r\n        let failure;\r\n        if (!force && isSameRouteLocation(stringifyQuery$1, from, targetLocation)) {\r\n            failure = createRouterError(16 /* NAVIGATION_DUPLICATED */, { to: toLocation, from });\r\n            // trigger scroll to allow scrolling to the same anchor\r\n            handleScroll(from, from, \r\n            // this is a push, the only way for it to be triggered from a\r\n            // history.listen is with a redirect, which makes it become a push\r\n            true, \r\n            // This cannot be the first navigation because the initial location\r\n            // cannot be manually navigated to\r\n            false);\r\n        }\r\n        return (failure ? Promise.resolve(failure) : navigate(toLocation, from))\r\n            .catch((error) => isNavigationFailure(error)\r\n            ? error\r\n            : // reject any unknown error\r\n                triggerError(error))\r\n            .then((failure) => {\r\n            if (failure) {\r\n                if (isNavigationFailure(failure, 2 /* NAVIGATION_GUARD_REDIRECT */)) {\r\n                    if ((process.env.NODE_ENV !== 'production') &&\r\n                        // we are redirecting to the same location we were already at\r\n                        isSameRouteLocation(stringifyQuery$1, resolve(failure.to), toLocation) &&\r\n                        // and we have done it a couple of times\r\n                        redirectedFrom &&\r\n                        // @ts-ignore\r\n                        (redirectedFrom._count = redirectedFrom._count\r\n                            ? // @ts-ignore\r\n                                redirectedFrom._count + 1\r\n                            : 1) > 10) {\r\n                        warn(`Detected an infinite redirection in a navigation guard when going from \"${from.fullPath}\" to \"${toLocation.fullPath}\". Aborting to avoid a Stack Overflow. This will break in production if not fixed.`);\r\n                        return Promise.reject(new Error('Infinite redirect in navigation guard'));\r\n                    }\r\n                    return pushWithRedirect(\r\n                    // keep options\r\n                    assign(locationAsObject(failure.to), {\r\n                        state: data,\r\n                        force,\r\n                        replace,\r\n                    }), \r\n                    // preserve the original redirectedFrom if any\r\n                    redirectedFrom || toLocation);\r\n                }\r\n            }\r\n            else {\r\n                // if we fail we don't finalize the navigation\r\n                failure = finalizeNavigation(toLocation, from, true, replace, data);\r\n            }\r\n            triggerAfterEach(toLocation, from, failure);\r\n            return failure;\r\n        });\r\n    }\r\n    /**\r\n     * Helper to reject and skip all navigation guards if a new navigation happened\r\n     * @param to\r\n     * @param from\r\n     */\r\n    function checkCanceledNavigationAndReject(to, from) {\r\n        const error = checkCanceledNavigation(to, from);\r\n        return error ? Promise.reject(error) : Promise.resolve();\r\n    }\r\n    // TODO: refactor the whole before guards by internally using router.beforeEach\r\n    function navigate(to, from) {\r\n        let guards;\r\n        const [leavingRecords, updatingRecords, enteringRecords,] = extractChangingRecords(to, from);\r\n        // all components here have been resolved once because we are leaving\r\n        guards = extractComponentsGuards(leavingRecords.reverse(), 'beforeRouteLeave', to, from);\r\n        // leavingRecords is already reversed\r\n        for (const record of leavingRecords) {\r\n            record.leaveGuards.forEach(guard => {\r\n                guards.push(guardToPromiseFn(guard, to, from));\r\n            });\r\n        }\r\n        const canceledNavigationCheck = checkCanceledNavigationAndReject.bind(null, to, from);\r\n        guards.push(canceledNavigationCheck);\r\n        // run the queue of per route beforeRouteLeave guards\r\n        return (runGuardQueue(guards)\r\n            .then(() => {\r\n            // check global guards beforeEach\r\n            guards = [];\r\n            for (const guard of beforeGuards.list()) {\r\n                guards.push(guardToPromiseFn(guard, to, from));\r\n            }\r\n            guards.push(canceledNavigationCheck);\r\n            return runGuardQueue(guards);\r\n        })\r\n            .then(() => {\r\n            // check in components beforeRouteUpdate\r\n            guards = extractComponentsGuards(updatingRecords, 'beforeRouteUpdate', to, from);\r\n            for (const record of updatingRecords) {\r\n                record.updateGuards.forEach(guard => {\r\n                    guards.push(guardToPromiseFn(guard, to, from));\r\n                });\r\n            }\r\n            guards.push(canceledNavigationCheck);\r\n            // run the queue of per route beforeEnter guards\r\n            return runGuardQueue(guards);\r\n        })\r\n            .then(() => {\r\n            // check the route beforeEnter\r\n            guards = [];\r\n            for (const record of to.matched) {\r\n                // do not trigger beforeEnter on reused views\r\n                if (record.beforeEnter && from.matched.indexOf(record) < 0) {\r\n                    if (Array.isArray(record.beforeEnter)) {\r\n                        for (const beforeEnter of record.beforeEnter)\r\n                            guards.push(guardToPromiseFn(beforeEnter, to, from));\r\n                    }\r\n                    else {\r\n                        guards.push(guardToPromiseFn(record.beforeEnter, to, from));\r\n                    }\r\n                }\r\n            }\r\n            guards.push(canceledNavigationCheck);\r\n            // run the queue of per route beforeEnter guards\r\n            return runGuardQueue(guards);\r\n        })\r\n            .then(() => {\r\n            // NOTE: at this point to.matched is normalized and does not contain any () => Promise<Component>\r\n            // clear existing enterCallbacks, these are added by extractComponentsGuards\r\n            to.matched.forEach(record => (record.enterCallbacks = {}));\r\n            // check in-component beforeRouteEnter\r\n            guards = extractComponentsGuards(enteringRecords, 'beforeRouteEnter', to, from);\r\n            guards.push(canceledNavigationCheck);\r\n            // run the queue of per route beforeEnter guards\r\n            return runGuardQueue(guards);\r\n        })\r\n            .then(() => {\r\n            // check global guards beforeResolve\r\n            guards = [];\r\n            for (const guard of beforeResolveGuards.list()) {\r\n                guards.push(guardToPromiseFn(guard, to, from));\r\n            }\r\n            guards.push(canceledNavigationCheck);\r\n            return runGuardQueue(guards);\r\n        })\r\n            // catch any navigation canceled\r\n            .catch(err => isNavigationFailure(err, 8 /* NAVIGATION_CANCELLED */)\r\n            ? err\r\n            : Promise.reject(err)));\r\n    }\r\n    function triggerAfterEach(to, from, failure) {\r\n        // navigation is confirmed, call afterGuards\r\n        // TODO: wrap with error handlers\r\n        for (const guard of afterGuards.list())\r\n            guard(to, from, failure);\r\n    }\r\n    /**\r\n     * - Cleans up any navigation guards\r\n     * - Changes the url if necessary\r\n     * - Calls the scrollBehavior\r\n     */\r\n    function finalizeNavigation(toLocation, from, isPush, replace, data) {\r\n        // a more recent navigation took place\r\n        const error = checkCanceledNavigation(toLocation, from);\r\n        if (error)\r\n            return error;\r\n        // only consider as push if it's not the first navigation\r\n        const isFirstNavigation = from === START_LOCATION_NORMALIZED;\r\n        const state = !isBrowser ? {} : history.state;\r\n        // change URL only if the user did a push/replace and if it's not the initial navigation because\r\n        // it's just reflecting the url\r\n        if (isPush) {\r\n            // on the initial navigation, we want to reuse the scroll position from\r\n            // history state if it exists\r\n            if (replace || isFirstNavigation)\r\n                routerHistory.replace(toLocation.fullPath, assign({\r\n                    scroll: isFirstNavigation && state && state.scroll,\r\n                }, data));\r\n            else\r\n                routerHistory.push(toLocation.fullPath, data);\r\n        }\r\n        // accept current navigation\r\n        currentRoute.value = toLocation;\r\n        handleScroll(toLocation, from, isPush, isFirstNavigation);\r\n        markAsReady();\r\n    }\r\n    let removeHistoryListener;\r\n    // attach listener to history to trigger navigations\r\n    function setupListeners() {\r\n        removeHistoryListener = routerHistory.listen((to, _from, info) => {\r\n            // cannot be a redirect route because it was in history\r\n            let toLocation = resolve(to);\r\n            // due to dynamic routing, and to hash history with manual navigation\r\n            // (manually changing the url or calling history.hash = '#/somewhere'),\r\n            // there could be a redirect record in history\r\n            const shouldRedirect = handleRedirectRecord(toLocation);\r\n            if (shouldRedirect) {\r\n                pushWithRedirect(assign(shouldRedirect, { replace: true }), toLocation).catch(noop);\r\n                return;\r\n            }\r\n            pendingLocation = toLocation;\r\n            const from = currentRoute.value;\r\n            // TODO: should be moved to web history?\r\n            if (isBrowser) {\r\n                saveScrollPosition(getScrollKey(from.fullPath, info.delta), computeScrollPosition());\r\n            }\r\n            navigate(toLocation, from)\r\n                .catch((error) => {\r\n                if (isNavigationFailure(error, 4 /* NAVIGATION_ABORTED */ | 8 /* NAVIGATION_CANCELLED */)) {\r\n                    return error;\r\n                }\r\n                if (isNavigationFailure(error, 2 /* NAVIGATION_GUARD_REDIRECT */)) {\r\n                    // Here we could call if (info.delta) routerHistory.go(-info.delta,\r\n                    // false) but this is bug prone as we have no way to wait the\r\n                    // navigation to be finished before calling pushWithRedirect. Using\r\n                    // a setTimeout of 16ms seems to work but there is not guarantee for\r\n                    // it to work on every browser. So Instead we do not restore the\r\n                    // history entry and trigger a new navigation as requested by the\r\n                    // navigation guard.\r\n                    // the error is already handled by router.push we just want to avoid\r\n                    // logging the error\r\n                    pushWithRedirect(error.to, toLocation\r\n                    // avoid an uncaught rejection, let push call triggerError\r\n                    ).catch(noop);\r\n                    // avoid the then branch\r\n                    return Promise.reject();\r\n                }\r\n                // do not restore history on unknown direction\r\n                if (info.delta)\r\n                    routerHistory.go(-info.delta, false);\r\n                // unrecognized error, transfer to the global handler\r\n                return triggerError(error);\r\n            })\r\n                .then((failure) => {\r\n                failure =\r\n                    failure ||\r\n                        finalizeNavigation(\r\n                        // after navigation, all matched components are resolved\r\n                        toLocation, from, false);\r\n                // revert the navigation\r\n                if (failure && info.delta)\r\n                    routerHistory.go(-info.delta, false);\r\n                triggerAfterEach(toLocation, from, failure);\r\n            })\r\n                .catch(noop);\r\n        });\r\n    }\r\n    // Initialization and Errors\r\n    let readyHandlers = useCallbacks();\r\n    let errorHandlers = useCallbacks();\r\n    let ready;\r\n    /**\r\n     * Trigger errorHandlers added via onError and throws the error as well\r\n     * @param error - error to throw\r\n     * @returns the error as a rejected promise\r\n     */\r\n    function triggerError(error) {\r\n        markAsReady(error);\r\n        errorHandlers.list().forEach(handler => handler(error));\r\n        return Promise.reject(error);\r\n    }\r\n    function isReady() {\r\n        if (ready && currentRoute.value !== START_LOCATION_NORMALIZED)\r\n            return Promise.resolve();\r\n        return new Promise((resolve, reject) => {\r\n            readyHandlers.add([resolve, reject]);\r\n        });\r\n    }\r\n    /**\r\n     * Mark the router as ready, resolving the promised returned by isReady(). Can\r\n     * only be called once, otherwise does nothing.\r\n     * @param err - optional error\r\n     */\r\n    function markAsReady(err) {\r\n        if (ready)\r\n            return;\r\n        ready = true;\r\n        setupListeners();\r\n        readyHandlers\r\n            .list()\r\n            .forEach(([resolve, reject]) => (err ? reject(err) : resolve()));\r\n        readyHandlers.reset();\r\n    }\r\n    // Scroll behavior\r\n    function handleScroll(to, from, isPush, isFirstNavigation) {\r\n        const { scrollBehavior } = options;\r\n        if (!isBrowser || !scrollBehavior)\r\n            return Promise.resolve();\r\n        let scrollPosition = (!isPush && getSavedScrollPosition(getScrollKey(to.fullPath, 0))) ||\r\n            ((isFirstNavigation || !isPush) &&\r\n                history.state &&\r\n                history.state.scroll) ||\r\n            null;\r\n        return nextTick()\r\n            .then(() => scrollBehavior(to, from, scrollPosition))\r\n            .then(position => position && scrollToPosition(position))\r\n            .catch(triggerError);\r\n    }\r\n    const go = (delta) => routerHistory.go(delta);\r\n    let started;\r\n    const installedApps = new Set();\r\n    const router = {\r\n        currentRoute,\r\n        addRoute,\r\n        removeRoute,\r\n        hasRoute,\r\n        getRoutes,\r\n        resolve,\r\n        options,\r\n        push,\r\n        replace,\r\n        go,\r\n        back: () => go(-1),\r\n        forward: () => go(1),\r\n        beforeEach: beforeGuards.add,\r\n        beforeResolve: beforeResolveGuards.add,\r\n        afterEach: afterGuards.add,\r\n        onError: errorHandlers.add,\r\n        isReady,\r\n        install(app) {\r\n            const router = this;\r\n            app.component('RouterLink', RouterLink);\r\n            app.component('RouterView', RouterView);\r\n            app.config.globalProperties.$router = router;\r\n            Object.defineProperty(app.config.globalProperties, '$route', {\r\n                get: () => unref(currentRoute),\r\n            });\r\n            // this initial navigation is only necessary on client, on server it doesn't\r\n            // make sense because it will create an extra unnecessary navigation and could\r\n            // lead to problems\r\n            if (isBrowser &&\r\n                // used for the initial navigation client side to avoid pushing\r\n                // multiple times when the router is used in multiple apps\r\n                !started &&\r\n                currentRoute.value === START_LOCATION_NORMALIZED) {\r\n                // see above\r\n                started = true;\r\n                push(routerHistory.location).catch(err => {\r\n                    if ((process.env.NODE_ENV !== 'production'))\r\n                        warn('Unexpected error when starting the router:', err);\r\n                });\r\n            }\r\n            const reactiveRoute = {};\r\n            for (let key in START_LOCATION_NORMALIZED) {\r\n                // @ts-ignore: the key matches\r\n                reactiveRoute[key] = computed(() => currentRoute.value[key]);\r\n            }\r\n            app.provide(routerKey, router);\r\n            app.provide(routeLocationKey, reactive(reactiveRoute));\r\n            app.provide(routerViewLocationKey, currentRoute);\r\n            let unmountApp = app.unmount;\r\n            installedApps.add(app);\r\n            app.unmount = function () {\r\n                installedApps.delete(app);\r\n                if (installedApps.size < 1) {\r\n                    removeHistoryListener();\r\n                    currentRoute.value = START_LOCATION_NORMALIZED;\r\n                    started = false;\r\n                    ready = false;\r\n                }\r\n                unmountApp();\r\n            };\r\n            if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) && true) {\r\n                addDevtools(app, router, matcher);\r\n            }\r\n        },\r\n    };\r\n    return router;\r\n}\r\nfunction runGuardQueue(guards) {\r\n    return guards.reduce((promise, guard) => promise.then(() => guard()), Promise.resolve());\r\n}\r\nfunction extractChangingRecords(to, from) {\r\n    const leavingRecords = [];\r\n    const updatingRecords = [];\r\n    const enteringRecords = [];\r\n    const len = Math.max(from.matched.length, to.matched.length);\r\n    for (let i = 0; i < len; i++) {\r\n        const recordFrom = from.matched[i];\r\n        if (recordFrom) {\r\n            if (to.matched.find(record => isSameRouteRecord(record, recordFrom)))\r\n                updatingRecords.push(recordFrom);\r\n            else\r\n                leavingRecords.push(recordFrom);\r\n        }\r\n        const recordTo = to.matched[i];\r\n        if (recordTo) {\r\n            // the type doesn't matter because we are comparing per reference\r\n            if (!from.matched.find(record => isSameRouteRecord(record, recordTo))) {\r\n                enteringRecords.push(recordTo);\r\n            }\r\n        }\r\n    }\r\n    return [leavingRecords, updatingRecords, enteringRecords];\r\n}\n\n/**\r\n * Returns the router instance. Equivalent to using `$router` inside\r\n * templates.\r\n */\r\nfunction useRouter() {\r\n    return inject(routerKey);\r\n}\r\n/**\r\n * Returns the current route location. Equivalent to using `$route` inside\r\n * templates.\r\n */\r\nfunction useRoute() {\r\n    return inject(routeLocationKey);\r\n}\n\nexport { NavigationFailureType, RouterLink, RouterView, START_LOCATION_NORMALIZED as START_LOCATION, createMemoryHistory, createRouter, createRouterMatcher, createWebHashHistory, createWebHistory, isNavigationFailure, matchedRouteKey, onBeforeRouteLeave, onBeforeRouteUpdate, parseQuery, routeLocationKey, routerKey, routerViewLocationKey, stringifyQuery, useLink, useRoute, useRouter, viewDepthKey };\n"],"sourceRoot":""}