{“version”:3,“sources”:,“names”:[“render”,“_vm”,“this”,“_h”,“$createElement”,“_c”,“_self”,“staticClass”,“_t”,“on”,“$event”,“parent”,“_v”,“directives”,“name”,“rawName”,“value”,“expression”,“attrs”,“oldData”,“newData”,“merge”,“isObject”,“staticRenderFns”,“item”,“Object”,“prototype”,“toString”,“call”,“t”,“match”,“split”,“_l”,“index”,“key”,“class”,“getDiff”,“style”,“_s”,“line”,“type”,“toggle”,“_e”,“show”,“comma”,“getOldDataObj”,“getNewDataObj”,“indent”,“lastLine”,“isArray”,“getOldDataArr”,“getNewDataArr”,“getClass”,“props”,“Array”,“showLeaf”,“default”,“needKey”,“objectType”,“computed”,“textIndent”,“methods”,“length”,“hasOwnProperty”,“getType”,“component”,“_line”,“parseData”,“source”,“parseObject”,“parseArray”,“obj”,“newObj”,“create”,“undefined”,“isString”,“push”,“arr”,“i”,“mergeArr”,“arr1”,“arr2”,“longer”,“merged”,“forEach”,“mergeObj”,“obj1”,“obj2”,“key1”,“keys”,“key2”,“mergeKey”,“Set”,“concat”,“components”,“tree”,“getMergedData”,“watch”,“val”,“mergeData”,“module”,“exports”,“normalizeComponent”,“scriptExports”,“functionalTemplate”,“injectStyles”,“scopeId”,“moduleIdentifier”,“shadowMode”,“hook”,“options”,“_compiled”,“functional”,“_scopeId”,“context”,“$vnode”,“ssrContext”,“VUE_SSR_CONTEXT”,“_registeredComponents”,“add”,“_ssrRegister”,“$root”,“$options”,“shadowRoot”,“_injectStyles”,“originalRender”,“h”,“existing”,“beforeCreate”,“emptyObject”,“freeze”,“isUndef”,“v”,“isDef”,“isTrue”,“isFalse”,“isPrimitive”,“_toString”,“isPlainObject”,“isRegExp”,“isValidArrayIndex”,“n”,“parseFloat”,“String”,“Math”,“floor”,“isFinite”,“isPromise”,“then”,“catch”,“JSON”,“stringify”,“toNumber”,“isNaN”,“makeMap”,“str”,“expectsLowerCase”,“map”,“list”,“toLowerCase”,“isReservedAttribute”,“remove”,“indexOf”,“splice”,“hasOwn”,“cached”,“fn”,“cache”,“hit”,“camelizeRE”,“camelize”,“replace”,“_”,“c”,“toUpperCase”,“capitalize”,“charAt”,“slice”,“hyphenateRE”,“hyphenate”,“polyfillBind”,“ctx”,“boundFn”,“a”,“l”,“arguments”,“apply”,“_length”,“nativeBind”,“bind”,“Function”,“toArray”,“start”,“ret”,“extend”,“to”,“_from”,“toObject”,“res”,“noop”,“b”,“no”,“identity”,“looseEqual”,“isObjectA”,“isObjectB”,“isArrayA”,“isArrayB”,“every”,“e”,“Date”,“getTime”,“keysA”,“keysB”,“looseIndexOf”,“once”,“called”,“SSR_ATTR”,“ASSET_TYPES”,“LIFECYCLE_HOOKS”,“config”,“optionMergeStrategies”,“silent”,“productionTip”,“devtools”,“performance”,“errorHandler”,“warnHandler”,“ignoredElements”,“keyCodes”,“isReservedTag”,“isReservedAttr”,“isUnknownElement”,“getTagNamespace”,“parsePlatformTagName”,“mustUseProp”,“async”,“_lifecycleHooks”,“unicodeRegExp”,“isReserved”,“charCodeAt”,“def”,“enumerable”,“defineProperty”,“writable”,“configurable”,“bailRE”,“RegExp”,“parsePath”,“path”,“test”,“segments”,“_isServer”,“hasProto”,“inBrowser”,“window”,“inWeex”,“WXEnvironment”,“platform”,“weexPlatform”,“UA”,“navigator”,“userAgent”,“isIE”,“isIE9”,“isEdge”,“isIOS”,“isFF”,“nativeWatch”,“supportsPassive”,“opts”,“get”,“addEventListener”,“isServerRendering”,“global”,“env”,“VUE_ENV”,“VUE_DEVTOOLS_GLOBAL_HOOK”,“isNative”,“Ctor”,“_Set”,“hasSymbol”,“Symbol”,“Reflect”,“ownKeys”,“set”,“has”,“clear”,“warn”,“uid”,“Dep”,“id”,“subs”,“addSub”,“sub”,“removeSub”,“depend”,“target”,“addDep”,“notify”,“update”,“targetStack”,“pushTarget”,“popTarget”,“pop”,“VNode”,“tag”,“data”,“children”,“text”,“elm”,“componentOptions”,“asyncFactory”,“ns”,“fnContext”,“fnOptions”,“fnScopeId”,“componentInstance”,“raw”,“isStatic”,“isRootInsert”,“isComment”,“isCloned”,“isOnce”,“asyncMeta”,“isAsyncPlaceholder”,“prototypeAccessors”,“child”,“defineProperties”,“createEmptyVNode”,“node”,“createTextVNode”,“cloneVNode”,“vnode”,“cloned”,“arrayProto”,“arrayMethods”,“methodsToPatch”,“method”,“original”,“args”,“len”,“inserted”,“result”,“ob”,“__ob__”,“observeArray”,“dep”,“arrayKeys”,“getOwnPropertyNames”,“shouldObserve”,“toggleObserving”,“Observer”,“vmCount”,“protoAugment”,“copyAugment”,“walk”,“src”,“__proto__”,“observe”,“asRootData”,“isExtensible”,“_isVue”,“defineReactive$$1”,“customSetter”,“shallow”,“property”,“getOwnPropertyDescriptor”,“getter”,“setter”,“childOb”,“dependArray”,“newVal”,“max”,“del”,“items”,“strats”,“from”,“toVal”,“fromVal”,“mergeDataOrFn”,“parentVal”,“childVal”,“vm”,“instanceData”,“defaultData”,“mergeHook”,“dedupeHooks”,“hooks”,“mergeAssets”,“key$1”,“inject”,“provide”,“defaultStrat”,“normalizeProps”,“normalizeInject”,“normalized”,“normalizeDirectives”,“dirs”,“def$$1”,“mergeOptions”,“_base”,“extends”,“mixins”,“mergeField”,“strat”,“resolveAsset”,“warnMissing”,“assets”,“camelizedId”,“PascalCaseId”,“validateProp”,“propOptions”,“propsData”,“prop”,“absent”,“booleanIndex”,“getTypeIndex”,“Boolean”,“stringIndex”,“getPropDefaultValue”,“prevShouldObserve”,“_props”,“isSameType”,“expectedTypes”,“handleError”,“err”,“info”,“cur”,“$parent”,“errorCaptured”,“capture”,“globalHandleError”,“invokeWithErrorHandling”,“handler”,“_handled”,“logError”,“console”,“error”,“timerFunc”,“isUsingMicroTask”,“callbacks”,“pending”,“flushCallbacks”,“copies”,“Promise”,“p”,“resolve”,“setTimeout”,“MutationObserver”,“setImmediate”,“counter”,“observer”,“textNode”,“document”,“createTextNode”,“characterData”,“nextTick”,“cb”,“_resolve”,“seenObjects”,“traverse”,“_traverse”,“seen”,“isA”,“isFrozen”,“depId”,“normalizeEvent”,“passive”,“once$$1”,“createFnInvoker”,“fns”,“invoker”,“arguments$1”,“updateListeners”,“oldOn”,“remove$$1”,“createOnceHandler”,“old”,“event”,“params”,“mergeVNodeHook”,“hookKey”,“oldHook”,“wrappedHook”,“extractPropsFromVNodeData”,“altKey”,“checkProp”,“hash”,“preserve”,“simpleNormalizeChildren”,“normalizeChildren”,“normalizeArrayChildren”,“isTextNode”,“nestedIndex”,“lastIndex”,“last”,“shift”,“_isVList”,“initProvide”,“_provided”,“initInjections”,“resolveInject”,“provideKey”,“provideDefault”,“resolveSlots”,“slots”,“slot”,“name$1”,“isWhitespace”,“normalizeScopedSlots”,“normalSlots”,“prevSlots”,“hasNormalSlots”,“isStable”,“$stable”,“$key”,“_normalized”,“$hasNormal”,“normalizeScopedSlot”,“key$2”,“proxyNormalSlot”,“proxy”,“renderList”,“iterator”,“next”,“done”,“renderSlot”,“fallback”,“bindObject”,“nodes”,“scopedSlotFn”,“$scopedSlots”,“$slots”,“resolveFilter”,“isKeyNotMatch”,“expect”,“actual”,“checkKeyCodes”,“eventKeyCode”,“builtInKeyCode”,“eventKeyName”,“builtInKeyName”,“mappedKeyCode”,“bindObjectProps”,“asProp”,“isSync”,“loop”,“domProps”,“camelizedKey”,“hyphenatedKey”,“renderStatic”,“isInFor”,“_staticTrees”,“_renderProxy”,“markStatic”,“markOnce”,“markStaticNode”,“bindObjectListeners”,“ours”,“resolveScopedSlots”,“hasDynamicKeys”,“contentHashKey”,“bindDynamicKeys”,“baseObj”,“values”,“prependModifier”,“symbol”,“installRenderHelpers”,“_o”,“_n”,“_q”,“_i”,“_m”,“_f”,“_k”,“_b”,“_u”,“_g”,“_d”,“_p”,“FunctionalRenderContext”,“contextVm”,“this$1”,“_original”,“isCompiled”,“needNormalization”,“listeners”,“injections”,“scopedSlots”,“d”,“createElement”,“createFunctionalComponent”,“mergeProps”,“renderContext”,“cloneAndMarkFunctionalResult”,“vnodes”,“clone”,“componentVNodeHooks”,“init”,“hydrating”,“_isDestroyed”,“keepAlive”,“mountedNode”,“prepatch”,“createComponentInstanceForVnode”,“activeInstance”,“$mount”,“oldVnode”,“updateChildComponent”,“insert”,“_isMounted”,“callHook”,“queueActivatedComponent”,“activateChildComponent”,“destroy”,“deactivateChildComponent”,“$destroy”,“hooksToMerge”,“createComponent”,“baseCtor”,“cid”,“resolveAsyncComponent”,“createAsyncPlaceholder”,“resolveConstructorOptions”,“model”,“transformModel”,“nativeOn”,“abstract”,“installComponentHooks”,“_isComponent”,“_parentVnode”,“inlineTemplate”,“toMerge”,“_merged”,“mergeHook$1”,“f1”,“f2”,“callback”,“SIMPLE_NORMALIZE”,“ALWAYS_NORMALIZE”,“normalizationType”,“alwaysNormalize”,“_createElement”,“is”,“pre”,“applyNS”,“registerDeepBindings”,“force”,“initRender”,“_vnode”,“parentVnode”,“_renderChildren”,“parentData”,“_parentListeners”,“currentRenderingInstance”,“renderMixin”,“Vue”,“$nextTick”,“_render”,“ref”,“ensureCtor”,“comp”,“base”,“__esModule”,“toStringTag”,“factory”,“errorComp”,“resolved”,“owner”,“owners”,“loading”,“loadingComp”,“sync”,“timerLoading”,“timerTimeout”,“$on”,“forceRender”,“renderCompleted”,“$forceUpdate”,“clearTimeout”,“reject”,“reason”,“delay”,“timeout”,“getFirstComponentChild”,“initEvents”,“_events”,“_hasHookEvent”,“updateComponentListeners”,“remove$1”,“$off”,“_target”,“onceHandler”,“oldListeners”,“eventsMixin”,“hookRE”,“$once”,“i$1”,“cbs”,“$emit”,“setActiveInstance”,“prevActiveInstance”,“initLifecycle”,“$children”,“$refs”,“_watcher”,“_inactive”,“_directInactive”,“_isBeingDestroyed”,“lifecycleMixin”,“_update”,“prevEl”,“$el”,“prevVnode”,“restoreActiveInstance”,“__patch__”,“__vue__”,“teardown”,“_watchers”,“_data”,“mountComponent”,“el”,“updateComponent”,“Watcher”,“before”,“renderChildren”,“newScopedSlots”,“oldScopedSlots”,“hasDynamicScopedSlot”,“needsForceUpdate”,“$attrs”,“$listeners”,“propKeys”,“_propKeys”,“isInInactiveTree”,“direct”,“handlers”,“j”,“queue”,“activatedChildren”,“waiting”,“flushing”,“resetSchedulerState”,“currentFlushTimestamp”,“getNow”,“now”,“createEvent”,“timeStamp”,“flushSchedulerQueue”,“watcher”,“sort”,“run”,“activatedQueue”,“updatedQueue”,“callActivatedHooks”,“callUpdatedHooks”,“emit”,“queueWatcher”,“uid$2”,“expOrFn”,“isRenderWatcher”,“deep”,“user”,“lazy”,“active”,“dirty”,“deps”,“newDeps”,“depIds”,“newDepIds”,“cleanupDeps”,“tmp”,“oldValue”,“evaluate”,“sharedPropertyDefinition”,“sourceKey”,“initState”,“initProps”,“initMethods”,“initData”,“initComputed”,“initWatch”,“propsOptions”,“isRoot”,“getData”,“computedWatcherOptions”,“watchers”,“_computedWatchers”,“isSSR”,“userDef”,“defineComputed”,“shouldCache”,“createComputedGetter”,“createGetterInvoker”,“createWatcher”,“$watch”,“stateMixin”,“dataDef”,“propsDef”,“$set”,“$delete”,“immediate”,“uid$3”,“initMixin”,“_init”,“_uid”,“initInternalComponent”,“constructor”,“vnodeComponentOptions”,“_componentTag”,“super”,“superOptions”,“cachedSuperOptions”,“modifiedOptions”,“resolveModifiedOptions”,“extendOptions”,“modified”,“latest”,“sealed”,“sealedOptions”,“initUse”,“use”,“plugin”,“installedPlugins”,“_installedPlugins”,“unshift”,“install”,“initMixin$1”,“mixin”,“initExtend”,“Super”,“SuperId”,“cachedCtors”,“_Ctor”,“Sub”,“initProps$1”,“initComputed$1”,“Comp”,“initAssetRegisters”,“definition”,“getComponentName”,“matches”,“pattern”,“pruneCache”,“keepAliveInstance”,“filter”,“cachedNode”,“pruneCacheEntry”,“current”,“cached$$1”,“patternTypes”,“KeepAlive”,“include”,“exclude”,“Number”,“created”,“destroyed”,“mounted”,“ref$1”,“parseInt”,“builtInComponents”,“initGlobalAPI”,“configDef”,“util”,“defineReactive”,“delete”,“observable”,“version”,“acceptValue”,“attr”,“isEnumeratedAttr”,“isValidContentEditableValue”,“convertEnumeratedValue”,“isFalsyAttrValue”,“isBooleanAttr”,“xlinkNS”,“isXlink”,“getXlinkProp”,“genClassForVnode”,“parentNode”,“childNode”,“mergeClassData”,“renderClass”,“dynamicClass”,“stringifyClass”,“stringifyArray”,“stringifyObject”,“stringified”,“namespaceMap”,“svg”,“math”,“isHTMLTag”,“isSVG”,“unknownElementCache”,“HTMLUnknownElement”,“HTMLElement”,“isTextInputType”,“query”,“selected”,“querySelector”,“createElement$1”,“tagName”,“multiple”,“setAttribute”,“createElementNS”,“namespace”,“createComment”,“insertBefore”,“newNode”,“referenceNode”,“removeChild”,“appendChild”,“nextSibling”,“setTextContent”,“textContent”,“setStyleScope”,“nodeOps”,“registerRef”,“isRemoval”,“refs”,“refInFor”,“emptyNode”,“sameVnode”,“sameInputType”,“typeA”,“typeB”,“createKeyToOldIdx”,“beginIdx”,“endIdx”,“createPatchFunction”,“backend”,“modules”,“emptyNodeAt”,“createRmCb”,“childElm”,“removeNode”,“createElm”,“insertedVnodeQueue”,“parentElm”,“refElm”,“nested”,“ownerArray”,“setScope”,“createChildren”,“invokeCreateHooks”,“isReactivated”,“initComponent”,“reactivateComponent”,“pendingInsert”,“isPatchable”,“innerNode”,“transition”,“activate”,“ref$$1”,“ancestor”,“addVnodes”,“startIdx”,“invokeDestroyHook”,“removeVnodes”,“ch”,“removeAndInvokeRemoveHook”,“rm”,“updateChildren”,“oldCh”,“newCh”,“removeOnly”,“oldKeyToIdx”,“idxInOld”,“vnodeToMove”,“oldStartIdx”,“newStartIdx”,“oldEndIdx”,“oldStartVnode”,“oldEndVnode”,“newEndIdx”,“newStartVnode”,“newEndVnode”,“canMove”,“patchVnode”,“findIdxInOld”,“end”,“hydrate”,“postpatch”,“invokeInsertHook”,“initial”,“isRenderedModule”,“inVPre”,“hasChildNodes”,“innerHTML”,“childrenMatch”,“firstChild”,“fullInvoke”,“isInitialPatch”,“isRealElement”,“nodeType”,“hasAttribute”,“removeAttribute”,“oldElm”,“_leaveCb”,“patchable”,“i$2”,“updateDirectives”,“oldDir”,“dir”,“isCreate”,“isDestroy”,“oldDirs”,“normalizeDirectives$1”,“newDirs”,“dirsWithInsert”,“dirsWithPostpatch”,“oldArg”,“arg”,“callHook$1”,“componentUpdated”,“callInsert”,“emptyModifiers”,“modifiers”,“getRawDirName”,“join”,“baseModules”,“updateAttrs”,“inheritAttrs”,“oldAttrs”,“setAttr”,“removeAttributeNS”,“baseSetAttr”,“setAttributeNS”,“__ieph”,“blocker”,“stopImmediatePropagation”,“removeEventListener”,“updateClass”,“cls”,“transitionClass”,“_transitionClasses”,“_prevClass”,“target$1”,“klass”,“RANGE_TOKEN”,“CHECKBOX_RADIO_TOKEN”,“normalizeEvents”,“change”,“createOnceHandler$1”,“remove$2”,“useMicrotaskFix”,“add$1”,“attachedTimestamp”,“_wrapper”,“currentTarget”,“ownerDocument”,“updateDOMListeners”,“svgContainer”,“events”,“updateDOMProps”,“oldProps”,“childNodes”,“_value”,“strCur”,“shouldUpdateValue”,“checkVal”,“composing”,“isNotInFocusAndDirty”,“isDirtyWithModifiers”,“notInFocus”,“activeElement”,“_vModifiers”,“number”,“trim”,“parseStyleText”,“cssText”,“listDelimiter”,“propertyDelimiter”,“normalizeStyleData”,“normalizeStyleBinding”,“staticStyle”,“bindingStyle”,“getStyle”,“checkChild”,“styleData”,“emptyStyle”,“cssVarRE”,“importantRE”,“setProp”,“setProperty”,“normalizedName”,“normalize”,“vendorNames”,“capName”,“updateStyle”,“oldStaticStyle”,“oldStyleBinding”,“normalizedStyle”,“oldStyle”,“newStyle”,“whitespaceRE”,“addClass”,“classList”,“getAttribute”,“removeClass”,“tar”,“resolveTransition”,“css”,“autoCssTransition”,“enterClass”,“enterToClass”,“enterActiveClass”,“leaveClass”,“leaveToClass”,“leaveActiveClass”,“hasTransition”,“TRANSITION”,“ANIMATION”,“transitionProp”,“transitionEndEvent”,“animationProp”,“animationEndEvent”,“ontransitionend”,“onwebkittransitionend”,“onanimationend”,“onwebkitanimationend”,“raf”,“requestAnimationFrame”,“nextFrame”,“addTransitionClass”,“transitionClasses”,“removeTransitionClass”,“whenTransitionEnds”,“expectedType”,“getTransitionInfo”,“propCount”,“ended”,“onEnd”,“transformRE”,“styles”,“getComputedStyle”,“transitionDelays”,“transitionDurations”,“transitionTimeout”,“getTimeout”,“animationDelays”,“animationDurations”,“animationTimeout”,“hasTransform”,“delays”,“durations”,“toMs”,“s”,“enter”,“toggleDisplay”,“cancelled”,“_enterCb”,“appearClass”,“appearToClass”,“appearActiveClass”,“beforeEnter”,“afterEnter”,“enterCancelled”,“beforeAppear”,“appear”,“afterAppear”,“appearCancelled”,“duration”,“transitionNode”,“isAppear”,“startClass”,“activeClass”,“toClass”,“beforeEnterHook”,“enterHook”,“afterEnterHook”,“enterCancelledHook”,“explicitEnterDuration”,“expectsCSS”,“userWantsControl”,“getHookArgumentsLength”,“pendingNode”,“_pending”,“isValidDuration”,“leave”,“beforeLeave”,“afterLeave”,“leaveCancelled”,“delayLeave”,“explicitLeaveDuration”,“performLeave”,“invokerFns”,“_enter”,“platformModules”,“patch”,“vmodel”,“trigger”,“directive”,“binding”,“_vOptions”,“setSelected”,“getValue”,“onCompositionStart”,“onCompositionEnd”,“prevOptions”,“curOptions”,“some”,“o”,“needReset”,“hasNoMatchingOption”,“actuallySetSelected”,“isMultiple”,“option”,“selectedIndex”,“initEvent”,“dispatchEvent”,“locateNode”,“transition$$1”,“originalDisplay”,“__vOriginalDisplay”,“display”,“unbind”,“platformDirectives”,“transitionProps”,“mode”,“getRealChild”,“compOptions”,“extractTransitionData”,“placeholder”,“rawChild”,“hasParentTransition”,“isSameChild”,“oldChild”,“isNotTextNode”,“isVShowDirective”,“Transition”,“_leaving”,“oldRawChild”,“delayedLeave”,“moveClass”,“TransitionGroup”,“beforeMount”,“kept”,“prevChildren”,“rawChildren”,“transitionData”,“removed”,“c$1”,“pos”,“getBoundingClientRect”,“updated”,“hasMove”,“callPendingCbs”,“recordPosition”,“applyTranslation”,“_reflow”,“body”,“offsetHeight”,“moved”,“transform”,“WebkitTransform”,“transitionDuration”,“_moveCb”,“propertyName”,“_hasMove”,“cloneNode”,“newPos”,“oldPos”,“dx”,“left”,“dy”,“top”,“platformComponents”,“condition”,“message”,“isError”,“isRouterError”,“errorType”,“_isRouter”,“View”,“routerView”,“route”,“$route”,“_routerViewCache”,“depth”,“inactive”,“_routerRoot”,“vnodeData”,“routerViewDepth”,“cachedData”,“cachedComponent”,“configProps”,“fillPropsinData”,“matched”,“registerRouteInstance”,“instances”,“propsToPass”,“resolveProps”,“encodeReserveRE”,“encodeReserveReplacer”,“commaRE”,“encode”,“encodeURIComponent”,“decode”,“decodeURIComponent”,“resolveQuery”,“extraQuery”,“_parseQuery”,“parsedQuery”,“parse”,“parseQuery”,“param”,“parts”,“stringifyQuery”,“val2”,“x”,“trailingSlashRE”,“createRoute”,“record”,“location”,“redirectedFrom”,“router”,“meta”,“fullPath”,“getFullPath”,“formatMatch”,“START”,“_stringifyQuery”,“isSameRoute”,“isObjectEqual”,“aKeys”,“bKeys”,“aVal”,“bVal”,“isIncludedRoute”,“queryIncludes”,“resolvePath”,“relative”,“append”,“firstChar”,“stack”,“segment”,“hashIndex”,“queryIndex”,“cleanPath”,“isarray”,“pathToRegexp_1”,“pathToRegexp”,“parse_1”,“compile_1”,“compile”,“tokensToFunction_1”,“tokensToFunction”,“tokensToRegExp_1”,“tokensToRegExp”,“PATH_REGEXP”,“tokens”,“defaultDelimiter”,“delimiter”,“exec”,“m”,“escaped”,“offset”,“prefix”,“group”,“modifier”,“asterisk”,“partial”,“repeat”,“optional”,“escapeGroup”,“escapeString”,“substr”,“encodeURIComponentPretty”,“encodeURI”,“encodeAsterisk”,“flags”,“pretty”,“token”,“TypeError”,“attachKeys”,“re”,“sensitive”,“regexpToRegexp”,“groups”,“arrayToRegexp”,“regexp”,“stringToRegexp”,“strict”,“endsWithDelimiter”,“regexpCompileCache”,“fillParams”,“routeMsg”,“filler”,“pathMatch”,“normalizeLocation”,“params$1”,“rawPath”,“parsedPath”,“basePath”,“_Vue”,“toTypes”,“eventTypes”,“Link”,“required”,“exact”,“exactActiveClass”,“ariaCurrentValue”,“$router”,“href”,“classes”,“globalActiveClass”,“linkActiveClass”,“globalExactActiveClass”,“linkExactActiveClass”,“activeClassFallback”,“exactActiveClassFallback”,“compareTarget”,“guardEvent”,“click”,“scopedSlot”,“navigate”,“isActive”,“isExactActive”,“findAnchor”,“aData”,“handler$1”,“event$1”,“aAttrs”,“metaKey”,“ctrlKey”,“shiftKey”,“defaultPrevented”,“button”,“preventDefault”,“installed”,“registerInstance”,“callVal”,“_router”,“history”,“_route”,“beforeRouteEnter”,“beforeRouteLeave”,“beforeRouteUpdate”,“createRouteMap”,“routes”,“oldPathList”,“oldPathMap”,“oldNameMap”,“pathList”,“pathMap”,“nameMap”,“addRouteRecord”,“matchAs”,“pathToRegexpOptions”,“normalizedPath”,“normalizePath”,“caseSensitive”,“regex”,“compileRouteRegex”,“redirect”,“childMatchAs”,“alias”,“aliases”,“aliasRoute”,“createMatcher”,“addRoutes”,“currentRoute”,“_createRoute”,“paramNames”,“record$1”,“matchRoute”,“originalRedirect”,“resolveRecordPath”,“resolvedPath”,“aliasedPath”,“aliasedMatch”,“aliasedRecord”,“Time”,“genStateKey”,“toFixed”,“_key”,“getStateKey”,“setStateKey”,“positionStore”,“setupScroll”,“scrollRestoration”,“protocolAndPath”,“protocol”,“host”,“absolutePath”,“stateCopy”,“state”,“replaceState”,“handlePopState”,“handleScroll”,“isPop”,“app”,“behavior”,“scrollBehavior”,“position”,“getScrollPosition”,“shouldScroll”,“scrollToPosition”,“saveScrollPosition”,“pageXOffset”,“y”,“pageYOffset”,“getElementPosition”,“docEl”,“documentElement”,“docRect”,“elRect”,“isValidPosition”,“isNumber”,“normalizePosition”,“normalizeOffset”,“hashStartsWithNumberRE”,“selector”,“getElementById”,“scrollTo”,“supportsPushState”,“ua”,“pushState”,“url”,“runQueue”,“step”,“resolveAsyncComponents”,“hasAsync”,“flatMapComponents”,“resolvedDef”,“isESModule”,“msg”,“Error”,“flatten”,“NavigationFailureType”,“redirected”,“aborted”,“duplicated”,“createNavigationRedirectedError”,“createRouterError”,“stringifyRoute”,“createNavigationDuplicatedError”,“createNavigationCancelledError”,“createNavigationAbortedError”,“propertiesToLog”,“History”,“normalizeBase”,“ready”,“readyCbs”,“readyErrorCbs”,“errorCbs”,“baseEl”,“resolveQueue”,“activated”,“deactivated”,“extractGuards”,“records”,“reverse”,“guards”,“instance”,“guard”,“extractGuard”,“extractLeaveGuards”,“bindGuard”,“extractUpdateHooks”,“extractEnterGuards”,“isValid”,“bindEnterGuard”,“poll”,“listen”,“onReady”,“errorCb”,“onError”,“transitionTo”,“onComplete”,“onAbort”,“confirmTransition”,“prev”,“updateRoute”,“ensureURL”,“afterHooks”,“abort”,“lastRouteIndex”,“lastCurrentIndex”,“beforeHooks”,“postEnterCbs”,“enterGuards”,“resolveHooks”,“setupListeners”,“teardownListeners”,“cleanupListener”,“HTML5History”,“_startLocation”,“getLocation”,“expectScroll”,“supportsScroll”,“handleRoutingEvent”,“go”,“fromRoute”,“getCurrentLocation”,“decodeURI”,“pathname”,“search”,“HashHistory”,“checkFallback”,“ensureSlash”,“getHash”,“replaceHash”,“eventType”,“pushHash”,“searchIndex”,“getUrl”,“AbstractHistory”,“targetIndex”,“VueRouter”,“apps”,“matcher”,“registerHook”,“createHref”,“beforeEach”,“beforeResolve”,“afterEach”,“back”,“forward”,“getMatchedComponents”,“normalizedTo”,“g”],“mappings”:“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”,“file”:“js/chunk-vendors.0f99b670.js”,“sourcesContent”:[“import mod from "-!../../mini-css-extract-plugin/dist/loader.js??ref–6-oneOf-1-0!../../css-loader/dist/cjs.js??ref–6-oneOf-1-1!../../vue-loader/lib/loaders/stylePostLoader.js!../../postcss-loader/src/index.js??ref–6-oneOf-1-2!../../cache-loader/dist/cjs.js??ref–0-0!../../vue-loader/lib/index.js??vue-loader-options!./vuejsoncompare.vue?vue&type=style&index=0&lang=css&"; export default mod; export * from "-!../../mini-css-extract-plugin/dist/loader.js??ref–6-oneOf-1-0!../../css-loader/dist/cjs.js??ref–6-oneOf-1-1!../../vue-loader/lib/loaders/stylePostLoader.js!../../postcss-loader/src/index.js??ref–6-oneOf-1-2!../../cache-loader/dist/cjs.js??ref–0-0!../../vue-loader/lib/index.js??vue-loader-options!./vuejsoncompare.vue?vue&type=style&index=0&lang=css&"”,“var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"alpaca-json"},[(_vm.isTheSameType)?_vm._t("default",[(_vm.isObject)?_c('p',{staticClass:"alpaca-f",on:{"click":function($event){_vm.parent=!_vm.parent}}},[_vm._v(" { "),_c('span',{directives:},[_vm._v("… }")])]):_c('p',{staticClass:"alpaca-f",on:{"click":function($event){_vm.parent=!_vm.parent}}},[_vm._v(" [ "),_c('span',{directives:},[_vm._v("… ]")])]),_c('tree',{directives:,attrs:{"oldData":_vm.oldData,"newData":_vm.newData,"merge":_vm.merge,"needKey":_vm.isObject,"objectType":_vm.isObject}}),(_vm.isObject)?_c('p',{directives:},[_vm._v("}")]):_c('p',{directives:},[_vm._v("]")])]):_vm._t("default",)],2)}nvar staticRenderFns = []nnexport { render, staticRenderFns }”,“export default {n isArray(item) {n return Object.prototype.toString.call(item) === '[object Array]';n },n isObject(item) {n return Object.prototype.toString.call(item) === '[object Object]';n },n isNull(item) {n return Object.prototype.toString.call(item) === '[object Null]';n },n isNumber(item) {n return typeof item === 'number';n },n isString(item) {n return typeof item === 'string';n },n isBoolean(item) {n return typeof item === 'boolean';n },n isUndefined(item) {n return typeof item === 'undefined';n },n getType(item) {n let t = Object.prototype.toString.call(item);n let match = /(?!\[).+(?=\])/g;n t = t.match(match).split(' ')[1];n return t;n }n};n”,“var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',_vm._l((_vm.merge),function(item,index){return _c('p',{key:index,staticClass:"alpaca-p",class:_vm.getDiff(item, index),style:(_vm.getStyle)},[_c('span',{staticClass:"alpaca-line"},[_vm._v(_vm._s(item.line))]),(_vm.isObject(item.type))?_vm._t("default",[_c('p',{staticClass:"alpaca-f",on:{"click":function($event){return _vm.toggle(item)}}},[(_vm.needKey)?_c('span',{staticClass:"alpaca-k"},[_vm._v("\""+_vm._s(item.key)+"\":")]):_vm._e(),_c('span',{staticClass:"alpaca-k"},[_vm._v("{")]),_c('span',{directives:,staticClass:"alpaca-k"},[_vm._v("… } "+_vm._s(_vm.comma(index)))])]),_c('self',{directives:,attrs:{"oldData":_vm.getOldDataObj(item),"newData":_vm.getNewDataObj(item),"merge":item.value,"objectType":true,"showLeaf":false,"indent":_vm.indent+1,"needKey":true}}),_c('p',{directives:,staticClass:"alpaca-p",class:_vm.getDiff(item, index),style:(_vm.getStyle)},[_c('span',{staticClass:"alpaca-line"},[_vm._v(_vm._s(item.lastLine))]),_c('span',{staticClass:"alpaca-k"},[_vm._v("} "+_vm._s(_vm.comma(index)))])])]):(_vm.isArray(item.type))?_vm._t("default",[_c('p',{staticClass:"alpaca-f",on:{"click":function($event){return _vm.toggle(item)}}},[(_vm.needKey)?_c('span',{staticClass:"alpaca-k"},[_vm._v("\""+_vm._s(item.key)+"\":")]):_vm._e(),_c('span',{staticClass:"alpaca-k"},[_vm._v("),_c('span',{directives:,staticClass:"alpaca-k"},[_vm._v("… ] "+_vm._s(_vm.comma(index)))])]),_c('self',{directives:,attrs:{"oldData":_vm.getOldDataArr(item),"newData":_vm.getNewDataArr(item),"merge":item.value,"showLeaf":false,"objectType":false,"indent":_vm.indent+1,"needKey":false}}),_c('p',{directives:,staticClass:"alpaca-p",class:_vm.getDiff(item, index),style:(_vm.getStyle)},[_c('span',{staticClass:"alpaca-line"},[_vm._v(_vm._s(item.lastLine))]),_c('span',{staticClass:"alpaca-k"},[_vm._v("] "+_vm._s(_vm.comma(index)))])])]):_vm._t("default",[(_vm.needKey)?_c(‘span’,{staticClass:"alpaca-k"},):_vm._e(),_c('span',{class:_vm.getClass(item.type)},[_vm._v(_vm._s(item.value)+_vm._s(_vm.comma(index)))])])],2)}),0)}nvar staticRenderFns = []nnexport { render, staticRenderFns }”,“<template>n <div>n <pn class="alpaca-p"n v-for="(item, index) in merge"n :key="index"n :style="getStyle"n :class="getDiff(item, index)"n >n <span class="alpaca-line">{{ item.line }}</span>n <slot v-if="isObject(item.type)">n <p @click="toggle(item)" class="alpaca-f">n <span v-if="needKey" class="alpaca-k">"{{ item.key }}":</span>n <span class="alpaca-k">{</span>n <span class="alpaca-k" v-show="!item.show">… } {{ comma(index) }}</span>n </p>n <selfn v-show="item.show"n :oldData="getOldDataObj(item)"n :newData="getNewDataObj(item)"n :merge="item.value"n :objectType="true"n :showLeaf="false"n :indent="indent+1"n :needKey="true"n ></self>n <p v-show="item.show" :style="getStyle" class="alpaca-p" :class="getDiff(item, index)">n <span class="alpaca-line">{{ item.lastLine }}</span>n <span class="alpaca-k">} {{ comma(index) }}</span>n </p>n </slot>n <slot v-else-if="isArray(item.type)">n <p @click="toggle(item)" class="alpaca-f">n <span v-if="needKey" class="alpaca-k">"{{ item.key }}":</span>n <span class="alpaca-k">[</span>n <span class="alpaca-k" v-show="!item.show">… ] {{ comma(index) }}</span>n </p>n <selfn v-show="item.show"n :oldData="getOldDataArr(item)"n :newData="getNewDataArr(item)"n :merge="item.value"n :showLeaf="false"n :objectType="false"n :indent="indent+1"n :needKey="false"n ></self>n <p v-show="item.show" :style="getStyle" class="alpaca-p" :class="getDiff(item, index)">n <span class="alpaca-line">{{ item.lastLine }}</span>n <span class="alpaca-k">] {{ comma(index) }}</span>n </p>n </slot>n <slot v-else>n <span v-if="needKey" class="alpaca-k">"{{ item.key }}":</span>n <span :class="getClass(item.type)">{{ item.value }}{{ comma(index) }}</span>n </slot>n </p>n </div>n</template>nn<script>nimport check from "./typeof.js";nexport default {n name: "self",n props: {n oldData: {n type: [Object, Array]n },n newData: {n type: [Object, Array]n },n merge: {n type: [Object, Array]n },n showLeaf: {n default: truen },n indent: {n default: 1n },n needKey: {n default: truen },n objectType: {n default: truen }n },n computed: {n getStyle() {n return { textIndent: `${(this.indent + 1) * 20}px` };n }n },n methods: {n notTree(type) {n return type !== "Object" && type !== "Array";n },n toggle(item) {n item.show = !item.show;n },n isObject(type) {n return type === "Object";n },n isArray(type) {n return type === "Array";n },n comma(index) {n if (index === this.merge.length - 1) {n return "";n }n return ",";n },n getClass(type) {n if (type === "Number") {n return "alpaca-number";n }n if (type === "String") {n return "alpaca-string";n }n if (type === "Boolean") {n return "alpaca-boolean";n }n if (type === "Undefined") {n return "alpaca-undefined";n }n if (type === "Null") {n return "alpaca-null";n }n // 其他不改变颜色n return "";n },n getOldDataObj(item) {n if (this.oldData.hasOwnProperty(item.key)) {n if (check.isObject(this.oldData)) {n return this.oldData;n }n }n return {};n },n getNewDataObj(item) {n if (this.newData.hasOwnProperty(item.key)) {n if (check.isObject(this.newData)) {n return this.newData;n }n }n return {};n },n getOldDataArr(item) {n if (this.oldData.hasOwnProperty(item.key)) {n if (check.isArray(this.oldData)) {n return this.oldData;n }n }n return [];n },n getNewDataArr(item) {n if (this.newData.hasOwnProperty(item.key)) {n if (check.isArray(this.newData)) {n return this.newData;n }n }n return [];n },n getDiff(item, index) {n let oldData = this.oldData;n let newData = this.newData;n if (this.objectType) {n // 对象,对比Keyn if (n oldData.hasOwnProperty(item.key) &&n newData.hasOwnProperty(item.key)n ) {n // 类型不同n if (n check.getType(oldData) !==n check.getType(newData)n ) {n return "alpaca-upd";n } else {n // 类型相同n if (n !check.isArray(oldData) &&n !check.isObject(oldData)n ) {n if (oldData !== newData) {n return "alpaca-upd";n }n }n }n }n if (n oldData.hasOwnProperty(item.key) &&n !newData.hasOwnProperty(item.key)n ) {n return "alpaca-del";n }n if (n !oldData.hasOwnProperty(item.key) &&n newData.hasOwnProperty(item.key)n ) {n return "alpaca-add";n }n // 无变化n return "";n }n // 数组,对比下标n if (n oldData.hasOwnProperty(item.key) &&n newData.hasOwnProperty(item.key)n ) {n // 类型不同n if (n check.getType(oldData) !== check.getType(newData)n ) {n return "alpaca-upd";n } else {n // 类型相同n if (n !check.isObject(oldData) &&n !check.isArray(oldData)n ) {n if (oldData !== newData) {n return "alpaca-upd";n }n }n }n }n if (n oldData.hasOwnProperty(item.key) &&n !newData.hasOwnProperty(item.key)n ) {n return "alpaca-del";n }n if (n !oldData.hasOwnProperty(item.key) &&n newData.hasOwnProperty(item.key)n ) {n return "alpaca-add";n }n // 无改变n return "";n }n }n};n</script>n”,“import mod from "-!../../cache-loader/dist/cjs.js??ref–0-0!../../vue-loader/lib/index.js??vue-loader-options!./tree.vue?vue&type=script&lang=js&"; export default mod; export * from "-!../../cache-loader/dist/cjs.js??ref–0-0!../../vue-loader/lib/index.js??vue-loader-options!./tree.vue?vue&type=script&lang=js&"”,“import { render, staticRenderFns } from "./tree.vue?vue&type=template&id=a0e3b4ee&"nimport script from "./tree.vue?vue&type=script&lang=js&"nexport * from "./tree.vue?vue&type=script&lang=js&"nnn/* normalize component */nimport normalizer from "!../../vue-loader/lib/runtime/componentNormalizer.js"nvar component = normalizer(n script,n render,n staticRenderFns,n false,n null,n null,n nulln n)nnexport default component.exports”,“import check from './typeof.js';nnlet _line = 1;nnconst parseData = source => {n _line = 1;n let newData = [];n if (check.isObject(source)) {n newData = parseObject(source);n } else if (check.isArray(source)) {n newData = parseArray(source);n } else {n return [n {n key: '',n value: 'error: data should be an Object or Array type',n type: 'String',n line: '1'n }n ];n }n return newData;n};nnconst parseObject = obj => {n let newData = [];n for (let key in obj) {n let newObj = Object.create(null);n newObj.type = check.getType(obj);n newObj.line = _line++;n newObj.key = key;n if (check.isObject(obj)) {n newObj.value = parseObject(obj, _line);n newObj.lastLine = _line++;n newObj.show = true;n } else if (check.isArray(obj)) {n newObj.value = parseArray(obj, _line);n newObj.lastLine = _line++;n newObj.show = true;n } else {n if (obj === null) {n newObj.value = 'null';n } else if (obj === undefined) {n newObj.value = 'undefined';n } else {n if (check.isString(obj)) {n newObj.value = '"' + obj + '"';n } else {n newObj.value = obj;n }n }n }n newData.push(newObj);n }n return newData;n};nnconst parseArray = arr => {n let newData = [];n for (let i = 0; i < arr.length; i++) {n let newObj = Object.create(null);n newObj.type = check.getType(arr);n newObj.key = i;n newObj.line = _line++;n if (check.isObject(arr)) {n newObj.value = parseObject(arr, _line);n newObj.lastLine = _line++;n newObj.show = true;n } else if (check.isArray(arr)) {n newObj.value = parseArray(arr, _line);n newObj.lastLine = _line++;n newObj.show = true;n } else {n if (arr === null) {n newObj.value = 'null';n } else if (arr === undefined) {n newObj.value = 'undefined';n } else {n if (check.isString(arr)) {n newObj.value = '"' + arr + '"';n } else {n newObj.value = arr;n }n }n }n newData.push(newObj);n }n return newData;n};nnexport default parseData;n”,“<template>n <div class="alpaca-json">n <slot v-if="isTheSameType">n <p v-if="isObject" @click="parent=!parent" class="alpaca-f">n {n <span v-show="!parent">… }</span>n </p>n <p v-else @click="parent=!parent" class="alpaca-f">n [n <span v-show="!parent">… ]</span>n </p>n <treen v-show="parent"n :oldData="oldData"n :newData="newData"n :merge="merge"n :needKey="isObject"n :objectType="isObject"n ></tree>n <p v-if="isObject" v-show="parent">}</p>n <p v-else v-show="parent">]</p>n </slot>n <slot v-else>类型不一致,无法对比</slot>n </div>n</template>nn<script>nimport check from "./typeof.js";nimport tree from "./tree.vue";nimport parseData from "./parsing.js";nconst mergeArr = (arr1, arr2) => {n let longer = [];n let merged = [];n if (arr1.length > arr2.length) {n longer = arr1;n } else {n longer = arr2;n }n longer.forEach((item, index) => {n if (arr1.hasOwnProperty(index) && arr2.hasOwnProperty(index)) {n if (check.getType(arr2) === check.getType(arr1)) {n if (check.isArray(arr2)) {n merged.push(mergeArr(arr1, arr2));n } else if (check.isObject(arr2)) {n merged.push(mergeObj(arr1, arr2));n } else {n merged.push(arr2);n }n } else {n merged.push(arr2);n }n } else {n if (arr2.hasOwnProperty(index)) {n merged.push(arr2);n } else {n merged.push(arr1);n }n }n });n return merged;n};nconst mergeObj = (obj1, obj2) => {n let key1 = Object.keys(obj1);n let key2 = Object.keys(obj2);n let mergeKey = […new Set(key1.concat(key2))];n let merged = Object.create(null);n mergeKey.forEach(key => {n if (obj1.hasOwnProperty(key) && obj2.hasOwnProperty(key)) {n if (check.getType(obj2) === check.getType(obj1)) {n if (check.isObject(obj2)) {n merged = mergeObj(obj1, obj2);n } else if (check.isArray(obj2)) {n merged = mergeArr(obj1, obj2);n } else {n merged = obj2;n }n } else {n merged = obj2;n }n } else {n if (obj2.hasOwnProperty(key)) {n merged = obj2;n } else {n merged = obj1;n }n }n });n return merged;n};nexport default {n props: ["oldData", "newData"],n components: {n treen },n data() {n return {n isObject: true,n parent: true,n merge: []n };n },n created() {n this.getMergedData();n },n watch: {n oldData(val) {n this.getMergedData();n },n newData(val) {n this.getMergedData();n }n },n computed: {n isTheSameType() {n return check.getType(this.oldData) === check.getType(this.newData);n }n },n methods: {n getMergedData() {n let mergeData = {};n if (check.isObject(this.newData)) {n this.isObject = true;n } else {n this.isObject = false;n }n if (check.isObject(this.newData) && check.isObject(this.oldData)) {n mergeData = mergeObj(this.oldData, this.newData);n }n if (check.isArray(this.newData) && check.isArray(this.oldData)) {n mergeData = mergeArr(this.oldData, this.newData);n }n this.merge = parseData(mergeData);n }n }n};n</script>nn<style>n.alpaca-json {n padding: 10px 20px;n border-radius: 5px;n color: #032f62;n font-size: 14px;n text-align: left;n font-family: "Avenir", Helvetica, Arial, sans-serif;n background-color: fafbfc;n}n.alpaca-p {n position: relative;n word-break: break-all;n margin: 0;n}n.alpaca-line {n position: absolute;n text-indent: 0;n left: 5px;n top: 2px;n font-size: 12px;n color: #808695;n z-index: 5;n user-select: none;n -moz-user-select: none;n -ms-user-select: none;n -webkit-user-select: none;n}n.alpaca-k {n color: #5cadff;n}n.alpaca-f {n cursor: pointer;n margin: 0;n}n.alpaca-f:hover .alpaca-k {n color: #19be6b;n font-weight: bold;n}n.alpaca-number {n color: ae81ff;n}n.alpaca-string {n color: a6e22e;n}n.alpaca-boolean {n color: #6f73ff;n}n.alpaca-null {n color: #66d9ef;n}n.alpaca-undefined {n color: f92672;n}n.alpaca-del {n position: relative;n background-color: ffeef0;n}n.alpaca-add {n position: relative;n background-color: e6ffed;n}n.alpaca-upd {n position: relative;n background-color: fffde6;n}n.alpaca-add:after {n content: "+";n position: absolute;n left: -10px;n top: 0px;n text-indent: 0;n color: #78ef9a;n}n.alpaca-del:after {n content: "-";n position: absolute;n left: -10px;n top: 0px;n text-indent: 0;n color: f13e53;n}n.alpaca-upd:after {n content: "*";n position: absolute;n left: -10px;n top: 5px;n text-indent: 0;n color: f1e234;n}n.alpaca-upd .alpaca-del,n.alpaca-upd .alpaca-add {n background-color: fffde6;n}n.alpaca-upd .alpaca-del:after,n.alpaca-upd .alpaca-add:after {n content: "*";n color: f1e234;n}n</style>n”,“import mod from "-!../../cache-loader/dist/cjs.js??ref–0-0!../../vue-loader/lib/index.js??vue-loader-options!./vuejsoncompare.vue?vue&type=script&lang=js&"; export default mod; export * from "-!../../cache-loader/dist/cjs.js??ref–0-0!../../vue-loader/lib/index.js??vue-loader-options!./vuejsoncompare.vue?vue&type=script&lang=js&"”,“import { render, staticRenderFns } from "./vuejsoncompare.vue?vue&type=template&id=0fd538f6&"nimport script from "./vuejsoncompare.vue?vue&type=script&lang=js&"nexport * from "./vuejsoncompare.vue?vue&type=script&lang=js&"nimport style0 from "./vuejsoncompare.vue?vue&type=style&index=0&lang=css&"nnn/* normalize component */nimport normalizer from "!../../vue-loader/lib/runtime/componentNormalizer.js"nvar component = normalizer(n script,n render,n staticRenderFns,n false,n null,n null,n nulln n)nnexport default component.exports”,“'use strict';nmodule.exports = require('./src/vuejsoncompare.vue');n”,“/* globals VUE_SSR_CONTEXT */nn// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).n// This module is a runtime utility for cleaner component module output and willn// be included in the final webpack user bundle.nnexport default function normalizeComponent (n scriptExports,n render,n staticRenderFns,n functionalTemplate,n injectStyles,n scopeId,n moduleIdentifier, /* server only */n shadowMode /* vue-cli only */n) {n // Vue.extend constructor export interopn var options = typeof scriptExports === 'function'n ? scriptExports.optionsn : scriptExportsnn // render functionsn if (render) {n options.render = rendern options.staticRenderFns = staticRenderFnsn options._compiled = truen }nn // functional templaten if (functionalTemplate) {n options.functional = truen }nn // scopedIdn if (scopeId) {n options._scopeId = 'data-v-' + scopeIdn }nn var hookn if (moduleIdentifier) { // server buildn hook = function (context) {n // 2.3 injectionn context =n context || // cached calln (this.$vnode && this.$vnode.ssrContext) || // statefuln (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functionaln // 2.2 with runInNewContext: truen if (!context && typeof VUE_SSR_CONTEXT !== 'undefined') {n context = VUE_SSR_CONTEXTn }n // inject component stylesn if (injectStyles) {n injectStyles.call(this, context)n }n // register component module identifier for async chunk inferrencen if (context && context._registeredComponents) {n context._registeredComponents.add(moduleIdentifier)n }n }n // used by ssr in case component is cached and beforeCreaten // never gets calledn options._ssrRegister = hookn } else if (injectStyles) {n hook = shadowModen ? function () {n injectStyles.call(n this,n (options.functional ? this.parent : this).$root.$options.shadowRootn )n }n : injectStylesn }nn if (hook) {n if (options.functional) {n // for template-only hot-reload because in that case the render fn doesn'tn // go through the normalizern options._injectStyles = hookn // register for functional component in vue filen var originalRender = options.rendern options.render = function renderWithStyleInjection (h, context) {n hook.call(context)n return originalRender(h, context)n }n } else {n // inject component registration as beforeCreate hookn var existing = options.beforeCreaten options.beforeCreate = existingn ? [].concat(existing, hook)n : [hook]n }n }nn return {n exports: scriptExports,n options: optionsn }n}n”,“/*!n * Vue.js v2.6.11n * © 2014-2019 Evan Youn * Released under the MIT License.n */n/* */nnvar emptyObject = Object.freeze({});nn// These helpers produce better VM code in JS engines due to theirn// explicitness and function inlining.nfunction isUndef (v) {n return v === undefined || v === nulln}nnfunction isDef (v) {n return v !== undefined && v !== nulln}nnfunction isTrue (v) {n return v === truen}nnfunction isFalse (v) {n return v === falsen}nn/**n * Check if value is primitive.n */nfunction isPrimitive (value) {n return (n typeof value === 'string' ||n typeof value === 'number' ||n // $flow-disable-linen typeof value === 'symbol' ||n typeof value === 'boolean'n )n}nn/**n * Quick object check - this is primarily used to telln * Objects from primitive values when we know the valuen * is a JSON-compliant type.n */nfunction isObject (obj) {n return obj !== null && typeof obj === 'object'n}nn/**n * Get the raw type string of a value, e.g., [object Object].n */nvar _toString = Object.prototype.toString;nnfunction toRawType (value) {n return _toString.call(value).slice(8, -1)n}nn/**n * Strict object type check. Only returns truen * for plain JavaScript objects.n */nfunction isPlainObject (obj) {n return _toString.call(obj) === '[object Object]'n}nnfunction isRegExp (v) {n return _toString.call(v) === '[object RegExp]'n}nn/**n * Check if val is a valid array index.n */nfunction isValidArrayIndex (val) {n var n = parseFloat(String(val));n return n >= 0 && Math.floor(n) === n && isFinite(val)n}nnfunction isPromise (val) {n return (n isDef(val) &&n typeof val.then === 'function' &&n typeof val.catch === 'function'n )n}nn/**n * Convert a value to a string that is actually rendered.n */nfunction toString (val) {n return val == nulln ? ''n : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)n ? JSON.stringify(val, null, 2)n : String(val)n}nn/**n * Convert an input value to a number for persistence.n * If the conversion fails, return original string.n */nfunction toNumber (val) {n var n = parseFloat(val);n return isNaN(n) ? val : nn}nn/**n * Make a map and return a function for checking if a keyn * is in that map.n */nfunction makeMap (n str,n expectsLowerCasen) {n var map = Object.create(null);n var list = str.split(',');n for (var i = 0; i < list.length; i++) {n map[list] = true;n }n return expectsLowerCasen ? function (val) { return map; }n : function (val) { return map; }n}nn/**n * Check if a tag is a built-in tag.n */nvar isBuiltInTag = makeMap('slot,component', true);nn/**n * Check if an attribute is a reserved attribute.n */nvar isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');nn/**n * Remove an item from an array.n */nfunction remove (arr, item) {n if (arr.length) {n var index = arr.indexOf(item);n if (index > -1) {n return arr.splice(index, 1)n }n }n}nn/**n * Check whether an object has the property.n */nvar hasOwnProperty = Object.prototype.hasOwnProperty;nfunction hasOwn (obj, key) {n return hasOwnProperty.call(obj, key)n}nn/**n * Create a cached version of a pure function.n */nfunction cached (fn) {n var cache = Object.create(null);n return (function cachedFn (str) {n var hit = cache;n return hit || (cache = fn(str))n })n}nn/**n * Camelize a hyphen-delimited string.n */nvar camelizeRE = /-(\w)/g;nvar camelize = cached(function (str) {n return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })n});nn/**n * Capitalize a string.n */nvar capitalize = cached(function (str) {n return str.charAt(0).toUpperCase() + str.slice(1)n});nn/**n * Hyphenate a camelCase string.n */nvar hyphenateRE = /\B()/g;nvar hyphenate = cached(function (str) {n return str.replace(hyphenateRE, '-$1').toLowerCase()n});nn/**n * Simple bind polyfill for environments that do not support it,n * e.g., PhantomJS 1.x. Technically, we don't need this anymoren * since native bind is now performant enough in most browsers.n * But removing it would mean breaking code that was able to run inn * PhantomJS 1.x, so this must be kept for backward compatibility.n */nn/* istanbul ignore next */nfunction polyfillBind (fn, ctx) {n function boundFn (a) {n var l = arguments.length;n return ln ? l > 1n ? fn.apply(ctx, arguments)n : fn.call(ctx, a)n : fn.call(ctx)n }nn boundFn._length = fn.length;n return boundFnn}nnfunction nativeBind (fn, ctx) {n return fn.bind(ctx)n}nnvar bind = Function.prototype.bindn ? nativeBindn : polyfillBind;nn/**n * Convert an Array-like object to a real Array.n */nfunction toArray (list, start) {n start = start || 0;n var i = list.length - start;n var ret = new Array(i);n while (i–) {n ret = list[i + start];n }n return retn}nn/**n * Mix properties into target object.n */nfunction extend (to, _from) {n for (var key in _from) {n to = _from;n }n return ton}nn/**n * Merge an Array of Objects into a single Object.n */nfunction toObject (arr) {n var res = {};n for (var i = 0; i < arr.length; i++) {n if (arr) {n extend(res, arr);n }n }n return resn}nn/* eslint-disable no-unused-vars */nn/**n * Perform no operation.n * Stubbing args to make Flow happy without leaving useless transpiled coden * with …rest (flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).n */nfunction noop (a, b, c) {}nn/**n * Always return false.n */nvar no = function (a, b, c) { return false; };nn/* eslint-enable no-unused-vars */nn/**n * Return the same value.n */nvar identity = function (_) { return _; };nn/**n * Check if two values are loosely equal - that is,n * if they are plain objects, do they have the same shape?n */nfunction looseEqual (a, b) {n if (a === b) { return true }n var isObjectA = isObject(a);n var isObjectB = isObject(b);n if (isObjectA && isObjectB) {n try {n var isArrayA = Array.isArray(a);n var isArrayB = Array.isArray(b);n if (isArrayA && isArrayB) {n return a.length === b.length && a.every(function (e, i) {n return looseEqual(e, b)n })n } else if (a instanceof Date && b instanceof Date) {n return a.getTime() === b.getTime()n } else if (!isArrayA && !isArrayB) {n var keysA = Object.keys(a);n var keysB = Object.keys(b);n return keysA.length === keysB.length && keysA.every(function (key) {n return looseEqual(a, b)n })n } else {n /* istanbul ignore next */n return falsen }n } catch (e) {n /* istanbul ignore next */n return falsen }n } else if (!isObjectA && !isObjectB) {n return String(a) === String(b)n } else {n return falsen }n}nn/**n * Return the first index at which a loosely equal value can ben * found in the array (if value is a plain object, the array mustn * contain an object of the same shape), or -1 if it is not present.n */nfunction looseIndexOf (arr, val) {n for (var i = 0; i < arr.length; i++) {n if (looseEqual(arr, val)) { return i }n }n return -1n}nn/**n * Ensure a function is called only once.n */nfunction once (fn) {n var called = false;n return function () {n if (!called) {n called = true;n fn.apply(this, arguments);n }n }n}nnvar SSR_ATTR = 'data-server-rendered';nnvar ASSET_TYPES = [n 'component',n 'directive',n 'filter'n];nnvar LIFECYCLE_HOOKS = [n 'beforeCreate',n 'created',n 'beforeMount',n 'mounted',n 'beforeUpdate',n 'updated',n 'beforeDestroy',n 'destroyed',n 'activated',n 'deactivated',n 'errorCaptured',n 'serverPrefetch'n];nn/* */nnnnvar config = ({n /**n * Option merge strategies (used in core/util/options)n */n // $flow-disable-linen optionMergeStrategies: Object.create(null),nn /**n * Whether to suppress warnings.n */n silent: false,nn /**n * Show production mode tip message on boot?n */n productionTip: process.env.NODE_ENV !== 'production',nn /**n * Whether to enable devtoolsn */n devtools: process.env.NODE_ENV !== 'production',nn /**n * Whether to record perfn */n performance: false,nn /**n * Error handler for watcher errorsn */n errorHandler: null,nn /**n * Warn handler for watcher warnsn */n warnHandler: null,nn /**n * Ignore certain custom elementsn */n ignoredElements: [],nn /**n * Custom user key aliases for v-onn */n // $flow-disable-linen keyCodes: Object.create(null),nn /**n * Check if a tag is reserved so that it cannot be registered as an * component. This is platform-dependent and may be overwritten.n */n isReservedTag: no,nn /**n * Check if an attribute is reserved so that it cannot be used as a componentn * prop. This is platform-dependent and may be overwritten.n */n isReservedAttr: no,nn /**n * Check if a tag is an unknown element.n * Platform-dependent.n */n isUnknownElement: no,nn /**n * Get the namespace of an elementn */n getTagNamespace: noop,nn /**n * Parse the real tag name for the specific platform.n */n parsePlatformTagName: identity,nn /**n * Check if an attribute must be bound using property, e.g. valuen * Platform-dependent.n */n mustUseProp: no,nn /**n * Perform updates asynchronously. Intended to be used by Vue Test Utilsn * This will significantly reduce performance if set to false.n */n async: true,nn /**n * Exposed for legacy reasonsn */n _lifecycleHooks: LIFECYCLE_HOOKSn});nn/* */nn/**n * unicode letters used for parsing html tags, component names and property paths.n * using www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementnamen * skipping \u10000-\uEFFFF due to it freezing up PhantomJSn */nvar unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;nn/**n * Check if a string starts with $ or _n */nfunction isReserved (str) {n var c = (str + '').charCodeAt(0);n return c === 0x24 || c === 0x5Fn}nn/**n * Define a property.n */nfunction def (obj, key, val, enumerable) {n Object.defineProperty(obj, key, {n value: val,n enumerable: !!enumerable,n writable: true,n configurable: truen });n}nn/**n * Parse simple path.n */nvar bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));nfunction parsePath (path) {n if (bailRE.test(path)) {n returnn }n var segments = path.split('.');n return function (obj) {n for (var i = 0; i < segments.length; i++) {n if (!obj) { return }n obj = obj[segments];n }n return objn }n}nn/* */nn// can we use __proto__?nvar hasProto = '__proto__' in {};nn// Browser environment sniffingnvar inBrowser = typeof window !== 'undefined';nvar inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;nvar weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();nvar isIE = UA && /msie|trident/.test(UA);nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;nvar isEdge = UA && UA.indexOf('edge/') > 0;nvar isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');nvar isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');nvar isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;nvar isPhantomJS = UA && /phantomjs/.test(UA);nvar isFF = UA && UA.match(/firefox\/(\d+)/);nn// Firefox has a "watch" function on Object.prototype…nvar nativeWatch = ({}).watch;nnvar supportsPassive = false;nif (inBrowser) {n try {n var opts = {};n Object.defineProperty(opts, 'passive', ({n get: function get () {n /* istanbul ignore next */n supportsPassive = true;n }n })); // github.com/facebook/flow/issues/285n window.addEventListener('test-passive', null, opts);n } catch (e) {}n}nn// this needs to be lazy-evaled because vue may be required beforen// vue-server-renderer can set VUE_ENVnvar _isServer;nvar isServerRendering = function () {n if (_isServer === undefined) {n /* istanbul ignore if */n if (!inBrowser && !inWeex && typeof global !== 'undefined') {n // detect presence of vue-server-renderer and avoidn // Webpack shimming the processn _isServer = global && global.env.VUE_ENV === 'server';n } else {n _isServer = false;n }n }n return _isServern};nn// detect devtoolsnvar devtools = inBrowser && window.VUE_DEVTOOLS_GLOBAL_HOOK;nn/* istanbul ignore next */nfunction isNative (Ctor) {n return typeof Ctor === 'function' && /native code/.test(Ctor.toString())n}nnvar hasSymbol =n typeof Symbol !== 'undefined' && isNative(Symbol) &&n typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);nnvar _Set;n/* istanbul ignore if */ // $flow-disable-linenif (typeof Set !== 'undefined' && isNative(Set)) {n // use native Set when available.n _Set = Set;n} else {n // a non-standard Set polyfill that only works with primitive keys.n _Set = /*@__PURE__*/(function () {n function Set () {n this.set = Object.create(null);n }n Set.prototype.has = function has (key) {n return this.set === truen };n Set.prototype.add = function add (key) {n this.set = true;n };n Set.prototype.clear = function clear () {n this.set = Object.create(null);n };nn return Set;n }());n}nn/* */nnvar warn = noop;nvar tip = noop;nvar generateComponentTrace = (noop); // work around flow checknvar formatComponentName = (noop);nnif (process.env.NODE_ENV !== 'production') {n var hasConsole = typeof console !== 'undefined';n var classifyRE = /(?:^|[-_])(\w)/g;n var classify = function (str) { return strn .replace(classifyRE, function © { return c.toUpperCase(); })n .replace(//g, ''); };nn warn = function (msg, vm) {n var trace = vm ? generateComponentTrace(vm) : '';nn if (config.warnHandler) {n config.warnHandler.call(null, msg, vm, trace);n } else if (hasConsole && (!config.silent)) {n console.error(("[Vue warn]: " + msg + trace));n }n };nn tip = function (msg, vm) {n if (hasConsole && (!config.silent)) {n console.warn("[Vue tip]: " + msg + (n vm ? generateComponentTrace(vm) : ''n ));n }n };nn formatComponentName = function (vm, includeFile) {n if (vm.$root === vm) {n return '<Root>'n }n var options = typeof vm === 'function' && vm.cid != nulln ? vm.optionsn : vm._isVuen ? vm.$options || vm.constructor.optionsn : vm;n var name = options.name || options._componentTag;n var file = options.__file;n if (!name && file) {n var match = file.match(/(+)\.vue$/);n name = match && match;n }nn return (n (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +n (file && includeFile !== false ? (" at " + file) : '')n )n };nn var repeat = function (str, n) {n var res = '';n while (n) {n if (n % 2 === 1) { res += str; }n if (n > 1) { str += str; }n n >>= 1;n }n return resn };nn generateComponentTrace = function (vm) {n if (vm._isVue && vm.$parent) {n var tree = [];n var currentRecursiveSequence = 0;n while (vm) {n if (tree.length > 0) {n var last = tree[tree.length - 1];n if (last.constructor === vm.constructor) {n currentRecursiveSequence++;n vm = vm.$parent;n continuen } else if (currentRecursiveSequence > 0) {n tree[tree.length - 1] = [last, currentRecursiveSequence];n currentRecursiveSequence = 0;n }n }n tree.push(vm);n vm = vm.$parent;n }n return '\n\nfound in\n\n' + treen .map(function (vm, i) { return ("" + (i === 0 ? '—> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)n ? ((formatComponentName(vm)) + "… (" + (vm) + " recursive calls)")n : formatComponentName(vm))); })n .join('\n')n } else {n return ("\n\n(found in " + (formatComponentName(vm)) + ")")n }n };n}nn/* */nnvar uid = 0;nn/**n * A dep is an observable that can have multiplen * directives subscribing to it.n */nvar Dep = function Dep () {n this.id = uid++;n this.subs = [];n};nnDep.prototype.addSub = function addSub (sub) {n this.subs.push(sub);n};nnDep.prototype.removeSub = function removeSub (sub) {n remove(this.subs, sub);n};nnDep.prototype.depend = function depend () {n if (Dep.target) {n Dep.target.addDep(this);n }n};nnDep.prototype.notify = function notify () {n // stabilize the subscriber list firstn var subs = this.subs.slice();n if (process.env.NODE_ENV !== 'production' && !config.async) {n // subs aren't sorted in scheduler if not running asyncn // we need to sort them now to make sure they fire in correctn // ordern subs.sort(function (a, b) { return a.id - b.id; });n }n for (var i = 0, l = subs.length; i < l; i++) {n subs.update();n }n};nn// The current target watcher being evaluated.n// This is globally unique because only one watchern// can be evaluated at a time.nDep.target = null;nvar targetStack = [];nnfunction pushTarget (target) {n targetStack.push(target);n Dep.target = target;n}nnfunction popTarget () {n targetStack.pop();n Dep.target = targetStack[targetStack.length - 1];n}nn/* */nnvar VNode = function VNode (n tag,n data,n children,n text,n elm,n context,n componentOptions,n asyncFactoryn) {n this.tag = tag;n this.data = data;n this.children = children;n this.text = text;n this.elm = elm;n this.ns = undefined;n this.context = context;n this.fnContext = undefined;n this.fnOptions = undefined;n this.fnScopeId = undefined;n this.key = data && data.key;n this.componentOptions = componentOptions;n this.componentInstance = undefined;n this.parent = undefined;n this.raw = false;n this.isStatic = false;n this.isRootInsert = true;n this.isComment = false;n this.isCloned = false;n this.isOnce = false;n this.asyncFactory = asyncFactory;n this.asyncMeta = undefined;n this.isAsyncPlaceholder = false;n};nnvar prototypeAccessors = { child: { configurable: true } };nn// DEPRECATED: alias for componentInstance for backwards compat.n/* istanbul ignore next */nprototypeAccessors.child.get = function () {n return this.componentInstancen};nnObject.defineProperties( VNode.prototype, prototypeAccessors );nnvar createEmptyVNode = function (text) {n if ( text === void 0 ) text = '';nn var node = new VNode();n node.text = text;n node.isComment = true;n return noden};nnfunction createTextVNode (val) {n return new VNode(undefined, undefined, undefined, String(val))n}nn// optimized shallow clonen// used for static nodes and slot nodes because they may be reused acrossn// multiple renders, cloning them avoids errors when DOM manipulations relyn// on their elm reference.nfunction cloneVNode (vnode) {n var cloned = new VNode(n vnode.tag,n vnode.data,n // #7975n // clone children array to avoid mutating original in case of cloningn // a child.n vnode.children && vnode.children.slice(),n vnode.text,n vnode.elm,n vnode.context,n vnode.componentOptions,n vnode.asyncFactoryn );n cloned.ns = vnode.ns;n cloned.isStatic = vnode.isStatic;n cloned.key = vnode.key;n cloned.isComment = vnode.isComment;n cloned.fnContext = vnode.fnContext;n cloned.fnOptions = vnode.fnOptions;n cloned.fnScopeId = vnode.fnScopeId;n cloned.asyncMeta = vnode.asyncMeta;n cloned.isCloned = true;n return clonedn}nn/*n * not type checking this file because flow doesn't play well withn * dynamically accessing methods on Array prototypen */nnvar arrayProto = Array.prototype;nvar arrayMethods = Object.create(arrayProto);nnvar methodsToPatch = [n 'push',n 'pop',n 'shift',n 'unshift',n 'splice',n 'sort',n 'reverse'n];nn/**n * Intercept mutating methods and emit eventsn */nmethodsToPatch.forEach(function (method) {n // cache original methodn var original = arrayProto;n def(arrayMethods, method, function mutator () {n var args = [], len = arguments.length;n while ( len– ) args[ len ] = arguments[ len ];nn var result = original.apply(this, args);n var ob = this.__ob__;n var inserted;n switch (method) {n case 'push':n case 'unshift':n inserted = args;n breakn case 'splice':n inserted = args.slice(2);n breakn }n if (inserted) { ob.observeArray(inserted); }n // notify changen ob.dep.notify();n return resultn });n});nn/* */nnvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);nn/**n * In some cases we may want to disable observation inside a component'sn * update computation.n */nvar shouldObserve = true;nnfunction toggleObserving (value) {n shouldObserve = value;n}nn/**n * Observer class that is attached to each observedn * object. Once attached, the observer converts the targetn * object's property keys into getter/setters thatn * collect dependencies and dispatch updates.n */nvar Observer = function Observer (value) {n this.value = value;n this.dep = new Dep();n this.vmCount = 0;n def(value, '__ob__', this);n if (Array.isArray(value)) {n if (hasProto) {n protoAugment(value, arrayMethods);n } else {n copyAugment(value, arrayMethods, arrayKeys);n }n this.observeArray(value);n } else {n this.walk(value);n }n};nn/**n * Walk through all properties and convert them inton * getter/setters. This method should only be called whenn * value type is Object.n */nObserver.prototype.walk = function walk (obj) {n var keys = Object.keys(obj);n for (var i = 0; i < keys.length; i++) {n defineReactive$$1(obj, keys);n }n};nn/**n * Observe a list of Array items.n */nObserver.prototype.observeArray = function observeArray (items) {n for (var i = 0, l = items.length; i < l; i++) {n observe(items);n }n};nn// helpersnn/**n * Augment a target Object or Array by interceptingn * the prototype chain using __proto__n */nfunction protoAugment (target, src) {n /* eslint-disable no-proto */n target.__proto__ = src;n /* eslint-enable no-proto */n}nn/**n * Augment a target Object or Array by definingn * hidden properties.n */n/* istanbul ignore next */nfunction copyAugment (target, src, keys) {n for (var i = 0, l = keys.length; i < l; i++) {n var key = keys;n def(target, key, src);n }n}nn/**n * Attempt to create an observer instance for a value,n * returns the new observer if successfully observed,n * or the existing observer if the value already has one.n */nfunction observe (value, asRootData) {n if (!isObject(value) || value instanceof VNode) {n returnn }n var ob;n if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {n ob = value.__ob__;n } else if (n shouldObserve &&n !isServerRendering() &&n (Array.isArray(value) || isPlainObject(value)) &&n Object.isExtensible(value) &&n !value._isVuen ) {n ob = new Observer(value);n }n if (asRootData && ob) {n ob.vmCount++;n }n return obn}nn/**n * Define a reactive property on an Object.n */nfunction defineReactive$$1 (n obj,n key,n val,n customSetter,n shallown) {n var dep = new Dep();nn var property = Object.getOwnPropertyDescriptor(obj, key);n if (property && property.configurable === false) {n returnn }nn // cater for pre-defined getter/settersn var getter = property && property.get;n var setter = property && property.set;n if ((!getter || setter) && arguments.length === 2) {n val = obj;n }nn var childOb = !shallow && observe(val);n Object.defineProperty(obj, key, {n enumerable: true,n configurable: true,n get: function reactiveGetter () {n var value = getter ? getter.call(obj) : val;n if (Dep.target) {n dep.depend();n if (childOb) {n childOb.dep.depend();n if (Array.isArray(value)) {n dependArray(value);n }n }n }n return valuen },n set: function reactiveSetter (newVal) {n var value = getter ? getter.call(obj) : val;n /* eslint-disable no-self-compare */n if (newVal === value || (newVal !== newVal && value !== value)) {n returnn }n /* eslint-enable no-self-compare */n if (process.env.NODE_ENV !== 'production' && customSetter) {n customSetter();n }n // #7981: for accessor properties without settern if (getter && !setter) { return }n if (setter) {n setter.call(obj, newVal);n } else {n val = newVal;n }n childOb = !shallow && observe(newVal);n dep.notify();n }n });n}nn/**n * Set a property on an object. Adds the new property andn * triggers change notification if the property doesn'tn * already exist.n */nfunction set (target, key, val) {n if (process.env.NODE_ENV !== 'production' &&n (isUndef(target) || isPrimitive(target))n ) {n warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));n }n if (Array.isArray(target) && isValidArrayIndex(key)) {n target.length = Math.max(target.length, key);n target.splice(key, 1, val);n return valn }n if (key in target && !(key in Object.prototype)) {n target = val;n return valn }n var ob = (target).__ob__;n if (target._isVue || (ob && ob.vmCount)) {n process.env.NODE_ENV !== 'production' && warn(n 'Avoid adding reactive properties to a Vue instance or its root $data ' +n 'at runtime - declare it upfront in the data option.'n );n return valn }n if (!ob) {n target = val;n return valn }n defineReactive$$1(ob.value, key, val);n ob.dep.notify();n return valn}nn/**n * Delete a property and trigger change if necessary.n */nfunction del (target, key) {n if (process.env.NODE_ENV !== 'production' &&n (isUndef(target) || isPrimitive(target))n ) {n warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));n }n if (Array.isArray(target) && isValidArrayIndex(key)) {n target.splice(key, 1);n returnn }n var ob = (target).__ob__;n if (target._isVue || (ob && ob.vmCount)) {n process.env.NODE_ENV !== 'production' && warn(n 'Avoid deleting properties on a Vue instance or its root $data ' +n '- just set it to null.'n );n returnn }n if (!hasOwn(target, key)) {n returnn }n delete target;n if (!ob) {n returnn }n ob.dep.notify();n}nn/**n * Collect dependencies on array elements when the array is touched, sincen * we cannot intercept array element access like property getters.n */nfunction dependArray (value) {n for (var e = (void 0), i = 0, l = value.length; i < l; i++) {n e = value;n e && e.__ob__ && e.__ob__.dep.depend();n if (Array.isArray(e)) {n dependArray(e);n }n }n}nn/* */nn/**n * Option overwriting strategies are functions that handlen * how to merge a parent option value and a child optionn * value into the final value.n */nvar strats = config.optionMergeStrategies;nn/**n * Options with restrictionsn */nif (process.env.NODE_ENV !== 'production') {n strats.el = strats.propsData = function (parent, child, vm, key) {n if (!vm) {n warn(n "option \"" + key + "\" can only be used during instance " +n 'creation with the `new` keyword.'n );n }n return defaultStrat(parent, child)n };n}nn/**n * Helper that recursively merges two data objects together.n */nfunction mergeData (to, from) {n if (!from) { return to }n var key, toVal, fromVal;nn var keys = hasSymboln ? Reflect.ownKeys(from)n : Object.keys(from);nn for (var i = 0; i < keys.length; i++) {n key = keys;n // in case the object is already observed…n if (key === '__ob__') { continue }n toVal = to;n fromVal = from;n if (!hasOwn(to, key)) {n set(to, key, fromVal);n } else if (n toVal !== fromVal &&n isPlainObject(toVal) &&n isPlainObject(fromVal)n ) {n mergeData(toVal, fromVal);n }n }n return ton}nn/**n * Datan */nfunction mergeDataOrFn (n parentVal,n childVal,n vmn) {n if (!vm) {n // in a Vue.extend merge, both should be functionsn if (!childVal) {n return parentValn }n if (!parentVal) {n return childValn }n // when parentVal & childVal are both present,n // we need to return a function that returns then // merged result of both functions… no need ton // check if parentVal is a function here becausen // it has to be a function to pass previous merges.n return function mergedDataFn () {n return mergeData(n typeof childVal === 'function' ? childVal.call(this, this) : childVal,n typeof parentVal === 'function' ? parentVal.call(this, this) : parentValn )n }n } else {n return function mergedInstanceDataFn () {n // instance mergen var instanceData = typeof childVal === 'function'n ? childVal.call(vm, vm)n : childVal;n var defaultData = typeof parentVal === 'function'n ? parentVal.call(vm, vm)n : parentVal;n if (instanceData) {n return mergeData(instanceData, defaultData)n } else {n return defaultDatan }n }n }n}nnstrats.data = function (n parentVal,n childVal,n vmn) {n if (!vm) {n if (childVal && typeof childVal !== 'function') {n process.env.NODE_ENV !== 'production' && warn(n 'The "data" option should be a function ' +n 'that returns a per-instance value in component ' +n 'definitions.',n vmn );nn return parentValn }n return mergeDataOrFn(parentVal, childVal)n }nn return mergeDataOrFn(parentVal, childVal, vm)n};nn/**n * Hooks and props are merged as arrays.n */nfunction mergeHook (n parentVal,n childValn) {n var res = childValn ? parentValn ? parentVal.concat(childVal)n : Array.isArray(childVal)n ? childValn : [childVal]n : parentVal;n return resn ? dedupeHooks(res)n : resn}nnfunction dedupeHooks (hooks) {n var res = [];n for (var i = 0; i < hooks.length; i++) {n if (res.indexOf(hooks) === -1) {n res.push(hooks);n }n }n return resn}nnLIFECYCLE_HOOKS.forEach(function (hook) {n strats = mergeHook;n});nn/**n * Assetsn *n * When a vm is present (instance creation), we need to don * a three-way merge between constructor options, instancen * options and parent options.n */nfunction mergeAssets (n parentVal,n childVal,n vm,n keyn) {n var res = Object.create(parentVal || null);n if (childVal) {n process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);n return extend(res, childVal)n } else {n return resn }n}nnASSET_TYPES.forEach(function (type) {n strats[type + 's'] = mergeAssets;n});nn/**n * Watchers.n *n * Watchers hashes should not overwrite onen * another, so we merge them as arrays.n */nstrats.watch = function (n parentVal,n childVal,n vm,n keyn) {n // work around Firefox's Object.prototype.watch…n if (parentVal === nativeWatch) { parentVal = undefined; }n if (childVal === nativeWatch) { childVal = undefined; }n /* istanbul ignore if */n if (!childVal) { return Object.create(parentVal || null) }n if (process.env.NODE_ENV !== 'production') {n assertObjectType(key, childVal, vm);n }n if (!parentVal) { return childVal }n var ret = {};n extend(ret, parentVal);n for (var key$1 in childVal) {n var parent = ret;n var child = childVal;n if (parent && !Array.isArray(parent)) {n parent = [parent];n }n ret = parentn ? parent.concat(child)n : Array.isArray(child) ? child : [child];n }n return retn};nn/**n * Other object hashes.n */nstrats.props =nstrats.methods =nstrats.inject =nstrats.computed = function (n parentVal,n childVal,n vm,n keyn) {n if (childVal && process.env.NODE_ENV !== 'production') {n assertObjectType(key, childVal, vm);n }n if (!parentVal) { return childVal }n var ret = Object.create(null);n extend(ret, parentVal);n if (childVal) { extend(ret, childVal); }n return retn};nstrats.provide = mergeDataOrFn;nn/**n * Default strategy.n */nvar defaultStrat = function (parentVal, childVal) {n return childVal === undefinedn ? parentValn : childValn};nn/**n * Validate component namesn */nfunction checkComponents (options) {n for (var key in options.components) {n validateComponentName(key);n }n}nnfunction validateComponentName (name) {n if (!new RegExp(("^[\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {n warn(n 'Invalid component name: "' + name + '". Component names ' +n 'should conform to valid custom element name in html5 specification.'n );n }n if (isBuiltInTag(name) || config.isReservedTag(name)) {n warn(n 'Do not use built-in or reserved HTML elements as component ' +n 'id: ' + namen );n }n}nn/**n * Ensure all props option syntax are normalized into then * Object-based format.n */nfunction normalizeProps (options, vm) {n var props = options.props;n if (!props) { return }n var res = {};n var i, val, name;n if (Array.isArray(props)) {n i = props.length;n while (i–) {n val = props;n if (typeof val === 'string') {n name = camelize(val);n res = { type: null };n } else if (process.env.NODE_ENV !== 'production') {n warn('props must be strings when using array syntax.');n }n }n } else if (isPlainObject(props)) {n for (var key in props) {n val = props;n name = camelize(key);n res = isPlainObject(val)n ? valn : { type: val };n }n } else if (process.env.NODE_ENV !== 'production') {n warn(n "Invalid value for option \"props\": expected an Array or an Object, " +n "but got " + (toRawType(props)) + ".",n vmn );n }n options.props = res;n}nn/**n * Normalize all injections into Object-based formatn */nfunction normalizeInject (options, vm) {n var inject = options.inject;n if (!inject) { return }n var normalized = options.inject = {};n if (Array.isArray(inject)) {n for (var i = 0; i < inject.length; i++) {n normalized[inject] = { from: inject };n }n } else if (isPlainObject(inject)) {n for (var key in inject) {n var val = inject;n normalized = isPlainObject(val)n ? extend({ from: key }, val)n : { from: val };n }n } else if (process.env.NODE_ENV !== 'production') {n warn(n "Invalid value for option \"inject\": expected an Array or an Object, " +n "but got " + (toRawType(inject)) + ".",n vmn );n }n}nn/**n * Normalize raw function directives into object format.n */nfunction normalizeDirectives (options) {n var dirs = options.directives;n if (dirs) {n for (var key in dirs) {n var def$$1 = dirs;n if (typeof def$$1 === 'function') {n dirs = { bind: def$$1, update: def$$1 };n }n }n }n}nnfunction assertObjectType (name, value, vm) {n if (!isPlainObject(value)) {n warn(n "Invalid value for option \"" + name + "\": expected an Object, " +n "but got " + (toRawType(value)) + ".",n vmn );n }n}nn/**n * Merge two option objects into a new one.n * Core utility used in both instantiation and inheritance.n */nfunction mergeOptions (n parent,n child,n vmn) {n if (process.env.NODE_ENV !== 'production') {n checkComponents(child);n }nn if (typeof child === 'function') {n child = child.options;n }nn normalizeProps(child, vm);n normalizeInject(child, vm);n normalizeDirectives(child);nn // Apply extends and mixins on the child options,n // but only if it is a raw options object that isn'tn // the result of another mergeOptions call.n // Only merged options has the _base property.n if (!child._base) {n if (child.extends) {n parent = mergeOptions(parent, child.extends, vm);n }n if (child.mixins) {n for (var i = 0, l = child.mixins.length; i < l; i++) {n parent = mergeOptions(parent, child.mixins, vm);n }n }n }nn var options = {};n var key;n for (key in parent) {n mergeField(key);n }n for (key in child) {n if (!hasOwn(parent, key)) {n mergeField(key);n }n }n function mergeField (key) {n var strat = strats || defaultStrat;n options = strat(parent, child, vm, key);n }n return optionsn}nn/**n * Resolve an asset.n * This function is used because child instances need accessn * to assets defined in its ancestor chain.n */nfunction resolveAsset (n options,n type,n id,n warnMissingn) {n /* istanbul ignore if */n if (typeof id !== 'string') {n returnn }n var assets = options;n // check local registration variations firstn if (hasOwn(assets, id)) { return assets }n var camelizedId = camelize(id);n if (hasOwn(assets, camelizedId)) { return assets }n var PascalCaseId = capitalize(camelizedId);n if (hasOwn(assets, PascalCaseId)) { return assets }n // fallback to prototype chainn var res = assets || assets || assets;n if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {n warn(n 'Failed to resolve ' + type.slice(0, -1) + ': ' + id,n optionsn );n }n return resn}nn/* */nnnnfunction validateProp (n key,n propOptions,n propsData,n vmn) {n var prop = propOptions;n var absent = !hasOwn(propsData, key);n var value = propsData;n // boolean castingn var booleanIndex = getTypeIndex(Boolean, prop.type);n if (booleanIndex > -1) {n if (absent && !hasOwn(prop, 'default')) {n value = false;n } else if (value === '' || value === hyphenate(key)) {n // only cast empty string / same name to boolean ifn // boolean has higher priorityn var stringIndex = getTypeIndex(String, prop.type);n if (stringIndex < 0 || booleanIndex < stringIndex) {n value = true;n }n }n }n // check default valuen if (value === undefined) {n value = getPropDefaultValue(vm, prop, key);n // since the default value is a fresh copy,n // make sure to observe it.n var prevShouldObserve = shouldObserve;n toggleObserving(true);n observe(value);n toggleObserving(prevShouldObserve);n }n if (n process.env.NODE_ENV !== 'production' &&n // skip validation for weex recycle-list child component propsn !(false)n ) {n assertProp(prop, key, value, vm, absent);n }n return valuen}nn/**n * Get the default value of a prop.n */nfunction getPropDefaultValue (vm, prop, key) {n // no default, return undefinedn if (!hasOwn(prop, 'default')) {n return undefinedn }n var def = prop.default;n // warn against non-factory defaults for Object & Arrayn if (process.env.NODE_ENV !== 'production' && isObject(def)) {n warn(n 'Invalid default value for prop "' + key + '": ' +n 'Props with type Object/Array must use a factory function ' +n 'to return the default value.',n vmn );n }n // the raw prop value was also undefined from previous render,n // return previous default value to avoid unnecessary watcher triggern if (vm && vm.$options.propsData &&n vm.$options.propsData === undefined &&n vm._props !== undefinedn ) {n return vm._propsn }n // call factory function for non-Function typesn // a value is Function if its prototype is function even across different execution contextn return typeof def === 'function' && getType(prop.type) !== 'Function'n ? def.call(vm)n : defn}nn/**n * Assert whether a prop is valid.n */nfunction assertProp (n prop,n name,n value,n vm,n absentn) {n if (prop.required && absent) {n warn(n 'Missing required prop: "' + name + '"',n vmn );n returnn }n if (value == null && !prop.required) {n returnn }n var type = prop.type;n var valid = !type || type === true;n var expectedTypes = [];n if (type) {n if (!Array.isArray(type)) {n type = [type];n }n for (var i = 0; i < type.length && !valid; i++) {n var assertedType = assertType(value, type);n expectedTypes.push(assertedType.expectedType || '');n valid = assertedType.valid;n }n }nn if (!valid) {n warn(n getInvalidTypeMessage(name, value, expectedTypes),n vmn );n returnn }n var validator = prop.validator;n if (validator) {n if (!validator(value)) {n warn(n 'Invalid prop: custom validator check failed for prop "' + name + '".',n vmn );n }n }n}nnvar simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;nnfunction assertType (value, type) {n var valid;n var expectedType = getType(type);n if (simpleCheckRE.test(expectedType)) {n var t = typeof value;n valid = t === expectedType.toLowerCase();n // for primitive wrapper objectsn if (!valid && t === 'object') {n valid = value instanceof type;n }n } else if (expectedType === 'Object') {n valid = isPlainObject(value);n } else if (expectedType === 'Array') {n valid = Array.isArray(value);n } else {n valid = value instanceof type;n }n return {n valid: valid,n expectedType: expectedTypen }n}nn/**n * Use function string name to check built-in types,n * because a simple equality check will fail when runningn * across different vms / iframes.n */nfunction getType (fn) {n var match = fn && fn.toString().match(/^\s*function (\w+)/);n return match ? match : ''n}nnfunction isSameType (a, b) {n return getType(a) === getType(b)n}nnfunction getTypeIndex (type, expectedTypes) {n if (!Array.isArray(expectedTypes)) {n return isSameType(expectedTypes, type) ? 0 : -1n }n for (var i = 0, len = expectedTypes.length; i < len; i++) {n if (isSameType(expectedTypes, type)) {n return in }n }n return -1n}nnfunction getInvalidTypeMessage (name, value, expectedTypes) {n var message = "Invalid prop: type check failed for prop \"" + name + "\"." +n " Expected " + (expectedTypes.map(capitalize).join(', '));n var expectedType = expectedTypes;n var receivedType = toRawType(value);n var expectedValue = styleValue(value, expectedType);n var receivedValue = styleValue(value, receivedType);n // check if we need to specify expected valuen if (expectedTypes.length === 1 &&n isExplicable(expectedType) &&n !isBoolean(expectedType, receivedType)) {n message += " with value " + expectedValue;n }n message += ", got " + receivedType + " ";n // check if we need to specify received valuen if (isExplicable(receivedType)) {n message += "with value " + receivedValue + ".";n }n return messagen}nnfunction styleValue (value, type) {n if (type === 'String') {n return ("\"" + value + "\"")n } else if (type === 'Number') {n return ("" + (Number(value)))n } else {n return ("" + value)n }n}nnfunction isExplicable (value) {n var explicitTypes = ['string', 'number', 'boolean'];n return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })n}nnfunction isBoolean () {n var args = [], len = arguments.length;n while ( len– ) args[ len ] = arguments[ len ];nn return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })n}nn/* */nnfunction handleError (err, vm, info) {n // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.n // See: github.com/vuejs/vuex/issues/1505n pushTarget();n try {n if (vm) {n var cur = vm;n while ((cur = cur.$parent)) {n var hooks = cur.$options.errorCaptured;n if (hooks) {n for (var i = 0; i < hooks.length; i++) {n try {n var capture = hooks.call(cur, err, vm, info) === false;n if (capture) { return }n } catch (e) {n globalHandleError(e, cur, 'errorCaptured hook');n }n }n }n }n }n globalHandleError(err, vm, info);n } finally {n popTarget();n }n}nnfunction invokeWithErrorHandling (n handler,n context,n args,n vm,n infon) {n var res;n try {n res = args ? handler.apply(context, args) : handler.call(context);n if (res && !res._isVue && isPromise(res) && !res._handled) {n res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });n // issue #9511n // avoid catch triggering multiple times when nested callsn res._handled = true;n }n } catch (e) {n handleError(e, vm, info);n }n return resn}nnfunction globalHandleError (err, vm, info) {n if (config.errorHandler) {n try {n return config.errorHandler.call(null, err, vm, info)n } catch (e) {n // if the user intentionally throws the original error in the handler,n // do not log it twicen if (e !== err) {n logError(e, null, 'config.errorHandler');n }n }n }n logError(err, vm, info);n}nnfunction logError (err, vm, info) {n if (process.env.NODE_ENV !== 'production') {n warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);n }n /* istanbul ignore else */n if ((inBrowser || inWeex) && typeof console !== 'undefined') {n console.error(err);n } else {n throw errn }n}nn/* */nnvar isUsingMicroTask = false;nnvar callbacks = [];nvar pending = false;nnfunction flushCallbacks () {n pending = false;n var copies = callbacks.slice(0);n callbacks.length = 0;n for (var i = 0; i < copies.length; i++) {n copies();n }n}nn// Here we have async deferring wrappers using microtasks.n// In 2.5 we used (macro) tasks (in combination with microtasks).n// However, it has subtle problems when state is changed right before repaintn// (e.g. #6813, out-in transitions).n// Also, using (macro) tasks in event handler would cause some weird behaviorsn// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).n// So we now use microtasks everywhere, again.n// A major drawback of this tradeoff is that there are some scenariosn// where microtasks have too high a priority and fire in between supposedlyn// sequential events (e.g. #4521, #6690, which have workarounds)n// or even between bubbling of the same event (#6566).nvar timerFunc;nn// The nextTick behavior leverages the microtask queue, which can be accessedn// via either native Promise.then or MutationObserver.n// MutationObserver has wider support, however it is seriously bugged inn// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. Itn// completely stops working after triggering a few times… so, if nativen// Promise is available, we will use it:n/* istanbul ignore next, $flow-disable-line */nif (typeof Promise !== 'undefined' && isNative(Promise)) {n var p = Promise.resolve();n timerFunc = function () {n p.then(flushCallbacks);n // In problematic UIWebViews, Promise.then doesn't completely break, butn // it can get stuck in a weird state where callbacks are pushed into then // microtask queue but the queue isn't being flushed, until the browsern // needs to do some other work, e.g. handle a timer. Therefore we cann // "force" the microtask queue to be flushed by adding an empty timer.n if (isIOS) { setTimeout(noop); }n };n isUsingMicroTask = true;n} else if (!isIE && typeof MutationObserver !== 'undefined' && (n isNative(MutationObserver) ||n // PhantomJS and iOS 7.xn MutationObserver.toString() === '[object MutationObserverConstructor]'n)) {n // Use MutationObserver where native Promise is not available,n // e.g. PhantomJS, iOS7, Android 4.4n // (#6466 MutationObserver is unreliable in IE11)n var counter = 1;n var observer = new MutationObserver(flushCallbacks);n var textNode = document.createTextNode(String(counter));n observer.observe(textNode, {n characterData: truen });n timerFunc = function () {n counter = (counter + 1) % 2;n textNode.data = String(counter);n };n isUsingMicroTask = true;n} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {n // Fallback to setImmediate.n // Technically it leverages the (macro) task queue,n // but it is still a better choice than setTimeout.n timerFunc = function () {n setImmediate(flushCallbacks);n };n} else {n // Fallback to setTimeout.n timerFunc = function () {n setTimeout(flushCallbacks, 0);n };n}nnfunction nextTick (cb, ctx) {n var _resolve;n callbacks.push(function () {n if (cb) {n try {n cb.call(ctx);n } catch (e) {n handleError(e, ctx, 'nextTick');n }n } else if (_resolve) {n _resolve(ctx);n }n });n if (!pending) {n pending = true;n timerFunc();n }n // $flow-disable-linen if (!cb && typeof Promise !== 'undefined') {n return new Promise(function (resolve) {n _resolve = resolve;n })n }n}nn/* */nn/* not type checking this file because flow doesn't play well with Proxy */nnvar initProxy;nnif (process.env.NODE_ENV !== 'production') {n var allowedGlobals = makeMap(n 'Infinity,undefined,NaN,isFinite,isNaN,' +n 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +n 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +n 'require' // for Webpack/Browserifyn );nn var warnNonPresent = function (target, key) {n warn(n "Property or method \"" + key + "\" is not defined on the instance but " +n 'referenced during render. Make sure that this property is reactive, ' +n 'either in the data option, or for class-based components, by ' +n 'initializing the property. ' +n 'See: vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.‘,n targetn );n };nn var warnReservedPrefix = function (target, key) {n warn(n "Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +n 'properties starting with "$" or "_" are not proxied in the Vue instance to ' +n 'prevent conflicts with Vue internals. ' +n 'See: vuejs.org/v2/api/#data’,n targetn );n };nn var hasProxy =n typeof Proxy !== 'undefined' && isNative(Proxy);nn if (hasProxy) {n var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');n config.keyCodes = new Proxy(config.keyCodes, {n set: function set (target, key, value) {n if (isBuiltInModifier(key)) {n warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));n return falsen } else {n target = value;n return truen }n }n });n }nn var hasHandler = {n has: function has (target, key) {n var has = key in target;n var isAllowed = allowedGlobals(key) ||n (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));n if (!has && !isAllowed) {n if (key in target.$data) { warnReservedPrefix(target, key); }n else { warnNonPresent(target, key); }n }n return has || !isAllowedn }n };nn var getHandler = {n get: function get (target, key) {n if (typeof key === 'string' && !(key in target)) {n if (key in target.$data) { warnReservedPrefix(target, key); }n else { warnNonPresent(target, key); }n }n return targetn }n };nn initProxy = function initProxy (vm) {n if (hasProxy) {n // determine which proxy handler to usen var options = vm.$options;n var handlers = options.render && options.render._withStrippedn ? getHandlern : hasHandler;n vm._renderProxy = new Proxy(vm, handlers);n } else {n vm._renderProxy = vm;n }n };n}nn/* */nnvar seenObjects = new _Set();nn/**n * Recursively traverse an object to evoke all convertedn * getters, so that every nested property inside the objectn * is collected as a "deep" dependency.n */nfunction traverse (val) {n _traverse(val, seenObjects);n seenObjects.clear();n}nnfunction _traverse (val, seen) {n var i, keys;n var isA = Array.isArray(val);n if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {n returnn }n if (val.__ob__) {n var depId = val.__ob__.dep.id;n if (seen.has(depId)) {n returnn }n seen.add(depId);n }n if (isA) {n i = val.length;n while (i–) { _traverse(val, seen); }n } else {n keys = Object.keys(val);n i = keys.length;n while (i–) { _traverse(val[keys], seen); }n }n}nnvar mark;nvar measure;nnif (process.env.NODE_ENV !== 'production') {n var perf = inBrowser && window.performance;n /* istanbul ignore if */n if (n perf &&n perf.mark &&n perf.measure &&n perf.clearMarks &&n perf.clearMeasuresn ) {n mark = function (tag) { return perf.mark(tag); };n measure = function (name, startTag, endTag) {n perf.measure(name, startTag, endTag);n perf.clearMarks(startTag);n perf.clearMarks(endTag);n // perf.clearMeasures(name)n };n }n}nn/* */nnvar normalizeEvent = cached(function (name) {n var passive = name.charAt(0) === '&';n name = passive ? name.slice(1) : name;n var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked firstn name = once$$1 ? name.slice(1) : name;n var capture = name.charAt(0) === '!';n name = capture ? name.slice(1) : name;n return {n name: name,n once: once$$1,n capture: capture,n passive: passiven }n});nnfunction createFnInvoker (fns, vm) {n function invoker () {n var arguments$1 = arguments;nn var fns = invoker.fns;n if (Array.isArray(fns)) {n var cloned = fns.slice();n for (var i = 0; i < cloned.length; i++) {n invokeWithErrorHandling(cloned, null, arguments$1, vm, "v-on handler");n }n } else {n // return handler return value for single handlersn return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")n }n }n invoker.fns = fns;n return invokern}nnfunction updateListeners (n on,n oldOn,n add,n remove$$1,n createOnceHandler,n vmn) {n var name, def$$1, cur, old, event;n for (name in on) {n def$$1 = cur = on;n old = oldOn;n event = normalizeEvent(name);n if (isUndef(cur)) {n process.env.NODE_ENV !== 'production' && warn(n "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),n vmn );n } else if (isUndef(old)) {n if (isUndef(cur.fns)) {n cur = on = createFnInvoker(cur, vm);n }n if (isTrue(event.once)) {n cur = on = createOnceHandler(event.name, cur, event.capture);n }n add(event.name, cur, event.capture, event.passive, event.params);n } else if (cur !== old) {n old.fns = cur;n on = old;n }n }n for (name in oldOn) {n if (isUndef(on)) {n event = normalizeEvent(name);n remove$$1(event.name, oldOn, event.capture);n }n }n}nn/* */nnfunction mergeVNodeHook (def, hookKey, hook) {n if (def instanceof VNode) {n def = def.data.hook || (def.data.hook = {});n }n var invoker;n var oldHook = def;nn function wrappedHook () {n hook.apply(this, arguments);n // important: remove merged hook to ensure it's called only oncen // and prevent memory leakn remove(invoker.fns, wrappedHook);n }nn if (isUndef(oldHook)) {n // no existing hookn invoker = createFnInvoker();n } else {n /* istanbul ignore if */n if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {n // already a merged invokern invoker = oldHook;n invoker.fns.push(wrappedHook);n } else {n // existing plain hookn invoker = createFnInvoker([oldHook, wrappedHook]);n }n }nn invoker.merged = true;n def = invoker;n}nn/* */nnfunction extractPropsFromVNodeData (n data,n Ctor,n tagn) {n // we are only extracting raw values here.n // validation and default values are handled in the childn // component itself.n var propOptions = Ctor.options.props;n if (isUndef(propOptions)) {n returnn }n var res = {};n var attrs = data.attrs;n var props = data.props;n if (isDef(attrs) || isDef(props)) {n for (var key in propOptions) {n var altKey = hyphenate(key);n if (process.env.NODE_ENV !== 'production') {n var keyInLowerCase = key.toLowerCase();n if (n key !== keyInLowerCase &&n attrs && hasOwn(attrs, keyInLowerCase)n ) {n tip(n "Prop \"" + keyInLowerCase + "\" is passed to component " +n (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +n " \"" + key + "\". " +n "Note that HTML attributes are case-insensitive and camelCased " +n "props need to use their kebab-case equivalents when using in-DOM " +n "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."n );n }n }n checkProp(res, props, key, altKey, true) ||n checkProp(res, attrs, key, altKey, false);n }n }n return resn}nnfunction checkProp (n res,n hash,n key,n altKey,n preserven) {n if (isDef(hash)) {n if (hasOwn(hash, key)) {n res = hash;n if (!preserve) {n delete hash;n }n return truen } else if (hasOwn(hash, altKey)) {n res = hash;n if (!preserve) {n delete hash;n }n return truen }n }n return falsen}nn/* */nn// The template compiler attempts to minimize the need for normalization byn// statically analyzing the template at compile time.n//n// For plain HTML markup, normalization can be completely skipped because then// generated render function is guaranteed to return Array<VNode>. There aren// two cases where extra normalization is needed:nn// 1. When the children contains components - because a functional componentn// may return an Array instead of a single root. In this case, just a simplen// normalization is needed - if any child is an Array, we flatten the wholen// thing with Array.prototype.concat. It is guaranteed to be only 1-level deepn// because functional components already normalize their own children.nfunction simpleNormalizeChildren (children) {n for (var i = 0; i < children.length; i++) {n if (Array.isArray(children)) {n return Array.prototype.concat.apply([], children)n }n }n return childrenn}nn// 2. When the children contains constructs that always generated nested Arrays,n// e.g. <template>, <slot>, v-for, or when the children is provided by usern// with hand-written render functions / JSX. In such cases a full normalizationn// is needed to cater to all possible types of children values.nfunction normalizeChildren (children) {n return isPrimitive(children)n ? [createTextVNode(children)]n : Array.isArray(children)n ? normalizeArrayChildren(children)n : undefinedn}nnfunction isTextNode (node) {n return isDef(node) && isDef(node.text) && isFalse(node.isComment)n}nnfunction normalizeArrayChildren (children, nestedIndex) {n var res = [];n var i, c, lastIndex, last;n for (i = 0; i < children.length; i++) {n c = children;n if (isUndef© || typeof c === 'boolean') { continue }n lastIndex = res.length - 1;n last = res;n // nestedn if (Array.isArray©) {n if (c.length > 0) {n c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));n // merge adjacent text nodesn if (isTextNode(c) && isTextNode(last)) {n res = createTextVNode(last.text + (c).text);n c.shift();n }n res.push.apply(res, c);n }n } else if (isPrimitive©) {n if (isTextNode(last)) {n // merge adjacent text nodesn // this is necessary for SSR hydration because text nodes aren // essentially merged when rendered to HTML stringsn res = createTextVNode(last.text + c);n } else if (c !== '') {n // convert primitive to vnoden res.push(createTextVNode©);n }n } else {n if (isTextNode© && isTextNode(last)) {n // merge adjacent text nodesn res = createTextVNode(last.text + c.text);n } else {n // default key for nested array children (likely generated by v-for)n if (isTrue(children._isVList) &&n isDef(c.tag) &&n isUndef(c.key) &&n isDef(nestedIndex)) {n c.key = "__vlist" + nestedIndex + "_" + i + "__";n }n res.push©;n }n }n }n return resn}nn/* */nnfunction initProvide (vm) {n var provide = vm.$options.provide;n if (provide) {n vm._provided = typeof provide === 'function'n ? provide.call(vm)n : provide;n }n}nnfunction initInjections (vm) {n var result = resolveInject(vm.$options.inject, vm);n if (result) {n toggleObserving(false);n Object.keys(result).forEach(function (key) {n /* istanbul ignore else */n if (process.env.NODE_ENV !== 'production') {n defineReactive$$1(vm, key, result, function () {n warn(n "Avoid mutating an injected value directly since the changes will be " +n "overwritten whenever the provided component re-renders. " +n "injection being mutated: \"" + key + "\"",n vmn );n });n } else {n defineReactive$$1(vm, key, result);n }n });n toggleObserving(true);n }n}nnfunction resolveInject (inject, vm) {n if (inject) {n // inject is :any because flow is not smart enough to figure out cachedn var result = Object.create(null);n var keys = hasSymboln ? Reflect.ownKeys(inject)n : Object.keys(inject);nn for (var i = 0; i < keys.length; i++) {n var key = keys;n // #6574 in case the inject object is observed…n if (key === '__ob__') { continue }n var provideKey = inject.from;n var source = vm;n while (source) {n if (source._provided && hasOwn(source._provided, provideKey)) {n result = source._provided;n breakn }n source = source.$parent;n }n if (!source) {n if ('default' in inject) {n var provideDefault = inject.default;n result = typeof provideDefault === 'function'n ? provideDefault.call(vm)n : provideDefault;n } else if (process.env.NODE_ENV !== 'production') {n warn(("Injection \"" + key + "\" not found"), vm);n }n }n }n return resultn }n}nn/* */nnnn/**n * Runtime helper for resolving raw children VNodes into a slot object.n */nfunction resolveSlots (n children,n contextn) {n if (!children || !children.length) {n return {}n }n var slots = {};n for (var i = 0, l = children.length; i < l; i++) {n var child = children;n var data = child.data;n // remove slot attribute if the node is resolved as a Vue slot noden if (data && data.attrs && data.attrs.slot) {n delete data.attrs.slot;n }n // named slots should only be respected if the vnode was rendered in then // same context.n if ((child.context === context || child.fnContext === context) &&n data && data.slot != nulln ) {n var name = data.slot;n var slot = (slots || (slots = []));n if (child.tag === 'template') {n slot.push.apply(slot, child.children || []);n } else {n slot.push(child);n }n } else {n (slots.default || (slots.default = [])).push(child);n }n }n // ignore slots that contains only whitespacen for (var name$1 in slots) {n if (slots.every(isWhitespace)) {n delete slots;n }n }n return slotsn}nnfunction isWhitespace (node) {n return (node.isComment && !node.asyncFactory) || node.text === ' 'n}nn/* */nnfunction normalizeScopedSlots (n slots,n normalSlots,n prevSlotsn) {n var res;n var hasNormalSlots = Object.keys(normalSlots).length > 0;n var isStable = slots ? !!slots.$stable : !hasNormalSlots;n var key = slots && slots.$key;n if (!slots) {n res = {};n } else if (slots._normalized) {n // fast path 1: child component re-render only, parent did not changen return slots._normalizedn } else if (n isStable &&n prevSlots &&n prevSlots !== emptyObject &&n key === prevSlots.$key &&n !hasNormalSlots &&n !prevSlots.$hasNormaln ) {n // fast path 2: stable scoped slots w/ no normal slots to proxy,n // only need to normalize oncen return prevSlotsn } else {n res = {};n for (var key$1 in slots) {n if (slots && key$1 !== '$') {n res = normalizeScopedSlot(normalSlots, key$1, slots);n }n }n }n // expose normal slots on scopedSlotsn for (var key$2 in normalSlots) {n if (!(key$2 in res)) {n res = proxyNormalSlot(normalSlots, key$2);n }n }n // avoriaz seems to mock a non-extensible $scopedSlots objectn // and when that is passed down this would cause an errorn if (slots && Object.isExtensible(slots)) {n (slots)._normalized = res;n }n def(res, '$stable', isStable);n def(res, '$key', key);n def(res, '$hasNormal', hasNormalSlots);n return resn}nnfunction normalizeScopedSlot(normalSlots, key, fn) {n var normalized = function () {n var res = arguments.length ? fn.apply(null, arguments) : fn({});n res = res && typeof res === 'object' && !Array.isArray(res)n ? [res] // single vnoden : normalizeChildren(res);n return res && (n res.length === 0 ||n (res.length === 1 && res.isComment) // #9658n ) ? undefinedn : resn };n // this is a slot using the new v-slot syntax without scope. although it isn // compiled as a scoped slot, render fn users would expect it to be presentn // on this.$slots because the usage is semantically a normal slot.n if (fn.proxy) {n Object.defineProperty(normalSlots, key, {n get: normalized,n enumerable: true,n configurable: truen });n }n return normalizedn}nnfunction proxyNormalSlot(slots, key) {n return function () { return slots; }n}nn/* */nn/**n * Runtime helper for rendering v-for lists.n */nfunction renderList (n val,n rendern) {n var ret, i, l, keys, key;n if (Array.isArray(val) || typeof val === 'string') {n ret = new Array(val.length);n for (i = 0, l = val.length; i < l; i++) {n ret = render(val, i);n }n } else if (typeof val === 'number') {n ret = new Array(val);n for (i = 0; i < val; i++) {n ret = render(i + 1, i);n }n } else if (isObject(val)) {n if (hasSymbol && val) {n ret = [];n var iterator = val();n var result = iterator.next();n while (!result.done) {n ret.push(render(result.value, ret.length));n result = iterator.next();n }n } else {n keys = Object.keys(val);n ret = new Array(keys.length);n for (i = 0, l = keys.length; i < l; i++) {n key = keys;n ret = render(val, key, i);n }n }n }n if (!isDef(ret)) {n ret = [];n }n (ret)._isVList = true;n return retn}nn/* */nn/**n * Runtime helper for rendering <slot>n */nfunction renderSlot (n name,n fallback,n props,n bindObjectn) {n var scopedSlotFn = this.$scopedSlots;n var nodes;n if (scopedSlotFn) { // scoped slotn props = props || {};n if (bindObject) {n if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {n warn(n 'slot v-bind without argument expects an Object',n thisn );n }n props = extend(extend({}, bindObject), props);n }n nodes = scopedSlotFn(props) || fallback;n } else {n nodes = this.$slots || fallback;n }nn var target = props && props.slot;n if (target) {n return this.$createElement('template', { slot: target }, nodes)n } else {n return nodesn }n}nn/* */nn/**n * Runtime helper for resolving filtersn */nfunction resolveFilter (id) {n return resolveAsset(this.$options, 'filters', id, true) || identityn}nn/* */nnfunction isKeyNotMatch (expect, actual) {n if (Array.isArray(expect)) {n return expect.indexOf(actual) === -1n } else {n return expect !== actualn }n}nn/**n * Runtime helper for checking keyCodes from config.n * exposed as Vue.prototype._kn * passing in eventKeyName as last argument separately for backwards compatn */nfunction checkKeyCodes (n eventKeyCode,n key,n builtInKeyCode,n eventKeyName,n builtInKeyNamen) {n var mappedKeyCode = config.keyCodes || builtInKeyCode;n if (builtInKeyName && eventKeyName && !config.keyCodes) {n return isKeyNotMatch(builtInKeyName, eventKeyName)n } else if (mappedKeyCode) {n return isKeyNotMatch(mappedKeyCode, eventKeyCode)n } else if (eventKeyName) {n return hyphenate(eventKeyName) !== keyn }n}nn/* */nn/**n * Runtime helper for merging v-bind="object" into a VNode's data.n */nfunction bindObjectProps (n data,n tag,n value,n asProp,n isSyncn) {n if (value) {n if (!isObject(value)) {n process.env.NODE_ENV !== 'production' && warn(n 'v-bind without argument expects an Object or Array value',n thisn );n } else {n if (Array.isArray(value)) {n value = toObject(value);n }n var hash;n var loop = function ( key ) {n if (n key === 'class' ||n key === 'style' ||n isReservedAttribute(key)n ) {n hash = data;n } else {n var type = data.attrs && data.attrs.type;n hash = asProp || config.mustUseProp(tag, type, key)n ? data.domProps || (data.domProps = {})n : data.attrs || (data.attrs = {});n }n var camelizedKey = camelize(key);n var hyphenatedKey = hyphenate(key);n if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {n hash = value;nn if (isSync) {n var on = data.on || (data.on = {});n on[("update:" + key)] = function ($event) {n value = $event;n };n }n }n };nn for (var key in value) loop( key );n }n }n return datan}nn/* */nn/**n * Runtime helper for rendering static trees.n */nfunction renderStatic (n index,n isInForn) {n var cached = this._staticTrees || (this._staticTrees = []);n var tree = cached;n // if has already-rendered static tree and not inside v-for,n // we can reuse the same tree.n if (tree && !isInFor) {n return treen }n // otherwise, render a fresh tree.n tree = cached = this.$options.staticRenderFns.call(n this._renderProxy,n null,n this // for render fns generated for functional component templatesn );n markStatic(tree, ("__static__" + index), false);n return treen}nn/**n * Runtime helper for v-once.n * Effectively it means marking the node as static with a unique key.n */nfunction markOnce (n tree,n index,n keyn) {n markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);n return treen}nnfunction markStatic (n tree,n key,n isOncen) {n if (Array.isArray(tree)) {n for (var i = 0; i < tree.length; i++) {n if (tree && typeof tree !== 'string') {n markStaticNode(tree, (key + "_" + i), isOnce);n }n }n } else {n markStaticNode(tree, key, isOnce);n }n}nnfunction markStaticNode (node, key, isOnce) {n node.isStatic = true;n node.key = key;n node.isOnce = isOnce;n}nn/* */nnfunction bindObjectListeners (data, value) {n if (value) {n if (!isPlainObject(value)) {n process.env.NODE_ENV !== 'production' && warn(n 'v-on without argument expects an Object value',n thisn );n } else {n var on = data.on = data.on ? extend({}, data.on) : {};n for (var key in value) {n var existing = on;n var ours = value;n on = existing ? [].concat(existing, ours) : ours;n }n }n }n return datan}nn/* */nnfunction resolveScopedSlots (n fns, // see flow/vnoden res,n // the following are added in 2.6n hasDynamicKeys,n contentHashKeyn) {n res = res || { $stable: !hasDynamicKeys };n for (var i = 0; i < fns.length; i++) {n var slot = fns;n if (Array.isArray(slot)) {n resolveScopedSlots(slot, res, hasDynamicKeys);n } else if (slot) {n // marker for reverse proxying v-slot without scope on this.$slotsn if (slot.proxy) {n slot.fn.proxy = true;n }n res = slot.fn;n }n }n if (contentHashKey) {n (res).$key = contentHashKey;n }n return resn}nn/* */nnfunction bindDynamicKeys (baseObj, values) {n for (var i = 0; i < values.length; i += 2) {n var key = values;n if (typeof key === 'string' && key) {n baseObj[values] = values[i + 1];n } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) {n // null is a special value for explicitly removing a bindingn warn(n ("Invalid value for dynamic directive argument (expected string or null): " + key),n thisn );n }n }n return baseObjn}nn// helper to dynamically append modifier runtime markers to event names.n// ensure only append when value is already string, otherwise it will be castn// to string and cause the type check to miss.nfunction prependModifier (value, symbol) {n return typeof value === 'string' ? symbol + value : valuen}nn/* */nnfunction installRenderHelpers (target) {n target._o = markOnce;n target._n = toNumber;n target._s = toString;n target._l = renderList;n target._t = renderSlot;n target._q = looseEqual;n target._i = looseIndexOf;n target._m = renderStatic;n target._f = resolveFilter;n target._k = checkKeyCodes;n target._b = bindObjectProps;n target._v = createTextVNode;n target._e = createEmptyVNode;n target._u = resolveScopedSlots;n target._g = bindObjectListeners;n target._d = bindDynamicKeys;n target._p = prependModifier;n}nn/* */nnfunction FunctionalRenderContext (n data,n props,n children,n parent,n Ctorn) {n var this$1 = this;nn var options = Ctor.options;n // ensure the createElement function in functional componentsn // gets a unique context - this is necessary for correct named slot checkn var contextVm;n if (hasOwn(parent, '_uid')) {n contextVm = Object.create(parent);n // $flow-disable-linen contextVm._original = parent;n } else {n // the context vm passed in is a functional context as well.n // in this case we want to make sure we are able to get a hold to then // real context instance.n contextVm = parent;n // $flow-disable-linen parent = parent._original;n }n var isCompiled = isTrue(options._compiled);n var needNormalization = !isCompiled;nn this.data = data;n this.props = props;n this.children = children;n this.parent = parent;n this.listeners = data.on || emptyObject;n this.injections = resolveInject(options.inject, parent);n this.slots = function () {n if (!this$1.$slots) {n normalizeScopedSlots(n data.scopedSlots,n this$1.$slots = resolveSlots(children, parent)n );n }n return this$1.$slotsn };nn Object.defineProperty(this, 'scopedSlots', ({n enumerable: true,n get: function get () {n return normalizeScopedSlots(data.scopedSlots, this.slots())n }n }));nn // support for compiled functional templaten if (isCompiled) {n // exposing $options for renderStatic()n this.$options = options;n // pre-resolve slots for renderSlot()n this.$slots = this.slots();n this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);n }nn if (options._scopeId) {n this._c = function (a, b, c, d) {n var vnode = createElement(contextVm, a, b, c, d, needNormalization);n if (vnode && !Array.isArray(vnode)) {n vnode.fnScopeId = options._scopeId;n vnode.fnContext = parent;n }n return vnoden };n } else {n this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };n }n}nninstallRenderHelpers(FunctionalRenderContext.prototype);nnfunction createFunctionalComponent (n Ctor,n propsData,n data,n contextVm,n childrenn) {n var options = Ctor.options;n var props = {};n var propOptions = options.props;n if (isDef(propOptions)) {n for (var key in propOptions) {n props = validateProp(key, propOptions, propsData || emptyObject);n }n } else {n if (isDef(data.attrs)) { mergeProps(props, data.attrs); }n if (isDef(data.props)) { mergeProps(props, data.props); }n }nn var renderContext = new FunctionalRenderContext(n data,n props,n children,n contextVm,n Ctorn );nn var vnode = options.render.call(null, renderContext._c, renderContext);nn if (vnode instanceof VNode) {n return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)n } else if (Array.isArray(vnode)) {n var vnodes = normalizeChildren(vnode) || [];n var res = new Array(vnodes.length);n for (var i = 0; i < vnodes.length; i++) {n res = cloneAndMarkFunctionalResult(vnodes, data, renderContext.parent, options, renderContext);n }n return resn }n}nnfunction cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {n // #7817 clone node before setting fnContext, otherwise if the node is reusedn // (e.g. it was from a cached normal slot) the fnContext causes named slotsn // that should not be matched to match.n var clone = cloneVNode(vnode);n clone.fnContext = contextVm;n clone.fnOptions = options;n if (process.env.NODE_ENV !== 'production') {n (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;n }n if (data.slot) {n (clone.data || (clone.data = {})).slot = data.slot;n }n return clonen}nnfunction mergeProps (to, from) {n for (var key in from) {n to = from;n }n}nn/* */nn/* */nn/* */nn/* */nn// inline hooks to be invoked on component VNodes during patchnvar componentVNodeHooks = {n init: function init (vnode, hydrating) {n if (n vnode.componentInstance &&n !vnode.componentInstance._isDestroyed &&n vnode.data.keepAliven ) {n // kept-alive components, treat as a patchn var mountedNode = vnode; // work around flown componentVNodeHooks.prepatch(mountedNode, mountedNode);n } else {n var child = vnode.componentInstance = createComponentInstanceForVnode(n vnode,n activeInstancen );n child.$mount(hydrating ? vnode.elm : undefined, hydrating);n }n },nn prepatch: function prepatch (oldVnode, vnode) {n var options = vnode.componentOptions;n var child = vnode.componentInstance = oldVnode.componentInstance;n updateChildComponent(n child,n options.propsData, // updated propsn options.listeners, // updated listenersn vnode, // new parent vnoden options.children // new childrenn );n },nn insert: function insert (vnode) {n var context = vnode.context;n var componentInstance = vnode.componentInstance;n if (!componentInstance._isMounted) {n componentInstance._isMounted = true;n callHook(componentInstance, 'mounted');n }n if (vnode.data.keepAlive) {n if (context._isMounted) {n // vue-router#1212n // During updates, a kept-alive component's child components mayn // change, so directly walking the tree here may call activated hooksn // on incorrect children. Instead we push them into a queue which willn // be processed after the whole patch process ended.n queueActivatedComponent(componentInstance);n } else {n activateChildComponent(componentInstance, true /* direct */);n }n }n },nn destroy: function destroy (vnode) {n var componentInstance = vnode.componentInstance;n if (!componentInstance._isDestroyed) {n if (!vnode.data.keepAlive) {n componentInstance.$destroy();n } else {n deactivateChildComponent(componentInstance, true /* direct */);n }n }n }n};nnvar hooksToMerge = Object.keys(componentVNodeHooks);nnfunction createComponent (n Ctor,n data,n context,n children,n tagn) {n if (isUndef(Ctor)) {n returnn }nn var baseCtor = context.$options._base;nn // plain options object: turn it into a constructorn if (isObject(Ctor)) {n Ctor = baseCtor.extend(Ctor);n }nn // if at this stage it's not a constructor or an async component factory,n // reject.n if (typeof Ctor !== 'function') {n if (process.env.NODE_ENV !== 'production') {n warn(("Invalid Component definition: " + (String(Ctor))), context);n }n returnn }nn // async componentn var asyncFactory;n if (isUndef(Ctor.cid)) {n asyncFactory = Ctor;n Ctor = resolveAsyncComponent(asyncFactory, baseCtor);n if (Ctor === undefined) {n // return a placeholder node for async component, which is renderedn // as a comment node but preserves all the raw information for the node.n // the information will be used for async server-rendering and hydration.n return createAsyncPlaceholder(n asyncFactory,n data,n context,n children,n tagn )n }n }nn data = data || {};nn // resolve constructor options in case global mixins are applied aftern // component constructor creationn resolveConstructorOptions(Ctor);nn // transform component v-model data into props & eventsn if (isDef(data.model)) {n transformModel(Ctor.options, data);n }nn // extract propsn var propsData = extractPropsFromVNodeData(data, Ctor, tag);nn // functional componentn if (isTrue(Ctor.options.functional)) {n return createFunctionalComponent(Ctor, propsData, data, context, children)n }nn // extract listeners, since these needs to be treated asn // child component listeners instead of DOM listenersn var listeners = data.on;n // replace with listeners with .native modifiern // so it gets processed during parent component patch.n data.on = data.nativeOn;nn if (isTrue(Ctor.options.abstract)) {n // abstract components do not keep anythingn // other than props & listeners & slotnn // work around flown var slot = data.slot;n data = {};n if (slot) {n data.slot = slot;n }n }nn // install component management hooks onto the placeholder noden installComponentHooks(data);nn // return a placeholder vnoden var name = Ctor.options.name || tag;n var vnode = new VNode(n ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),n data, undefined, undefined, undefined, context,n { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },n asyncFactoryn );nn return vnoden}nnfunction createComponentInstanceForVnode (n vnode, // we know it's MountedComponentVNode but flow doesn'tn parent // activeInstance in lifecycle staten) {n var options = {n _isComponent: true,n _parentVnode: vnode,n parent: parentn };n // check inline-template render functionsn var inlineTemplate = vnode.data.inlineTemplate;n if (isDef(inlineTemplate)) {n options.render = inlineTemplate.render;n options.staticRenderFns = inlineTemplate.staticRenderFns;n }n return new vnode.componentOptions.Ctor(options)n}nnfunction installComponentHooks (data) {n var hooks = data.hook || (data.hook = {});n for (var i = 0; i < hooksToMerge.length; i++) {n var key = hooksToMerge;n var existing = hooks;n var toMerge = componentVNodeHooks;n if (existing !== toMerge && !(existing && existing._merged)) {n hooks = existing ? mergeHook$1(toMerge, existing) : toMerge;n }n }n}nnfunction mergeHook$1 (f1, f2) {n var merged = function (a, b) {n // flow complains about extra args which is why we use anyn f1(a, b);n f2(a, b);n };n merged._merged = true;n return mergedn}nn// transform component v-model info (value and callback) inton// prop and event handler respectively.nfunction transformModel (options, data) {n var prop = (options.model && options.model.prop) || 'value';n var event = (options.model && options.model.event) || 'input'n ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;n var on = data.on || (data.on = {});n var existing = on;n var callback = data.model.callback;n if (isDef(existing)) {n if (n Array.isArray(existing)n ? existing.indexOf(callback) === -1n : existing !== callbackn ) {n on = [callback].concat(existing);n }n } else {n on = callback;n }n}nn/* */nnvar SIMPLE_NORMALIZE = 1;nvar ALWAYS_NORMALIZE = 2;nn// wrapper function for providing a more flexible interfacen// without getting yelled at by flownfunction createElement (n context,n tag,n data,n children,n normalizationType,n alwaysNormalizen) {n if (Array.isArray(data) || isPrimitive(data)) {n normalizationType = children;n children = data;n data = undefined;n }n if (isTrue(alwaysNormalize)) {n normalizationType = ALWAYS_NORMALIZE;n }n return _createElement(context, tag, data, children, normalizationType)n}nnfunction _createElement (n context,n tag,n data,n children,n normalizationTypen) {n if (isDef(data) && isDef((data).__ob__)) {n process.env.NODE_ENV !== 'production' && warn(n "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +n 'Always create fresh vnode data objects in each render!',n contextn );n return createEmptyVNode()n }n // object syntax in v-bindn if (isDef(data) && isDef(data.is)) {n tag = data.is;n }n if (!tag) {n // in case of component :is set to falsy valuen return createEmptyVNode()n }n // warn against non-primitive keyn if (process.env.NODE_ENV !== 'production' &&n isDef(data) && isDef(data.key) && !isPrimitive(data.key)n ) {n {n warn(n 'Avoid using non-primitive value as key, ' +n 'use string/number value instead.',n contextn );n }n }n // support single function children as default scoped slotn if (Array.isArray(children) &&n typeof children === 'function'n ) {n data = data || {};n data.scopedSlots = { default: children };n children.length = 0;n }n if (normalizationType === ALWAYS_NORMALIZE) {n children = normalizeChildren(children);n } else if (normalizationType === SIMPLE_NORMALIZE) {n children = simpleNormalizeChildren(children);n }n var vnode, ns;n if (typeof tag === 'string') {n var Ctor;n ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);n if (config.isReservedTag(tag)) {n // platform built-in elementsn if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.nativeOn)) {n warn(n ("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."),n contextn );n }n vnode = new VNode(n config.parsePlatformTagName(tag), data, children,n undefined, undefined, contextn );n } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {n // componentn vnode = createComponent(Ctor, data, context, children, tag);n } else {n // unknown or unlisted namespaced elementsn // check at runtime because it may get assigned a namespace when itsn // parent normalizes childrenn vnode = new VNode(n tag, data, children,n undefined, undefined, contextn );n }n } else {n // direct component options / constructorn vnode = createComponent(tag, data, context, children);n }n if (Array.isArray(vnode)) {n return vnoden } else if (isDef(vnode)) {n if (isDef(ns)) { applyNS(vnode, ns); }n if (isDef(data)) { registerDeepBindings(data); }n return vnoden } else {n return createEmptyVNode()n }n}nnfunction applyNS (vnode, ns, force) {n vnode.ns = ns;n if (vnode.tag === 'foreignObject') {n // use default namespace inside foreignObjectn ns = undefined;n force = true;n }n if (isDef(vnode.children)) {n for (var i = 0, l = vnode.children.length; i < l; i++) {n var child = vnode.children;n if (isDef(child.tag) && (n isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {n applyNS(child, ns, force);n }n }n }n}nn// ref #5318n// necessary to ensure parent re-render when deep bindings like :style andn// :class are used on slot nodesnfunction registerDeepBindings (data) {n if (isObject(data.style)) {n traverse(data.style);n }n if (isObject(data.class)) {n traverse(data.class);n }n}nn/* */nnfunction initRender (vm) {n vm._vnode = null; // the root of the child treen vm._staticTrees = null; // v-once cached treesn var options = vm.$options;n var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent treen var renderContext = parentVnode && parentVnode.context;n vm.$slots = resolveSlots(options._renderChildren, renderContext);n vm.$scopedSlots = emptyObject;n // bind the createElement fn to this instancen // so that we get proper render context inside it.n // args order: tag, data, children, normalizationType, alwaysNormalizen // internal version is used by render functions compiled from templatesn vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };n // normalization is always applied for the public version, used inn // user-written render functions.n vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };nn // $attrs & $listeners are exposed for easier HOC creation.n // they need to be reactive so that HOCs using them are always updatedn var parentData = parentVnode && parentVnode.data;nn /* istanbul ignore else */n if (process.env.NODE_ENV !== 'production') {n defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {n !isUpdatingChildComponent && warn("$attrs is readonly.", vm);n }, true);n defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {n !isUpdatingChildComponent && warn("$listeners is readonly.", vm);n }, true);n } else {n defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, null, true);n defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, null, true);n }n}nnvar currentRenderingInstance = null;nnfunction renderMixin (Vue) {n // install runtime convenience helpersn installRenderHelpers(Vue.prototype);nn Vue.prototype.$nextTick = function (fn) {n return nextTick(fn, this)n };nn Vue.prototype._render = function () {n var vm = this;n var ref = vm.$options;n var render = ref.render;n var _parentVnode = ref._parentVnode;nn if (_parentVnode) {n vm.$scopedSlots = normalizeScopedSlots(n _parentVnode.data.scopedSlots,n vm.$slots,n vm.$scopedSlotsn );n }nn // set parent vnode. this allows render functions to have accessn // to the data on the placeholder node.n vm.$vnode = _parentVnode;n // render selfn var vnode;n try {n // There's no need to maintain a stack because all render fns are calledn // separately from one another. Nested component's render fns are calledn // when parent component is patched.n currentRenderingInstance = vm;n vnode = render.call(vm._renderProxy, vm.$createElement);n } catch (e) {n handleError(e, vm, "render");n // return error render result,n // or previous vnode to prevent render error causing blank componentn /* istanbul ignore else */n if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {n try {n vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);n } catch (e) {n handleError(e, vm, "renderError");n vnode = vm._vnode;n }n } else {n vnode = vm._vnode;n }n } finally {n currentRenderingInstance = null;n }n // if the returned array contains only a single node, allow itn if (Array.isArray(vnode) && vnode.length === 1) {n vnode = vnode;n }n // return empty vnode in case the render function errored outn if (!(vnode instanceof VNode)) {n if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {n warn(n 'Multiple root nodes returned from render function. Render function ' +n 'should return a single root node.',n vmn );n }n vnode = createEmptyVNode();n }n // set parentn vnode.parent = _parentVnode;n return vnoden };n}nn/* */nnfunction ensureCtor (comp, base) {n if (n comp.__esModule ||n (hasSymbol && comp === 'Module')n ) {n comp = comp.default;n }n return isObject(comp)n ? base.extend(comp)n : compn}nnfunction createAsyncPlaceholder (n factory,n data,n context,n children,n tagn) {n var node = createEmptyVNode();n node.asyncFactory = factory;n node.asyncMeta = { data: data, context: context, children: children, tag: tag };n return noden}nnfunction resolveAsyncComponent (n factory,n baseCtorn) {n if (isTrue(factory.error) && isDef(factory.errorComp)) {n return factory.errorCompn }nn if (isDef(factory.resolved)) {n return factory.resolvedn }nn var owner = currentRenderingInstance;n if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {n // already pendingn factory.owners.push(owner);n }nn if (isTrue(factory.loading) && isDef(factory.loadingComp)) {n return factory.loadingCompn }nn if (owner && !isDef(factory.owners)) {n var owners = factory.owners = [owner];n var sync = true;n var timerLoading = null;n var timerTimeout = nullnn ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });nn var forceRender = function (renderCompleted) {n for (var i = 0, l = owners.length; i < l; i++) {n (owners).$forceUpdate();n }nn if (renderCompleted) {n owners.length = 0;n if (timerLoading !== null) {n clearTimeout(timerLoading);n timerLoading = null;n }n if (timerTimeout !== null) {n clearTimeout(timerTimeout);n timerTimeout = null;n }n }n };nn var resolve = once(function (res) {n // cache resolvedn factory.resolved = ensureCtor(res, baseCtor);n // invoke callbacks only if this is not a synchronous resolven // (async resolves are shimmed as synchronous during SSR)n if (!sync) {n forceRender(true);n } else {n owners.length = 0;n }n });nn var reject = once(function (reason) {n process.env.NODE_ENV !== 'production' && warn(n "Failed to resolve async component: " + (String(factory)) +n (reason ? ("\nReason: " + reason) : '')n );n if (isDef(factory.errorComp)) {n factory.error = true;n forceRender(true);n }n });nn var res = factory(resolve, reject);nn if (isObject(res)) {n if (isPromise(res)) {n // () => Promisen if (isUndef(factory.resolved)) {n res.then(resolve, reject);n }n } else if (isPromise(res.component)) {n res.component.then(resolve, reject);nn if (isDef(res.error)) {n factory.errorComp = ensureCtor(res.error, baseCtor);n }nn if (isDef(res.loading)) {n factory.loadingComp = ensureCtor(res.loading, baseCtor);n if (res.delay === 0) {n factory.loading = true;n } else {n timerLoading = setTimeout(function () {n timerLoading = null;n if (isUndef(factory.resolved) && isUndef(factory.error)) {n factory.loading = true;n forceRender(false);n }n }, res.delay || 200);n }n }nn if (isDef(res.timeout)) {n timerTimeout = setTimeout(function () {n timerTimeout = null;n if (isUndef(factory.resolved)) {n reject(n process.env.NODE_ENV !== 'production'n ? ("timeout (" + (res.timeout) + "ms)")n : nulln );n }n }, res.timeout);n }n }n }nn sync = false;n // return in case resolved synchronouslyn return factory.loadingn ? factory.loadingCompn : factory.resolvedn }n}nn/* */nnfunction isAsyncPlaceholder (node) {n return node.isComment && node.asyncFactoryn}nn/* */nnfunction getFirstComponentChild (children) {n if (Array.isArray(children)) {n for (var i = 0; i < children.length; i++) {n var c = children;n if (isDef© && (isDef(c.componentOptions) || isAsyncPlaceholder©)) {n return cn }n }n }n}nn/* */nn/* */nnfunction initEvents (vm) {n vm._events = Object.create(null);n vm._hasHookEvent = false;n // init parent attached eventsn var listeners = vm.$options._parentListeners;n if (listeners) {n updateComponentListeners(vm, listeners);n }n}nnvar target;nnfunction add (event, fn) {n target.$on(event, fn);n}nnfunction remove$1 (event, fn) {n target.$off(event, fn);n}nnfunction createOnceHandler (event, fn) {n var _target = target;n return function onceHandler () {n var res = fn.apply(null, arguments);n if (res !== null) {n _target.$off(event, onceHandler);n }n }n}nnfunction updateComponentListeners (n vm,n listeners,n oldListenersn) {n target = vm;n updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);n target = undefined;n}nnfunction eventsMixin (Vue) {n var hookRE = /^hook:/;n Vue.prototype.$on = function (event, fn) {n var vm = this;n if (Array.isArray(event)) {n for (var i = 0, l = event.length; i < l; i++) {n vm.$on(event, fn);n }n } else {n (vm._events || (vm._events = [])).push(fn);n // optimize hook:event cost by using a boolean flag marked at registrationn // instead of a hash lookupn if (hookRE.test(event)) {n vm._hasHookEvent = true;n }n }n return vmn };nn Vue.prototype.$once = function (event, fn) {n var vm = this;n function on () {n vm.$off(event, on);n fn.apply(vm, arguments);n }n on.fn = fn;n vm.$on(event, on);n return vmn };nn Vue.prototype.$off = function (event, fn) {n var vm = this;n // alln if (!arguments.length) {n vm._events = Object.create(null);n return vmn }n // array of eventsn if (Array.isArray(event)) {n for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {n vm.$off(event, fn);n }n return vmn }n // specific eventn var cbs = vm._events;n if (!cbs) {n return vmn }n if (!fn) {n vm._events = null;n return vmn }n // specific handlern var cb;n var i = cbs.length;n while (i–) {n cb = cbs;n if (cb === fn || cb.fn === fn) {n cbs.splice(i, 1);n breakn }n }n return vmn };nn Vue.prototype.$emit = function (event) {n var vm = this;n if (process.env.NODE_ENV !== 'production') {n var lowerCaseEvent = event.toLowerCase();n if (lowerCaseEvent !== event && vm._events) {n tip(n "Event \"" + lowerCaseEvent + "\" is emitted in component " +n (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +n "Note that HTML attributes are case-insensitive and you cannot use " +n "v-on to listen to camelCase events when using in-DOM templates. " +n "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."n );n }n }n var cbs = vm._events;n if (cbs) {n cbs = cbs.length > 1 ? toArray(cbs) : cbs;n var args = toArray(arguments, 1);n var info = "event handler for \"" + event + "\"";n for (var i = 0, l = cbs.length; i < l; i++) {n invokeWithErrorHandling(cbs, vm, args, vm, info);n }n }n return vmn };n}nn/* */nnvar activeInstance = null;nvar isUpdatingChildComponent = false;nnfunction setActiveInstance(vm) {n var prevActiveInstance = activeInstance;n activeInstance = vm;n return function () {n activeInstance = prevActiveInstance;n }n}nnfunction initLifecycle (vm) {n var options = vm.$options;nn // locate first non-abstract parentn var parent = options.parent;n if (parent && !options.abstract) {n while (parent.$options.abstract && parent.$parent) {n parent = parent.$parent;n }n parent.$children.push(vm);n }nn vm.$parent = parent;n vm.$root = parent ? parent.$root : vm;nn vm.$children = [];n vm.$refs = {};nn vm._watcher = null;n vm._inactive = null;n vm._directInactive = false;n vm._isMounted = false;n vm._isDestroyed = false;n vm._isBeingDestroyed = false;n}nnfunction lifecycleMixin (Vue) {n Vue.prototype._update = function (vnode, hydrating) {n var vm = this;n var prevEl = vm.$el;n var prevVnode = vm._vnode;n var restoreActiveInstance = setActiveInstance(vm);n vm._vnode = vnode;n // Vue.prototype.__patch__ is injected in entry pointsn // based on the rendering backend used.n if (!prevVnode) {n // initial rendern vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);n } else {n // updatesn vm.$el = vm.__patch__(prevVnode, vnode);n }n restoreActiveInstance();n // update __vue__ referencen if (prevEl) {n prevEl.__vue__ = null;n }n if (vm.$el) {n vm.$el.__vue__ = vm;n }n // if parent is an HOC, update its $el as welln if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {n vm.$parent.$el = vm.$el;n }n // updated hook is called by the scheduler to ensure that children aren // updated in a parent's updated hook.n };nn Vue.prototype.$forceUpdate = function () {n var vm = this;n if (vm._watcher) {n vm._watcher.update();n }n };nn Vue.prototype.$destroy = function () {n var vm = this;n if (vm._isBeingDestroyed) {n returnn }n callHook(vm, 'beforeDestroy');n vm._isBeingDestroyed = true;n // remove self from parentn var parent = vm.$parent;n if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {n remove(parent.$children, vm);n }n // teardown watchersn if (vm._watcher) {n vm._watcher.teardown();n }n var i = vm._watchers.length;n while (i–) {n vm._watchers.teardown();n }n // remove reference from data obn // frozen object may not have observer.n if (vm.data._ob__) {n vm.data._ob__.vmCount–;n }n // call the last hook…n vm._isDestroyed = true;n // invoke destroy hooks on current rendered treen vm.__patch__(vm._vnode, null);n // fire destroyed hookn callHook(vm, 'destroyed');n // turn off all instance listeners.n vm.$off();n // remove __vue__ referencen if (vm.$el) {n vm.$el.__vue__ = null;n }n // release circular reference (#6759)n if (vm.$vnode) {n vm.$vnode.parent = null;n }n };n}nnfunction mountComponent (n vm,n el,n hydratingn) {n vm.$el = el;n if (!vm.$options.render) {n vm.$options.render = createEmptyVNode;n if (process.env.NODE_ENV !== 'production') {n /* istanbul ignore if */n if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||n vm.$options.el || el) {n warn(n 'You are using the runtime-only build of Vue where the template ' +n 'compiler is not available. Either pre-compile the templates into ' +n 'render functions, or use the compiler-included build.',n vmn );n } else {n warn(n 'Failed to mount component: template or render function not defined.',n vmn );n }n }n }n callHook(vm, 'beforeMount');nn var updateComponent;n /* istanbul ignore if */n if (process.env.NODE_ENV !== 'production' && config.performance && mark) {n updateComponent = function () {n var name = vm._name;n var id = vm._uid;n var startTag = "vue-perf-start:" + id;n var endTag = "vue-perf-end:" + id;nn mark(startTag);n var vnode = vm._render();n mark(endTag);n measure(("vue " + name + " render"), startTag, endTag);nn mark(startTag);n vm._update(vnode, hydrating);n mark(endTag);n measure(("vue " + name + " patch"), startTag, endTag);n };n } else {n updateComponent = function () {n vm._update(vm._render(), hydrating);n };n }nn // we set this to vm._watcher inside the watcher's constructorn // since the watcher's initial patch may call $forceUpdate (e.g. inside childn // component's mounted hook), which relies on vm._watcher being already definedn new Watcher(vm, updateComponent, noop, {n before: function before () {n if (vm._isMounted && !vm._isDestroyed) {n callHook(vm, 'beforeUpdate');n }n }n }, true /* isRenderWatcher */);n hydrating = false;nn // manually mounted instance, call mounted on selfn // mounted is called for render-created child components in its inserted hookn if (vm.$vnode == null) {n vm._isMounted = true;n callHook(vm, 'mounted');n }n return vmn}nnfunction updateChildComponent (n vm,n propsData,n listeners,n parentVnode,n renderChildrenn) {n if (process.env.NODE_ENV !== 'production') {n isUpdatingChildComponent = true;n }nn // determine whether component has slot childrenn // we need to do this before overwriting $options._renderChildren.nn // check if there are dynamic scopedSlots (hand-written or compiled but withn // dynamic slot names). Static scoped slots compiled from template has then // "$stable" marker.n var newScopedSlots = parentVnode.data.scopedSlots;n var oldScopedSlots = vm.$scopedSlots;n var hasDynamicScopedSlot = !!(n (newScopedSlots && !newScopedSlots.$stable) ||n (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||n (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)n );nn // Any static slot children from the parent may have changed during parent'sn // update. Dynamic scoped slots may also have changed. In such cases, a forcedn // update is necessary to ensure correctness.n var needsForceUpdate = !!(n renderChildren || // has new static slotsn vm.$options._renderChildren || // has old static slotsn hasDynamicScopedSlotn );nn vm.$options._parentVnode = parentVnode;n vm.$vnode = parentVnode; // update vm's placeholder node without re-rendernn if (vm._vnode) { // update child tree's parentn vm._vnode.parent = parentVnode;n }n vm.$options._renderChildren = renderChildren;nn // update $attrs and $listeners hashn // these are also reactive so they may trigger child update if the childn // used them during rendern vm.$attrs = parentVnode.data.attrs || emptyObject;n vm.$listeners = listeners || emptyObject;nn // update propsn if (propsData && vm.$options.props) {n toggleObserving(false);n var props = vm._props;n var propKeys = vm.$options._propKeys || [];n for (var i = 0; i < propKeys.length; i++) {n var key = propKeys;n var propOptions = vm.$options.props; // wtf flow?n props = validateProp(key, propOptions, propsData, vm);n }n toggleObserving(true);n // keep a copy of raw propsDatan vm.$options.propsData = propsData;n }nn // update listenersn listeners = listeners || emptyObject;n var oldListeners = vm.$options._parentListeners;n vm.$options._parentListeners = listeners;n updateComponentListeners(vm, listeners, oldListeners);nn // resolve slots + force update if has childrenn if (needsForceUpdate) {n vm.$slots = resolveSlots(renderChildren, parentVnode.context);n vm.$forceUpdate();n }nn if (process.env.NODE_ENV !== 'production') {n isUpdatingChildComponent = false;n }n}nnfunction isInInactiveTree (vm) {n while (vm && (vm = vm.$parent)) {n if (vm._inactive) { return true }n }n return falsen}nnfunction activateChildComponent (vm, direct) {n if (direct) {n vm._directInactive = false;n if (isInInactiveTree(vm)) {n returnn }n } else if (vm._directInactive) {n returnn }n if (vm._inactive || vm._inactive === null) {n vm._inactive = false;n for (var i = 0; i < vm.$children.length; i++) {n activateChildComponent(vm.$children);n }n callHook(vm, 'activated');n }n}nnfunction deactivateChildComponent (vm, direct) {n if (direct) {n vm._directInactive = true;n if (isInInactiveTree(vm)) {n returnn }n }n if (!vm._inactive) {n vm._inactive = true;n for (var i = 0; i < vm.$children.length; i++) {n deactivateChildComponent(vm.$children);n }n callHook(vm, 'deactivated');n }n}nnfunction callHook (vm, hook) {n // #7573 disable dep collection when invoking lifecycle hooksn pushTarget();n var handlers = vm.$options;n var info = hook + " hook";n if (handlers) {n for (var i = 0, j = handlers.length; i < j; i++) {n invokeWithErrorHandling(handlers, vm, null, vm, info);n }n }n if (vm._hasHookEvent) {n vm.$emit('hook:' + hook);n }n popTarget();n}nn/* */nnvar MAX_UPDATE_COUNT = 100;nnvar queue = [];nvar activatedChildren = [];nvar has = {};nvar circular = {};nvar waiting = false;nvar flushing = false;nvar index = 0;nn/**n * Reset the scheduler's state.n */nfunction resetSchedulerState () {n index = queue.length = activatedChildren.length = 0;n has = {};n if (process.env.NODE_ENV !== 'production') {n circular = {};n }n waiting = flushing = false;n}nn// Async edge case #6566 requires saving the timestamp when event listeners aren// attached. However, calling performance.now() has a perf overhead especiallyn// if the page has thousands of event listeners. Instead, we take a timestampn// every time the scheduler flushes and use that for all event listenersn// attached during that flush.nvar currentFlushTimestamp = 0;nn// Async edge case fix requires storing an event listener's attach timestamp.nvar getNow = Date.now;nn// Determine what event timestamp the browser is using. Annoyingly, then// timestamp can either be hi-res (relative to page load) or low-resn// (relative to UNIX epoch), so in order to compare time we have to use then// same timestamp type when saving the flush timestamp.n// All IE versions use low-res event timestamps, and have problematic clockn// implementations (#9632)nif (inBrowser && !isIE) {n var performance = window.performance;n if (n performance &&n typeof performance.now === 'function' &&n getNow() > document.createEvent('Event').timeStampn ) {n // if the event timestamp, although evaluated AFTER the Date.now(), isn // smaller than it, it means the event is using a hi-res timestamp,n // and we need to use the hi-res version for event listener timestamps asn // well.n getNow = function () { return performance.now(); };n }n}nn/**n * Flush both queues and run the watchers.n */nfunction flushSchedulerQueue () {n currentFlushTimestamp = getNow();n flushing = true;n var watcher, id;nn // Sort queue before flush.n // This ensures that:n // 1. Components are updated from parent to child. (because parent is alwaysn // created before the child)n // 2. A component's user watchers are run before its render watcher (becausen // user watchers are created before the render watcher)n // 3. If a component is destroyed during a parent component's watcher run,n // its watchers can be skipped.n queue.sort(function (a, b) { return a.id - b.id; });nn // do not cache length because more watchers might be pushedn // as we run existing watchersn for (index = 0; index < queue.length; index++) {n watcher = queue;n if (watcher.before) {n watcher.before();n }n id = watcher.id;n has = null;n watcher.run();n // in dev build, check and stop circular updates.n if (process.env.NODE_ENV !== 'production' && has != null) {n circular = (circular || 0) + 1;n if (circular > MAX_UPDATE_COUNT) {n warn(n 'You may have an infinite update loop ' + (n watcher.usern ? ("in watcher with expression \"" + (watcher.expression) + "\"")n : "in a component render function."n ),n watcher.vmn );n breakn }n }n }nn // keep copies of post queues before resetting staten var activatedQueue = activatedChildren.slice();n var updatedQueue = queue.slice();nn resetSchedulerState();nn // call component updated and activated hooksn callActivatedHooks(activatedQueue);n callUpdatedHooks(updatedQueue);nn // devtool hookn /* istanbul ignore if */n if (devtools && config.devtools) {n devtools.emit('flush');n }n}nnfunction callUpdatedHooks (queue) {n var i = queue.length;n while (i–) {n var watcher = queue;n var vm = watcher.vm;n if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {n callHook(vm, 'updated');n }n }n}nn/**n * Queue a kept-alive component that was activated during patch.n * The queue will be processed after the entire tree has been patched.n */nfunction queueActivatedComponent (vm) {n // setting _inactive to false here so that a render function cann // rely on checking whether it's in an inactive tree (e.g. router-view)n vm._inactive = false;n activatedChildren.push(vm);n}nnfunction callActivatedHooks (queue) {n for (var i = 0; i < queue.length; i++) {n queue._inactive = true;n activateChildComponent(queue, true /* true */);n }n}nn/**n * Push a watcher into the watcher queue.n * Jobs with duplicate IDs will be skipped unless it'sn * pushed when the queue is being flushed.n */nfunction queueWatcher (watcher) {n var id = watcher.id;n if (has == null) {n has = true;n if (!flushing) {n queue.push(watcher);n } else {n // if already flushing, splice the watcher based on its idn // if already past its id, it will be run next immediately.n var i = queue.length - 1;n while (i > index && queue.id > watcher.id) {n i–;n }n queue.splice(i + 1, 0, watcher);n }n // queue the flushn if (!waiting) {n waiting = true;nn if (process.env.NODE_ENV !== 'production' && !config.async) {n flushSchedulerQueue();n returnn }n nextTick(flushSchedulerQueue);n }n }n}nn/* */nnnnvar uid$2 = 0;nn/**n * A watcher parses an expression, collects dependencies,n * and fires callback when the expression value changes.n * This is used for both the $watch() api and directives.n */nvar Watcher = function Watcher (n vm,n expOrFn,n cb,n options,n isRenderWatchern) {n this.vm = vm;n if (isRenderWatcher) {n vm._watcher = this;n }n vm._watchers.push(this);n // optionsn if (options) {n this.deep = !!options.deep;n this.user = !!options.user;n this.lazy = !!options.lazy;n this.sync = !!options.sync;n this.before = options.before;n } else {n this.deep = this.user = this.lazy = this.sync = false;n }n this.cb = cb;n this.id = ++uid$2; // uid for batchingn this.active = true;n this.dirty = this.lazy; // for lazy watchersn this.deps = [];n this.newDeps = [];n this.depIds = new _Set();n this.newDepIds = new _Set();n this.expression = process.env.NODE_ENV !== 'production'n ? expOrFn.toString()n : '';n // parse expression for gettern if (typeof expOrFn === 'function') {n this.getter = expOrFn;n } else {n this.getter = parsePath(expOrFn);n if (!this.getter) {n this.getter = noop;n process.env.NODE_ENV !== 'production' && warn(n "Failed watching path: \"" + expOrFn + "\" " +n 'Watcher only accepts simple dot-delimited paths. ' +n 'For full control, use a function instead.',n vmn );n }n }n this.value = this.lazyn ? undefinedn : this.get();n};nn/**n * Evaluate the getter, and re-collect dependencies.n */nWatcher.prototype.get = function get () {n pushTarget(this);n var value;n var vm = this.vm;n try {n value = this.getter.call(vm, vm);n } catch (e) {n if (this.user) {n handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));n } else {n throw en }n } finally {n // "touch" every property so they are all tracked asn // dependencies for deep watchingn if (this.deep) {n traverse(value);n }n popTarget();n this.cleanupDeps();n }n return valuen};nn/**n * Add a dependency to this directive.n */nWatcher.prototype.addDep = function addDep (dep) {n var id = dep.id;n if (!this.newDepIds.has(id)) {n this.newDepIds.add(id);n this.newDeps.push(dep);n if (!this.depIds.has(id)) {n dep.addSub(this);n }n }n};nn/**n * Clean up for dependency collection.n */nWatcher.prototype.cleanupDeps = function cleanupDeps () {n var i = this.deps.length;n while (i–) {n var dep = this.deps;n if (!this.newDepIds.has(dep.id)) {n dep.removeSub(this);n }n }n var tmp = this.depIds;n this.depIds = this.newDepIds;n this.newDepIds = tmp;n this.newDepIds.clear();n tmp = this.deps;n this.deps = this.newDeps;n this.newDeps = tmp;n this.newDeps.length = 0;n};nn/**n * Subscriber interface.n * Will be called when a dependency changes.n */nWatcher.prototype.update = function update () {n /* istanbul ignore else */n if (this.lazy) {n this.dirty = true;n } else if (this.sync) {n this.run();n } else {n queueWatcher(this);n }n};nn/**n * Scheduler job interface.n * Will be called by the scheduler.n */nWatcher.prototype.run = function run () {n if (this.active) {n var value = this.get();n if (n value !== this.value ||n // Deep watchers and watchers on Object/Arrays should fire evenn // when the value is the same, because the value mayn // have mutated.n isObject(value) ||n this.deepn ) {n // set new valuen var oldValue = this.value;n this.value = value;n if (this.user) {n try {n this.cb.call(this.vm, value, oldValue);n } catch (e) {n handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));n }n } else {n this.cb.call(this.vm, value, oldValue);n }n }n }n};nn/**n * Evaluate the value of the watcher.n * This only gets called for lazy watchers.n */nWatcher.prototype.evaluate = function evaluate () {n this.value = this.get();n this.dirty = false;n};nn/**n * Depend on all deps collected by this watcher.n */nWatcher.prototype.depend = function depend () {n var i = this.deps.length;n while (i–) {n this.deps.depend();n }n};nn/**n * Remove self from all dependencies' subscriber list.n */nWatcher.prototype.teardown = function teardown () {n if (this.active) {n // remove self from vm's watcher listn // this is a somewhat expensive operation so we skip itn // if the vm is being destroyed.n if (!this.vm._isBeingDestroyed) {n remove(this.vm._watchers, this);n }n var i = this.deps.length;n while (i–) {n this.deps.removeSub(this);n }n this.active = false;n }n};nn/* */nnvar sharedPropertyDefinition = {n enumerable: true,n configurable: true,n get: noop,n set: noopn};nnfunction proxy (target, sourceKey, key) {n sharedPropertyDefinition.get = function proxyGetter () {n return this[key]n };n sharedPropertyDefinition.set = function proxySetter (val) {n this[key] = val;n };n Object.defineProperty(target, key, sharedPropertyDefinition);n}nnfunction initState (vm) {n vm._watchers = [];n var opts = vm.$options;n if (opts.props) { initProps(vm, opts.props); }n if (opts.methods) { initMethods(vm, opts.methods); }n if (opts.data) {n initData(vm);n } else {n observe(vm._data = {}, true /* asRootData */);n }n if (opts.computed) { initComputed(vm, opts.computed); }n if (opts.watch && opts.watch !== nativeWatch) {n initWatch(vm, opts.watch);n }n}nnfunction initProps (vm, propsOptions) {n var propsData = vm.$options.propsData || {};n var props = vm._props = {};n // cache prop keys so that future props updates can iterate using Arrayn // instead of dynamic object key enumeration.n var keys = vm.$options._propKeys = [];n var isRoot = !vm.$parent;n // root instance props should be convertedn if (!isRoot) {n toggleObserving(false);n }n var loop = function ( key ) {n keys.push(key);n var value = validateProp(key, propsOptions, propsData, vm);n /* istanbul ignore else */n if (process.env.NODE_ENV !== 'production') {n var hyphenatedKey = hyphenate(key);n if (isReservedAttribute(hyphenatedKey) ||n config.isReservedAttr(hyphenatedKey)) {n warn(n ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),n vmn );n }n defineReactive$$1(props, key, value, function () {n if (!isRoot && !isUpdatingChildComponent) {n warn(n "Avoid mutating a prop directly since the value will be " +n "overwritten whenever the parent component re-renders. " +n "Instead, use a data or computed property based on the prop's " +n "value. Prop being mutated: \"" + key + "\"",n vmn );n }n });n } else {n defineReactive$$1(props, key, value);n }n // static props are already proxied on the component's prototypen // during Vue.extend(). We only need to proxy props defined atn // instantiation here.n if (!(key in vm)) {n proxy(vm, "_props", key);n }n };nn for (var key in propsOptions) loop( key );n toggleObserving(true);n}nnfunction initData (vm) {n var data = vm.$options.data;n data = vm._data = typeof data === 'function'n ? getData(data, vm)n : data || {};n if (!isPlainObject(data)) {n data = {};n process.env.NODE_ENV !== 'production' && warn(n 'data functions should return an object:\n' +n 'vuejs.org/v2/guide/components.html#data-Must-Be-a-Function’,n vmn );n }n // proxy data on instancen var keys = Object.keys(data);n var props = vm.$options.props;n var methods = vm.$options.methods;n var i = keys.length;n while (i–) {n var key = keys;n if (process.env.NODE_ENV !== 'production') {n if (methods && hasOwn(methods, key)) {n warn(n ("Method \"" + key + "\" has already been defined as a data property."),n vmn );n }n }n if (props && hasOwn(props, key)) {n process.env.NODE_ENV !== 'production' && warn(n "The data property \"" + key + "\" is already declared as a prop. " +n "Use prop default value instead.",n vmn );n } else if (!isReserved(key)) {n proxy(vm, "_data", key);n }n }n // observe datan observe(data, true /* asRootData */);n}nnfunction getData (data, vm) {n // #7573 disable dep collection when invoking data gettersn pushTarget();n try {n return data.call(vm, vm)n } catch (e) {n handleError(e, vm, "data()");n return {}n } finally {n popTarget();n }n}nnvar computedWatcherOptions = { lazy: true };nnfunction initComputed (vm, computed) {n // $flow-disable-linen var watchers = vm._computedWatchers = Object.create(null);n // computed properties are just getters during SSRn var isSSR = isServerRendering();nn for (var key in computed) {n var userDef = computed;n var getter = typeof userDef === 'function' ? userDef : userDef.get;n if (process.env.NODE_ENV !== 'production' && getter == null) {n warn(n ("Getter is missing for computed property \"" + key + "\"."),n vmn );n }nn if (!isSSR) {n // create internal watcher for the computed property.n watchers = new Watcher(n vm,n getter || noop,n noop,n computedWatcherOptionsn );n }nn // component-defined computed properties are already defined on then // component prototype. We only need to define computed properties definedn // at instantiation here.n if (!(key in vm)) {n defineComputed(vm, key, userDef);n } else if (process.env.NODE_ENV !== 'production') {n if (key in vm.$data) {n warn(("The computed property \"" + key + "\" is already defined in data."), vm);n } else if (vm.$options.props && key in vm.$options.props) {n warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);n }n }n }n}nnfunction defineComputed (n target,n key,n userDefn) {n var shouldCache = !isServerRendering();n if (typeof userDef === 'function') {n sharedPropertyDefinition.get = shouldCachen ? createComputedGetter(key)n : createGetterInvoker(userDef);n sharedPropertyDefinition.set = noop;n } else {n sharedPropertyDefinition.get = userDef.getn ? shouldCache && userDef.cache !== falsen ? createComputedGetter(key)n : createGetterInvoker(userDef.get)n : noop;n sharedPropertyDefinition.set = userDef.set || noop;n }n if (process.env.NODE_ENV !== 'production' &&n sharedPropertyDefinition.set === noop) {n sharedPropertyDefinition.set = function () {n warn(n ("Computed property \"" + key + "\" was assigned to but it has no setter."),n thisn );n };n }n Object.defineProperty(target, key, sharedPropertyDefinition);n}nnfunction createComputedGetter (key) {n return function computedGetter () {n var watcher = this._computedWatchers && this._computedWatchers;n if (watcher) {n if (watcher.dirty) {n watcher.evaluate();n }n if (Dep.target) {n watcher.depend();n }n return watcher.valuen }n }n}nnfunction createGetterInvoker(fn) {n return function computedGetter () {n return fn.call(this, this)n }n}nnfunction initMethods (vm, methods) {n var props = vm.$options.props;n for (var key in methods) {n if (process.env.NODE_ENV !== 'production') {n if (typeof methods !== 'function') {n warn(n "Method \"" + key + "\" has type \"" + (typeof methods) + "\" in the component definition. " +n "Did you reference the function correctly?",n vmn );n }n if (props && hasOwn(props, key)) {n warn(n ("Method \"" + key + "\" has already been defined as a prop."),n vmn );n }n if ((key in vm) && isReserved(key)) {n warn(n "Method \"" + key + "\" conflicts with an existing Vue instance method. " +n "Avoid defining component methods that start with _ or $."n );n }n }n vm = typeof methods !== 'function' ? noop : bind(methods, vm);n }n}nnfunction initWatch (vm, watch) {n for (var key in watch) {n var handler = watch;n if (Array.isArray(handler)) {n for (var i = 0; i < handler.length; i++) {n createWatcher(vm, key, handler);n }n } else {n createWatcher(vm, key, handler);n }n }n}nnfunction createWatcher (n vm,n expOrFn,n handler,n optionsn) {n if (isPlainObject(handler)) {n options = handler;n handler = handler.handler;n }n if (typeof handler === 'string') {n handler = vm;n }n return vm.$watch(expOrFn, handler, options)n}nnfunction stateMixin (Vue) {n // flow somehow has problems with directly declared definition objectn // when using Object.defineProperty, so we have to procedurally build upn // the object here.n var dataDef = {};n dataDef.get = function () { return this._data };n var propsDef = {};n propsDef.get = function () { return this._props };n if (process.env.NODE_ENV !== 'production') {n dataDef.set = function () {n warn(n 'Avoid replacing instance root $data. ' +n 'Use nested data properties instead.',n thisn );n };n propsDef.set = function () {n warn("$props is readonly.", this);n };n }n Object.defineProperty(Vue.prototype, '$data', dataDef);n Object.defineProperty(Vue.prototype, '$props', propsDef);nn Vue.prototype.$set = set;n Vue.prototype.$delete = del;nn Vue.prototype.$watch = function (n expOrFn,n cb,n optionsn ) {n var vm = this;n if (isPlainObject(cb)) {n return createWatcher(vm, expOrFn, cb, options)n }n options = options || {};n options.user = true;n var watcher = new Watcher(vm, expOrFn, cb, options);n if (options.immediate) {n try {n cb.call(vm, watcher.value);n } catch (error) {n handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));n }n }n return function unwatchFn () {n watcher.teardown();n }n };n}nn/* */nnvar uid$3 = 0;nnfunction initMixin (Vue) {n Vue.prototype._init = function (options) {n var vm = this;n // a uidn vm._uid = uid$3++;nn var startTag, endTag;n /* istanbul ignore if */n if (process.env.NODE_ENV !== 'production' && config.performance && mark) {n startTag = "vue-perf-start:" + (vm._uid);n endTag = "vue-perf-end:" + (vm._uid);n mark(startTag);n }nn // a flag to avoid this being observedn vm._isVue = true;n // merge optionsn if (options && options._isComponent) {n // optimize internal component instantiationn // since dynamic options merging is pretty slow, and none of then // internal component options needs special treatment.n initInternalComponent(vm, options);n } else {n vm.$options = mergeOptions(n resolveConstructorOptions(vm.constructor),n options || {},n vmn );n }n /* istanbul ignore else */n if (process.env.NODE_ENV !== 'production') {n initProxy(vm);n } else {n vm._renderProxy = vm;n }n // expose real selfn vm._self = vm;n initLifecycle(vm);n initEvents(vm);n initRender(vm);n callHook(vm, 'beforeCreate');n initInjections(vm); // resolve injections before data/propsn initState(vm);n initProvide(vm); // resolve provide after data/propsn callHook(vm, 'created');nn /* istanbul ignore if */n if (process.env.NODE_ENV !== 'production' && config.performance && mark) {n vm._name = formatComponentName(vm, false);n mark(endTag);n measure(("vue " + (vm._name) + " init"), startTag, endTag);n }nn if (vm.$options.el) {n vm.$mount(vm.$options.el);n }n };n}nnfunction initInternalComponent (vm, options) {n var opts = vm.$options = Object.create(vm.constructor.options);n // doing this because it's faster than dynamic enumeration.n var parentVnode = options._parentVnode;n opts.parent = options.parent;n opts._parentVnode = parentVnode;nn var vnodeComponentOptions = parentVnode.componentOptions;n opts.propsData = vnodeComponentOptions.propsData;n opts._parentListeners = vnodeComponentOptions.listeners;n opts._renderChildren = vnodeComponentOptions.children;n opts._componentTag = vnodeComponentOptions.tag;nn if (options.render) {n opts.render = options.render;n opts.staticRenderFns = options.staticRenderFns;n }n}nnfunction resolveConstructorOptions (Ctor) {n var options = Ctor.options;n if (Ctor.super) {n var superOptions = resolveConstructorOptions(Ctor.super);n var cachedSuperOptions = Ctor.superOptions;n if (superOptions !== cachedSuperOptions) {n // super option changed,n // need to resolve new options.n Ctor.superOptions = superOptions;n // check if there are any late-modified/attached options (#4976)n var modifiedOptions = resolveModifiedOptions(Ctor);n // update base extend optionsn if (modifiedOptions) {n extend(Ctor.extendOptions, modifiedOptions);n }n options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);n if (options.name) {n options.components = Ctor;n }n }n }n return optionsn}nnfunction resolveModifiedOptions (Ctor) {n var modified;n var latest = Ctor.options;n var sealed = Ctor.sealedOptions;n for (var key in latest) {n if (latest !== sealed) {n if (!modified) { modified = {}; }n modified = latest;n }n }n return modifiedn}nnfunction Vue (options) {n if (process.env.NODE_ENV !== 'production' &&n !(this instanceof Vue)n ) {n warn('Vue is a constructor and should be called with the `new` keyword');n }n this._init(options);n}nninitMixin(Vue);nstateMixin(Vue);neventsMixin(Vue);nlifecycleMixin(Vue);nrenderMixin(Vue);nn/* */nnfunction initUse (Vue) {n Vue.use = function (plugin) {n var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));n if (installedPlugins.indexOf(plugin) > -1) {n return thisn }nn // additional parametersn var args = toArray(arguments, 1);n args.unshift(this);n if (typeof plugin.install === 'function') {n plugin.install.apply(plugin, args);n } else if (typeof plugin === 'function') {n plugin.apply(null, args);n }n installedPlugins.push(plugin);n return thisn };n}nn/* */nnfunction initMixin$1 (Vue) {n Vue.mixin = function (mixin) {n this.options = mergeOptions(this.options, mixin);n return thisn };n}nn/* */nnfunction initExtend (Vue) {n /**n * Each instance constructor, including Vue, has a uniquen * cid. This enables us to create wrapped "childn * constructors" for prototypal inheritance and cache them.n */n Vue.cid = 0;n var cid = 1;nn /**n * Class inheritancen */n Vue.extend = function (extendOptions) {n extendOptions = extendOptions || {};n var Super = this;n var SuperId = Super.cid;n var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});n if (cachedCtors) {n return cachedCtorsn }nn var name = extendOptions.name || Super.options.name;n if (process.env.NODE_ENV !== 'production' && name) {n validateComponentName(name);n }nn var Sub = function VueComponent (options) {n this._init(options);n };n Sub.prototype = Object.create(Super.prototype);n Sub.prototype.constructor = Sub;n Sub.cid = cid++;n Sub.options = mergeOptions(n Super.options,n extendOptionsn );n Sub = Super;nn // For props and computed properties, we define the proxy getters onn // the Vue instances at extension time, on the extended prototype. Thisn // avoids Object.defineProperty calls for each instance created.n if (Sub.options.props) {n initProps$1(Sub);n }n if (Sub.options.computed) {n initComputed$1(Sub);n }nn // allow further extension/mixin/plugin usagen Sub.extend = Super.extend;n Sub.mixin = Super.mixin;n Sub.use = Super.use;nn // create asset registers, so extended classesn // can have their private assets too.n ASSET_TYPES.forEach(function (type) {n Sub = Super;n });n // enable recursive self-lookupn if (name) {n Sub.options.components = Sub;n }nn // keep a reference to the super options at extension time.n // later at instantiation we can check if Super's options haven // been updated.n Sub.superOptions = Super.options;n Sub.extendOptions = extendOptions;n Sub.sealedOptions = extend({}, Sub.options);nn // cache constructorn cachedCtors = Sub;n return Subn };n}nnfunction initProps$1 (Comp) {n var props = Comp.options.props;n for (var key in props) {n proxy(Comp.prototype, "_props", key);n }n}nnfunction initComputed$1 (Comp) {n var computed = Comp.options.computed;n for (var key in computed) {n defineComputed(Comp.prototype, key, computed);n }n}nn/* */nnfunction initAssetRegisters (Vue) {n /**n * Create asset registration methods.n */n ASSET_TYPES.forEach(function (type) {n Vue = function (n id,n definitionn ) {n if (!definition) {n return this.options[type + 's’]n } else {n /* istanbul ignore if */n if (process.env.NODE_ENV !== 'production' && type === 'component') {n validateComponentName(id);n }n if (type === 'component' && isPlainObject(definition)) {n definition.name = definition.name || id;n definition = this.options._base.extend(definition);n }n if (type === 'directive' && typeof definition === 'function') {n definition = { bind: definition, update: definition };n }n this.options[type + 's’] = definition;n return definitionn }n };n });n}nn/* */nnnnfunction getComponentName (opts) {n return opts && (opts.Ctor.options.name || opts.tag)n}nnfunction matches (pattern, name) {n if (Array.isArray(pattern)) {n return pattern.indexOf(name) > -1n } else if (typeof pattern === 'string') {n return pattern.split(',').indexOf(name) > -1n } else if (isRegExp(pattern)) {n return pattern.test(name)n }n /* istanbul ignore next */n return falsen}nnfunction pruneCache (keepAliveInstance, filter) {n var cache = keepAliveInstance.cache;n var keys = keepAliveInstance.keys;n var _vnode = keepAliveInstance._vnode;n for (var key in cache) {n var cachedNode = cache;n if (cachedNode) {n var name = getComponentName(cachedNode.componentOptions);n if (name && !filter(name)) {n pruneCacheEntry(cache, key, keys, _vnode);n }n }n }n}nnfunction pruneCacheEntry (n cache,n key,n keys,n currentn) {n var cached$$1 = cache;n if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {n cached$$1.componentInstance.$destroy();n }n cache = null;n remove(keys, key);n}nnvar patternTypes = [String, RegExp, Array];nnvar KeepAlive = {n name: 'keep-alive',n abstract: true,nn props: {n include: patternTypes,n exclude: patternTypes,n max: [String, Number]n },nn created: function created () {n this.cache = Object.create(null);n this.keys = [];n },nn destroyed: function destroyed () {n for (var key in this.cache) {n pruneCacheEntry(this.cache, key, this.keys);n }n },nn mounted: function mounted () {n var this$1 = this;nn this.$watch('include', function (val) {n pruneCache(this$1, function (name) { return matches(val, name); });n });n this.$watch('exclude', function (val) {n pruneCache(this$1, function (name) { return !matches(val, name); });n });n },nn render: function render () {n var slot = this.$slots.default;n var vnode = getFirstComponentChild(slot);n var componentOptions = vnode && vnode.componentOptions;n if (componentOptions) {n // check patternn var name = getComponentName(componentOptions);n var ref = this;n var include = ref.include;n var exclude = ref.exclude;n if (n // not includedn (include && (!name || !matches(include, name))) ||n // excludedn (exclude && name && matches(exclude, name))n ) {n return vnoden }nn var ref$1 = this;n var cache = ref$1.cache;n var keys = ref$1.keys;n var key = vnode.key == nulln // same constructor may get registered as different local componentsn // so cid alone is not enough (#3269)n ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')n : vnode.key;n if (cache) {n vnode.componentInstance = cache.componentInstance;n // make current key freshestn remove(keys, key);n keys.push(key);n } else {n cache = vnode;n keys.push(key);n // prune oldest entryn if (this.max && keys.length > parseInt(this.max)) {n pruneCacheEntry(cache, keys, keys, this._vnode);n }n }nn vnode.data.keepAlive = true;n }n return vnode || (slot && slot)n }n};nnvar builtInComponents = {n KeepAlive: KeepAliven};nn/* */nnfunction initGlobalAPI (Vue) {n // confign var configDef = {};n configDef.get = function () { return config; };n if (process.env.NODE_ENV !== 'production') {n configDef.set = function () {n warn(n 'Do not replace the Vue.config object, set individual fields instead.'n );n };n }n Object.defineProperty(Vue, 'config', configDef);nn // exposed util methods.n // NOTE: these are not considered part of the public API - avoid relying onn // them unless you are aware of the risk.n Vue.util = {n warn: warn,n extend: extend,n mergeOptions: mergeOptions,n defineReactive: defineReactive$$1n };nn Vue.set = set;n Vue.delete = del;n Vue.nextTick = nextTick;nn // 2.6 explicit observable APIn Vue.observable = function (obj) {n observe(obj);n return objn };nn Vue.options = Object.create(null);n ASSET_TYPES.forEach(function (type) {n Vue.options[type + 's'] = Object.create(null);n });nn // this is used to identify the "base" constructor to extend all plain-objectn // components with in Weex's multi-instance scenarios.n Vue.options._base = Vue;nn extend(Vue.options.components, builtInComponents);nn initUse(Vue);n initMixin$1(Vue);n initExtend(Vue);n initAssetRegisters(Vue);n}nninitGlobalAPI(Vue);nnObject.defineProperty(Vue.prototype, '$isServer', {n get: isServerRenderingn});nnObject.defineProperty(Vue.prototype, '$ssrContext', {n get: function get () {n /* istanbul ignore next */n return this.$vnode && this.$vnode.ssrContextn }n});nn// expose FunctionalRenderContext for ssr runtime helper installationnObject.defineProperty(Vue, 'FunctionalRenderContext', {n value: FunctionalRenderContextn});nnVue.version = '2.6.11';nn/* */nn// these are reserved for web because they are directly compiled awayn// during template compilationnvar isReservedAttr = makeMap('style,class');nn// attributes that should be using props for bindingnvar acceptValue = makeMap('input,textarea,option,select,progress');nvar mustUseProp = function (tag, type, attr) {n return (n (attr === 'value' && acceptValue(tag)) && type !== 'button' ||n (attr === 'selected' && tag === 'option') ||n (attr === 'checked' && tag === 'input') ||n (attr === 'muted' && tag === 'video')n )n};nnvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');nnvar isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');nnvar convertEnumeratedValue = function (key, value) {n return isFalsyAttrValue(value) || value === 'false'n ? 'false'n // allow arbitrary string value for contenteditablen : key === 'contenteditable' && isValidContentEditableValue(value)n ? valuen : 'true'n};nnvar isBooleanAttr = makeMap(n 'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +n 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +n 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +n 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +n 'required,reversed,scoped,seamless,selected,sortable,translate,' +n 'truespeed,typemustmatch,visible'n);nnvar xlinkNS = 'www.w3.org/1999/xlink’;nnvar isXlink = function (name) {n return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'n};nnvar getXlinkProp = function (name) {n return isXlink(name) ? name.slice(6, name.length) : ''n};nnvar isFalsyAttrValue = function (val) {n return val == null || val === falsen};nn/* */nnfunction genClassForVnode (vnode) {n var data = vnode.data;n var parentNode = vnode;n var childNode = vnode;n while (isDef(childNode.componentInstance)) {n childNode = childNode.componentInstance._vnode;n if (childNode && childNode.data) {n data = mergeClassData(childNode.data, data);n }n }n while (isDef(parentNode = parentNode.parent)) {n if (parentNode && parentNode.data) {n data = mergeClassData(data, parentNode.data);n }n }n return renderClass(data.staticClass, data.class)n}nnfunction mergeClassData (child, parent) {n return {n staticClass: concat(child.staticClass, parent.staticClass),n class: isDef(child.class)n ? [child.class, parent.class]n : parent.classn }n}nnfunction renderClass (n staticClass,n dynamicClassn) {n if (isDef(staticClass) || isDef(dynamicClass)) {n return concat(staticClass, stringifyClass(dynamicClass))n }n /* istanbul ignore next */n return ''n}nnfunction concat (a, b) {n return a ? b ? (a + ' ' + b) : a : (b || '')n}nnfunction stringifyClass (value) {n if (Array.isArray(value)) {n return stringifyArray(value)n }n if (isObject(value)) {n return stringifyObject(value)n }n if (typeof value === 'string') {n return valuen }n /* istanbul ignore next */n return ''n}nnfunction stringifyArray (value) {n var res = '';n var stringified;n for (var i = 0, l = value.length; i < l; i++) {n if (isDef(stringified = stringifyClass(value)) && stringified !== '') {n if (res) { res += ' '; }n res += stringified;n }n }n return resn}nnfunction stringifyObject (value) {n var res = '';n for (var key in value) {n if (value) {n if (res) { res += ' '; }n res += key;n }n }n return resn}nn/* */nnvar namespaceMap = {n svg: 'www.w3.org/2000/svg’,n math: 'www.w3.org/1998/Math/MathML’n};nnvar isHTMLTag = makeMap(n 'html,body,base,head,link,meta,style,title,' +n 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +n 'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +n 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +n 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +n 'embed,object,param,source,canvas,script,noscript,del,ins,' +n 'caption,col,colgroup,table,thead,tbody,td,th,tr,' +n 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +n 'output,progress,select,textarea,' +n 'details,dialog,menu,menuitem,summary,' +n 'content,element,shadow,template,blockquote,iframe,tfoot'n);nn// this map is intentionally selective, only covering SVG elements that mayn// contain child elements.nvar isSVG = makeMap(n 'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +n 'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +n 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',n truen);nnvar isReservedTag = function (tag) {n return isHTMLTag(tag) || isSVG(tag)n};nnfunction getTagNamespace (tag) {n if (isSVG(tag)) {n return 'svg'n }n // basic support for MathMLn // note it doesn't support other MathML elements being component rootsn if (tag === 'math') {n return 'math'n }n}nnvar unknownElementCache = Object.create(null);nfunction isUnknownElement (tag) {n /* istanbul ignore if */n if (!inBrowser) {n return truen }n if (isReservedTag(tag)) {n return falsen }n tag = tag.toLowerCase();n /* istanbul ignore if */n if (unknownElementCache != null) {n return unknownElementCachen }n var el = document.createElement(tag);n if (tag.indexOf('-') > -1) {n // stackoverflow.com/a/28210364/1070244n return (unknownElementCache = (n el.constructor === window.HTMLUnknownElement ||n el.constructor === window.HTMLElementn ))n } else {n return (unknownElementCache = /HTMLUnknownElement/.test(el.toString()))n }n}nnvar isTextInputType = makeMap('text,number,password,search,email,tel,url');nn/* */nn/**n * Query an element selector if it's not an element already.n */nfunction query (el) {n if (typeof el === 'string') {n var selected = document.querySelector(el);n if (!selected) {n process.env.NODE_ENV !== 'production' && warn(n 'Cannot find element: ' + eln );n return document.createElement('div')n }n return selectedn } else {n return eln }n}nn/* */nnfunction createElement$1 (tagName, vnode) {n var elm = document.createElement(tagName);n if (tagName !== 'select') {n return elmn }n // false or null will remove the attribute but undefined will notn if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {n elm.setAttribute('multiple', 'multiple');n }n return elmn}nnfunction createElementNS (namespace, tagName) {n return document.createElementNS(namespaceMap, tagName)n}nnfunction createTextNode (text) {n return document.createTextNode(text)n}nnfunction createComment (text) {n return document.createComment(text)n}nnfunction insertBefore (parentNode, newNode, referenceNode) {n parentNode.insertBefore(newNode, referenceNode);n}nnfunction removeChild (node, child) {n node.removeChild(child);n}nnfunction appendChild (node, child) {n node.appendChild(child);n}nnfunction parentNode (node) {n return node.parentNoden}nnfunction nextSibling (node) {n return node.nextSiblingn}nnfunction tagName (node) {n return node.tagNamen}nnfunction setTextContent (node, text) {n node.textContent = text;n}nnfunction setStyleScope (node, scopeId) {n node.setAttribute(scopeId, '');n}nnvar nodeOps = /*#__PURE__*/Object.freeze({n createElement: createElement$1,n createElementNS: createElementNS,n createTextNode: createTextNode,n createComment: createComment,n insertBefore: insertBefore,n removeChild: removeChild,n appendChild: appendChild,n parentNode: parentNode,n nextSibling: nextSibling,n tagName: tagName,n setTextContent: setTextContent,n setStyleScope: setStyleScopen});nn/* */nnvar ref = {n create: function create (_, vnode) {n registerRef(vnode);n },n update: function update (oldVnode, vnode) {n if (oldVnode.data.ref !== vnode.data.ref) {n registerRef(oldVnode, true);n registerRef(vnode);n }n },n destroy: function destroy (vnode) {n registerRef(vnode, true);n }n};nnfunction registerRef (vnode, isRemoval) {n var key = vnode.data.ref;n if (!isDef(key)) { return }nn var vm = vnode.context;n var ref = vnode.componentInstance || vnode.elm;n var refs = vm.$refs;n if (isRemoval) {n if (Array.isArray(refs)) {n remove(refs, ref);n } else if (refs === ref) {n refs = undefined;n }n } else {n if (vnode.data.refInFor) {n if (!Array.isArray(refs)) {n refs = [ref];n } else if (refs.indexOf(ref) < 0) {n // $flow-disable-linen refs.push(ref);n }n } else {n refs = ref;n }n }n}nn/**n * Virtual DOM patching algorithm based on Snabbdom byn * Simon Friis Vindum (@paldepind)n * Licensed under the MIT Licensen * github.com/paldepind/snabbdom/blob/master/LICENSEn *n * modified by Evan You (@yyx990803)n *n * Not type-checking this because this file is perf-critical and the costn * of making flow understand it is not worth it.n */nnvar emptyNode = new VNode('', {}, []);nnvar hooks = ['create', 'activate', 'update', 'remove', 'destroy'];nnfunction sameVnode (a, b) {n return (n a.key === b.key && (n (n a.tag === b.tag &&n a.isComment === b.isComment &&n isDef(a.data) === isDef(b.data) &&n sameInputType(a, b)n ) || (n isTrue(a.isAsyncPlaceholder) &&n a.asyncFactory === b.asyncFactory &&n isUndef(b.asyncFactory.error)n )n )n )n}nnfunction sameInputType (a, b) {n if (a.tag !== 'input') { return true }n var i;n var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;n var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;n return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)n}nnfunction createKeyToOldIdx (children, beginIdx, endIdx) {n var i, key;n var map = {};n for (i = beginIdx; i <= endIdx; ++i) {n key = children.key;n if (isDef(key)) { map = i; }n }n return mapn}nnfunction createPatchFunction (backend) {n var i, j;n var cbs = {};nn var modules = backend.modules;n var nodeOps = backend.nodeOps;nn for (i = 0; i < hooks.length; ++i) {n cbs[hooks] = [];n for (j = 0; j < modules.length; ++j) {n if (isDef(modules[hooks])) {n cbs[hooks].push(modules[hooks]);n }n }n }nn function emptyNodeAt (elm) {n return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)n }nn function createRmCb (childElm, listeners) {n function remove$$1 () {n if (–remove$$1.listeners === 0) {n removeNode(childElm);n }n }n remove$$1.listeners = listeners;n return remove$$1n }nn function removeNode (el) {n var parent = nodeOps.parentNode(el);n // element may have already been removed due to v-html / v-textn if (isDef(parent)) {n nodeOps.removeChild(parent, el);n }n }nn function isUnknownElement$$1 (vnode, inVPre) {n return (n !inVPre &&n !vnode.ns &&n !(n config.ignoredElements.length &&n config.ignoredElements.some(function (ignore) {n return isRegExp(ignore)n ? ignore.test(vnode.tag)n : ignore === vnode.tagn })n ) &&n config.isUnknownElement(vnode.tag)n )n }nn var creatingElmInVPre = 0;nn function createElm (n vnode,n insertedVnodeQueue,n parentElm,n refElm,n nested,n ownerArray,n indexn ) {n if (isDef(vnode.elm) && isDef(ownerArray)) {n // This vnode was used in a previous render!n // now it's used as a new node, overwriting its elm would causen // potential patch errors down the road when it's used as an insertionn // reference node. Instead, we clone the node on-demand before creatingn // associated DOM element for it.n vnode = ownerArray = cloneVNode(vnode);n }nn vnode.isRootInsert = !nested; // for transition enter checkn if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {n returnn }nn var data = vnode.data;n var children = vnode.children;n var tag = vnode.tag;n if (isDef(tag)) {n if (process.env.NODE_ENV !== 'production') {n if (data && data.pre) {n creatingElmInVPre++;n }n if (isUnknownElement$$1(vnode, creatingElmInVPre)) {n warn(n 'Unknown custom element: <' + tag + '> - did you ' +n 'register the component correctly? For recursive components, ' +n 'make sure to provide the "name" option.',n vnode.contextn );n }n }nn vnode.elm = vnode.nsn ? nodeOps.createElementNS(vnode.ns, tag)n : nodeOps.createElement(tag, vnode);n setScope(vnode);nn /* istanbul ignore if */n {n createChildren(vnode, children, insertedVnodeQueue);n if (isDef(data)) {n invokeCreateHooks(vnode, insertedVnodeQueue);n }n insert(parentElm, vnode.elm, refElm);n }nn if (process.env.NODE_ENV !== 'production' && data && data.pre) {n creatingElmInVPre–;n }n } else if (isTrue(vnode.isComment)) {n vnode.elm = nodeOps.createComment(vnode.text);n insert(parentElm, vnode.elm, refElm);n } else {n vnode.elm = nodeOps.createTextNode(vnode.text);n insert(parentElm, vnode.elm, refElm);n }n }nn function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {n var i = vnode.data;n if (isDef(i)) {n var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;n if (isDef(i = i.hook) && isDef(i = i.init)) {n i(vnode, false /* hydrating */);n }n // after calling the init hook, if the vnode is a child componentn // it should've created a child instance and mounted it. the childn // component also has set the placeholder vnode's elm.n // in that case we can just return the element and be done.n if (isDef(vnode.componentInstance)) {n initComponent(vnode, insertedVnodeQueue);n insert(parentElm, vnode.elm, refElm);n if (isTrue(isReactivated)) {n reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);n }n return truen }n }n }nn function initComponent (vnode, insertedVnodeQueue) {n if (isDef(vnode.data.pendingInsert)) {n insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);n vnode.data.pendingInsert = null;n }n vnode.elm = vnode.componentInstance.$el;n if (isPatchable(vnode)) {n invokeCreateHooks(vnode, insertedVnodeQueue);n setScope(vnode);n } else {n // empty component root.n // skip all element-related modules except for ref (#3455)n registerRef(vnode);n // make sure to invoke the insert hookn insertedVnodeQueue.push(vnode);n }n }nn function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {n var i;n // hack for #4339: a reactivated component with inner transitionn // does not trigger because the inner node's created hooks are not calledn // again. It's not ideal to involve module-specific logic in here butn // there doesn't seem to be a better way to do it.n var innerNode = vnode;n while (innerNode.componentInstance) {n innerNode = innerNode.componentInstance._vnode;n if (isDef(i = innerNode.data) && isDef(i = i.transition)) {n for (i = 0; i < cbs.activate.length; ++i) {n cbs.activate(emptyNode, innerNode);n }n insertedVnodeQueue.push(innerNode);n breakn }n }n // unlike a newly created component,n // a reactivated keep-alive component doesn't insert itselfn insert(parentElm, vnode.elm, refElm);n }nn function insert (parent, elm, ref$$1) {n if (isDef(parent)) {n if (isDef(ref$$1)) {n if (nodeOps.parentNode(ref$$1) === parent) {n nodeOps.insertBefore(parent, elm, ref$$1);n }n } else {n nodeOps.appendChild(parent, elm);n }n }n }nn function createChildren (vnode, children, insertedVnodeQueue) {n if (Array.isArray(children)) {n if (process.env.NODE_ENV !== 'production') {n checkDuplicateKeys(children);n }n for (var i = 0; i < children.length; ++i) {n createElm(children, insertedVnodeQueue, vnode.elm, null, true, children, i);n }n } else if (isPrimitive(vnode.text)) {n nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));n }n }nn function isPatchable (vnode) {n while (vnode.componentInstance) {n vnode = vnode.componentInstance._vnode;n }n return isDef(vnode.tag)n }nn function invokeCreateHooks (vnode, insertedVnodeQueue) {n for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {n cbs.create(emptyNode, vnode);n }n i = vnode.data.hook; // Reuse variablen if (isDef(i)) {n if (isDef(i.create)) { i.create(emptyNode, vnode); }n if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }n }n }nn // set scope id attribute for scoped CSS.n // this is implemented as a special case to avoid the overheadn // of going through the normal attribute patching process.n function setScope (vnode) {n var i;n if (isDef(i = vnode.fnScopeId)) {n nodeOps.setStyleScope(vnode.elm, i);n } else {n var ancestor = vnode;n while (ancestor) {n if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {n nodeOps.setStyleScope(vnode.elm, i);n }n ancestor = ancestor.parent;n }n }n // for slot content they should also get the scopeId from the host instance.n if (isDef(i = activeInstance) &&n i !== vnode.context &&n i !== vnode.fnContext &&n isDef(i = i.$options._scopeId)n ) {n nodeOps.setStyleScope(vnode.elm, i);n }n }nn function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {n for (; startIdx <= endIdx; ++startIdx) {n createElm(vnodes, insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);n }n }nn function invokeDestroyHook (vnode) {n var i, j;n var data = vnode.data;n if (isDef(data)) {n if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }n for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy(vnode); }n }n if (isDef(i = vnode.children)) {n for (j = 0; j < vnode.children.length; ++j) {n invokeDestroyHook(vnode.children);n }n }n }nn function removeVnodes (vnodes, startIdx, endIdx) {n for (; startIdx <= endIdx; ++startIdx) {n var ch = vnodes;n if (isDef(ch)) {n if (isDef(ch.tag)) {n removeAndInvokeRemoveHook(ch);n invokeDestroyHook(ch);n } else { // Text noden removeNode(ch.elm);n }n }n }n }nn function removeAndInvokeRemoveHook (vnode, rm) {n if (isDef(rm) || isDef(vnode.data)) {n var i;n var listeners = cbs.remove.length + 1;n if (isDef(rm)) {n // we have a recursively passed down rm callbackn // increase the listeners countn rm.listeners += listeners;n } else {n // directly removingn rm = createRmCb(vnode.elm, listeners);n }n // recursively invoke hooks on child component root noden if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {n removeAndInvokeRemoveHook(i, rm);n }n for (i = 0; i < cbs.remove.length; ++i) {n cbs.remove(vnode, rm);n }n if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {n i(vnode, rm);n } else {n rm();n }n } else {n removeNode(vnode.elm);n }n }nn function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {n var oldStartIdx = 0;n var newStartIdx = 0;n var oldEndIdx = oldCh.length - 1;n var oldStartVnode = oldCh;n var oldEndVnode = oldCh;n var newEndIdx = newCh.length - 1;n var newStartVnode = newCh;n var newEndVnode = newCh;n var oldKeyToIdx, idxInOld, vnodeToMove, refElm;nn // removeOnly is a special flag used only by <transition-group>n // to ensure removed elements stay in correct relative positionsn // during leaving transitionsn var canMove = !removeOnly;nn if (process.env.NODE_ENV !== 'production') {n checkDuplicateKeys(newCh);n }nn while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {n if (isUndef(oldStartVnode)) {n oldStartVnode = oldCh; // Vnode has been moved leftn } else if (isUndef(oldEndVnode)) {n oldEndVnode = oldCh;n } else if (sameVnode(oldStartVnode, newStartVnode)) {n patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);n oldStartVnode = oldCh;n newStartVnode = newCh;n } else if (sameVnode(oldEndVnode, newEndVnode)) {n patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);n oldEndVnode = oldCh;n newEndVnode = newCh;n } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved rightn patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);n canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));n oldStartVnode = oldCh;n newEndVnode = newCh;n } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved leftn patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);n canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);n oldEndVnode = oldCh;n newStartVnode = newCh;n } else {n if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }n idxInOld = isDef(newStartVnode.key)n ? oldKeyToIdxn : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);n if (isUndef(idxInOld)) { // New elementn createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);n } else {n vnodeToMove = oldCh;n if (sameVnode(vnodeToMove, newStartVnode)) {n patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);n oldCh = undefined;n canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);n } else {n // same key but different element. treat as new elementn createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);n }n }n newStartVnode = newCh;n }n }n if (oldStartIdx > oldEndIdx) {n refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;n addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);n } else if (newStartIdx > newEndIdx) {n removeVnodes(oldCh, oldStartIdx, oldEndIdx);n }n }nn function checkDuplicateKeys (children) {n var seenKeys = {};n for (var i = 0; i < children.length; i++) {n var vnode = children;n var key = vnode.key;n if (isDef(key)) {n if (seenKeys) {n warn(n ("Duplicate keys detected: '" + key + "'. This may cause an update error."),n vnode.contextn );n } else {n seenKeys = true;n }n }n }n }nn function findIdxInOld (node, oldCh, start, end) {n for (var i = start; i < end; i++) {n var c = oldCh;n if (isDef© && sameVnode(node, c)) { return i }n }n }nn function patchVnode (n oldVnode,n vnode,n insertedVnodeQueue,n ownerArray,n index,n removeOnlyn ) {n if (oldVnode === vnode) {n returnn }nn if (isDef(vnode.elm) && isDef(ownerArray)) {n // clone reused vnoden vnode = ownerArray = cloneVNode(vnode);n }nn var elm = vnode.elm = oldVnode.elm;nn if (isTrue(oldVnode.isAsyncPlaceholder)) {n if (isDef(vnode.asyncFactory.resolved)) {n hydrate(oldVnode.elm, vnode, insertedVnodeQueue);n } else {n vnode.isAsyncPlaceholder = true;n }n returnn }nn // reuse element for static trees.n // note we only do this if the vnode is cloned -n // if the new node is not cloned it means the render functions have beenn // reset by the hot-reload-api and we need to do a proper re-render.n if (isTrue(vnode.isStatic) &&n isTrue(oldVnode.isStatic) &&n vnode.key === oldVnode.key &&n (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))n ) {n vnode.componentInstance = oldVnode.componentInstance;n returnn }nn var i;n var data = vnode.data;n if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {n i(oldVnode, vnode);n }nn var oldCh = oldVnode.children;n var ch = vnode.children;n if (isDef(data) && isPatchable(vnode)) {n for (i = 0; i < cbs.update.length; ++i) { cbs.update(oldVnode, vnode); }n if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }n }n if (isUndef(vnode.text)) {n if (isDef(oldCh) && isDef(ch)) {n if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }n } else if (isDef(ch)) {n if (process.env.NODE_ENV !== 'production') {n checkDuplicateKeys(ch);n }n if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }n addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);n } else if (isDef(oldCh)) {n removeVnodes(oldCh, 0, oldCh.length - 1);n } else if (isDef(oldVnode.text)) {n nodeOps.setTextContent(elm, '');n }n } else if (oldVnode.text !== vnode.text) {n nodeOps.setTextContent(elm, vnode.text);n }n if (isDef(data)) {n if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }n }n }nn function invokeInsertHook (vnode, queue, initial) {n // delay insert hooks for component root nodes, invoke them after then // element is really insertedn if (isTrue(initial) && isDef(vnode.parent)) {n vnode.parent.data.pendingInsert = queue;n } else {n for (var i = 0; i < queue.length; ++i) {n queue.data.hook.insert(queue);n }n }n }nn var hydrationBailed = false;n // list of modules that can skip create hook during hydration because theyn // are already rendered on the client or has no need for initializationn // Note: style is excluded because it relies on initial clone for futuren // deep updates (#7063).n var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');nn // Note: this is a browser-only function so we can assume elms are DOM nodes.n function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {n var i;n var tag = vnode.tag;n var data = vnode.data;n var children = vnode.children;n inVPre = inVPre || (data && data.pre);n vnode.elm = elm;nn if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {n vnode.isAsyncPlaceholder = true;n return truen }n // assert node matchn if (process.env.NODE_ENV !== 'production') {n if (!assertNodeMatch(elm, vnode, inVPre)) {n return falsen }n }n if (isDef(data)) {n if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }n if (isDef(i = vnode.componentInstance)) {n // child component. it should have hydrated its own tree.n initComponent(vnode, insertedVnodeQueue);n return truen }n }n if (isDef(tag)) {n if (isDef(children)) {n // empty element, allow client to pick up and populate childrenn if (!elm.hasChildNodes()) {n createChildren(vnode, children, insertedVnodeQueue);n } else {n // v-html and domProps: innerHTMLn if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {n if (i !== elm.innerHTML) {n /* istanbul ignore if */n if (process.env.NODE_ENV !== 'production' &&n typeof console !== 'undefined' &&n !hydrationBailedn ) {n hydrationBailed = true;n console.warn('Parent: ', elm);n console.warn('server innerHTML: ', i);n console.warn('client innerHTML: ', elm.innerHTML);n }n return falsen }n } else {n // iterate and compare children listsn var childrenMatch = true;n var childNode = elm.firstChild;n for (var i$1 = 0; i$1 < children.length; i$1++) {n if (!childNode || !hydrate(childNode, children, insertedVnodeQueue, inVPre)) {n childrenMatch = false;n breakn }n childNode = childNode.nextSibling;n }n // if childNode is not null, it means the actual childNodes list isn // longer than the virtual children list.n if (!childrenMatch || childNode) {n /* istanbul ignore if */n if (process.env.NODE_ENV !== 'production' &&n typeof console !== 'undefined' &&n !hydrationBailedn ) {n hydrationBailed = true;n console.warn('Parent: ', elm);n console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);n }n return falsen }n }n }n }n if (isDef(data)) {n var fullInvoke = false;n for (var key in data) {n if (!isRenderedModule(key)) {n fullInvoke = true;n invokeCreateHooks(vnode, insertedVnodeQueue);n breakn }n }n if (!fullInvoke && data) {n // ensure collecting deps for deep class bindings for future updatesn traverse(data);n }n }n } else if (elm.data !== vnode.text) {n elm.data = vnode.text;n }n return truen }nn function assertNodeMatch (node, vnode, inVPre) {n if (isDef(vnode.tag)) {n return vnode.tag.indexOf('vue-component') === 0 || (n !isUnknownElement$$1(vnode, inVPre) &&n vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())n )n } else {n return node.nodeType === (vnode.isComment ? 8 : 3)n }n }nn return function patch (oldVnode, vnode, hydrating, removeOnly) {n if (isUndef(vnode)) {n if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }n returnn }nn var isInitialPatch = false;n var insertedVnodeQueue = [];nn if (isUndef(oldVnode)) {n // empty mount (likely as component), create new root elementn isInitialPatch = true;n createElm(vnode, insertedVnodeQueue);n } else {n var isRealElement = isDef(oldVnode.nodeType);n if (!isRealElement && sameVnode(oldVnode, vnode)) {n // patch existing root noden patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);n } else {n if (isRealElement) {n // mounting to a real elementn // check if this is server-rendered content and if we can performn // a successful hydration.n if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {n oldVnode.removeAttribute(SSR_ATTR);n hydrating = true;n }n if (isTrue(hydrating)) {n if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {n invokeInsertHook(vnode, insertedVnodeQueue, true);n return oldVnoden } else if (process.env.NODE_ENV !== 'production') {n warn(n 'The client-side rendered virtual DOM tree is not matching ' +n 'server-rendered content. This is likely caused by incorrect ' +n 'HTML markup, for example nesting block-level elements inside ' +n '<p>, or missing <tbody>. Bailing hydration and performing ' +n 'full client-side render.'n );n }n }n // either not server-rendered, or hydration failed.n // create an empty node and replace itn oldVnode = emptyNodeAt(oldVnode);n }nn // replacing existing elementn var oldElm = oldVnode.elm;n var parentElm = nodeOps.parentNode(oldElm);nn // create new noden createElm(n vnode,n insertedVnodeQueue,n // extremely rare edge case: do not insert if old element is in an // leaving transition. Only happens when combining transition +n // keep-alive + HOCs. (#4590)n oldElm._leaveCb ? null : parentElm,n nodeOps.nextSibling(oldElm)n );nn // update parent placeholder node element, recursivelyn if (isDef(vnode.parent)) {n var ancestor = vnode.parent;n var patchable = isPatchable(vnode);n while (ancestor) {n for (var i = 0; i < cbs.destroy.length; ++i) {n cbs.destroy(ancestor);n }n ancestor.elm = vnode.elm;n if (patchable) {n for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {n cbs.create(emptyNode, ancestor);n }n // #6513n // invoke insert hooks that may have been merged by create hooks.n // e.g. for directives that uses the "inserted" hook.n var insert = ancestor.data.hook.insert;n if (insert.merged) {n // start at index 1 to avoid re-invoking component mounted hookn for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {n insert.fns();n }n }n } else {n registerRef(ancestor);n }n ancestor = ancestor.parent;n }n }nn // destroy old noden if (isDef(parentElm)) {n removeVnodes(, 0, 0);n } else if (isDef(oldVnode.tag)) {n invokeDestroyHook(oldVnode);n }n }n }nn invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);n return vnode.elmn }n}nn/* */nnvar directives = {n create: updateDirectives,n update: updateDirectives,n destroy: function unbindDirectives (vnode) {n updateDirectives(vnode, emptyNode);n }n};nnfunction updateDirectives (oldVnode, vnode) {n if (oldVnode.data.directives || vnode.data.directives) {n _update(oldVnode, vnode);n }n}nnfunction _update (oldVnode, vnode) {n var isCreate = oldVnode === emptyNode;n var isDestroy = vnode === emptyNode;n var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);n var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);nn var dirsWithInsert = [];n var dirsWithPostpatch = [];nn var key, oldDir, dir;n for (key in newDirs) {n oldDir = oldDirs;n dir = newDirs;n if (!oldDir) {n // new directive, bindn callHook$1(dir, 'bind', vnode, oldVnode);n if (dir.def && dir.def.inserted) {n dirsWithInsert.push(dir);n }n } else {n // existing directive, updaten dir.oldValue = oldDir.value;n dir.oldArg = oldDir.arg;n callHook$1(dir, 'update', vnode, oldVnode);n if (dir.def && dir.def.componentUpdated) {n dirsWithPostpatch.push(dir);n }n }n }nn if (dirsWithInsert.length) {n var callInsert = function () {n for (var i = 0; i < dirsWithInsert.length; i++) {n callHook$1(dirsWithInsert, 'inserted', vnode, oldVnode);n }n };n if (isCreate) {n mergeVNodeHook(vnode, 'insert', callInsert);n } else {n callInsert();n }n }nn if (dirsWithPostpatch.length) {n mergeVNodeHook(vnode, 'postpatch', function () {n for (var i = 0; i < dirsWithPostpatch.length; i++) {n callHook$1(dirsWithPostpatch, 'componentUpdated', vnode, oldVnode);n }n });n }nn if (!isCreate) {n for (key in oldDirs) {n if (!newDirs) {n // no longer present, unbindn callHook$1(oldDirs, 'unbind', oldVnode, oldVnode, isDestroy);n }n }n }n}nnvar emptyModifiers = Object.create(null);nnfunction normalizeDirectives$1 (n dirs,n vmn) {n var res = Object.create(null);n if (!dirs) {n // $flow-disable-linen return resn }n var i, dir;n for (i = 0; i < dirs.length; i++) {n dir = dirs;n if (!dir.modifiers) {n // $flow-disable-linen dir.modifiers = emptyModifiers;n }n res = dir;n dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);n }n // $flow-disable-linen return resn}nnfunction getRawDirName (dir) {n return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))n}nnfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {n var fn = dir.def && dir.def;n if (fn) {n try {n fn(vnode.elm, dir, vnode, oldVnode, isDestroy);n } catch (e) {n handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));n }n }n}nnvar baseModules = [n ref,n directivesn];nn/* */nnfunction updateAttrs (oldVnode, vnode) {n var opts = vnode.componentOptions;n if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {n returnn }n if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {n returnn }n var key, cur, old;n var elm = vnode.elm;n var oldAttrs = oldVnode.data.attrs || {};n var attrs = vnode.data.attrs || {};n // clone observed objects, as the user probably wants to mutate itn if (isDef(attrs.__ob__)) {n attrs = vnode.data.attrs = extend({}, attrs);n }nn for (key in attrs) {n cur = attrs;n old = oldAttrs;n if (old !== cur) {n setAttr(elm, key, cur);n }n }n // #4391: in IE9, setting type can reset value for inputn // #6666: IE/Edge forces progress value down to 1 before setting a maxn /* istanbul ignore if */n if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {n setAttr(elm, 'value', attrs.value);n }n for (key in oldAttrs) {n if (isUndef(attrs)) {n if (isXlink(key)) {n elm.removeAttributeNS(xlinkNS, getXlinkProp(key));n } else if (!isEnumeratedAttr(key)) {n elm.removeAttribute(key);n }n }n }n}nnfunction setAttr (el, key, value) {n if (el.tagName.indexOf('-') > -1) {n baseSetAttr(el, key, value);n } else if (isBooleanAttr(key)) {n // set attribute for blank valuen // e.g. <option disabled>Select one</option>n if (isFalsyAttrValue(value)) {n el.removeAttribute(key);n } else {n // technically allowfullscreen is a boolean attribute for <iframe>,n // but Flash expects a value of "true" when used on <embed> tagn value = key === 'allowfullscreen' && el.tagName === 'EMBED'n ? 'true'n : key;n el.setAttribute(key, value);n }n } else if (isEnumeratedAttr(key)) {n el.setAttribute(key, convertEnumeratedValue(key, value));n } else if (isXlink(key)) {n if (isFalsyAttrValue(value)) {n el.removeAttributeNS(xlinkNS, getXlinkProp(key));n } else {n el.setAttributeNS(xlinkNS, key, value);n }n } else {n baseSetAttr(el, key, value);n }n}nnfunction baseSetAttr (el, key, value) {n if (isFalsyAttrValue(value)) {n el.removeAttribute(key);n } else {n // #7138: IE10 & 11 fires input event when setting placeholder onn // <textarea>… block the first input event and remove the blockern // immediately.n /* istanbul ignore if */n if (n isIE && !isIE9 &&n el.tagName === 'TEXTAREA' &&n key === 'placeholder' && value !== '' && !el.__iephn ) {n var blocker = function (e) {n e.stopImmediatePropagation();n el.removeEventListener('input', blocker);n };n el.addEventListener('input', blocker);n // $flow-disable-linen el.__ieph = true; /* IE placeholder patched */n }n el.setAttribute(key, value);n }n}nnvar attrs = {n create: updateAttrs,n update: updateAttrsn};nn/* */nnfunction updateClass (oldVnode, vnode) {n var el = vnode.elm;n var data = vnode.data;n var oldData = oldVnode.data;n if (n isUndef(data.staticClass) &&n isUndef(data.class) && (n isUndef(oldData) || (n isUndef(oldData.staticClass) &&n isUndef(oldData.class)n )n )n ) {n returnn }nn var cls = genClassForVnode(vnode);nn // handle transition classesn var transitionClass = el._transitionClasses;n if (isDef(transitionClass)) {n cls = concat(cls, stringifyClass(transitionClass));n }nn // set the classn if (cls !== el._prevClass) {n el.setAttribute('class', cls);n el._prevClass = cls;n }n}nnvar klass = {n create: updateClass,n update: updateClassn};nn/* */nn/* */nn/* */nn/* */nn// in some cases, the event used has to be determined at runtimen// so we used some reserved tokens during compile.nvar RANGE_TOKEN = '__r';nvar CHECKBOX_RADIO_TOKEN = '__c';nn/* */nn// normalize v-model event tokens that can only be determined at runtime.n// it's important to place the event as the first in the array becausen// the whole point is ensuring the v-model callback gets called beforen// user-attached handlers.nfunction normalizeEvents (on) {n /* istanbul ignore if */n if (isDef(on)) {n // IE input only supports `change` eventn var event = isIE ? 'change' : 'input';n on = [].concat(on, on || []);n delete on;n }n // This was originally intended to fix #4521 but no longer necessaryn // after 2.5. Keeping it for backwards compat with generated code from < 2.4n /* istanbul ignore if */n if (isDef(on)) {n on.change = [].concat(on, on.change || []);n delete on;n }n}nnvar target$1;nnfunction createOnceHandler$1 (event, handler, capture) {n var _target = target$1; // save current target element in closuren return function onceHandler () {n var res = handler.apply(null, arguments);n if (res !== null) {n remove$2(event, onceHandler, capture, _target);n }n }n}nn// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStampn// implementation and does not fire microtasks in between event propagation, son// safe to exclude.nvar useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF) <= 53);nnfunction add$1 (n name,n handler,n capture,n passiven) {n // async edge case #6566: inner click event triggers patch, event handlern // attached to outer element during patch, and triggered again. Thisn // happens because browsers fire microtask ticks between event propagation.n // the solution is simple: we save the timestamp when a handler is attached,n // and the handler would only fire if the event passed to it was firedn // AFTER it was attached.n if (useMicrotaskFix) {n var attachedTimestamp = currentFlushTimestamp;n var original = handler;n handler = original._wrapper = function (e) {n if (n // no bubbling, should always fire.n // this is just a safety net in case event.timeStamp is unreliable inn // certain weird environments…n e.target === e.currentTarget ||n // event is fired after handler attachmentn e.timeStamp >= attachedTimestamp ||n // bail for environments that have buggy event.timeStamp implementationsn // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushStaten // #9681 QtWebEngine event.timeStamp is negative valuen e.timeStamp <= 0 ||n // #9448 bail if event is fired in another document in a multi-pagen // electron/nw.js app, since event.timeStamp will be using a differentn // starting referencen e.target.ownerDocument !== documentn ) {n return original.apply(this, arguments)n }n };n }n target$1.addEventListener(n name,n handler,n supportsPassiven ? { capture: capture, passive: passive }n : capturen );n}nnfunction remove$2 (n name,n handler,n capture,n _targetn) {n (_target || target$1).removeEventListener(n name,n handler._wrapper || handler,n capturen );n}nnfunction updateDOMListeners (oldVnode, vnode) {n if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {n returnn }n var on = vnode.data.on || {};n var oldOn = oldVnode.data.on || {};n target$1 = vnode.elm;n normalizeEvents(on);n updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);n target$1 = undefined;n}nnvar events = {n create: updateDOMListeners,n update: updateDOMListenersn};nn/* */nnvar svgContainer;nnfunction updateDOMProps (oldVnode, vnode) {n if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {n returnn }n var key, cur;n var elm = vnode.elm;n var oldProps = oldVnode.data.domProps || {};n var props = vnode.data.domProps || {};n // clone observed objects, as the user probably wants to mutate itn if (isDef(props.__ob__)) {n props = vnode.data.domProps = extend({}, props);n }nn for (key in oldProps) {n if (!(key in props)) {n elm = '';n }n }nn for (key in props) {n cur = props;n // ignore children if the node has textContent or innerHTML,n // as these will throw away existing DOM nodes and cause removal errorsn // on subsequent patches (#3360)n if (key === 'textContent' || key === 'innerHTML') {n if (vnode.children) { vnode.children.length = 0; }n if (cur === oldProps) { continue }n // #6601 work around Chrome version <= 55 bug where single textNoden // replaced by innerHTML/textContent retains its parentNode propertyn if (elm.childNodes.length === 1) {n elm.removeChild(elm.childNodes);n }n }nn if (key === 'value' && elm.tagName !== 'PROGRESS') {n // store value as _value as well sincen // non-string values will be stringifiedn elm._value = cur;n // avoid resetting cursor position when value is the samen var strCur = isUndef(cur) ? '' : String(cur);n if (shouldUpdateValue(elm, strCur)) {n elm.value = strCur;n }n } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {n // IE doesn't support innerHTML for SVG elementsn svgContainer = svgContainer || document.createElement('div');n svgContainer.innerHTML = "<svg>" + cur + "</svg>";n var svg = svgContainer.firstChild;n while (elm.firstChild) {n elm.removeChild(elm.firstChild);n }n while (svg.firstChild) {n elm.appendChild(svg.firstChild);n }n } else if (n // skip the update if old and new VDOM state is the same.n // `value` is handled separately because the DOM value may be temporarilyn // out of sync with VDOM state due to focus, composition and modifiers.n // This #4521 by skipping the unnecesarry `checked` update.n cur !== oldPropsn ) {n // some property updates can thrown // e.g. `value` on <progress> w/ non-finite valuen try {n elm = cur;n } catch (e) {}n }n }n}nn// check platforms/web/util/attrs.js acceptValuennnfunction shouldUpdateValue (elm, checkVal) {n return (!elm.composing && (n elm.tagName === 'OPTION' ||n isNotInFocusAndDirty(elm, checkVal) ||n isDirtyWithModifiers(elm, checkVal)n ))n}nnfunction isNotInFocusAndDirty (elm, checkVal) {n // return true when textbox (.number and .trim) loses focus and its value isn // not equal to the updated valuen var notInFocus = true;n // #6157n // work around IE bug when accessing document.activeElement in an iframen try { notInFocus = document.activeElement !== elm; } catch (e) {}n return notInFocus && elm.value !== checkValn}nnfunction isDirtyWithModifiers (elm, newVal) {n var value = elm.value;n var modifiers = elm._vModifiers; // injected by v-model runtimen if (isDef(modifiers)) {n if (modifiers.number) {n return toNumber(value) !== toNumber(newVal)n }n if (modifiers.trim) {n return value.trim() !== newVal.trim()n }n }n return value !== newValn}nnvar domProps = {n create: updateDOMProps,n update: updateDOMPropsn};nn/* */nnvar parseStyleText = cached(function (cssText) {n var res = {};n var listDelimiter = /;(?![^(]*\))/g;n var propertyDelimiter = /:(.+)/;n cssText.split(listDelimiter).forEach(function (item) {n if (item) {n var tmp = item.split(propertyDelimiter);n tmp.length > 1 && (res[tmp.trim()] = tmp.trim());n }n });n return resn});nn// merge static and dynamic style data on the same vnodenfunction normalizeStyleData (data) {n var style = normalizeStyleBinding(data.style);n // static style is pre-processed into an object during compilationn // and is always a fresh object, so it's safe to merge into itn return data.staticStylen ? extend(data.staticStyle, style)n : stylen}nn// normalize possible array / string values into Objectnfunction normalizeStyleBinding (bindingStyle) {n if (Array.isArray(bindingStyle)) {n return toObject(bindingStyle)n }n if (typeof bindingStyle === 'string') {n return parseStyleText(bindingStyle)n }n return bindingStylen}nn/**n * parent component style should be after child'sn * so that parent component's style could override itn */nfunction getStyle (vnode, checkChild) {n var res = {};n var styleData;nn if (checkChild) {n var childNode = vnode;n while (childNode.componentInstance) {n childNode = childNode.componentInstance._vnode;n if (n childNode && childNode.data &&n (styleData = normalizeStyleData(childNode.data))n ) {n extend(res, styleData);n }n }n }nn if ((styleData = normalizeStyleData(vnode.data))) {n extend(res, styleData);n }nn var parentNode = vnode;n while ((parentNode = parentNode.parent)) {n if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {n extend(res, styleData);n }n }n return resn}nn/* */nnvar cssVarRE = /^–/;nvar importantRE = /\s*!important$/;nvar setProp = function (el, name, val) {n /* istanbul ignore if */n if (cssVarRE.test(name)) {n el.style.setProperty(name, val);n } else if (importantRE.test(val)) {n el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');n } else {n var normalizedName = normalize(name);n if (Array.isArray(val)) {n // Support values array created by autoprefixer, e.g.n // {display: ["-webkit-box", "-ms-flexbox", "flex"]}n // Set them one by one, and the browser will only set those it can recognizen for (var i = 0, len = val.length; i < len; i++) {n el.style = val;n }n } else {n el.style = val;n }n }n};nnvar vendorNames = ['Webkit', 'Moz', 'ms'];nnvar emptyStyle;nvar normalize = cached(function (prop) {n emptyStyle = emptyStyle || document.createElement('div').style;n prop = camelize(prop);n if (prop !== 'filter' && (prop in emptyStyle)) {n return propn }n var capName = prop.charAt(0).toUpperCase() + prop.slice(1);n for (var i = 0; i < vendorNames.length; i++) {n var name = vendorNames + capName;n if (name in emptyStyle) {n return namen }n }n});nnfunction updateStyle (oldVnode, vnode) {n var data = vnode.data;n var oldData = oldVnode.data;nn if (isUndef(data.staticStyle) && isUndef(data.style) &&n isUndef(oldData.staticStyle) && isUndef(oldData.style)n ) {n returnn }nn var cur, name;n var el = vnode.elm;n var oldStaticStyle = oldData.staticStyle;n var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};nn // if static style exists, stylebinding already merged into it when doing normalizeStyleDatan var oldStyle = oldStaticStyle || oldStyleBinding;nn var style = normalizeStyleBinding(vnode.data.style) || {};nn // store normalized style under a different key for next diffn // make sure to clone it if it's reactive, since the user likely wantsn // to mutate it.n vnode.data.normalizedStyle = isDef(style.__ob__)n ? extend({}, style)n : style;nn var newStyle = getStyle(vnode, true);nn for (name in oldStyle) {n if (isUndef(newStyle)) {n setProp(el, name, '');n }n }n for (name in newStyle) {n cur = newStyle;n if (cur !== oldStyle) {n // ie9 setting to null has no effect, must use empty stringn setProp(el, name, cur == null ? '' : cur);n }n }n}nnvar style = {n create: updateStyle,n update: updateStylen};nn/* */nnvar whitespaceRE = /\s+/;nn/**n * Add class with compatibility for SVG since classList is not supported onn * SVG elements in IEn */nfunction addClass (el, cls) {n /* istanbul ignore if */n if (!cls || !(cls = cls.trim())) {n returnn }nn /* istanbul ignore else */n if (el.classList) {n if (cls.indexOf(' ') > -1) {n cls.split(whitespaceRE).forEach(function © { return el.classList.add©; });n } else {n el.classList.add(cls);n }n } else {n var cur = " " + (el.getAttribute('class') || '') + " ";n if (cur.indexOf(' ' + cls + ' ') < 0) {n el.setAttribute('class', (cur + cls).trim());n }n }n}nn/**n * Remove class with compatibility for SVG since classList is not supported onn * SVG elements in IEn */nfunction removeClass (el, cls) {n /* istanbul ignore if */n if (!cls || !(cls = cls.trim())) {n returnn }nn /* istanbul ignore else */n if (el.classList) {n if (cls.indexOf(' ') > -1) {n cls.split(whitespaceRE).forEach(function © { return el.classList.remove©; });n } else {n el.classList.remove(cls);n }n if (!el.classList.length) {n el.removeAttribute('class');n }n } else {n var cur = " " + (el.getAttribute('class') || '') + " ";n var tar = ' ' + cls + ' ';n while (cur.indexOf(tar) >= 0) {n cur = cur.replace(tar, ' ');n }n cur = cur.trim();n if (cur) {n el.setAttribute('class', cur);n } else {n el.removeAttribute('class');n }n }n}nn/* */nnfunction resolveTransition (def$$1) {n if (!def$$1) {n returnn }n /* istanbul ignore else */n if (typeof def$$1 === 'object') {n var res = {};n if (def$$1.css !== false) {n extend(res, autoCssTransition(def$$1.name || 'v'));n }n extend(res, def$$1);n return resn } else if (typeof def$$1 === 'string') {n return autoCssTransition(def$$1)n }n}nnvar autoCssTransition = cached(function (name) {n return {n enterClass: (name + "-enter"),n enterToClass: (name + "-enter-to"),n enterActiveClass: (name + "-enter-active"),n leaveClass: (name + "-leave"),n leaveToClass: (name + "-leave-to"),n leaveActiveClass: (name + "-leave-active")n }n});nnvar hasTransition = inBrowser && !isIE9;nvar TRANSITION = 'transition';nvar ANIMATION = 'animation';nn// Transition property/event sniffingnvar transitionProp = 'transition';nvar transitionEndEvent = 'transitionend';nvar animationProp = 'animation';nvar animationEndEvent = 'animationend';nif (hasTransition) {n /* istanbul ignore if */n if (window.ontransitionend === undefined &&n window.onwebkittransitionend !== undefinedn ) {n transitionProp = 'WebkitTransition';n transitionEndEvent = 'webkitTransitionEnd';n }n if (window.onanimationend === undefined &&n window.onwebkitanimationend !== undefinedn ) {n animationProp = 'WebkitAnimation';n animationEndEvent = 'webkitAnimationEnd';n }n}nn// binding to window is necessary to make hot reload work in IE in strict modenvar raf = inBrowsern ? window.requestAnimationFramen ? window.requestAnimationFrame.bind(window)n : setTimeoutn : /* istanbul ignore next */ function (fn) { return fn(); };nnfunction nextFrame (fn) {n raf(function () {n raf(fn);n });n}nnfunction addTransitionClass (el, cls) {n var transitionClasses = el._transitionClasses || (el._transitionClasses = []);n if (transitionClasses.indexOf(cls) < 0) {n transitionClasses.push(cls);n addClass(el, cls);n }n}nnfunction removeTransitionClass (el, cls) {n if (el._transitionClasses) {n remove(el._transitionClasses, cls);n }n removeClass(el, cls);n}nnfunction whenTransitionEnds (n el,n expectedType,n cbn) {n var ref = getTransitionInfo(el, expectedType);n var type = ref.type;n var timeout = ref.timeout;n var propCount = ref.propCount;n if (!type) { return cb() }n var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;n var ended = 0;n var end = function () {n el.removeEventListener(event, onEnd);n cb();n };n var onEnd = function (e) {n if (e.target === el) {n if (++ended >= propCount) {n end();n }n }n };n setTimeout(function () {n if (ended < propCount) {n end();n }n }, timeout + 1);n el.addEventListener(event, onEnd);n}nnvar transformRE = /\b(transform|all)(,|$)/;nnfunction getTransitionInfo (el, expectedType) {n var styles = window.getComputedStyle(el);n // JSDOM may return undefined for transition propertiesn var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');n var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');n var transitionTimeout = getTimeout(transitionDelays, transitionDurations);n var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');n var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');n var animationTimeout = getTimeout(animationDelays, animationDurations);nn var type;n var timeout = 0;n var propCount = 0;n /* istanbul ignore if */n if (expectedType === TRANSITION) {n if (transitionTimeout > 0) {n type = TRANSITION;n timeout = transitionTimeout;n propCount = transitionDurations.length;n }n } else if (expectedType === ANIMATION) {n if (animationTimeout > 0) {n type = ANIMATION;n timeout = animationTimeout;n propCount = animationDurations.length;n }n } else {n timeout = Math.max(transitionTimeout, animationTimeout);n type = timeout > 0n ? transitionTimeout > animationTimeoutn ? TRANSITIONn : ANIMATIONn : null;n propCount = typen ? type === TRANSITIONn ? transitionDurations.lengthn : animationDurations.lengthn : 0;n }n var hasTransform =n type === TRANSITION &&n transformRE.test(styles[transitionProp + 'Property']);n return {n type: type,n timeout: timeout,n propCount: propCount,n hasTransform: hasTransformn }n}nnfunction getTimeout (delays, durations) {n /* istanbul ignore next */n while (delays.length < durations.length) {n delays = delays.concat(delays);n }nn return Math.max.apply(null, durations.map(function (d, i) {n return toMs(d) + toMs(delays)n }))n}nn// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbersn// in a locale-dependent way, using a comma instead of a dot.n// If comma is not replaced with a dot, the input will be rounded down (i.e. actingn// as a floor function) causing unexpected behaviorsnfunction toMs (s) {n return Number(s.slice(0, -1).replace(',', '.')) * 1000n}nn/* */nnfunction enter (vnode, toggleDisplay) {n var el = vnode.elm;nn // call leave callback nown if (isDef(el._leaveCb)) {n el._leaveCb.cancelled = true;n el._leaveCb();n }nn var data = resolveTransition(vnode.data.transition);n if (isUndef(data)) {n returnn }nn /* istanbul ignore if */n if (isDef(el._enterCb) || el.nodeType !== 1) {n returnn }nn var css = data.css;n var type = data.type;n var enterClass = data.enterClass;n var enterToClass = data.enterToClass;n var enterActiveClass = data.enterActiveClass;n var appearClass = data.appearClass;n var appearToClass = data.appearToClass;n var appearActiveClass = data.appearActiveClass;n var beforeEnter = data.beforeEnter;n var enter = data.enter;n var afterEnter = data.afterEnter;n var enterCancelled = data.enterCancelled;n var beforeAppear = data.beforeAppear;n var appear = data.appear;n var afterAppear = data.afterAppear;n var appearCancelled = data.appearCancelled;n var duration = data.duration;nn // activeInstance will always be the <transition> component managing thisn // transition. One edge case to check is when the <transition> is placedn // as the root node of a child component. In that case we need to checkn // <transition>'s parent for appear check.n var context = activeInstance;n var transitionNode = activeInstance.$vnode;n while (transitionNode && transitionNode.parent) {n context = transitionNode.context;n transitionNode = transitionNode.parent;n }nn var isAppear = !context._isMounted || !vnode.isRootInsert;nn if (isAppear && !appear && appear !== '') {n returnn }nn var startClass = isAppear && appearClassn ? appearClassn : enterClass;n var activeClass = isAppear && appearActiveClassn ? appearActiveClassn : enterActiveClass;n var toClass = isAppear && appearToClassn ? appearToClassn : enterToClass;nn var beforeEnterHook = isAppearn ? (beforeAppear || beforeEnter)n : beforeEnter;n var enterHook = isAppearn ? (typeof appear === 'function' ? appear : enter)n : enter;n var afterEnterHook = isAppearn ? (afterAppear || afterEnter)n : afterEnter;n var enterCancelledHook = isAppearn ? (appearCancelled || enterCancelled)n : enterCancelled;nn var explicitEnterDuration = toNumber(n isObject(duration)n ? duration.entern : durationn );nn if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {n checkDuration(explicitEnterDuration, 'enter', vnode);n }nn var expectsCSS = css !== false && !isIE9;n var userWantsControl = getHookArgumentsLength(enterHook);nn var cb = el._enterCb = once(function () {n if (expectsCSS) {n removeTransitionClass(el, toClass);n removeTransitionClass(el, activeClass);n }n if (cb.cancelled) {n if (expectsCSS) {n removeTransitionClass(el, startClass);n }n enterCancelledHook && enterCancelledHook(el);n } else {n afterEnterHook && afterEnterHook(el);n }n el._enterCb = null;n });nn if (!vnode.data.show) {n // remove pending leave element on enter by injecting an insert hookn mergeVNodeHook(vnode, 'insert', function () {n var parent = el.parentNode;n var pendingNode = parent && parent._pending && parent._pending;n if (pendingNode &&n pendingNode.tag === vnode.tag &&n pendingNode.elm._leaveCbn ) {n pendingNode.elm._leaveCb();n }n enterHook && enterHook(el, cb);n });n }nn // start enter transitionn beforeEnterHook && beforeEnterHook(el);n if (expectsCSS) {n addTransitionClass(el, startClass);n addTransitionClass(el, activeClass);n nextFrame(function () {n removeTransitionClass(el, startClass);n if (!cb.cancelled) {n addTransitionClass(el, toClass);n if (!userWantsControl) {n if (isValidDuration(explicitEnterDuration)) {n setTimeout(cb, explicitEnterDuration);n } else {n whenTransitionEnds(el, type, cb);n }n }n }n });n }nn if (vnode.data.show) {n toggleDisplay && toggleDisplay();n enterHook && enterHook(el, cb);n }nn if (!expectsCSS && !userWantsControl) {n cb();n }n}nnfunction leave (vnode, rm) {n var el = vnode.elm;nn // call enter callback nown if (isDef(el._enterCb)) {n el._enterCb.cancelled = true;n el._enterCb();n }nn var data = resolveTransition(vnode.data.transition);n if (isUndef(data) || el.nodeType !== 1) {n return rm()n }nn /* istanbul ignore if */n if (isDef(el._leaveCb)) {n returnn }nn var css = data.css;n var type = data.type;n var leaveClass = data.leaveClass;n var leaveToClass = data.leaveToClass;n var leaveActiveClass = data.leaveActiveClass;n var beforeLeave = data.beforeLeave;n var leave = data.leave;n var afterLeave = data.afterLeave;n var leaveCancelled = data.leaveCancelled;n var delayLeave = data.delayLeave;n var duration = data.duration;nn var expectsCSS = css !== false && !isIE9;n var userWantsControl = getHookArgumentsLength(leave);nn var explicitLeaveDuration = toNumber(n isObject(duration)n ? duration.leaven : durationn );nn if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {n checkDuration(explicitLeaveDuration, 'leave', vnode);n }nn var cb = el._leaveCb = once(function () {n if (el.parentNode && el.parentNode._pending) {n el.parentNode._pending = null;n }n if (expectsCSS) {n removeTransitionClass(el, leaveToClass);n removeTransitionClass(el, leaveActiveClass);n }n if (cb.cancelled) {n if (expectsCSS) {n removeTransitionClass(el, leaveClass);n }n leaveCancelled && leaveCancelled(el);n } else {n rm();n afterLeave && afterLeave(el);n }n el._leaveCb = null;n });nn if (delayLeave) {n delayLeave(performLeave);n } else {n performLeave();n }nn function performLeave () {n // the delayed leave may have already been cancelledn if (cb.cancelled) {n returnn }n // record leaving elementn if (!vnode.data.show && el.parentNode) {n (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;n }n beforeLeave && beforeLeave(el);n if (expectsCSS) {n addTransitionClass(el, leaveClass);n addTransitionClass(el, leaveActiveClass);n nextFrame(function () {n removeTransitionClass(el, leaveClass);n if (!cb.cancelled) {n addTransitionClass(el, leaveToClass);n if (!userWantsControl) {n if (isValidDuration(explicitLeaveDuration)) {n setTimeout(cb, explicitLeaveDuration);n } else {n whenTransitionEnds(el, type, cb);n }n }n }n });n }n leave && leave(el, cb);n if (!expectsCSS && !userWantsControl) {n cb();n }n }n}nn// only used in dev modenfunction checkDuration (val, name, vnode) {n if (typeof val !== 'number') {n warn(n "<transition> explicit " + name + " duration is not a valid number - " +n "got " + (JSON.stringify(val)) + ".",n vnode.contextn );n } else if (isNaN(val)) {n warn(n "<transition> explicit " + name + " duration is NaN - " +n 'the duration expression might be incorrect.',n vnode.contextn );n }n}nnfunction isValidDuration (val) {n return typeof val === 'number' && !isNaN(val)n}nn/**n * Normalize a transition hook's argument length. The hook may be:n * - a merged hook (invoker) with the original in .fnsn * - a wrapped component method (check ._length)n * - a plain function (.length)n */nfunction getHookArgumentsLength (fn) {n if (isUndef(fn)) {n return falsen }n var invokerFns = fn.fns;n if (isDef(invokerFns)) {n // invokern return getHookArgumentsLength(n Array.isArray(invokerFns)n ? invokerFnsn : invokerFnsn )n } else {n return (fn._length || fn.length) > 1n }n}nnfunction _enter (_, vnode) {n if (vnode.data.show !== true) {n enter(vnode);n }n}nnvar transition = inBrowser ? {n create: _enter,n activate: _enter,n remove: function remove$$1 (vnode, rm) {n /* istanbul ignore else */n if (vnode.data.show !== true) {n leave(vnode, rm);n } else {n rm();n }n }n} : {};nnvar platformModules = [n attrs,n klass,n events,n domProps,n style,n transitionn];nn/* */nn// the directive module should be applied last, after alln// built-in modules have been applied.nvar modules = platformModules.concat(baseModules);nnvar patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });nn/**n * Not type checking this file because flow doesn't like attachingn * properties to Elements.n */nn/* istanbul ignore if */nif (isIE9) {n // www.matts411.com/post/internet-explorer-9-oninput/n document.addEventListener('selectionchange', function () {n var el = document.activeElement;n if (el && el.vmodel) {n trigger(el, 'input');n }n });n}nnvar directive = {n inserted: function inserted (el, binding, vnode, oldVnode) {n if (vnode.tag === 'select') {n // #6903n if (oldVnode.elm && !oldVnode.elm._vOptions) {n mergeVNodeHook(vnode, 'postpatch', function () {n directive.componentUpdated(el, binding, vnode);n });n } else {n setSelected(el, binding, vnode.context);n }n el._vOptions = [].map.call(el.options, getValue);n } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {n el._vModifiers = binding.modifiers;n if (!binding.modifiers.lazy) {n el.addEventListener('compositionstart', onCompositionStart);n el.addEventListener('compositionend', onCompositionEnd);n // Safari < 10.2 & UIWebView doesn't fire compositionend whenn // switching focus before confirming composition choicen // this also fixes the issue where some browsers e.g. iOS Chromen // fires "change" instead of "input" on autocomplete.n el.addEventListener('change', onCompositionEnd);n /* istanbul ignore if */n if (isIE9) {n el.vmodel = true;n }n }n }n },nn componentUpdated: function componentUpdated (el, binding, vnode) {n if (vnode.tag === 'select') {n setSelected(el, binding, vnode.context);n // in case the options rendered by v-for have changed,n // it's possible that the value is out-of-sync with the rendered options.n // detect such cases and filter out values that no longer has a matchingn // option in the DOM.n var prevOptions = el._vOptions;n var curOptions = el._vOptions = [].map.call(el.options, getValue);n if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions); })) {n // trigger change event ifn // no matching option found for at least one valuen var needReset = el.multiplen ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })n : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);n if (needReset) {n trigger(el, 'change');n }n }n }n }n};nnfunction setSelected (el, binding, vm) {n actuallySetSelected(el, binding, vm);n /* istanbul ignore if */n if (isIE || isEdge) {n setTimeout(function () {n actuallySetSelected(el, binding, vm);n }, 0);n }n}nnfunction actuallySetSelected (el, binding, vm) {n var value = binding.value;n var isMultiple = el.multiple;n if (isMultiple && !Array.isArray(value)) {n process.env.NODE_ENV !== 'production' && warn(n "<select multiple v-model=\"" + (binding.expression) + "\"> " +n "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)),n vmn );n returnn }n var selected, option;n for (var i = 0, l = el.options.length; i < l; i++) {n option = el.options;n if (isMultiple) {n selected = looseIndexOf(value, getValue(option)) > -1;n if (option.selected !== selected) {n option.selected = selected;n }n } else {n if (looseEqual(getValue(option), value)) {n if (el.selectedIndex !== i) {n el.selectedIndex = i;n }n returnn }n }n }n if (!isMultiple) {n el.selectedIndex = -1;n }n}nnfunction hasNoMatchingOption (value, options) {n return options.every(function (o) { return !looseEqual(o, value); })n}nnfunction getValue (option) {n return '_value' in optionn ? option._valuen : option.valuen}nnfunction onCompositionStart (e) {n e.target.composing = true;n}nnfunction onCompositionEnd (e) {n // prevent triggering an input event for no reasonn if (!e.target.composing) { return }n e.target.composing = false;n trigger(e.target, 'input');n}nnfunction trigger (el, type) {n var e = document.createEvent('HTMLEvents');n e.initEvent(type, true, true);n el.dispatchEvent(e);n}nn/* */nn// recursively search for possible transition defined inside the component rootnfunction locateNode (vnode) {n return vnode.componentInstance && (!vnode.data || !vnode.data.transition)n ? locateNode(vnode.componentInstance._vnode)n : vnoden}nnvar show = {n bind: function bind (el, ref, vnode) {n var value = ref.value;nn vnode = locateNode(vnode);n var transition$$1 = vnode.data && vnode.data.transition;n var originalDisplay = el.__vOriginalDisplay =n el.style.display === 'none' ? '' : el.style.display;n if (value && transition$$1) {n vnode.data.show = true;n enter(vnode, function () {n el.style.display = originalDisplay;n });n } else {n el.style.display = value ? originalDisplay : 'none';n }n },nn update: function update (el, ref, vnode) {n var value = ref.value;n var oldValue = ref.oldValue;nn /* istanbul ignore if */n if (!value === !oldValue) { return }n vnode = locateNode(vnode);n var transition$$1 = vnode.data && vnode.data.transition;n if (transition$$1) {n vnode.data.show = true;n if (value) {n enter(vnode, function () {n el.style.display = el.__vOriginalDisplay;n });n } else {n leave(vnode, function () {n el.style.display = 'none';n });n }n } else {n el.style.display = value ? el.__vOriginalDisplay : 'none';n }n },nn unbind: function unbind (n el,n binding,n vnode,n oldVnode,n isDestroyn ) {n if (!isDestroy) {n el.style.display = el.__vOriginalDisplay;n }n }n};nnvar platformDirectives = {n model: directive,n show: shown};nn/* */nnvar transitionProps = {n name: String,n appear: Boolean,n css: Boolean,n mode: String,n type: String,n enterClass: String,n leaveClass: String,n enterToClass: String,n leaveToClass: String,n enterActiveClass: String,n leaveActiveClass: String,n appearClass: String,n appearActiveClass: String,n appearToClass: String,n duration: [Number, String, Object]n};nn// in case the child is also an abstract component, e.g. <keep-alive>n// we want to recursively retrieve the real component to be renderednfunction getRealChild (vnode) {n var compOptions = vnode && vnode.componentOptions;n if (compOptions && compOptions.Ctor.options.abstract) {n return getRealChild(getFirstComponentChild(compOptions.children))n } else {n return vnoden }n}nnfunction extractTransitionData (comp) {n var data = {};n var options = comp.$options;n // propsn for (var key in options.propsData) {n data = comp;n }n // events.n // extract listeners and pass them directly to the transition methodsn var listeners = options._parentListeners;n for (var key$1 in listeners) {n data = listeners;n }n return datan}nnfunction placeholder (h, rawChild) {n if (/\d-keep-alive$/.test(rawChild.tag)) {n return h('keep-alive', {n props: rawChild.componentOptions.propsDatan })n }n}nnfunction hasParentTransition (vnode) {n while ((vnode = vnode.parent)) {n if (vnode.data.transition) {n return truen }n }n}nnfunction isSameChild (child, oldChild) {n return oldChild.key === child.key && oldChild.tag === child.tagn}nnvar isNotTextNode = function © { return c.tag || isAsyncPlaceholder©; };nnvar isVShowDirective = function (d) { return d.name === 'show'; };nnvar Transition = {n name: 'transition',n props: transitionProps,n abstract: true,nn render: function render (h) {n var this$1 = this;nn var children = this.$slots.default;n if (!children) {n returnn }nn // filter out text nodes (possible whitespaces)n children = children.filter(isNotTextNode);n /* istanbul ignore if */n if (!children.length) {n returnn }nn // warn multiple elementsn if (process.env.NODE_ENV !== 'production' && children.length > 1) {n warn(n '<transition> can only be used on a single element. Use ' +n '<transition-group> for lists.',n this.$parentn );n }nn var mode = this.mode;nn // warn invalid moden if (process.env.NODE_ENV !== 'production' &&n mode && mode !== 'in-out' && mode !== 'out-in'n ) {n warn(n 'invalid <transition> mode: ' + mode,n this.$parentn );n }nn var rawChild = children;nn // if this is a component root node and the component'sn // parent container node also has transition, skip.n if (hasParentTransition(this.$vnode)) {n return rawChildn }nn // apply transition data to childn // use getRealChild() to ignore abstract components e.g. keep-aliven var child = getRealChild(rawChild);n /* istanbul ignore if */n if (!child) {n return rawChildn }nn if (this._leaving) {n return placeholder(h, rawChild)n }nn // ensure a key that is unique to the vnode type and to this transitionn // component instance. This key will be used to remove pending leaving nodesn // during entering.n var id = "__transition-" + (this._uid) + "-";n child.key = child.key == nulln ? child.isCommentn ? id + 'comment'n : id + child.tagn : isPrimitive(child.key)n ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)n : child.key;nn var data = (child.data || (child.data = {})).transition = extractTransitionData(this);n var oldRawChild = this._vnode;n var oldChild = getRealChild(oldRawChild);nn // mark v-shown // so that the transition module can hand over the control to the directiven if (child.data.directives && child.data.directives.some(isVShowDirective)) {n child.data.show = true;n }nn if (n oldChild &&n oldChild.data &&n !isSameChild(child, oldChild) &&n !isAsyncPlaceholder(oldChild) &&n // #6687 component root is a comment noden !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)n ) {n // replace old child transition data with fresh onen // important for dynamic transitions!n var oldData = oldChild.data.transition = extend({}, data);n // handle transition moden if (mode === 'out-in') {n // return placeholder node and queue update when leave finishesn this._leaving = true;n mergeVNodeHook(oldData, 'afterLeave', function () {n this$1._leaving = false;n this$1.$forceUpdate();n });n return placeholder(h, rawChild)n } else if (mode === 'in-out') {n if (isAsyncPlaceholder(child)) {n return oldRawChildn }n var delayedLeave;n var performLeave = function () { delayedLeave(); };n mergeVNodeHook(data, 'afterEnter', performLeave);n mergeVNodeHook(data, 'enterCancelled', performLeave);n mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });n }n }nn return rawChildn }n};nn/* */nnvar props = extend({n tag: String,n moveClass: Stringn}, transitionProps);nndelete props.mode;nnvar TransitionGroup = {n props: props,nn beforeMount: function beforeMount () {n var this$1 = this;nn var update = this._update;n this._update = function (vnode, hydrating) {n var restoreActiveInstance = setActiveInstance(this$1);n // force removing passn this$1.__patch__(n this$1._vnode,n this$1.kept,n false, // hydratingn true // removeOnly (!important, avoids unnecessary moves)n );n this$1._vnode = this$1.kept;n restoreActiveInstance();n update.call(this$1, vnode, hydrating);n };n },nn render: function render (h) {n var tag = this.tag || this.$vnode.data.tag || 'span';n var map = Object.create(null);n var prevChildren = this.prevChildren = this.children;n var rawChildren = this.$slots.default || [];n var children = this.children = [];n var transitionData = extractTransitionData(this);nn for (var i = 0; i < rawChildren.length; i++) {n var c = rawChildren;n if (c.tag) {n if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {n children.push©;n map = cn ;(c.data || (c.data = {})).transition = transitionData;n } else if (process.env.NODE_ENV !== 'production') {n var opts = c.componentOptions;n var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;n warn(("<transition-group> children must be keyed: <" + name + ">"));n }n }n }nn if (prevChildren) {n var kept = [];n var removed = [];n for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {n var c$1 = prevChildren;n c$1.data.transition = transitionData;n c$1.data.pos = c$1.elm.getBoundingClientRect();n if (map) {n kept.push(c$1);n } else {n removed.push(c$1);n }n }n this.kept = h(tag, null, kept);n this.removed = removed;n }nn return h(tag, null, children)n },nn updated: function updated () {n var children = this.prevChildren;n var moveClass = this.moveClass || ((this.name || 'v') + '-move');n if (!children.length || !this.hasMove(children.elm, moveClass)) {n returnn }nn // we divide the work into three loops to avoid mixing DOM reads and writesn // in each iteration - which helps prevent layout thrashing.n children.forEach(callPendingCbs);n children.forEach(recordPosition);n children.forEach(applyTranslation);nn // force reflow to put everything in positionn // assign to this to avoid being removed in tree-shakingn // $flow-disable-linen this._reflow = document.body.offsetHeight;nn children.forEach(function © {n if (c.data.moved) {n var el = c.elm;n var s = el.style;n addTransitionClass(el, moveClass);n s.transform = s.WebkitTransform = s.transitionDuration = '';n el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {n if (e && e.target !== el) {n returnn }n if (!e || /transform$/.test(e.propertyName)) {n el.removeEventListener(transitionEndEvent, cb);n el._moveCb = null;n removeTransitionClass(el, moveClass);n }n });n }n });n },nn methods: {n hasMove: function hasMove (el, moveClass) {n /* istanbul ignore if */n if (!hasTransition) {n return falsen }n /* istanbul ignore if */n if (this._hasMove) {n return this._hasMoven }n // Detect whether an element with the move class applied hasn // CSS transitions. Since the element may be inside an enteringn // transition at this very moment, we make a clone of it and removen // all other transition classes applied to ensure only the move classn // is applied.n var clone = el.cloneNode();n if (el._transitionClasses) {n el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); });n }n addClass(clone, moveClass);n clone.style.display = 'none';n this.$el.appendChild(clone);n var info = getTransitionInfo(clone);n this.$el.removeChild(clone);n return (this._hasMove = info.hasTransform)n }n }n};nnfunction callPendingCbs © {n /* istanbul ignore if */n if (c.elm._moveCb) {n c.elm._moveCb();n }n /* istanbul ignore if */n if (c.elm._enterCb) {n c.elm._enterCb();n }n}nnfunction recordPosition © {n c.data.newPos = c.elm.getBoundingClientRect();n}nnfunction applyTranslation © {n var oldPos = c.data.pos;n var newPos = c.data.newPos;n var dx = oldPos.left - newPos.left;n var dy = oldPos.top - newPos.top;n if (dx || dy) {n c.data.moved = true;n var s = c.elm.style;n s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";n s.transitionDuration = '0s';n }n}nnvar platformComponents = {n Transition: Transition,n TransitionGroup: TransitionGroupn};nn/* */nn// install platform specific utilsnVue.config.mustUseProp = mustUseProp;nVue.config.isReservedTag = isReservedTag;nVue.config.isReservedAttr = isReservedAttr;nVue.config.getTagNamespace = getTagNamespace;nVue.config.isUnknownElement = isUnknownElement;nn// install platform runtime directives & componentsnextend(Vue.options.directives, platformDirectives);nextend(Vue.options.components, platformComponents);nn// install platform patch functionnVue.prototype.__patch__ = inBrowser ? patch : noop;nn// public mount methodnVue.prototype.$mount = function (n el,n hydratingn) {n el = el && inBrowser ? query(el) : undefined;n return mountComponent(this, el, hydrating)n};nn// devtools global hookn/* istanbul ignore next */nif (inBrowser) {n setTimeout(function () {n if (config.devtools) {n if (devtools) {n devtools.emit('init', Vue);n } else if (n process.env.NODE_ENV !== 'production' &&n process.env.NODE_ENV !== 'test'n ) {n console[console.info ? 'info' : 'log'](n 'Download the Vue Devtools extension for a better development experience:\n' +n 'github.com/vuejs/vue-devtools’n );n }n }n if (process.env.NODE_ENV !== 'production' &&n process.env.NODE_ENV !== 'test' &&n config.productionTip !== false &&n typeof console !== 'undefined'n ) {n console[console.info ? 'info' : 'log'](n "You are running Vue in development mode.\n" +n "Make sure to turn on production mode when deploying for production.\n" +n "See more tips at vuejs.org/guide/deployment.html"n );n }n }, 0);n}nn/* */nnexport default Vue;n”,“/*!n * vue-router v3.3.4n * © 2020 Evan Youn * @license MITn */n/* */nnfunction assert (condition, message) {n if (!condition) {n throw new Error((" " + message))n }n}nnfunction warn (condition, message) {n if (process.env.NODE_ENV !== 'production' && !condition) {n typeof console !== 'undefined' && console.warn((" " + message));n }n}nnfunction isError (err) {n return Object.prototype.toString.call(err).indexOf('Error') > -1n}nnfunction isRouterError (err, errorType) {n return isError(err) && err._isRouter && (errorType == null || err.type === errorType)n}nnfunction extend (a, b) {n for (var key in b) {n a = b;n }n return an}nnvar View = {n name: 'RouterView',n functional: true,n props: {n name: {n type: String,n default: 'default'n }n },n render: function render (_, ref) {n var props = ref.props;n var children = ref.children;n var parent = ref.parent;n var data = ref.data;nn // used by devtools to display a router-view badgen data.routerView = true;nn // directly use parent context's createElement() functionn // so that components rendered by router-view can resolve named slotsn var h = parent.$createElement;n var name = props.name;n var route = parent.$route;n var cache = parent._routerViewCache || (parent._routerViewCache = {});nn // determine current view depth, also check to see if the treen // has been toggled inactive but kept-alive.n var depth = 0;n var inactive = false;n while (parent && parent._routerRoot !== parent) {n var vnodeData = parent.$vnode ? parent.$vnode.data : {};n if (vnodeData.routerView) {n depth++;n }n if (vnodeData.keepAlive && parent._directInactive && parent._inactive) {n inactive = true;n }n parent = parent.$parent;n }n data.routerViewDepth = depth;nn // render previous view if the tree is inactive and kept-aliven if (inactive) {n var cachedData = cache;n var cachedComponent = cachedData && cachedData.component;n if (cachedComponent) {n // #2301n // pass propsn if (cachedData.configProps) {n fillPropsinData(cachedComponent, data, cachedData.route, cachedData.configProps);n }n return h(cachedComponent, data, children)n } else {n // render previous empty viewn return h()n }n }nn var matched = route.matched;n var component = matched && matched.components;nn // render empty node if no matched route or no config componentn if (!matched || !component) {n cache = null;n return h()n }nn // cache componentn cache = { component: component };nn // attach instance registration hookn // this will be called in the instance's injected lifecycle hooksn data.registerRouteInstance = function (vm, val) {n // val could be undefined for unregistrationn var current = matched.instances;n if (n (val && current !== vm) ||n (!val && current === vm)n ) {n matched.instances = val;n }n }nn // also register instance in prepatch hookn // in case the same component instance is reused across different routesn ;(data.hook || (data.hook = {})).prepatch = function (_, vnode) {n matched.instances = vnode.componentInstance;n };nn // register instance in init hookn // in case kept-alive component be actived when routes changedn data.hook.init = function (vnode) {n if (vnode.data.keepAlive &&n vnode.componentInstance &&n vnode.componentInstance !== matched.instancesn ) {n matched.instances = vnode.componentInstance;n }n };nn var configProps = matched.props && matched.props;n // save route and configProps in cachcen if (configProps) {n extend(cache, {n route: route,n configProps: configPropsn });n fillPropsinData(component, data, route, configProps);n }nn return h(component, data, children)n }n};nnfunction fillPropsinData (component, data, route, configProps) {n // resolve propsn var propsToPass = data.props = resolveProps(route, configProps);n if (propsToPass) {n // clone to prevent mutationn propsToPass = data.props = extend({}, propsToPass);n // pass non-declared props as attrsn var attrs = data.attrs = data.attrs || {};n for (var key in propsToPass) {n if (!component.props || !(key in component.props)) {n attrs = propsToPass;n delete propsToPass;n }n }n }n}nnfunction resolveProps (route, config) {n switch (typeof config) {n case 'undefined':n returnn case 'object':n return confign case 'function':n return config(route)n case 'boolean':n return config ? route.params : undefinedn default:n if (process.env.NODE_ENV !== 'production') {n warn(n false,n "props in \"" + (route.path) + "\" is a " + (typeof config) + ", " +n "expecting an object, function or boolean."n );n }n }n}nn/* */nnvar encodeReserveRE = /[!'()*]/g;nvar encodeReserveReplacer = function © { return '%' + c.charCodeAt(0).toString(16); };nvar commaRE = /%2C/g;nn// fixed encodeURIComponent which is more conformant to RFC3986:n// - escapes [!'()*]n// - preserve commasnvar encode = function (str) { return encodeURIComponent(str)n .replace(encodeReserveRE, encodeReserveReplacer)n .replace(commaRE, ','); };nnvar decode = decodeURIComponent;nnfunction resolveQuery (n query,n extraQuery,n _parseQueryn) {n if ( extraQuery === void 0 ) extraQuery = {};nn var parse = _parseQuery || parseQuery;n var parsedQuery;n try {n parsedQuery = parse(query || '');n } catch (e) {n process.env.NODE_ENV !== 'production' && warn(false, e.message);n parsedQuery = {};n }n for (var key in extraQuery) {n parsedQuery = extraQuery;n }n return parsedQueryn}nnfunction parseQuery (query) {n var res = {};nn query = query.trim().replace(/^(\?|#|&)/, '');nn if (!query) {n return resn }nn query.split('&').forEach(function (param) {n var parts = param.replace(/+/g, ' ').split('=');n var key = decode(parts.shift());n var val = parts.length > 0n ? decode(parts.join('='))n : null;nn if (res === undefined) {n res = val;n } else if (Array.isArray(res)) {n res.push(val);n } else {n res = [res, val];n }n });nn return resn}nnfunction stringifyQuery (obj) {n var res = obj ? Object.keys(obj).map(function (key) {n var val = obj;nn if (val === undefined) {n return ''n }nn if (val === null) {n return encode(key)n }nn if (Array.isArray(val)) {n var result = [];n val.forEach(function (val2) {n if (val2 === undefined) {n returnn }n if (val2 === null) {n result.push(encode(key));n } else {n result.push(encode(key) + '=' + encode(val2));n }n });n return result.join('&')n }nn return encode(key) + '=' + encode(val)n }).filter(function (x) { return x.length > 0; }).join('&') : null;n return res ? ("?" + res) : ''n}nn/* */nnvar trailingSlashRE = /\/?$/;nnfunction createRoute (n record,n location,n redirectedFrom,n routern) {n var stringifyQuery = router && router.options.stringifyQuery;nn var query = location.query || {};n try {n query = clone(query);n } catch (e) {}nn var route = {n name: location.name || (record && record.name),n meta: (record && record.meta) || {},n path: location.path || '/',n hash: location.hash || '',n query: query,n params: location.params || {},n fullPath: getFullPath(location, stringifyQuery),n matched: record ? formatMatch(record) : []n };n if (redirectedFrom) {n route.redirectedFrom = getFullPath(redirectedFrom, stringifyQuery);n }n return Object.freeze(route)n}nnfunction clone (value) {n if (Array.isArray(value)) {n return value.map(clone)n } else if (value && typeof value === 'object') {n var res = {};n for (var key in value) {n res = clone(value);n }n return resn } else {n return valuen }n}nn// the starting route that represents the initial statenvar START = createRoute(null, {n path: '/'n});nnfunction formatMatch (record) {n var res = [];n while (record) {n res.unshift(record);n record = record.parent;n }n return resn}nnfunction getFullPath (n ref,n _stringifyQueryn) {n var path = ref.path;n var query = ref.query; if ( query === void 0 ) query = {};n var hash = ref.hash; if ( hash === void 0 ) hash = '';nn var stringify = _stringifyQuery || stringifyQuery;n return (path || '/') + stringify(query) + hashn}nnfunction isSameRoute (a, b) {n if (b === START) {n return a === bn } else if (!b) {n return falsen } else if (a.path && b.path) {n return (n a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') &&n a.hash === b.hash &&n isObjectEqual(a.query, b.query)n )n } else if (a.name && b.name) {n return (n a.name === b.name &&n a.hash === b.hash &&n isObjectEqual(a.query, b.query) &&n isObjectEqual(a.params, b.params)n )n } else {n return falsen }n}nnfunction isObjectEqual (a, b) {n if ( a === void 0 ) a = {};n if ( b === void 0 ) b = {};nn // handle null value #1566n if (!a || !b) { return a === b }n var aKeys = Object.keys(a);n var bKeys = Object.keys(b);n if (aKeys.length !== bKeys.length) {n return falsen }n return aKeys.every(function (key) {n var aVal = a;n var bVal = b;n // check nested equalityn if (typeof aVal === 'object' && typeof bVal === 'object') {n return isObjectEqual(aVal, bVal)n }n return String(aVal) === String(bVal)n })n}nnfunction isIncludedRoute (current, target) {n return (n current.path.replace(trailingSlashRE, '/').indexOf(n target.path.replace(trailingSlashRE, '/')n ) === 0 &&n (!target.hash || current.hash === target.hash) &&n queryIncludes(current.query, target.query)n )n}nnfunction queryIncludes (current, target) {n for (var key in target) {n if (!(key in current)) {n return falsen }n }n return truen}nn/* */nnfunction resolvePath (n relative,n base,n appendn) {n var firstChar = relative.charAt(0);n if (firstChar === '/') {n return relativen }nn if (firstChar === '?' || firstChar === '#') {n return base + relativen }nn var stack = base.split('/');nn // remove trailing segment if:n // - not appendingn // - appending to trailing slash (last segment is empty)n if (!append || !stack[stack.length - 1]) {n stack.pop();n }nn // resolve relative pathn var segments = relative.replace(/^\//, '').split('/');n for (var i = 0; i < segments.length; i++) {n var segment = segments;n if (segment === '..') {n stack.pop();n } else if (segment !== '.') {n stack.push(segment);n }n }nn // ensure leading slashn if (stack !== '') {n stack.unshift('');n }nn return stack.join('/')n}nnfunction parsePath (path) {n var hash = '';n var query = '';nn var hashIndex = path.indexOf('#');n if (hashIndex >= 0) {n hash = path.slice(hashIndex);n path = path.slice(0, hashIndex);n }nn var queryIndex = path.indexOf('?');n if (queryIndex >= 0) {n query = path.slice(queryIndex + 1);n path = path.slice(0, queryIndex);n }nn return {n path: path,n query: query,n hash: hashn }n}nnfunction cleanPath (path) {n return path.replace(/\/\//g, '/')n}nnvar isarray = Array.isArray || function (arr) {n return Object.prototype.toString.call(arr) == '[object Array]';n};nn/**n * Expose `pathToRegexp`.n */nvar pathToRegexp_1 = pathToRegexp;nvar parse_1 = parse;nvar compile_1 = compile;nvar tokensToFunction_1 = tokensToFunction;nvar tokensToRegExp_1 = tokensToRegExp;nn/**n * The main path matching regexp utility.n *n * @type {RegExp}n */nvar PATH_REGEXP = new RegExp([n // Match escaped characters that would otherwise appear in future matches.n // This allows the user to escape special characters that won't transform.n '(\\\\.)',n // Match Express-style parameters and un-named parameters with a prefixn // and optional suffixes. Matches appear as:n //n // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]n // "/route(\\d+)" => [undefined, undefined, undefined, "\d+", undefined, undefined]n // "/*" => ["/", undefined, undefined, undefined, undefined, "*"]n '([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|)+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\*))'n].join('|'), 'g');nn/**n * Parse a string for the raw tokens.n *n * @param {string} strn * @param {Object=} optionsn * @return {!Array}n */nfunction parse (str, options) {n var tokens = [];n var key = 0;n var index = 0;n var path = '';n var defaultDelimiter = options && options.delimiter || '/';n var res;nn while ((res = PATH_REGEXP.exec(str)) != null) {n var m = res;n var escaped = res;n var offset = res.index;n path += str.slice(index, offset);n index = offset + m.length;nn // Ignore already escaped sequences.n if (escaped) {n path += escaped;n continuen }nn var next = str;n var prefix = res;n var name = res;n var capture = res;n var group = res;n var modifier = res;n var asterisk = res;nn // Push the current path onto the tokens.n if (path) {n tokens.push(path);n path = '';n }nn var partial = prefix != null && next != null && next !== prefix;n var repeat = modifier === '+' || modifier === '*';n var optional = modifier === '?' || modifier === '*';n var delimiter = res || defaultDelimiter;n var pattern = capture || group;nn tokens.push({n name: name || key++,n prefix: prefix || '',n delimiter: delimiter,n optional: optional,n repeat: repeat,n partial: partial,n asterisk: !!asterisk,n pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')n });n }nn // Match any characters still remaining.n if (index < str.length) {n path += str.substr(index);n }nn // If the path exists, push it onto the end.n if (path) {n tokens.push(path);n }nn return tokensn}nn/**n * Compile a string to a template function for the path.n *n * @param {string} strn * @param {Object=} optionsn * @return {!function(Object=, Object=)}n */nfunction compile (str, options) {n return tokensToFunction(parse(str, options), options)n}nn/**n * Prettier encoding of URI path segments.n *n * @param {string}n * @return {string}n */nfunction encodeURIComponentPretty (str) {n return encodeURI(str).replace(//g, function © {n return '%' + c.charCodeAt(0).toString(16).toUpperCase()n })n}nn/**n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.n *n * @param {string}n * @return {string}n */nfunction encodeAsterisk (str) {n return encodeURI(str).replace(//g, function © {n return '%' + c.charCodeAt(0).toString(16).toUpperCase()n })n}nn/**n * Expose a method for transforming tokens into the path function.n */nfunction tokensToFunction (tokens, options) {n // Compile all the tokens into regexps.n var matches = new Array(tokens.length);nn // Compile all the patterns before compilation.n for (var i = 0; i < tokens.length; i++) {n if (typeof tokens === 'object') {n matches = new RegExp('^(?:' + tokens.pattern + ')$', flags(options));n }n }nn return function (obj, opts) {n var path = '';n var data = obj || {};n var options = opts || {};n var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;nn for (var i = 0; i < tokens.length; i++) {n var token = tokens;nn if (typeof token === 'string') {n path += token;nn continuen }nn var value = data;n var segment;nn if (value == null) {n if (token.optional) {n // Prepend partial segment prefixes.n if (token.partial) {n path += token.prefix;n }nn continuen } else {n throw new TypeError('Expected "' + token.name + '" to be defined')n }n }nn if (isarray(value)) {n if (!token.repeat) {n throw new TypeError('Expected "' + token.name + '" to not repeat, but received `' + JSON.stringify(value) + '`')n }nn if (value.length === 0) {n if (token.optional) {n continuen } else {n throw new TypeError('Expected "' + token.name + '" to not be empty')n }n }nn for (var j = 0; j < value.length; j++) {n segment = encode(value);nn if (!matches.test(segment)) {n throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + JSON.stringify(segment) + '`')n }nn path += (j === 0 ? token.prefix : token.delimiter) + segment;n }nn continuen }nn segment = token.asterisk ? encodeAsterisk(value) : encode(value);nn if (!matches.test(segment)) {n throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"')n }nn path += token.prefix + segment;n }nn return pathn }n}nn/**n * Escape a regular expression string.n *n * @param {string} strn * @return {string}n */nfunction escapeString (str) {n return str.replace(/([.+*?=^!:${}()|\/\\])/g, '\\$1')n}nn/**n * Escape the capturing group by escaping special characters and meaning.n *n * @param {string} groupn * @return {string}n */nfunction escapeGroup (group) {n return group.replace(/()/g, '\\$1')n}nn/**n * Attach the keys as a property of the regexp.n *n * @param {!RegExp} ren * @param {Array} keysn * @return {!RegExp}n */nfunction attachKeys (re, keys) {n re.keys = keys;n return ren}nn/**n * Get the flags for a regexp from the options.n *n * @param {Object} optionsn * @return {string}n */nfunction flags (options) {n return options && options.sensitive ? '' : 'i'n}nn/**n * Pull out keys from a regexp.n *n * @param {!RegExp} pathn * @param {!Array} keysn * @return {!RegExp}n */nfunction regexpToRegexp (path, keys) {n // Use a negative lookahead to match only capturing groups.n var groups = path.source.match(/\((?!\?)/g);nn if (groups) {n for (var i = 0; i < groups.length; i++) {n keys.push({n name: i,n prefix: null,n delimiter: null,n optional: false,n repeat: false,n partial: false,n asterisk: false,n pattern: nulln });n }n }nn return attachKeys(path, keys)n}nn/**n * Transform an array into a regexp.n *n * @param {!Array} pathn * @param {Array} keysn * @param {!Object} optionsn * @return {!RegExp}n */nfunction arrayToRegexp (path, keys, options) {n var parts = [];nn for (var i = 0; i < path.length; i++) {n parts.push(pathToRegexp(path, keys, options).source);n }nn var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));nn return attachKeys(regexp, keys)n}nn/**n * Create a path regexp from string input.n *n * @param {string} pathn * @param {!Array} keysn * @param {!Object} optionsn * @return {!RegExp}n */nfunction stringToRegexp (path, keys, options) {n return tokensToRegExp(parse(path, options), keys, options)n}nn/**n * Expose a function for taking tokens and returning a RegExp.n *n * @param {!Array} tokensn * @param {(Array|Object)=} keysn * @param {Object=} optionsn * @return {!RegExp}n */nfunction tokensToRegExp (tokens, keys, options) {n if (!isarray(keys)) {n options = /** @type {!Object} */ (keys || options);n keys = [];n }nn options = options || {};nn var strict = options.strict;n var end = options.end !== false;n var route = '';nn // Iterate over the tokens and create our regexp string.n for (var i = 0; i < tokens.length; i++) {n var token = tokens;nn if (typeof token === 'string') {n route += escapeString(token);n } else {n var prefix = escapeString(token.prefix);n var capture = '(?:' + token.pattern + ')';nn keys.push(token);nn if (token.repeat) {n capture += '(?:' + prefix + capture + ')*';n }nn if (token.optional) {n if (!token.partial) {n capture = '(?:' + prefix + '(' + capture + '))?';n } else {n capture = prefix + '(' + capture + ')?';n }n } else {n capture = prefix + '(' + capture + ')';n }nn route += capture;n }n }nn var delimiter = escapeString(options.delimiter || '/');n var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;nn // In non-strict mode we allow a slash at the end of match. If the path ton // match already ends with a slash, we remove it for consistency. The slashn // is valid at the end of a path match, not in the middle. This is importantn // in non-ending mode, where "/test/" shouldn't match "/test//route".n if (!strict) {n route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';n }nn if (end) {n route += '$';n } else {n // In non-ending mode, we need the capturing groups to match as much asn // possible by using a positive lookahead to the end or next path segment.n route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';n }nn return attachKeys(new RegExp('^' + route, flags(options)), keys)n}nn/**n * Normalize the given path string, returning a regular expression.n *n * An empty array can be passed in for the keys, which will hold then * placeholder key descriptions. For example, using `/user/:id`, `keys` willn * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.n *n * @param {(string|RegExp|Array)} pathn * @param {(Array|Object)=} keysn * @param {Object=} optionsn * @return {!RegExp}n */nfunction pathToRegexp (path, keys, options) {n if (!isarray(keys)) {n options = /** @type {!Object} */ (keys || options);n keys = [];n }nn options = options || {};nn if (path instanceof RegExp) {n return regexpToRegexp(path, /** @type {!Array} */ (keys))n }nn if (isarray(path)) {n return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)n }nn return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)n}npathToRegexp_1.parse = parse_1;npathToRegexp_1.compile = compile_1;npathToRegexp_1.tokensToFunction = tokensToFunction_1;npathToRegexp_1.tokensToRegExp = tokensToRegExp_1;nn/* */nn// $flow-disable-linenvar regexpCompileCache = Object.create(null);nnfunction fillParams (n path,n params,n routeMsgn) {n params = params || {};n try {n var filler =n regexpCompileCache ||n (regexpCompileCache = pathToRegexp_1.compile(path));nn // Fix #2505 resolving asterisk routes { name: 'not-found', params: { pathMatch: '/not-found' }}n // and fix #3106 so that you can work with location descriptor object having params.pathMatch equal to empty stringn if (typeof params.pathMatch === 'string') { params = params.pathMatch; }nn return filler(params, { pretty: true })n } catch (e) {n if (process.env.NODE_ENV !== 'production') {n // Fix #3072 no warn if `pathMatch` is stringn warn(typeof params.pathMatch === 'string', ("missing param for " + routeMsg + ": " + (e.message)));n }n return ''n } finally {n // delete the 0 if it was addedn delete params;n }n}nn/* */nnfunction normalizeLocation (n raw,n current,n append,n routern) {n var next = typeof raw === 'string' ? { path: raw } : raw;n // named targetn if (next._normalized) {n return nextn } else if (next.name) {n next = extend({}, raw);n var params = next.params;n if (params && typeof params === 'object') {n next.params = extend({}, params);n }n return nextn }nn // relative paramsn if (!next.path && next.params && current) {n next = extend({}, next);n next._normalized = true;n var params$1 = extend(extend({}, current.params), next.params);n if (current.name) {n next.name = current.name;n next.params = params$1;n } else if (current.matched.length) {n var rawPath = current.matched[current.matched.length - 1].path;n next.path = fillParams(rawPath, params$1, ("path " + (current.path)));n } else if (process.env.NODE_ENV !== 'production') {n warn(false, "relative params navigation requires a current route.");n }n return nextn }nn var parsedPath = parsePath(next.path || '');n var basePath = (current && current.path) || '/';n var path = parsedPath.pathn ? resolvePath(parsedPath.path, basePath, append || next.append)n : basePath;nn var query = resolveQuery(n parsedPath.query,n next.query,n router && router.options.parseQueryn );nn var hash = next.hash || parsedPath.hash;n if (hash && hash.charAt(0) !== '#') {n hash = "#" + hash;n }nn return {n _normalized: true,n path: path,n query: query,n hash: hashn }n}nn/* */nn// work around weird flow bugnvar toTypes = [String, Object];nvar eventTypes = [String, Array];nnvar noop = function () {};nnvar Link = {n name: 'RouterLink',n props: {n to: {n type: toTypes,n required: truen },n tag: {n type: String,n default: 'a'n },n exact: Boolean,n append: Boolean,n replace: Boolean,n activeClass: String,n exactActiveClass: String,n ariaCurrentValue: {n type: String,n default: 'page'n },n event: {n type: eventTypes,n default: 'click'n }n },n render: function render (h) {n var this$1 = this;nn var router = this.$router;n var current = this.$route;n var ref = router.resolve(n this.to,n current,n this.appendn );n var location = ref.location;n var route = ref.route;n var href = ref.href;nn var classes = {};n var globalActiveClass = router.options.linkActiveClass;n var globalExactActiveClass = router.options.linkExactActiveClass;n // Support global empty active classn var activeClassFallback =n globalActiveClass == null ? 'router-link-active' : globalActiveClass;n var exactActiveClassFallback =n globalExactActiveClass == nulln ? 'router-link-exact-active'n : globalExactActiveClass;n var activeClass =n this.activeClass == null ? activeClassFallback : this.activeClass;n var exactActiveClass =n this.exactActiveClass == nulln ? exactActiveClassFallbackn : this.exactActiveClass;nn var compareTarget = route.redirectedFromn ? createRoute(null, normalizeLocation(route.redirectedFrom), null, router)n : route;nn classes = isSameRoute(current, compareTarget);n classes = this.exactn ? classesn : isIncludedRoute(current, compareTarget);nn var ariaCurrentValue = classes ? this.ariaCurrentValue : null;nn var handler = function (e) {n if (guardEvent(e)) {n if (this$1.replace) {n router.replace(location, noop);n } else {n router.push(location, noop);n }n }n };nn var on = { click: guardEvent };n if (Array.isArray(this.event)) {n this.event.forEach(function (e) {n on = handler;n });n } else {n on = handler;n }nn var data = { class: classes };nn var scopedSlot =n !this.$scopedSlots.$hasNormal &&n this.$scopedSlots.default &&n this.$scopedSlots.default({n href: href,n route: route,n navigate: handler,n isActive: classes,n isExactActive: classesn });nn if (scopedSlot) {n if (scopedSlot.length === 1) {n return scopedSlotn } else if (scopedSlot.length > 1 || !scopedSlot.length) {n if (process.env.NODE_ENV !== 'production') {n warn(n false,n ("RouterLink with to=\"" + (this.to) + "\" is trying to use a scoped slot but it didn't provide exactly one child. Wrapping the content with a span element.")n );n }n return scopedSlot.length === 0 ? h() : h('span', {}, scopedSlot)n }n }nn if (this.tag === 'a') {n data.on = on;n data.attrs = { href: href, 'aria-current': ariaCurrentValue };n } else {n // find the first <a> child and apply listener and hrefn var a = findAnchor(this.$slots.default);n if (a) {n // in case the <a> is a static noden a.isStatic = false;n var aData = (a.data = extend({}, a.data));n aData.on = aData.on || {};n // transform existing events in both objects into arrays so we can push latern for (var event in aData.on) {n var handler$1 = aData.on;n if (event in on) {n aData.on = Array.isArray(handler$1) ? handler$1 : [handler$1];n }n }n // append new listeners for router-linkn for (var event$1 in on) {n if (event$1 in aData.on) {n // on is always a functionn aData.on.push(on);n } else {n aData.on = handler;n }n }nn var aAttrs = (a.data.attrs = extend({}, a.data.attrs));n aAttrs.href = href;n aAttrs = ariaCurrentValue;n } else {n // doesn't have <a> child, apply listener to selfn data.on = on;n }n }nn return h(this.tag, data, this.$slots.default)n }n};nnfunction guardEvent (e) {n // don't redirect with control keysn if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) { return }n // don't redirect when preventDefault calledn if (e.defaultPrevented) { return }n // don't redirect on right clickn if (e.button !== undefined && e.button !== 0) { return }n // don't redirect if `target="_blank"`n if (e.currentTarget && e.currentTarget.getAttribute) {n var target = e.currentTarget.getAttribute('target');n if (/\b_blank\b/i.test(target)) { return }n }n // this may be a Weex event which doesn't have this methodn if (e.preventDefault) {n e.preventDefault();n }n return truen}nnfunction findAnchor (children) {n if (children) {n var child;n for (var i = 0; i < children.length; i++) {n child = children;n if (child.tag === 'a') {n return childn }n if (child.children && (child = findAnchor(child.children))) {n return childn }n }n }n}nnvar _Vue;nnfunction install (Vue) {n if (install.installed && _Vue === Vue) { return }n install.installed = true;nn _Vue = Vue;nn var isDef = function (v) { return v !== undefined; };nn var registerInstance = function (vm, callVal) {n var i = vm.$options._parentVnode;n if (isDef(i) && isDef(i = i.data) && isDef(i = i.registerRouteInstance)) {n i(vm, callVal);n }n };nn Vue.mixin({n beforeCreate: function beforeCreate () {n if (isDef(this.$options.router)) {n this._routerRoot = this;n this._router = this.$options.router;n this._router.init(this);n Vue.util.defineReactive(this, '_route', this._router.history.current);n } else {n this._routerRoot = (this.$parent && this.$parent._routerRoot) || this;n }n registerInstance(this, this);n },n destroyed: function destroyed () {n registerInstance(this);n }n });nn Object.defineProperty(Vue.prototype, '$router', {n get: function get () { return this._routerRoot._router }n });nn Object.defineProperty(Vue.prototype, '$route', {n get: function get () { return this._routerRoot._route }n });nn Vue.component('RouterView', View);n Vue.component('RouterLink', Link);nn var strats = Vue.config.optionMergeStrategies;n // use the same hook merging strategy for route hooksn strats.beforeRouteEnter = strats.beforeRouteLeave = strats.beforeRouteUpdate = strats.created;n}nn/* */nnvar inBrowser = typeof window !== 'undefined';nn/* */nnfunction createRouteMap (n routes,n oldPathList,n oldPathMap,n oldNameMapn) {n // the path list is used to control path matching priorityn var pathList = oldPathList || [];n // $flow-disable-linen var pathMap = oldPathMap || Object.create(null);n // $flow-disable-linen var nameMap = oldNameMap || Object.create(null);nn routes.forEach(function (route) {n addRouteRecord(pathList, pathMap, nameMap, route);n });nn // ensure wildcard routes are always at the endn for (var i = 0, l = pathList.length; i < l; i++) {n if (pathList === '*') {n pathList.push(pathList.splice(i, 1));n l–;n i–;n }n }nn if (process.env.NODE_ENV === 'development') {n // warn if routes do not include leading slashesn var found = pathListn // check for missing leading slashn .filter(function (path) { return path && path.charAt(0) !== '*' && path.charAt(0) !== '/'; });nn if (found.length > 0) {n var pathNames = found.map(function (path) { return ("- " + path); }).join('\n');n warn(false, ("Non-nested routes must include a leading slash character. Fix the following routes: \n" + pathNames));n }n }nn return {n pathList: pathList,n pathMap: pathMap,n nameMap: nameMapn }n}nnfunction addRouteRecord (n pathList,n pathMap,n nameMap,n route,n parent,n matchAsn) {n var path = route.path;n var name = route.name;n if (process.env.NODE_ENV !== 'production') {n assert(path != null, "\"path\" is required in a route configuration.");n assert(n typeof route.component !== 'string',n "route config \"component\" for path: " + (String(n path || namen )) + " cannot be a " + "string id. Use an actual component instead."n );n }nn var pathToRegexpOptions =n route.pathToRegexpOptions || {};n var normalizedPath = normalizePath(path, parent, pathToRegexpOptions.strict);nn if (typeof route.caseSensitive === 'boolean') {n pathToRegexpOptions.sensitive = route.caseSensitive;n }nn var record = {n path: normalizedPath,n regex: compileRouteRegex(normalizedPath, pathToRegexpOptions),n components: route.components || { default: route.component },n instances: {},n name: name,n parent: parent,n matchAs: matchAs,n redirect: route.redirect,n beforeEnter: route.beforeEnter,n meta: route.meta || {},n props:n route.props == nulln ? {}n : route.componentsn ? route.propsn : { default: route.props }n };nn if (route.children) {n // Warn if route is named, does not redirect and has a default child route.n // If users navigate to this route by name, the default child willn // not be rendered (GH Issue #629)n if (process.env.NODE_ENV !== 'production') {n if (n route.name &&n !route.redirect &&n route.children.some(function (child) { return /^\/?$/.test(child.path); })n ) {n warn(n false,n "Named Route '" + (route.name) + "' has a default child route. " +n "When navigating to this named route (:to=\"{name: '" + (route.name) + "'\"), " +n "the default child route will not be rendered. Remove the name from " +n "this route and use the name of the default child route for named " +n "links instead."n );n }n }n route.children.forEach(function (child) {n var childMatchAs = matchAsn ? cleanPath((matchAs + "/" + (child.path)))n : undefined;n addRouteRecord(pathList, pathMap, nameMap, child, record, childMatchAs);n });n }nn if (!pathMap) {n pathList.push(record.path);n pathMap = record;n }nn if (route.alias !== undefined) {n var aliases = Array.isArray(route.alias) ? route.alias : [route.alias];n for (var i = 0; i < aliases.length; ++i) {n var alias = aliases;n if (process.env.NODE_ENV !== 'production' && alias === path) {n warn(n false,n ("Found an alias with the same value as the path: \"" + path + "\". You have to remove that alias. It will be ignored in development.")n );n // skip in dev to make it workn continuen }nn var aliasRoute = {n path: alias,n children: route.childrenn };n addRouteRecord(n pathList,n pathMap,n nameMap,n aliasRoute,n parent,n record.path || '/' // matchAsn );n }n }nn if (name) {n if (!nameMap) {n nameMap = record;n } else if (process.env.NODE_ENV !== 'production' && !matchAs) {n warn(n false,n "Duplicate named routes definition: " +n "{ name: \"" + name + "\", path: \"" + (record.path) + "\" }"n );n }n }n}nnfunction compileRouteRegex (n path,n pathToRegexpOptionsn) {n var regex = pathToRegexp_1(path, [], pathToRegexpOptions);n if (process.env.NODE_ENV !== 'production') {n var keys = Object.create(null);n regex.keys.forEach(function (key) {n warn(n !keys,n ("Duplicate param keys in route with path: \"" + path + "\"")n );n keys = true;n });n }n return regexn}nnfunction normalizePath (n path,n parent,n strictn) {n if (!strict) { path = path.replace(/\/$/, ''); }n if (path === '/') { return path }n if (parent == null) { return path }n return cleanPath(((parent.path) + "/" + path))n}nn/* */nnnnfunction createMatcher (n routes,n routern) {n var ref = createRouteMap(routes);n var pathList = ref.pathList;n var pathMap = ref.pathMap;n var nameMap = ref.nameMap;nn function addRoutes (routes) {n createRouteMap(routes, pathList, pathMap, nameMap);n }nn function match (n raw,n currentRoute,n redirectedFromn ) {n var location = normalizeLocation(raw, currentRoute, false, router);n var name = location.name;nn if (name) {n var record = nameMap;n if (process.env.NODE_ENV !== 'production') {n warn(record, ("Route with name '" + name + "' does not exist"));n }n if (!record) { return _createRoute(null, location) }n var paramNames = record.regex.keysn .filter(function (key) { return !key.optional; })n .map(function (key) { return key.name; });nn if (typeof location.params !== 'object') {n location.params = {};n }nn if (currentRoute && typeof currentRoute.params === 'object') {n for (var key in currentRoute.params) {n if (!(key in location.params) && paramNames.indexOf(key) > -1) {n location.params = currentRoute.params;n }n }n }nn location.path = fillParams(record.path, location.params, ("named route \"" + name + "\""));n return _createRoute(record, location, redirectedFrom)n } else if (location.path) {n location.params = {};n for (var i = 0; i < pathList.length; i++) {n var path = pathList;n var record$1 = pathMap;n if (matchRoute(record$1.regex, location.path, location.params)) {n return _createRoute(record$1, location, redirectedFrom)n }n }n }n // no matchn return _createRoute(null, location)n }nn function redirect (n record,n locationn ) {n var originalRedirect = record.redirect;n var redirect = typeof originalRedirect === 'function'n ? originalRedirect(createRoute(record, location, null, router))n : originalRedirect;nn if (typeof redirect === 'string') {n redirect = { path: redirect };n }nn if (!redirect || typeof redirect !== 'object') {n if (process.env.NODE_ENV !== 'production') {n warn(n false, ("invalid redirect option: " + (JSON.stringify(redirect)))n );n }n return _createRoute(null, location)n }nn var re = redirect;n var name = re.name;n var path = re.path;n var query = location.query;n var hash = location.hash;n var params = location.params;n query = re.hasOwnProperty('query') ? re.query : query;n hash = re.hasOwnProperty('hash') ? re.hash : hash;n params = re.hasOwnProperty('params') ? re.params : params;nn if (name) {n // resolved named directn var targetRecord = nameMap;n if (process.env.NODE_ENV !== 'production') {n assert(targetRecord, ("redirect failed: named route \"" + name + "\" not found."));n }n return match({n _normalized: true,n name: name,n query: query,n hash: hash,n params: paramsn }, undefined, location)n } else if (path) {n // 1. resolve relative redirectn var rawPath = resolveRecordPath(path, record);n // 2. resolve paramsn var resolvedPath = fillParams(rawPath, params, ("redirect route with path \"" + rawPath + "\""));n // 3. rematch with existing query and hashn return match({n _normalized: true,n path: resolvedPath,n query: query,n hash: hashn }, undefined, location)n } else {n if (process.env.NODE_ENV !== 'production') {n warn(false, ("invalid redirect option: " + (JSON.stringify(redirect))));n }n return _createRoute(null, location)n }n }nn function alias (n record,n location,n matchAsn ) {n var aliasedPath = fillParams(matchAs, location.params, ("aliased route with path \"" + matchAs + "\""));n var aliasedMatch = match({n _normalized: true,n path: aliasedPathn });n if (aliasedMatch) {n var matched = aliasedMatch.matched;n var aliasedRecord = matched[matched.length - 1];n location.params = aliasedMatch.params;n return _createRoute(aliasedRecord, location)n }n return _createRoute(null, location)n }nn function _createRoute (n record,n location,n redirectedFromn ) {n if (record && record.redirect) {n return redirect(record, redirectedFrom || location)n }n if (record && record.matchAs) {n return alias(record, location, record.matchAs)n }n return createRoute(record, location, redirectedFrom, router)n }nn return {n match: match,n addRoutes: addRoutesn }n}nnfunction matchRoute (n regex,n path,n paramsn) {n var m = path.match(regex);nn if (!m) {n return falsen } else if (!params) {n return truen }nn for (var i = 1, len = m.length; i < len; ++i) {n var key = regex.keys[i - 1];n var val = typeof m === 'string' ? decodeURIComponent(m) : m;n if (key) {n // Fix #1994: using * with props: true generates a param named 0n params[key.name || 'pathMatch'] = val;n }n }nn return truen}nnfunction resolveRecordPath (path, record) {n return resolvePath(path, record.parent ? record.parent.path : '/', true)n}nn/* */nn// use User Timing api (if present) for more accurate key precisionnvar Time =n inBrowser && window.performance && window.performance.nown ? window.performancen : Date;nnfunction genStateKey () {n return Time.now().toFixed(3)n}nnvar _key = genStateKey();nnfunction getStateKey () {n return _keyn}nnfunction setStateKey (key) {n return (_key = key)n}nn/* */nnvar positionStore = Object.create(null);nnfunction setupScroll () {n // Prevent browser scroll behavior on History popstaten if ('scrollRestoration' in window.history) {n window.history.scrollRestoration = 'manual';n }n // Fix for #1585 for Firefoxn // Fix for #2195 Add optional third attribute to workaround a bug in safari bugs.webkit.org/show_bug.cgi?id=182678n // Fix for #2774 Support for apps loaded from Windows file shares not mapped to network drives: replaced location.origin withn // window.location.protocol + '//' + window.location.hostn // location.host contains the port and location.hostname doesn'tn var protocolAndPath = window.location.protocol + '//' + window.location.host;n var absolutePath = window.location.href.replace(protocolAndPath, '');n // preserve existing history state as it could be overriden by the usern var stateCopy = extend({}, window.history.state);n stateCopy.key = getStateKey();n window.history.replaceState(stateCopy, '', absolutePath);n window.addEventListener('popstate', handlePopState);n return function () {n window.removeEventListener('popstate', handlePopState);n }n}nnfunction handleScroll (n router,n to,n from,n isPopn) {n if (!router.app) {n returnn }nn var behavior = router.options.scrollBehavior;n if (!behavior) {n returnn }nn if (process.env.NODE_ENV !== 'production') {n assert(typeof behavior === 'function', "scrollBehavior must be a function");n }nn // wait until re-render finishes before scrollingn router.app.$nextTick(function () {n var position = getScrollPosition();n var shouldScroll = behavior.call(n router,n to,n from,n isPop ? position : nulln );nn if (!shouldScroll) {n returnn }nn if (typeof shouldScroll.then === 'function') {n shouldScrolln .then(function (shouldScroll) {n scrollToPosition((shouldScroll), position);n })n .catch(function (err) {n if (process.env.NODE_ENV !== 'production') {n assert(false, err.toString());n }n });n } else {n scrollToPosition(shouldScroll, position);n }n });n}nnfunction saveScrollPosition () {n var key = getStateKey();n if (key) {n positionStore = {n x: window.pageXOffset,n y: window.pageYOffsetn };n }n}nnfunction handlePopState (e) {n saveScrollPosition();n if (e.state && e.state.key) {n setStateKey(e.state.key);n }n}nnfunction getScrollPosition () {n var key = getStateKey();n if (key) {n return positionStoren }n}nnfunction getElementPosition (el, offset) {n var docEl = document.documentElement;n var docRect = docEl.getBoundingClientRect();n var elRect = el.getBoundingClientRect();n return {n x: elRect.left - docRect.left - offset.x,n y: elRect.top - docRect.top - offset.yn }n}nnfunction isValidPosition (obj) {n return isNumber(obj.x) || isNumber(obj.y)n}nnfunction normalizePosition (obj) {n return {n x: isNumber(obj.x) ? obj.x : window.pageXOffset,n y: isNumber(obj.y) ? obj.y : window.pageYOffsetn }n}nnfunction normalizeOffset (obj) {n return {n x: isNumber(obj.x) ? obj.x : 0,n y: isNumber(obj.y) ? obj.y : 0n }n}nnfunction isNumber (v) {n return typeof v === 'number'n}nnvar hashStartsWithNumberRE = /^#\d/;nnfunction scrollToPosition (shouldScroll, position) {n var isObject = typeof shouldScroll === 'object';n if (isObject && typeof shouldScroll.selector === 'string') {n // getElementById would still fail if the selector contains a more complicated query like main[data-attr]n // but at the same time, it doesn't make much sense to select an element with an id and an extra selectorn var el = hashStartsWithNumberRE.test(shouldScroll.selector) // $flow-disable-linen ? document.getElementById(shouldScroll.selector.slice(1)) // $flow-disable-linen : document.querySelector(shouldScroll.selector);nn if (el) {n var offset =n shouldScroll.offset && typeof shouldScroll.offset === 'object'n ? shouldScroll.offsetn : {};n offset = normalizeOffset(offset);n position = getElementPosition(el, offset);n } else if (isValidPosition(shouldScroll)) {n position = normalizePosition(shouldScroll);n }n } else if (isObject && isValidPosition(shouldScroll)) {n position = normalizePosition(shouldScroll);n }nn if (position) {n window.scrollTo(position.x, position.y);n }n}nn/* */nnvar supportsPushState =n inBrowser &&n (function () {n var ua = window.navigator.userAgent;nn if (n (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&n ua.indexOf('Mobile Safari') !== -1 &&n ua.indexOf('Chrome') === -1 &&n ua.indexOf('Windows Phone') === -1n ) {n return falsen }nn return window.history && typeof window.history.pushState === 'function'n })();nnfunction pushState (url, replace) {n saveScrollPosition();n // try…catch the pushState call to get around Safarin // DOM Exception 18 where it limits to 100 pushState callsn var history = window.history;n try {n if (replace) {n // preserve existing history state as it could be overriden by the usern var stateCopy = extend({}, history.state);n stateCopy.key = getStateKey();n history.replaceState(stateCopy, '', url);n } else {n history.pushState({ key: setStateKey(genStateKey()) }, '', url);n }n } catch (e) {n window.location[replace ? 'replace' : 'assign'](url);n }n}nnfunction replaceState (url) {n pushState(url, true);n}nn/* */nnfunction runQueue (queue, fn, cb) {n var step = function (index) {n if (index >= queue.length) {n cb();n } else {n if (queue) {n fn(queue, function () {n step(index + 1);n });n } else {n step(index + 1);n }n }n };n step(0);n}nn/* */nnfunction resolveAsyncComponents (matched) {n return function (to, from, next) {n var hasAsync = false;n var pending = 0;n var error = null;nn flatMapComponents(matched, function (def, _, match, key) {n // if it's a function and doesn't have cid attached,n // assume it's an async component resolve function.n // we are not using Vue's default async resolving mechanism becausen // we want to halt the navigation until the incoming component has beenn // resolved.n if (typeof def === 'function' && def.cid === undefined) {n hasAsync = true;n pending++;nn var resolve = once(function (resolvedDef) {n if (isESModule(resolvedDef)) {n resolvedDef = resolvedDef.default;n }n // save resolved on async factory in case it's used elsewheren def.resolved = typeof resolvedDef === 'function'n ? resolvedDefn : _Vue.extend(resolvedDef);n match.components = resolvedDef;n pending–;n if (pending <= 0) {n next();n }n });nn var reject = once(function (reason) {n var msg = "Failed to resolve async component " + key + ": " + reason;n process.env.NODE_ENV !== 'production' && warn(false, msg);n if (!error) {n error = isError(reason)n ? reasonn : new Error(msg);n next(error);n }n });nn var res;n try {n res = def(resolve, reject);n } catch (e) {n reject(e);n }n if (res) {n if (typeof res.then === 'function') {n res.then(resolve, reject);n } else {n // new syntax in Vue 2.3n var comp = res.component;n if (comp && typeof comp.then === 'function') {n comp.then(resolve, reject);n }n }n }n }n });nn if (!hasAsync) { next(); }n }n}nnfunction flatMapComponents (n matched,n fnn) {n return flatten(matched.map(function (m) {n return Object.keys(m.components).map(function (key) { return fn(n m.components,n m.instances,n m, keyn ); })n }))n}nnfunction flatten (arr) {n return Array.prototype.concat.apply([], arr)n}nnvar hasSymbol =n typeof Symbol === 'function' &&n typeof Symbol.toStringTag === 'symbol';nnfunction isESModule (obj) {n return obj.__esModule || (hasSymbol && obj === 'Module')n}nn// in Webpack 2, require.ensure now also returns a Promisen// so the resolve/reject functions may get called an extra timen// if the user uses an arrow function shorthand that happens ton// return that Promise.nfunction once (fn) {n var called = false;n return function () {n var args = [], len = arguments.length;n while ( len– ) args[ len ] = arguments[ len ];nn if (called) { return }n called = true;n return fn.apply(this, args)n }n}nnvar NavigationFailureType = {n redirected: 1,n aborted: 2,n cancelled: 3,n duplicated: 4n};nnfunction createNavigationRedirectedError (from, to) {n return createRouterError(n from,n to,n NavigationFailureType.redirected,n ("Redirected when going from \"" + (from.fullPath) + "\" to \"" + (stringifyRoute(n ton )) + "\" via a navigation guard.")n )n}nnfunction createNavigationDuplicatedError (from, to) {n return createRouterError(n from,n to,n NavigationFailureType.duplicated,n ("Avoided redundant navigation to current location: \"" + (from.fullPath) + "\".")n )n}nnfunction createNavigationCancelledError (from, to) {n return createRouterError(n from,n to,n NavigationFailureType.cancelled,n ("Navigation cancelled from \"" + (from.fullPath) + "\" to \"" + (to.fullPath) + "\" with a new navigation.")n )n}nnfunction createNavigationAbortedError (from, to) {n return createRouterError(n from,n to,n NavigationFailureType.aborted,n ("Navigation aborted from \"" + (from.fullPath) + "\" to \"" + (to.fullPath) + "\" via a navigation guard.")n )n}nnfunction createRouterError (from, to, type, message) {n var error = new Error(message);n error._isRouter = true;n error.from = from;n error.to = to;n error.type = type;nn return errorn}nnvar propertiesToLog = ['params', 'query', 'hash'];nnfunction stringifyRoute (to) {n if (typeof to === 'string') { return to }n if ('path' in to) { return to.path }n var location = {};n propertiesToLog.forEach(function (key) {n if (key in to) { location = to; }n });n return JSON.stringify(location, null, 2)n}nn/* */nnvar History = function History (router, base) {n this.router = router;n this.base = normalizeBase(base);n // start with a route object that stands for "nowhere"n this.current = START;n this.pending = null;n this.ready = false;n this.readyCbs = [];n this.readyErrorCbs = [];n this.errorCbs = [];n this.listeners = [];n};nnHistory.prototype.listen = function listen (cb) {n this.cb = cb;n};nnHistory.prototype.onReady = function onReady (cb, errorCb) {n if (this.ready) {n cb();n } else {n this.readyCbs.push(cb);n if (errorCb) {n this.readyErrorCbs.push(errorCb);n }n }n};nnHistory.prototype.onError = function onError (errorCb) {n this.errorCbs.push(errorCb);n};nnHistory.prototype.transitionTo = function transitionTo (n location,n onComplete,n onAbortn) {n var this$1 = this;nn var route = this.router.match(location, this.current);n this.confirmTransition(n route,n function () {n var prev = this$1.current;n this$1.updateRoute(route);n onComplete && onComplete(route);n this$1.ensureURL();n this$1.router.afterHooks.forEach(function (hook) {n hook && hook(route, prev);n });nn // fire ready cbs oncen if (!this$1.ready) {n this$1.ready = true;n this$1.readyCbs.forEach(function (cb) {n cb(route);n });n }n },n function (err) {n if (onAbort) {n onAbort(err);n }n if (err && !this$1.ready) {n this$1.ready = true;n // Initial redirection should still trigger the onReady onSuccessn // github.com/vuejs/vue-router/issues/3225n if (!isRouterError(err, NavigationFailureType.redirected)) {n this$1.readyErrorCbs.forEach(function (cb) {n cb(err);n });n } else {n this$1.readyCbs.forEach(function (cb) {n cb(route);n });n }n }n }n );n};nnHistory.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {n var this$1 = this;nn var current = this.current;n var abort = function (err) {n // changed after adding errors withn // github.com/vuejs/vue-router/pull/3047 before that change,n // redirect and aborted navigation would produce an err == nulln if (!isRouterError(err) && isError(err)) {n if (this$1.errorCbs.length) {n this$1.errorCbs.forEach(function (cb) {n cb(err);n });n } else {n warn(false, 'uncaught error during route navigation:');n console.error(err);n }n }n onAbort && onAbort(err);n };n var lastRouteIndex = route.matched.length - 1;n var lastCurrentIndex = current.matched.length - 1;n if (n isSameRoute(route, current) &&n // in the case the route map has been dynamically appended ton lastRouteIndex === lastCurrentIndex &&n route.matched === current.matchedn ) {n this.ensureURL();n return abort(createNavigationDuplicatedError(current, route))n }nn var ref = resolveQueue(n this.current.matched,n route.matchedn );n var updated = ref.updated;n var deactivated = ref.deactivated;n var activated = ref.activated;nn var queue = [].concat(n // in-component leave guardsn extractLeaveGuards(deactivated),n // global before hooksn this.router.beforeHooks,n // in-component update hooksn extractUpdateHooks(updated),n // in-config enter guardsn activated.map(function (m) { return m.beforeEnter; }),n // async componentsn resolveAsyncComponents(activated)n );nn this.pending = route;n var iterator = function (hook, next) {n if (this$1.pending !== route) {n return abort(createNavigationCancelledError(current, route))n }n try {n hook(route, current, function (to) {n if (to === false) {n // next(false) -> abort navigation, ensure current URLn this$1.ensureURL(true);n abort(createNavigationAbortedError(current, route));n } else if (isError(to)) {n this$1.ensureURL(true);n abort(to);n } else if (n typeof to === 'string' ||n (typeof to === 'object' &&n (typeof to.path === 'string' || typeof to.name === 'string'))n ) {n // next('/') or next({ path: '/' }) -> redirectn abort(createNavigationRedirectedError(current, route));n if (typeof to === 'object' && to.replace) {n this$1.replace(to);n } else {n this$1.push(to);n }n } else {n // confirm transition and pass on the valuen next(to);n }n });n } catch (e) {n abort(e);n }n };nn runQueue(queue, iterator, function () {n var postEnterCbs = [];n var isValid = function () { return this$1.current === route; };n // wait until async components are resolved beforen // extracting in-component enter guardsn var enterGuards = extractEnterGuards(activated, postEnterCbs, isValid);n var queue = enterGuards.concat(this$1.router.resolveHooks);n runQueue(queue, iterator, function () {n if (this$1.pending !== route) {n return abort(createNavigationCancelledError(current, route))n }n this$1.pending = null;n onComplete(route);n if (this$1.router.app) {n this$1.router.app.$nextTick(function () {n postEnterCbs.forEach(function (cb) {n cb();n });n });n }n });n });n};nnHistory.prototype.updateRoute = function updateRoute (route) {n this.current = route;n this.cb && this.cb(route);n};nnHistory.prototype.setupListeners = function setupListeners () {n // Default implementation is emptyn};nnHistory.prototype.teardownListeners = function teardownListeners () {n this.listeners.forEach(function (cleanupListener) {n cleanupListener();n });n this.listeners = [];n};nnfunction normalizeBase (base) {n if (!base) {n if (inBrowser) {n // respect <base> tagn var baseEl = document.querySelector('base');n base = (baseEl && baseEl.getAttribute('href')) || '/';n // strip full URL originn base = base.replace(/^https?:\/\/+/, '');n } else {n base = '/';n }n }n // make sure there's the starting slashn if (base.charAt(0) !== '/') {n base = '/' + base;n }n // remove trailing slashn return base.replace(/\/$/, '')n}nnfunction resolveQueue (n current,n nextn) {n var i;n var max = Math.max(current.length, next.length);n for (i = 0; i < max; i++) {n if (current !== next) {n breakn }n }n return {n updated: next.slice(0, i),n activated: next.slice(i),n deactivated: current.slice(i)n }n}nnfunction extractGuards (n records,n name,n bind,n reversen) {n var guards = flatMapComponents(records, function (def, instance, match, key) {n var guard = extractGuard(def, name);n if (guard) {n return Array.isArray(guard)n ? guard.map(function (guard) { return bind(guard, instance, match, key); })n : bind(guard, instance, match, key)n }n });n return flatten(reverse ? guards.reverse() : guards)n}nnfunction extractGuard (n def,n keyn) {n if (typeof def !== 'function') {n // extend now so that global mixins are applied.n def = _Vue.extend(def);n }n return def.optionsn}nnfunction extractLeaveGuards (deactivated) {n return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)n}nnfunction extractUpdateHooks (updated) {n return extractGuards(updated, 'beforeRouteUpdate', bindGuard)n}nnfunction bindGuard (guard, instance) {n if (instance) {n return function boundRouteGuard () {n return guard.apply(instance, arguments)n }n }n}nnfunction extractEnterGuards (n activated,n cbs,n isValidn) {n return extractGuards(n activated,n 'beforeRouteEnter',n function (guard, _, match, key) {n return bindEnterGuard(guard, match, key, cbs, isValid)n }n )n}nnfunction bindEnterGuard (n guard,n match,n key,n cbs,n isValidn) {n return function routeEnterGuard (to, from, next) {n return guard(to, from, function (cb) {n if (typeof cb === 'function') {n cbs.push(function () {n // #750n // if a router-view is wrapped with an out-in transition,n // the instance may not have been registered at this time.n // we will need to poll for registration until current routen // is no longer valid.n poll(cb, match.instances, key, isValid);n });n }n next(cb);n })n }n}nnfunction poll (n cb, // somehow flow cannot infer this is a functionn instances,n key,n isValidn) {n if (n instances &&n !instances._isBeingDestroyed // do not reuse being destroyed instancen ) {n cb(instances);n } else if (isValid()) {n setTimeout(function () {n poll(cb, instances, key, isValid);n }, 16);n }n}nn/* */nnvar HTML5History = /*@__PURE__*/(function (History) {n function HTML5History (router, base) {n History.call(this, router, base);nn this._startLocation = getLocation(this.base);n }nn if ( History ) HTML5History.__proto__ = History;n HTML5History.prototype = Object.create( History && History.prototype );n HTML5History.prototype.constructor = HTML5History;nn HTML5History.prototype.setupListeners = function setupListeners () {n var this$1 = this;nn if (this.listeners.length > 0) {n returnn }nn var router = this.router;n var expectScroll = router.options.scrollBehavior;n var supportsScroll = supportsPushState && expectScroll;nn if (supportsScroll) {n this.listeners.push(setupScroll());n }nn var handleRoutingEvent = function () {n var current = this$1.current;nn // Avoiding first `popstate` event dispatched in some browsers but firstn // history route not updated since async guard at the same time.n var location = getLocation(this$1.base);n if (this$1.current === START && location === this$1._startLocation) {n returnn }nn this$1.transitionTo(location, function (route) {n if (supportsScroll) {n handleScroll(router, route, current, true);n }n });n };n window.addEventListener('popstate', handleRoutingEvent);n this.listeners.push(function () {n window.removeEventListener('popstate', handleRoutingEvent);n });n };nn HTML5History.prototype.go = function go (n) {n window.history.go(n);n };nn HTML5History.prototype.push = function push (location, onComplete, onAbort) {n var this$1 = this;nn var ref = this;n var fromRoute = ref.current;n this.transitionTo(location, function (route) {n pushState(cleanPath(this$1.base + route.fullPath));n handleScroll(this$1.router, route, fromRoute, false);n onComplete && onComplete(route);n }, onAbort);n };nn HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {n var this$1 = this;nn var ref = this;n var fromRoute = ref.current;n this.transitionTo(location, function (route) {n replaceState(cleanPath(this$1.base + route.fullPath));n handleScroll(this$1.router, route, fromRoute, false);n onComplete && onComplete(route);n }, onAbort);n };nn HTML5History.prototype.ensureURL = function ensureURL (push) {n if (getLocation(this.base) !== this.current.fullPath) {n var current = cleanPath(this.base + this.current.fullPath);n push ? pushState(current) : replaceState(current);n }n };nn HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {n return getLocation(this.base)n };nn return HTML5History;n}(History));nnfunction getLocation (base) {n var path = decodeURI(window.location.pathname);n if (base && path.toLowerCase().indexOf(base.toLowerCase()) === 0) {n path = path.slice(base.length);n }n return (path || '/') + window.location.search + window.location.hashn}nn/* */nnvar HashHistory = /*@__PURE__*/(function (History) {n function HashHistory (router, base, fallback) {n History.call(this, router, base);n // check history fallback deeplinkingn if (fallback && checkFallback(this.base)) {n returnn }n ensureSlash();n }nn if ( History ) HashHistory.__proto__ = History;n HashHistory.prototype = Object.create( History && History.prototype );n HashHistory.prototype.constructor = HashHistory;nn // this is delayed until the app mountsn // to avoid the hashchange listener being fired too earlyn HashHistory.prototype.setupListeners = function setupListeners () {n var this$1 = this;nn if (this.listeners.length > 0) {n returnn }nn var router = this.router;n var expectScroll = router.options.scrollBehavior;n var supportsScroll = supportsPushState && expectScroll;nn if (supportsScroll) {n this.listeners.push(setupScroll());n }nn var handleRoutingEvent = function () {n var current = this$1.current;n if (!ensureSlash()) {n returnn }n this$1.transitionTo(getHash(), function (route) {n if (supportsScroll) {n handleScroll(this$1.router, route, current, true);n }n if (!supportsPushState) {n replaceHash(route.fullPath);n }n });n };n var eventType = supportsPushState ? 'popstate' : 'hashchange';n window.addEventListener(n eventType,n handleRoutingEventn );n this.listeners.push(function () {n window.removeEventListener(eventType, handleRoutingEvent);n });n };nn HashHistory.prototype.push = function push (location, onComplete, onAbort) {n var this$1 = this;nn var ref = this;n var fromRoute = ref.current;n this.transitionTo(n location,n function (route) {n pushHash(route.fullPath);n handleScroll(this$1.router, route, fromRoute, false);n onComplete && onComplete(route);n },n onAbortn );n };nn HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {n var this$1 = this;nn var ref = this;n var fromRoute = ref.current;n this.transitionTo(n location,n function (route) {n replaceHash(route.fullPath);n handleScroll(this$1.router, route, fromRoute, false);n onComplete && onComplete(route);n },n onAbortn );n };nn HashHistory.prototype.go = function go (n) {n window.history.go(n);n };nn HashHistory.prototype.ensureURL = function ensureURL (push) {n var current = this.current.fullPath;n if (getHash() !== current) {n push ? pushHash(current) : replaceHash(current);n }n };nn HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {n return getHash()n };nn return HashHistory;n}(History));nnfunction checkFallback (base) {n var location = getLocation(base);n if (!/^\/#/.test(location)) {n window.location.replace(cleanPath(base + '/#' + location));n return truen }n}nnfunction ensureSlash () {n var path = getHash();n if (path.charAt(0) === '/') {n return truen }n replaceHash('/' + path);n return falsen}nnfunction getHash () {n // We can't use window.location.hash here because it's notn // consistent across browsers - Firefox will pre-decode it!n var href = window.location.href;n var index = href.indexOf('#');n // empty pathn if (index < 0) { return '' }nn href = href.slice(index + 1);n // decode the hash but not the search or hashn // as search(query) is already decodedn // github.com/vuejs/vue-router/issues/2708n var searchIndex = href.indexOf('?');n if (searchIndex < 0) {n var hashIndex = href.indexOf('#');n if (hashIndex > -1) {n href = decodeURI(href.slice(0, hashIndex)) + href.slice(hashIndex);n } else { href = decodeURI(href); }n } else {n href = decodeURI(href.slice(0, searchIndex)) + href.slice(searchIndex);n }nn return hrefn}nnfunction getUrl (path) {n var href = window.location.href;n var i = href.indexOf('#');n var base = i >= 0 ? href.slice(0, i) : href;n return (base + "#" + path)n}nnfunction pushHash (path) {n if (supportsPushState) {n pushState(getUrl(path));n } else {n window.location.hash = path;n }n}nnfunction replaceHash (path) {n if (supportsPushState) {n replaceState(getUrl(path));n } else {n window.location.replace(getUrl(path));n }n}nn/* */nnvar AbstractHistory = /*@__PURE__*/(function (History) {n function AbstractHistory (router, base) {n History.call(this, router, base);n this.stack = [];n this.index = -1;n }nn if ( History ) AbstractHistory.__proto__ = History;n AbstractHistory.prototype = Object.create( History && History.prototype );n AbstractHistory.prototype.constructor = AbstractHistory;nn AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {n var this$1 = this;nn this.transitionTo(n location,n function (route) {n this$1.stack = this$1.stack.slice(0, this$1.index + 1).concat(route);n this$1.index++;n onComplete && onComplete(route);n },n onAbortn );n };nn AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {n var this$1 = this;nn this.transitionTo(n location,n function (route) {n this$1.stack = this$1.stack.slice(0, this$1.index).concat(route);n onComplete && onComplete(route);n },n onAbortn );n };nn AbstractHistory.prototype.go = function go (n) {n var this$1 = this;nn var targetIndex = this.index + n;n if (targetIndex < 0 || targetIndex >= this.stack.length) {n returnn }n var route = this.stack;n this.confirmTransition(n route,n function () {n this$1.index = targetIndex;n this$1.updateRoute(route);n },n function (err) {n if (isRouterError(err, NavigationFailureType.duplicated)) {n this$1.index = targetIndex;n }n }n );n };nn AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {n var current = this.stack[this.stack.length - 1];n return current ? current.fullPath : '/'n };nn AbstractHistory.prototype.ensureURL = function ensureURL () {n // noopn };nn return AbstractHistory;n}(History));nn/* */nnnnvar VueRouter = function VueRouter (options) {n if ( options === void 0 ) options = {};nn this.app = null;n this.apps = [];n this.options = options;n this.beforeHooks = [];n this.resolveHooks = [];n this.afterHooks = [];n this.matcher = createMatcher(options.routes || [], this);nn var mode = options.mode || 'hash';n this.fallback = mode === 'history' && !supportsPushState && options.fallback !== false;n if (this.fallback) {n mode = 'hash';n }n if (!inBrowser) {n mode = 'abstract';n }n this.mode = mode;nn switch (mode) {n case 'history':n this.history = new HTML5History(this, options.base);n breakn case 'hash':n this.history = new HashHistory(this, options.base, this.fallback);n breakn case 'abstract':n this.history = new AbstractHistory(this, options.base);n breakn default:n if (process.env.NODE_ENV !== 'production') {n assert(false, ("invalid mode: " + mode));n }n }n};nnvar prototypeAccessors = { currentRoute: { configurable: true } };nnVueRouter.prototype.match = function match (n raw,n current,n redirectedFromn) {n return this.matcher.match(raw, current, redirectedFrom)n};nnprototypeAccessors.currentRoute.get = function () {n return this.history && this.history.currentn};nnVueRouter.prototype.init = function init (app /* Vue component instance */) {n var this$1 = this;nn process.env.NODE_ENV !== 'production' && assert(n install.installed,n "not installed. Make sure to call `Vue.use(VueRouter)` " +n "before creating root instance."n );nn this.apps.push(app);nn // set up app destroyed handlern // github.com/vuejs/vue-router/issues/2639n app.$once('hook:destroyed', function () {n // clean out app from this.apps array once destroyedn var index = this$1.apps.indexOf(app);n if (index > -1) { this$1.apps.splice(index, 1); }n // ensure we still have a main app or null if no appsn // we do not release the router so it can be reusedn if (this$1.app === app) { this$1.app = this$1.apps || null; }nn if (!this$1.app) {n // clean up event listenersn // github.com/vuejs/vue-router/issues/2341n this$1.history.teardownListeners();n }n });nn // main app previously initializedn // return as we don't need to set up new history listenern if (this.app) {n returnn }nn this.app = app;nn var history = this.history;nn if (history instanceof HTML5History || history instanceof HashHistory) {n var setupListeners = function () {n history.setupListeners();n };n history.transitionTo(history.getCurrentLocation(), setupListeners, setupListeners);n }nn history.listen(function (route) {n this$1.apps.forEach(function (app) {n app._route = route;n });n });n};nnVueRouter.prototype.beforeEach = function beforeEach (fn) {n return registerHook(this.beforeHooks, fn)n};nnVueRouter.prototype.beforeResolve = function beforeResolve (fn) {n return registerHook(this.resolveHooks, fn)n};nnVueRouter.prototype.afterEach = function afterEach (fn) {n return registerHook(this.afterHooks, fn)n};nnVueRouter.prototype.onReady = function onReady (cb, errorCb) {n this.history.onReady(cb, errorCb);n};nnVueRouter.prototype.onError = function onError (errorCb) {n this.history.onError(errorCb);n};nnVueRouter.prototype.push = function push (location, onComplete, onAbort) {n var this$1 = this;nn // $flow-disable-linen if (!onComplete && !onAbort && typeof Promise !== 'undefined') {n return new Promise(function (resolve, reject) {n this$1.history.push(location, resolve, reject);n })n } else {n this.history.push(location, onComplete, onAbort);n }n};nnVueRouter.prototype.replace = function replace (location, onComplete, onAbort) {n var this$1 = this;nn // $flow-disable-linen if (!onComplete && !onAbort && typeof Promise !== 'undefined') {n return new Promise(function (resolve, reject) {n this$1.history.replace(location, resolve, reject);n })n } else {n this.history.replace(location, onComplete, onAbort);n }n};nnVueRouter.prototype.go = function go (n) {n this.history.go(n);n};nnVueRouter.prototype.back = function back () {n this.go(-1);n};nnVueRouter.prototype.forward = function forward () {n this.go(1);n};nnVueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {n var route = ton ? to.matchedn ? ton : this.resolve(to).routen : this.currentRoute;n if (!route) {n return []n }n return [].concat.apply([], route.matched.map(function (m) {n return Object.keys(m.components).map(function (key) {n return m.componentsn })n }))n};nnVueRouter.prototype.resolve = function resolve (n to,n current,n appendn) {n current = current || this.history.current;n var location = normalizeLocation(n to,n current,n append,n thisn );n var route = this.match(location, current);n var fullPath = route.redirectedFrom || route.fullPath;n var base = this.history.base;n var href = createHref(base, fullPath, this.mode);n return {n location: location,n route: route,n href: href,n // for backwards compatn normalizedTo: location,n resolved: routen }n};nnVueRouter.prototype.addRoutes = function addRoutes (routes) {n this.matcher.addRoutes(routes);n if (this.history.current !== START) {n this.history.transitionTo(this.history.getCurrentLocation());n }n};nnObject.defineProperties( VueRouter.prototype, prototypeAccessors );nnfunction registerHook (list, fn) {n list.push(fn);n return function () {n var i = list.indexOf(fn);n if (i > -1) { list.splice(i, 1); }n }n}nnfunction createHref (base, fullPath, mode) {n var path = mode === 'hash' ? '#' + fullPath : fullPath;n return base ? cleanPath(base + '/' + path) : pathn}nnVueRouter.install = install;nVueRouter.version = '3.3.4';nnif (inBrowser && window.Vue) {n window.Vue.use(VueRouter);n}nnexport default VueRouter;n”,“var g;nn// This works in non-strict modeng = (function() {ntreturn this;n})();nntry {nt// This works if eval is allowed (see CSP)ntg = g || new Function("return this")();n} catch (e) {nt// This works if the window reference is availablentif (typeof window === "object") g = window;n}nn// g can still be undefined, but nothing to do about it…n// We return undefined, instead of nothing here, so it'sn// easier to handle this case. if(!global) { …}nnmodule.exports = g;n”],“sourceRoot”:“”}