{"version":3,"sources":["webpack:///./node_modules/axios/lib/core/Axios.js","webpack:///./node_modules/axios/lib/helpers/spread.js","webpack:///./node_modules/axios/lib/helpers/bind.js","webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/axios/lib/cancel/isCancel.js","webpack:///./node_modules/axios/lib/helpers/buildURL.js","webpack:///./node_modules/axios/lib/helpers/isURLSameOrigin.js","webpack:///./node_modules/@vue/devtools-api/lib/esm/index.js","webpack:///./node_modules/node-libs-browser/mock/process.js","webpack:///./node_modules/axios/lib/helpers/null.js","webpack:///./node_modules/axios/lib/core/settle.js","webpack:///./node_modules/axios/lib/core/mergeConfig.js","webpack:///./node_modules/axios/lib/defaults/index.js","webpack:///./node_modules/axios/lib/core/dispatchRequest.js","webpack:///./node_modules/axios/lib/env/data.js","webpack:///./node_modules/axios/lib/helpers/isAxiosError.js","webpack:///./node_modules/vue-router/dist/vue-router.esm-bundler.js","webpack:///./node_modules/axios/lib/core/AxiosError.js","webpack:///./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js","webpack:///./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js","webpack:///./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js","webpack:///./node_modules/axios/lib/helpers/cookies.js","webpack:///./node_modules/axios/lib/core/buildFullPath.js","webpack:///./node_modules/axios/lib/helpers/validator.js","webpack:///./node_modules/axios/lib/cancel/CancelToken.js","webpack:///./node_modules/ieee754/index.js","webpack:///./node_modules/@vue/shared/dist/shared.esm-bundler.js","webpack:///./node_modules/@vue/devtools-api/lib/esm/env.js","webpack:///./node_modules/axios/lib/adapters/xhr.js","webpack:///./node_modules/buffer/index.js","webpack:///./node_modules/axios/lib/helpers/parseProtocol.js","webpack:///./node_modules/@vue/devtools-api/lib/esm/const.js","webpack:///./node_modules/axios/index.js","webpack:///./node_modules/axios/lib/helpers/parseHeaders.js","webpack:///./node_modules/axios/lib/core/transformData.js","webpack:///./node_modules/axios/lib/utils.js","webpack:///./node_modules/axios/lib/helpers/normalizeHeaderName.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/axios/lib/defaults/transitional.js","webpack:///./node_modules/axios/lib/axios.js","webpack:///./node_modules/axios/lib/helpers/isAbsoluteURL.js","webpack:///./node_modules/path-browserify/index.js","webpack:///./node_modules/isarray/index.js","webpack:///./node_modules/axios/lib/helpers/toFormData.js","webpack:///./node_modules/axios/lib/helpers/combineURLs.js","webpack:///./node_modules/axios/lib/core/InterceptorManager.js","webpack:///./node_modules/axios/lib/cancel/CanceledError.js"],"names":["utils","buildURL","InterceptorManager","dispatchRequest","mergeConfig","buildFullPath","validator","validators","Axios","instanceConfig","this","defaults","interceptors","request","response","prototype","configOrUrl","config","url","method","toLowerCase","transitional","undefined","assertOptions","silentJSONParsing","boolean","forcedJSONParsing","clarifyTimeoutError","requestInterceptorChain","synchronousRequestInterceptors","forEach","interceptor","runWhen","synchronous","unshift","fulfilled","rejected","promise","responseInterceptorChain","push","chain","Array","apply","concat","Promise","resolve","length","then","shift","newConfig","onFulfilled","onRejected","error","reject","getUri","fullPath","baseURL","params","paramsSerializer","data","generateHTTPMethod","isForm","headers","module","exports","callback","arr","fn","thisArg","args","arguments","i","byteLength","toByteArray","fromByteArray","lookup","revLookup","Arr","Uint8Array","code","len","charCodeAt","getLens","b64","Error","validLen","indexOf","placeHoldersLen","lens","_byteLength","tmp","curByte","tripletToBase64","num","encodeChunk","uint8","start","end","output","join","extraBytes","parts","maxChunkLength","len2","value","__CANCEL__","encode","val","encodeURIComponent","replace","serializedParams","isURLSearchParams","toString","key","isArray","v","isDate","toISOString","isObject","JSON","stringify","hashmarkIndex","slice","isStandardBrowserEnv","originURL","msie","test","navigator","userAgent","urlParsingNode","document","createElement","resolveURL","href","setAttribute","protocol","host","search","hash","hostname","port","pathname","charAt","window","location","requestURL","parsed","isString","setupDevtoolsPlugin","pluginDescriptor","setupFn","hook","emit","target","list","__VUE_DEVTOOLS_PLUGINS__","nextTick","call","setTimeout","platform","arch","execPath","title","pid","browser","env","argv","binding","name","path","cwd","chdir","dir","exit","kill","umask","dlopen","uptime","memoryUsage","uvCounters","features","AxiosError","validateStatus","status","ERR_BAD_REQUEST","ERR_BAD_RESPONSE","Math","floor","config1","config2","getMergedValue","source","isPlainObject","merge","mergeDeepProperties","prop","isUndefined","valueFromConfig2","defaultToConfig2","mergeDirectKeys","mergeMap","Object","keys","configValue","normalizeHeaderName","transitionalDefaults","toFormData","DEFAULT_CONTENT_TYPE","setContentTypeIfUnset","getDefaultAdapter","adapter","XMLHttpRequest","process","stringifySafely","rawValue","parser","encoder","parse","trim","e","transformRequest","isFormData","isArrayBuffer","isBuffer","isStream","isFile","isBlob","isArrayBufferView","buffer","isFileList","isObjectPayload","contentType","_FormData","FormData","transformResponse","strictJSONParsing","responseType","from","timeout","xsrfCookieName","xsrfHeaderName","maxContentLength","maxBodyLength","common","transformData","isCancel","CanceledError","throwIfCancellationRequested","cancelToken","throwIfRequested","signal","aborted","reason","payload","isAxiosError","hasSymbol","Symbol","toStringTag","PolySymbol","matchedRouteKey","viewDepthKey","routerKey","routeLocationKey","routerViewLocationKey","isBrowser","isESModule","obj","__esModule","assign","applyToParams","newParams","map","noop","TRAILING_SLASH_RE","removeTrailingSlash","parseURL","parseQuery","currentLocation","query","searchString","searchPos","hashPos","resolveRelativePath","stringifyURL","stringifyQuery","stripBase","base","startsWith","isSameRouteLocation","a","b","aLastIndex","matched","bLastIndex","isSameRouteRecord","isSameRouteLocationParams","aliasOf","isSameRouteLocationParamsValue","isEquivalentArray","every","to","fromSegments","split","toSegments","toPosition","segment","position","NavigationType","NavigationDirection","normalizeBase","baseEl","querySelector","getAttribute","BEFORE_HASH_RE","createHref","getElementPosition","el","offset","docRect","documentElement","getBoundingClientRect","elRect","behavior","left","top","computeScrollPosition","pageXOffset","pageYOffset","scrollToPosition","scrollToOptions","positionEl","isIdSelector","getElementById","style","scrollTo","getScrollKey","delta","history","state","scrollPositions","Map","saveScrollPosition","scrollPosition","set","getSavedScrollPosition","scroll","get","delete","createBaseLocation","createCurrentLocation","slicePos","includes","pathFromHash","useHistoryListeners","historyState","listeners","teardowns","pauseState","popStateHandler","fromState","listener","type","pop","direction","forward","back","unknown","pauseListeners","listen","teardown","index","splice","beforeUnloadListener","replaceState","destroy","removeEventListener","addEventListener","buildState","current","replaced","computeScroll","useHistoryStateNavigation","changeLocation","hashIndex","err","console","currentState","createWebHistory","historyNavigation","historyListeners","go","triggerListeners","routerHistory","bind","defineProperty","enumerable","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","segments","extraOptions","options","score","pattern","segmentScores","tokenIndex","token","subSegmentScore","repeatable","optional","regexp","re","RegExp","message","subPattern","match","avoidDuplicatedSlash","endsWith","param","text","compareScoreArray","diff","comparePathParserScore","aScore","bScore","comp","ROOT_TOKEN","VALID_PARAM_RE","tokenizePath","crash","previousState","tokens","finalizeSegment","char","customRe","consumeBuffer","addCharToBuffer","createRouteRecordMatcher","record","parent","matcher","children","alias","createRouterMatcher","routes","globalOptions","matchers","matcherMap","getRecordMatcher","addRoute","originalRecord","isRootAdd","mainNormalizedRecord","normalizeRouteRecord","mergeOptions","normalizedRecords","aliases","components","originalMatcher","normalizedRecord","parentPath","connectingSlash","isAliasRecord","removeRoute","insertMatcher","matcherRef","getRoutes","paramsFromLocation","filter","k","find","m","parentMatcher","mergeMetaFields","redirect","beforeEnter","props","normalizeRecordProps","instances","leaveGuards","Set","updateGuards","enterCallbacks","default","component","propsObject","reduce","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","currentValue","values","normalizeQuery","normalizedQuery","useCallbacks","handlers","add","handler","reset","guardToPromiseFn","guard","enterCallbackArray","next","valid","guardReturn","guardCall","catch","extractComponentsGuards","guardType","guards","rawComponent","isRouteComponent","__vccOpts","componentPromise","resolved","resolvedComponent","useLink","router","currentRoute","activeRecordIndex","routeMatched","currentMatched","findIndex","parentRecordPath","getOriginalPath","isActive","includesParams","isExactActive","navigate","guardEvent","RouterLinkImpl","String","required","Boolean","activeClass","exactActiveClass","custom","ariaCurrentValue","slots","link","elClass","getLinkClass","linkActiveClass","linkExactActiveClass","onClick","class","RouterLink","metaKey","altKey","ctrlKey","shiftKey","defaultPrevented","button","currentTarget","preventDefault","outer","inner","innerValue","outerValue","some","propClass","globalClass","defaultClass","RouterViewImpl","inheritAttrs","attrs","injectedRoute","routeToDisplay","depth","matchedRouteRef","viewRef","instance","oldInstance","oldName","size","flush","matchedRoute","ViewComponent","currentName","normalizeSlot","Component","routePropsOption","routeProps","onVnodeUnmounted","vnode","isUnmounted","ref","slot","slotContent","RouterView","createRouter","parseQuery$1","stringifyQuery$1","beforeGuards","beforeResolveGuards","afterGuards","pendingLocation","scrollBehavior","scrollRestoration","normalizeParams","paramValue","encodeParams","decodeParams","parentOrRoute","recordMatcher","routeMatcher","hasRoute","rawLocation","locationNormalized","matcherLocation","targetParams","locationAsObject","checkCanceledNavigation","pushWithRedirect","handleRedirectRecord","lastMatched","newTargetLocation","targetLocation","force","shouldRedirect","toLocation","failure","handleScroll","triggerError","finalizeNavigation","triggerAfterEach","checkCanceledNavigationAndReject","leavingRecords","updatingRecords","enteringRecords","extractChangingRecords","reverse","canceledNavigationCheck","runGuardQueue","isPush","isFirstNavigation","markAsReady","removeHistoryListener","setupListeners","_from","info","ready","readyHandlers","errorHandlers","isReady","started","installedApps","beforeEach","beforeResolve","afterEach","onError","app","globalProperties","$router","reactiveRoute","provide","unmountApp","unmount","max","recordFrom","recordTo","inherits","toJSON","description","number","fileName","lineNumber","columnNumber","stack","descriptors","defineProperties","customProps","axiosError","create","toFlatObject","targetMap","WeakMap","effectStack","activeEffect","ITERATE_KEY","MAP_KEY_ITERATE_KEY","isEffect","_isEffect","raw","effect","createReactiveEffect","lazy","stop","active","onStop","uid","enableTracking","resetTracking","id","allowRecurse","deps","shouldTrack","trackStack","pauseTracking","last","track","depsMap","dep","has","trigger","newValue","oldValue","oldTarget","effects","effectsToAdd","run","scheduler","isNonTrackableKeys","builtInSymbols","getOwnPropertyNames","createGetter","shallowGet","readonlyGet","arrayInstrumentations","createArrayInstrumentations","instrumentations","toRaw","l","res","isReadonly","shallow","receiver","shallowReadonlyMap","readonlyMap","shallowReactiveMap","reactiveMap","targetIsArray","Reflect","isRef","shouldUnwrap","readonly","reactive","createSetter","shallowSet","hadKey","Number","result","deleteProperty","ownKeys","mutableHandlers","readonlyHandlers","shallowReactiveHandlers","toReactive","toReadonly","toShallow","getProto","getPrototypeOf","get$1","isShallow","rawTarget","rawKey","wrap","has$1","proto","set$1","deleteEntry","clear","hadItems","createForEach","observed","createIterableMethod","targetIsMap","isPair","iterator","isKeyOnly","innerIterator","done","createReadonlyMethod","createInstrumentations","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","shallowReadonlyInstrumentations","iteratorMethods","createInstrumentationGetter","mutableCollectionHandlers","shallowCollectionHandlers","readonlyCollectionHandlers","targetTypeMap","rawType","getTargetType","isExtensible","createReactiveObject","shallowReactive","baseHandlers","collectionHandlers","proxyMap","existingProxy","targetType","proxy","Proxy","isReactive","isProxy","markRaw","convert","r","__v_isRef","createRef","shallowRef","_shallow","_rawValue","_value","newVal","unref","shallowUnwrapHandlers","proxyRefs","objectWithRefs","ComputedRefImpl","getter","_setter","_dirty","self","getterOrOptions","setter","callWithErrorHandling","handleError","callWithAsyncErrorHandling","throwInDev","contextVNode","cur","exposedInstance","errorInfo","errorCapturedHooks","ec","appErrorHandler","appContext","errorHandler","logError","isFlushing","isFlushPending","queue","flushIndex","pendingPreFlushCbs","activePreFlushCbs","preFlushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","currentFlushPromise","currentPreFlushParentJob","p","findInsertionIndex","job","jobId","getId","middle","middleJobId","queueJob","pos","queueFlush","flushJobs","invalidateJob","queueCb","cb","activeQueue","pendingQueue","queuePreFlushCb","queuePostFlushCb","flushPreFlushCbs","seen","parentJob","flushPostFlushCbs","deduped","sort","Infinity","event","rawArgs","isModelListener","modelArg","modifiersKey","handlerName","onceHandler","emitted","normalizeEmitsOptions","asMixin","cache","emitsCache","cached","emits","normalized","hasExtends","extendEmits","normalizedFromExtend","mixins","extends","isEmitListener","currentRenderingInstance","currentScopeId","setCurrentRenderingInstance","prev","__scopeId","pushScopeId","popScopeId","withScopeId","_id","withCtx","ctx","isNonScopedSlot","_n","renderFnWithContext","_d","setBlockTracking","prevInstance","_c","renderComponentRoot","withProxy","propsOptions","render","renderCache","setupState","fallthroughAttrs","shapeFlag","proxyToUse","normalizeVNode","getFunctionalFallthrough","root","filterModelListeners","cloneVNode","dirs","transition","blockStack","createVNode","Comment$1","shouldUpdateComponent","prevVNode","nextVNode","optimized","prevProps","prevChildren","nextProps","nextChildren","patchFlag","emitsOptions","$stable","hasPropsChanged","dynamicProps","nextKeys","updateHOCHostEl","subTree","isSuspense","__isSuspense","queueEffectWithSuspense","suspense","pendingBranch","currentInstance","provides","parentProvides","inject","defaultValue","treatDefaultAsFactory","INITIAL_WATCHER_VALUE","watch","doWatch","immediate","deep","onTrack","onTrigger","cleanup","forceTrigger","isMultiSource","s","traverse","onInvalidate","baseGetter","runner","queuePostRenderEffect","isMounted","recordInstanceBoundEffect","instanceWatch","publicThis","createPathGetter","useTransitionState","isLeaving","isUnmounting","leavingVNodes","onMounted","onBeforeUnmount","TransitionHookValidator","Function","BaseTransitionImpl","mode","appear","persisted","onBeforeEnter","onEnter","onAfterEnter","onEnterCancelled","onBeforeLeave","onLeave","onAfterLeave","onLeaveCancelled","onBeforeAppear","onAppear","onAfterAppear","onAppearCancelled","getCurrentInstance","prevTransitionKey","getTransitionRawChildren","rawProps","child","emptyPlaceholder","innerChild","getKeepAliveChild","enterHooks","resolveTransitionHooks","setTransitionHooks","oldChild","oldInnerChild","transitionKeyChanged","getTransitionKey","isSameVNodeType","leavingHooks","afterLeave","update","delayLeave","earlyRemove","delayedLeave","leavingVNodesCache","getLeavingNodesForType","_leaveCb","BaseTransition","callHook","hooks","leavingVNode","afterHook","cancelHook","called","_enterCb","cancelled","remove","isKeepAlive","ssContent","clone","ssFallback","keepComment","ret","keyedFragmentCount","Fragment","defineComponent","setup","isAsyncWrapper","__asyncLoader","__isKeepAlive","matches","onActivated","registerKeepAliveHook","onDeactivated","wrappedHook","__wdc","isDeactivated","injectHook","injectToKeepAliveRoot","keepAliveRoot","injected","onUnmounted","resetShapeFlag","getInnerChild","prepend","__weh","setCurrentInstance","createHook","lifecycle","isInSSRComponentSetup","onBeforeMount","onBeforeUpdate","onUpdated","onServerPrefetch","onRenderTriggered","onRenderTracked","onErrorCaptured","shouldCacheAccess","applyOptions","resolveMergedOptions","beforeCreate","dataOptions","computed","computedOptions","methods","watchOptions","provideOptions","injectOptions","created","beforeMount","mounted","beforeUpdate","updated","activated","deactivated","beforeDestroy","beforeUnmount","destroyed","unmounted","renderTracked","renderTriggered","errorCaptured","serverPrefetch","expose","directives","filters","checkDuplicateProperties","resolveInjections","methodHandler","opt","c","configurable","createWatcher","registerLifecycleHook","register","_hook","exposed","normalizeInject","h","extendsOptions","globalMixins","optionsCache","optionMergeStrategies","strats","strat","internalOptionMergeStrats","mergeDataFn","mergeObjectOptions","mergeAsArray","mergeWatchOptions","mergeInject","merged","initProps","isStateful","isSSR","InternalObjectKey","propsDefaults","setFullProps","updateProps","rawPrevProps","rawCurrentProps","hasAttrsChanged","kebabKey","resolvePropValue","propsToUpdate","camelizedKey","needCastKeys","rawCastValues","camelKey","castValues","isAbsent","hasDefault","normalizePropsOptions","propsCache","extendProps","normalizedKey","validatePropName","booleanIndex","getTypeIndex","stringIndex","getType","ctor","isSameType","expectedTypes","t","isInternalKey","normalizeSlotValue","rawSlot","normalizeObjectSlots","rawSlots","_ctx","normalizeVNodeSlots","initSlots","_","updateSlots","needDeletionCheck","deletionComparisonTarget","invokeDirectiveHook","bindings","oldBindings","createAppContext","isNativeTag","performance","warnHandler","compilerOptions","createAppAPI","hydrate","rootComponent","rootProps","context","installedPlugins","_uid","_component","_props","_container","_context","_instance","version","plugin","install","mixin","directive","rootContainer","isHydrate","isSVG","__vue_app__","initFeatureFlags","prodEffectOptions","setRef","rawRef","oldRawRef","parentSuspense","isUnmount","refValue","getExposeProxy","owner","oldRef","refs","doSet","createRenderer","baseCreateRenderer","createHydrationFns","insert","hostInsert","hostRemove","patchProp","hostPatchProp","forcePatchProp","hostForcePatchProp","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","dynamicChildren","getNextHostNode","Text","processText","processCommentNode","Static","mountStaticNode","processFragment","processElement","processComponent","internals","moveStaticNode","removeStaticNode","mountElement","patchElement","vnodeHook","is","mountChildren","unmountChildren","onVnodeBeforeMount","invokeVNodeHook","scopeId","needCallTransitionHooks","onVnodeMounted","enter","parentVNode","cloneIfMounted","oldProps","newProps","onVnodeBeforeUpdate","patchProps","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","hydrateNode","hydrateSubTree","scopedInitialVNode","c1","prevShapeFlag","c2","patchKeyedChildren","patchUnkeyedChildren","oldLength","newLength","commonLength","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","removeFragment","performRemove","bum","um","suspenseId","pendingId","_vnode","mt","mc","pc","pbc","n","o","createApp","ch1","ch2","arrI","isTeleport","__isTeleport","COMPONENTS","resolveComponent","maybeSelfReference","resolveAsset","NULL_DYNAMIC_COMPONENT","warnMissing","selfName","getComponentName","registry","currentBlock","openBlock","disableTracking","closeBlock","isBlockTreeEnabled","createBlock","isVNode","__v_isVNode","normalizeKey","normalizeRef","_createVNode","isBlockNode","cloned","normalizeChildren","isClassComponent","klass","__v_skip","targetAnchor","normalize","extraProps","mergeRef","mergedProps","mergeProps","staticCount","createTextVNode","flag","slotFlag","toMerge","existing","incoming","renderList","renderItem","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","exposeProxy","setupContext","bc","da","rtg","rtc","sp","compile","setupResult","setupStatefulComponent","createSetupContext","unsetInstance","resolvedResult","handleSetupResult","finishComponentSetup","skipOptions","template","isCustomElement","delimiters","componentCompilerOptions","finalCompilerOptions","_rc","displayName","propsOrChildren","svgNS","doc","staticTemplateCache","nodeOps","insertBefore","removeChild","tag","createElementNS","multiple","createTextNode","node","nodeValue","textContent","selector","content","before","previousSibling","lastChild","innerHTML","wrapper","firstChild","appendChild","patchClass","transitionClasses","_vtc","removeAttribute","className","patchStyle","display","cssText","setStyle","importantRE","setProperty","prefixed","autoPrefix","prefixes","prefixCache","rawName","xlinkNS","patchAttr","removeAttributeNS","setAttributeNS","isBoolean","patchDOMProp","tagName","_a","_getNow","Date","now","skipTimestampCheck","createEvent","timeStamp","ffMatch","cachedNow","getNow","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","hasExplicitCallback","baseProps","durations","normalizeDuration","enterDuration","leaveDuration","finishEnter","isAppear","removeTransitionClass","finishLeave","makeEnterHook","nextFrame","addTransitionClass","whenTransitionEnds","forceReflow","NumberOf","cls","classList","requestAnimationFrame","endId","expectedType","explicitTimeout","_endId","resolveIfNotStale","propCount","getTransitionInfo","endEvent","ended","onEnd","styles","getComputedStyle","getStyleProperties","transitionDelays","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationDurations","animationTimeout","hasTransform","delays","d","toMs","body","offsetHeight","rendererOptions","ensureRenderer","mount","containerOrSelector","normalizeContainer","SVGElement","Element","write","expires","domain","secure","cookie","isNumber","toGMTString","read","isAbsoluteURL","combineURLs","requestedURL","VERSION","thing","deprecatedWarnings","schema","allowUnknown","ERR_BAD_OPTION_VALUE","ERR_BAD_OPTION","formatMessage","desc","opts","ERR_DEPRECATED","warn","CancelToken","executor","TypeError","resolvePromise","cancel","_listeners","onfulfilled","_resolve","subscribe","unsubscribe","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","pow","rt","abs","isNaN","log","LN2","makeMap","str","expectsLowerCase","GLOBALS_WHITE_LISTED","isGloballyWhitelisted","specialBooleanAttrs","isSpecialBooleanAttr","normalizeStyle","item","parseStringStyle","listDelimiterRE","propertyDelimiterRE","normalizeClass","HTML_TAGS","SVG_TAGS","isHTMLTag","isSVGTag","looseCompareArrays","equal","looseEqual","aValidType","bValidType","getTime","aKeysCount","bKeysCount","aHasKey","hasOwnProperty","bHasKey","looseIndexOf","toDisplayString","replacer","_key","isMap","entries","isSet","EMPTY_OBJ","EMPTY_ARR","NOOP","NO","onRE","isOn","extend","hasOwn","toTypeString","isFunction","isSymbol","isPromise","objectToString","toRawType","isIntegerKey","parseInt","isReservedProp","cacheStringFunction","hit","camelizeRE","camelize","toUpperCase","hyphenateRE","hyphenate","capitalize","toHandlerKey","hasChanged","invokeArrayFns","fns","arg","def","toNumber","parseFloat","getDevtoolsGlobalHook","getTarget","__VUE_DEVTOOLS_GLOBAL_HOOK__","global","settle","cookies","parseHeaders","isURLSameOrigin","parseProtocol","onCanceled","requestData","requestHeaders","auth","username","password","unescape","Authorization","btoa","onloadend","responseHeaders","getAllResponseHeaders","responseData","responseText","statusText","open","onreadystatechange","readyState","responseURL","onabort","ECONNABORTED","onerror","ERR_NETWORK","ontimeout","timeoutErrorMessage","ETIMEDOUT","xsrfValue","withCredentials","setRequestHeader","onDownloadProgress","onUploadProgress","upload","abort","send","base64","ieee754","typedArraySupport","__proto__","foo","subarray","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","encodingOrOffset","allocUnsafe","ArrayBuffer","fromArrayBuffer","fromString","fromObject","assertSize","alloc","fill","encoding","checked","string","isEncoding","actual","fromArrayLike","array","byteOffset","copy","isnan","SlowBuffer","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","buf","readUInt16BE","foundIndex","found","hexWrite","remaining","strLen","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","decodeCodePointsArray","INSPECT_MAX_BYTES","poolSize","_augment","species","allocUnsafeSlow","_isBuffer","compare","x","y","swap16","swap32","swap64","equals","inspect","thisStart","thisEnd","thisCopy","targetCopy","isFinite","_arr","MAX_ARGUMENTS_LENGTH","codePoints","fromCharCode","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","INVALID_BASE64_RE","base64clean","stringtrim","units","leadSurrogate","byteArray","hi","lo","src","dst","exec","HOOK_SETUP","ignoreDuplicateOf","line","kindOf","kindOfTest","constructor","pipe","product","assignValue","stripBOM","superConstructor","sourceObj","destObj","lastIndex","toArray","isTypedArray","TypedArray","normalizedName","g","createInstance","defaultConfig","axios","Cancel","all","promises","spread","normalizeArray","allowAboveRoot","up","basename","matchedSlash","xs","f","resolvedPath","resolvedAbsolute","isAbsolute","trailingSlash","paths","relative","fromParts","toParts","samePartsLength","outputParts","sep","delimiter","dirname","hasRoot","extname","startDot","startPart","preDotState","formData","convertValue","Blob","build","parentKey","fullKey","append","relativeURL","use","eject","ERR_CANCELED"],"mappings":"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","file":"js/chunk-vendors.d2187e9e.js","sourcesContent":["'use strict';\n\nvar utils = require('./../utils');\nvar buildURL = require('../helpers/buildURL');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar mergeConfig = require('./mergeConfig');\nvar buildFullPath = require('./buildFullPath');\nvar validator = require('../helpers/validator');\n\nvar validators = validator.validators;\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n  this.defaults = instanceConfig;\n  this.interceptors = {\n    request: new InterceptorManager(),\n    response: new InterceptorManager()\n  };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(configOrUrl, config) {\n  /*eslint no-param-reassign:0*/\n  // Allow for axios('example/url'[, config]) a la fetch API\n  if (typeof configOrUrl === 'string') {\n    config = config || {};\n    config.url = configOrUrl;\n  } else {\n    config = configOrUrl || {};\n  }\n\n  config = mergeConfig(this.defaults, config);\n\n  // Set config.method\n  if (config.method) {\n    config.method = config.method.toLowerCase();\n  } else if (this.defaults.method) {\n    config.method = this.defaults.method.toLowerCase();\n  } else {\n    config.method = 'get';\n  }\n\n  var transitional = config.transitional;\n\n  if (transitional !== undefined) {\n    validator.assertOptions(transitional, {\n      silentJSONParsing: validators.transitional(validators.boolean),\n      forcedJSONParsing: validators.transitional(validators.boolean),\n      clarifyTimeoutError: validators.transitional(validators.boolean)\n    }, false);\n  }\n\n  // filter out skipped interceptors\n  var requestInterceptorChain = [];\n  var synchronousRequestInterceptors = true;\n  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n    if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {\n      return;\n    }\n\n    synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;\n\n    requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  var responseInterceptorChain = [];\n  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  var promise;\n\n  if (!synchronousRequestInterceptors) {\n    var chain = [dispatchRequest, undefined];\n\n    Array.prototype.unshift.apply(chain, requestInterceptorChain);\n    chain = chain.concat(responseInterceptorChain);\n\n    promise = Promise.resolve(config);\n    while (chain.length) {\n      promise = promise.then(chain.shift(), chain.shift());\n    }\n\n    return promise;\n  }\n\n\n  var newConfig = config;\n  while (requestInterceptorChain.length) {\n    var onFulfilled = requestInterceptorChain.shift();\n    var onRejected = requestInterceptorChain.shift();\n    try {\n      newConfig = onFulfilled(newConfig);\n    } catch (error) {\n      onRejected(error);\n      break;\n    }\n  }\n\n  try {\n    promise = dispatchRequest(newConfig);\n  } catch (error) {\n    return Promise.reject(error);\n  }\n\n  while (responseInterceptorChain.length) {\n    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());\n  }\n\n  return promise;\n};\n\nAxios.prototype.getUri = function getUri(config) {\n  config = mergeConfig(this.defaults, config);\n  var fullPath = buildFullPath(config.baseURL, config.url);\n  return buildURL(fullPath, config.params, config.paramsSerializer);\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(mergeConfig(config || {}, {\n      method: method,\n      url: url,\n      data: (config || {}).data\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n\n  function generateHTTPMethod(isForm) {\n    return function httpMethod(url, data, config) {\n      return this.request(mergeConfig(config || {}, {\n        method: method,\n        headers: isForm ? {\n          'Content-Type': 'multipart/form-data'\n        } : {},\n        url: url,\n        data: data\n      }));\n    };\n  }\n\n  Axios.prototype[method] = generateHTTPMethod();\n\n  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);\n});\n\nmodule.exports = Axios;\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n};\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n  return function wrap() {\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n    return fn.apply(thisArg, args);\n  };\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+').\n    replace(/%5B/gi, '[').\n    replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n\n  var serializedParams;\n  if (paramsSerializer) {\n    serializedParams = paramsSerializer(params);\n  } else if (utils.isURLSearchParams(params)) {\n    serializedParams = params.toString();\n  } else {\n    var parts = [];\n\n    utils.forEach(params, function serialize(val, key) {\n      if (val === null || typeof val === 'undefined') {\n        return;\n      }\n\n      if (utils.isArray(val)) {\n        key = key + '[]';\n      } else {\n        val = [val];\n      }\n\n      utils.forEach(val, function parseValue(v) {\n        if (utils.isDate(v)) {\n          v = v.toISOString();\n        } else if (utils.isObject(v)) {\n          v = JSON.stringify(v);\n        }\n        parts.push(encode(key) + '=' + encode(v));\n      });\n    });\n\n    serializedParams = parts.join('&');\n  }\n\n  if (serializedParams) {\n    var hashmarkIndex = url.indexOf('#');\n    if (hashmarkIndex !== -1) {\n      url = url.slice(0, hashmarkIndex);\n    }\n\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs have full support of the APIs needed to test\n  // whether the request URL is of the same origin as current location.\n    (function standardBrowserEnv() {\n      var msie = /(msie|trident)/i.test(navigator.userAgent);\n      var urlParsingNode = document.createElement('a');\n      var originURL;\n\n      /**\n    * Parse a URL to discover it's components\n    *\n    * @param {String} url The URL to be parsed\n    * @returns {Object}\n    */\n      function resolveURL(url) {\n        var href = url;\n\n        if (msie) {\n        // IE needs attribute set twice to normalize properties\n          urlParsingNode.setAttribute('href', href);\n          href = urlParsingNode.href;\n        }\n\n        urlParsingNode.setAttribute('href', href);\n\n        // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n        return {\n          href: urlParsingNode.href,\n          protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n          host: urlParsingNode.host,\n          search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n          hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n          hostname: urlParsingNode.hostname,\n          port: urlParsingNode.port,\n          pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n            urlParsingNode.pathname :\n            '/' + urlParsingNode.pathname\n        };\n      }\n\n      originURL = resolveURL(window.location.href);\n\n      /**\n    * Determine if a URL shares the same origin as the current location\n    *\n    * @param {String} requestURL The URL to test\n    * @returns {boolean} True if URL shares the same origin, otherwise false\n    */\n      return function isURLSameOrigin(requestURL) {\n        var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n        return (parsed.protocol === originURL.protocol &&\n            parsed.host === originURL.host);\n      };\n    })() :\n\n  // Non standard browser envs (web workers, react-native) lack needed support.\n    (function nonStandardBrowserEnv() {\n      return function isURLSameOrigin() {\n        return true;\n      };\n    })()\n);\n","import { getTarget, getDevtoolsGlobalHook } from './env';\nimport { HOOK_SETUP } from './const';\nexport * from './api';\nexport function 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","exports.nextTick = function nextTick(fn) {\n    var args = Array.prototype.slice.call(arguments);\n    args.shift();\n    setTimeout(function () {\n        fn.apply(null, args);\n    }, 0);\n};\n\nexports.platform = exports.arch = \nexports.execPath = exports.title = 'browser';\nexports.pid = 1;\nexports.browser = true;\nexports.env = {};\nexports.argv = [];\n\nexports.binding = function (name) {\n\tthrow new Error('No such module. (Possibly not yet loaded)')\n};\n\n(function () {\n    var cwd = '/';\n    var path;\n    exports.cwd = function () { return cwd };\n    exports.chdir = function (dir) {\n        if (!path) path = require('path');\n        cwd = path.resolve(dir, cwd);\n    };\n})();\n\nexports.exit = exports.kill = \nexports.umask = exports.dlopen = \nexports.uptime = exports.memoryUsage = \nexports.uvCounters = function() {};\nexports.features = {};\n","// eslint-disable-next-line strict\nmodule.exports = null;\n","'use strict';\n\nvar AxiosError = require('./AxiosError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n  var validateStatus = response.config.validateStatus;\n  if (!response.status || !validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(new AxiosError(\n      'Request failed with status code ' + response.status,\n      [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],\n      response.config,\n      response.request,\n      response\n    ));\n  }\n};\n","'use strict';\n\nvar utils = require('../utils');\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n * @returns {Object} New object resulting from merging config2 to config1\n */\nmodule.exports = function mergeConfig(config1, config2) {\n  // eslint-disable-next-line no-param-reassign\n  config2 = config2 || {};\n  var config = {};\n\n  function getMergedValue(target, source) {\n    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {\n      return utils.merge(target, source);\n    } else if (utils.isPlainObject(source)) {\n      return utils.merge({}, source);\n    } else if (utils.isArray(source)) {\n      return source.slice();\n    }\n    return source;\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDeepProperties(prop) {\n    if (!utils.isUndefined(config2[prop])) {\n      return getMergedValue(config1[prop], config2[prop]);\n    } else if (!utils.isUndefined(config1[prop])) {\n      return getMergedValue(undefined, config1[prop]);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function valueFromConfig2(prop) {\n    if (!utils.isUndefined(config2[prop])) {\n      return getMergedValue(undefined, config2[prop]);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function defaultToConfig2(prop) {\n    if (!utils.isUndefined(config2[prop])) {\n      return getMergedValue(undefined, config2[prop]);\n    } else if (!utils.isUndefined(config1[prop])) {\n      return getMergedValue(undefined, config1[prop]);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDirectKeys(prop) {\n    if (prop in config2) {\n      return getMergedValue(config1[prop], config2[prop]);\n    } else if (prop in config1) {\n      return getMergedValue(undefined, config1[prop]);\n    }\n  }\n\n  var mergeMap = {\n    'url': valueFromConfig2,\n    'method': valueFromConfig2,\n    'data': valueFromConfig2,\n    'baseURL': defaultToConfig2,\n    'transformRequest': defaultToConfig2,\n    'transformResponse': defaultToConfig2,\n    'paramsSerializer': defaultToConfig2,\n    'timeout': defaultToConfig2,\n    'timeoutMessage': defaultToConfig2,\n    'withCredentials': defaultToConfig2,\n    'adapter': defaultToConfig2,\n    'responseType': defaultToConfig2,\n    'xsrfCookieName': defaultToConfig2,\n    'xsrfHeaderName': defaultToConfig2,\n    'onUploadProgress': defaultToConfig2,\n    'onDownloadProgress': defaultToConfig2,\n    'decompress': defaultToConfig2,\n    'maxContentLength': defaultToConfig2,\n    'maxBodyLength': defaultToConfig2,\n    'beforeRedirect': defaultToConfig2,\n    'transport': defaultToConfig2,\n    'httpAgent': defaultToConfig2,\n    'httpsAgent': defaultToConfig2,\n    'cancelToken': defaultToConfig2,\n    'socketPath': defaultToConfig2,\n    'responseEncoding': defaultToConfig2,\n    'validateStatus': mergeDirectKeys\n  };\n\n  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {\n    var merge = mergeMap[prop] || mergeDeepProperties;\n    var configValue = merge(prop);\n    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);\n  });\n\n  return config;\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar normalizeHeaderName = require('../helpers/normalizeHeaderName');\nvar AxiosError = require('../core/AxiosError');\nvar transitionalDefaults = require('./transitional');\nvar toFormData = require('../helpers/toFormData');\n\nvar DEFAULT_CONTENT_TYPE = {\n  'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n    headers['Content-Type'] = value;\n  }\n}\n\nfunction getDefaultAdapter() {\n  var adapter;\n  if (typeof XMLHttpRequest !== 'undefined') {\n    // For browsers use XHR adapter\n    adapter = require('../adapters/xhr');\n  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {\n    // For node use HTTP adapter\n    adapter = require('../adapters/http');\n  }\n  return adapter;\n}\n\nfunction stringifySafely(rawValue, parser, encoder) {\n  if (utils.isString(rawValue)) {\n    try {\n      (parser || JSON.parse)(rawValue);\n      return utils.trim(rawValue);\n    } catch (e) {\n      if (e.name !== 'SyntaxError') {\n        throw e;\n      }\n    }\n  }\n\n  return (encoder || JSON.stringify)(rawValue);\n}\n\nvar defaults = {\n\n  transitional: transitionalDefaults,\n\n  adapter: getDefaultAdapter(),\n\n  transformRequest: [function transformRequest(data, headers) {\n    normalizeHeaderName(headers, 'Accept');\n    normalizeHeaderName(headers, 'Content-Type');\n\n    if (utils.isFormData(data) ||\n      utils.isArrayBuffer(data) ||\n      utils.isBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n      return data.toString();\n    }\n\n    var isObjectPayload = utils.isObject(data);\n    var contentType = headers && headers['Content-Type'];\n\n    var isFileList;\n\n    if ((isFileList = utils.isFileList(data)) || (isObjectPayload && contentType === 'multipart/form-data')) {\n      var _FormData = this.env && this.env.FormData;\n      return toFormData(isFileList ? {'files[]': data} : data, _FormData && new _FormData());\n    } else if (isObjectPayload || contentType === 'application/json') {\n      setContentTypeIfUnset(headers, 'application/json');\n      return stringifySafely(data);\n    }\n\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    var transitional = this.transitional || defaults.transitional;\n    var silentJSONParsing = transitional && transitional.silentJSONParsing;\n    var forcedJSONParsing = transitional && transitional.forcedJSONParsing;\n    var strictJSONParsing = !silentJSONParsing && this.responseType === 'json';\n\n    if (strictJSONParsing || (forcedJSONParsing && utils.isString(data) && data.length)) {\n      try {\n        return JSON.parse(data);\n      } catch (e) {\n        if (strictJSONParsing) {\n          if (e.name === 'SyntaxError') {\n            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);\n          }\n          throw e;\n        }\n      }\n    }\n\n    return data;\n  }],\n\n  /**\n   * A timeout in milliseconds to abort a request. If set to 0 (default) a\n   * timeout is not created.\n   */\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n  maxBodyLength: -1,\n\n  env: {\n    FormData: require('./env/FormData')\n  },\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  },\n\n  headers: {\n    common: {\n      'Accept': 'application/json, text/plain, */*'\n    }\n  }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n  defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\nvar CanceledError = require('../cancel/CanceledError');\n\n/**\n * Throws a `CanceledError` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n\n  if (config.signal && config.signal.aborted) {\n    throw new CanceledError();\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  // Ensure headers exist\n  config.headers = config.headers || {};\n\n  // Transform request data\n  config.data = transformData.call(\n    config,\n    config.data,\n    config.headers,\n    config.transformRequest\n  );\n\n  // Flatten headers\n  config.headers = utils.merge(\n    config.headers.common || {},\n    config.headers[config.method] || {},\n    config.headers\n  );\n\n  utils.forEach(\n    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n    function cleanHeaderConfig(method) {\n      delete config.headers[method];\n    }\n  );\n\n  var adapter = config.adapter || defaults.adapter;\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData.call(\n      config,\n      response.data,\n      response.headers,\n      config.transformResponse\n    );\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData.call(\n          config,\n          reason.response.data,\n          reason.response.headers,\n          config.transformResponse\n        );\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n};\n","module.exports = {\n  \"version\": \"0.27.2\"\n};","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Determines whether the payload is an error thrown by Axios\n *\n * @param {*} payload The value to test\n * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false\n */\nmodule.exports = function isAxiosError(payload) {\n  return utils.isObject(payload) && (payload.isAxiosError === true);\n};\n","/*!\n  * vue-router v4.0.11\n  * (c) 2021 Eduardo San Martin Morote\n  * @license MIT\n  */\nimport { getCurrentInstance, inject, onUnmounted, onDeactivated, onActivated, computed, unref, watchEffect, defineComponent, reactive, h, provide, ref, watch, shallowRef, nextTick } from 'vue';\nimport { setupDevtoolsPlugin } from '@vue/devtools-api';\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\nconst 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    const 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().startsWith(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    const aLastIndex = a.matched.length - 1;\r\n    const 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 (const 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        const 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                    const 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 bases like #, /#, #/, #!, #!/, /#!/, or even /folder#end\r\n    const hashPos = base.indexOf('#');\r\n    if (hashPos > -1) {\r\n        let slicePos = hash.includes(base.slice(hashPos))\r\n            ? base.slice(hashPos).length\r\n            : 1;\r\n        let pathFromHash = hash.slice(slicePos);\r\n        // prepend the starting slash to hash so the url starts with /#\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    const currentLocation = {\r\n        value: createCurrentLocation(base, location),\r\n    };\r\n    const 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        enumerable: true,\r\n        get: () => historyNavigation.location.value,\r\n    });\r\n    Object.defineProperty(routerHistory, 'state', {\r\n        enumerable: true,\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 (const 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        // TODO: should be kept in queue\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            queue = [START];\r\n            position = 0;\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        enumerable: true,\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.includes('#'))\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    // keep full error messages in cjs versions\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    const 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 *\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 *\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        const isRootAdd = !originalRecord;\r\n        const 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            const { 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                const parentPath = parent.record.path;\r\n                const 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                const 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            const 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    const newParams = {};\r\n    for (const 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 (const 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    const options = {};\r\n    for (const key in defaults) {\r\n        options[key] = 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 (const 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 (const 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 (const 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. If `text` is `null` or `undefined`, returns an empty\r\n * string instead.\r\n *\r\n * @param text - string to encode\r\n * @returns encoded string\r\n */\r\nfunction encodeParam(text) {\r\n    return text == null ? '' : 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        const eqPos = searchParam.indexOf('=');\r\n        const key = decode(eqPos < 0 ? searchParam : searchParam.slice(0, eqPos));\r\n        const 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        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 += (search.length ? '&' : '') + key;\r\n            }\r\n            continue;\r\n        }\r\n        // keep null values\r\n        const values = Array.isArray(value)\r\n            ? value.map(v => v && encodeQueryValue(v))\r\n            : [value && encodeQueryValue(value)];\r\n        values.forEach(value => {\r\n            // skip undefined values in arrays as if they were not present\r\n            // smaller code than using filter\r\n            if (value !== undefined) {\r\n                // only append & with non-empty search\r\n                search += (search.length ? '&' : '') + key;\r\n                if (value != null)\r\n                    search += '=' + value;\r\n            }\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 (const key in query) {\r\n        const 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, \r\n    // to avoid warning\r\n    {}).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, \r\n    // to avoid warning\r\n    {}).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-expect-error: _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-expect-error: _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-expect-error: 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                    const 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                const 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                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                    const 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 *\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        const { matched } = route.value;\r\n        const { length } = matched;\r\n        const routeMatched = matched[length - 1];\r\n        const currentMatched = currentRoute.matched;\r\n        if (!routeMatched || !currentMatched.length)\r\n            return -1;\r\n        const index = currentMatched.findIndex(isSameRouteRecord.bind(null, routeMatched));\r\n        if (index > -1)\r\n            return index;\r\n        // possible parent record\r\n        const 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            // avoid uncaught errors are they are logged anyway\r\n            ).catch(noop);\r\n        }\r\n        return Promise.resolve();\r\n    }\r\n    // devtools only\r\n    if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) && isBrowser) {\r\n        const instance = getCurrentInstance();\r\n        if (instance) {\r\n            const linkContextDevtools = {\r\n                route: route.value,\r\n                isActive: isActive.value,\r\n                isExactActive: isExactActive.value,\r\n            };\r\n            // @ts-expect-error: this is internal\r\n            instance.__vrl_devtools = instance.__vrl_devtools || [];\r\n            // @ts-expect-error: this is internal\r\n            instance.__vrl_devtools.push(linkContextDevtools);\r\n            watchEffect(() => {\r\n                linkContextDevtools.route = route.value;\r\n                linkContextDevtools.isActive = isActive.value;\r\n                linkContextDevtools.isExactActive = isExactActive.value;\r\n            }, { flush: 'post' });\r\n        }\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    useLink,\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        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-expect-error getAttribute does exist\r\n    if (e.currentTarget && e.currentTarget.getAttribute) {\r\n        // @ts-expect-error 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 (const key in inner) {\r\n        const innerValue = inner[key];\r\n        const 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 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 multiple useLink are used\r\n            if (Array.isArray(componentInstance.__vrl_devtools)) {\r\n                componentInstance.__devtoolsApi = api;\r\n                componentInstance.__vrl_devtools.forEach(devtoolsData => {\r\n                    let backgroundColor = ORANGE_400;\r\n                    let tooltip = '';\r\n                    if (devtoolsData.isExactActive) {\r\n                        backgroundColor = LIME_500;\r\n                        tooltip = 'This is exactly active';\r\n                    }\r\n                    else if (devtoolsData.isActive) {\r\n                        backgroundColor = BLUE_600;\r\n                        tooltip = 'This link is active';\r\n                    }\r\n                    node.tags.push({\r\n                        label: devtoolsData.route.path,\r\n                        textColor: 0,\r\n                        tooltip,\r\n                        backgroundColor,\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            api.sendInspectorState(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, to) => {\r\n            api.addTimelineEvent({\r\n                layerId: navigationsLayerId,\r\n                event: {\r\n                    title: 'Error during Navigation',\r\n                    subtitle: to.fullPath,\r\n                    logType: 'error',\r\n                    time: Date.now(),\r\n                    data: { error },\r\n                    groupId: to.meta.__navigationId,\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                    subtitle: to.fullPath,\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                    subtitle: to.fullPath,\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 = record.__vd_id;\r\n    if (id == null) {\r\n        id = String(routeRecordId++);\r\n        record.__vd_id = id;\r\n    }\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 (const key in obj) {\r\n        if (!keys.includes(key)) {\r\n            // @ts-expect-error\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    const parseQuery$1 = options.parseQuery || parseQuery;\r\n    const stringifyQuery$1 = options.stringifyQuery || stringifyQuery;\r\n    const 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 = \r\n    // @ts-expect-error: intentionally avoid the type check\r\n    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        const 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            const locationNormalized = parseURL(parseQuery$1, rawLocation, currentLocation.path);\r\n            const matchedRoute = matcher.resolve({ path: locationNormalized.path }, currentLocation);\r\n            const 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            // remove any nullish param\r\n            const targetParams = assign({}, rawLocation.params);\r\n            for (const key in targetParams) {\r\n                if (targetParams[key] == null) {\r\n                    delete targetParams[key];\r\n                }\r\n            }\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        const 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        const 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.includes('?') || newTargetLocation.includes('#')\r\n                        ? (newTargetLocation = locationAsObject(newTargetLocation))\r\n                        : // force empty params\r\n                            { path: newTargetLocation };\r\n                // @ts-expect-error: force empty params when a string is passed to let\r\n                // the router parse them again\r\n                newTargetLocation.params = {};\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, toLocation, from))\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-expect-error: added only in dev\r\n                        (redirectedFrom._count = redirectedFrom._count\r\n                            ? // @ts-expect-error\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.includes(record)) {\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            const 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                    )\r\n                        .then(failure => {\r\n                        // manual change in hash history #916 ending up in the URL not\r\n                        // changing but it was changed by the manual url change, so we\r\n                        // need to manually change it ourselves\r\n                        if (isNavigationFailure(failure, 4 /* NAVIGATION_ABORTED */ |\r\n                            16 /* NAVIGATION_DUPLICATED */) &&\r\n                            !info.delta &&\r\n                            info.type === NavigationType.pop) {\r\n                            routerHistory.go(-1, false);\r\n                        }\r\n                    })\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, toLocation, from);\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) {\r\n                    if (info.delta) {\r\n                        routerHistory.go(-info.delta, false);\r\n                    }\r\n                    else if (info.type === NavigationType.pop &&\r\n                        isNavigationFailure(failure, 4 /* NAVIGATION_ABORTED */ | 16 /* NAVIGATION_DUPLICATED */)) {\r\n                        // manual change in hash history #916\r\n                        // it's like a push but lacks the information of the direction\r\n                        routerHistory.go(-1, false);\r\n                    }\r\n                }\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     *\r\n     * @param error - error to throw\r\n     * @param to - location we were navigating to when the error happened\r\n     * @param from - location we were navigating from when the error happened\r\n     * @returns the error as a rejected promise\r\n     */\r\n    function triggerError(error, to, from) {\r\n        markAsReady(error);\r\n        const list = errorHandlers.list();\r\n        if (list.length) {\r\n            list.forEach(handler => handler(error, to, from));\r\n        }\r\n        else {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                warn('uncaught error during route navigation:');\r\n            }\r\n            console.error(error);\r\n        }\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        const 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(err => triggerError(err, to, from));\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                enumerable: true,\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 (const key in START_LOCATION_NORMALIZED) {\r\n                // @ts-expect-error: 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            const unmountApp = app.unmount;\r\n            installedApps.add(app);\r\n            app.unmount = function () {\r\n                installedApps.delete(app);\r\n                // the router is not attached to an app anymore\r\n                if (installedApps.size < 1) {\r\n                    // invalidate the current navigation\r\n                    pendingLocation = START_LOCATION_NORMALIZED;\r\n                    removeHistoryListener && 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__) && isBrowser) {\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","'use strict';\n\nvar utils = require('../utils');\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [config] The config.\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nfunction AxiosError(message, code, config, request, response) {\n  Error.call(this);\n  this.message = message;\n  this.name = 'AxiosError';\n  code && (this.code = code);\n  config && (this.config = config);\n  request && (this.request = request);\n  response && (this.response = response);\n}\n\nutils.inherits(AxiosError, Error, {\n  toJSON: function toJSON() {\n    return {\n      // Standard\n      message: this.message,\n      name: this.name,\n      // Microsoft\n      description: this.description,\n      number: this.number,\n      // Mozilla\n      fileName: this.fileName,\n      lineNumber: this.lineNumber,\n      columnNumber: this.columnNumber,\n      stack: this.stack,\n      // Axios\n      config: this.config,\n      code: this.code,\n      status: this.response && this.response.status ? this.response.status : null\n    };\n  }\n});\n\nvar prototype = AxiosError.prototype;\nvar descriptors = {};\n\n[\n  'ERR_BAD_OPTION_VALUE',\n  'ERR_BAD_OPTION',\n  'ECONNABORTED',\n  'ETIMEDOUT',\n  'ERR_NETWORK',\n  'ERR_FR_TOO_MANY_REDIRECTS',\n  'ERR_DEPRECATED',\n  'ERR_BAD_RESPONSE',\n  'ERR_BAD_REQUEST',\n  'ERR_CANCELED'\n// eslint-disable-next-line func-names\n].forEach(function(code) {\n  descriptors[code] = {value: code};\n});\n\nObject.defineProperties(AxiosError, descriptors);\nObject.defineProperty(prototype, 'isAxiosError', {value: true});\n\n// eslint-disable-next-line func-names\nAxiosError.from = function(error, code, config, request, response, customProps) {\n  var axiosError = Object.create(prototype);\n\n  utils.toFlatObject(error, axiosError, function filter(obj) {\n    return obj !== Error.prototype;\n  });\n\n  AxiosError.call(axiosError, error.message, code, config, request, response);\n\n  axiosError.name = error.name;\n\n  customProps && Object.assign(axiosError, customProps);\n\n  return axiosError;\n};\n\nmodule.exports = AxiosError;\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 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 = /*#__PURE__*/ createArrayInstrumentations();\r\nfunction createArrayInstrumentations() {\r\n    const instrumentations = {};\r\n    ['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n        instrumentations[key] = function (...args) {\r\n            const arr = toRaw(this);\r\n            for (let i = 0, l = this.length; i < l; i++) {\r\n                track(arr, \"get\" /* GET */, i + '');\r\n            }\r\n            // we run the method using the original args first (which may be reactive)\r\n            const res = arr[key](...args);\r\n            if (res === -1 || res === false) {\r\n                // if that didn't work, run it again using raw values.\r\n                return arr[key](...args.map(toRaw));\r\n            }\r\n            else {\r\n                return res;\r\n            }\r\n        };\r\n    });\r\n    ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {\r\n        instrumentations[key] = function (...args) {\r\n            pauseTracking();\r\n            const res = toRaw(this)[key].apply(this, args);\r\n            resetTracking();\r\n            return res;\r\n        };\r\n    });\r\n    return instrumentations;\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) ? builtInSymbols.has(key) : 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 = /*#__PURE__*/ 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 = /*#__PURE__*/ 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    else if (target !== rawTarget) {\r\n        // #3602 readonly(reactive(Map))\r\n        // ensure that the nested reactive `Map` can do tracking for itself\r\n        target.get(key);\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\nfunction createInstrumentations() {\r\n    const 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\n    const 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\n    const 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\n    const 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\n    const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\n    iteratorMethods.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\n    return [\r\n        mutableInstrumentations,\r\n        readonlyInstrumentations,\r\n        shallowInstrumentations,\r\n        shallowReadonlyInstrumentations\r\n    ];\r\n}\r\nconst [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();\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: /*#__PURE__*/ createInstrumentationGetter(false, false)\r\n};\r\nconst shallowCollectionHandlers = {\r\n    get: /*#__PURE__*/ createInstrumentationGetter(false, true)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n    get: /*#__PURE__*/ createInstrumentationGetter(true, false)\r\n};\r\nconst shallowReadonlyCollectionHandlers = {\r\n    get: /*#__PURE__*/ 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(value, _shallow = false) {\r\n        this._shallow = _shallow;\r\n        this.__v_isRef = true;\r\n        this._rawValue = _shallow ? value : toRaw(value);\r\n        this._value = _shallow ? value : convert(value);\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        newVal = this._shallow ? newVal : toRaw(newVal);\r\n        if (hasChanged(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, isReactive, effect, stop, ref, reactive, shallowReactive, trigger, isProxy, shallowReadonly, track, markRaw, proxyRefs, 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 as isFunction$1, isPromise as isPromise$1, isArray, extend, hasOwn, EMPTY_OBJ, toHandlerKey, toNumber, hyphenate, camelize, isOn, isModelListener, remove, NOOP, hasChanged, isObject as isObject$1, isSet, isMap, isPlainObject, invokeArrayFns, def, isReservedProp, EMPTY_ARR, capitalize, toRawType, makeMap, 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$1(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    [\"sp\" /* SERVER_PREFETCH */]: 'serverPrefetch hook',\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$1(fn)) {\r\n        const res = callWithErrorHandling(fn, instance, type, args);\r\n        if (res && isPromise$1(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                continue;\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                continue;\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 && job.active !== false) {\r\n                if ((process.env.NODE_ENV !== 'production') && checkRecursiveUpdates(seen, job)) {\r\n                    continue;\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 ||\r\n            pendingPreFlushCbs.length ||\r\n            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            const instance = fn.ownerInstance;\r\n            const componentName = instance && getComponentName(instance.type);\r\n            warn(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. ` +\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            return true;\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 !== '__file' && !(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: Comment$1,\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\nconst devtoolsPerfStart = /*#__PURE__*/ createDevtoolsPerformanceHook(\"perf:start\" /* PERFORMANCE_START */);\r\nconst devtoolsPerfEnd = /*#__PURE__*/ createDevtoolsPerformanceHook(\"perf:end\" /* PERFORMANCE_END */);\r\nfunction createDevtoolsPerformanceHook(hook) {\r\n    return (component, type, time) => {\r\n        if (!devtools)\r\n            return;\r\n        devtools.emit(hook, component.appContext.app, component.uid, component, type, time);\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\nconst deprecationData = {\r\n    [\"GLOBAL_MOUNT\" /* GLOBAL_MOUNT */]: {\r\n        message: `The global app bootstrapping API has changed: vm.$mount() and the \"el\" ` +\r\n            `option have been removed. Use createApp(RootComponent).mount() instead.`,\r\n        link: `https://v3.vuejs.org/guide/migration/global-api.html#mounting-app-instance`\r\n    },\r\n    [\"GLOBAL_MOUNT_CONTAINER\" /* GLOBAL_MOUNT_CONTAINER */]: {\r\n        message: `Vue detected directives on the mount container. ` +\r\n            `In Vue 3, the container is no longer considered part of the template ` +\r\n            `and will not be processed/replaced.`,\r\n        link: `https://v3.vuejs.org/guide/migration/mount-changes.html`\r\n    },\r\n    [\"GLOBAL_EXTEND\" /* GLOBAL_EXTEND */]: {\r\n        message: `Vue.extend() has been removed in Vue 3. ` +\r\n            `Use defineComponent() instead.`,\r\n        link: `https://v3.vuejs.org/api/global-api.html#definecomponent`\r\n    },\r\n    [\"GLOBAL_PROTOTYPE\" /* GLOBAL_PROTOTYPE */]: {\r\n        message: `Vue.prototype is no longer available in Vue 3. ` +\r\n            `Use app.config.globalProperties instead.`,\r\n        link: `https://v3.vuejs.org/guide/migration/global-api.html#vue-prototype-replaced-by-config-globalproperties`\r\n    },\r\n    [\"GLOBAL_SET\" /* GLOBAL_SET */]: {\r\n        message: `Vue.set() has been removed as it is no longer needed in Vue 3. ` +\r\n            `Simply use native JavaScript mutations.`\r\n    },\r\n    [\"GLOBAL_DELETE\" /* GLOBAL_DELETE */]: {\r\n        message: `Vue.delete() has been removed as it is no longer needed in Vue 3. ` +\r\n            `Simply use native JavaScript mutations.`\r\n    },\r\n    [\"GLOBAL_OBSERVABLE\" /* GLOBAL_OBSERVABLE */]: {\r\n        message: `Vue.observable() has been removed. ` +\r\n            `Use \\`import { reactive } from \"vue\"\\` from Composition API instead.`,\r\n        link: `https://v3.vuejs.org/api/basic-reactivity.html`\r\n    },\r\n    [\"GLOBAL_PRIVATE_UTIL\" /* GLOBAL_PRIVATE_UTIL */]: {\r\n        message: `Vue.util has been removed. Please refactor to avoid its usage ` +\r\n            `since it was an internal API even in Vue 2.`\r\n    },\r\n    [\"CONFIG_SILENT\" /* CONFIG_SILENT */]: {\r\n        message: `config.silent has been removed because it is not good practice to ` +\r\n            `intentionally suppress warnings. You can use your browser console's ` +\r\n            `filter features to focus on relevant messages.`\r\n    },\r\n    [\"CONFIG_DEVTOOLS\" /* CONFIG_DEVTOOLS */]: {\r\n        message: `config.devtools has been removed. To enable devtools for ` +\r\n            `production, configure the __VUE_PROD_DEVTOOLS__ compile-time flag.`,\r\n        link: `https://github.com/vuejs/vue-next/tree/master/packages/vue#bundler-build-feature-flags`\r\n    },\r\n    [\"CONFIG_KEY_CODES\" /* CONFIG_KEY_CODES */]: {\r\n        message: `config.keyCodes has been removed. ` +\r\n            `In Vue 3, you can directly use the kebab-case key names as v-on modifiers.`,\r\n        link: `https://v3.vuejs.org/guide/migration/keycode-modifiers.html`\r\n    },\r\n    [\"CONFIG_PRODUCTION_TIP\" /* CONFIG_PRODUCTION_TIP */]: {\r\n        message: `config.productionTip has been removed.`,\r\n        link: `https://v3.vuejs.org/guide/migration/global-api.html#config-productiontip-removed`\r\n    },\r\n    [\"CONFIG_IGNORED_ELEMENTS\" /* CONFIG_IGNORED_ELEMENTS */]: {\r\n        message: () => {\r\n            let msg = `config.ignoredElements has been removed.`;\r\n            if (isRuntimeOnly()) {\r\n                msg += ` Pass the \"isCustomElement\" option to @vue/compiler-dom instead.`;\r\n            }\r\n            else {\r\n                msg += ` Use config.isCustomElement instead.`;\r\n            }\r\n            return msg;\r\n        },\r\n        link: `https://v3.vuejs.org/guide/migration/global-api.html#config-ignoredelements-is-now-config-iscustomelement`\r\n    },\r\n    [\"CONFIG_WHITESPACE\" /* CONFIG_WHITESPACE */]: {\r\n        // this warning is only relevant in the full build when using runtime\r\n        // compilation, so it's put in the runtime compatConfig list.\r\n        message: `Vue 3 compiler's whitespace option will default to \"condense\" instead of ` +\r\n            `\"preserve\". To suppress this warning, provide an explicit value for ` +\r\n            `\\`config.compilerOptions.whitespace\\`.`\r\n    },\r\n    [\"CONFIG_OPTION_MERGE_STRATS\" /* CONFIG_OPTION_MERGE_STRATS */]: {\r\n        message: `config.optionMergeStrategies no longer exposes internal strategies. ` +\r\n            `Use custom merge functions instead.`\r\n    },\r\n    [\"INSTANCE_SET\" /* INSTANCE_SET */]: {\r\n        message: `vm.$set() has been removed as it is no longer needed in Vue 3. ` +\r\n            `Simply use native JavaScript mutations.`\r\n    },\r\n    [\"INSTANCE_DELETE\" /* INSTANCE_DELETE */]: {\r\n        message: `vm.$delete() has been removed as it is no longer needed in Vue 3. ` +\r\n            `Simply use native JavaScript mutations.`\r\n    },\r\n    [\"INSTANCE_DESTROY\" /* INSTANCE_DESTROY */]: {\r\n        message: `vm.$destroy() has been removed. Use app.unmount() instead.`,\r\n        link: `https://v3.vuejs.org/api/application-api.html#unmount`\r\n    },\r\n    [\"INSTANCE_EVENT_EMITTER\" /* INSTANCE_EVENT_EMITTER */]: {\r\n        message: `vm.$on/$once/$off() have been removed. ` +\r\n            `Use an external event emitter library instead.`,\r\n        link: `https://v3.vuejs.org/guide/migration/events-api.html`\r\n    },\r\n    [\"INSTANCE_EVENT_HOOKS\" /* INSTANCE_EVENT_HOOKS */]: {\r\n        message: event => `\"${event}\" lifecycle events are no longer supported. From templates, ` +\r\n            `use the \"vnode\" prefix instead of \"hook:\". For example, @${event} ` +\r\n            `should be changed to @vnode-${event.slice(5)}. ` +\r\n            `From JavaScript, use Composition API to dynamically register lifecycle ` +\r\n            `hooks.`,\r\n        link: `https://v3.vuejs.org/guide/migration/vnode-lifecycle-events.html`\r\n    },\r\n    [\"INSTANCE_CHILDREN\" /* INSTANCE_CHILDREN */]: {\r\n        message: `vm.$children has been removed. Consider refactoring your logic ` +\r\n            `to avoid relying on direct access to child components.`,\r\n        link: `https://v3.vuejs.org/guide/migration/children.html`\r\n    },\r\n    [\"INSTANCE_LISTENERS\" /* INSTANCE_LISTENERS */]: {\r\n        message: `vm.$listeners has been removed. In Vue 3, parent v-on listeners are ` +\r\n            `included in vm.$attrs and it is no longer necessary to separately use ` +\r\n            `v-on=\"$listeners\" if you are already using v-bind=\"$attrs\". ` +\r\n            `(Note: the Vue 3 behavior only applies if this compat config is disabled)`,\r\n        link: `https://v3.vuejs.org/guide/migration/listeners-removed.html`\r\n    },\r\n    [\"INSTANCE_SCOPED_SLOTS\" /* INSTANCE_SCOPED_SLOTS */]: {\r\n        message: `vm.$scopedSlots has been removed. Use vm.$slots instead.`,\r\n        link: `https://v3.vuejs.org/guide/migration/slots-unification.html`\r\n    },\r\n    [\"INSTANCE_ATTRS_CLASS_STYLE\" /* INSTANCE_ATTRS_CLASS_STYLE */]: {\r\n        message: componentName => `Component <${componentName ||\r\n            'Anonymous'}> has \\`inheritAttrs: false\\` but is ` +\r\n            `relying on class/style fallthrough from parent. In Vue 3, class/style ` +\r\n            `are now included in $attrs and will no longer fallthrough when ` +\r\n            `inheritAttrs is false. If you are already using v-bind=\"$attrs\" on ` +\r\n            `component root it should render the same end result. ` +\r\n            `If you are binding $attrs to a non-root element and expecting ` +\r\n            `class/style to fallthrough on root, you will need to now manually bind ` +\r\n            `them on root via :class=\"$attrs.class\".`,\r\n        link: `https://v3.vuejs.org/guide/migration/attrs-includes-class-style.html`\r\n    },\r\n    [\"OPTIONS_DATA_FN\" /* OPTIONS_DATA_FN */]: {\r\n        message: `The \"data\" option can no longer be a plain object. ` +\r\n            `Always use a function.`,\r\n        link: `https://v3.vuejs.org/guide/migration/data-option.html`\r\n    },\r\n    [\"OPTIONS_DATA_MERGE\" /* OPTIONS_DATA_MERGE */]: {\r\n        message: (key) => `Detected conflicting key \"${key}\" when merging data option values. ` +\r\n            `In Vue 3, data keys are merged shallowly and will override one another.`,\r\n        link: `https://v3.vuejs.org/guide/migration/data-option.html#mixin-merge-behavior-change`\r\n    },\r\n    [\"OPTIONS_BEFORE_DESTROY\" /* OPTIONS_BEFORE_DESTROY */]: {\r\n        message: `\\`beforeDestroy\\` has been renamed to \\`beforeUnmount\\`.`\r\n    },\r\n    [\"OPTIONS_DESTROYED\" /* OPTIONS_DESTROYED */]: {\r\n        message: `\\`destroyed\\` has been renamed to \\`unmounted\\`.`\r\n    },\r\n    [\"WATCH_ARRAY\" /* WATCH_ARRAY */]: {\r\n        message: `\"watch\" option or vm.$watch on an array value will no longer ` +\r\n            `trigger on array mutation unless the \"deep\" option is specified. ` +\r\n            `If current usage is intended, you can disable the compat behavior and ` +\r\n            `suppress this warning with:` +\r\n            `\\n\\n  configureCompat({ ${\"WATCH_ARRAY\" /* WATCH_ARRAY */}: false })\\n`,\r\n        link: `https://v3.vuejs.org/guide/migration/watch.html`\r\n    },\r\n    [\"PROPS_DEFAULT_THIS\" /* PROPS_DEFAULT_THIS */]: {\r\n        message: (key) => `props default value function no longer has access to \"this\". The compat ` +\r\n            `build only offers access to this.$options.` +\r\n            `(found in prop \"${key}\")`,\r\n        link: `https://v3.vuejs.org/guide/migration/props-default-this.html`\r\n    },\r\n    [\"CUSTOM_DIR\" /* CUSTOM_DIR */]: {\r\n        message: (legacyHook, newHook) => `Custom directive hook \"${legacyHook}\" has been removed. ` +\r\n            `Use \"${newHook}\" instead.`,\r\n        link: `https://v3.vuejs.org/guide/migration/custom-directives.html`\r\n    },\r\n    [\"V_FOR_REF\" /* V_FOR_REF */]: {\r\n        message: `Ref usage on v-for no longer creates array ref values in Vue 3. ` +\r\n            `Consider using function refs or refactor to avoid ref usage altogether.`,\r\n        link: `https://v3.vuejs.org/guide/migration/array-refs.html`\r\n    },\r\n    [\"V_ON_KEYCODE_MODIFIER\" /* V_ON_KEYCODE_MODIFIER */]: {\r\n        message: `Using keyCode as v-on modifier is no longer supported. ` +\r\n            `Use kebab-case key name modifiers instead.`,\r\n        link: `https://v3.vuejs.org/guide/migration/keycode-modifiers.html`\r\n    },\r\n    [\"ATTR_FALSE_VALUE\" /* ATTR_FALSE_VALUE */]: {\r\n        message: (name) => `Attribute \"${name}\" with v-bind value \\`false\\` will render ` +\r\n            `${name}=\"false\" instead of removing it in Vue 3. To remove the attribute, ` +\r\n            `use \\`null\\` or \\`undefined\\` instead. If the usage is intended, ` +\r\n            `you can disable the compat behavior and suppress this warning with:` +\r\n            `\\n\\n  configureCompat({ ${\"ATTR_FALSE_VALUE\" /* ATTR_FALSE_VALUE */}: false })\\n`,\r\n        link: `https://v3.vuejs.org/guide/migration/attribute-coercion.html`\r\n    },\r\n    [\"ATTR_ENUMERATED_COERCION\" /* ATTR_ENUMERATED_COERCION */]: {\r\n        message: (name, value, coerced) => `Enumerated attribute \"${name}\" with v-bind value \\`${value}\\` will ` +\r\n            `${value === null ? `be removed` : `render the value as-is`} instead of coercing the value to \"${coerced}\" in Vue 3. ` +\r\n            `Always use explicit \"true\" or \"false\" values for enumerated attributes. ` +\r\n            `If the usage is intended, ` +\r\n            `you can disable the compat behavior and suppress this warning with:` +\r\n            `\\n\\n  configureCompat({ ${\"ATTR_ENUMERATED_COERCION\" /* ATTR_ENUMERATED_COERCION */}: false })\\n`,\r\n        link: `https://v3.vuejs.org/guide/migration/attribute-coercion.html`\r\n    },\r\n    [\"TRANSITION_CLASSES\" /* TRANSITION_CLASSES */]: {\r\n        message: `` // this feature cannot be runtime-detected\r\n    },\r\n    [\"TRANSITION_GROUP_ROOT\" /* TRANSITION_GROUP_ROOT */]: {\r\n        message: `<TransitionGroup> no longer renders a root <span> element by ` +\r\n            `default if no \"tag\" prop is specified. If you do not rely on the span ` +\r\n            `for styling, you can disable the compat behavior and suppress this ` +\r\n            `warning with:` +\r\n            `\\n\\n  configureCompat({ ${\"TRANSITION_GROUP_ROOT\" /* TRANSITION_GROUP_ROOT */}: false })\\n`,\r\n        link: `https://v3.vuejs.org/guide/migration/transition-group.html`\r\n    },\r\n    [\"COMPONENT_ASYNC\" /* COMPONENT_ASYNC */]: {\r\n        message: (comp) => {\r\n            const name = getComponentName(comp);\r\n            return (`Async component${name ? ` <${name}>` : `s`} should be explicitly created via \\`defineAsyncComponent()\\` ` +\r\n                `in Vue 3. Plain functions will be treated as functional components in ` +\r\n                `non-compat build. If you have already migrated all async component ` +\r\n                `usage and intend to use plain functions for functional components, ` +\r\n                `you can disable the compat behavior and suppress this ` +\r\n                `warning with:` +\r\n                `\\n\\n  configureCompat({ ${\"COMPONENT_ASYNC\" /* COMPONENT_ASYNC */}: false })\\n`);\r\n        },\r\n        link: `https://v3.vuejs.org/guide/migration/async-components.html`\r\n    },\r\n    [\"COMPONENT_FUNCTIONAL\" /* COMPONENT_FUNCTIONAL */]: {\r\n        message: (comp) => {\r\n            const name = getComponentName(comp);\r\n            return (`Functional component${name ? ` <${name}>` : `s`} should be defined as a plain function in Vue 3. The \"functional\" ` +\r\n                `option has been removed. NOTE: Before migrating to use plain ` +\r\n                `functions for functional components, first make sure that all async ` +\r\n                `components usage have been migrated and its compat behavior has ` +\r\n                `been disabled.`);\r\n        },\r\n        link: `https://v3.vuejs.org/guide/migration/functional-components.html`\r\n    },\r\n    [\"COMPONENT_V_MODEL\" /* COMPONENT_V_MODEL */]: {\r\n        message: (comp) => {\r\n            const configMsg = `opt-in to ` +\r\n                `Vue 3 behavior on a per-component basis with \\`compatConfig: { ${\"COMPONENT_V_MODEL\" /* COMPONENT_V_MODEL */}: false }\\`.`;\r\n            if (comp.props &&\r\n                (isArray(comp.props)\r\n                    ? comp.props.includes('modelValue')\r\n                    : hasOwn(comp.props, 'modelValue'))) {\r\n                return (`Component delcares \"modelValue\" prop, which is Vue 3 usage, but ` +\r\n                    `is running under Vue 2 compat v-model behavior. You can ${configMsg}`);\r\n            }\r\n            return (`v-model usage on component has changed in Vue 3. Component that expects ` +\r\n                `to work with v-model should now use the \"modelValue\" prop and emit the ` +\r\n                `\"update:modelValue\" event. You can update the usage and then ${configMsg}`);\r\n        },\r\n        link: `https://v3.vuejs.org/guide/migration/v-model.html`\r\n    },\r\n    [\"RENDER_FUNCTION\" /* RENDER_FUNCTION */]: {\r\n        message: `Vue 3's render function API has changed. ` +\r\n            `You can opt-in to the new API with:` +\r\n            `\\n\\n  configureCompat({ ${\"RENDER_FUNCTION\" /* RENDER_FUNCTION */}: false })\\n` +\r\n            `\\n  (This can also be done per-component via the \"compatConfig\" option.)`,\r\n        link: `https://v3.vuejs.org/guide/migration/render-function-api.html`\r\n    },\r\n    [\"FILTERS\" /* FILTERS */]: {\r\n        message: `filters have been removed in Vue 3. ` +\r\n            `The \"|\" symbol will be treated as native JavaScript bitwise OR operator. ` +\r\n            `Use method calls or computed properties instead.`,\r\n        link: `https://v3.vuejs.org/guide/migration/filters.html`\r\n    },\r\n    [\"PRIVATE_APIS\" /* PRIVATE_APIS */]: {\r\n        message: name => `\"${name}\" is a Vue 2 private API that no longer exists in Vue 3. ` +\r\n            `If you are seeing this warning only due to a dependency, you can ` +\r\n            `suppress this warning via { PRIVATE_APIS: 'supress-warning' }.`\r\n    }\r\n};\r\nconst instanceWarned = Object.create(null);\r\nconst warnCount = Object.create(null);\r\nfunction warnDeprecation(key, instance, ...args) {\r\n    if (!(process.env.NODE_ENV !== 'production')) {\r\n        return;\r\n    }\r\n    instance = instance || getCurrentInstance();\r\n    // check user config\r\n    const config = getCompatConfigForKey(key, instance);\r\n    if (config === 'suppress-warning') {\r\n        return;\r\n    }\r\n    const dupKey = key + args.join('');\r\n    let compId = instance && formatComponentName(instance, instance.type);\r\n    if (compId === 'Anonymous' && instance) {\r\n        compId = instance.uid;\r\n    }\r\n    // skip if the same warning is emitted for the same component type\r\n    const componentDupKey = dupKey + compId;\r\n    if (componentDupKey in instanceWarned) {\r\n        return;\r\n    }\r\n    instanceWarned[componentDupKey] = true;\r\n    // same warning, but different component. skip the long message and just\r\n    // log the key and count.\r\n    if (dupKey in warnCount) {\r\n        warn(`(deprecation ${key}) (${++warnCount[dupKey] + 1})`);\r\n        return;\r\n    }\r\n    warnCount[dupKey] = 0;\r\n    const { message, link } = deprecationData[key];\r\n    warn(`(deprecation ${key}) ${typeof message === 'function' ? message(...args) : message}${link ? `\\n  Details: ${link}` : ``}`);\r\n    if (!isCompatEnabled(key, instance, true)) {\r\n        console.error(`^ The above deprecation's compat behavior is disabled and will likely ` +\r\n            `lead to runtime errors.`);\r\n    }\r\n}\r\nconst globalCompatConfig = {\r\n    MODE: 2\r\n};\r\nfunction getCompatConfigForKey(key, instance) {\r\n    const instanceConfig = instance && instance.type.compatConfig;\r\n    if (instanceConfig && key in instanceConfig) {\r\n        return instanceConfig[key];\r\n    }\r\n    return globalCompatConfig[key];\r\n}\r\nfunction isCompatEnabled(key, instance, enableForBuiltIn = false) {\r\n    // skip compat for built-in components\r\n    if (!enableForBuiltIn && instance && instance.type.__isBuiltIn) {\r\n        return false;\r\n    }\r\n    const rawMode = getCompatConfigForKey('MODE', instance) || 2;\r\n    const val = getCompatConfigForKey(key, instance);\r\n    const mode = isFunction$1(rawMode)\r\n        ? rawMode(instance && instance.type)\r\n        : rawMode;\r\n    if (mode === 2) {\r\n        return val !== false;\r\n    }\r\n    else {\r\n        return val === true || val === 'suppress-warning';\r\n    }\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                !(false )) {\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$1(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 = {};\r\n        }\r\n        else if (instance.emitted[handlerName]) {\r\n            return;\r\n        }\r\n        instance.emitted[handlerName] = true;\r\n        callWithAsyncErrorHandling(onceHandler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);\r\n    }\r\n}\r\nfunction normalizeEmitsOptions(comp, appContext, asMixin = false) {\r\n    const cache = appContext.emitsCache;\r\n    const cached = cache.get(comp);\r\n    if (cached !== undefined) {\r\n        return cached;\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$1(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        cache.set(comp, null);\r\n        return 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    cache.set(comp, normalized);\r\n    return 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\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, isNonScopedSlot // false only\r\n) {\r\n    if (!ctx)\r\n        return fn;\r\n    // already normalized\r\n    if (fn._n) {\r\n        return fn;\r\n    }\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 disable block tracking and\r\n        // force bail out when invoking a compiled slot (indicated by the ._d flag).\r\n        // This isn't necessary if rendering a compiled `<slot>`, so we flip the\r\n        // ._d flag off when invoking the wrapped fn inside `renderSlot`.\r\n        if (renderFnWithContext._d) {\r\n            setBlockTracking(-1);\r\n        }\r\n        const prevInstance = setCurrentRenderingInstance(ctx);\r\n        const res = fn(...args);\r\n        setCurrentRenderingInstance(prevInstance);\r\n        if (renderFnWithContext._d) {\r\n            setBlockTracking(1);\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n            devtoolsComponentUpdated(ctx);\r\n        }\r\n        return res;\r\n    };\r\n    // mark normalized to avoid duplicated wrapping\r\n    renderFnWithContext._n = true;\r\n    // mark this as compiled by default\r\n    // this is used in vnode.ts -> normalizeChildren() to set the slot\r\n    // rendering flag.\r\n    renderFnWithContext._c = true;\r\n    // disable block tracking by default\r\n    renderFnWithContext._d = 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, inheritAttrs } = 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 (fallthroughAttrs && inheritAttrs !== false) {\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$1) {\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        if (false &&\r\n            isCompatEnabled(\"INSTANCE_ATTRS_CLASS_STYLE\" /* INSTANCE_ATTRS_CLASS_STYLE */, instance) &&\r\n            vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */ &&\r\n            (root.shapeFlag & 1 /* ELEMENT */ ||\r\n                root.shapeFlag & 6 /* COMPONENT */)) ;\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$1);\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$1 || 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$1 // 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    normalize: normalizeSuspenseChildren\r\n};\r\n// Force-casted public typing for h and TSX props inference\r\nconst Suspense = (SuspenseImpl\r\n    );\r\nfunction triggerEvent(vnode, name) {\r\n    const eventListener = vnode.props && vnode.props[name];\r\n    if (isFunction$1(eventListener)) {\r\n        eventListener();\r\n    }\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        // invoke @fallback event\r\n        triggerEvent(vnode, 'onPending');\r\n        triggerEvent(vnode, 'onFallback');\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            triggerEvent(n2, 'onPending');\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            triggerEvent(vnode, 'onResolve');\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            triggerEvent(vnode, 'onFallback');\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            suspense.isInFallback = true;\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            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    const isSlotChildren = shapeFlag & 32 /* SLOTS_CHILDREN */;\r\n    vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children);\r\n    vnode.ssFallback = isSlotChildren\r\n        ? normalizeSuspenseSlot(children.fallback)\r\n        : createVNode(Comment);\r\n}\r\nfunction normalizeSuspenseSlot(s) {\r\n    let block;\r\n    if (isFunction$1(s)) {\r\n        const isCompiledSlot = s._c;\r\n        if (isCompiledSlot) {\r\n            // disableTracking: false\r\n            // allow block tracking for compiled slots\r\n            // (see ./componentRenderContext.ts)\r\n            s._d = false;\r\n            openBlock();\r\n        }\r\n        s = s();\r\n        if (isCompiledSlot) {\r\n            s._d = true;\r\n            block = currentBlock;\r\n            closeBlock();\r\n        }\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    s = normalizeVNode(s);\r\n    if (block) {\r\n        s.dynamicChildren = block.filter(c => c !== s);\r\n    }\r\n    return 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 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$1(defaultValue)\r\n                ? defaultValue.call(instance.proxy)\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\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$1(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    let isMultiSource = 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        isMultiSource = true;\r\n        forceTrigger = source.some(isReactive);\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$1(s)) {\r\n                return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n            }\r\n            else {\r\n                (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n            }\r\n        });\r\n    }\r\n    else if (isFunction$1(source)) {\r\n        if (cb) {\r\n            // getter with cb\r\n            getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n        }\r\n        else {\r\n            // no cb -> simple effect\r\n            getter = () => {\r\n                if (instance && instance.isUnmounted) {\r\n                    return;\r\n                }\r\n                if (cleanup) {\r\n                    cleanup();\r\n                }\r\n                return 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 = isMultiSource ? [] : 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 ||\r\n                forceTrigger ||\r\n                (isMultiSource\r\n                    ? newValue.some((v, i) => hasChanged(v, oldValue[i]))\r\n                    : hasChanged(newValue, oldValue)) ||\r\n                (false  )) {\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; // the scheduler function gets called directly\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, value, options) {\r\n    const publicThis = this.proxy;\r\n    const getter = isString(source)\r\n        ? source.includes('.')\r\n            ? createPathGetter(publicThis, source)\r\n            : () => publicThis[source]\r\n        : source.bind(publicThis, publicThis);\r\n    let cb;\r\n    if (isFunction$1(value)) {\r\n        cb = value;\r\n    }\r\n    else {\r\n        cb = value.handler;\r\n        options = value;\r\n    }\r\n    return doWatch(getter, cb.bind(publicThis), options, this);\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 traverse(value, seen = new Set()) {\r\n    if (!isObject$1(value) || value[\"__v_skip\" /* SKIP */]) {\r\n        return value;\r\n    }\r\n    seen = seen || new Set();\r\n    if (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 if (isPlainObject(value)) {\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$1 &&\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$1) {\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$1) {\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\n// implementation, close to no-op\r\nfunction defineComponent(options) {\r\n    return isFunction$1(options) ? { setup: options, name: options.name } : options;\r\n}\n\nconst isAsyncWrapper = (i) => !!i.type.__asyncLoader;\r\nfunction defineAsyncComponent(source) {\r\n    if (isFunction$1(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$1(comp) && !isFunction$1(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        name: 'AsyncComponentWrapper',\r\n        __asyncLoader: load,\r\n        get __asyncResolved() {\r\n            return resolvedComp;\r\n        },\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                if (instance.parent && isKeepAlive(instance.parent.vnode)) {\r\n                    // parent is keep-alive, force update so the loaded component's\r\n                    // name is taken into account\r\n                    queueJob(instance.parent.update);\r\n                }\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 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        if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n            instance.__v_cache = cache;\r\n        }\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            if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n                // Update components tree\r\n                devtoolsComponentAdded(instance);\r\n            }\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            if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n                // Update components tree\r\n                devtoolsComponentAdded(instance);\r\n            }\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            // for async components, name check should be based in its loaded\r\n            // inner component if available\r\n            const name = getComponentName(isAsyncWrapper(vnode)\r\n                ? vnode.type.__asyncResolved || {}\r\n                : 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\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 (except for serverPrefetch)\r\n(!isInSSRComponentSetup || lifecycle === \"sp\" /* SERVER_PREFETCH */) &&\r\n    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 onServerPrefetch = createHook(\"sp\" /* SERVER_PREFETCH */);\r\nconst onRenderTriggered = createHook(\"rtg\" /* RENDER_TRIGGERED */);\r\nconst onRenderTracked = createHook(\"rtc\" /* RENDER_TRACKED */);\r\nfunction onErrorCaptured(hook, target = currentInstance) {\r\n    injectHook(\"ec\" /* ERROR_CAPTURED */, hook, target);\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) {\r\n    const options = resolveMergedOptions(instance);\r\n    const publicThis = instance.proxy;\r\n    const ctx = instance.ctx;\r\n    // do not cache property access on public proxy during state initialization\r\n    shouldCacheAccess = false;\r\n    // call beforeCreate first before accessing other options since\r\n    // the hook may mutate resolved options (#2791)\r\n    if (options.beforeCreate) {\r\n        callHook(options.beforeCreate, instance, \"bc\" /* BEFORE_CREATE */);\r\n    }\r\n    const { \r\n    // state\r\n    data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, \r\n    // lifecycle\r\n    created, beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeDestroy, beforeUnmount, destroyed, unmounted, render, renderTracked, renderTriggered, errorCaptured, serverPrefetch, \r\n    // public API\r\n    expose, inheritAttrs, \r\n    // assets\r\n    components, directives, filters } = options;\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        resolveInjections(injectOptions, ctx, checkDuplicateProperties);\r\n    }\r\n    if (methods) {\r\n        for (const key in methods) {\r\n            const methodHandler = methods[key];\r\n            if (isFunction$1(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 (dataOptions) {\r\n        if ((process.env.NODE_ENV !== 'production') && !isFunction$1(dataOptions)) {\r\n            warn(`The data option must be a function. ` +\r\n                `Plain object usage is no longer supported.`);\r\n        }\r\n        const data = dataOptions.call(publicThis, publicThis);\r\n        if ((process.env.NODE_ENV !== 'production') && isPromise$1(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$1(data)) {\r\n            (process.env.NODE_ENV !== 'production') && warn(`data() should return an object.`);\r\n        }\r\n        else {\r\n            instance.data = reactive(data);\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                for (const key in data) {\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: () => data[key],\r\n                            set: NOOP\r\n                        });\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    // state initialization complete at this point - start caching access\r\n    shouldCacheAccess = true;\r\n    if (computedOptions) {\r\n        for (const key in computedOptions) {\r\n            const opt = computedOptions[key];\r\n            const get = isFunction$1(opt)\r\n                ? opt.bind(publicThis, publicThis)\r\n                : isFunction$1(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$1(opt) && isFunction$1(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        for (const key in watchOptions) {\r\n            createWatcher(watchOptions[key], ctx, publicThis, key);\r\n        }\r\n    }\r\n    if (provideOptions) {\r\n        const provides = isFunction$1(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    if (created) {\r\n        callHook(created, instance, \"c\" /* CREATED */);\r\n    }\r\n    function registerLifecycleHook(register, hook) {\r\n        if (isArray(hook)) {\r\n            hook.forEach(_hook => register(_hook.bind(publicThis)));\r\n        }\r\n        else if (hook) {\r\n            register(hook.bind(publicThis));\r\n        }\r\n    }\r\n    registerLifecycleHook(onBeforeMount, beforeMount);\r\n    registerLifecycleHook(onMounted, mounted);\r\n    registerLifecycleHook(onBeforeUpdate, beforeUpdate);\r\n    registerLifecycleHook(onUpdated, updated);\r\n    registerLifecycleHook(onActivated, activated);\r\n    registerLifecycleHook(onDeactivated, deactivated);\r\n    registerLifecycleHook(onErrorCaptured, errorCaptured);\r\n    registerLifecycleHook(onRenderTracked, renderTracked);\r\n    registerLifecycleHook(onRenderTriggered, renderTriggered);\r\n    registerLifecycleHook(onBeforeUnmount, beforeUnmount);\r\n    registerLifecycleHook(onUnmounted, unmounted);\r\n    registerLifecycleHook(onServerPrefetch, serverPrefetch);\r\n    if (isArray(expose)) {\r\n        if (expose.length) {\r\n            const exposed = instance.exposed || (instance.exposed = {});\r\n            expose.forEach(key => {\r\n                Object.defineProperty(exposed, key, {\r\n                    get: () => publicThis[key],\r\n                    set: val => (publicThis[key] = val)\r\n                });\r\n            });\r\n        }\r\n        else if (!instance.exposed) {\r\n            instance.exposed = {};\r\n        }\r\n    }\r\n    // options that are handled when creating the instance but also need to be\r\n    // applied from mixins\r\n    if (render && instance.render === NOOP) {\r\n        instance.render = render;\r\n    }\r\n    if (inheritAttrs != null) {\r\n        instance.inheritAttrs = inheritAttrs;\r\n    }\r\n    // asset options.\r\n    if (components)\r\n        instance.components = components;\r\n    if (directives)\r\n        instance.directives = directives;\r\n}\r\nfunction resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {\r\n    if (isArray(injectOptions)) {\r\n        injectOptions = normalizeInject(injectOptions);\r\n    }\r\n    for (const key in injectOptions) {\r\n        const opt = injectOptions[key];\r\n        if (isObject$1(opt)) {\r\n            if ('default' in 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.from || key);\r\n            }\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\nfunction callHook(hook, instance, type) {\r\n    callWithAsyncErrorHandling(isArray(hook)\r\n        ? hook.map(h => h.bind(instance.proxy))\r\n        : hook.bind(instance.proxy), instance, type);\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$1(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$1(raw)) {\r\n        watch(getter, raw.bind(publicThis));\r\n    }\r\n    else if (isObject$1(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$1(raw.handler)\r\n                ? raw.handler.bind(publicThis)\r\n                : ctx[raw.handler];\r\n            if (isFunction$1(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\n/**\r\n * Resolve merged options and cache it on the component.\r\n * This is done only once per-component since the merging does not involve\r\n * instances.\r\n */\r\nfunction resolveMergedOptions(instance) {\r\n    const base = instance.type;\r\n    const { mixins, extends: extendsOptions } = base;\r\n    const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance.appContext;\r\n    const cached = cache.get(base);\r\n    let resolved;\r\n    if (cached) {\r\n        resolved = cached;\r\n    }\r\n    else if (!globalMixins.length && !mixins && !extendsOptions) {\r\n        {\r\n            resolved = base;\r\n        }\r\n    }\r\n    else {\r\n        resolved = {};\r\n        if (globalMixins.length) {\r\n            globalMixins.forEach(m => mergeOptions(resolved, m, optionMergeStrategies, true));\r\n        }\r\n        mergeOptions(resolved, base, optionMergeStrategies);\r\n    }\r\n    cache.set(base, resolved);\r\n    return resolved;\r\n}\r\nfunction mergeOptions(to, from, strats, asMixin = false) {\r\n    const { mixins, extends: extendsOptions } = from;\r\n    if (extendsOptions) {\r\n        mergeOptions(to, extendsOptions, strats, true);\r\n    }\r\n    if (mixins) {\r\n        mixins.forEach((m) => mergeOptions(to, m, strats, true));\r\n    }\r\n    for (const key in from) {\r\n        if (asMixin && key === 'expose') {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`\"expose\" option is ignored when declared in mixins or extends. ` +\r\n                    `It should only be declared in the base component itself.`);\r\n        }\r\n        else {\r\n            const strat = internalOptionMergeStrats[key] || (strats && strats[key]);\r\n            to[key] = strat ? strat(to[key], from[key]) : from[key];\r\n        }\r\n    }\r\n    return to;\r\n}\r\nconst internalOptionMergeStrats = {\r\n    data: mergeDataFn,\r\n    props: mergeObjectOptions,\r\n    emits: mergeObjectOptions,\r\n    // objects\r\n    methods: mergeObjectOptions,\r\n    computed: mergeObjectOptions,\r\n    // lifecycle\r\n    beforeCreate: mergeAsArray,\r\n    created: mergeAsArray,\r\n    beforeMount: mergeAsArray,\r\n    mounted: mergeAsArray,\r\n    beforeUpdate: mergeAsArray,\r\n    updated: mergeAsArray,\r\n    beforeDestroy: mergeAsArray,\r\n    destroyed: mergeAsArray,\r\n    activated: mergeAsArray,\r\n    deactivated: mergeAsArray,\r\n    errorCaptured: mergeAsArray,\r\n    serverPrefetch: mergeAsArray,\r\n    // assets\r\n    components: mergeObjectOptions,\r\n    directives: mergeObjectOptions,\r\n    // watch\r\n    watch: mergeWatchOptions,\r\n    // provide / inject\r\n    provide: mergeDataFn,\r\n    inject: mergeInject\r\n};\r\nfunction mergeDataFn(to, from) {\r\n    if (!from) {\r\n        return to;\r\n    }\r\n    if (!to) {\r\n        return from;\r\n    }\r\n    return function mergedDataFn() {\r\n        return (extend)(isFunction$1(to) ? to.call(this, this) : to, isFunction$1(from) ? from.call(this, this) : from);\r\n    };\r\n}\r\nfunction mergeInject(to, from) {\r\n    return mergeObjectOptions(normalizeInject(to), normalizeInject(from));\r\n}\r\nfunction normalizeInject(raw) {\r\n    if (isArray(raw)) {\r\n        const res = {};\r\n        for (let i = 0; i < raw.length; i++) {\r\n            res[raw[i]] = raw[i];\r\n        }\r\n        return res;\r\n    }\r\n    return raw;\r\n}\r\nfunction mergeAsArray(to, from) {\r\n    return to ? [...new Set([].concat(to, from))] : from;\r\n}\r\nfunction mergeObjectOptions(to, from) {\r\n    return to ? extend(extend(Object.create(null), to), from) : from;\r\n}\r\nfunction mergeWatchOptions(to, from) {\r\n    if (!to)\r\n        return from;\r\n    if (!from)\r\n        return to;\r\n    const merged = extend(Object.create(null), to);\r\n    for (const key in from) {\r\n        merged[key] = mergeAsArray(to[key], from[key]);\r\n    }\r\n    return merged;\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    // ensure all declared prop keys are present\r\n    for (const key in instance.propsOptions[0]) {\r\n        if (!(key in props)) {\r\n            props[key] = undefined;\r\n        }\r\n    }\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    let hasAttrsChanged = false;\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                let 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                        if (value !== attrs[key]) {\r\n                            attrs[key] = value;\r\n                            hasAttrsChanged = true;\r\n                        }\r\n                    }\r\n                    else {\r\n                        const camelizedKey = camelize(key);\r\n                        props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false /* isAbsent */);\r\n                    }\r\n                }\r\n                else {\r\n                    if (value !== attrs[key]) {\r\n                        attrs[key] = value;\r\n                        hasAttrsChanged = true;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        // full props update.\r\n        if (setFullProps(instance, rawProps, props, attrs)) {\r\n            hasAttrsChanged = true;\r\n        }\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, rawCurrentProps, key, undefined, instance, true /* isAbsent */);\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                    hasAttrsChanged = true;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    // trigger updates for $attrs in case it's used in component slots\r\n    if (hasAttrsChanged) {\r\n        trigger(instance, \"set\" /* SET */, '$attrs');\r\n    }\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    let hasAttrsChanged = false;\r\n    let rawCastValues;\r\n    if (rawProps) {\r\n        for (let key in rawProps) {\r\n            // key, ref are reserved and never passed down\r\n            if (isReservedProp(key)) {\r\n                continue;\r\n            }\r\n            const value = rawProps[key];\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                if (!needCastKeys || !needCastKeys.includes(camelKey)) {\r\n                    props[camelKey] = value;\r\n                }\r\n                else {\r\n                    (rawCastValues || (rawCastValues = {}))[camelKey] = value;\r\n                }\r\n            }\r\n            else if (!isEmitListener(instance.emitsOptions, key)) {\r\n                if (value !== attrs[key]) {\r\n                    attrs[key] = value;\r\n                    hasAttrsChanged = true;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    if (needCastKeys) {\r\n        const rawCurrentProps = toRaw(props);\r\n        const castValues = rawCastValues || EMPTY_OBJ;\r\n        for (let i = 0; i < needCastKeys.length; i++) {\r\n            const key = needCastKeys[i];\r\n            props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn(castValues, key));\r\n        }\r\n    }\r\n    return hasAttrsChanged;\r\n}\r\nfunction resolvePropValue(options, props, key, value, instance, isAbsent) {\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$1(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.call(null, 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 (isAbsent && !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    const cache = appContext.propsCache;\r\n    const cached = cache.get(comp);\r\n    if (cached) {\r\n        return cached;\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$1(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        cache.set(comp, EMPTY_ARR);\r\n        return 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$1(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$1(opt) ? { type: opt } : opt);\r\n                if (prop) {\r\n                    const booleanIndex = getTypeIndex(Boolean, prop.type);\r\n                    const stringIndex = getTypeIndex(String, prop.type);\r\n                    prop[0 /* shouldCast */] = booleanIndex > -1;\r\n                    prop[1 /* shouldCastTrue */] =\r\n                        stringIndex < 0 || booleanIndex < stringIndex;\r\n                    // if the prop needs boolean casting or default value\r\n                    if (booleanIndex > -1 || hasOwn(prop, 'default')) {\r\n                        needCastKeys.push(normalizedKey);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    const res = [normalized, needCastKeys];\r\n    cache.set(comp, res);\r\n    return res;\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$1(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$1(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\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) => {\r\n    const normalized = 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\n    normalized._c = false;\r\n    return normalized;\r\n};\r\nconst normalizeObjectSlots = (rawSlots, slots, instance) => {\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$1(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                !(false )) {\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') &&\r\n        !isKeepAlive(instance.vnode) &&\r\n        !(false )) {\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            // users can get the shallow readonly version of the slots object through `this.$slots`,\r\n            // we should avoid the proxy object polluting the slots of the internal instance\r\n            instance.slots = toRaw(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$1(dir)) {\r\n            dir = {\r\n                mounted: dir,\r\n                updated: dir\r\n            };\r\n        }\r\n        if (dir.deep) {\r\n            traverse(value);\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        let hook = binding.dir[name];\r\n        if (hook) {\r\n            // disable tracking inside all lifecycle hooks\r\n            // since they can potentially be called inside effects.\r\n            pauseTracking();\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            resetTracking();\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            errorHandler: undefined,\r\n            warnHandler: undefined,\r\n            compilerOptions: {}\r\n        },\r\n        mixins: [],\r\n        components: {},\r\n        directives: {},\r\n        provides: Object.create(null),\r\n        optionsCache: new WeakMap(),\r\n        propsCache: new WeakMap(),\r\n        emitsCache: new WeakMap()\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$1(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            _instance: null,\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$1(plugin.install)) {\r\n                    installedPlugins.add(plugin);\r\n                    plugin.install(app, ...options);\r\n                }\r\n                else if (isFunction$1(plugin)) {\r\n                    installedPlugins.add(plugin);\r\n                    plugin(app, ...options);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`A plugin must either be a function or an object with an \"install\" ` +\r\n                        `function.`);\r\n                }\r\n                return app;\r\n            },\r\n            mixin(mixin) {\r\n                if (__VUE_OPTIONS_API__) {\r\n                    if (!context.mixins.includes(mixin)) {\r\n                        context.mixins.push(mixin);\r\n                    }\r\n                    else if ((process.env.NODE_ENV !== 'production')) {\r\n                        warn('Mixin has already been applied to target app' +\r\n                            (mixin.name ? `: ${mixin.name}` : ''));\r\n                    }\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn('Mixins are only available in builds supporting Options API');\r\n                }\r\n                return app;\r\n            },\r\n            component(name, component) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    validateComponentName(name, context.config);\r\n                }\r\n                if (!component) {\r\n                    return context.components[name];\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && context.components[name]) {\r\n                    warn(`Component \"${name}\" has already been registered in target app.`);\r\n                }\r\n                context.components[name] = component;\r\n                return app;\r\n            },\r\n            directive(name, directive) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    validateDirectiveName(name);\r\n                }\r\n                if (!directive) {\r\n                    return context.directives[name];\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && context.directives[name]) {\r\n                    warn(`Directive \"${name}\" has already been registered in target app.`);\r\n                }\r\n                context.directives[name] = directive;\r\n                return app;\r\n            },\r\n            mount(rootContainer, isHydrate, 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                        app._instance = vnode.component;\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                        app._instance = null;\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 (!container.hasChildNodes()) {\r\n            (process.env.NODE_ENV !== 'production') &&\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            flushPostFlushCbs();\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$1:\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                    mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized);\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                    // #3787\r\n                    // if component is async, it may get moved / unmounted before its\r\n                    // inner component is loaded, so we need to give it a placeholder\r\n                    // vnode that matches its adopted DOM.\r\n                    if (isAsyncWrapper(vnode)) {\r\n                        let subTree;\r\n                        if (isFragmentStart) {\r\n                            subTree = createVNode(Fragment);\r\n                            subTree.anchor = nextNode\r\n                                ? nextNode.previousSibling\r\n                                : container.lastChild;\r\n                        }\r\n                        else {\r\n                            subTree =\r\n                                node.nodeType === 3 ? createTextVNode('') : createVNode('div');\r\n                        }\r\n                        subTree.el = node;\r\n                        vnode.component.subTree = subTree;\r\n                    }\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 { type, props, patchFlag, shapeFlag, dirs } = vnode;\r\n        // #4006 for form elements with non-string v-model value bindings\r\n        // e.g. <option :value=\"obj\">, <input type=\"checkbox\" :true-value=\"1\">\r\n        const forcePatchValue = (type === 'input' && dirs) || type === 'option';\r\n        // skip props & children if this is hoisted static nodes\r\n        if (forcePatchValue || 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 (forcePatchValue ||\r\n                    !optimized ||\r\n                    (patchFlag & 16 /* FULL_PROPS */ ||\r\n                        patchFlag & 32 /* HYDRATE_EVENTS */)) {\r\n                    for (const key in props) {\r\n                        if ((forcePatchValue && key.endsWith('value')) ||\r\n                            (isOn(key) && !isReservedProp(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    if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n        devtoolsPerfStart(instance, type, supported ? perf.now() : Date.now());\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    if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n        devtoolsPerfEnd(instance, type, supported ? perf.now() : Date.now());\r\n    }\r\n}\r\nfunction isSupported() {\r\n    if (supported !== undefined) {\r\n        return supported;\r\n    }\r\n    /* eslint-disable no-restricted-globals */\r\n    if (typeof window !== 'undefined' && window.performance) {\r\n        supported = true;\r\n        perf = window.performance;\r\n    }\r\n    else {\r\n        supported = false;\r\n    }\r\n    /* eslint-enable no-restricted-globals */\r\n    return supported;\r\n}\n\n/**\r\n * This is only called in esm-bundler builds.\r\n * It is called when a renderer is created, in `baseCreateRenderer` so that\r\n * importing runtime-core is side-effects free.\r\n *\r\n * istanbul-ignore-next\r\n */\r\nfunction initFeatureFlags() {\r\n    let needWarn = false;\r\n    if (typeof __VUE_OPTIONS_API__ !== 'boolean') {\r\n        needWarn = true;\r\n        getGlobalThis().__VUE_OPTIONS_API__ = true;\r\n    }\r\n    if (typeof __VUE_PROD_DEVTOOLS__ !== 'boolean') {\r\n        needWarn = true;\r\n        getGlobalThis().__VUE_PROD_DEVTOOLS__ = false;\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production') && needWarn) {\r\n        console.warn(`You are running the esm-bundler build of Vue. It is recommended to ` +\r\n            `configure your bundler to explicitly replace feature flag globals ` +\r\n            `with boolean literals to get proper tree-shaking in the final bundle. ` +\r\n            `See http://link.vuejs.org/feature-flags for more details.`);\r\n    }\r\n}\n\nconst prodEffectOptions = {\r\n    scheduler: queueJob,\r\n    // #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, isUnmount = false) => {\r\n    if (isArray(rawRef)) {\r\n        rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount));\r\n        return;\r\n    }\r\n    if (isAsyncWrapper(vnode) && !isUnmount) {\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    const refValue = vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */\r\n        ? getExposeProxy(vnode.component) || vnode.component.proxy\r\n        : vnode.el;\r\n    const value = isUnmount ? null : refValue;\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    // dynamic ref changed. 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            {\r\n                refs[ref] = value;\r\n            }\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$1(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 = (process.env.NODE_ENV !== 'production') && isHmrUpdating ? false : !!n2.dynamicChildren) => {\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$1:\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 || n1, !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);\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, slotScopeIds, optimized, start = 0) => {\r\n        for (let i = start; i < children.length; i++) {\r\n            const child = (children[i] = optimized\r\n                ? cloneIfMounted(children[i])\r\n                : normalizeVNode(children[i]));\r\n            patch(null, child, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\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            // oldVNode may be an errored async setup() component inside Suspense\r\n            // which will not have a mounted element\r\n            oldVNode.el &&\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 (dynamicChildren) {\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        {\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        }\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$1));\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                if (el && hydrateNode) {\r\n                    // vnode has adopted host node - perform hydration instead of mount.\r\n                    const hydrateSubTree = () => {\r\n                        if ((process.env.NODE_ENV !== 'production')) {\r\n                            startMeasure(instance, `render`);\r\n                        }\r\n                        instance.subTree = renderComponentRoot(instance);\r\n                        if ((process.env.NODE_ENV !== 'production')) {\r\n                            endMeasure(instance, `render`);\r\n                        }\r\n                        if ((process.env.NODE_ENV !== 'production')) {\r\n                            startMeasure(instance, `hydrate`);\r\n                        }\r\n                        hydrateNode(el, instance.subTree, instance, parentSuspense, null);\r\n                        if ((process.env.NODE_ENV !== 'production')) {\r\n                            endMeasure(instance, `hydrate`);\r\n                        }\r\n                    };\r\n                    if (isAsyncWrapper(initialVNode)) {\r\n                        initialVNode.type.__asyncLoader().then(\r\n                        // note: we are moving the render call into an async callback,\r\n                        // which means it won't track dependencies - but it's ok because\r\n                        // a server-rendered async wrapper is already in resolved state\r\n                        // and it will never need to change.\r\n                        () => !instance.isUnmounted && hydrateSubTree());\r\n                    }\r\n                    else {\r\n                        hydrateSubTree();\r\n                    }\r\n                }\r\n                else {\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 ((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(() => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode), 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                if (initialVNode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {\r\n                    instance.a && queuePostRenderEffect(instance.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(() => invokeVNodeHook(vnodeHook, parent, next, vnode), 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        if ((process.env.NODE_ENV !== 'production')) {\r\n            // @ts-ignore\r\n            instance.update.ownerInstance = instance;\r\n        }\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, vnode, true);\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$1 && !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        let { shapeFlag, children, dynamicChildren } = 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            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 (dynamicChildren) {\r\n                // fast path when the teleport happens to be a block root\r\n                patchBlockChildren(n1.dynamicChildren, 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                    const child = children[i];\r\n                    unmount(child, parentComponent, parentSuspense, true, !!child.dynamicChildren);\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 which is resolved for options API\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$1 = 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 isBlockTreeEnabled = 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    isBlockTreeEnabled += 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 =\r\n        isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;\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 (isBlockTreeEnabled > 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$1(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$1;\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$1(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$1(type)\r\n                    ? 4 /* STATEFUL_COMPONENT */\r\n                    : isFunction$1(type)\r\n                        ? 2 /* FUNCTIONAL_COMPONENT */\r\n                        : 0;\r\n    if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n        type = toRaw(type);\r\n        warn(`Vue received a Component which was made a reactive object. This can ` +\r\n            `lead to unnecessary performance overhead, and should be avoided by ` +\r\n            `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n            `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n    }\r\n    const vnode = {\r\n        __v_isVNode: true,\r\n        __v_skip: true,\r\n        type,\r\n        props,\r\n        key: props && normalizeKey(props),\r\n        ref: props && normalizeRef(props),\r\n        scopeId: currentScopeId,\r\n        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        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        type.normalize(vnode);\r\n    }\r\n    if (isBlockTreeEnabled > 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    const cloned = {\r\n        __v_isVNode: true,\r\n        __v_skip: true,\r\n        type: vnode.type,\r\n        props: mergedProps,\r\n        key: mergedProps && normalizeKey(mergedProps),\r\n        ref: extraProps && extraProps.ref\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    return cloned;\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$1, null, text))\r\n        : createVNode(Comment$1, 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$1);\r\n    }\r\n    else if (isArray(child)) {\r\n        // fragment\r\n        return createVNode(Fragment, null, \r\n        // #3666, avoid reference pollution when reusing vnode\r\n        child.slice());\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 cloneIfMounted(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 && (slot._d = false);\r\n                normalizeChildren(vnode, slot());\r\n                slot._c && (slot._d = true);\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.slots._ === 1 /* STABLE */) {\r\n                    children._ = 1 /* STABLE */;\r\n                }\r\n                else {\r\n                    children._ = 2 /* DYNAMIC */;\r\n                    vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else if (isFunction$1(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, incoming)\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\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$1(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 * 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/**\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    if (slot && slot._c) {\r\n        slot._d = false;\r\n    }\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    if (slot && slot._c) {\r\n        slot._d = true;\r\n    }\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$1)\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 * 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$1(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 * #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 getExposeProxy(i) || 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        // 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        // prioritize <script setup> bindings during dev.\r\n        // this allows even properties that start with _ or $ to be used - so that\r\n        // it aligns with the production behavior where the render fn is inlined and\r\n        // indeed has access to all declared variables.\r\n        if ((process.env.NODE_ENV !== 'production') &&\r\n            setupState !== EMPTY_OBJ &&\r\n            setupState.__isScriptSetup &&\r\n            hasOwn(setupState, key)) {\r\n            return setupState[key];\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            {\r\n                return globalProperties[key];\r\n            }\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    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 (!setupState.__isScriptSetup && (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        exposeProxy: 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        // inheritAttrs\r\n        inheritAttrs: type.inheritAttrs,\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        sp: 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        if (Component.compilerOptions && isRuntimeOnly()) {\r\n            warn(`\"compilerOptions\" is only supported when using a build of Vue that ` +\r\n                `includes the runtime compiler. Since you are using a runtime-only ` +\r\n                `build, the options should be passed via your build tool config instead.`);\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 = markRaw(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$1(setupResult)) {\r\n            const unsetInstance = () => {\r\n                currentInstance = null;\r\n            };\r\n            setupResult.then(unsetInstance, unsetInstance);\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$1(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$1(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, skipOptions) {\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.render) {\r\n            const template = Component.template;\r\n            if (template) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    startMeasure(instance, `compile`);\r\n                }\r\n                const { isCustomElement, compilerOptions } = instance.appContext.config;\r\n                const { delimiters, compilerOptions: componentCompilerOptions } = Component;\r\n                const finalCompilerOptions = extend(extend({\r\n                    isCustomElement,\r\n                    delimiters\r\n                }, compilerOptions), componentCompilerOptions);\r\n                Component.render = compile(template, finalCompilerOptions);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    endMeasure(instance, `compile`);\r\n                }\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__ && !(false )) {\r\n        currentInstance = instance;\r\n        pauseTracking();\r\n        applyOptions(instance);\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 attrDevProxyHandlers = {\r\n    get: (target, key) => {\r\n        markAttrsAccessed();\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 = exposed || {};\r\n    };\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        let attrs;\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 (attrs || (attrs = new Proxy(instance.attrs, attrDevProxyHandlers)));\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\nfunction getExposeProxy(instance) {\r\n    if (instance.exposed) {\r\n        return (instance.exposeProxy ||\r\n            (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {\r\n                get(target, key) {\r\n                    if (key in target) {\r\n                        return target[key];\r\n                    }\r\n                    else if (key in publicPropertiesMap) {\r\n                        return publicPropertiesMap[key](instance);\r\n                    }\r\n                }\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$1(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$1(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(process.env.NODE_ENV !== 'production')\r\n    ? Object.freeze({})\r\n    : {};\r\n(process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\r\nconst isFunction = (val) => typeof val === 'function';\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};\n\n// dev only\r\nconst warnRuntimeUsage = (method) => warn(`${method}() 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// implementation\r\nfunction defineProps() {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        warnRuntimeUsage(`defineProps`);\r\n    }\r\n    return null;\r\n}\r\n// implementation\r\nfunction defineEmits() {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        warnRuntimeUsage(`defineEmits`);\r\n    }\r\n    return null;\r\n}\r\n/**\r\n * @deprecated use `defineEmits` instead.\r\n */\r\nconst defineEmit = defineEmits;\r\n/**\r\n * Vue `<script setup>` compiler macro for declaring a component's exposed\r\n * instance properties when it is accessed by a parent component via template\r\n * refs.\r\n *\r\n * `<script setup>` components are closed by default - i.e. varaibles inside\r\n * the `<script setup>` scope is not exposed to parent unless explicitly exposed\r\n * via `defineExpose`.\r\n *\r\n * This is only usable inside `<script setup>`, is compiled away in the\r\n * output and should **not** be actually called at runtime.\r\n */\r\nfunction defineExpose(exposed) {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        warnRuntimeUsage(`defineExpose`);\r\n    }\r\n}\r\n/**\r\n * Vue `<script setup>` compiler macro for providing props default values when\r\n * using type-based `defineProps` decalration.\r\n *\r\n * Example usage:\r\n * ```ts\r\n * withDefaults(defineProps<{\r\n *   size?: number\r\n *   labels?: string[]\r\n * }>(), {\r\n *   size: 3,\r\n *   labels: () => ['default label']\r\n * })\r\n * ```\r\n *\r\n * This is only usable inside `<script setup>`, is compiled away in the output\r\n * and should **not** be actually called at runtime.\r\n */\r\nfunction withDefaults(props, defaults) {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        warnRuntimeUsage(`withDefaults`);\r\n    }\r\n    return null;\r\n}\r\n/**\r\n * @deprecated use `useSlots` and `useAttrs` instead.\r\n */\r\nfunction useContext() {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`\\`useContext()\\` has been deprecated and will be removed in the ` +\r\n            `next minor release. Use \\`useSlots()\\` and \\`useAttrs()\\` instead.`);\r\n    }\r\n    return getContext();\r\n}\r\nfunction useSlots() {\r\n    return getContext().slots;\r\n}\r\nfunction useAttrs() {\r\n    return getContext().attrs;\r\n}\r\nfunction getContext() {\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}\r\n/**\r\n * Runtime helper for merging default declarations. Imported by compiled code\r\n * only.\r\n * @internal\r\n */\r\nfunction mergeDefaults(\r\n// the base props is compiler-generated and guaranteed to be in this shape.\r\nprops, defaults) {\r\n    for (const key in defaults) {\r\n        const val = props[key];\r\n        if (val) {\r\n            val.default = defaults[key];\r\n        }\r\n        else if (val === null) {\r\n            props[key] = { default: defaults[key] };\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production')) {\r\n            warn(`props default key \"${key}\" has no corresponding declaration.`);\r\n        }\r\n    }\r\n    return props;\r\n}\r\n/**\r\n * `<script setup>` helper for persisting the current instance context over\r\n * async/await flows.\r\n *\r\n * `@vue/compiler-sfc` converts the following:\r\n *\r\n * ```ts\r\n * const x = await foo()\r\n * ```\r\n *\r\n * into:\r\n *\r\n * ```ts\r\n * let __temp, __restore\r\n * const x = (([__temp, __restore] = withAsyncContext(() => foo())),__temp=await __temp,__restore(),__temp)\r\n * ```\r\n * @internal\r\n */\r\nfunction withAsyncContext(getAwaitable) {\r\n    const ctx = getCurrentInstance();\r\n    let awaitable = getAwaitable();\r\n    setCurrentInstance(null);\r\n    if (isPromise(awaitable)) {\r\n        awaitable = awaitable.catch(e => {\r\n            setCurrentInstance(ctx);\r\n            throw e;\r\n        });\r\n    }\r\n    return [awaitable, () => setCurrentInstance(ctx)];\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$1(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$1(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$1(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$1(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$1(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// Core API ------------------------------------------------------------------\r\nconst version = \"3.1.5\";\r\n/**\r\n * SSR utils for \\@vue/server-renderer. Only exposed in cjs builds.\r\n * @internal\r\n */\r\nconst ssrUtils = (null);\r\n/**\r\n * @internal only exposed in compat builds\r\n */\r\nconst resolveFilter = null;\r\n/**\r\n * @internal only exposed in compat builds.\r\n */\r\nconst compatUtils = (null);\n\nexport { BaseTransition, Comment$1 as Comment, Fragment, KeepAlive, Static, Suspense, Teleport, Text, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, compatUtils, computed, createBlock, createCommentVNode, createHydrationRenderer, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, defineAsyncComponent, defineComponent, defineEmit, defineEmits, defineExpose, defineProps, devtools, getCurrentInstance, getTransitionRawChildren, h, handleError, initCustomFormatter, inject, isRuntimeOnly, isVNode, mergeDefaults, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onServerPrefetch, onUnmounted, onUpdated, openBlock, popScopeId, provide, pushScopeId, queuePostFlushCb, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveFilter, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, ssrContextKey, ssrUtils, toHandlers, transformVNodeArgs, useAttrs, useContext, useSSRContext, useSlots, useTransitionState, version, warn, watch, watchEffect, withAsyncContext, withCtx, withDefaults, withDirectives, withScopeId };\n","import { camelize, warn, callWithAsyncErrorHandling, getCurrentInstance, onMounted, watchEffect, onUpdated, Fragment, Static, 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\nconst staticTemplateCache = new Map();\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        // <parent> before | first ... last | anchor </parent>\r\n        const before = anchor ? anchor.previousSibling : parent.lastChild;\r\n        let template = staticTemplateCache.get(content);\r\n        if (!template) {\r\n            const t = doc.createElement('template');\r\n            t.innerHTML = isSVG ? `<svg>${content}</svg>` : content;\r\n            template = t.content;\r\n            if (isSVG) {\r\n                // remove outer svg wrapper\r\n                const wrapper = template.firstChild;\r\n                while (wrapper.firstChild) {\r\n                    template.appendChild(wrapper.firstChild);\r\n                }\r\n                template.removeChild(wrapper);\r\n            }\r\n            staticTemplateCache.set(content, template);\r\n        }\r\n        parent.insertBefore(template.cloneNode(true), anchor);\r\n        return [\r\n            // first\r\n            before ? before.nextSibling : parent.firstChild,\r\n            // last\r\n            anchor ? anchor.previousSibling : parent.lastChild\r\n        ];\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    // 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    if (value == null) {\r\n        el.removeAttribute('class');\r\n    }\r\n    else if (isSVG) {\r\n        el.setAttribute('class', value);\r\n    }\r\n    else {\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, instance) {\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        if (value == null) {\r\n            el.removeAttribute(key);\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            // the value of some IDL attr must be greater than 0, e.g. input.size = 0 -> error\r\n            try {\r\n                el[key] = 0;\r\n            }\r\n            catch (_a) { }\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        setVarsOnNode(vnode.el, vars);\r\n    }\r\n    else if (vnode.type === Fragment) {\r\n        vnode.children.forEach(c => setVarsOnVNode(c, vars));\r\n    }\r\n    else if (vnode.type === Static) {\r\n        let { el, anchor } = vnode;\r\n        while (el) {\r\n            setVarsOnNode(el, vars);\r\n            if (el === anchor)\r\n                break;\r\n            el = el.nextSibling;\r\n        }\r\n    }\r\n}\r\nfunction setVarsOnNode(el, vars) {\r\n    if (el.nodeType === 1) {\r\n        const style = el.style;\r\n        for (const key in vars) {\r\n            style.setProperty(`--${key}`, vars[key]);\r\n        }\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\n/**\r\n * #3227 Incoming hooks may be merged into arrays when wrapping Transition\r\n * with custom HOCs.\r\n */\r\nconst callHook = (hook, args = []) => {\r\n    if (isArray(hook)) {\r\n        hook.forEach(h => h(...args));\r\n    }\r\n    else if (hook) {\r\n        hook(...args);\r\n    }\r\n};\r\n/**\r\n * Check if a hook expects a callback (2nd arg), which means the user\r\n * intends to explicitly control the end of the transition.\r\n */\r\nconst hasExplicitCallback = (hook) => {\r\n    return hook\r\n        ? isArray(hook)\r\n            ? hook.some(h => h.length > 1)\r\n            : hook.length > 1\r\n        : false;\r\n};\r\nfunction resolveTransitionProps(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 (rawProps.css === false) {\r\n        return baseProps;\r\n    }\r\n    const { name = 'v', type, 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 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            callHook(hook, [el, resolve]);\r\n            nextFrame(() => {\r\n                removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);\r\n                addTransitionClass(el, isAppear ? appearToClass : enterToClass);\r\n                if (!hasExplicitCallback(hook)) {\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            callHook(onBeforeEnter, [el]);\r\n            addTransitionClass(el, enterFromClass);\r\n            addTransitionClass(el, enterActiveClass);\r\n        },\r\n        onBeforeAppear(el) {\r\n            callHook(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 (!hasExplicitCallback(onLeave)) {\r\n                    whenTransitionEnds(el, type, leaveDuration, resolve);\r\n                }\r\n            });\r\n            callHook(onLeave, [el, resolve]);\r\n        },\r\n        onEnterCancelled(el) {\r\n            finishEnter(el, false);\r\n            callHook(onEnterCancelled, [el]);\r\n        },\r\n        onAppearCancelled(el) {\r\n            finishEnter(el, true);\r\n            callHook(onAppearCancelled, [el]);\r\n        },\r\n        onLeaveCancelled(el) {\r\n            finishLeave(el);\r\n            callHook(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            let 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    // #4096 array checkboxes need to be deep traversed\r\n    deep: true,\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    // <select multiple> value need to be deep traversed\r\n    deep: true,\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                if (el.selectedIndex !== i)\r\n                    el.selectedIndex = i;\r\n                return;\r\n            }\r\n        }\r\n    }\r\n    if (!isMultiple && el.selectedIndex !== -1) {\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        }\r\n        const eventKey = hyphenate(event.key);\r\n        if (modifiers.some(k => k === eventKey || keyNames[k] === eventKey)) {\r\n            return fn(event);\r\n        }\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        injectCompilerOptionsCheck(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            // __UNSAFE__\r\n            // Reason: potential execution of JS expressions in in-DOM template.\r\n            // The user must make sure the in-DOM template is trusted. If it's\r\n            // rendered by the server, the template should not contain any user data.\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        injectCompilerOptionsCheck(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 injectCompilerOptionsCheck(app) {\r\n    if (isRuntimeOnly()) {\r\n        const isCustomElement = app.config.isCustomElement;\r\n        Object.defineProperty(app.config, 'isCustomElement', {\r\n            get() {\r\n                return isCustomElement;\r\n            },\r\n            set() {\r\n                warn(`The \\`isCustomElement\\` config option is deprecated. Use ` +\r\n                    `\\`compilerOptions.isCustomElement\\` instead.`);\r\n            }\r\n        });\r\n        const compilerOptions = app.config.compilerOptions;\r\n        const msg = `The \\`compilerOptions\\` config option is only respected when using ` +\r\n            `a build of Vue.js that includes the runtime compiler (aka \"full build\"). ` +\r\n            `Since you are using the runtime-only build, \\`compilerOptions\\` ` +\r\n            `must be passed to \\`@vue/compiler-dom\\` in the build setup instead.\\n` +\r\n            `- For vue-loader: pass it via vue-loader's \\`compilerOptions\\` loader option.\\n` +\r\n            `- For vue-cli: see https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader\\n` +\r\n            `- For vite: pass it via @vitejs/plugin-vue options. See https://github.com/vitejs/vite/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-dom`;\r\n        Object.defineProperty(app.config, 'compilerOptions', {\r\n            get() {\r\n                warn(msg);\r\n                return compilerOptions;\r\n            },\r\n            set() {\r\n                warn(msg);\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","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs support document.cookie\n    (function standardBrowserEnv() {\n      return {\n        write: function write(name, value, expires, path, domain, secure) {\n          var cookie = [];\n          cookie.push(name + '=' + encodeURIComponent(value));\n\n          if (utils.isNumber(expires)) {\n            cookie.push('expires=' + new Date(expires).toGMTString());\n          }\n\n          if (utils.isString(path)) {\n            cookie.push('path=' + path);\n          }\n\n          if (utils.isString(domain)) {\n            cookie.push('domain=' + domain);\n          }\n\n          if (secure === true) {\n            cookie.push('secure');\n          }\n\n          document.cookie = cookie.join('; ');\n        },\n\n        read: function read(name) {\n          var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n          return (match ? decodeURIComponent(match[3]) : null);\n        },\n\n        remove: function remove(name) {\n          this.write(name, '', Date.now() - 86400000);\n        }\n      };\n    })() :\n\n  // Non standard browser env (web workers, react-native) lack needed support.\n    (function nonStandardBrowserEnv() {\n      return {\n        write: function write() {},\n        read: function read() { return null; },\n        remove: function remove() {}\n      };\n    })()\n);\n","'use strict';\n\nvar isAbsoluteURL = require('../helpers/isAbsoluteURL');\nvar combineURLs = require('../helpers/combineURLs');\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n * @returns {string} The combined full path\n */\nmodule.exports = function buildFullPath(baseURL, requestedURL) {\n  if (baseURL && !isAbsoluteURL(requestedURL)) {\n    return combineURLs(baseURL, requestedURL);\n  }\n  return requestedURL;\n};\n","'use strict';\n\nvar VERSION = require('../env/data').version;\nvar AxiosError = require('../core/AxiosError');\n\nvar validators = {};\n\n// eslint-disable-next-line func-names\n['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function(type, i) {\n  validators[type] = function validator(thing) {\n    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;\n  };\n});\n\nvar deprecatedWarnings = {};\n\n/**\n * Transitional option validator\n * @param {function|boolean?} validator - set to false if the transitional option has been removed\n * @param {string?} version - deprecated version / removed since version\n * @param {string?} message - some message with additional info\n * @returns {function}\n */\nvalidators.transitional = function transitional(validator, version, message) {\n  function formatMessage(opt, desc) {\n    return '[Axios v' + VERSION + '] Transitional option \\'' + opt + '\\'' + desc + (message ? '. ' + message : '');\n  }\n\n  // eslint-disable-next-line func-names\n  return function(value, opt, opts) {\n    if (validator === false) {\n      throw new AxiosError(\n        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),\n        AxiosError.ERR_DEPRECATED\n      );\n    }\n\n    if (version && !deprecatedWarnings[opt]) {\n      deprecatedWarnings[opt] = true;\n      // eslint-disable-next-line no-console\n      console.warn(\n        formatMessage(\n          opt,\n          ' has been deprecated since v' + version + ' and will be removed in the near future'\n        )\n      );\n    }\n\n    return validator ? validator(value, opt, opts) : true;\n  };\n};\n\n/**\n * Assert object's properties type\n * @param {object} options\n * @param {object} schema\n * @param {boolean?} allowUnknown\n */\n\nfunction assertOptions(options, schema, allowUnknown) {\n  if (typeof options !== 'object') {\n    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);\n  }\n  var keys = Object.keys(options);\n  var i = keys.length;\n  while (i-- > 0) {\n    var opt = keys[i];\n    var validator = schema[opt];\n    if (validator) {\n      var value = options[opt];\n      var result = value === undefined || validator(value, opt, options);\n      if (result !== true) {\n        throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);\n      }\n      continue;\n    }\n    if (allowUnknown !== true) {\n      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);\n    }\n  }\n}\n\nmodule.exports = {\n  assertOptions: assertOptions,\n  validators: validators\n};\n","'use strict';\n\nvar CanceledError = require('./CanceledError');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n  if (typeof executor !== 'function') {\n    throw new TypeError('executor must be a function.');\n  }\n\n  var resolvePromise;\n\n  this.promise = new Promise(function promiseExecutor(resolve) {\n    resolvePromise = resolve;\n  });\n\n  var token = this;\n\n  // eslint-disable-next-line func-names\n  this.promise.then(function(cancel) {\n    if (!token._listeners) return;\n\n    var i;\n    var l = token._listeners.length;\n\n    for (i = 0; i < l; i++) {\n      token._listeners[i](cancel);\n    }\n    token._listeners = null;\n  });\n\n  // eslint-disable-next-line func-names\n  this.promise.then = function(onfulfilled) {\n    var _resolve;\n    // eslint-disable-next-line func-names\n    var promise = new Promise(function(resolve) {\n      token.subscribe(resolve);\n      _resolve = resolve;\n    }).then(onfulfilled);\n\n    promise.cancel = function reject() {\n      token.unsubscribe(_resolve);\n    };\n\n    return promise;\n  };\n\n  executor(function cancel(message) {\n    if (token.reason) {\n      // Cancellation has already been requested\n      return;\n    }\n\n    token.reason = new CanceledError(message);\n    resolvePromise(token.reason);\n  });\n}\n\n/**\n * Throws a `CanceledError` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n  if (this.reason) {\n    throw this.reason;\n  }\n};\n\n/**\n * Subscribe to the cancel signal\n */\n\nCancelToken.prototype.subscribe = function subscribe(listener) {\n  if (this.reason) {\n    listener(this.reason);\n    return;\n  }\n\n  if (this._listeners) {\n    this._listeners.push(listener);\n  } else {\n    this._listeners = [listener];\n  }\n};\n\n/**\n * Unsubscribe from the cancel signal\n */\n\nCancelToken.prototype.unsubscribe = function unsubscribe(listener) {\n  if (!this._listeners) {\n    return;\n  }\n  var index = this._listeners.indexOf(listener);\n  if (index !== -1) {\n    this._listeners.splice(index, 1);\n  }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n  var cancel;\n  var token = new CancelToken(function executor(c) {\n    cancel = c;\n  });\n  return {\n    token: token,\n    cancel: cancel\n  };\n};\n\nmodule.exports = CancelToken;\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n    const map = Object.create(null);\r\n    const list = str.split(',');\r\n    for (let i = 0; i < list.length; i++) {\r\n        map[list[i]] = true;\r\n    }\r\n    return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\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    // Split the content into individual lines but capture the newline sequence\r\n    // that separated each line. This is important because the actual sequence is\r\n    // needed to properly take into account the full line length for offset\r\n    // comparison\r\n    let lines = source.split(/(\\r?\\n)/);\r\n    // Separate the lines and newline sequences into separate arrays for easier referencing\r\n    const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);\r\n    lines = lines.filter((_, idx) => idx % 2 === 0);\r\n    let count = 0;\r\n    const res = [];\r\n    for (let i = 0; i < lines.length; i++) {\r\n        count +=\r\n            lines[i].length +\r\n                ((newlineSequences[i] && newlineSequences[i].length) || 0);\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                const newLineSeqLength = (newlineSequences[j] && newlineSequences[j].length) || 0;\r\n                if (j === i) {\r\n                    // push underline\r\n                    const pad = start - (count - (lineLength + newLineSeqLength));\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 + newLineSeqLength;\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","export function getDevtoolsGlobalHook() {\n    return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;\n}\nexport function getTarget() {\n    // @ts-ignore\n    return typeof navigator !== 'undefined'\n        ? window\n        : typeof global !== 'undefined'\n            ? global\n            : {};\n}\n","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar cookies = require('./../helpers/cookies');\nvar buildURL = require('./../helpers/buildURL');\nvar buildFullPath = require('../core/buildFullPath');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar transitionalDefaults = require('../defaults/transitional');\nvar AxiosError = require('../core/AxiosError');\nvar CanceledError = require('../cancel/CanceledError');\nvar parseProtocol = require('../helpers/parseProtocol');\n\nmodule.exports = function xhrAdapter(config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    var requestData = config.data;\n    var requestHeaders = config.headers;\n    var responseType = config.responseType;\n    var onCanceled;\n    function done() {\n      if (config.cancelToken) {\n        config.cancelToken.unsubscribe(onCanceled);\n      }\n\n      if (config.signal) {\n        config.signal.removeEventListener('abort', onCanceled);\n      }\n    }\n\n    if (utils.isFormData(requestData) && utils.isStandardBrowserEnv()) {\n      delete requestHeaders['Content-Type']; // Let the browser set it\n    }\n\n    var request = new XMLHttpRequest();\n\n    // HTTP basic authentication\n    if (config.auth) {\n      var username = config.auth.username || '';\n      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';\n      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n    }\n\n    var fullPath = buildFullPath(config.baseURL, config.url);\n\n    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);\n\n    // Set the request timeout in MS\n    request.timeout = config.timeout;\n\n    function onloadend() {\n      if (!request) {\n        return;\n      }\n      // Prepare the response\n      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n      var responseData = !responseType || responseType === 'text' ||  responseType === 'json' ?\n        request.responseText : request.response;\n      var response = {\n        data: responseData,\n        status: request.status,\n        statusText: request.statusText,\n        headers: responseHeaders,\n        config: config,\n        request: request\n      };\n\n      settle(function _resolve(value) {\n        resolve(value);\n        done();\n      }, function _reject(err) {\n        reject(err);\n        done();\n      }, response);\n\n      // Clean up request\n      request = null;\n    }\n\n    if ('onloadend' in request) {\n      // Use onloadend if available\n      request.onloadend = onloadend;\n    } else {\n      // Listen for ready state to emulate onloadend\n      request.onreadystatechange = function handleLoad() {\n        if (!request || request.readyState !== 4) {\n          return;\n        }\n\n        // The request errored out and we didn't get a response, this will be\n        // handled by onerror instead\n        // With one exception: request that using file: protocol, most browsers\n        // will return status as 0 even though it's a successful request\n        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n          return;\n        }\n        // readystate handler is calling before onerror or ontimeout handlers,\n        // so we should call onloadend on the next 'tick'\n        setTimeout(onloadend);\n      };\n    }\n\n    // Handle browser request cancellation (as opposed to a manual cancellation)\n    request.onabort = function handleAbort() {\n      if (!request) {\n        return;\n      }\n\n      reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n    request.onerror = function handleError() {\n      // Real errors are hidden from us by the browser\n      // onerror should only fire if it's a network error\n      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      var timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';\n      var transitional = config.transitional || transitionalDefaults;\n      if (config.timeoutErrorMessage) {\n        timeoutErrorMessage = config.timeoutErrorMessage;\n      }\n      reject(new AxiosError(\n        timeoutErrorMessage,\n        transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,\n        config,\n        request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Add xsrf header\n    // This is only done if running in a standard browser environment.\n    // Specifically not if we're in a web worker, or react-native.\n    if (utils.isStandardBrowserEnv()) {\n      // Add xsrf header\n      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?\n        cookies.read(config.xsrfCookieName) :\n        undefined;\n\n      if (xsrfValue) {\n        requestHeaders[config.xsrfHeaderName] = xsrfValue;\n      }\n    }\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n          // Remove Content-Type if data is undefined\n          delete requestHeaders[key];\n        } else {\n          // Otherwise add header to the request\n          request.setRequestHeader(key, val);\n        }\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (!utils.isUndefined(config.withCredentials)) {\n      request.withCredentials = !!config.withCredentials;\n    }\n\n    // Add responseType to request if needed\n    if (responseType && responseType !== 'json') {\n      request.responseType = config.responseType;\n    }\n\n    // Handle progress if needed\n    if (typeof config.onDownloadProgress === 'function') {\n      request.addEventListener('progress', config.onDownloadProgress);\n    }\n\n    // Not all browsers support upload events\n    if (typeof config.onUploadProgress === 'function' && request.upload) {\n      request.upload.addEventListener('progress', config.onUploadProgress);\n    }\n\n    if (config.cancelToken || config.signal) {\n      // Handle cancellation\n      // eslint-disable-next-line func-names\n      onCanceled = function(cancel) {\n        if (!request) {\n          return;\n        }\n        reject(!cancel || (cancel && cancel.type) ? new CanceledError() : cancel);\n        request.abort();\n        request = null;\n      };\n\n      config.cancelToken && config.cancelToken.subscribe(onCanceled);\n      if (config.signal) {\n        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);\n      }\n    }\n\n    if (!requestData) {\n      requestData = null;\n    }\n\n    var protocol = parseProtocol(fullPath);\n\n    if (protocol && [ 'http', 'https', 'file' ].indexOf(protocol) === -1) {\n      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));\n      return;\n    }\n\n\n    // Send the request\n    request.send(requestData);\n  });\n};\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","'use strict';\n\nmodule.exports = function parseProtocol(url) {\n  var match = /^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(url);\n  return match && match[1] || '';\n};\n","export const HOOK_SETUP = 'devtools-plugin:setup';\n","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\n\n// Headers whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nvar ignoreDuplicateOf = [\n  'age', 'authorization', 'content-length', 'content-type', 'etag',\n  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',\n  'last-modified', 'location', 'max-forwards', 'proxy-authorization',\n  'referer', 'retry-after', 'user-agent'\n];\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n  var parsed = {};\n  var key;\n  var val;\n  var i;\n\n  if (!headers) { return parsed; }\n\n  utils.forEach(headers.split('\\n'), function parser(line) {\n    i = line.indexOf(':');\n    key = utils.trim(line.substr(0, i)).toLowerCase();\n    val = utils.trim(line.substr(i + 1));\n\n    if (key) {\n      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {\n        return;\n      }\n      if (key === 'set-cookie') {\n        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);\n      } else {\n        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n      }\n    }\n  });\n\n  return parsed;\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar defaults = require('../defaults');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n  var context = this || defaults;\n  /*eslint no-param-reassign:0*/\n  utils.forEach(fns, function transform(fn) {\n    data = fn.call(context, data, headers);\n  });\n\n  return data;\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n// eslint-disable-next-line func-names\nvar kindOf = (function(cache) {\n  // eslint-disable-next-line func-names\n  return function(thing) {\n    var str = toString.call(thing);\n    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());\n  };\n})(Object.create(null));\n\nfunction kindOfTest(type) {\n  type = type.toLowerCase();\n  return function isKindOf(thing) {\n    return kindOf(thing) === type;\n  };\n}\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n  return Array.isArray(val);\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n  return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)\n    && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nvar isArrayBuffer = kindOfTest('ArrayBuffer');\n\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  var result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n  return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n  return typeof val === 'number';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n  return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a plain Object\n *\n * @param {Object} val The value to test\n * @return {boolean} True if value is a plain Object, otherwise false\n */\nfunction isPlainObject(val) {\n  if (kindOf(val) !== 'object') {\n    return false;\n  }\n\n  var prototype = Object.getPrototypeOf(val);\n  return prototype === null || prototype === Object.prototype;\n}\n\n/**\n * Determine if a value is a Date\n *\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nvar isDate = kindOfTest('Date');\n\n/**\n * Determine if a value is a File\n *\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nvar isFile = kindOfTest('File');\n\n/**\n * Determine if a value is a Blob\n *\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nvar isBlob = kindOfTest('Blob');\n\n/**\n * Determine if a value is a FileList\n *\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nvar isFileList = kindOfTest('FileList');\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n  return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n  return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} thing The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(thing) {\n  var pattern = '[object FormData]';\n  return thing && (\n    (typeof FormData === 'function' && thing instanceof FormData) ||\n    toString.call(thing) === pattern ||\n    (isFunction(thing.toString) && thing.toString() === pattern)\n  );\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nvar isURLSearchParams = kindOfTest('URLSearchParams');\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n  return str.trim ? str.trim() : str.replace(/^\\s+|\\s+$/g, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  navigator.product -> 'ReactNative'\n * nativescript\n *  navigator.product -> 'NativeScript' or 'NS'\n */\nfunction isStandardBrowserEnv() {\n  if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||\n                                           navigator.product === 'NativeScript' ||\n                                           navigator.product === 'NS')) {\n    return false;\n  }\n  return (\n    typeof window !== 'undefined' &&\n    typeof document !== 'undefined'\n  );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object') {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (var i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    for (var key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key)) {\n        fn.call(null, obj[key], key, obj);\n      }\n    }\n  }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  var result = {};\n  function assignValue(val, key) {\n    if (isPlainObject(result[key]) && isPlainObject(val)) {\n      result[key] = merge(result[key], val);\n    } else if (isPlainObject(val)) {\n      result[key] = merge({}, val);\n    } else if (isArray(val)) {\n      result[key] = val.slice();\n    } else {\n      result[key] = val;\n    }\n  }\n\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n  forEach(b, function assignValue(val, key) {\n    if (thisArg && typeof val === 'function') {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  });\n  return a;\n}\n\n/**\n * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)\n *\n * @param {string} content with BOM\n * @return {string} content value without BOM\n */\nfunction stripBOM(content) {\n  if (content.charCodeAt(0) === 0xFEFF) {\n    content = content.slice(1);\n  }\n  return content;\n}\n\n/**\n * Inherit the prototype methods from one constructor into another\n * @param {function} constructor\n * @param {function} superConstructor\n * @param {object} [props]\n * @param {object} [descriptors]\n */\n\nfunction inherits(constructor, superConstructor, props, descriptors) {\n  constructor.prototype = Object.create(superConstructor.prototype, descriptors);\n  constructor.prototype.constructor = constructor;\n  props && Object.assign(constructor.prototype, props);\n}\n\n/**\n * Resolve object with deep prototype chain to a flat object\n * @param {Object} sourceObj source object\n * @param {Object} [destObj]\n * @param {Function} [filter]\n * @returns {Object}\n */\n\nfunction toFlatObject(sourceObj, destObj, filter) {\n  var props;\n  var i;\n  var prop;\n  var merged = {};\n\n  destObj = destObj || {};\n\n  do {\n    props = Object.getOwnPropertyNames(sourceObj);\n    i = props.length;\n    while (i-- > 0) {\n      prop = props[i];\n      if (!merged[prop]) {\n        destObj[prop] = sourceObj[prop];\n        merged[prop] = true;\n      }\n    }\n    sourceObj = Object.getPrototypeOf(sourceObj);\n  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);\n\n  return destObj;\n}\n\n/*\n * determines whether a string ends with the characters of a specified string\n * @param {String} str\n * @param {String} searchString\n * @param {Number} [position= 0]\n * @returns {boolean}\n */\nfunction endsWith(str, searchString, position) {\n  str = String(str);\n  if (position === undefined || position > str.length) {\n    position = str.length;\n  }\n  position -= searchString.length;\n  var lastIndex = str.indexOf(searchString, position);\n  return lastIndex !== -1 && lastIndex === position;\n}\n\n\n/**\n * Returns new array from array like object\n * @param {*} [thing]\n * @returns {Array}\n */\nfunction toArray(thing) {\n  if (!thing) return null;\n  var i = thing.length;\n  if (isUndefined(i)) return null;\n  var arr = new Array(i);\n  while (i-- > 0) {\n    arr[i] = thing[i];\n  }\n  return arr;\n}\n\n// eslint-disable-next-line func-names\nvar isTypedArray = (function(TypedArray) {\n  // eslint-disable-next-line func-names\n  return function(thing) {\n    return TypedArray && thing instanceof TypedArray;\n  };\n})(typeof Uint8Array !== 'undefined' && Object.getPrototypeOf(Uint8Array));\n\nmodule.exports = {\n  isArray: isArray,\n  isArrayBuffer: isArrayBuffer,\n  isBuffer: isBuffer,\n  isFormData: isFormData,\n  isArrayBufferView: isArrayBufferView,\n  isString: isString,\n  isNumber: isNumber,\n  isObject: isObject,\n  isPlainObject: isPlainObject,\n  isUndefined: isUndefined,\n  isDate: isDate,\n  isFile: isFile,\n  isBlob: isBlob,\n  isFunction: isFunction,\n  isStream: isStream,\n  isURLSearchParams: isURLSearchParams,\n  isStandardBrowserEnv: isStandardBrowserEnv,\n  forEach: forEach,\n  merge: merge,\n  extend: extend,\n  trim: trim,\n  stripBOM: stripBOM,\n  inherits: inherits,\n  toFlatObject: toFlatObject,\n  kindOf: kindOf,\n  kindOfTest: kindOfTest,\n  endsWith: endsWith,\n  toArray: toArray,\n  isTypedArray: isTypedArray,\n  isFileList: isFileList\n};\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n  utils.forEach(headers, function processHeader(value, name) {\n    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n      headers[normalizedName] = value;\n      delete headers[name];\n    }\n  });\n};\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","'use strict';\n\nmodule.exports = {\n  silentJSONParsing: true,\n  forcedJSONParsing: true,\n  clarifyTimeoutError: false\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar mergeConfig = require('./core/mergeConfig');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  var context = new Axios(defaultConfig);\n  var instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context);\n\n  // Copy context to instance\n  utils.extend(instance, context);\n\n  // Factory for creating new instances\n  instance.create = function create(instanceConfig) {\n    return createInstance(mergeConfig(defaultConfig, instanceConfig));\n  };\n\n  return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Expose Cancel & CancelToken\naxios.CanceledError = require('./cancel/CanceledError');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\naxios.VERSION = require('./env/data').version;\naxios.toFormData = require('./helpers/toFormData');\n\n// Expose AxiosError class\naxios.AxiosError = require('../lib/core/AxiosError');\n\n// alias for CanceledError for backward compatibility\naxios.Cancel = axios.CanceledError;\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\n// Expose isAxiosError\naxios.isAxiosError = require('./helpers/isAxiosError');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(url);\n};\n","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47 /*/*/;\n  var end = -1;\n  var matchedSlash = true;\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n  var f = basename(path);\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  var preDotState = 0;\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1)\n          startDot = i;\n        else if (preDotState !== 1)\n          preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 ||\n      // We saw a non-dot character immediately before the dot\n      preDotState === 0 ||\n      // The (right-most) trimmed path component is exactly '..'\n      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","'use strict';\n\nvar utils = require('../utils');\n\n/**\n * Convert a data object to FormData\n * @param {Object} obj\n * @param {?Object} [formData]\n * @returns {Object}\n **/\n\nfunction toFormData(obj, formData) {\n  // eslint-disable-next-line no-param-reassign\n  formData = formData || new FormData();\n\n  var stack = [];\n\n  function convertValue(value) {\n    if (value === null) return '';\n\n    if (utils.isDate(value)) {\n      return value.toISOString();\n    }\n\n    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {\n      return typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);\n    }\n\n    return value;\n  }\n\n  function build(data, parentKey) {\n    if (utils.isPlainObject(data) || utils.isArray(data)) {\n      if (stack.indexOf(data) !== -1) {\n        throw Error('Circular reference detected in ' + parentKey);\n      }\n\n      stack.push(data);\n\n      utils.forEach(data, function each(value, key) {\n        if (utils.isUndefined(value)) return;\n        var fullKey = parentKey ? parentKey + '.' + key : key;\n        var arr;\n\n        if (value && !parentKey && typeof value === 'object') {\n          if (utils.endsWith(key, '{}')) {\n            // eslint-disable-next-line no-param-reassign\n            value = JSON.stringify(value);\n          } else if (utils.endsWith(key, '[]') && (arr = utils.toArray(value))) {\n            // eslint-disable-next-line func-names\n            arr.forEach(function(el) {\n              !utils.isUndefined(el) && formData.append(fullKey, convertValue(el));\n            });\n            return;\n          }\n        }\n\n        build(value, fullKey);\n      });\n\n      stack.pop();\n    } else {\n      formData.append(parentKey, convertValue(data));\n    }\n  }\n\n  build(obj);\n\n  return formData;\n}\n\nmodule.exports = toFormData;\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n  return relativeURL\n    ? baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '')\n    : baseURL;\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n  this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected, options) {\n  this.handlers.push({\n    fulfilled: fulfilled,\n    rejected: rejected,\n    synchronous: options ? options.synchronous : false,\n    runWhen: options ? options.runWhen : null\n  });\n  return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n  if (this.handlers[id]) {\n    this.handlers[id] = null;\n  }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n  utils.forEach(this.handlers, function forEachHandler(h) {\n    if (h !== null) {\n      fn(h);\n    }\n  });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar AxiosError = require('../core/AxiosError');\nvar utils = require('../utils');\n\n/**\n * A `CanceledError` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction CanceledError(message) {\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED);\n  this.name = 'CanceledError';\n}\n\nutils.inherits(CanceledError, AxiosError, {\n  __CANCEL__: true\n});\n\nmodule.exports = CanceledError;\n"],"sourceRoot":""}