{"version":3,"sources":["../../node_modules/vue/dist/vue.runtime.esm.js","../../node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","../../node_modules/@babel/runtime/helpers/iterableToArray.js","../../node_modules/@babel/runtime/helpers/nonIterableSpread.js","../../node_modules/@babel/runtime/helpers/toConsumableArray.js","../../node_modules/regenerator-runtime/runtime.js","../../node_modules/regenerator-runtime/runtime-module.js","../../node_modules/@babel/runtime/regenerator/index.js","../../node_modules/@babel/runtime/helpers/asyncToGenerator.js","../../node_modules/@babel/runtime/helpers/defineProperty.js","../../node_modules/@babel/runtime/helpers/objectSpread.js","../../node_modules/better-scroll/dist/bscroll.esm.js","../../src/Scroll/mixins/index.js","../../src/Scroll/Loading/index.vue","../../src/Scroll/Bubble/index.vue","../../src/Scroll/utils/index.js","../../src/Scroll/index.vue","../../src/index.js","App.vue","main.js"],"names":["Vue","emptyObject","Object","freeze","isUndef","v","isDef","isTrue","isFalse","isPrimitive","value","isObject","obj","_toString","prototype","toString","toRawType","call","slice","isPlainObject","isRegExp","isValidArrayIndex","val","n","parseFloat","String","Math","floor","isFinite","isPromise","then","catch","Array","isArray","JSON","stringify","toNumber","isNaN","makeMap","str","expectsLowerCase","map","create","list","split","i","length","toLowerCase","isBuiltInTag","isReservedAttribute","remove","arr","item","index","indexOf","splice","hasOwnProperty","hasOwn","key","cached","fn","cache","hit","camelizeRE","camelize","replace","_","c","toUpperCase","capitalize","charAt","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","keys","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","source","parsePath","path","test","segments","_isServer","hasProto","inBrowser","window","inWeex","WXEnvironment","platform","weexPlatform","UA","navigator","userAgent","isIE","isIE9","isEdge","isAndroid","isIOS","isChrome","isPhantomJS","isFF","match","nativeWatch","watch","supportsPassive","opts","get","addEventListener","isServerRendering","undefined","global","env","VUE_ENV","__VUE_DEVTOOLS_GLOBAL_HOOK__","isNative","Ctor","_Set","hasSymbol","Symbol","Reflect","ownKeys","Set","set","has","add","clear","hasConsole","classifyRE","classify","repeat","warn","tip","generateComponentTrace","formatComponentName","uid","Dep","id","subs","addSub","sub","push","removeSub","depend","target","addDep","notify","update","targetStack","pushTarget","popTarget","pop","VNode","tag","data","children","text","elm","context","componentOptions","asyncFactory","ns","fnContext","fnOptions","fnScopeId","componentInstance","parent","raw","isStatic","isRootInsert","isComment","isCloned","isOnce","asyncMeta","isAsyncPlaceholder","prototypeAccessors","child","defineProperties","createEmptyVNode","node","createTextVNode","cloneVNode","vnode","cloned","arrayProto","arrayMethods","methodsToPatch","forEach","method","original","len","args","result","inserted","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","mergeData","from","toVal","fromVal","mergeDataOrFn","parentVal","childVal","vm","instanceData","defaultData","mergeHook","concat","dedupeHooks","hooks","mergeAssets","hook","type","key$1","props","methods","inject","computed","provide","defaultStrat","checkComponents","options","components","validateComponentName","name","normalizeProps","normalizeInject","normalized","normalizeDirectives","dirs","directives","def$$1","assertObjectType","mergeOptions","_base","extends","mixins","mergeField","strat","resolveAsset","warnMissing","assets","camelizedId","PascalCaseId","validateProp","propOptions","propsData","prop","absent","booleanIndex","getTypeIndex","Boolean","stringIndex","getPropDefaultValue","prevShouldObserve","default","$options","_props","getType","assertProp","required","valid","expectedTypes","assertedType","assertType","expectedType","validator","getInvalidTypeMessage","simpleCheckRE","t","isSameType","message","join","receivedType","expectedValue","styleValue","receivedValue","isExplicable","isBoolean","Number","explicitTypes","some","elem","handleError","err","info","cur","$parent","errorCaptured","capture","globalHandleError","invokeWithErrorHandling","handler","logError","console","error","timerFunc","initProxy","allowedGlobals","warnNonPresent","warnReservedPrefix","hasProxy","isBuiltInModifier","hasHandler","getHandler","isUsingMicroTask","callbacks","pending","flushCallbacks","copies","Promise","p","resolve","setTimeout","MutationObserver","setImmediate","counter","observer","textNode","document","createTextNode","characterData","nextTick","cb","_resolve","mark","measure","perf","seenObjects","traverse","_traverse","seen","isA","isFrozen","depId","normalizeEvent","passive","once$$1","createFnInvoker","fns","invoker","arguments$1","updateListeners","on","oldOn","remove$$1","createOnceHandler","old","event","params","mergeVNodeHook","hookKey","oldHook","wrappedHook","merged","extractPropsFromVNodeData","attrs","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","isStable","$stable","$key","_normalized","normalizeScopedSlot","key$2","proxyNormalSlot","proxy","renderList","render","iterator","next","done","renderSlot","fallback","bindObject","scopedSlotFn","nodes","$scopedSlots","$slots","$createElement","resolveFilter","isKeyNotMatch","expect","actual","checkKeyCodes","eventKeyCode","builtInKeyCode","eventKeyName","builtInKeyName","mappedKeyCode","bindObjectProps","asProp","isSync","loop","domProps","camelizedKey","$event","renderStatic","isInFor","_staticTrees","tree","markStatic","staticRenderFns","_renderProxy","markOnce","markStaticNode","bindObjectListeners","existing","ours","resolveScopedSlots","hasDynamicKeys","contentHashKey","bindDynamicKeys","baseObj","values","prependModifier","symbol","installRenderHelpers","_o","_n","_s","_l","_t","_q","_i","_m","_f","_k","_b","_v","_e","_u","_g","_d","_p","FunctionalRenderContext","this$1","contextVm","_original","isCompiled","_compiled","needNormalization","listeners","injections","scopedSlots","_scopeId","_c","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","functional","nativeOn","abstract","installComponentHooks","_isComponent","_parentVnode","inlineTemplate","toMerge","_merged","mergeHook$1","f1","f2","callback","SIMPLE_NORMALIZE","ALWAYS_NORMALIZE","normalizationType","alwaysNormalize","_createElement","is","$vnode","pre","applyNS","registerDeepBindings","force","style","class","initRender","_vnode","parentVnode","_renderChildren","parentData","_parentListeners","currentRenderingInstance","renderMixin","$nextTick","_render","ref","ensureCtor","comp","base","__esModule","toStringTag","factory","errorComp","resolved","owner","owners","loading","loadingComp","sync","$on","forceRender","renderCompleted","$forceUpdate","reject","reason","component","delay","timeout","getFirstComponentChild","initEvents","_events","_hasHookEvent","updateComponentListeners","remove$1","$off","_target","onceHandler","oldListeners","eventsMixin","hookRE","$once","i$1","cbs","$emit","isUpdatingChildComponent","setActiveInstance","prevActiveInstance","initLifecycle","$children","$root","$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","MAX_UPDATE_COUNT","queue","activatedChildren","circular","waiting","flushing","resetSchedulerState","currentFlushTimestamp","getNow","now","flushSchedulerQueue","watcher","sort","run","activatedQueue","updatedQueue","callActivatedHooks","callUpdatedHooks","emit","queueWatcher","createEvent","timeStamp","uid$2","expOrFn","isRenderWatcher","deep","user","lazy","active","dirty","deps","newDeps","depIds","newDepIds","expression","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","_self","vnodeComponentOptions","_componentTag","super","superOptions","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","created","destroyed","mounted","ref$1","parseInt","builtInComponents","initGlobalAPI","configDef","util","defineReactive","delete","observable","ssrContext","version","acceptValue","attr","isEnumeratedAttr","isValidContentEditableValue","convertEnumeratedValue","isFalsyAttrValue","isBooleanAttr","xlinkNS","isXlink","getXlinkProp","genClassForVnode","parentNode","childNode","mergeClassData","renderClass","staticClass","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","scopeId","nodeOps","registerRef","isRemoval","refs","refInFor","emptyNode","sameVnode","sameInputType","typeA","typeB","createKeyToOldIdx","beginIdx","endIdx","createPatchFunction","backend","modules","removeNode","createElm","insertedVnodeQueue","parentElm","refElm","nested","ownerArray","isReactivated","initComponent","reactivateComponent","innerNode","transition","activate","setScope","createChildren","invokeCreateHooks","pendingInsert","isPatchable","ref$$1","ancestor","addVnodes","startIdx","invokeDestroyHook","removeVnodes","ch","removeAndInvokeRemoveHook","rm","createRmCb","childElm","findIdxInOld","oldCh","end","patchVnode","removeOnly","hydrate","updateChildren","newCh","oldStartIdx","oldKeyToIdx","idxInOld","vnodeToMove","newStartIdx","oldEndIdx","oldStartVnode","oldEndVnode","newEndIdx","newStartVnode","newEndVnode","canMove","postpatch","invokeInsertHook","initial","hydrationBailed","isRenderedModule","inVPre","hasChildNodes","innerHTML","childrenMatch","firstChild","fullInvoke","isInitialPatch","isRealElement","nodeType","hasAttribute","removeAttribute","oldElm","_leaveCb","patchable","i$2","updateDirectives","isCreate","oldDir","dir","isDestroy","oldDirs","normalizeDirectives$1","newDirs","dirsWithInsert","dirsWithPostpatch","oldArg","arg","callHook$1","componentUpdated","callInsert","emptyModifiers","modifiers","getRawDirName","rawName","baseModules","updateAttrs","inheritAttrs","oldAttrs","setAttr","removeAttributeNS","baseSetAttr","setAttributeNS","__ieph","blocker","stopImmediatePropagation","removeEventListener","updateClass","oldData","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","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","getTransitionInfo","propCount","ended","onEnd","transformRE","styles","getComputedStyle","transitionDelays","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationDurations","animationTimeout","hasTransform","delays","durations","toMs","s","enter","toggleDisplay","cancelled","_enterCb","transitionNode","appearClass","appearToClass","appearActiveClass","beforeEnter","afterEnter","enterCancelled","beforeAppear","appear","afterAppear","appearCancelled","duration","isAppear","startClass","activeClass","toClass","beforeEnterHook","enterHook","afterEnterHook","enterCancelledHook","explicitEnterDuration","expectsCSS","userWantsControl","getHookArgumentsLength","show","pendingNode","_pending","isValidDuration","leave","beforeLeave","afterLeave","leaveCancelled","delayLeave","explicitLeaveDuration","performLeave","checkDuration","invokerFns","_enter","platformModules","patch","vmodel","trigger","directive","binding","_vOptions","setSelected","getValue","onCompositionStart","onCompositionEnd","prevOptions","curOptions","o","hasNoMatchingOption","actuallySetSelected","isMultiple","option","selectedIndex","initEvent","dispatchEvent","locateNode","transition$$1","originalDisplay","__vOriginalDisplay","display","unbind","platformDirectives","transitionProps","mode","getRealChild","compOptions","extractTransitionData","placeholder","h","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","BScroll","spliceOne","slicedToArray","sliceIterator","_arr","TypeError","toConsumableArray","arr2","eventMixin","magic","off","count","eventsCopy","_event","ua","isWeChatDevTools","timing","navigationStart","_len","rest","_key","getDistance","x","y","sqrt","elementStyle","vendor","transformNames","webkit","Moz","O","ms","standard","prefixStyle","substr","addEvent","removeEvent","offset","offsetLeft","offsetTop","offsetParent","offsetToBody","rect","pageXOffset","pageYOffset","cssVendor","hasPerspective","hasTouch","transitionTimingFunction","transitionDelay","transformOrigin","transitionEnd","TOUCH_EVENT","MOUSE_EVENT","eventType","touchstart","touchmove","touchend","mousedown","mousemove","mouseup","getRect","SVGElement","width","height","offsetWidth","preventDefaultException","exceptions","tap","eventName","ev","pageX","pageY","click","eventSource","changedTouches","posSrc","screenX","screenY","clientX","clientY","bubbles","cancelable","MouseEvent","forwardedTouchEvent","_constructed","dblclick","prepend","DEFAULT_OPTIONS","startX","startY","scrollX","scrollY","freeScroll","directionLockThreshold","eventPassthrough","bounce","bounceTime","momentum","momentumLimitTime","momentumLimitDistance","swipeTime","swipeBounceTime","deceleration","flickLimitTime","flickLimitDistance","resizePolling","probeType","preventDefault","HWCompositing","useTransition","useTransform","bindToWrapper","disableMouse","disableTouch","observeDOM","autoBlur","wheel","snap","scrollbar","pullDownRefresh","pullUpLoad","mouseWheel","stopPropagation","zoom","infinity","_handleOptions","directionX","directionY","setScale","_addDOMEvents","_initExtFeatures","_watchTransition","_initDOMObserver","_handleAutoBlur","refresh","scrollTo","enable","scale","lastScale","translateZ","eventOperation","_handleDOMEvents","_removeDOMEvents","wrapper","scroller","_initSnap","_initScrollbar","_initPullUp","_initPullDown","_initWheel","_initMouseWheel","_initZoom","_initInfinite","me","isInTransition","pointerEvents","pulling","blur","_this","timer","mutations","_shouldNotRefresh","immediateRefresh","deferredRefresh","mutation","clearTimeout","attributes","childList","subtree","disconnect","_checkDOMUpdate","outsideBoundaries","minScrollX","maxScrollX","minScrollY","maxScrollY","stopFromTransition","scrollerRect","oldWidth","oldHeight","_this2","check","newWidth","newHeight","handleEvent","_start","touches","_zoomStart","_zoom","_move","scaled","_zoomEnd","_end","_resize","_transitionEnd","enabled","_onMouseWheel","isWrapperStatic","position","wrapperRect","wrapperWidth","wrapperHeight","scrollerWidth","round","scrollerHeight","relativeX","relativeY","itemHeight","hasHorizontalScroll","hasVerticalScroll","endTime","wrapperOffset","resetPosition","disable","ease","swipe","swipeBounce","time","lowerMargin","upperMargin","wrapperSize","distance","speed","abs","rate","destination","min","DEFAULT_INTERVAL","webkitRequestAnimationFrame","mozRequestAnimationFrame","oRequestAnimationFrame","interval","cancelAnimationFrame","webkitCancelAnimationFrame","mozCancelAnimationFrame","oCancelAnimationFrame","DIRECTION_UP","DIRECTION_DOWN","DIRECTION_LEFT","DIRECTION_RIGHT","PROBE_DEBOUNCE","PROBE_REALTIME","msg","assert","condition","Error","coreMixin","_eventType","button","initiated","distX","distY","movingDirectionX","movingDirectionY","directionLocked","_transitionTime","startTime","stop","point","absStartX","absStartY","pointX","pointY","deltaX","deltaY","absDistX","absDistY","timestamp","newX","newY","bottom","right","_translate","scrollLeft","documentElement","scrollTop","pX","pY","clientWidth","clientHeight","_checkPullDown","_checkClick","flick","momentumX","momentumY","adjustTime","easing","_nearestSnap","currentPage","snapSpeed","preventClick","contains","wheelWrapperClass","_offset","scrollToElement","_dblclick","dblclickTrigged","lastClickTime","_dblclick$delay","resizeTimeout","_startProbe","probeTimer","probe","getComputedPosition","scrollerStyle","indicators","transitionTime","_transitionTimingFunction","_i2","_options$wheel$rotate","rotate","deg","_i3","updatePosition","_animate","destX","destY","easingFn","startScale","destScale","destTime","isAnimating","animateTimer","step","newScale","scrollBy","offsetX","offsetY","wheelItemClass","easeing","roundX","roundY","matrix","snapMixin","querySelectorAll","pages","stepX","stepY","cx","cy","m","_checkSnapLoop","initPageX","_loopX","initPageY","_loopY","_goToPage","snapThreshold","threshold","snapThresholdX","snapThresholdY","listenFlick","_children","posX","posY","goToPage","prev","getCurrentPage","wheelMixin","wheelTo","getSelectedIndex","INDICATOR_MIN_LEN","scrollbarMixin","_options$scrollbar","_options$scrollbar$fa","fade","_options$scrollbar$in","interactive","indicator","createScrollbar","direction","_insertScrollBar","Indicator","_removeScrollBars","className","wrapperStyle","indicatorStyle","visible","opacity","sizeRatioX","sizeRatioY","maxPosX","maxPosY","pullDownMixin","_options$pullDownRefr","_options$pullDownRefr2","_options$pullDownRefr3","finishPullDown","openPullDown","closePullDown","autoPullDownRefresh","_options$pullDownRefr4","_options$pullDownRefr5","_options$pullDownRefr6","pullUpMixin","pullupWatching","_watchPullUp","_checkToEnd","_options$pullUpLoad$t","finishPullUp","openPullUp","closePullUp","mouseWheelMixin","_handleMouseWheelEvent","mouseWheelTimer","mouseWheelEndTimer","firstWheelOpreation","_options$mouseWheel","_options$mouseWheel$s","_options$mouseWheel$i","invert","_options$mouseWheel$e","easeTime","wheelDeltaX","wheelDeltaY","deltaMode","wheelDelta","detail","needTriggerEnd","zoomMixin","_options$zoom","_options$zoom$start","_options$zoom$min","_options$zoom$max","_zoomTo","originX","originY","zoomTo","_offsetToBody","firstFinger","secondFinger","startDistance","_offsetToBody2","_options$zoom2","_options$zoom2$min","_options$zoom2$max","pow","_options$zoom3","_options$zoom3$min","_options$zoom3$max","_shouldShow","_calculate","hold","fadeTimeout","indicatorHeight","_height","indicatorWidth","_width","lastPointX","lastPointY","_handleMoveEvents","_pos","snapOption","_snapOption$easing","RUNWAY_ITEMS","RUNWAY_ITEMS_OPPOSITE","ANIMATION_DURATION_MS","DEFAULT_SCROLL_RUNWAY","infiniteMixin","infiniteScroller","InfiniteScroller","isTombstoneNode","createTombstone","fetch","firstAttachedItem","lastAttachedItem","anchorScrollTop","anchorItem","tombstoneHeight","tombstoneWidth","tombstones","tombstonesAnimationHandlers","loadedItems","requestInProgress","hasMore","wrapperEl","scrollerEl","onScroll","onResize","_onResizeHandler","delta","_calculateAnchoredItem","lastScreenItem","fill","maybeRequestContent","tombstone","attachContent","_this3","itemsNeeded","addContent","tombstoneLen","_removeTombstones","curPos","_fixScrollPosition","_setupAnimations","_addItem","unusedNodes","_collectUnusedNodes","tombstoneAnimations","_createDOMNodes","_cleanupUnusedNodes","_cacheNodeSize","resetMore","markIndex","itemLen","currentNode","currentData","zIndex","_getTombStone","isTombstone","_this4","animation","_animation","tombstoneNode","tombstoneAnimationsHandler","_animation2","initialAnchor","ceil","Version","Scroll","App"],"mappings":"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","file":"main.67df5253.map","sourceRoot":"..","sourcesContent":["/*!\n * Vue.js v2.6.8\n * (c) 2014-2019 Evan You\n * Released under the MIT License.\n */\n/*  */\n\nvar emptyObject = Object.freeze({});\n\n// These helpers produce better VM code in JS engines due to their\n// explicitness and function inlining.\nfunction isUndef (v) {\n  return v === undefined || v === null\n}\n\nfunction isDef (v) {\n  return v !== undefined && v !== null\n}\n\nfunction isTrue (v) {\n  return v === true\n}\n\nfunction isFalse (v) {\n  return v === false\n}\n\n/**\n * Check if value is primitive.\n */\nfunction isPrimitive (value) {\n  return (\n    typeof value === 'string' ||\n    typeof value === 'number' ||\n    // $flow-disable-line\n    typeof value === 'symbol' ||\n    typeof value === 'boolean'\n  )\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject (obj) {\n  return obj !== null && typeof obj === 'object'\n}\n\n/**\n * Get the raw type string of a value, e.g., [object Object].\n */\nvar _toString = Object.prototype.toString;\n\nfunction toRawType (value) {\n  return _toString.call(value).slice(8, -1)\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nfunction isPlainObject (obj) {\n  return _toString.call(obj) === '[object Object]'\n}\n\nfunction isRegExp (v) {\n  return _toString.call(v) === '[object RegExp]'\n}\n\n/**\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}\n\nfunction isPromise (val) {\n  return (\n    isDef(val) &&\n    typeof val.then === 'function' &&\n    typeof val.catch === 'function'\n  )\n}\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction toString (val) {\n  return val == null\n    ? ''\n    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)\n      ? JSON.stringify(val, null, 2)\n      : String(val)\n}\n\n/**\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 : n\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap (\n  str,\n  expectsLowerCase\n) {\n  var map = Object.create(null);\n  var list = str.split(',');\n  for (var i = 0; i < list.length; i++) {\n    map[list[i]] = true;\n  }\n  return expectsLowerCase\n    ? function (val) { return map[val.toLowerCase()]; }\n    : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Check if an attribute is a reserved attribute.\n */\nvar isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');\n\n/**\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}\n\n/**\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}\n\n/**\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[str];\n    return hit || (cache[str] = fn(str))\n  })\n}\n\n/**\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});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = cached(function (str) {\n  return str.charAt(0).toUpperCase() + str.slice(1)\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /\\B([A-Z])/g;\nvar hyphenate = cached(function (str) {\n  return str.replace(hyphenateRE, '-$1').toLowerCase()\n});\n\n/**\n * Simple bind polyfill for environments that do not support it,\n * e.g., PhantomJS 1.x. Technically, we don't need this anymore\n * since native bind is now performant enough in most browsers.\n * But removing it would mean breaking code that was able to run in\n * PhantomJS 1.x, so this must be kept for backward compatibility.\n */\n\n/* istanbul ignore next */\nfunction polyfillBind (fn, ctx) {\n  function boundFn (a) {\n    var l = arguments.length;\n    return l\n      ? l > 1\n        ? fn.apply(ctx, arguments)\n        : fn.call(ctx, a)\n      : fn.call(ctx)\n  }\n\n  boundFn._length = fn.length;\n  return boundFn\n}\n\nfunction nativeBind (fn, ctx) {\n  return fn.bind(ctx)\n}\n\nvar bind = Function.prototype.bind\n  ? nativeBind\n  : polyfillBind;\n\n/**\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[i] = list[i + start];\n  }\n  return ret\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend (to, _from) {\n  for (var key in _from) {\n    to[key] = _from[key];\n  }\n  return to\n}\n\n/**\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[i]) {\n      extend(res, arr[i]);\n    }\n  }\n  return res\n}\n\n/* eslint-disable no-unused-vars */\n\n/**\n * Perform no operation.\n * Stubbing args to make Flow happy without leaving useless transpiled code\n * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).\n */\nfunction noop (a, b, c) {}\n\n/**\n * Always return false.\n */\nvar no = function (a, b, c) { return false; };\n\n/* eslint-enable no-unused-vars */\n\n/**\n * Return the same value.\n */\nvar identity = function (_) { return _; };\n\n/**\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[i])\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[key], b[key])\n        })\n      } else {\n        /* istanbul ignore next */\n        return false\n      }\n    } catch (e) {\n      /* istanbul ignore next */\n      return false\n    }\n  } else if (!isObjectA && !isObjectB) {\n    return String(a) === String(b)\n  } else {\n    return false\n  }\n}\n\n/**\n * Return the first index at which a loosely equal value can be\n * found in the array (if value is a plain object, the array must\n * 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[i], val)) { return i }\n  }\n  return -1\n}\n\n/**\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}\n\nvar SSR_ATTR = 'data-server-rendered';\n\nvar ASSET_TYPES = [\n  'component',\n  'directive',\n  'filter'\n];\n\nvar 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];\n\n/*  */\n\n\n\nvar config = ({\n  /**\n   * Option merge strategies (used in core/util/options)\n   */\n  // $flow-disable-line\n  optionMergeStrategies: Object.create(null),\n\n  /**\n   * Whether to suppress warnings.\n   */\n  silent: false,\n\n  /**\n   * Show production mode tip message on boot?\n   */\n  productionTip: process.env.NODE_ENV !== 'production',\n\n  /**\n   * Whether to enable devtools\n   */\n  devtools: process.env.NODE_ENV !== 'production',\n\n  /**\n   * Whether to record perf\n   */\n  performance: false,\n\n  /**\n   * Error handler for watcher errors\n   */\n  errorHandler: null,\n\n  /**\n   * Warn handler for watcher warns\n   */\n  warnHandler: null,\n\n  /**\n   * Ignore certain custom elements\n   */\n  ignoredElements: [],\n\n  /**\n   * Custom user key aliases for v-on\n   */\n  // $flow-disable-line\n  keyCodes: Object.create(null),\n\n  /**\n   * Check if a tag is reserved so that it cannot be registered as a\n   * component. This is platform-dependent and may be overwritten.\n   */\n  isReservedTag: no,\n\n  /**\n   * Check if an attribute is reserved so that it cannot be used as a component\n   * prop. This is platform-dependent and may be overwritten.\n   */\n  isReservedAttr: no,\n\n  /**\n   * Check if a tag is an unknown element.\n   * Platform-dependent.\n   */\n  isUnknownElement: no,\n\n  /**\n   * Get the namespace of an element\n   */\n  getTagNamespace: noop,\n\n  /**\n   * Parse the real tag name for the specific platform.\n   */\n  parsePlatformTagName: identity,\n\n  /**\n   * Check if an attribute must be bound using property, e.g. value\n   * Platform-dependent.\n   */\n  mustUseProp: no,\n\n  /**\n   * Perform updates asynchronously. Intended to be used by Vue Test Utils\n   * This will significantly reduce performance if set to false.\n   */\n  async: true,\n\n  /**\n   * Exposed for legacy reasons\n   */\n  _lifecycleHooks: LIFECYCLE_HOOKS\n});\n\n/*  */\n\n/**\n * unicode letters used for parsing html tags, component names and property paths.\n * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname\n * skipping \\u10000-\\uEFFFF due to it freezing up PhantomJS\n */\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/;\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved (str) {\n  var c = (str + '').charCodeAt(0);\n  return c === 0x24 || c === 0x5F\n}\n\n/**\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: true\n  });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = new RegExp((\"[^\" + (unicodeRegExp.source) + \".$_\\\\d]\"));\nfunction parsePath (path) {\n  if (bailRE.test(path)) {\n    return\n  }\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[i]];\n    }\n    return obj\n  }\n}\n\n/*  */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar 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+)/);\n\n// Firefox has a \"watch\" function on Object.prototype...\nvar nativeWatch = ({}).watch;\n\nvar 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    })); // https://github.com/facebook/flow/issues/285\n    window.addEventListener('test-passive', null, opts);\n  } catch (e) {}\n}\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _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 avoid\n      // Webpack shimming the process\n      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';\n    } else {\n      _isServer = false;\n    }\n  }\n  return _isServer\n};\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative (Ctor) {\n  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())\n}\n\nvar hasSymbol =\n  typeof Symbol !== 'undefined' && isNative(Symbol) &&\n  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);\n\nvar _Set;\n/* istanbul ignore if */ // $flow-disable-line\nif (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[key] === true\n    };\n    Set.prototype.add = function add (key) {\n      this.set[key] = true;\n    };\n    Set.prototype.clear = function clear () {\n      this.set = Object.create(null);\n    };\n\n    return Set;\n  }());\n}\n\n/*  */\n\nvar warn = noop;\nvar tip = noop;\nvar generateComponentTrace = (noop); // work around flow check\nvar formatComponentName = (noop);\n\nif (process.env.NODE_ENV !== 'production') {\n  var hasConsole = typeof console !== 'undefined';\n  var classifyRE = /(?:^|[-_])(\\w)/g;\n  var classify = function (str) { return str\n    .replace(classifyRE, function (c) { return c.toUpperCase(); })\n    .replace(/[-_]/g, ''); };\n\n  warn = function (msg, vm) {\n    var trace = vm ? generateComponentTrace(vm) : '';\n\n    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  };\n\n  tip = function (msg, vm) {\n    if (hasConsole && (!config.silent)) {\n      console.warn(\"[Vue tip]: \" + msg + (\n        vm ? generateComponentTrace(vm) : ''\n      ));\n    }\n  };\n\n  formatComponentName = function (vm, includeFile) {\n    if (vm.$root === vm) {\n      return '<Root>'\n    }\n    var options = typeof vm === 'function' && vm.cid != null\n      ? vm.options\n      : vm._isVue\n        ? vm.$options || vm.constructor.options\n        : 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[1];\n    }\n\n    return (\n      (name ? (\"<\" + (classify(name)) + \">\") : \"<Anonymous>\") +\n      (file && includeFile !== false ? (\" at \" + file) : '')\n    )\n  };\n\n  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 res\n  };\n\n  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            continue\n          } 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' + tree\n        .map(function (vm, i) { return (\"\" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)\n            ? ((formatComponentName(vm[0])) + \"... (\" + (vm[1]) + \" recursive calls)\")\n            : formatComponentName(vm))); })\n        .join('\\n')\n    } else {\n      return (\"\\n\\n(found in \" + (formatComponentName(vm)) + \")\")\n    }\n  };\n}\n\n/*  */\n\nvar uid = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n  this.id = uid++;\n  this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n  this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n  remove(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n  if (Dep.target) {\n    Dep.target.addDep(this);\n  }\n};\n\nDep.prototype.notify = function notify () {\n  // stabilize the subscriber list first\n  var subs = this.subs.slice();\n  if (process.env.NODE_ENV !== 'production' && !config.async) {\n    // subs aren't sorted in scheduler if not running async\n    // we need to sort them now to make sure they fire in correct\n    // order\n    subs.sort(function (a, b) { return a.id - b.id; });\n  }\n  for (var i = 0, l = subs.length; i < l; i++) {\n    subs[i].update();\n  }\n};\n\n// The current target watcher being evaluated.\n// This is globally unique because only one watcher\n// can be evaluated at a time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (target) {\n  targetStack.push(target);\n  Dep.target = target;\n}\n\nfunction popTarget () {\n  targetStack.pop();\n  Dep.target = targetStack[targetStack.length - 1];\n}\n\n/*  */\n\nvar VNode = function VNode (\n  tag,\n  data,\n  children,\n  text,\n  elm,\n  context,\n  componentOptions,\n  asyncFactory\n) {\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};\n\nvar prototypeAccessors = { child: { configurable: true } };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n  return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function (text) {\n  if ( text === void 0 ) text = '';\n\n  var node = new VNode();\n  node.text = text;\n  node.isComment = true;\n  return node\n};\n\nfunction createTextVNode (val) {\n  return new VNode(undefined, undefined, undefined, String(val))\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode (vnode) {\n  var cloned = new VNode(\n    vnode.tag,\n    vnode.data,\n    // #7975\n    // clone children array to avoid mutating original in case of cloning\n    // a child.\n    vnode.children && vnode.children.slice(),\n    vnode.text,\n    vnode.elm,\n    vnode.context,\n    vnode.componentOptions,\n    vnode.asyncFactory\n  );\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 cloned\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);\n\nvar methodsToPatch = [\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse'\n];\n\n/**\n * Intercept mutating methods and emit events\n */\nmethodsToPatch.forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  def(arrayMethods, method, function mutator () {\n    var args = [], len = arguments.length;\n    while ( len-- ) args[ len ] = arguments[ len ];\n\n    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        break\n      case 'splice':\n        inserted = args.slice(2);\n        break\n    }\n    if (inserted) { ob.observeArray(inserted); }\n    // notify change\n    ob.dep.notify();\n    return result\n  });\n});\n\n/*  */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * In some cases we may want to disable observation inside a component's\n * update computation.\n */\nvar shouldObserve = true;\n\nfunction toggleObserving (value) {\n  shouldObserve = value;\n}\n\n/**\n * Observer class that is attached to each observed\n * object. Once attached, the observer converts the target\n * object's property keys into getter/setters that\n * 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};\n\n/**\n * Walk through all properties and convert them into\n * getter/setters. This method should only be called when\n * 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[i]);\n  }\n};\n\n/**\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[i]);\n  }\n};\n\n// helpers\n\n/**\n * Augment a target Object or Array by intercepting\n * 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}\n\n/**\n * Augment a target Object or Array by defining\n * 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[i];\n    def(target, key, src[key]);\n  }\n}\n\n/**\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    return\n  }\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._isVue\n  ) {\n    ob = new Observer(value);\n  }\n  if (asRootData && ob) {\n    ob.vmCount++;\n  }\n  return ob\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive$$1 (\n  obj,\n  key,\n  val,\n  customSetter,\n  shallow\n) {\n  var dep = new Dep();\n\n  var property = Object.getOwnPropertyDescriptor(obj, key);\n  if (property && property.configurable === false) {\n    return\n  }\n\n  // cater for pre-defined getter/setters\n  var getter = property && property.get;\n  var setter = property && property.set;\n  if ((!getter || setter) && arguments.length === 2) {\n    val = obj[key];\n  }\n\n  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 value\n    },\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        return\n      }\n      /* eslint-enable no-self-compare */\n      if (process.env.NODE_ENV !== 'production' && customSetter) {\n        customSetter();\n      }\n      // #7981: for accessor properties without setter\n      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}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * 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 val\n  }\n  if (key in target && !(key in Object.prototype)) {\n    target[key] = val;\n    return val\n  }\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 val\n  }\n  if (!ob) {\n    target[key] = val;\n    return val\n  }\n  defineReactive$$1(ob.value, key, val);\n  ob.dep.notify();\n  return val\n}\n\n/**\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    return\n  }\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    return\n  }\n  if (!hasOwn(target, key)) {\n    return\n  }\n  delete target[key];\n  if (!ob) {\n    return\n  }\n  ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * 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[i];\n    e && e.__ob__ && e.__ob__.dep.depend();\n    if (Array.isArray(e)) {\n      dependArray(e);\n    }\n  }\n}\n\n/*  */\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\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}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData (to, from) {\n  if (!from) { return to }\n  var key, toVal, fromVal;\n\n  var keys = hasSymbol\n    ? Reflect.ownKeys(from)\n    : Object.keys(from);\n\n  for (var i = 0; i < keys.length; i++) {\n    key = keys[i];\n    // in case the object is already observed...\n    if (key === '__ob__') { continue }\n    toVal = to[key];\n    fromVal = from[key];\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 to\n}\n\n/**\n * Data\n */\nfunction mergeDataOrFn (\n  parentVal,\n  childVal,\n  vm\n) {\n  if (!vm) {\n    // in a Vue.extend merge, both should be functions\n    if (!childVal) {\n      return parentVal\n    }\n    if (!parentVal) {\n      return childVal\n    }\n    // when parentVal & childVal are both present,\n    // we need to return a function that returns the\n    // merged result of both functions... no need to\n    // check if parentVal is a function here because\n    // 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) : parentVal\n      )\n    }\n  } else {\n    return function mergedInstanceDataFn () {\n      // instance merge\n      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 defaultData\n      }\n    }\n  }\n}\n\nstrats.data = function (\n  parentVal,\n  childVal,\n  vm\n) {\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        vm\n      );\n\n      return parentVal\n    }\n    return mergeDataOrFn(parentVal, childVal)\n  }\n\n  return mergeDataOrFn(parentVal, childVal, vm)\n};\n\n/**\n * Hooks and props are merged as arrays.\n */\nfunction mergeHook (\n  parentVal,\n  childVal\n) {\n  var res = childVal\n    ? parentVal\n      ? parentVal.concat(childVal)\n      : Array.isArray(childVal)\n        ? childVal\n        : [childVal]\n    : parentVal;\n  return res\n    ? dedupeHooks(res)\n    : res\n}\n\nfunction dedupeHooks (hooks) {\n  var res = [];\n  for (var i = 0; i < hooks.length; i++) {\n    if (res.indexOf(hooks[i]) === -1) {\n      res.push(hooks[i]);\n    }\n  }\n  return res\n}\n\nLIFECYCLE_HOOKS.forEach(function (hook) {\n  strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets (\n  parentVal,\n  childVal,\n  vm,\n  key\n) {\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 res\n  }\n}\n\nASSET_TYPES.forEach(function (type) {\n  strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (\n  parentVal,\n  childVal,\n  vm,\n  key\n) {\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[key$1];\n    var child = childVal[key$1];\n    if (parent && !Array.isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key$1] = parent\n      ? parent.concat(child)\n      : Array.isArray(child) ? child : [child];\n  }\n  return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.inject =\nstrats.computed = function (\n  parentVal,\n  childVal,\n  vm,\n  key\n) {\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 ret\n};\nstrats.provide = mergeDataOrFn;\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n  return childVal === undefined\n    ? parentVal\n    : childVal\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents (options) {\n  for (var key in options.components) {\n    validateComponentName(key);\n  }\n}\n\nfunction validateComponentName (name) {\n  if (!new RegExp((\"^[a-zA-Z][\\\\-\\\\.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: ' + name\n    );\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * 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[i];\n      if (typeof val === 'string') {\n        name = camelize(val);\n        res[name] = { 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[key];\n      name = camelize(key);\n      res[name] = isPlainObject(val)\n        ? val\n        : { 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      vm\n    );\n  }\n  options.props = res;\n}\n\n/**\n * Normalize all injections into Object-based format\n */\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[i]] = { from: inject[i] };\n    }\n  } else if (isPlainObject(inject)) {\n    for (var key in inject) {\n      var val = inject[key];\n      normalized[key] = 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      vm\n    );\n  }\n}\n\n/**\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[key];\n      if (typeof def$$1 === 'function') {\n        dirs[key] = { bind: def$$1, update: def$$1 };\n      }\n    }\n  }\n}\n\nfunction 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      vm\n    );\n  }\n}\n\n/**\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  vm\n) {\n  if (process.env.NODE_ENV !== 'production') {\n    checkComponents(child);\n  }\n\n  if (typeof child === 'function') {\n    child = child.options;\n  }\n\n  normalizeProps(child, vm);\n  normalizeInject(child, vm);\n  normalizeDirectives(child);\n\n  // Apply extends and mixins on the child options,\n  // but only if it is a raw options object that isn't\n  // 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[i], vm);\n      }\n    }\n  }\n\n  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[key] || defaultStrat;\n    options[key] = strat(parent[key], child[key], vm, key);\n  }\n  return options\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset (\n  options,\n  type,\n  id,\n  warnMissing\n) {\n  /* istanbul ignore if */\n  if (typeof id !== 'string') {\n    return\n  }\n  var assets = options[type];\n  // check local registration variations first\n  if (hasOwn(assets, id)) { return assets[id] }\n  var camelizedId = camelize(id);\n  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n  var PascalCaseId = capitalize(camelizedId);\n  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n  // fallback to prototype chain\n  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {\n    warn(\n      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n      options\n    );\n  }\n  return res\n}\n\n/*  */\n\n\n\nfunction validateProp (\n  key,\n  propOptions,\n  propsData,\n  vm\n) {\n  var prop = propOptions[key];\n  var absent = !hasOwn(propsData, key);\n  var value = propsData[key];\n  // boolean casting\n  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 if\n      // boolean has higher priority\n      var stringIndex = getTypeIndex(String, prop.type);\n      if (stringIndex < 0 || booleanIndex < stringIndex) {\n        value = true;\n      }\n    }\n  }\n  // check default value\n  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 props\n    !(false)\n  ) {\n    assertProp(prop, key, value, vm, absent);\n  }\n  return value\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue (vm, prop, key) {\n  // no default, return undefined\n  if (!hasOwn(prop, 'default')) {\n    return undefined\n  }\n  var def = prop.default;\n  // warn against non-factory defaults for Object & Array\n  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      vm\n    );\n  }\n  // the raw prop value was also undefined from previous render,\n  // return previous default value to avoid unnecessary watcher trigger\n  if (vm && vm.$options.propsData &&\n    vm.$options.propsData[key] === undefined &&\n    vm._props[key] !== undefined\n  ) {\n    return vm._props[key]\n  }\n  // call factory function for non-Function types\n  // a value is Function if its prototype is function even across different execution context\n  return typeof def === 'function' && getType(prop.type) !== 'Function'\n    ? def.call(vm)\n    : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n  prop,\n  name,\n  value,\n  vm,\n  absent\n) {\n  if (prop.required && absent) {\n    warn(\n      'Missing required prop: \"' + name + '\"',\n      vm\n    );\n    return\n  }\n  if (value == null && !prop.required) {\n    return\n  }\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[i]);\n      expectedTypes.push(assertedType.expectedType || '');\n      valid = assertedType.valid;\n    }\n  }\n\n  if (!valid) {\n    warn(\n      getInvalidTypeMessage(name, value, expectedTypes),\n      vm\n    );\n    return\n  }\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        vm\n      );\n    }\n  }\n}\n\nvar simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;\n\nfunction 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 objects\n    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: expectedType\n  }\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType (fn) {\n  var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n  return match ? match[1] : ''\n}\n\nfunction isSameType (a, b) {\n  return getType(a) === getType(b)\n}\n\nfunction getTypeIndex (type, expectedTypes) {\n  if (!Array.isArray(expectedTypes)) {\n    return isSameType(expectedTypes, type) ? 0 : -1\n  }\n  for (var i = 0, len = expectedTypes.length; i < len; i++) {\n    if (isSameType(expectedTypes[i], type)) {\n      return i\n    }\n  }\n  return -1\n}\n\nfunction 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[0];\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 value\n  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 value\n  if (isExplicable(receivedType)) {\n    message += \"with value \" + receivedValue + \".\";\n  }\n  return message\n}\n\nfunction 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}\n\nfunction isExplicable (value) {\n  var explicitTypes = ['string', 'number', 'boolean'];\n  return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })\n}\n\nfunction isBoolean () {\n  var args = [], len = arguments.length;\n  while ( len-- ) args[ len ] = arguments[ len ];\n\n  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })\n}\n\n/*  */\n\nfunction handleError (err, vm, info) {\n  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.\n  // See: https://github.com/vuejs/vuex/issues/1505\n  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[i].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}\n\nfunction invokeWithErrorHandling (\n  handler,\n  context,\n  args,\n  vm,\n  info\n) {\n  var res;\n  try {\n    res = args ? handler.apply(context, args) : handler.call(context);\n    if (res && !res._isVue && isPromise(res)) {\n      // issue #9511\n      // reassign to res to avoid catch triggering multiple times when nested calls\n      res = res.catch(function (e) { return handleError(e, vm, info + \" (Promise/async)\"); });\n    }\n  } catch (e) {\n    handleError(e, vm, info);\n  }\n  return res\n}\n\nfunction 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 twice\n      if (e !== err) {\n        logError(e, null, 'config.errorHandler');\n      }\n    }\n  }\n  logError(err, vm, info);\n}\n\nfunction 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 err\n  }\n}\n\n/*  */\n\nvar isUsingMicroTask = false;\n\nvar callbacks = [];\nvar pending = false;\n\nfunction 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[i]();\n  }\n}\n\n// 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 repaint\n// (e.g. #6813, out-in transitions).\n// Also, using (macro) tasks in event handler would cause some weird behaviors\n// 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 scenarios\n// where microtasks have too high a priority and fire in between supposedly\n// sequential events (e.g. #4521, #6690, which have workarounds)\n// or even between bubbling of the same event (#6566).\nvar timerFunc;\n\n// The nextTick behavior leverages the microtask queue, which can be accessed\n// via either native Promise.then or MutationObserver.\n// MutationObserver has wider support, however it is seriously bugged in\n// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n// completely stops working after triggering a few times... so, if native\n// 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, but\n    // it can get stuck in a weird state where callbacks are pushed into the\n    // microtask queue but the queue isn't being flushed, until the browser\n    // needs to do some other work, e.g. handle a timer. Therefore we can\n    // \"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.x\n  MutationObserver.toString() === '[object MutationObserverConstructor]'\n)) {\n  // Use MutationObserver where native Promise is not available,\n  // e.g. PhantomJS, iOS7, Android 4.4\n  // (#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: true\n  });\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  // Techinically 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}\n\nfunction 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-line\n  if (!cb && typeof Promise !== 'undefined') {\n    return new Promise(function (resolve) {\n      _resolve = resolve;\n    })\n  }\n}\n\n/*  */\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (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/Browserify\n  );\n\n  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: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',\n      target\n    );\n  };\n\n  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: https://vuejs.org/v2/api/#data',\n      target\n    );\n  };\n\n  var hasProxy =\n    typeof Proxy !== 'undefined' && isNative(Proxy);\n\n  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 false\n        } else {\n          target[key] = value;\n          return true\n        }\n      }\n    });\n  }\n\n  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 || !isAllowed\n    }\n  };\n\n  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 target[key]\n    }\n  };\n\n  initProxy = function initProxy (vm) {\n    if (hasProxy) {\n      // determine which proxy handler to use\n      var options = vm.$options;\n      var handlers = options.render && options.render._withStripped\n        ? getHandler\n        : hasHandler;\n      vm._renderProxy = new Proxy(vm, handlers);\n    } else {\n      vm._renderProxy = vm;\n    }\n  };\n}\n\n/*  */\n\nvar seenObjects = new _Set();\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nfunction traverse (val) {\n  _traverse(val, seenObjects);\n  seenObjects.clear();\n}\n\nfunction _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    return\n  }\n  if (val.__ob__) {\n    var depId = val.__ob__.dep.id;\n    if (seen.has(depId)) {\n      return\n    }\n    seen.add(depId);\n  }\n  if (isA) {\n    i = val.length;\n    while (i--) { _traverse(val[i], seen); }\n  } else {\n    keys = Object.keys(val);\n    i = keys.length;\n    while (i--) { _traverse(val[keys[i]], seen); }\n  }\n}\n\nvar mark;\nvar measure;\n\nif (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.clearMeasures\n  ) {\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}\n\n/*  */\n\nvar 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 first\n  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: passive\n  }\n});\n\nfunction createFnInvoker (fns, vm) {\n  function invoker () {\n    var arguments$1 = arguments;\n\n    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[i], null, arguments$1, vm, \"v-on handler\");\n      }\n    } else {\n      // return handler return value for single handlers\n      return invokeWithErrorHandling(fns, null, arguments, vm, \"v-on handler\")\n    }\n  }\n  invoker.fns = fns;\n  return invoker\n}\n\nfunction updateListeners (\n  on,\n  oldOn,\n  add,\n  remove$$1,\n  createOnceHandler,\n  vm\n) {\n  var name, def$$1, cur, old, event;\n  for (name in on) {\n    def$$1 = cur = on[name];\n    old = oldOn[name];\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        vm\n      );\n    } else if (isUndef(old)) {\n      if (isUndef(cur.fns)) {\n        cur = on[name] = createFnInvoker(cur, vm);\n      }\n      if (isTrue(event.once)) {\n        cur = on[name] = 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[name] = old;\n    }\n  }\n  for (name in oldOn) {\n    if (isUndef(on[name])) {\n      event = normalizeEvent(name);\n      remove$$1(event.name, oldOn[name], event.capture);\n    }\n  }\n}\n\n/*  */\n\nfunction 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[hookKey];\n\n  function wrappedHook () {\n    hook.apply(this, arguments);\n    // important: remove merged hook to ensure it's called only once\n    // and prevent memory leak\n    remove(invoker.fns, wrappedHook);\n  }\n\n  if (isUndef(oldHook)) {\n    // no existing hook\n    invoker = createFnInvoker([wrappedHook]);\n  } else {\n    /* istanbul ignore if */\n    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {\n      // already a merged invoker\n      invoker = oldHook;\n      invoker.fns.push(wrappedHook);\n    } else {\n      // existing plain hook\n      invoker = createFnInvoker([oldHook, wrappedHook]);\n    }\n  }\n\n  invoker.merged = true;\n  def[hookKey] = invoker;\n}\n\n/*  */\n\nfunction extractPropsFromVNodeData (\n  data,\n  Ctor,\n  tag\n) {\n  // we are only extracting raw values here.\n  // validation and default values are handled in the child\n  // component itself.\n  var propOptions = Ctor.options.props;\n  if (isUndef(propOptions)) {\n    return\n  }\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 res\n}\n\nfunction checkProp (\n  res,\n  hash,\n  key,\n  altKey,\n  preserve\n) {\n  if (isDef(hash)) {\n    if (hasOwn(hash, key)) {\n      res[key] = hash[key];\n      if (!preserve) {\n        delete hash[key];\n      }\n      return true\n    } else if (hasOwn(hash, altKey)) {\n      res[key] = hash[altKey];\n      if (!preserve) {\n        delete hash[altKey];\n      }\n      return true\n    }\n  }\n  return false\n}\n\n/*  */\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// normalization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// 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[i])) {\n      return Array.prototype.concat.apply([], children)\n    }\n  }\n  return children\n}\n\n// 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 user\n// with hand-written render functions / JSX. In such cases a full normalization\n// 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      : undefined\n}\n\nfunction isTextNode (node) {\n  return isDef(node) && isDef(node.text) && isFalse(node.isComment)\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n  var res = [];\n  var i, c, lastIndex, last;\n  for (i = 0; i < children.length; i++) {\n    c = children[i];\n    if (isUndef(c) || typeof c === 'boolean') { continue }\n    lastIndex = res.length - 1;\n    last = res[lastIndex];\n    //  nested\n    if (Array.isArray(c)) {\n      if (c.length > 0) {\n        c = normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i));\n        // merge adjacent text nodes\n        if (isTextNode(c[0]) && isTextNode(last)) {\n          res[lastIndex] = createTextVNode(last.text + (c[0]).text);\n          c.shift();\n        }\n        res.push.apply(res, c);\n      }\n    } else if (isPrimitive(c)) {\n      if (isTextNode(last)) {\n        // merge adjacent text nodes\n        // this is necessary for SSR hydration because text nodes are\n        // essentially merged when rendered to HTML strings\n        res[lastIndex] = createTextVNode(last.text + c);\n      } else if (c !== '') {\n        // convert primitive to vnode\n        res.push(createTextVNode(c));\n      }\n    } else {\n      if (isTextNode(c) && isTextNode(last)) {\n        // merge adjacent text nodes\n        res[lastIndex] = 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(c);\n      }\n    }\n  }\n  return res\n}\n\n/*  */\n\nfunction 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}\n\nfunction 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[key], 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            vm\n          );\n        });\n      } else {\n        defineReactive$$1(vm, key, result[key]);\n      }\n    });\n    toggleObserving(true);\n  }\n}\n\nfunction resolveInject (inject, vm) {\n  if (inject) {\n    // inject is :any because flow is not smart enough to figure out cached\n    var result = Object.create(null);\n    var keys = hasSymbol\n      ? Reflect.ownKeys(inject)\n      : Object.keys(inject);\n\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i];\n      // #6574 in case the inject object is observed...\n      if (key === '__ob__') { continue }\n      var provideKey = inject[key].from;\n      var source = vm;\n      while (source) {\n        if (source._provided && hasOwn(source._provided, provideKey)) {\n          result[key] = source._provided[provideKey];\n          break\n        }\n        source = source.$parent;\n      }\n      if (!source) {\n        if ('default' in inject[key]) {\n          var provideDefault = inject[key].default;\n          result[key] = 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 result\n  }\n}\n\n/*  */\n\n\n\n/**\n * Runtime helper for resolving raw children VNodes into a slot object.\n */\nfunction resolveSlots (\n  children,\n  context\n) {\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[i];\n    var data = child.data;\n    // remove slot attribute if the node is resolved as a Vue slot node\n    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 the\n    // same context.\n    if ((child.context === context || child.fnContext === context) &&\n      data && data.slot != null\n    ) {\n      var name = data.slot;\n      var slot = (slots[name] || (slots[name] = []));\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 whitespace\n  for (var name$1 in slots) {\n    if (slots[name$1].every(isWhitespace)) {\n      delete slots[name$1];\n    }\n  }\n  return slots\n}\n\nfunction isWhitespace (node) {\n  return (node.isComment && !node.asyncFactory) || node.text === ' '\n}\n\n/*  */\n\nfunction normalizeScopedSlots (\n  slots,\n  normalSlots,\n  prevSlots\n) {\n  var res;\n  var isStable = slots ? !!slots.$stable : true;\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 change\n    return slots._normalized\n  } else if (\n    isStable &&\n    prevSlots &&\n    prevSlots !== emptyObject &&\n    key === prevSlots.$key &&\n    Object.keys(normalSlots).length === 0\n  ) {\n    // fast path 2: stable scoped slots w/ no normal slots to proxy,\n    // only need to normalize once\n    return prevSlots\n  } else {\n    res = {};\n    for (var key$1 in slots) {\n      if (slots[key$1] && key$1[0] !== '$') {\n        res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);\n      }\n    }\n  }\n  // expose normal slots on scopedSlots\n  for (var key$2 in normalSlots) {\n    if (!(key$2 in res)) {\n      res[key$2] = proxyNormalSlot(normalSlots, key$2);\n    }\n  }\n  // avoriaz seems to mock a non-extensible $scopedSlots object\n  // and when that is passed down this would cause an error\n  if (slots && Object.isExtensible(slots)) {\n    (slots)._normalized = res;\n  }\n  def(res, '$stable', isStable);\n  def(res, '$key', key);\n  return res\n}\n\nfunction 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 vnode\n      : normalizeChildren(res);\n    return res && res.length === 0\n      ? undefined\n      : res\n  };\n  // this is a slot using the new v-slot syntax without scope. although it is\n  // compiled as a scoped slot, render fn users would expect it to be present\n  // 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: true\n    });\n  }\n  return normalized\n}\n\nfunction proxyNormalSlot(slots, key) {\n  return function () { return slots[key]; }\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering v-for lists.\n */\nfunction renderList (\n  val,\n  render\n) {\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[i] = render(val[i], i);\n    }\n  } else if (typeof val === 'number') {\n    ret = new Array(val);\n    for (i = 0; i < val; i++) {\n      ret[i] = render(i + 1, i);\n    }\n  } else if (isObject(val)) {\n    if (hasSymbol && val[Symbol.iterator]) {\n      ret = [];\n      var iterator = val[Symbol.iterator]();\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[i];\n        ret[i] = render(val[key], key, i);\n      }\n    }\n  }\n  if (!isDef(ret)) {\n    ret = [];\n  }\n  (ret)._isVList = true;\n  return ret\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering <slot>\n */\nfunction renderSlot (\n  name,\n  fallback,\n  props,\n  bindObject\n) {\n  var scopedSlotFn = this.$scopedSlots[name];\n  var nodes;\n  if (scopedSlotFn) { // scoped slot\n    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          this\n        );\n      }\n      props = extend(extend({}, bindObject), props);\n    }\n    nodes = scopedSlotFn(props) || fallback;\n  } else {\n    nodes = this.$slots[name] || fallback;\n  }\n\n  var target = props && props.slot;\n  if (target) {\n    return this.$createElement('template', { slot: target }, nodes)\n  } else {\n    return nodes\n  }\n}\n\n/*  */\n\n/**\n * Runtime helper for resolving filters\n */\nfunction resolveFilter (id) {\n  return resolveAsset(this.$options, 'filters', id, true) || identity\n}\n\n/*  */\n\nfunction isKeyNotMatch (expect, actual) {\n  if (Array.isArray(expect)) {\n    return expect.indexOf(actual) === -1\n  } else {\n    return expect !== actual\n  }\n}\n\n/**\n * Runtime helper for checking keyCodes from config.\n * exposed as Vue.prototype._k\n * passing in eventKeyName as last argument separately for backwards compat\n */\nfunction checkKeyCodes (\n  eventKeyCode,\n  key,\n  builtInKeyCode,\n  eventKeyName,\n  builtInKeyName\n) {\n  var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;\n  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {\n    return isKeyNotMatch(builtInKeyName, eventKeyName)\n  } else if (mappedKeyCode) {\n    return isKeyNotMatch(mappedKeyCode, eventKeyCode)\n  } else if (eventKeyName) {\n    return hyphenate(eventKeyName) !== key\n  }\n}\n\n/*  */\n\n/**\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  isSync\n) {\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        this\n      );\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        if (!(key in hash) && !(camelizedKey in hash)) {\n          hash[key] = value[key];\n\n          if (isSync) {\n            var on = data.on || (data.on = {});\n            on[(\"update:\" + camelizedKey)] = function ($event) {\n              value[key] = $event;\n            };\n          }\n        }\n      };\n\n      for (var key in value) loop( key );\n    }\n  }\n  return data\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering static trees.\n */\nfunction renderStatic (\n  index,\n  isInFor\n) {\n  var cached = this._staticTrees || (this._staticTrees = []);\n  var tree = cached[index];\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 tree\n  }\n  // otherwise, render a fresh tree.\n  tree = cached[index] = this.$options.staticRenderFns[index].call(\n    this._renderProxy,\n    null,\n    this // for render fns generated for functional component templates\n  );\n  markStatic(tree, (\"__static__\" + index), false);\n  return tree\n}\n\n/**\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  key\n) {\n  markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n  return tree\n}\n\nfunction markStatic (\n  tree,\n  key,\n  isOnce\n) {\n  if (Array.isArray(tree)) {\n    for (var i = 0; i < tree.length; i++) {\n      if (tree[i] && typeof tree[i] !== 'string') {\n        markStaticNode(tree[i], (key + \"_\" + i), isOnce);\n      }\n    }\n  } else {\n    markStaticNode(tree, key, isOnce);\n  }\n}\n\nfunction markStaticNode (node, key, isOnce) {\n  node.isStatic = true;\n  node.key = key;\n  node.isOnce = isOnce;\n}\n\n/*  */\n\nfunction 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        this\n      );\n    } else {\n      var on = data.on = data.on ? extend({}, data.on) : {};\n      for (var key in value) {\n        var existing = on[key];\n        var ours = value[key];\n        on[key] = existing ? [].concat(existing, ours) : ours;\n      }\n    }\n  }\n  return data\n}\n\n/*  */\n\nfunction resolveScopedSlots (\n  fns, // see flow/vnode\n  res,\n  // the following are added in 2.6\n  hasDynamicKeys,\n  contentHashKey\n) {\n  res = res || { $stable: !hasDynamicKeys };\n  for (var i = 0; i < fns.length; i++) {\n    var slot = fns[i];\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.$slots\n      if (slot.proxy) {\n        slot.fn.proxy = true;\n      }\n      res[slot.key] = slot.fn;\n    }\n  }\n  if (contentHashKey) {\n    (res).$key = contentHashKey;\n  }\n  return res\n}\n\n/*  */\n\nfunction bindDynamicKeys (baseObj, values) {\n  for (var i = 0; i < values.length; i += 2) {\n    var key = values[i];\n    if (typeof key === 'string' && key) {\n      baseObj[values[i]] = values[i + 1];\n    } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) {\n      // null is a speical value for explicitly removing a binding\n      warn(\n        (\"Invalid value for dynamic directive argument (expected string or null): \" + key),\n        this\n      );\n    }\n  }\n  return baseObj\n}\n\n// helper to dynamically append modifier runtime markers to event names.\n// ensure only append when value is already string, otherwise it will be cast\n// to string and cause the type check to miss.\nfunction prependModifier (value, symbol) {\n  return typeof value === 'string' ? symbol + value : value\n}\n\n/*  */\n\nfunction 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}\n\n/*  */\n\nfunction FunctionalRenderContext (\n  data,\n  props,\n  children,\n  parent,\n  Ctor\n) {\n  var this$1 = this;\n\n  var options = Ctor.options;\n  // ensure the createElement function in functional components\n  // gets a unique context - this is necessary for correct named slot check\n  var contextVm;\n  if (hasOwn(parent, '_uid')) {\n    contextVm = Object.create(parent);\n    // $flow-disable-line\n    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 the\n    // real context instance.\n    contextVm = parent;\n    // $flow-disable-line\n    parent = parent._original;\n  }\n  var isCompiled = isTrue(options._compiled);\n  var needNormalization = !isCompiled;\n\n  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.$slots\n  };\n\n  Object.defineProperty(this, 'scopedSlots', ({\n    enumerable: true,\n    get: function get () {\n      return normalizeScopedSlots(data.scopedSlots, this.slots())\n    }\n  }));\n\n  // support for compiled functional template\n  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  }\n\n  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 vnode\n    };\n  } else {\n    this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };\n  }\n}\n\ninstallRenderHelpers(FunctionalRenderContext.prototype);\n\nfunction createFunctionalComponent (\n  Ctor,\n  propsData,\n  data,\n  contextVm,\n  children\n) {\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[key] = 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  }\n\n  var renderContext = new FunctionalRenderContext(\n    data,\n    props,\n    children,\n    contextVm,\n    Ctor\n  );\n\n  var vnode = options.render.call(null, renderContext._c, renderContext);\n\n  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[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);\n    }\n    return res\n  }\n}\n\nfunction cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {\n  // #7817 clone node before setting fnContext, otherwise if the node is reused\n  // (e.g. it was from a cached normal slot) the fnContext causes named slots\n  // 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 clone\n}\n\nfunction mergeProps (to, from) {\n  for (var key in from) {\n    to[camelize(key)] = from[key];\n  }\n}\n\n/*  */\n\n/*  */\n\n/*  */\n\n/*  */\n\n// inline hooks to be invoked on component VNodes during patch\nvar componentVNodeHooks = {\n  init: function init (vnode, hydrating) {\n    if (\n      vnode.componentInstance &&\n      !vnode.componentInstance._isDestroyed &&\n      vnode.data.keepAlive\n    ) {\n      // kept-alive components, treat as a patch\n      var mountedNode = vnode; // work around flow\n      componentVNodeHooks.prepatch(mountedNode, mountedNode);\n    } else {\n      var child = vnode.componentInstance = createComponentInstanceForVnode(\n        vnode,\n        activeInstance\n      );\n      child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n    }\n  },\n\n  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 props\n      options.listeners, // updated listeners\n      vnode, // new parent vnode\n      options.children // new children\n    );\n  },\n\n  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#1212\n        // During updates, a kept-alive component's child components may\n        // change, so directly walking the tree here may call activated hooks\n        // on incorrect children. Instead we push them into a queue which will\n        // be processed after the whole patch process ended.\n        queueActivatedComponent(componentInstance);\n      } else {\n        activateChildComponent(componentInstance, true /* direct */);\n      }\n    }\n  },\n\n  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};\n\nvar hooksToMerge = Object.keys(componentVNodeHooks);\n\nfunction createComponent (\n  Ctor,\n  data,\n  context,\n  children,\n  tag\n) {\n  if (isUndef(Ctor)) {\n    return\n  }\n\n  var baseCtor = context.$options._base;\n\n  // plain options object: turn it into a constructor\n  if (isObject(Ctor)) {\n    Ctor = baseCtor.extend(Ctor);\n  }\n\n  // 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    return\n  }\n\n  // async component\n  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 rendered\n      // 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        tag\n      )\n    }\n  }\n\n  data = data || {};\n\n  // resolve constructor options in case global mixins are applied after\n  // component constructor creation\n  resolveConstructorOptions(Ctor);\n\n  // transform component v-model data into props & events\n  if (isDef(data.model)) {\n    transformModel(Ctor.options, data);\n  }\n\n  // extract props\n  var propsData = extractPropsFromVNodeData(data, Ctor, tag);\n\n  // functional component\n  if (isTrue(Ctor.options.functional)) {\n    return createFunctionalComponent(Ctor, propsData, data, context, children)\n  }\n\n  // extract listeners, since these needs to be treated as\n  // child component listeners instead of DOM listeners\n  var listeners = data.on;\n  // replace with listeners with .native modifier\n  // so it gets processed during parent component patch.\n  data.on = data.nativeOn;\n\n  if (isTrue(Ctor.options.abstract)) {\n    // abstract components do not keep anything\n    // other than props & listeners & slot\n\n    // work around flow\n    var slot = data.slot;\n    data = {};\n    if (slot) {\n      data.slot = slot;\n    }\n  }\n\n  // install component management hooks onto the placeholder node\n  installComponentHooks(data);\n\n  // return a placeholder vnode\n  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    asyncFactory\n  );\n\n  return vnode\n}\n\nfunction createComponentInstanceForVnode (\n  vnode, // we know it's MountedComponentVNode but flow doesn't\n  parent // activeInstance in lifecycle state\n) {\n  var options = {\n    _isComponent: true,\n    _parentVnode: vnode,\n    parent: parent\n  };\n  // check inline-template render functions\n  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}\n\nfunction installComponentHooks (data) {\n  var hooks = data.hook || (data.hook = {});\n  for (var i = 0; i < hooksToMerge.length; i++) {\n    var key = hooksToMerge[i];\n    var existing = hooks[key];\n    var toMerge = componentVNodeHooks[key];\n    if (existing !== toMerge && !(existing && existing._merged)) {\n      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;\n    }\n  }\n}\n\nfunction mergeHook$1 (f1, f2) {\n  var merged = function (a, b) {\n    // flow complains about extra args which is why we use any\n    f1(a, b);\n    f2(a, b);\n  };\n  merged._merged = true;\n  return merged\n}\n\n// transform component v-model info (value and callback) into\n// 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[event];\n  var callback = data.model.callback;\n  if (isDef(existing)) {\n    if (\n      Array.isArray(existing)\n        ? existing.indexOf(callback) === -1\n        : existing !== callback\n    ) {\n      on[event] = [callback].concat(existing);\n    }\n  } else {\n    on[event] = callback;\n  }\n}\n\n/*  */\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType,\n  alwaysNormalize\n) {\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}\n\nfunction _createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType\n) {\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      context\n    );\n    return createEmptyVNode()\n  }\n  // object syntax in v-bind\n  if (isDef(data) && isDef(data.is)) {\n    tag = data.is;\n  }\n  if (!tag) {\n    // in case of component :is set to falsy value\n    return createEmptyVNode()\n  }\n  // warn against non-primitive key\n  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        context\n      );\n    }\n  }\n  // support single function children as default scoped slot\n  if (Array.isArray(children) &&\n    typeof children[0] === 'function'\n  ) {\n    data = data || {};\n    data.scopedSlots = { default: children[0] };\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 elements\n      vnode = new VNode(\n        config.parsePlatformTagName(tag), data, children,\n        undefined, undefined, context\n      );\n    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {\n      // component\n      vnode = createComponent(Ctor, data, context, children, tag);\n    } else {\n      // unknown or unlisted namespaced elements\n      // check at runtime because it may get assigned a namespace when its\n      // parent normalizes children\n      vnode = new VNode(\n        tag, data, children,\n        undefined, undefined, context\n      );\n    }\n  } else {\n    // direct component options / constructor\n    vnode = createComponent(tag, data, context, children);\n  }\n  if (Array.isArray(vnode)) {\n    return vnode\n  } else if (isDef(vnode)) {\n    if (isDef(ns)) { applyNS(vnode, ns); }\n    if (isDef(data)) { registerDeepBindings(data); }\n    return vnode\n  } else {\n    return createEmptyVNode()\n  }\n}\n\nfunction applyNS (vnode, ns, force) {\n  vnode.ns = ns;\n  if (vnode.tag === 'foreignObject') {\n    // use default namespace inside foreignObject\n    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[i];\n      if (isDef(child.tag) && (\n        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {\n        applyNS(child, ns, force);\n      }\n    }\n  }\n}\n\n// ref #5318\n// necessary to ensure parent re-render when deep bindings like :style and\n// :class are used on slot nodes\nfunction registerDeepBindings (data) {\n  if (isObject(data.style)) {\n    traverse(data.style);\n  }\n  if (isObject(data.class)) {\n    traverse(data.class);\n  }\n}\n\n/*  */\n\nfunction initRender (vm) {\n  vm._vnode = null; // the root of the child tree\n  vm._staticTrees = null; // v-once cached trees\n  var options = vm.$options;\n  var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree\n  var renderContext = parentVnode && parentVnode.context;\n  vm.$slots = resolveSlots(options._renderChildren, renderContext);\n  vm.$scopedSlots = emptyObject;\n  // bind the createElement fn to this instance\n  // so that we get proper render context inside it.\n  // args order: tag, data, children, normalizationType, alwaysNormalize\n  // internal version is used by render functions compiled from templates\n  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 in\n  // user-written render functions.\n  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\n\n  // $attrs & $listeners are exposed for easier HOC creation.\n  // they need to be reactive so that HOCs using them are always updated\n  var parentData = parentVnode && parentVnode.data;\n\n  /* 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}\n\nvar currentRenderingInstance = null;\n\nfunction renderMixin (Vue) {\n  // install runtime convenience helpers\n  installRenderHelpers(Vue.prototype);\n\n  Vue.prototype.$nextTick = function (fn) {\n    return nextTick(fn, this)\n  };\n\n  Vue.prototype._render = function () {\n    var vm = this;\n    var ref = vm.$options;\n    var render = ref.render;\n    var _parentVnode = ref._parentVnode;\n\n    if (_parentVnode) {\n      vm.$scopedSlots = normalizeScopedSlots(\n        _parentVnode.data.scopedSlots,\n        vm.$slots,\n        vm.$scopedSlots\n      );\n    }\n\n    // set parent vnode. this allows render functions to have access\n    // to the data on the placeholder node.\n    vm.$vnode = _parentVnode;\n    // render self\n    var vnode;\n    try {\n      // There's no need to maintain a stack becaues all render fns are called\n      // separately from one another. Nested component's render fns are called\n      // 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 component\n      /* 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 it\n    if (Array.isArray(vnode) && vnode.length === 1) {\n      vnode = vnode[0];\n    }\n    // return empty vnode in case the render function errored out\n    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          vm\n        );\n      }\n      vnode = createEmptyVNode();\n    }\n    // set parent\n    vnode.parent = _parentVnode;\n    return vnode\n  };\n}\n\n/*  */\n\nfunction ensureCtor (comp, base) {\n  if (\n    comp.__esModule ||\n    (hasSymbol && comp[Symbol.toStringTag] === 'Module')\n  ) {\n    comp = comp.default;\n  }\n  return isObject(comp)\n    ? base.extend(comp)\n    : comp\n}\n\nfunction createAsyncPlaceholder (\n  factory,\n  data,\n  context,\n  children,\n  tag\n) {\n  var node = createEmptyVNode();\n  node.asyncFactory = factory;\n  node.asyncMeta = { data: data, context: context, children: children, tag: tag };\n  return node\n}\n\nfunction resolveAsyncComponent (\n  factory,\n  baseCtor\n) {\n  if (isTrue(factory.error) && isDef(factory.errorComp)) {\n    return factory.errorComp\n  }\n\n  if (isDef(factory.resolved)) {\n    return factory.resolved\n  }\n\n  var owner = currentRenderingInstance;\n  if (isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {\n    // already pending\n    factory.owners.push(owner);\n  }\n\n  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {\n    return factory.loadingComp\n  }\n\n  if (!isDef(factory.owners)) {\n    var owners = factory.owners = [owner];\n    var sync = true\n\n    ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });\n\n    var forceRender = function (renderCompleted) {\n      for (var i = 0, l = owners.length; i < l; i++) {\n        (owners[i]).$forceUpdate();\n      }\n\n      if (renderCompleted) {\n        owners.length = 0;\n      }\n    };\n\n    var resolve = once(function (res) {\n      // cache resolved\n      factory.resolved = ensureCtor(res, baseCtor);\n      // invoke callbacks only if this is not a synchronous resolve\n      // (async resolves are shimmed as synchronous during SSR)\n      if (!sync) {\n        forceRender(true);\n      } else {\n        owners.length = 0;\n      }\n    });\n\n    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    });\n\n    var res = factory(resolve, reject);\n\n    if (isObject(res)) {\n      if (isPromise(res)) {\n        // () => Promise\n        if (isUndef(factory.resolved)) {\n          res.then(resolve, reject);\n        }\n      } else if (isPromise(res.component)) {\n        res.component.then(resolve, reject);\n\n        if (isDef(res.error)) {\n          factory.errorComp = ensureCtor(res.error, baseCtor);\n        }\n\n        if (isDef(res.loading)) {\n          factory.loadingComp = ensureCtor(res.loading, baseCtor);\n          if (res.delay === 0) {\n            factory.loading = true;\n          } else {\n            setTimeout(function () {\n              if (isUndef(factory.resolved) && isUndef(factory.error)) {\n                factory.loading = true;\n                forceRender(false);\n              }\n            }, res.delay || 200);\n          }\n        }\n\n        if (isDef(res.timeout)) {\n          setTimeout(function () {\n            if (isUndef(factory.resolved)) {\n              reject(\n                process.env.NODE_ENV !== 'production'\n                  ? (\"timeout (\" + (res.timeout) + \"ms)\")\n                  : null\n              );\n            }\n          }, res.timeout);\n        }\n      }\n    }\n\n    sync = false;\n    // return in case resolved synchronously\n    return factory.loading\n      ? factory.loadingComp\n      : factory.resolved\n  }\n}\n\n/*  */\n\nfunction isAsyncPlaceholder (node) {\n  return node.isComment && node.asyncFactory\n}\n\n/*  */\n\nfunction getFirstComponentChild (children) {\n  if (Array.isArray(children)) {\n    for (var i = 0; i < children.length; i++) {\n      var c = children[i];\n      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {\n        return c\n      }\n    }\n  }\n}\n\n/*  */\n\n/*  */\n\nfunction initEvents (vm) {\n  vm._events = Object.create(null);\n  vm._hasHookEvent = false;\n  // init parent attached events\n  var listeners = vm.$options._parentListeners;\n  if (listeners) {\n    updateComponentListeners(vm, listeners);\n  }\n}\n\nvar target;\n\nfunction add (event, fn) {\n  target.$on(event, fn);\n}\n\nfunction remove$1 (event, fn) {\n  target.$off(event, fn);\n}\n\nfunction 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}\n\nfunction updateComponentListeners (\n  vm,\n  listeners,\n  oldListeners\n) {\n  target = vm;\n  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);\n  target = undefined;\n}\n\nfunction 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[i], fn);\n      }\n    } else {\n      (vm._events[event] || (vm._events[event] = [])).push(fn);\n      // optimize hook:event cost by using a boolean flag marked at registration\n      // instead of a hash lookup\n      if (hookRE.test(event)) {\n        vm._hasHookEvent = true;\n      }\n    }\n    return vm\n  };\n\n  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 vm\n  };\n\n  Vue.prototype.$off = function (event, fn) {\n    var vm = this;\n    // all\n    if (!arguments.length) {\n      vm._events = Object.create(null);\n      return vm\n    }\n    // array of events\n    if (Array.isArray(event)) {\n      for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {\n        vm.$off(event[i$1], fn);\n      }\n      return vm\n    }\n    // specific event\n    var cbs = vm._events[event];\n    if (!cbs) {\n      return vm\n    }\n    if (!fn) {\n      vm._events[event] = null;\n      return vm\n    }\n    // specific handler\n    var cb;\n    var i = cbs.length;\n    while (i--) {\n      cb = cbs[i];\n      if (cb === fn || cb.fn === fn) {\n        cbs.splice(i, 1);\n        break\n      }\n    }\n    return vm\n  };\n\n  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[lowerCaseEvent]) {\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[event];\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[i], vm, args, vm, info);\n      }\n    }\n    return vm\n  };\n}\n\n/*  */\n\nvar activeInstance = null;\nvar isUpdatingChildComponent = false;\n\nfunction setActiveInstance(vm) {\n  var prevActiveInstance = activeInstance;\n  activeInstance = vm;\n  return function () {\n    activeInstance = prevActiveInstance;\n  }\n}\n\nfunction initLifecycle (vm) {\n  var options = vm.$options;\n\n  // locate first non-abstract parent\n  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  }\n\n  vm.$parent = parent;\n  vm.$root = parent ? parent.$root : vm;\n\n  vm.$children = [];\n  vm.$refs = {};\n\n  vm._watcher = null;\n  vm._inactive = null;\n  vm._directInactive = false;\n  vm._isMounted = false;\n  vm._isDestroyed = false;\n  vm._isBeingDestroyed = false;\n}\n\nfunction 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 points\n    // based on the rendering backend used.\n    if (!prevVnode) {\n      // initial render\n      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);\n    } else {\n      // updates\n      vm.$el = vm.__patch__(prevVnode, vnode);\n    }\n    restoreActiveInstance();\n    // update __vue__ reference\n    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 well\n    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 are\n    // updated in a parent's updated hook.\n  };\n\n  Vue.prototype.$forceUpdate = function () {\n    var vm = this;\n    if (vm._watcher) {\n      vm._watcher.update();\n    }\n  };\n\n  Vue.prototype.$destroy = function () {\n    var vm = this;\n    if (vm._isBeingDestroyed) {\n      return\n    }\n    callHook(vm, 'beforeDestroy');\n    vm._isBeingDestroyed = true;\n    // remove self from parent\n    var parent = vm.$parent;\n    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n      remove(parent.$children, vm);\n    }\n    // teardown watchers\n    if (vm._watcher) {\n      vm._watcher.teardown();\n    }\n    var i = vm._watchers.length;\n    while (i--) {\n      vm._watchers[i].teardown();\n    }\n    // remove reference from data ob\n    // 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 tree\n    vm.__patch__(vm._vnode, null);\n    // fire destroyed hook\n    callHook(vm, 'destroyed');\n    // turn off all instance listeners.\n    vm.$off();\n    // remove __vue__ reference\n    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}\n\nfunction mountComponent (\n  vm,\n  el,\n  hydrating\n) {\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          vm\n        );\n      } else {\n        warn(\n          'Failed to mount component: template or render function not defined.',\n          vm\n        );\n      }\n    }\n  }\n  callHook(vm, 'beforeMount');\n\n  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;\n\n      mark(startTag);\n      var vnode = vm._render();\n      mark(endTag);\n      measure((\"vue \" + name + \" render\"), startTag, endTag);\n\n      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  }\n\n  // we set this to vm._watcher inside the watcher's constructor\n  // since the watcher's initial patch may call $forceUpdate (e.g. inside child\n  // component's mounted hook), which relies on vm._watcher being already defined\n  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;\n\n  // manually mounted instance, call mounted on self\n  // mounted is called for render-created child components in its inserted hook\n  if (vm.$vnode == null) {\n    vm._isMounted = true;\n    callHook(vm, 'mounted');\n  }\n  return vm\n}\n\nfunction updateChildComponent (\n  vm,\n  propsData,\n  listeners,\n  parentVnode,\n  renderChildren\n) {\n  if (process.env.NODE_ENV !== 'production') {\n    isUpdatingChildComponent = true;\n  }\n\n  // determine whether component has slot children\n  // we need to do this before overwriting $options._renderChildren.\n\n  // check if there are dynamic scopedSlots (hand-written or compiled but with\n  // dynamic slot names). Static scoped slots compiled from template has the\n  // \"$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  );\n\n  // Any static slot children from the parent may have changed during parent's\n  // update. Dynamic scoped slots may also have changed. In such cases, a forced\n  // update is necessary to ensure correctness.\n  var needsForceUpdate = !!(\n    renderChildren ||               // has new static slots\n    vm.$options._renderChildren ||  // has old static slots\n    hasDynamicScopedSlot\n  );\n\n  vm.$options._parentVnode = parentVnode;\n  vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n\n  if (vm._vnode) { // update child tree's parent\n    vm._vnode.parent = parentVnode;\n  }\n  vm.$options._renderChildren = renderChildren;\n\n  // update $attrs and $listeners hash\n  // these are also reactive so they may trigger child update if the child\n  // used them during render\n  vm.$attrs = parentVnode.data.attrs || emptyObject;\n  vm.$listeners = listeners || emptyObject;\n\n  // update props\n  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[i];\n      var propOptions = vm.$options.props; // wtf flow?\n      props[key] = validateProp(key, propOptions, propsData, vm);\n    }\n    toggleObserving(true);\n    // keep a copy of raw propsData\n    vm.$options.propsData = propsData;\n  }\n\n  // update listeners\n  listeners = listeners || emptyObject;\n  var oldListeners = vm.$options._parentListeners;\n  vm.$options._parentListeners = listeners;\n  updateComponentListeners(vm, listeners, oldListeners);\n\n  // resolve slots + force update if has children\n  if (needsForceUpdate) {\n    vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n    vm.$forceUpdate();\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    isUpdatingChildComponent = false;\n  }\n}\n\nfunction isInInactiveTree (vm) {\n  while (vm && (vm = vm.$parent)) {\n    if (vm._inactive) { return true }\n  }\n  return false\n}\n\nfunction activateChildComponent (vm, direct) {\n  if (direct) {\n    vm._directInactive = false;\n    if (isInInactiveTree(vm)) {\n      return\n    }\n  } else if (vm._directInactive) {\n    return\n  }\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[i]);\n    }\n    callHook(vm, 'activated');\n  }\n}\n\nfunction deactivateChildComponent (vm, direct) {\n  if (direct) {\n    vm._directInactive = true;\n    if (isInInactiveTree(vm)) {\n      return\n    }\n  }\n  if (!vm._inactive) {\n    vm._inactive = true;\n    for (var i = 0; i < vm.$children.length; i++) {\n      deactivateChildComponent(vm.$children[i]);\n    }\n    callHook(vm, 'deactivated');\n  }\n}\n\nfunction callHook (vm, hook) {\n  // #7573 disable dep collection when invoking lifecycle hooks\n  pushTarget();\n  var handlers = vm.$options[hook];\n  var info = hook + \" hook\";\n  if (handlers) {\n    for (var i = 0, j = handlers.length; i < j; i++) {\n      invokeWithErrorHandling(handlers[i], vm, null, vm, info);\n    }\n  }\n  if (vm._hasHookEvent) {\n    vm.$emit('hook:' + hook);\n  }\n  popTarget();\n}\n\n/*  */\n\nvar MAX_UPDATE_COUNT = 100;\n\nvar queue = [];\nvar activatedChildren = [];\nvar has = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\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}\n\n// Async edge case #6566 requires saving the timestamp when event listeners are\n// attached. However, calling performance.now() has a perf overhead especially\n// if the page has thousands of event listeners. Instead, we take a timestamp\n// every time the scheduler flushes and use that for all event listeners\n// attached during that flush.\nvar currentFlushTimestamp = 0;\n\n// Async edge case fix requires storing an event listener's attach timestamp.\nvar getNow = Date.now;\n\n// Determine what event timestamp the browser is using. Annoyingly, the\n// timestamp can either be hi-res (relative to page load) or low-res\n// (relative to UNIX epoch), so in order to compare time we have to use the\n// same timestamp type when saving the flush timestamp.\nif (inBrowser && getNow() > document.createEvent('Event').timeStamp) {\n  // if the low-res timestamp which is bigger than the event timestamp\n  // (which is evaluated AFTER) it means the event is using a hi-res timestamp,\n  // and we need to use the hi-res version for event listeners as well.\n  getNow = function () { return performance.now(); };\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n  currentFlushTimestamp = getNow();\n  flushing = true;\n  var watcher, id;\n\n  // Sort queue before flush.\n  // This ensures that:\n  // 1. Components are updated from parent to child. (because parent is always\n  //    created before the child)\n  // 2. A component's user watchers are run before its render watcher (because\n  //    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; });\n\n  // do not cache length because more watchers might be pushed\n  // as we run existing watchers\n  for (index = 0; index < queue.length; index++) {\n    watcher = queue[index];\n    if (watcher.before) {\n      watcher.before();\n    }\n    id = watcher.id;\n    has[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if (process.env.NODE_ENV !== 'production' && has[id] != null) {\n      circular[id] = (circular[id] || 0) + 1;\n      if (circular[id] > MAX_UPDATE_COUNT) {\n        warn(\n          'You may have an infinite update loop ' + (\n            watcher.user\n              ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n              : \"in a component render function.\"\n          ),\n          watcher.vm\n        );\n        break\n      }\n    }\n  }\n\n  // keep copies of post queues before resetting state\n  var activatedQueue = activatedChildren.slice();\n  var updatedQueue = queue.slice();\n\n  resetSchedulerState();\n\n  // call component updated and activated hooks\n  callActivatedHooks(activatedQueue);\n  callUpdatedHooks(updatedQueue);\n\n  // devtool hook\n  /* istanbul ignore if */\n  if (devtools && config.devtools) {\n    devtools.emit('flush');\n  }\n}\n\nfunction callUpdatedHooks (queue) {\n  var i = queue.length;\n  while (i--) {\n    var watcher = queue[i];\n    var vm = watcher.vm;\n    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {\n      callHook(vm, 'updated');\n    }\n  }\n}\n\n/**\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 can\n  // rely on checking whether it's in an inactive tree (e.g. router-view)\n  vm._inactive = false;\n  activatedChildren.push(vm);\n}\n\nfunction callActivatedHooks (queue) {\n  for (var i = 0; i < queue.length; i++) {\n    queue[i]._inactive = true;\n    activateChildComponent(queue[i], true /* true */);\n  }\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher (watcher) {\n  var id = watcher.id;\n  if (has[id] == null) {\n    has[id] = true;\n    if (!flushing) {\n      queue.push(watcher);\n    } else {\n      // if already flushing, splice the watcher based on its id\n      // if already past its id, it will be run next immediately.\n      var i = queue.length - 1;\n      while (i > index && queue[i].id > watcher.id) {\n        i--;\n      }\n      queue.splice(i + 1, 0, watcher);\n    }\n    // queue the flush\n    if (!waiting) {\n      waiting = true;\n\n      if (process.env.NODE_ENV !== 'production' && !config.async) {\n        flushSchedulerQueue();\n        return\n      }\n      nextTick(flushSchedulerQueue);\n    }\n  }\n}\n\n/*  */\n\n\n\nvar uid$2 = 0;\n\n/**\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  isRenderWatcher\n) {\n  this.vm = vm;\n  if (isRenderWatcher) {\n    vm._watcher = this;\n  }\n  vm._watchers.push(this);\n  // options\n  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 batching\n  this.active = true;\n  this.dirty = this.lazy; // for lazy watchers\n  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 getter\n  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        vm\n      );\n    }\n  }\n  this.value = this.lazy\n    ? undefined\n    : this.get();\n};\n\n/**\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 e\n    }\n  } finally {\n    // \"touch\" every property so they are all tracked as\n    // dependencies for deep watching\n    if (this.deep) {\n      traverse(value);\n    }\n    popTarget();\n    this.cleanupDeps();\n  }\n  return value\n};\n\n/**\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};\n\n/**\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[i];\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};\n\n/**\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};\n\n/**\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 even\n      // when the value is the same, because the value may\n      // have mutated.\n      isObject(value) ||\n      this.deep\n    ) {\n      // set new value\n      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};\n\n/**\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};\n\n/**\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[i].depend();\n  }\n};\n\n/**\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 list\n    // this is a somewhat expensive operation so we skip it\n    // 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[i].removeSub(this);\n    }\n    this.active = false;\n  }\n};\n\n/*  */\n\nvar sharedPropertyDefinition = {\n  enumerable: true,\n  configurable: true,\n  get: noop,\n  set: noop\n};\n\nfunction proxy (target, sourceKey, key) {\n  sharedPropertyDefinition.get = function proxyGetter () {\n    return this[sourceKey][key]\n  };\n  sharedPropertyDefinition.set = function proxySetter (val) {\n    this[sourceKey][key] = val;\n  };\n  Object.defineProperty(target, key, sharedPropertyDefinition);\n}\n\nfunction 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}\n\nfunction 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 Array\n  // instead of dynamic object key enumeration.\n  var keys = vm.$options._propKeys = [];\n  var isRoot = !vm.$parent;\n  // root instance props should be converted\n  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          vm\n        );\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            vm\n          );\n        }\n      });\n    } else {\n      defineReactive$$1(props, key, value);\n    }\n    // static props are already proxied on the component's prototype\n    // during Vue.extend(). We only need to proxy props defined at\n    // instantiation here.\n    if (!(key in vm)) {\n      proxy(vm, \"_props\", key);\n    }\n  };\n\n  for (var key in propsOptions) loop( key );\n  toggleObserving(true);\n}\n\nfunction 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      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n      vm\n    );\n  }\n  // proxy data on instance\n  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[i];\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          vm\n        );\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        vm\n      );\n    } else if (!isReserved(key)) {\n      proxy(vm, \"_data\", key);\n    }\n  }\n  // observe data\n  observe(data, true /* asRootData */);\n}\n\nfunction getData (data, vm) {\n  // #7573 disable dep collection when invoking data getters\n  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}\n\nvar computedWatcherOptions = { lazy: true };\n\nfunction initComputed (vm, computed) {\n  // $flow-disable-line\n  var watchers = vm._computedWatchers = Object.create(null);\n  // computed properties are just getters during SSR\n  var isSSR = isServerRendering();\n\n  for (var key in computed) {\n    var userDef = computed[key];\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        vm\n      );\n    }\n\n    if (!isSSR) {\n      // create internal watcher for the computed property.\n      watchers[key] = new Watcher(\n        vm,\n        getter || noop,\n        noop,\n        computedWatcherOptions\n      );\n    }\n\n    // component-defined computed properties are already defined on the\n    // component prototype. We only need to define computed properties defined\n    // 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}\n\nfunction defineComputed (\n  target,\n  key,\n  userDef\n) {\n  var shouldCache = !isServerRendering();\n  if (typeof userDef === 'function') {\n    sharedPropertyDefinition.get = shouldCache\n      ? createComputedGetter(key)\n      : createGetterInvoker(userDef);\n    sharedPropertyDefinition.set = noop;\n  } else {\n    sharedPropertyDefinition.get = userDef.get\n      ? shouldCache && userDef.cache !== false\n        ? 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        this\n      );\n    };\n  }\n  Object.defineProperty(target, key, sharedPropertyDefinition);\n}\n\nfunction createComputedGetter (key) {\n  return function computedGetter () {\n    var watcher = this._computedWatchers && this._computedWatchers[key];\n    if (watcher) {\n      if (watcher.dirty) {\n        watcher.evaluate();\n      }\n      if (Dep.target) {\n        watcher.depend();\n      }\n      return watcher.value\n    }\n  }\n}\n\nfunction createGetterInvoker(fn) {\n  return function computedGetter () {\n    return fn.call(this, this)\n  }\n}\n\nfunction 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[key] !== 'function') {\n        warn(\n          \"Method \\\"\" + key + \"\\\" has type \\\"\" + (typeof methods[key]) + \"\\\" in the component definition. \" +\n          \"Did you reference the function correctly?\",\n          vm\n        );\n      }\n      if (props && hasOwn(props, key)) {\n        warn(\n          (\"Method \\\"\" + key + \"\\\" has already been defined as a prop.\"),\n          vm\n        );\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[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);\n  }\n}\n\nfunction initWatch (vm, watch) {\n  for (var key in watch) {\n    var handler = watch[key];\n    if (Array.isArray(handler)) {\n      for (var i = 0; i < handler.length; i++) {\n        createWatcher(vm, key, handler[i]);\n      }\n    } else {\n      createWatcher(vm, key, handler);\n    }\n  }\n}\n\nfunction createWatcher (\n  vm,\n  expOrFn,\n  handler,\n  options\n) {\n  if (isPlainObject(handler)) {\n    options = handler;\n    handler = handler.handler;\n  }\n  if (typeof handler === 'string') {\n    handler = vm[handler];\n  }\n  return vm.$watch(expOrFn, handler, options)\n}\n\nfunction stateMixin (Vue) {\n  // flow somehow has problems with directly declared definition object\n  // when using Object.defineProperty, so we have to procedurally build up\n  // 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        this\n      );\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);\n\n  Vue.prototype.$set = set;\n  Vue.prototype.$delete = del;\n\n  Vue.prototype.$watch = function (\n    expOrFn,\n    cb,\n    options\n  ) {\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}\n\n/*  */\n\nvar uid$3 = 0;\n\nfunction initMixin (Vue) {\n  Vue.prototype._init = function (options) {\n    var vm = this;\n    // a uid\n    vm._uid = uid$3++;\n\n    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    }\n\n    // a flag to avoid this being observed\n    vm._isVue = true;\n    // merge options\n    if (options && options._isComponent) {\n      // optimize internal component instantiation\n      // since dynamic options merging is pretty slow, and none of the\n      // internal component options needs special treatment.\n      initInternalComponent(vm, options);\n    } else {\n      vm.$options = mergeOptions(\n        resolveConstructorOptions(vm.constructor),\n        options || {},\n        vm\n      );\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 self\n    vm._self = vm;\n    initLifecycle(vm);\n    initEvents(vm);\n    initRender(vm);\n    callHook(vm, 'beforeCreate');\n    initInjections(vm); // resolve injections before data/props\n    initState(vm);\n    initProvide(vm); // resolve provide after data/props\n    callHook(vm, 'created');\n\n    /* 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    }\n\n    if (vm.$options.el) {\n      vm.$mount(vm.$options.el);\n    }\n  };\n}\n\nfunction 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;\n\n  var vnodeComponentOptions = parentVnode.componentOptions;\n  opts.propsData = vnodeComponentOptions.propsData;\n  opts._parentListeners = vnodeComponentOptions.listeners;\n  opts._renderChildren = vnodeComponentOptions.children;\n  opts._componentTag = vnodeComponentOptions.tag;\n\n  if (options.render) {\n    opts.render = options.render;\n    opts.staticRenderFns = options.staticRenderFns;\n  }\n}\n\nfunction 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 options\n      if (modifiedOptions) {\n        extend(Ctor.extendOptions, modifiedOptions);\n      }\n      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);\n      if (options.name) {\n        options.components[options.name] = Ctor;\n      }\n    }\n  }\n  return options\n}\n\nfunction resolveModifiedOptions (Ctor) {\n  var modified;\n  var latest = Ctor.options;\n  var sealed = Ctor.sealedOptions;\n  for (var key in latest) {\n    if (latest[key] !== sealed[key]) {\n      if (!modified) { modified = {}; }\n      modified[key] = latest[key];\n    }\n  }\n  return modified\n}\n\nfunction 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}\n\ninitMixin(Vue);\nstateMixin(Vue);\neventsMixin(Vue);\nlifecycleMixin(Vue);\nrenderMixin(Vue);\n\n/*  */\n\nfunction initUse (Vue) {\n  Vue.use = function (plugin) {\n    var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));\n    if (installedPlugins.indexOf(plugin) > -1) {\n      return this\n    }\n\n    // additional parameters\n    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 this\n  };\n}\n\n/*  */\n\nfunction initMixin$1 (Vue) {\n  Vue.mixin = function (mixin) {\n    this.options = mergeOptions(this.options, mixin);\n    return this\n  };\n}\n\n/*  */\n\nfunction initExtend (Vue) {\n  /**\n   * Each instance constructor, including Vue, has a unique\n   * cid. This enables us to create wrapped \"child\n   * constructors\" for prototypal inheritance and cache them.\n   */\n  Vue.cid = 0;\n  var cid = 1;\n\n  /**\n   * Class inheritance\n   */\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[SuperId]) {\n      return cachedCtors[SuperId]\n    }\n\n    var name = extendOptions.name || Super.options.name;\n    if (process.env.NODE_ENV !== 'production' && name) {\n      validateComponentName(name);\n    }\n\n    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      extendOptions\n    );\n    Sub['super'] = Super;\n\n    // For props and computed properties, we define the proxy getters on\n    // the Vue instances at extension time, on the extended prototype. This\n    // 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    }\n\n    // allow further extension/mixin/plugin usage\n    Sub.extend = Super.extend;\n    Sub.mixin = Super.mixin;\n    Sub.use = Super.use;\n\n    // create asset registers, so extended classes\n    // can have their private assets too.\n    ASSET_TYPES.forEach(function (type) {\n      Sub[type] = Super[type];\n    });\n    // enable recursive self-lookup\n    if (name) {\n      Sub.options.components[name] = Sub;\n    }\n\n    // keep a reference to the super options at extension time.\n    // later at instantiation we can check if Super's options have\n    // been updated.\n    Sub.superOptions = Super.options;\n    Sub.extendOptions = extendOptions;\n    Sub.sealedOptions = extend({}, Sub.options);\n\n    // cache constructor\n    cachedCtors[SuperId] = Sub;\n    return Sub\n  };\n}\n\nfunction initProps$1 (Comp) {\n  var props = Comp.options.props;\n  for (var key in props) {\n    proxy(Comp.prototype, \"_props\", key);\n  }\n}\n\nfunction initComputed$1 (Comp) {\n  var computed = Comp.options.computed;\n  for (var key in computed) {\n    defineComputed(Comp.prototype, key, computed[key]);\n  }\n}\n\n/*  */\n\nfunction initAssetRegisters (Vue) {\n  /**\n   * Create asset registration methods.\n   */\n  ASSET_TYPES.forEach(function (type) {\n    Vue[type] = function (\n      id,\n      definition\n    ) {\n      if (!definition) {\n        return this.options[type + 's'][id]\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'][id] = definition;\n        return definition\n      }\n    };\n  });\n}\n\n/*  */\n\n\n\nfunction getComponentName (opts) {\n  return opts && (opts.Ctor.options.name || opts.tag)\n}\n\nfunction matches (pattern, name) {\n  if (Array.isArray(pattern)) {\n    return pattern.indexOf(name) > -1\n  } else if (typeof pattern === 'string') {\n    return pattern.split(',').indexOf(name) > -1\n  } else if (isRegExp(pattern)) {\n    return pattern.test(name)\n  }\n  /* istanbul ignore next */\n  return false\n}\n\nfunction 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[key];\n    if (cachedNode) {\n      var name = getComponentName(cachedNode.componentOptions);\n      if (name && !filter(name)) {\n        pruneCacheEntry(cache, key, keys, _vnode);\n      }\n    }\n  }\n}\n\nfunction pruneCacheEntry (\n  cache,\n  key,\n  keys,\n  current\n) {\n  var cached$$1 = cache[key];\n  if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {\n    cached$$1.componentInstance.$destroy();\n  }\n  cache[key] = null;\n  remove(keys, key);\n}\n\nvar patternTypes = [String, RegExp, Array];\n\nvar KeepAlive = {\n  name: 'keep-alive',\n  abstract: true,\n\n  props: {\n    include: patternTypes,\n    exclude: patternTypes,\n    max: [String, Number]\n  },\n\n  created: function created () {\n    this.cache = Object.create(null);\n    this.keys = [];\n  },\n\n  destroyed: function destroyed () {\n    for (var key in this.cache) {\n      pruneCacheEntry(this.cache, key, this.keys);\n    }\n  },\n\n  mounted: function mounted () {\n    var this$1 = this;\n\n    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  },\n\n  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 pattern\n      var name = getComponentName(componentOptions);\n      var ref = this;\n      var include = ref.include;\n      var exclude = ref.exclude;\n      if (\n        // not included\n        (include && (!name || !matches(include, name))) ||\n        // excluded\n        (exclude && name && matches(exclude, name))\n      ) {\n        return vnode\n      }\n\n      var ref$1 = this;\n      var cache = ref$1.cache;\n      var keys = ref$1.keys;\n      var key = vnode.key == null\n        // same constructor may get registered as different local components\n        // so cid alone is not enough (#3269)\n        ? componentOptions.Ctor.cid + (componentOptions.tag ? (\"::\" + (componentOptions.tag)) : '')\n        : vnode.key;\n      if (cache[key]) {\n        vnode.componentInstance = cache[key].componentInstance;\n        // make current key freshest\n        remove(keys, key);\n        keys.push(key);\n      } else {\n        cache[key] = vnode;\n        keys.push(key);\n        // prune oldest entry\n        if (this.max && keys.length > parseInt(this.max)) {\n          pruneCacheEntry(cache, keys[0], keys, this._vnode);\n        }\n      }\n\n      vnode.data.keepAlive = true;\n    }\n    return vnode || (slot && slot[0])\n  }\n};\n\nvar builtInComponents = {\n  KeepAlive: KeepAlive\n};\n\n/*  */\n\nfunction initGlobalAPI (Vue) {\n  // config\n  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);\n\n  // exposed util methods.\n  // NOTE: these are not considered part of the public API - avoid relying on\n  // them unless you are aware of the risk.\n  Vue.util = {\n    warn: warn,\n    extend: extend,\n    mergeOptions: mergeOptions,\n    defineReactive: defineReactive$$1\n  };\n\n  Vue.set = set;\n  Vue.delete = del;\n  Vue.nextTick = nextTick;\n\n  // 2.6 explicit observable API\n  Vue.observable = function (obj) {\n    observe(obj);\n    return obj\n  };\n\n  Vue.options = Object.create(null);\n  ASSET_TYPES.forEach(function (type) {\n    Vue.options[type + 's'] = Object.create(null);\n  });\n\n  // this is used to identify the \"base\" constructor to extend all plain-object\n  // components with in Weex's multi-instance scenarios.\n  Vue.options._base = Vue;\n\n  extend(Vue.options.components, builtInComponents);\n\n  initUse(Vue);\n  initMixin$1(Vue);\n  initExtend(Vue);\n  initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue);\n\nObject.defineProperty(Vue.prototype, '$isServer', {\n  get: isServerRendering\n});\n\nObject.defineProperty(Vue.prototype, '$ssrContext', {\n  get: function get () {\n    /* istanbul ignore next */\n    return this.$vnode && this.$vnode.ssrContext\n  }\n});\n\n// expose FunctionalRenderContext for ssr runtime helper installation\nObject.defineProperty(Vue, 'FunctionalRenderContext', {\n  value: FunctionalRenderContext\n});\n\nVue.version = '2.6.8';\n\n/*  */\n\n// these are reserved for web because they are directly compiled away\n// during template compilation\nvar isReservedAttr = makeMap('style,class');\n\n// attributes that should be using props for binding\nvar 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};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');\n\nvar convertEnumeratedValue = function (key, value) {\n  return isFalsyAttrValue(value) || value === 'false'\n    ? 'false'\n    // allow arbitrary string value for contenteditable\n    : key === 'contenteditable' && isValidContentEditableValue(value)\n      ? value\n      : 'true'\n};\n\nvar 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);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n  return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n  return val == null || val === false\n};\n\n/*  */\n\nfunction 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}\n\nfunction mergeClassData (child, parent) {\n  return {\n    staticClass: concat(child.staticClass, parent.staticClass),\n    class: isDef(child.class)\n      ? [child.class, parent.class]\n      : parent.class\n  }\n}\n\nfunction renderClass (\n  staticClass,\n  dynamicClass\n) {\n  if (isDef(staticClass) || isDef(dynamicClass)) {\n    return concat(staticClass, stringifyClass(dynamicClass))\n  }\n  /* istanbul ignore next */\n  return ''\n}\n\nfunction concat (a, b) {\n  return a ? b ? (a + ' ' + b) : a : (b || '')\n}\n\nfunction 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 value\n  }\n  /* istanbul ignore next */\n  return ''\n}\n\nfunction 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[i])) && stringified !== '') {\n      if (res) { res += ' '; }\n      res += stringified;\n    }\n  }\n  return res\n}\n\nfunction stringifyObject (value) {\n  var res = '';\n  for (var key in value) {\n    if (value[key]) {\n      if (res) { res += ' '; }\n      res += key;\n    }\n  }\n  return res\n}\n\n/*  */\n\nvar namespaceMap = {\n  svg: 'http://www.w3.org/2000/svg',\n  math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar 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);\n\n// this map is intentionally selective, only covering SVG elements that may\n// 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  true\n);\n\nvar isReservedTag = function (tag) {\n  return isHTMLTag(tag) || isSVG(tag)\n};\n\nfunction getTagNamespace (tag) {\n  if (isSVG(tag)) {\n    return 'svg'\n  }\n  // basic support for MathML\n  // note it doesn't support other MathML elements being component roots\n  if (tag === 'math') {\n    return 'math'\n  }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement (tag) {\n  /* istanbul ignore if */\n  if (!inBrowser) {\n    return true\n  }\n  if (isReservedTag(tag)) {\n    return false\n  }\n  tag = tag.toLowerCase();\n  /* istanbul ignore if */\n  if (unknownElementCache[tag] != null) {\n    return unknownElementCache[tag]\n  }\n  var el = document.createElement(tag);\n  if (tag.indexOf('-') > -1) {\n    // http://stackoverflow.com/a/28210364/1070244\n    return (unknownElementCache[tag] = (\n      el.constructor === window.HTMLUnknownElement ||\n      el.constructor === window.HTMLElement\n    ))\n  } else {\n    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n  }\n}\n\nvar isTextInputType = makeMap('text,number,password,search,email,tel,url');\n\n/*  */\n\n/**\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: ' + el\n      );\n      return document.createElement('div')\n    }\n    return selected\n  } else {\n    return el\n  }\n}\n\n/*  */\n\nfunction createElement$1 (tagName, vnode) {\n  var elm = document.createElement(tagName);\n  if (tagName !== 'select') {\n    return elm\n  }\n  // false or null will remove the attribute but undefined will not\n  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {\n    elm.setAttribute('multiple', 'multiple');\n  }\n  return elm\n}\n\nfunction createElementNS (namespace, tagName) {\n  return document.createElementNS(namespaceMap[namespace], tagName)\n}\n\nfunction createTextNode (text) {\n  return document.createTextNode(text)\n}\n\nfunction createComment (text) {\n  return document.createComment(text)\n}\n\nfunction insertBefore (parentNode, newNode, referenceNode) {\n  parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild (node, child) {\n  node.removeChild(child);\n}\n\nfunction appendChild (node, child) {\n  node.appendChild(child);\n}\n\nfunction parentNode (node) {\n  return node.parentNode\n}\n\nfunction nextSibling (node) {\n  return node.nextSibling\n}\n\nfunction tagName (node) {\n  return node.tagName\n}\n\nfunction setTextContent (node, text) {\n  node.textContent = text;\n}\n\nfunction setStyleScope (node, scopeId) {\n  node.setAttribute(scopeId, '');\n}\n\nvar 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: setStyleScope\n});\n\n/*  */\n\nvar 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};\n\nfunction registerRef (vnode, isRemoval) {\n  var key = vnode.data.ref;\n  if (!isDef(key)) { return }\n\n  var vm = vnode.context;\n  var ref = vnode.componentInstance || vnode.elm;\n  var refs = vm.$refs;\n  if (isRemoval) {\n    if (Array.isArray(refs[key])) {\n      remove(refs[key], ref);\n    } else if (refs[key] === ref) {\n      refs[key] = undefined;\n    }\n  } else {\n    if (vnode.data.refInFor) {\n      if (!Array.isArray(refs[key])) {\n        refs[key] = [ref];\n      } else if (refs[key].indexOf(ref) < 0) {\n        // $flow-disable-line\n        refs[key].push(ref);\n      }\n    } else {\n      refs[key] = ref;\n    }\n  }\n}\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = new VNode('', {}, []);\n\nvar hooks = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction 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}\n\nfunction 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}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n  var i, key;\n  var map = {};\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) { map[key] = i; }\n  }\n  return map\n}\n\nfunction createPatchFunction (backend) {\n  var i, j;\n  var cbs = {};\n\n  var modules = backend.modules;\n  var nodeOps = backend.nodeOps;\n\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (isDef(modules[j][hooks[i]])) {\n        cbs[hooks[i]].push(modules[j][hooks[i]]);\n      }\n    }\n  }\n\n  function emptyNodeAt (elm) {\n    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n  }\n\n  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$$1\n  }\n\n  function removeNode (el) {\n    var parent = nodeOps.parentNode(el);\n    // element may have already been removed due to v-html / v-text\n    if (isDef(parent)) {\n      nodeOps.removeChild(parent, el);\n    }\n  }\n\n  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.tag\n        })\n      ) &&\n      config.isUnknownElement(vnode.tag)\n    )\n  }\n\n  var creatingElmInVPre = 0;\n\n  function createElm (\n    vnode,\n    insertedVnodeQueue,\n    parentElm,\n    refElm,\n    nested,\n    ownerArray,\n    index\n  ) {\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 cause\n      // potential patch errors down the road when it's used as an insertion\n      // reference node. Instead, we clone the node on-demand before creating\n      // associated DOM element for it.\n      vnode = ownerArray[index] = cloneVNode(vnode);\n    }\n\n    vnode.isRootInsert = !nested; // for transition enter check\n    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n      return\n    }\n\n    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.context\n          );\n        }\n      }\n\n      vnode.elm = vnode.ns\n        ? nodeOps.createElementNS(vnode.ns, tag)\n        : nodeOps.createElement(tag, vnode);\n      setScope(vnode);\n\n      /* 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      }\n\n      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  }\n\n  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 component\n      // it should've created a child instance and mounted it. the child\n      // 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 true\n      }\n    }\n  }\n\n  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 hook\n      insertedVnodeQueue.push(vnode);\n    }\n  }\n\n  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i;\n    // hack for #4339: a reactivated component with inner transition\n    // does not trigger because the inner node's created hooks are not called\n    // again. It's not ideal to involve module-specific logic in here but\n    // 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[i](emptyNode, innerNode);\n        }\n        insertedVnodeQueue.push(innerNode);\n        break\n      }\n    }\n    // unlike a newly created component,\n    // a reactivated keep-alive component doesn't insert itself\n    insert(parentElm, vnode.elm, refElm);\n  }\n\n  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  }\n\n  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[i], 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  }\n\n  function isPatchable (vnode) {\n    while (vnode.componentInstance) {\n      vnode = vnode.componentInstance._vnode;\n    }\n    return isDef(vnode.tag)\n  }\n\n  function invokeCreateHooks (vnode, insertedVnodeQueue) {\n    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n      cbs.create[i$1](emptyNode, vnode);\n    }\n    i = vnode.data.hook; // Reuse variable\n    if (isDef(i)) {\n      if (isDef(i.create)) { i.create(emptyNode, vnode); }\n      if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }\n    }\n  }\n\n  // set scope id attribute for scoped CSS.\n  // this is implemented as a special case to avoid the overhead\n  // 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  }\n\n  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);\n    }\n  }\n\n  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[i](vnode); }\n    }\n    if (isDef(i = vnode.children)) {\n      for (j = 0; j < vnode.children.length; ++j) {\n        invokeDestroyHook(vnode.children[j]);\n      }\n    }\n  }\n\n  function removeVnodes (parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.tag)) {\n          removeAndInvokeRemoveHook(ch);\n          invokeDestroyHook(ch);\n        } else { // Text node\n          removeNode(ch.elm);\n        }\n      }\n    }\n  }\n\n  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 callback\n        // increase the listeners count\n        rm.listeners += listeners;\n      } else {\n        // directly removing\n        rm = createRmCb(vnode.elm, listeners);\n      }\n      // recursively invoke hooks on child component root node\n      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[i](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  }\n\n  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[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, vnodeToMove, refElm;\n\n    // removeOnly is a special flag used only by <transition-group>\n    // to ensure removed elements stay in correct relative positions\n    // during leaving transitions\n    var canMove = !removeOnly;\n\n    if (process.env.NODE_ENV !== 'production') {\n      checkDuplicateKeys(newCh);\n    }\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);\n        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);\n        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n        idxInOld = isDef(newStartVnode.key)\n          ? oldKeyToIdx[newStartVnode.key]\n          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);\n        if (isUndef(idxInOld)) { // New element\n          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);\n        } else {\n          vnodeToMove = oldCh[idxInOld];\n          if (sameVnode(vnodeToMove, newStartVnode)) {\n            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);\n            oldCh[idxInOld] = undefined;\n            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);\n          } else {\n            // same key but different element. treat as new element\n            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);\n          }\n        }\n        newStartVnode = newCh[++newStartIdx];\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(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function checkDuplicateKeys (children) {\n    var seenKeys = {};\n    for (var i = 0; i < children.length; i++) {\n      var vnode = children[i];\n      var key = vnode.key;\n      if (isDef(key)) {\n        if (seenKeys[key]) {\n          warn(\n            (\"Duplicate keys detected: '\" + key + \"'. This may cause an update error.\"),\n            vnode.context\n          );\n        } else {\n          seenKeys[key] = true;\n        }\n      }\n    }\n  }\n\n  function findIdxInOld (node, oldCh, start, end) {\n    for (var i = start; i < end; i++) {\n      var c = oldCh[i];\n      if (isDef(c) && sameVnode(node, c)) { return i }\n    }\n  }\n\n  function patchVnode (\n    oldVnode,\n    vnode,\n    insertedVnodeQueue,\n    ownerArray,\n    index,\n    removeOnly\n  ) {\n    if (oldVnode === vnode) {\n      return\n    }\n\n    if (isDef(vnode.elm) && isDef(ownerArray)) {\n      // clone reused vnode\n      vnode = ownerArray[index] = cloneVNode(vnode);\n    }\n\n    var elm = vnode.elm = oldVnode.elm;\n\n    if (isTrue(oldVnode.isAsyncPlaceholder)) {\n      if (isDef(vnode.asyncFactory.resolved)) {\n        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);\n      } else {\n        vnode.isAsyncPlaceholder = true;\n      }\n      return\n    }\n\n    // 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 been\n    // 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      return\n    }\n\n    var i;\n    var data = vnode.data;\n    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n      i(oldVnode, vnode);\n    }\n\n    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[i](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(elm, 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  }\n\n  function invokeInsertHook (vnode, queue, initial) {\n    // delay insert hooks for component root nodes, invoke them after the\n    // element is really inserted\n    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[i].data.hook.insert(queue[i]);\n      }\n    }\n  }\n\n  var hydrationBailed = false;\n  // list of modules that can skip create hook during hydration because they\n  // are already rendered on the client or has no need for initialization\n  // Note: style is excluded because it relies on initial clone for future\n  // deep updates (#7063).\n  var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');\n\n  // 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;\n\n    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {\n      vnode.isAsyncPlaceholder = true;\n      return true\n    }\n    // assert node match\n    if (process.env.NODE_ENV !== 'production') {\n      if (!assertNodeMatch(elm, vnode, inVPre)) {\n        return false\n      }\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 true\n      }\n    }\n    if (isDef(tag)) {\n      if (isDef(children)) {\n        // empty element, allow client to pick up and populate children\n        if (!elm.hasChildNodes()) {\n          createChildren(vnode, children, insertedVnodeQueue);\n        } else {\n          // v-html and domProps: innerHTML\n          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                !hydrationBailed\n              ) {\n                hydrationBailed = true;\n                console.warn('Parent: ', elm);\n                console.warn('server innerHTML: ', i);\n                console.warn('client innerHTML: ', elm.innerHTML);\n              }\n              return false\n            }\n          } else {\n            // iterate and compare children lists\n            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[i$1], insertedVnodeQueue, inVPre)) {\n                childrenMatch = false;\n                break\n              }\n              childNode = childNode.nextSibling;\n            }\n            // if childNode is not null, it means the actual childNodes list is\n            // 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                !hydrationBailed\n              ) {\n                hydrationBailed = true;\n                console.warn('Parent: ', elm);\n                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n              }\n              return false\n            }\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            break\n          }\n        }\n        if (!fullInvoke && data['class']) {\n          // ensure collecting deps for deep class bindings for future updates\n          traverse(data['class']);\n        }\n      }\n    } else if (elm.data !== vnode.text) {\n      elm.data = vnode.text;\n    }\n    return true\n  }\n\n  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  }\n\n  return function patch (oldVnode, vnode, hydrating, removeOnly) {\n    if (isUndef(vnode)) {\n      if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }\n      return\n    }\n\n    var isInitialPatch = false;\n    var insertedVnodeQueue = [];\n\n    if (isUndef(oldVnode)) {\n      // empty mount (likely as component), create new root element\n      isInitialPatch = true;\n      createElm(vnode, insertedVnodeQueue);\n    } else {\n      var isRealElement = isDef(oldVnode.nodeType);\n      if (!isRealElement && sameVnode(oldVnode, vnode)) {\n        // patch existing root node\n        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);\n      } else {\n        if (isRealElement) {\n          // mounting to a real element\n          // check if this is server-rendered content and if we can perform\n          // 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 oldVnode\n            } 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 it\n          oldVnode = emptyNodeAt(oldVnode);\n        }\n\n        // replacing existing element\n        var oldElm = oldVnode.elm;\n        var parentElm = nodeOps.parentNode(oldElm);\n\n        // create new node\n        createElm(\n          vnode,\n          insertedVnodeQueue,\n          // extremely rare edge case: do not insert if old element is in a\n          // leaving transition. Only happens when combining transition +\n          // keep-alive + HOCs. (#4590)\n          oldElm._leaveCb ? null : parentElm,\n          nodeOps.nextSibling(oldElm)\n        );\n\n        // update parent placeholder node element, recursively\n        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[i](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[i$1](emptyNode, ancestor);\n              }\n              // #6513\n              // 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 hook\n                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {\n                  insert.fns[i$2]();\n                }\n              }\n            } else {\n              registerRef(ancestor);\n            }\n            ancestor = ancestor.parent;\n          }\n        }\n\n        // destroy old node\n        if (isDef(parentElm)) {\n          removeVnodes(parentElm, [oldVnode], 0, 0);\n        } else if (isDef(oldVnode.tag)) {\n          invokeDestroyHook(oldVnode);\n        }\n      }\n    }\n\n    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n    return vnode.elm\n  }\n}\n\n/*  */\n\nvar directives = {\n  create: updateDirectives,\n  update: updateDirectives,\n  destroy: function unbindDirectives (vnode) {\n    updateDirectives(vnode, emptyNode);\n  }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n  if (oldVnode.data.directives || vnode.data.directives) {\n    _update(oldVnode, vnode);\n  }\n}\n\nfunction _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);\n\n  var dirsWithInsert = [];\n  var dirsWithPostpatch = [];\n\n  var key, oldDir, dir;\n  for (key in newDirs) {\n    oldDir = oldDirs[key];\n    dir = newDirs[key];\n    if (!oldDir) {\n      // new directive, bind\n      callHook$1(dir, 'bind', vnode, oldVnode);\n      if (dir.def && dir.def.inserted) {\n        dirsWithInsert.push(dir);\n      }\n    } else {\n      // existing directive, update\n      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  }\n\n  if (dirsWithInsert.length) {\n    var callInsert = function () {\n      for (var i = 0; i < dirsWithInsert.length; i++) {\n        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n      }\n    };\n    if (isCreate) {\n      mergeVNodeHook(vnode, 'insert', callInsert);\n    } else {\n      callInsert();\n    }\n  }\n\n  if (dirsWithPostpatch.length) {\n    mergeVNodeHook(vnode, 'postpatch', function () {\n      for (var i = 0; i < dirsWithPostpatch.length; i++) {\n        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n      }\n    });\n  }\n\n  if (!isCreate) {\n    for (key in oldDirs) {\n      if (!newDirs[key]) {\n        // no longer present, unbind\n        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n      }\n    }\n  }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n  dirs,\n  vm\n) {\n  var res = Object.create(null);\n  if (!dirs) {\n    // $flow-disable-line\n    return res\n  }\n  var i, dir;\n  for (i = 0; i < dirs.length; i++) {\n    dir = dirs[i];\n    if (!dir.modifiers) {\n      // $flow-disable-line\n      dir.modifiers = emptyModifiers;\n    }\n    res[getRawDirName(dir)] = dir;\n    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n  }\n  // $flow-disable-line\n  return res\n}\n\nfunction getRawDirName (dir) {\n  return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n  var fn = dir.def && dir.def[hook];\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}\n\nvar baseModules = [\n  ref,\n  directives\n];\n\n/*  */\n\nfunction updateAttrs (oldVnode, vnode) {\n  var opts = vnode.componentOptions;\n  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {\n    return\n  }\n  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {\n    return\n  }\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 it\n  if (isDef(attrs.__ob__)) {\n    attrs = vnode.data.attrs = extend({}, attrs);\n  }\n\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      setAttr(elm, key, cur);\n    }\n  }\n  // #4391: in IE9, setting type can reset value for input[type=radio]\n  // #6666: IE/Edge forces progress value down to 1 before setting a max\n  /* 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[key])) {\n      if (isXlink(key)) {\n        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n      } else if (!isEnumeratedAttr(key)) {\n        elm.removeAttribute(key);\n      }\n    }\n  }\n}\n\nfunction 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 value\n    // 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> tag\n      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}\n\nfunction baseSetAttr (el, key, value) {\n  if (isFalsyAttrValue(value)) {\n    el.removeAttribute(key);\n  } else {\n    // #7138: IE10 & 11 fires input event when setting placeholder on\n    // <textarea>... block the first input event and remove the blocker\n    // immediately.\n    /* istanbul ignore if */\n    if (\n      isIE && !isIE9 &&\n      el.tagName === 'TEXTAREA' &&\n      key === 'placeholder' && value !== '' && !el.__ieph\n    ) {\n      var blocker = function (e) {\n        e.stopImmediatePropagation();\n        el.removeEventListener('input', blocker);\n      };\n      el.addEventListener('input', blocker);\n      // $flow-disable-line\n      el.__ieph = true; /* IE placeholder patched */\n    }\n    el.setAttribute(key, value);\n  }\n}\n\nvar attrs = {\n  create: updateAttrs,\n  update: updateAttrs\n};\n\n/*  */\n\nfunction 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    return\n  }\n\n  var cls = genClassForVnode(vnode);\n\n  // handle transition classes\n  var transitionClass = el._transitionClasses;\n  if (isDef(transitionClass)) {\n    cls = concat(cls, stringifyClass(transitionClass));\n  }\n\n  // set the class\n  if (cls !== el._prevClass) {\n    el.setAttribute('class', cls);\n    el._prevClass = cls;\n  }\n}\n\nvar klass = {\n  create: updateClass,\n  update: updateClass\n};\n\n/*  */\n\n/*  */\n\n/*  */\n\n/*  */\n\n// in some cases, the event used has to be determined at runtime\n// so we used some reserved tokens during compile.\nvar RANGE_TOKEN = '__r';\nvar CHECKBOX_RADIO_TOKEN = '__c';\n\n/*  */\n\n// 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 because\n// the whole point is ensuring the v-model callback gets called before\n// user-attached handlers.\nfunction normalizeEvents (on) {\n  /* istanbul ignore if */\n  if (isDef(on[RANGE_TOKEN])) {\n    // IE input[type=range] only supports `change` event\n    var event = isIE ? 'change' : 'input';\n    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);\n    delete on[RANGE_TOKEN];\n  }\n  // This was originally intended to fix #4521 but no longer necessary\n  // after 2.5. Keeping it for backwards compat with generated code from < 2.4\n  /* istanbul ignore if */\n  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {\n    on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);\n    delete on[CHECKBOX_RADIO_TOKEN];\n  }\n}\n\nvar target$1;\n\nfunction createOnceHandler$1 (event, handler, capture) {\n  var _target = target$1; // save current target element in closure\n  return function onceHandler () {\n    var res = handler.apply(null, arguments);\n    if (res !== null) {\n      remove$2(event, onceHandler, capture, _target);\n    }\n  }\n}\n\n// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp\n// implementation and does not fire microtasks in between event propagation, so\n// safe to exclude.\nvar useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);\n\nfunction add$1 (\n  name,\n  handler,\n  capture,\n  passive\n) {\n  // async edge case #6566: inner click event triggers patch, event handler\n  // attached to outer element during patch, and triggered again. This\n  // 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 fired\n  // 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 in\n        // certain weird environments...\n        e.target === e.currentTarget ||\n        // event is fired after handler attachment\n        e.timeStamp >= attachedTimestamp ||\n        // #9462 bail for iOS 9 bug: event.timeStamp is 0 after history.pushState\n        e.timeStamp === 0 ||\n        // #9448 bail if event is fired in another document in a multi-page\n        // electron/nw.js app, since event.timeStamp will be using a different\n        // starting reference\n        e.target.ownerDocument !== document\n      ) {\n        return original.apply(this, arguments)\n      }\n    };\n  }\n  target$1.addEventListener(\n    name,\n    handler,\n    supportsPassive\n      ? { capture: capture, passive: passive }\n      : capture\n  );\n}\n\nfunction remove$2 (\n  name,\n  handler,\n  capture,\n  _target\n) {\n  (_target || target$1).removeEventListener(\n    name,\n    handler._wrapper || handler,\n    capture\n  );\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {\n    return\n  }\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}\n\nvar events = {\n  create: updateDOMListeners,\n  update: updateDOMListeners\n};\n\n/*  */\n\nvar svgContainer;\n\nfunction updateDOMProps (oldVnode, vnode) {\n  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {\n    return\n  }\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 it\n  if (isDef(props.__ob__)) {\n    props = vnode.data.domProps = extend({}, props);\n  }\n\n  for (key in oldProps) {\n    if (isUndef(props[key])) {\n      elm[key] = '';\n    }\n  }\n  for (key in props) {\n    cur = props[key];\n    // ignore children if the node has textContent or innerHTML,\n    // as these will throw away existing DOM nodes and cause removal errors\n    // on subsequent patches (#3360)\n    if (key === 'textContent' || key === 'innerHTML') {\n      if (vnode.children) { vnode.children.length = 0; }\n      if (cur === oldProps[key]) { continue }\n      // #6601 work around Chrome version <= 55 bug where single textNode\n      // replaced by innerHTML/textContent retains its parentNode property\n      if (elm.childNodes.length === 1) {\n        elm.removeChild(elm.childNodes[0]);\n      }\n    }\n\n    if (key === 'value' && elm.tagName !== 'PROGRESS') {\n      // store value as _value as well since\n      // non-string values will be stringified\n      elm._value = cur;\n      // avoid resetting cursor position when value is the same\n      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 elements\n      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 temporarily\n      // out of sync with VDOM state due to focus, composition and modifiers.\n      // This  #4521 by skipping the unnecesarry `checked` update.\n      cur !== oldProps[key]\n    ) {\n      // some property updates can throw\n      // e.g. `value` on <progress> w/ non-finite value\n      try {\n        elm[key] = cur;\n      } catch (e) {}\n    }\n  }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (elm, checkVal) {\n  return (!elm.composing && (\n    elm.tagName === 'OPTION' ||\n    isNotInFocusAndDirty(elm, checkVal) ||\n    isDirtyWithModifiers(elm, checkVal)\n  ))\n}\n\nfunction isNotInFocusAndDirty (elm, checkVal) {\n  // return true when textbox (.number and .trim) loses focus and its value is\n  // not equal to the updated value\n  var notInFocus = true;\n  // #6157\n  // work around IE bug when accessing document.activeElement in an iframe\n  try { notInFocus = document.activeElement !== elm; } catch (e) {}\n  return notInFocus && elm.value !== checkVal\n}\n\nfunction isDirtyWithModifiers (elm, newVal) {\n  var value = elm.value;\n  var modifiers = elm._vModifiers; // injected by v-model runtime\n  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 !== newVal\n}\n\nvar domProps = {\n  create: updateDOMProps,\n  update: updateDOMProps\n};\n\n/*  */\n\nvar 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[0].trim()] = tmp[1].trim());\n    }\n  });\n  return res\n});\n\n// merge static and dynamic style data on the same vnode\nfunction normalizeStyleData (data) {\n  var style = normalizeStyleBinding(data.style);\n  // static style is pre-processed into an object during compilation\n  // and is always a fresh object, so it's safe to merge into it\n  return data.staticStyle\n    ? extend(data.staticStyle, style)\n    : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n  if (Array.isArray(bindingStyle)) {\n    return toObject(bindingStyle)\n  }\n  if (typeof bindingStyle === 'string') {\n    return parseStyleText(bindingStyle)\n  }\n  return bindingStyle\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle (vnode, checkChild) {\n  var res = {};\n  var styleData;\n\n  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  }\n\n  if ((styleData = normalizeStyleData(vnode.data))) {\n    extend(res, styleData);\n  }\n\n  var parentNode = vnode;\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n      extend(res, styleData);\n    }\n  }\n  return res\n}\n\n/*  */\n\nvar 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 recognize\n      for (var i = 0, len = val.length; i < len; i++) {\n        el.style[normalizedName] = val[i];\n      }\n    } else {\n      el.style[normalizedName] = val;\n    }\n  }\n};\n\nvar vendorNames = ['Webkit', 'Moz', 'ms'];\n\nvar 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 prop\n  }\n  var capName = prop.charAt(0).toUpperCase() + prop.slice(1);\n  for (var i = 0; i < vendorNames.length; i++) {\n    var name = vendorNames[i] + capName;\n    if (name in emptyStyle) {\n      return name\n    }\n  }\n});\n\nfunction updateStyle (oldVnode, vnode) {\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n\n  if (isUndef(data.staticStyle) && isUndef(data.style) &&\n    isUndef(oldData.staticStyle) && isUndef(oldData.style)\n  ) {\n    return\n  }\n\n  var cur, name;\n  var el = vnode.elm;\n  var oldStaticStyle = oldData.staticStyle;\n  var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};\n\n  // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n  var oldStyle = oldStaticStyle || oldStyleBinding;\n\n  var style = normalizeStyleBinding(vnode.data.style) || {};\n\n  // store normalized style under a different key for next diff\n  // make sure to clone it if it's reactive, since the user likely wants\n  // to mutate it.\n  vnode.data.normalizedStyle = isDef(style.__ob__)\n    ? extend({}, style)\n    : style;\n\n  var newStyle = getStyle(vnode, true);\n\n  for (name in oldStyle) {\n    if (isUndef(newStyle[name])) {\n      setProp(el, name, '');\n    }\n  }\n  for (name in newStyle) {\n    cur = newStyle[name];\n    if (cur !== oldStyle[name]) {\n      // ie9 setting to null has no effect, must use empty string\n      setProp(el, name, cur == null ? '' : cur);\n    }\n  }\n}\n\nvar style = {\n  create: updateStyle,\n  update: updateStyle\n};\n\n/*  */\n\nvar whitespaceRE = /\\s+/;\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !(cls = cls.trim())) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });\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}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !(cls = cls.trim())) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });\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}\n\n/*  */\n\nfunction resolveTransition (def$$1) {\n  if (!def$$1) {\n    return\n  }\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 res\n  } else if (typeof def$$1 === 'string') {\n    return autoCssTransition(def$$1)\n  }\n}\n\nvar 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});\n\nvar hasTransition = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar 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 !== undefined\n  ) {\n    transitionProp = 'WebkitTransition';\n    transitionEndEvent = 'webkitTransitionEnd';\n  }\n  if (window.onanimationend === undefined &&\n    window.onwebkitanimationend !== undefined\n  ) {\n    animationProp = 'WebkitAnimation';\n    animationEndEvent = 'webkitAnimationEnd';\n  }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser\n  ? window.requestAnimationFrame\n    ? window.requestAnimationFrame.bind(window)\n    : setTimeout\n  : /* istanbul ignore next */ function (fn) { return fn(); };\n\nfunction nextFrame (fn) {\n  raf(function () {\n    raf(fn);\n  });\n}\n\nfunction 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}\n\nfunction removeTransitionClass (el, cls) {\n  if (el._transitionClasses) {\n    remove(el._transitionClasses, cls);\n  }\n  removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n  el,\n  expectedType,\n  cb\n) {\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}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo (el, expectedType) {\n  var styles = window.getComputedStyle(el);\n  // JSDOM may return undefined for transition properties\n  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);\n\n  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 > 0\n      ? transitionTimeout > animationTimeout\n        ? TRANSITION\n        : ANIMATION\n      : null;\n    propCount = type\n      ? type === TRANSITION\n        ? transitionDurations.length\n        : animationDurations.length\n      : 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: hasTransform\n  }\n}\n\nfunction getTimeout (delays, durations) {\n  /* istanbul ignore next */\n  while (delays.length < durations.length) {\n    delays = delays.concat(delays);\n  }\n\n  return Math.max.apply(null, durations.map(function (d, i) {\n    return toMs(d) + toMs(delays[i])\n  }))\n}\n\n// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers\n// 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. acting\n// as a floor function) causing unexpected behaviors\nfunction toMs (s) {\n  return Number(s.slice(0, -1).replace(',', '.')) * 1000\n}\n\n/*  */\n\nfunction enter (vnode, toggleDisplay) {\n  var el = vnode.elm;\n\n  // call leave callback now\n  if (isDef(el._leaveCb)) {\n    el._leaveCb.cancelled = true;\n    el._leaveCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (isUndef(data)) {\n    return\n  }\n\n  /* istanbul ignore if */\n  if (isDef(el._enterCb) || el.nodeType !== 1) {\n    return\n  }\n\n  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;\n\n  // activeInstance will always be the <transition> component managing this\n  // transition. One edge case to check is when the <transition> is placed\n  // as the root node of a child component. In that case we need to check\n  // <transition>'s parent for appear check.\n  var context = activeInstance;\n  var transitionNode = activeInstance.$vnode;\n  while (transitionNode && transitionNode.parent) {\n    transitionNode = transitionNode.parent;\n    context = transitionNode.context;\n  }\n\n  var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n  if (isAppear && !appear && appear !== '') {\n    return\n  }\n\n  var startClass = isAppear && appearClass\n    ? appearClass\n    : enterClass;\n  var activeClass = isAppear && appearActiveClass\n    ? appearActiveClass\n    : enterActiveClass;\n  var toClass = isAppear && appearToClass\n    ? appearToClass\n    : enterToClass;\n\n  var beforeEnterHook = isAppear\n    ? (beforeAppear || beforeEnter)\n    : beforeEnter;\n  var enterHook = isAppear\n    ? (typeof appear === 'function' ? appear : enter)\n    : enter;\n  var afterEnterHook = isAppear\n    ? (afterAppear || afterEnter)\n    : afterEnter;\n  var enterCancelledHook = isAppear\n    ? (appearCancelled || enterCancelled)\n    : enterCancelled;\n\n  var explicitEnterDuration = toNumber(\n    isObject(duration)\n      ? duration.enter\n      : duration\n  );\n\n  if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {\n    checkDuration(explicitEnterDuration, 'enter', vnode);\n  }\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl = getHookArgumentsLength(enterHook);\n\n  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  });\n\n  if (!vnode.data.show) {\n    // remove pending leave element on enter by injecting an insert hook\n    mergeVNodeHook(vnode, 'insert', function () {\n      var parent = el.parentNode;\n      var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n      if (pendingNode &&\n        pendingNode.tag === vnode.tag &&\n        pendingNode.elm._leaveCb\n      ) {\n        pendingNode.elm._leaveCb();\n      }\n      enterHook && enterHook(el, cb);\n    });\n  }\n\n  // start enter transition\n  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  }\n\n  if (vnode.data.show) {\n    toggleDisplay && toggleDisplay();\n    enterHook && enterHook(el, cb);\n  }\n\n  if (!expectsCSS && !userWantsControl) {\n    cb();\n  }\n}\n\nfunction leave (vnode, rm) {\n  var el = vnode.elm;\n\n  // call enter callback now\n  if (isDef(el._enterCb)) {\n    el._enterCb.cancelled = true;\n    el._enterCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (isUndef(data) || el.nodeType !== 1) {\n    return rm()\n  }\n\n  /* istanbul ignore if */\n  if (isDef(el._leaveCb)) {\n    return\n  }\n\n  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;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl = getHookArgumentsLength(leave);\n\n  var explicitLeaveDuration = toNumber(\n    isObject(duration)\n      ? duration.leave\n      : duration\n  );\n\n  if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {\n    checkDuration(explicitLeaveDuration, 'leave', vnode);\n  }\n\n  var cb = el._leaveCb = once(function () {\n    if (el.parentNode && el.parentNode._pending) {\n      el.parentNode._pending[vnode.key] = 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  });\n\n  if (delayLeave) {\n    delayLeave(performLeave);\n  } else {\n    performLeave();\n  }\n\n  function performLeave () {\n    // the delayed leave may have already been cancelled\n    if (cb.cancelled) {\n      return\n    }\n    // record leaving element\n    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}\n\n// only used in dev mode\nfunction 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.context\n    );\n  } else if (isNaN(val)) {\n    warn(\n      \"<transition> explicit \" + name + \" duration is NaN - \" +\n      'the duration expression might be incorrect.',\n      vnode.context\n    );\n  }\n}\n\nfunction isValidDuration (val) {\n  return typeof val === 'number' && !isNaN(val)\n}\n\n/**\n * Normalize a transition hook's argument length. The hook may be:\n * - a merged hook (invoker) with the original in .fns\n * - a wrapped component method (check ._length)\n * - a plain function (.length)\n */\nfunction getHookArgumentsLength (fn) {\n  if (isUndef(fn)) {\n    return false\n  }\n  var invokerFns = fn.fns;\n  if (isDef(invokerFns)) {\n    // invoker\n    return getHookArgumentsLength(\n      Array.isArray(invokerFns)\n        ? invokerFns[0]\n        : invokerFns\n    )\n  } else {\n    return (fn._length || fn.length) > 1\n  }\n}\n\nfunction _enter (_, vnode) {\n  if (vnode.data.show !== true) {\n    enter(vnode);\n  }\n}\n\nvar 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} : {};\n\nvar platformModules = [\n  attrs,\n  klass,\n  events,\n  domProps,\n  style,\n  transition\n];\n\n/*  */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\n/* istanbul ignore if */\nif (isIE9) {\n  // http://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}\n\nvar directive = {\n  inserted: function inserted (el, binding, vnode, oldVnode) {\n    if (vnode.tag === 'select') {\n      // #6903\n      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 when\n        // switching focus before confirming composition choice\n        // this also fixes the issue where some browsers e.g. iOS Chrome\n        // 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  },\n\n  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 matching\n      // 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[i]); })) {\n        // trigger change event if\n        // no matching option found for at least one value\n        var needReset = el.multiple\n          ? 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};\n\nfunction 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}\n\nfunction 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      vm\n    );\n    return\n  }\n  var selected, option;\n  for (var i = 0, l = el.options.length; i < l; i++) {\n    option = el.options[i];\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        return\n      }\n    }\n  }\n  if (!isMultiple) {\n    el.selectedIndex = -1;\n  }\n}\n\nfunction hasNoMatchingOption (value, options) {\n  return options.every(function (o) { return !looseEqual(o, value); })\n}\n\nfunction getValue (option) {\n  return '_value' in option\n    ? option._value\n    : option.value\n}\n\nfunction onCompositionStart (e) {\n  e.target.composing = true;\n}\n\nfunction onCompositionEnd (e) {\n  // prevent triggering an input event for no reason\n  if (!e.target.composing) { return }\n  e.target.composing = false;\n  trigger(e.target, 'input');\n}\n\nfunction trigger (el, type) {\n  var e = document.createEvent('HTMLEvents');\n  e.initEvent(type, true, true);\n  el.dispatchEvent(e);\n}\n\n/*  */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n    ? locateNode(vnode.componentInstance._vnode)\n    : vnode\n}\n\nvar show = {\n  bind: function bind (el, ref, vnode) {\n    var value = ref.value;\n\n    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  },\n\n  update: function update (el, ref, vnode) {\n    var value = ref.value;\n    var oldValue = ref.oldValue;\n\n    /* 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  },\n\n  unbind: function unbind (\n    el,\n    binding,\n    vnode,\n    oldVnode,\n    isDestroy\n  ) {\n    if (!isDestroy) {\n      el.style.display = el.__vOriginalDisplay;\n    }\n  }\n};\n\nvar platformDirectives = {\n  model: directive,\n  show: show\n};\n\n/*  */\n\nvar 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};\n\n// in case the child is also an abstract component, e.g. <keep-alive>\n// we want to recursively retrieve the real component to be rendered\nfunction 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 vnode\n  }\n}\n\nfunction extractTransitionData (comp) {\n  var data = {};\n  var options = comp.$options;\n  // props\n  for (var key in options.propsData) {\n    data[key] = comp[key];\n  }\n  // events.\n  // extract listeners and pass them directly to the transition methods\n  var listeners = options._parentListeners;\n  for (var key$1 in listeners) {\n    data[camelize(key$1)] = listeners[key$1];\n  }\n  return data\n}\n\nfunction placeholder (h, rawChild) {\n  if (/\\d-keep-alive$/.test(rawChild.tag)) {\n    return h('keep-alive', {\n      props: rawChild.componentOptions.propsData\n    })\n  }\n}\n\nfunction hasParentTransition (vnode) {\n  while ((vnode = vnode.parent)) {\n    if (vnode.data.transition) {\n      return true\n    }\n  }\n}\n\nfunction isSameChild (child, oldChild) {\n  return oldChild.key === child.key && oldChild.tag === child.tag\n}\n\nvar isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };\n\nvar isVShowDirective = function (d) { return d.name === 'show'; };\n\nvar Transition = {\n  name: 'transition',\n  props: transitionProps,\n  abstract: true,\n\n  render: function render (h) {\n    var this$1 = this;\n\n    var children = this.$slots.default;\n    if (!children) {\n      return\n    }\n\n    // filter out text nodes (possible whitespaces)\n    children = children.filter(isNotTextNode);\n    /* istanbul ignore if */\n    if (!children.length) {\n      return\n    }\n\n    // warn multiple elements\n    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.$parent\n      );\n    }\n\n    var mode = this.mode;\n\n    // warn invalid mode\n    if (process.env.NODE_ENV !== 'production' &&\n      mode && mode !== 'in-out' && mode !== 'out-in'\n    ) {\n      warn(\n        'invalid <transition> mode: ' + mode,\n        this.$parent\n      );\n    }\n\n    var rawChild = children[0];\n\n    // if this is a component root node and the component's\n    // parent container node also has transition, skip.\n    if (hasParentTransition(this.$vnode)) {\n      return rawChild\n    }\n\n    // apply transition data to child\n    // use getRealChild() to ignore abstract components e.g. keep-alive\n    var child = getRealChild(rawChild);\n    /* istanbul ignore if */\n    if (!child) {\n      return rawChild\n    }\n\n    if (this._leaving) {\n      return placeholder(h, rawChild)\n    }\n\n    // ensure a key that is unique to the vnode type and to this transition\n    // component instance. This key will be used to remove pending leaving nodes\n    // during entering.\n    var id = \"__transition-\" + (this._uid) + \"-\";\n    child.key = child.key == null\n      ? child.isComment\n        ? id + 'comment'\n        : id + child.tag\n      : isPrimitive(child.key)\n        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n        : child.key;\n\n    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n    var oldRawChild = this._vnode;\n    var oldChild = getRealChild(oldRawChild);\n\n    // mark v-show\n    // so that the transition module can hand over the control to the directive\n    if (child.data.directives && child.data.directives.some(isVShowDirective)) {\n      child.data.show = true;\n    }\n\n    if (\n      oldChild &&\n      oldChild.data &&\n      !isSameChild(child, oldChild) &&\n      !isAsyncPlaceholder(oldChild) &&\n      // #6687 component root is a comment node\n      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)\n    ) {\n      // replace old child transition data with fresh one\n      // important for dynamic transitions!\n      var oldData = oldChild.data.transition = extend({}, data);\n      // handle transition mode\n      if (mode === 'out-in') {\n        // return placeholder node and queue update when leave finishes\n        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 oldRawChild\n        }\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    }\n\n    return rawChild\n  }\n};\n\n/*  */\n\nvar props = extend({\n  tag: String,\n  moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n  props: props,\n\n  beforeMount: function beforeMount () {\n    var this$1 = this;\n\n    var update = this._update;\n    this._update = function (vnode, hydrating) {\n      var restoreActiveInstance = setActiveInstance(this$1);\n      // force removing pass\n      this$1.__patch__(\n        this$1._vnode,\n        this$1.kept,\n        false, // hydrating\n        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  },\n\n  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);\n\n    for (var i = 0; i < rawChildren.length; i++) {\n      var c = rawChildren[i];\n      if (c.tag) {\n        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n          children.push(c);\n          map[c.key] = c\n          ;(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    }\n\n    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[i$1];\n        c$1.data.transition = transitionData;\n        c$1.data.pos = c$1.elm.getBoundingClientRect();\n        if (map[c$1.key]) {\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    }\n\n    return h(tag, null, children)\n  },\n\n  updated: function updated () {\n    var children = this.prevChildren;\n    var moveClass = this.moveClass || ((this.name || 'v') + '-move');\n    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n      return\n    }\n\n    // we divide the work into three loops to avoid mixing DOM reads and writes\n    // in each iteration - which helps prevent layout thrashing.\n    children.forEach(callPendingCbs);\n    children.forEach(recordPosition);\n    children.forEach(applyTranslation);\n\n    // force reflow to put everything in position\n    // assign to this to avoid being removed in tree-shaking\n    // $flow-disable-line\n    this._reflow = document.body.offsetHeight;\n\n    children.forEach(function (c) {\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            return\n          }\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  },\n\n  methods: {\n    hasMove: function hasMove (el, moveClass) {\n      /* istanbul ignore if */\n      if (!hasTransition) {\n        return false\n      }\n      /* istanbul ignore if */\n      if (this._hasMove) {\n        return this._hasMove\n      }\n      // Detect whether an element with the move class applied has\n      // CSS transitions. Since the element may be inside an entering\n      // transition at this very moment, we make a clone of it and remove\n      // all other transition classes applied to ensure only the move class\n      // 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};\n\nfunction callPendingCbs (c) {\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}\n\nfunction recordPosition (c) {\n  c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation (c) {\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}\n\nvar platformComponents = {\n  Transition: Transition,\n  TransitionGroup: TransitionGroup\n};\n\n/*  */\n\n// install platform specific utils\nVue.config.mustUseProp = mustUseProp;\nVue.config.isReservedTag = isReservedTag;\nVue.config.isReservedAttr = isReservedAttr;\nVue.config.getTagNamespace = getTagNamespace;\nVue.config.isUnknownElement = isUnknownElement;\n\n// install platform runtime directives & components\nextend(Vue.options.directives, platformDirectives);\nextend(Vue.options.components, platformComponents);\n\n// install platform patch function\nVue.prototype.__patch__ = inBrowser ? patch : noop;\n\n// public mount method\nVue.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && inBrowser ? query(el) : undefined;\n  return mountComponent(this, el, hydrating)\n};\n\n// devtools global hook\n/* 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          'https://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 https://vuejs.org/guide/deployment.html\"\n      );\n    }\n  }, 0);\n}\n\n/*  */\n\nexport default Vue;\n","function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  }\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\nmodule.exports = _nonIterableSpread;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n!(function(global) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  var inModule = typeof module === \"object\";\n  var runtime = global.regeneratorRuntime;\n  if (runtime) {\n    if (inModule) {\n      // If regeneratorRuntime is defined globally and we're in a module,\n      // make the exports object identical to regeneratorRuntime.\n      module.exports = runtime;\n    }\n    // Don't bother evaluating the rest of this file if the runtime was\n    // already defined globally.\n    return;\n  }\n\n  // Define the runtime globally (as expected by generated code) as either\n  // module.exports (if we're in a module) or a new, empty object.\n  runtime = global.regeneratorRuntime = inModule ? module.exports : {};\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  runtime.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  runtime.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  runtime.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  runtime.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return Promise.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return Promise.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  runtime.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  runtime.async = function(innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\n    );\n\n    return runtime.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        if (delegate.iterator.return) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  runtime.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  runtime.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n})(\n  // In sloppy mode, unbound `this` refers to the global object, fallback to\n  // Function constructor if we're in global strict mode. That is sadly a form\n  // of indirect eval which violates Content Security Policy.\n  (function() {\n    return this || (typeof self === \"object\" && self);\n  })() || Function(\"return this\")()\n);\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n// This method of obtaining a reference to the global object needs to be\n// kept identical to the way it is obtained in runtime.js\nvar g = (function() {\n  return this || (typeof self === \"object\" && self);\n})() || Function(\"return this\")();\n\n// Use `getOwnPropertyNames` because not all browsers support calling\n// `hasOwnProperty` on the global `self` object in a worker. See #183.\nvar hadRuntime = g.regeneratorRuntime &&\n  Object.getOwnPropertyNames(g).indexOf(\"regeneratorRuntime\") >= 0;\n\n// Save the old regeneratorRuntime in case it needs to be restored later.\nvar oldRuntime = hadRuntime && g.regeneratorRuntime;\n\n// Force reevalutation of runtime.js.\ng.regeneratorRuntime = undefined;\n\nmodule.exports = require(\"./runtime\");\n\nif (hadRuntime) {\n  // Restore the original runtime.\n  g.regeneratorRuntime = oldRuntime;\n} else {\n  // Remove the global property added by runtime.js.\n  try {\n    delete g.regeneratorRuntime;\n  } catch(e) {\n    g.regeneratorRuntime = undefined;\n  }\n}\n","module.exports = require(\"regenerator-runtime\");\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty;","var defineProperty = require(\"./defineProperty\");\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n    var ownKeys = Object.keys(source);\n\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n\n    ownKeys.forEach(function (key) {\n      defineProperty(target, key, source[key]);\n    });\n  }\n\n  return target;\n}\n\nmodule.exports = _objectSpread;","/*!\n * better-normal-scroll v1.14.1\n * (c) 2016-2019 ustbhuangyi\n * Released under the MIT License.\n */\n// As of V8 6.6, depending on the size of the array, this is anywhere\n// between 1.5-10x faster than the two-arg version of Array#splice()\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++) {\n    list[index] = list[index + 1];\n  }\n\n  list.pop();\n}\n\nvar slicedToArray = function () {\n  function sliceIterator(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"]) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  return function (arr, i) {\n    if (Array.isArray(arr)) {\n      return arr;\n    } else if (Symbol.iterator in Object(arr)) {\n      return sliceIterator(arr, i);\n    } else {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }\n  };\n}();\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar toConsumableArray = function (arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n};\n\nfunction eventMixin(BScroll) {\n  BScroll.prototype.on = function (type, fn) {\n    var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this;\n\n    if (!this._events[type]) {\n      this._events[type] = [];\n    }\n\n    this._events[type].push([fn, context]);\n  };\n\n  BScroll.prototype.once = function (type, fn) {\n    var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this;\n\n    function magic() {\n      this.off(type, magic);\n\n      fn.apply(context, arguments);\n    }\n    // To expose the corresponding function method in order to execute the off method\n    magic.fn = fn;\n\n    this.on(type, magic);\n  };\n\n  BScroll.prototype.off = function (type, fn) {\n    var _events = this._events[type];\n    if (!_events) {\n      return;\n    }\n\n    var count = _events.length;\n    while (count--) {\n      if (_events[count][0] === fn || _events[count][0] && _events[count][0].fn === fn) {\n        spliceOne(_events, count);\n      }\n    }\n  };\n\n  BScroll.prototype.trigger = function (type) {\n    var events = this._events[type];\n    if (!events) {\n      return;\n    }\n\n    var len = events.length;\n    var eventsCopy = [].concat(toConsumableArray(events));\n    for (var i = 0; i < len; i++) {\n      var event = eventsCopy[i];\n\n      var _event = slicedToArray(event, 2),\n          fn = _event[0],\n          context = _event[1];\n\n      if (fn) {\n        fn.apply(context, [].slice.call(arguments, 1));\n      }\n    }\n  };\n}\n\n// ssr support\nvar inBrowser = typeof window !== 'undefined';\nvar ua = inBrowser && navigator.userAgent.toLowerCase();\nvar isWeChatDevTools = ua && /wechatdevtools/.test(ua);\nvar isAndroid = ua && ua.indexOf('android') > 0;\n\nfunction getNow() {\n  return window.performance && window.performance.now ? window.performance.now() + window.performance.timing.navigationStart : +new Date();\n}\n\nfunction extend(target) {\n  for (var _len = arguments.length, rest = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    rest[_key - 1] = arguments[_key];\n  }\n\n  for (var i = 0; i < rest.length; i++) {\n    var source = rest[i];\n    for (var key in source) {\n      target[key] = source[key];\n    }\n  }\n  return target;\n}\n\nfunction isUndef(v) {\n  return v === undefined || v === null;\n}\n\nfunction getDistance(x, y) {\n  return Math.sqrt(x * x + y * y);\n}\n\nvar elementStyle = inBrowser && document.createElement('div').style;\n\nvar vendor = function () {\n  if (!inBrowser) {\n    return false;\n  }\n  var transformNames = {\n    webkit: 'webkitTransform',\n    Moz: 'MozTransform',\n    O: 'OTransform',\n    ms: 'msTransform',\n    standard: 'transform'\n  };\n\n  for (var key in transformNames) {\n    if (elementStyle[transformNames[key]] !== undefined) {\n      return key;\n    }\n  }\n\n  return false;\n}();\n\nfunction prefixStyle(style) {\n  if (vendor === false) {\n    return false;\n  }\n\n  if (vendor === 'standard') {\n    if (style === 'transitionEnd') {\n      return 'transitionend';\n    }\n    return style;\n  }\n\n  return vendor + style.charAt(0).toUpperCase() + style.substr(1);\n}\n\nfunction addEvent(el, type, fn, capture) {\n  el.addEventListener(type, fn, { passive: false, capture: !!capture });\n}\n\nfunction removeEvent(el, type, fn, capture) {\n  el.removeEventListener(type, fn, { passive: false, capture: !!capture });\n}\n\nfunction offset(el) {\n  var left = 0;\n  var top = 0;\n\n  while (el) {\n    left -= el.offsetLeft;\n    top -= el.offsetTop;\n    el = el.offsetParent;\n  }\n\n  return {\n    left: left,\n    top: top\n  };\n}\n\nfunction offsetToBody(el) {\n  var rect = el.getBoundingClientRect();\n\n  return {\n    left: -(rect.left + window.pageXOffset),\n    top: -(rect.top + window.pageYOffset)\n  };\n}\n\nvar cssVendor = vendor && vendor !== 'standard' ? '-' + vendor.toLowerCase() + '-' : '';\n\nvar transform = prefixStyle('transform');\nvar transition = prefixStyle('transition');\n\nvar hasPerspective = inBrowser && prefixStyle('perspective') in elementStyle;\n// fix issue #361\nvar hasTouch = inBrowser && ('ontouchstart' in window || isWeChatDevTools);\nvar hasTransform = transform !== false;\nvar hasTransition = inBrowser && transition in elementStyle;\n\nvar style = {\n  transform: transform,\n  transition: transition,\n  transitionTimingFunction: prefixStyle('transitionTimingFunction'),\n  transitionDuration: prefixStyle('transitionDuration'),\n  transitionDelay: prefixStyle('transitionDelay'),\n  transformOrigin: prefixStyle('transformOrigin'),\n  transitionEnd: prefixStyle('transitionEnd')\n};\n\nvar TOUCH_EVENT = 1;\nvar MOUSE_EVENT = 2;\n\nvar eventType = {\n  touchstart: TOUCH_EVENT,\n  touchmove: TOUCH_EVENT,\n  touchend: TOUCH_EVENT,\n\n  mousedown: MOUSE_EVENT,\n  mousemove: MOUSE_EVENT,\n  mouseup: MOUSE_EVENT\n};\n\nfunction getRect(el) {\n  if (el instanceof window.SVGElement) {\n    var rect = el.getBoundingClientRect();\n    return {\n      top: rect.top,\n      left: rect.left,\n      width: rect.width,\n      height: rect.height\n    };\n  } else {\n    return {\n      top: el.offsetTop,\n      left: el.offsetLeft,\n      width: el.offsetWidth,\n      height: el.offsetHeight\n    };\n  }\n}\n\nfunction preventDefaultException(el, exceptions) {\n  for (var i in exceptions) {\n    if (exceptions[i].test(el[i])) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction tap(e, eventName) {\n  var ev = document.createEvent('Event');\n  ev.initEvent(eventName, true, true);\n  ev.pageX = e.pageX;\n  ev.pageY = e.pageY;\n  e.target.dispatchEvent(ev);\n}\n\nfunction click(e) {\n  var event = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'click';\n\n  var eventSource = void 0;\n  if (e.type === 'mouseup' || e.type === 'mousecancel') {\n    eventSource = e;\n  } else if (e.type === 'touchend' || e.type === 'touchcancel') {\n    eventSource = e.changedTouches[0];\n  }\n  var posSrc = {};\n  if (eventSource) {\n    posSrc.screenX = eventSource.screenX || 0;\n    posSrc.screenY = eventSource.screenY || 0;\n    posSrc.clientX = eventSource.clientX || 0;\n    posSrc.clientY = eventSource.clientY || 0;\n  }\n  var ev = void 0;\n  var bubbles = true;\n  var cancelable = true;\n  if (typeof MouseEvent !== 'undefined') {\n    try {\n      ev = new MouseEvent(event, extend({\n        bubbles: bubbles,\n        cancelable: cancelable\n      }, posSrc));\n    } catch (e) {\n      createEvent();\n    }\n  } else {\n    createEvent();\n  }\n\n  function createEvent() {\n    ev = document.createEvent('Event');\n    ev.initEvent(event, bubbles, cancelable);\n    extend(ev, posSrc);\n  }\n\n  // forwardedTouchEvent set to true in case of the conflict with fastclick\n  ev.forwardedTouchEvent = true;\n  ev._constructed = true;\n  e.target.dispatchEvent(ev);\n}\n\nfunction dblclick(e) {\n  click(e, 'dblclick');\n}\n\nfunction prepend(el, target) {\n  if (target.firstChild) {\n    before(el, target.firstChild);\n  } else {\n    target.appendChild(el);\n  }\n}\n\nfunction before(el, target) {\n  target.parentNode.insertBefore(el, target);\n}\n\nfunction removeChild(el, child) {\n  el.removeChild(child);\n}\n\nvar DEFAULT_OPTIONS = {\n  startX: 0,\n  startY: 0,\n  scrollX: false,\n  scrollY: true,\n  freeScroll: false,\n  directionLockThreshold: 5,\n  eventPassthrough: '',\n  click: false,\n  tap: false,\n  /**\n   * support any side\n   * bounce: {\n   *   top: true,\n   *   bottom: true,\n   *   left: true,\n   *   right: true\n   * }\n   */\n  bounce: true,\n  bounceTime: 800,\n  momentum: true,\n  momentumLimitTime: 300,\n  momentumLimitDistance: 15,\n  swipeTime: 2500,\n  swipeBounceTime: 500,\n  deceleration: 0.0015,\n  flickLimitTime: 200,\n  flickLimitDistance: 100,\n  resizePolling: 60,\n  probeType: 0,\n  preventDefault: true,\n  preventDefaultException: {\n    tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT|AUDIO)$/\n  },\n  HWCompositing: true,\n  useTransition: true,\n  useTransform: true,\n  bindToWrapper: false,\n  disableMouse: hasTouch,\n  disableTouch: !hasTouch,\n  observeDOM: true,\n  autoBlur: true,\n  /**\n   * for picker\n   * wheel: {\n   *   selectedIndex: 0,\n   *   rotate: 25,\n   *   adjustTime: 400\n   *   wheelWrapperClass: 'wheel-scroll',\n   *   wheelItemClass: 'wheel-item'\n   * }\n   */\n  wheel: false,\n  /**\n   * for slide\n   * snap: {\n   *   loop: false,\n   *   el: domEl,\n   *   threshold: 0.1,\n   *   stepX: 100,\n   *   stepY: 100,\n   *   speed: 400,\n   *   easing: {\n   *     style: 'cubic-bezier(0.25, 0.46, 0.45, 0.94)',\n   *     fn: function (t) {\n   *       return t * (2 - t)\n   *     }\n   *   }\n   *   listenFlick: true\n   * }\n   */\n  snap: false,\n  /**\n   * for scrollbar\n   * scrollbar: {\n   *   fade: true,\n   *   interactive: false\n   * }\n   */\n  scrollbar: false,\n  /**\n   * for pull down and refresh\n   * pullDownRefresh: {\n   *   threshold: 50,\n   *   stop: 20\n   * }\n   */\n  pullDownRefresh: false,\n  /**\n   * for pull up and load\n   * pullUpLoad: {\n   *   threshold: 50\n   * }\n   */\n  pullUpLoad: false,\n  /**\n   * for mouse wheel\n   * mouseWheel: {\n   *   speed: 20,\n   *   invert: false,\n   *   easeTime: 300\n   * }\n   */\n  mouseWheel: false,\n  stopPropagation: false,\n  /**\n   * for zoom\n   * zoom: {\n   *   start: 1,\n   *   min: 1,\n   *   max: 4\n   * }\n   */\n  zoom: false,\n  /**\n   * for infinity\n   * infinity: {\n   *   render(item, div) {\n   *   },\n   *   createTombstone() {\n   *   },\n   *   fetch(count) {\n   *   }\n   * }\n   */\n  infinity: false,\n  /**\n   * for double click\n   * dblclick: {\n   *   delay: 300\n   * }\n   */\n  dblclick: false\n};\n\nfunction initMixin(BScroll) {\n  BScroll.prototype._init = function (options) {\n    this._handleOptions(options);\n\n    // init private custom events\n    this._events = {};\n\n    this.x = 0;\n    this.y = 0;\n    this.directionX = 0;\n    this.directionY = 0;\n\n    this.setScale(1);\n\n    this._addDOMEvents();\n\n    this._initExtFeatures();\n\n    this._watchTransition();\n\n    if (this.options.observeDOM) {\n      this._initDOMObserver();\n    }\n\n    if (this.options.autoBlur) {\n      this._handleAutoBlur();\n    }\n\n    this.refresh();\n\n    if (!this.options.snap) {\n      this.scrollTo(this.options.startX, this.options.startY);\n    }\n\n    this.enable();\n  };\n\n  BScroll.prototype.setScale = function (scale) {\n    this.lastScale = isUndef(this.scale) ? scale : this.scale;\n    this.scale = scale;\n  };\n\n  BScroll.prototype._handleOptions = function (options) {\n    this.options = extend({}, DEFAULT_OPTIONS, options);\n\n    this.translateZ = this.options.HWCompositing && hasPerspective ? ' translateZ(0)' : '';\n\n    this.options.useTransition = this.options.useTransition && hasTransition;\n    this.options.useTransform = this.options.useTransform && hasTransform;\n\n    this.options.preventDefault = !this.options.eventPassthrough && this.options.preventDefault;\n\n    // If you want eventPassthrough I have to lock one of the axes\n    this.options.scrollX = this.options.eventPassthrough === 'horizontal' ? false : this.options.scrollX;\n    this.options.scrollY = this.options.eventPassthrough === 'vertical' ? false : this.options.scrollY;\n\n    // With eventPassthrough we also need lockDirection mechanism\n    this.options.freeScroll = this.options.freeScroll && !this.options.eventPassthrough;\n    this.options.directionLockThreshold = this.options.eventPassthrough ? 0 : this.options.directionLockThreshold;\n\n    if (this.options.tap === true) {\n      this.options.tap = 'tap';\n    }\n  };\n\n  BScroll.prototype._addDOMEvents = function () {\n    var eventOperation = addEvent;\n    this._handleDOMEvents(eventOperation);\n  };\n\n  BScroll.prototype._removeDOMEvents = function () {\n    var eventOperation = removeEvent;\n    this._handleDOMEvents(eventOperation);\n  };\n\n  BScroll.prototype._handleDOMEvents = function (eventOperation) {\n    var target = this.options.bindToWrapper ? this.wrapper : window;\n    eventOperation(window, 'orientationchange', this);\n    eventOperation(window, 'resize', this);\n\n    if (this.options.click) {\n      eventOperation(this.wrapper, 'click', this, true);\n    }\n\n    if (!this.options.disableMouse) {\n      eventOperation(this.wrapper, 'mousedown', this);\n      eventOperation(target, 'mousemove', this);\n      eventOperation(target, 'mousecancel', this);\n      eventOperation(target, 'mouseup', this);\n    }\n\n    if (hasTouch && !this.options.disableTouch) {\n      eventOperation(this.wrapper, 'touchstart', this);\n      eventOperation(target, 'touchmove', this);\n      eventOperation(target, 'touchcancel', this);\n      eventOperation(target, 'touchend', this);\n    }\n\n    eventOperation(this.scroller, style.transitionEnd, this);\n  };\n\n  BScroll.prototype._initExtFeatures = function () {\n    if (this.options.snap) {\n      this._initSnap();\n    }\n    if (this.options.scrollbar) {\n      this._initScrollbar();\n    }\n    if (this.options.pullUpLoad) {\n      this._initPullUp();\n    }\n    if (this.options.pullDownRefresh) {\n      this._initPullDown();\n    }\n    if (this.options.wheel) {\n      this._initWheel();\n    }\n    if (this.options.mouseWheel) {\n      this._initMouseWheel();\n    }\n    if (this.options.zoom) {\n      this._initZoom();\n    }\n    if (this.options.infinity) {\n      this._initInfinite();\n    }\n  };\n\n  BScroll.prototype._watchTransition = function () {\n    if (typeof Object.defineProperty !== 'function') {\n      return;\n    }\n    var me = this;\n    var isInTransition = false;\n    var key = this.options.useTransition ? 'isInTransition' : 'isAnimating';\n    Object.defineProperty(this, key, {\n      get: function get() {\n        return isInTransition;\n      },\n      set: function set(newVal) {\n        isInTransition = newVal;\n        // fix issue #359\n        var el = me.scroller.children.length ? me.scroller.children : [me.scroller];\n        var pointerEvents = isInTransition && !me.pulling ? 'none' : 'auto';\n        for (var i = 0; i < el.length; i++) {\n          el[i].style.pointerEvents = pointerEvents;\n        }\n      }\n    });\n  };\n\n  BScroll.prototype._handleAutoBlur = function () {\n    this.on('scrollStart', function () {\n      var activeElement = document.activeElement;\n      if (activeElement && (activeElement.tagName === 'INPUT' || activeElement.tagName === 'TEXTAREA')) {\n        activeElement.blur();\n      }\n    });\n  };\n\n  BScroll.prototype._initDOMObserver = function () {\n    var _this = this;\n\n    if (typeof MutationObserver !== 'undefined') {\n      var timer = void 0;\n      var observer = new MutationObserver(function (mutations) {\n        // don't do any refresh during the transition, or outside of the boundaries\n        if (_this._shouldNotRefresh()) {\n          return;\n        }\n        var immediateRefresh = false;\n        var deferredRefresh = false;\n        for (var i = 0; i < mutations.length; i++) {\n          var mutation = mutations[i];\n          if (mutation.type !== 'attributes') {\n            immediateRefresh = true;\n            break;\n          } else {\n            if (mutation.target !== _this.scroller) {\n              deferredRefresh = true;\n              break;\n            }\n          }\n        }\n        if (immediateRefresh) {\n          _this.refresh();\n        } else if (deferredRefresh) {\n          // attributes changes too often\n          clearTimeout(timer);\n          timer = setTimeout(function () {\n            if (!_this._shouldNotRefresh()) {\n              _this.refresh();\n            }\n          }, 60);\n        }\n      });\n      var config = {\n        attributes: true,\n        childList: true,\n        subtree: true\n      };\n      observer.observe(this.scroller, config);\n\n      this.on('destroy', function () {\n        observer.disconnect();\n      });\n    } else {\n      this._checkDOMUpdate();\n    }\n  };\n\n  BScroll.prototype._shouldNotRefresh = function () {\n    var outsideBoundaries = this.x > this.minScrollX || this.x < this.maxScrollX || this.y > this.minScrollY || this.y < this.maxScrollY;\n\n    return this.isInTransition || this.stopFromTransition || outsideBoundaries;\n  };\n\n  BScroll.prototype._checkDOMUpdate = function () {\n    var scrollerRect = getRect(this.scroller);\n    var oldWidth = scrollerRect.width;\n    var oldHeight = scrollerRect.height;\n\n    function check() {\n      if (this.destroyed) {\n        return;\n      }\n      scrollerRect = getRect(this.scroller);\n      var newWidth = scrollerRect.width;\n      var newHeight = scrollerRect.height;\n\n      if (oldWidth !== newWidth || oldHeight !== newHeight) {\n        this.refresh();\n      }\n      oldWidth = newWidth;\n      oldHeight = newHeight;\n\n      next.call(this);\n    }\n\n    function next() {\n      var _this2 = this;\n\n      setTimeout(function () {\n        check.call(_this2);\n      }, 1000);\n    }\n\n    next.call(this);\n  };\n\n  BScroll.prototype.handleEvent = function (e) {\n    switch (e.type) {\n      case 'touchstart':\n      case 'mousedown':\n        this._start(e);\n        if (this.options.zoom && e.touches && e.touches.length > 1) {\n          this._zoomStart(e);\n        }\n        break;\n      case 'touchmove':\n      case 'mousemove':\n        if (this.options.zoom && e.touches && e.touches.length > 1) {\n          this._zoom(e);\n        } else {\n          this._move(e);\n        }\n        break;\n      case 'touchend':\n      case 'mouseup':\n      case 'touchcancel':\n      case 'mousecancel':\n        if (this.scaled) {\n          this._zoomEnd(e);\n        } else {\n          this._end(e);\n        }\n        break;\n      case 'orientationchange':\n      case 'resize':\n        this._resize();\n        break;\n      case 'transitionend':\n      case 'webkitTransitionEnd':\n      case 'oTransitionEnd':\n      case 'MSTransitionEnd':\n        this._transitionEnd(e);\n        break;\n      case 'click':\n        if (this.enabled && !e._constructed) {\n          if (!preventDefaultException(e.target, this.options.preventDefaultException)) {\n            e.preventDefault();\n            e.stopPropagation();\n          }\n        }\n        break;\n      case 'wheel':\n      case 'DOMMouseScroll':\n      case 'mousewheel':\n        this._onMouseWheel(e);\n        break;\n    }\n  };\n\n  BScroll.prototype.refresh = function () {\n    var isWrapperStatic = window.getComputedStyle(this.wrapper, null).position === 'static';\n    var wrapperRect = getRect(this.wrapper);\n    this.wrapperWidth = wrapperRect.width;\n    this.wrapperHeight = wrapperRect.height;\n\n    var scrollerRect = getRect(this.scroller);\n    this.scrollerWidth = Math.round(scrollerRect.width * this.scale);\n    this.scrollerHeight = Math.round(scrollerRect.height * this.scale);\n\n    this.relativeX = scrollerRect.left;\n    this.relativeY = scrollerRect.top;\n\n    if (isWrapperStatic) {\n      this.relativeX -= wrapperRect.left;\n      this.relativeY -= wrapperRect.top;\n    }\n\n    this.minScrollX = 0;\n    this.minScrollY = 0;\n\n    var wheel = this.options.wheel;\n    if (wheel) {\n      this.items = this.scroller.children;\n      this.options.itemHeight = this.itemHeight = this.items.length ? this.scrollerHeight / this.items.length : 0;\n      if (this.selectedIndex === undefined) {\n        this.selectedIndex = wheel.selectedIndex || 0;\n      }\n      this.options.startY = -this.selectedIndex * this.itemHeight;\n      this.maxScrollX = 0;\n      this.maxScrollY = -this.itemHeight * (this.items.length - 1);\n    } else {\n      this.maxScrollX = this.wrapperWidth - this.scrollerWidth;\n      if (!this.options.infinity) {\n        this.maxScrollY = this.wrapperHeight - this.scrollerHeight;\n      }\n      if (this.maxScrollX < 0) {\n        this.maxScrollX -= this.relativeX;\n        this.minScrollX = -this.relativeX;\n      } else if (this.scale > 1) {\n        this.maxScrollX = this.maxScrollX / 2 - this.relativeX;\n        this.minScrollX = this.maxScrollX;\n      }\n      if (this.maxScrollY < 0) {\n        this.maxScrollY -= this.relativeY;\n        this.minScrollY = -this.relativeY;\n      } else if (this.scale > 1) {\n        this.maxScrollY = this.maxScrollY / 2 - this.relativeY;\n        this.minScrollY = this.maxScrollY;\n      }\n    }\n\n    this.hasHorizontalScroll = this.options.scrollX && this.maxScrollX < this.minScrollX;\n    this.hasVerticalScroll = this.options.scrollY && this.maxScrollY < this.minScrollY;\n\n    if (!this.hasHorizontalScroll) {\n      this.maxScrollX = this.minScrollX;\n      this.scrollerWidth = this.wrapperWidth;\n    }\n\n    if (!this.hasVerticalScroll) {\n      this.maxScrollY = this.minScrollY;\n      this.scrollerHeight = this.wrapperHeight;\n    }\n\n    this.endTime = 0;\n    this.directionX = 0;\n    this.directionY = 0;\n    this.wrapperOffset = offset(this.wrapper);\n\n    this.trigger('refresh');\n\n    !this.scaled && this.resetPosition();\n  };\n\n  BScroll.prototype.enable = function () {\n    this.enabled = true;\n  };\n\n  BScroll.prototype.disable = function () {\n    this.enabled = false;\n  };\n}\n\nvar ease = {\n  // easeOutQuint\n  swipe: {\n    style: 'cubic-bezier(0.23, 1, 0.32, 1)',\n    fn: function fn(t) {\n      return 1 + --t * t * t * t * t;\n    }\n  },\n  // easeOutQuard\n  swipeBounce: {\n    style: 'cubic-bezier(0.25, 0.46, 0.45, 0.94)',\n    fn: function fn(t) {\n      return t * (2 - t);\n    }\n  },\n  // easeOutQuart\n  bounce: {\n    style: 'cubic-bezier(0.165, 0.84, 0.44, 1)',\n    fn: function fn(t) {\n      return 1 - --t * t * t * t;\n    }\n  }\n};\n\nfunction momentum(current, start, time, lowerMargin, upperMargin, wrapperSize, options) {\n  var distance = current - start;\n  var speed = Math.abs(distance) / time;\n\n  var deceleration = options.deceleration,\n      itemHeight = options.itemHeight,\n      swipeBounceTime = options.swipeBounceTime,\n      wheel = options.wheel,\n      swipeTime = options.swipeTime;\n\n  var duration = swipeTime;\n  var rate = wheel ? 4 : 15;\n\n  var destination = current + speed / deceleration * (distance < 0 ? -1 : 1);\n\n  if (wheel && itemHeight) {\n    destination = Math.round(destination / itemHeight) * itemHeight;\n  }\n\n  if (destination < lowerMargin) {\n    destination = wrapperSize ? Math.max(lowerMargin - wrapperSize / 4, lowerMargin - wrapperSize / rate * speed) : lowerMargin;\n    duration = swipeBounceTime;\n  } else if (destination > upperMargin) {\n    destination = wrapperSize ? Math.min(upperMargin + wrapperSize / 4, upperMargin + wrapperSize / rate * speed) : upperMargin;\n    duration = swipeBounceTime;\n  }\n\n  return {\n    destination: Math.round(destination),\n    duration: duration\n  };\n}\n\nvar DEFAULT_INTERVAL = 100 / 60;\n\nfunction noop() {}\n\nvar requestAnimationFrame = function () {\n  if (!inBrowser) {\n    /* istanbul ignore if */\n    return noop;\n  }\n  return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame ||\n  // if all else fails, use setTimeout\n  function (callback) {\n    return window.setTimeout(callback, (callback.interval || DEFAULT_INTERVAL) / 2); // make interval as precise as possible.\n  };\n}();\n\nvar cancelAnimationFrame = function () {\n  if (!inBrowser) {\n    /* istanbul ignore if */\n    return noop;\n  }\n  return window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || function (id) {\n    window.clearTimeout(id);\n  };\n}();\n\nvar DIRECTION_UP = 1;\nvar DIRECTION_DOWN = -1;\nvar DIRECTION_LEFT = 1;\nvar DIRECTION_RIGHT = -1;\n\nvar PROBE_DEBOUNCE = 1;\n\nvar PROBE_REALTIME = 3;\n\nfunction warn(msg) {\n  console.error('[BScroll warn]: ' + msg);\n}\n\nfunction assert(condition, msg) {\n  if (!condition) {\n    throw new Error('[BScroll] ' + msg);\n  }\n}\n\nfunction coreMixin(BScroll) {\n  BScroll.prototype._start = function (e) {\n    var _eventType = eventType[e.type];\n    if (_eventType !== TOUCH_EVENT) {\n      if (e.button !== 0) {\n        return;\n      }\n    }\n    if (!this.enabled || this.destroyed || this.initiated && this.initiated !== _eventType) {\n      return;\n    }\n    this.initiated = _eventType;\n\n    if (this.options.preventDefault && !preventDefaultException(e.target, this.options.preventDefaultException)) {\n      e.preventDefault();\n    }\n    if (this.options.stopPropagation) {\n      e.stopPropagation();\n    }\n\n    this.moved = false;\n    this.distX = 0;\n    this.distY = 0;\n    this.directionX = 0;\n    this.directionY = 0;\n    this.movingDirectionX = 0;\n    this.movingDirectionY = 0;\n    this.directionLocked = 0;\n\n    this._transitionTime();\n    this.startTime = getNow();\n\n    if (this.options.wheel) {\n      this.target = e.target;\n    }\n\n    this.stop();\n\n    var point = e.touches ? e.touches[0] : e;\n\n    this.startX = this.x;\n    this.startY = this.y;\n    this.absStartX = this.x;\n    this.absStartY = this.y;\n    this.pointX = point.pageX;\n    this.pointY = point.pageY;\n\n    this.trigger('beforeScrollStart');\n  };\n\n  BScroll.prototype._move = function (e) {\n    if (!this.enabled || this.destroyed || eventType[e.type] !== this.initiated) {\n      return;\n    }\n\n    if (this.options.preventDefault) {\n      e.preventDefault();\n    }\n    if (this.options.stopPropagation) {\n      e.stopPropagation();\n    }\n\n    var point = e.touches ? e.touches[0] : e;\n    var deltaX = point.pageX - this.pointX;\n    var deltaY = point.pageY - this.pointY;\n\n    this.pointX = point.pageX;\n    this.pointY = point.pageY;\n\n    this.distX += deltaX;\n    this.distY += deltaY;\n\n    var absDistX = Math.abs(this.distX);\n    var absDistY = Math.abs(this.distY);\n\n    var timestamp = getNow();\n\n    // We need to move at least momentumLimitDistance pixels for the scrolling to initiate\n    if (timestamp - this.endTime > this.options.momentumLimitTime && absDistY < this.options.momentumLimitDistance && absDistX < this.options.momentumLimitDistance) {\n      return;\n    }\n\n    // If you are scrolling in one direction lock the other\n    if (!this.directionLocked && !this.options.freeScroll) {\n      if (absDistX > absDistY + this.options.directionLockThreshold) {\n        this.directionLocked = 'h'; // lock horizontally\n      } else if (absDistY >= absDistX + this.options.directionLockThreshold) {\n        this.directionLocked = 'v'; // lock vertically\n      } else {\n        this.directionLocked = 'n'; // no lock\n      }\n    }\n\n    if (this.directionLocked === 'h') {\n      if (this.options.eventPassthrough === 'vertical') {\n        e.preventDefault();\n      } else if (this.options.eventPassthrough === 'horizontal') {\n        this.initiated = false;\n        return;\n      }\n      deltaY = 0;\n    } else if (this.directionLocked === 'v') {\n      if (this.options.eventPassthrough === 'horizontal') {\n        e.preventDefault();\n      } else if (this.options.eventPassthrough === 'vertical') {\n        this.initiated = false;\n        return;\n      }\n      deltaX = 0;\n    }\n\n    deltaX = this.hasHorizontalScroll ? deltaX : 0;\n    deltaY = this.hasVerticalScroll ? deltaY : 0;\n    this.movingDirectionX = deltaX > 0 ? DIRECTION_RIGHT : deltaX < 0 ? DIRECTION_LEFT : 0;\n    this.movingDirectionY = deltaY > 0 ? DIRECTION_DOWN : deltaY < 0 ? DIRECTION_UP : 0;\n\n    var newX = this.x + deltaX;\n    var newY = this.y + deltaY;\n\n    var top = false;\n    var bottom = false;\n    var left = false;\n    var right = false;\n    // Slow down or stop if outside of the boundaries\n    var bounce = this.options.bounce;\n    if (bounce !== false) {\n      top = bounce.top === undefined ? true : bounce.top;\n      bottom = bounce.bottom === undefined ? true : bounce.bottom;\n      left = bounce.left === undefined ? true : bounce.left;\n      right = bounce.right === undefined ? true : bounce.right;\n    }\n    if (newX > this.minScrollX || newX < this.maxScrollX) {\n      if (newX > this.minScrollX && left || newX < this.maxScrollX && right) {\n        newX = this.x + deltaX / 3;\n      } else {\n        newX = newX > this.minScrollX ? this.minScrollX : this.maxScrollX;\n      }\n    }\n    if (newY > this.minScrollY || newY < this.maxScrollY) {\n      if (newY > this.minScrollY && top || newY < this.maxScrollY && bottom) {\n        newY = this.y + deltaY / 3;\n      } else {\n        newY = newY > this.minScrollY ? this.minScrollY : this.maxScrollY;\n      }\n    }\n\n    if (!this.moved) {\n      this.moved = true;\n      this.trigger('scrollStart');\n    }\n\n    this._translate(newX, newY);\n\n    if (timestamp - this.startTime > this.options.momentumLimitTime) {\n      this.startTime = timestamp;\n      this.startX = this.x;\n      this.startY = this.y;\n\n      if (this.options.probeType === PROBE_DEBOUNCE) {\n        this.trigger('scroll', {\n          x: this.x,\n          y: this.y\n        });\n      }\n    }\n\n    if (this.options.probeType > PROBE_DEBOUNCE) {\n      this.trigger('scroll', {\n        x: this.x,\n        y: this.y\n      });\n    }\n\n    var scrollLeft = document.documentElement.scrollLeft || window.pageXOffset || document.body.scrollLeft;\n    var scrollTop = document.documentElement.scrollTop || window.pageYOffset || document.body.scrollTop;\n\n    var pX = this.pointX - scrollLeft;\n    var pY = this.pointY - scrollTop;\n\n    if (pX > document.documentElement.clientWidth - this.options.momentumLimitDistance || pX < this.options.momentumLimitDistance || pY < this.options.momentumLimitDistance || pY > document.documentElement.clientHeight - this.options.momentumLimitDistance) {\n      this._end(e);\n    }\n  };\n\n  BScroll.prototype._end = function (e) {\n    if (!this.enabled || this.destroyed || eventType[e.type] !== this.initiated) {\n      return;\n    }\n    this.initiated = false;\n\n    if (this.options.preventDefault && !preventDefaultException(e.target, this.options.preventDefaultException)) {\n      e.preventDefault();\n    }\n    if (this.options.stopPropagation) {\n      e.stopPropagation();\n    }\n\n    this.trigger('touchEnd', {\n      x: this.x,\n      y: this.y\n    });\n\n    this.isInTransition = false;\n\n    // ensures that the last position is rounded\n    var newX = Math.round(this.x);\n    var newY = Math.round(this.y);\n\n    var deltaX = newX - this.absStartX;\n    var deltaY = newY - this.absStartY;\n    this.directionX = deltaX > 0 ? DIRECTION_RIGHT : deltaX < 0 ? DIRECTION_LEFT : 0;\n    this.directionY = deltaY > 0 ? DIRECTION_DOWN : deltaY < 0 ? DIRECTION_UP : 0;\n\n    // if configure pull down refresh, check it first\n    if (this.options.pullDownRefresh && this._checkPullDown()) {\n      return;\n    }\n\n    // check if it is a click operation\n    if (this._checkClick(e)) {\n      this.trigger('scrollCancel');\n      return;\n    }\n\n    // reset if we are outside of the boundaries\n    if (this.resetPosition(this.options.bounceTime, ease.bounce)) {\n      return;\n    }\n\n    this._translate(newX, newY);\n\n    this.endTime = getNow();\n    var duration = this.endTime - this.startTime;\n    var absDistX = Math.abs(newX - this.startX);\n    var absDistY = Math.abs(newY - this.startY);\n\n    // flick\n    if (this._events.flick && duration < this.options.flickLimitTime && absDistX < this.options.flickLimitDistance && absDistY < this.options.flickLimitDistance) {\n      this.trigger('flick');\n      return;\n    }\n\n    var time = 0;\n    // start momentum animation if needed\n    if (this.options.momentum && duration < this.options.momentumLimitTime && (absDistY > this.options.momentumLimitDistance || absDistX > this.options.momentumLimitDistance)) {\n      var top = false;\n      var bottom = false;\n      var left = false;\n      var right = false;\n      var bounce = this.options.bounce;\n      if (bounce !== false) {\n        top = bounce.top === undefined ? true : bounce.top;\n        bottom = bounce.bottom === undefined ? true : bounce.bottom;\n        left = bounce.left === undefined ? true : bounce.left;\n        right = bounce.right === undefined ? true : bounce.right;\n      }\n      var wrapperWidth = this.directionX === DIRECTION_RIGHT && left || this.directionX === DIRECTION_LEFT && right ? this.wrapperWidth : 0;\n      var wrapperHeight = this.directionY === DIRECTION_DOWN && top || this.directionY === DIRECTION_UP && bottom ? this.wrapperHeight : 0;\n      var momentumX = this.hasHorizontalScroll ? momentum(this.x, this.startX, duration, this.maxScrollX, this.minScrollX, wrapperWidth, this.options) : { destination: newX, duration: 0 };\n      var momentumY = this.hasVerticalScroll ? momentum(this.y, this.startY, duration, this.maxScrollY, this.minScrollY, wrapperHeight, this.options) : { destination: newY, duration: 0 };\n      newX = momentumX.destination;\n      newY = momentumY.destination;\n      time = Math.max(momentumX.duration, momentumY.duration);\n      this.isInTransition = true;\n    } else {\n      if (this.options.wheel) {\n        newY = Math.round(newY / this.itemHeight) * this.itemHeight;\n        time = this.options.wheel.adjustTime || 400;\n      }\n    }\n\n    var easing = ease.swipe;\n    if (this.options.snap) {\n      var snap = this._nearestSnap(newX, newY);\n      this.currentPage = snap;\n      time = this.options.snapSpeed || Math.max(Math.max(Math.min(Math.abs(newX - snap.x), 1000), Math.min(Math.abs(newY - snap.y), 1000)), 300);\n      newX = snap.x;\n      newY = snap.y;\n\n      this.directionX = 0;\n      this.directionY = 0;\n      easing = this.options.snap.easing || ease.bounce;\n    }\n\n    if (newX !== this.x || newY !== this.y) {\n      // change easing function when scroller goes out of the boundaries\n      if (newX > this.minScrollX || newX < this.maxScrollX || newY > this.minScrollY || newY < this.maxScrollY) {\n        easing = ease.swipeBounce;\n      }\n      this.scrollTo(newX, newY, time, easing);\n      return;\n    }\n\n    if (this.options.wheel) {\n      this.selectedIndex = Math.round(Math.abs(this.y / this.itemHeight));\n    }\n    this.trigger('scrollEnd', {\n      x: this.x,\n      y: this.y\n    });\n  };\n\n  BScroll.prototype._checkClick = function (e) {\n    // when in the process of pulling down, it should not prevent click\n    var preventClick = this.stopFromTransition && !this.pulling;\n    this.stopFromTransition = false;\n\n    // we scrolled less than 15 pixels\n    if (!this.moved) {\n      if (this.options.wheel) {\n        if (this.target && this.target.classList.contains(this.options.wheel.wheelWrapperClass)) {\n          var index = Math.abs(Math.round(this.y / this.itemHeight));\n          var _offset = Math.round((this.pointY + offsetToBody(this.wrapper).top - this.wrapperHeight / 2) / this.itemHeight);\n          this.target = this.items[index + _offset];\n        }\n        this.scrollToElement(this.target, this.options.wheel.adjustTime || 400, true, true, ease.swipe);\n        return true;\n      } else {\n        if (!preventClick) {\n          var _dblclick = this.options.dblclick;\n          var dblclickTrigged = false;\n          if (_dblclick && this.lastClickTime) {\n            var _dblclick$delay = _dblclick.delay,\n                delay = _dblclick$delay === undefined ? 300 : _dblclick$delay;\n\n            if (getNow() - this.lastClickTime < delay) {\n              dblclickTrigged = true;\n              dblclick(e);\n            }\n          }\n          if (this.options.tap) {\n            tap(e, this.options.tap);\n          }\n\n          if (this.options.click && !preventDefaultException(e.target, this.options.preventDefaultException)) {\n            click(e);\n          }\n          this.lastClickTime = dblclickTrigged ? null : getNow();\n          return true;\n        }\n        return false;\n      }\n    }\n    return false;\n  };\n\n  BScroll.prototype._resize = function () {\n    var _this = this;\n\n    if (!this.enabled) {\n      return;\n    }\n    // fix a scroll problem under Android condition\n    if (isAndroid) {\n      this.wrapper.scrollTop = 0;\n    }\n    clearTimeout(this.resizeTimeout);\n    this.resizeTimeout = setTimeout(function () {\n      _this.refresh();\n    }, this.options.resizePolling);\n  };\n\n  BScroll.prototype._startProbe = function () {\n    cancelAnimationFrame(this.probeTimer);\n    this.probeTimer = requestAnimationFrame(probe);\n\n    var me = this;\n\n    function probe() {\n      var pos = me.getComputedPosition();\n      me.trigger('scroll', pos);\n      if (!me.isInTransition) {\n        me.trigger('scrollEnd', pos);\n        return;\n      }\n      me.probeTimer = requestAnimationFrame(probe);\n    }\n  };\n\n  BScroll.prototype._transitionTime = function () {\n    var time = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n    this.scrollerStyle[style.transitionDuration] = time + 'ms';\n\n    if (this.options.wheel) {\n      for (var i = 0; i < this.items.length; i++) {\n        this.items[i].style[style.transitionDuration] = time + 'ms';\n      }\n    }\n\n    if (this.indicators) {\n      for (var _i = 0; _i < this.indicators.length; _i++) {\n        this.indicators[_i].transitionTime(time);\n      }\n    }\n  };\n\n  BScroll.prototype._transitionTimingFunction = function (easing) {\n    this.scrollerStyle[style.transitionTimingFunction] = easing;\n\n    if (this.options.wheel) {\n      for (var i = 0; i < this.items.length; i++) {\n        this.items[i].style[style.transitionTimingFunction] = easing;\n      }\n    }\n\n    if (this.indicators) {\n      for (var _i2 = 0; _i2 < this.indicators.length; _i2++) {\n        this.indicators[_i2].transitionTimingFunction(easing);\n      }\n    }\n  };\n\n  BScroll.prototype._transitionEnd = function (e) {\n    if (e.target !== this.scroller || !this.isInTransition) {\n      return;\n    }\n\n    this._transitionTime();\n    var needReset = !this.pulling || this.movingDirectionY === DIRECTION_UP;\n    if (needReset && !this.resetPosition(this.options.bounceTime, ease.bounce)) {\n      this.isInTransition = false;\n      if (this.options.probeType !== PROBE_REALTIME) {\n        this.trigger('scrollEnd', {\n          x: this.x,\n          y: this.y\n        });\n      }\n    }\n  };\n\n  BScroll.prototype._translate = function (x, y, scale) {\n    assert(!isUndef(x) && !isUndef(y), 'Translate x or y is null or undefined.');\n    if (isUndef(scale)) {\n      scale = this.scale;\n    }\n    if (this.options.useTransform) {\n      this.scrollerStyle[style.transform] = 'translate(' + x + 'px,' + y + 'px) scale(' + scale + ')' + this.translateZ;\n    } else {\n      x = Math.round(x);\n      y = Math.round(y);\n      this.scrollerStyle.left = x + 'px';\n      this.scrollerStyle.top = y + 'px';\n    }\n\n    if (this.options.wheel) {\n      var _options$wheel$rotate = this.options.wheel.rotate,\n          rotate = _options$wheel$rotate === undefined ? 25 : _options$wheel$rotate;\n\n      for (var i = 0; i < this.items.length; i++) {\n        var deg = rotate * (y / this.itemHeight + i);\n        this.items[i].style[style.transform] = 'rotateX(' + deg + 'deg)';\n      }\n    }\n\n    this.x = x;\n    this.y = y;\n    this.setScale(scale);\n\n    if (this.indicators) {\n      for (var _i3 = 0; _i3 < this.indicators.length; _i3++) {\n        this.indicators[_i3].updatePosition();\n      }\n    }\n  };\n\n  BScroll.prototype._animate = function (destX, destY, duration, easingFn) {\n    var me = this;\n    var startX = this.x;\n    var startY = this.y;\n    var startScale = this.lastScale;\n    var destScale = this.scale;\n    var startTime = getNow();\n    var destTime = startTime + duration;\n\n    function step() {\n      var now = getNow();\n\n      if (now >= destTime) {\n        me.isAnimating = false;\n        me._translate(destX, destY, destScale);\n\n        me.trigger('scroll', {\n          x: me.x,\n          y: me.y\n        });\n\n        if (!me.pulling && !me.resetPosition(me.options.bounceTime)) {\n          me.trigger('scrollEnd', {\n            x: me.x,\n            y: me.y\n          });\n        }\n        return;\n      }\n      now = (now - startTime) / duration;\n      var easing = easingFn(now);\n      var newX = (destX - startX) * easing + startX;\n      var newY = (destY - startY) * easing + startY;\n      var newScale = (destScale - startScale) * easing + startScale;\n\n      me._translate(newX, newY, newScale);\n\n      if (me.isAnimating) {\n        me.animateTimer = requestAnimationFrame(step);\n      }\n\n      if (me.options.probeType === PROBE_REALTIME) {\n        me.trigger('scroll', {\n          x: me.x,\n          y: me.y\n        });\n      }\n    }\n\n    this.isAnimating = true;\n    cancelAnimationFrame(this.animateTimer);\n    step();\n  };\n\n  BScroll.prototype.scrollBy = function (x, y) {\n    var time = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n    var easing = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ease.bounce;\n\n    x = this.x + x;\n    y = this.y + y;\n\n    this.scrollTo(x, y, time, easing);\n  };\n\n  BScroll.prototype.scrollTo = function (x, y) {\n    var time = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n    var easing = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ease.bounce;\n\n    var isMoved = this.x !== x || this.y !== y;\n    // an useless scroll\n    if (!isMoved) return;\n\n    this.isInTransition = this.options.useTransition && time > 0 && (x !== this.x || y !== this.y);\n\n    if (!time || this.options.useTransition) {\n      this._transitionTimingFunction(easing.style);\n      this._transitionTime(time);\n      this._translate(x, y);\n\n      if (time && this.options.probeType === PROBE_REALTIME) {\n        this._startProbe();\n      }\n      if (!time) {\n        this.trigger('scroll', {\n          x: x,\n          y: y\n        });\n        // force reflow to put everything in position\n        this._reflow = document.body.offsetHeight;\n        if (!this.resetPosition(this.options.bounceTime, ease.bounce)) {\n          this.trigger('scrollEnd', {\n            x: x,\n            y: y\n          });\n        }\n      }\n\n      if (this.options.wheel) {\n        if (y > this.minScrollY) {\n          this.selectedIndex = 0;\n        } else if (y < this.maxScrollY) {\n          this.selectedIndex = this.items.length - 1;\n        } else {\n          this.selectedIndex = Math.round(Math.abs(y / this.itemHeight));\n        }\n      }\n    } else {\n      this._animate(x, y, time, easing.fn);\n    }\n  };\n\n  BScroll.prototype.scrollToElement = function (el, time, offsetX, offsetY, easing) {\n    if (!el) {\n      return;\n    }\n    el = el.nodeType ? el : this.scroller.querySelector(el);\n\n    if (this.options.wheel && !el.classList.contains(this.options.wheel.wheelItemClass)) {\n      return;\n    }\n\n    var pos = offset(el);\n    pos.left -= this.wrapperOffset.left;\n    pos.top -= this.wrapperOffset.top;\n\n    // if offsetX/Y are true we center the element to the screen\n    if (offsetX === true) {\n      offsetX = Math.round(el.offsetWidth / 2 - this.wrapper.offsetWidth / 2);\n    }\n    if (offsetY === true) {\n      offsetY = Math.round(el.offsetHeight / 2 - this.wrapper.offsetHeight / 2);\n    }\n\n    pos.left -= offsetX || 0;\n    pos.top -= offsetY || 0;\n    pos.left = pos.left > this.minScrollX ? this.minScrollX : pos.left < this.maxScrollX ? this.maxScrollX : pos.left;\n    pos.top = pos.top > this.minScrollY ? this.minScrollY : pos.top < this.maxScrollY ? this.maxScrollY : pos.top;\n\n    if (this.options.wheel) {\n      pos.top = Math.round(pos.top / this.itemHeight) * this.itemHeight;\n    }\n\n    this.scrollTo(pos.left, pos.top, time, easing);\n  };\n\n  BScroll.prototype.resetPosition = function () {\n    var time = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n    var easeing = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ease.bounce;\n\n    var x = this.x;\n    var roundX = Math.round(x);\n    if (!this.hasHorizontalScroll || roundX > this.minScrollX) {\n      x = this.minScrollX;\n    } else if (roundX < this.maxScrollX) {\n      x = this.maxScrollX;\n    }\n\n    var y = this.y;\n    var roundY = Math.round(y);\n    if (!this.hasVerticalScroll || roundY > this.minScrollY) {\n      y = this.minScrollY;\n    } else if (roundY < this.maxScrollY) {\n      y = this.maxScrollY;\n    }\n\n    if (x === this.x && y === this.y) {\n      return false;\n    }\n\n    this.scrollTo(x, y, time, easeing);\n\n    return true;\n  };\n\n  BScroll.prototype.getComputedPosition = function () {\n    var matrix = window.getComputedStyle(this.scroller, null);\n    var x = void 0;\n    var y = void 0;\n\n    if (this.options.useTransform) {\n      matrix = matrix[style.transform].split(')')[0].split(', ');\n      x = +(matrix[12] || matrix[4]);\n      y = +(matrix[13] || matrix[5]);\n    } else {\n      x = +matrix.left.replace(/[^-\\d.]/g, '');\n      y = +matrix.top.replace(/[^-\\d.]/g, '');\n    }\n\n    return {\n      x: x,\n      y: y\n    };\n  };\n\n  BScroll.prototype.stop = function () {\n    if (this.options.useTransition && this.isInTransition) {\n      this.isInTransition = false;\n      cancelAnimationFrame(this.probeTimer);\n      var pos = this.getComputedPosition();\n      this._translate(pos.x, pos.y);\n      if (this.options.wheel) {\n        this.target = this.items[Math.round(-pos.y / this.itemHeight)];\n      } else {\n        this.trigger('scrollEnd', {\n          x: this.x,\n          y: this.y\n        });\n      }\n      this.stopFromTransition = true;\n    } else if (!this.options.useTransition && this.isAnimating) {\n      this.isAnimating = false;\n      cancelAnimationFrame(this.animateTimer);\n      this.trigger('scrollEnd', {\n        x: this.x,\n        y: this.y\n      });\n      this.stopFromTransition = true;\n    }\n  };\n\n  BScroll.prototype.destroy = function () {\n    this.destroyed = true;\n    this.trigger('destroy');\n    if (this.options.useTransition) {\n      cancelAnimationFrame(this.probeTimer);\n    } else {\n      cancelAnimationFrame(this.animateTimer);\n    }\n    this._removeDOMEvents();\n    // remove custom events\n    this._events = {};\n  };\n}\n\nfunction snapMixin(BScroll) {\n  BScroll.prototype._initSnap = function () {\n    var _this = this;\n\n    this.currentPage = {};\n    var snap = this.options.snap;\n\n    if (snap.loop) {\n      var children = this.scroller.children;\n      if (children.length > 1) {\n        prepend(children[children.length - 1].cloneNode(true), this.scroller);\n        this.scroller.appendChild(children[1].cloneNode(true));\n      } else {\n        // Loop does not make any sense if there is only one child.\n        snap.loop = false;\n      }\n    }\n\n    var el = snap.el;\n    if (typeof el === 'string') {\n      el = this.scroller.querySelectorAll(el);\n    }\n\n    this.on('refresh', function () {\n      _this.pages = [];\n\n      if (!_this.wrapperWidth || !_this.wrapperHeight || !_this.scrollerWidth || !_this.scrollerHeight) {\n        return;\n      }\n\n      var stepX = snap.stepX || _this.wrapperWidth;\n      var stepY = snap.stepY || _this.wrapperHeight;\n\n      var x = 0;\n      var y = void 0;\n      var cx = void 0;\n      var cy = void 0;\n      var i = 0;\n      var l = void 0;\n      var m = 0;\n      var n = void 0;\n      var rect = void 0;\n      if (!el) {\n        cx = Math.round(stepX / 2);\n        cy = Math.round(stepY / 2);\n\n        while (x > -_this.scrollerWidth) {\n          _this.pages[i] = [];\n          l = 0;\n          y = 0;\n\n          while (y > -_this.scrollerHeight) {\n            _this.pages[i][l] = {\n              x: Math.max(x, _this.maxScrollX),\n              y: Math.max(y, _this.maxScrollY),\n              width: stepX,\n              height: stepY,\n              cx: x - cx,\n              cy: y - cy\n            };\n\n            y -= stepY;\n            l++;\n          }\n\n          x -= stepX;\n          i++;\n        }\n      } else {\n        l = el.length;\n        n = -1;\n\n        for (; i < l; i++) {\n          rect = getRect(el[i]);\n          if (i === 0 || rect.left <= getRect(el[i - 1]).left) {\n            m = 0;\n            n++;\n          }\n\n          if (!_this.pages[m]) {\n            _this.pages[m] = [];\n          }\n\n          x = Math.max(-rect.left, _this.maxScrollX);\n          y = Math.max(-rect.top, _this.maxScrollY);\n          cx = x - Math.round(rect.width / 2);\n          cy = y - Math.round(rect.height / 2);\n\n          _this.pages[m][n] = {\n            x: x,\n            y: y,\n            width: rect.width,\n            height: rect.height,\n            cx: cx,\n            cy: cy\n          };\n\n          if (x > _this.maxScrollX) {\n            m++;\n          }\n        }\n      }\n\n      _this._checkSnapLoop();\n\n      var initPageX = snap._loopX ? 1 : 0;\n      var initPageY = snap._loopY ? 1 : 0;\n      _this._goToPage(_this.currentPage.pageX || initPageX, _this.currentPage.pageY || initPageY, 0);\n\n      // Update snap threshold if needed.\n      var snapThreshold = snap.threshold;\n      if (snapThreshold % 1 === 0) {\n        _this.snapThresholdX = snapThreshold;\n        _this.snapThresholdY = snapThreshold;\n      } else {\n        _this.snapThresholdX = Math.round(_this.pages[_this.currentPage.pageX][_this.currentPage.pageY].width * snapThreshold);\n        _this.snapThresholdY = Math.round(_this.pages[_this.currentPage.pageX][_this.currentPage.pageY].height * snapThreshold);\n      }\n    });\n\n    this.on('scrollEnd', function () {\n      if (snap.loop) {\n        if (snap._loopX) {\n          if (_this.currentPage.pageX === 0) {\n            _this._goToPage(_this.pages.length - 2, _this.currentPage.pageY, 0);\n          }\n          if (_this.currentPage.pageX === _this.pages.length - 1) {\n            _this._goToPage(1, _this.currentPage.pageY, 0);\n          }\n        } else {\n          if (_this.currentPage.pageY === 0) {\n            _this._goToPage(_this.currentPage.pageX, _this.pages[0].length - 2, 0);\n          }\n          if (_this.currentPage.pageY === _this.pages[0].length - 1) {\n            _this._goToPage(_this.currentPage.pageX, 1, 0);\n          }\n        }\n      }\n    });\n\n    if (snap.listenFlick !== false) {\n      this.on('flick', function () {\n        var time = snap.speed || Math.max(Math.max(Math.min(Math.abs(_this.x - _this.startX), 1000), Math.min(Math.abs(_this.y - _this.startY), 1000)), 300);\n\n        _this._goToPage(_this.currentPage.pageX + _this.directionX, _this.currentPage.pageY + _this.directionY, time);\n      });\n    }\n\n    this.on('destroy', function () {\n      if (snap.loop) {\n        var _children = _this.scroller.children;\n        if (_children.length > 2) {\n          removeChild(_this.scroller, _children[_children.length - 1]);\n          removeChild(_this.scroller, _children[0]);\n        }\n      }\n    });\n  };\n\n  BScroll.prototype._checkSnapLoop = function () {\n    var snap = this.options.snap;\n\n    if (!snap.loop || !this.pages || !this.pages.length) {\n      return;\n    }\n\n    if (this.pages.length > 1) {\n      snap._loopX = true;\n    }\n    if (this.pages[0] && this.pages[0].length > 1) {\n      snap._loopY = true;\n    }\n    if (snap._loopX && snap._loopY) {\n      warn('Loop does not support two direction at the same time.');\n    }\n  };\n\n  BScroll.prototype._nearestSnap = function (x, y) {\n    if (!this.pages.length) {\n      return { x: 0, y: 0, pageX: 0, pageY: 0 };\n    }\n\n    var i = 0;\n    // Check if we exceeded the snap threshold\n    if (Math.abs(x - this.absStartX) <= this.snapThresholdX && Math.abs(y - this.absStartY) <= this.snapThresholdY) {\n      return this.currentPage;\n    }\n\n    if (x > this.minScrollX) {\n      x = this.minScrollX;\n    } else if (x < this.maxScrollX) {\n      x = this.maxScrollX;\n    }\n\n    if (y > this.minScrollY) {\n      y = this.minScrollY;\n    } else if (y < this.maxScrollY) {\n      y = this.maxScrollY;\n    }\n\n    var l = this.pages.length;\n    for (; i < l; i++) {\n      if (x >= this.pages[i][0].cx) {\n        x = this.pages[i][0].x;\n        break;\n      }\n    }\n\n    l = this.pages[i].length;\n\n    var m = 0;\n    for (; m < l; m++) {\n      if (y >= this.pages[0][m].cy) {\n        y = this.pages[0][m].y;\n        break;\n      }\n    }\n\n    if (i === this.currentPage.pageX) {\n      i += this.directionX;\n\n      if (i < 0) {\n        i = 0;\n      } else if (i >= this.pages.length) {\n        i = this.pages.length - 1;\n      }\n\n      x = this.pages[i][0].x;\n    }\n\n    if (m === this.currentPage.pageY) {\n      m += this.directionY;\n\n      if (m < 0) {\n        m = 0;\n      } else if (m >= this.pages[0].length) {\n        m = this.pages[0].length - 1;\n      }\n\n      y = this.pages[0][m].y;\n    }\n\n    return {\n      x: x,\n      y: y,\n      pageX: i,\n      pageY: m\n    };\n  };\n\n  BScroll.prototype._goToPage = function (x) {\n    var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n    var time = arguments[2];\n    var easing = arguments[3];\n\n    var snap = this.options.snap;\n\n    if (!snap || !this.pages || !this.pages.length) {\n      return;\n    }\n\n    easing = easing || snap.easing || ease.bounce;\n\n    if (x >= this.pages.length) {\n      x = this.pages.length - 1;\n    } else if (x < 0) {\n      x = 0;\n    }\n\n    if (!this.pages[x]) {\n      return;\n    }\n\n    if (y >= this.pages[x].length) {\n      y = this.pages[x].length - 1;\n    } else if (y < 0) {\n      y = 0;\n    }\n\n    var posX = this.pages[x][y].x;\n    var posY = this.pages[x][y].y;\n\n    time = time === undefined ? snap.speed || Math.max(Math.max(Math.min(Math.abs(posX - this.x), 1000), Math.min(Math.abs(posY - this.y), 1000)), 300) : time;\n\n    this.currentPage = {\n      x: posX,\n      y: posY,\n      pageX: x,\n      pageY: y\n    };\n    this.scrollTo(posX, posY, time, easing);\n  };\n\n  BScroll.prototype.goToPage = function (x, y, time, easing) {\n    var snap = this.options.snap;\n    if (!snap || !this.pages || !this.pages.length) {\n      return;\n    }\n\n    if (snap.loop) {\n      var len = void 0;\n      if (snap._loopX) {\n        len = this.pages.length - 2;\n        if (x >= len) {\n          x = len - 1;\n        } else if (x < 0) {\n          x = 0;\n        }\n        x += 1;\n      } else {\n        len = this.pages[0].length - 2;\n        if (y >= len) {\n          y = len - 1;\n        } else if (y < 0) {\n          y = 0;\n        }\n        y += 1;\n      }\n    }\n    this._goToPage(x, y, time, easing);\n  };\n\n  BScroll.prototype.next = function (time, easing) {\n    var snap = this.options.snap;\n    if (!snap) {\n      return;\n    }\n\n    var x = this.currentPage.pageX;\n    var y = this.currentPage.pageY;\n\n    x++;\n    if (x >= this.pages.length && this.hasVerticalScroll) {\n      x = 0;\n      y++;\n    }\n\n    this._goToPage(x, y, time, easing);\n  };\n\n  BScroll.prototype.prev = function (time, easing) {\n    var snap = this.options.snap;\n    if (!snap) {\n      return;\n    }\n\n    var x = this.currentPage.pageX;\n    var y = this.currentPage.pageY;\n\n    x--;\n    if (x < 0 && this.hasVerticalScroll) {\n      x = 0;\n      y--;\n    }\n\n    this._goToPage(x, y, time, easing);\n  };\n\n  BScroll.prototype.getCurrentPage = function () {\n    var snap = this.options.snap;\n    if (!snap) {\n      return null;\n    }\n\n    if (snap.loop) {\n      var currentPage = void 0;\n      if (snap._loopX) {\n        currentPage = extend({}, this.currentPage, {\n          pageX: this.currentPage.pageX - 1\n        });\n      } else {\n        currentPage = extend({}, this.currentPage, {\n          pageY: this.currentPage.pageY - 1\n        });\n      }\n      return currentPage;\n    }\n    return this.currentPage;\n  };\n}\n\nfunction wheelMixin(BScroll) {\n  BScroll.prototype.wheelTo = function () {\n    var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n    if (this.options.wheel) {\n      var y = -index * this.itemHeight;\n      this.scrollTo(0, y);\n    }\n  };\n\n  BScroll.prototype.getSelectedIndex = function () {\n    return this.options.wheel && this.selectedIndex;\n  };\n\n  BScroll.prototype._initWheel = function () {\n    var wheel = this.options.wheel;\n    if (!wheel.wheelWrapperClass) {\n      wheel.wheelWrapperClass = 'wheel-scroll';\n    }\n    if (!wheel.wheelItemClass) {\n      wheel.wheelItemClass = 'wheel-item';\n    }\n    if (wheel.selectedIndex === undefined) {\n      wheel.selectedIndex = 0;\n      warn('wheel option selectedIndex is required!');\n    }\n  };\n}\n\nvar INDICATOR_MIN_LEN = 8;\n\nfunction scrollbarMixin(BScroll) {\n  BScroll.prototype._initScrollbar = function () {\n    var _this = this;\n\n    var _options$scrollbar = this.options.scrollbar,\n        _options$scrollbar$fa = _options$scrollbar.fade,\n        fade = _options$scrollbar$fa === undefined ? true : _options$scrollbar$fa,\n        _options$scrollbar$in = _options$scrollbar.interactive,\n        interactive = _options$scrollbar$in === undefined ? false : _options$scrollbar$in;\n\n    this.indicators = [];\n    var indicator = void 0;\n\n    if (this.options.scrollX) {\n      indicator = {\n        el: createScrollbar('horizontal'),\n        direction: 'horizontal',\n        fade: fade,\n        interactive: interactive\n      };\n      this._insertScrollBar(indicator.el);\n\n      this.indicators.push(new Indicator(this, indicator));\n    }\n\n    if (this.options.scrollY) {\n      indicator = {\n        el: createScrollbar('vertical'),\n        direction: 'vertical',\n        fade: fade,\n        interactive: interactive\n      };\n      this._insertScrollBar(indicator.el);\n      this.indicators.push(new Indicator(this, indicator));\n    }\n\n    this.on('refresh', function () {\n      for (var i = 0; i < _this.indicators.length; i++) {\n        _this.indicators[i].refresh();\n      }\n    });\n\n    if (fade) {\n      this.on('scrollEnd', function () {\n        for (var i = 0; i < _this.indicators.length; i++) {\n          _this.indicators[i].fade();\n        }\n      });\n\n      this.on('scrollCancel', function () {\n        for (var i = 0; i < _this.indicators.length; i++) {\n          _this.indicators[i].fade();\n        }\n      });\n\n      this.on('scrollStart', function () {\n        for (var i = 0; i < _this.indicators.length; i++) {\n          _this.indicators[i].fade(true);\n        }\n      });\n\n      this.on('beforeScrollStart', function () {\n        for (var i = 0; i < _this.indicators.length; i++) {\n          _this.indicators[i].fade(true, true);\n        }\n      });\n    }\n\n    this.on('destroy', function () {\n      _this._removeScrollBars();\n    });\n  };\n\n  BScroll.prototype._insertScrollBar = function (scrollbar) {\n    this.wrapper.appendChild(scrollbar);\n  };\n\n  BScroll.prototype._removeScrollBars = function () {\n    for (var i = 0; i < this.indicators.length; i++) {\n      this.indicators[i].destroy();\n    }\n  };\n}\n\nfunction createScrollbar(direction) {\n  var scrollbar = document.createElement('div');\n  var indicator = document.createElement('div');\n\n  scrollbar.style.cssText = 'position:absolute;z-index:9999;pointerEvents:none';\n  indicator.style.cssText = 'box-sizing:border-box;position:absolute;background:rgba(0,0,0,0.5);border:1px solid rgba(255,255,255,0.9);border-radius:3px;';\n\n  indicator.className = 'bscroll-indicator';\n\n  if (direction === 'horizontal') {\n    scrollbar.style.cssText += ';height:7px;left:2px;right:2px;bottom:0';\n    indicator.style.height = '100%';\n    scrollbar.className = 'bscroll-horizontal-scrollbar';\n  } else {\n    scrollbar.style.cssText += ';width:7px;bottom:2px;top:2px;right:1px';\n    indicator.style.width = '100%';\n    scrollbar.className = 'bscroll-vertical-scrollbar';\n  }\n\n  scrollbar.style.cssText += ';overflow:hidden';\n  scrollbar.appendChild(indicator);\n\n  return scrollbar;\n}\n\nfunction Indicator(scroller, options) {\n  this.wrapper = options.el;\n  this.wrapperStyle = this.wrapper.style;\n  this.indicator = this.wrapper.children[0];\n  this.indicatorStyle = this.indicator.style;\n  this.scroller = scroller;\n  this.direction = options.direction;\n  if (options.fade) {\n    this.visible = 0;\n    this.wrapperStyle.opacity = '0';\n  } else {\n    this.visible = 1;\n  }\n\n  this.sizeRatioX = 1;\n  this.sizeRatioY = 1;\n  this.maxPosX = 0;\n  this.maxPosY = 0;\n  this.x = 0;\n  this.y = 0;\n\n  if (options.interactive) {\n    this._addDOMEvents();\n  }\n}\n\nIndicator.prototype.handleEvent = function (e) {\n  switch (e.type) {\n    case 'touchstart':\n    case 'mousedown':\n      this._start(e);\n      break;\n    case 'touchmove':\n    case 'mousemove':\n      this._move(e);\n      break;\n    case 'touchend':\n    case 'mouseup':\n    case 'touchcancel':\n    case 'mousecancel':\n      this._end(e);\n      break;\n  }\n};\n\nIndicator.prototype.refresh = function () {\n  if (this._shouldShow()) {\n    this.transitionTime();\n    this._calculate();\n    this.updatePosition();\n  }\n};\n\nIndicator.prototype.fade = function (visible, hold) {\n  var _this2 = this;\n\n  if (hold && !this.visible) {\n    return;\n  }\n\n  var time = visible ? 250 : 500;\n\n  visible = visible ? '1' : '0';\n\n  this.wrapperStyle[style.transitionDuration] = time + 'ms';\n\n  clearTimeout(this.fadeTimeout);\n  this.fadeTimeout = setTimeout(function () {\n    _this2.wrapperStyle.opacity = visible;\n    _this2.visible = +visible;\n  }, 0);\n};\n\nIndicator.prototype.updatePosition = function () {\n  if (this.direction === 'vertical') {\n    var y = Math.round(this.sizeRatioY * this.scroller.y);\n\n    if (y < 0) {\n      this.transitionTime(500);\n      var height = Math.max(this.indicatorHeight + y * 3, INDICATOR_MIN_LEN);\n      this.indicatorStyle.height = height + 'px';\n      y = 0;\n    } else if (y > this.maxPosY) {\n      this.transitionTime(500);\n      var _height = Math.max(this.indicatorHeight - (y - this.maxPosY) * 3, INDICATOR_MIN_LEN);\n      this.indicatorStyle.height = _height + 'px';\n      y = this.maxPosY + this.indicatorHeight - _height;\n    } else {\n      this.indicatorStyle.height = this.indicatorHeight + 'px';\n    }\n    this.y = y;\n\n    if (this.scroller.options.useTransform) {\n      this.indicatorStyle[style.transform] = 'translateY(' + y + 'px)' + this.scroller.translateZ;\n    } else {\n      this.indicatorStyle.top = y + 'px';\n    }\n  } else {\n    var x = Math.round(this.sizeRatioX * this.scroller.x);\n\n    if (x < 0) {\n      this.transitionTime(500);\n      var width = Math.max(this.indicatorWidth + x * 3, INDICATOR_MIN_LEN);\n      this.indicatorStyle.width = width + 'px';\n      x = 0;\n    } else if (x > this.maxPosX) {\n      this.transitionTime(500);\n      var _width = Math.max(this.indicatorWidth - (x - this.maxPosX) * 3, INDICATOR_MIN_LEN);\n      this.indicatorStyle.width = _width + 'px';\n      x = this.maxPosX + this.indicatorWidth - _width;\n    } else {\n      this.indicatorStyle.width = this.indicatorWidth + 'px';\n    }\n\n    this.x = x;\n\n    if (this.scroller.options.useTransform) {\n      this.indicatorStyle[style.transform] = 'translateX(' + x + 'px)' + this.scroller.translateZ;\n    } else {\n      this.indicatorStyle.left = x + 'px';\n    }\n  }\n};\n\nIndicator.prototype.transitionTime = function () {\n  var time = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n  this.indicatorStyle[style.transitionDuration] = time + 'ms';\n};\n\nIndicator.prototype.transitionTimingFunction = function (easing) {\n  this.indicatorStyle[style.transitionTimingFunction] = easing;\n};\n\nIndicator.prototype.destroy = function () {\n  this._removeDOMEvents();\n  this.wrapper.parentNode.removeChild(this.wrapper);\n};\n\nIndicator.prototype._start = function (e) {\n  var point = e.touches ? e.touches[0] : e;\n\n  e.preventDefault();\n  e.stopPropagation();\n\n  this.transitionTime();\n\n  this.initiated = true;\n  this.moved = false;\n  this.lastPointX = point.pageX;\n  this.lastPointY = point.pageY;\n\n  this.startTime = getNow();\n\n  this._handleMoveEvents(addEvent);\n  this.scroller.trigger('beforeScrollStart');\n};\n\nIndicator.prototype._move = function (e) {\n  var point = e.touches ? e.touches[0] : e;\n\n  e.preventDefault();\n  e.stopPropagation();\n\n  if (!this.moved) {\n    this.scroller.trigger('scrollStart');\n  }\n\n  this.moved = true;\n\n  var deltaX = point.pageX - this.lastPointX;\n  this.lastPointX = point.pageX;\n\n  var deltaY = point.pageY - this.lastPointY;\n  this.lastPointY = point.pageY;\n\n  var newX = this.x + deltaX;\n  var newY = this.y + deltaY;\n\n  this._pos(newX, newY);\n};\n\nIndicator.prototype._end = function (e) {\n  if (!this.initiated) {\n    return;\n  }\n  this.initiated = false;\n\n  e.preventDefault();\n  e.stopPropagation();\n\n  this._handleMoveEvents(removeEvent);\n\n  var snapOption = this.scroller.options.snap;\n  if (snapOption) {\n    var speed = snapOption.speed,\n        _snapOption$easing = snapOption.easing,\n        easing = _snapOption$easing === undefined ? ease.bounce : _snapOption$easing;\n\n    var snap = this.scroller._nearestSnap(this.scroller.x, this.scroller.y);\n\n    var time = speed || Math.max(Math.max(Math.min(Math.abs(this.scroller.x - snap.x), 1000), Math.min(Math.abs(this.scroller.y - snap.y), 1000)), 300);\n\n    if (this.scroller.x !== snap.x || this.scroller.y !== snap.y) {\n      this.scroller.directionX = 0;\n      this.scroller.directionY = 0;\n      this.scroller.currentPage = snap;\n      this.scroller.scrollTo(snap.x, snap.y, time, easing);\n    }\n  }\n\n  if (this.moved) {\n    this.scroller.trigger('scrollEnd', {\n      x: this.scroller.x,\n      y: this.scroller.y\n    });\n  }\n};\n\nIndicator.prototype._pos = function (x, y) {\n  if (x < 0) {\n    x = 0;\n  } else if (x > this.maxPosX) {\n    x = this.maxPosX;\n  }\n\n  if (y < 0) {\n    y = 0;\n  } else if (y > this.maxPosY) {\n    y = this.maxPosY;\n  }\n\n  x = Math.round(x / this.sizeRatioX);\n  y = Math.round(y / this.sizeRatioY);\n\n  this.scroller.scrollTo(x, y);\n  this.scroller.trigger('scroll', {\n    x: this.scroller.x,\n    y: this.scroller.y\n  });\n};\n\nIndicator.prototype._shouldShow = function () {\n  if (this.direction === 'vertical' && this.scroller.hasVerticalScroll || this.direction === 'horizontal' && this.scroller.hasHorizontalScroll) {\n    this.wrapper.style.display = '';\n    return true;\n  }\n  this.wrapper.style.display = 'none';\n  return false;\n};\n\nIndicator.prototype._calculate = function () {\n  if (this.direction === 'vertical') {\n    var wrapperHeight = this.wrapper.clientHeight;\n    this.indicatorHeight = Math.max(Math.round(wrapperHeight * wrapperHeight / (this.scroller.scrollerHeight || wrapperHeight || 1)), INDICATOR_MIN_LEN);\n    this.indicatorStyle.height = this.indicatorHeight + 'px';\n\n    this.maxPosY = wrapperHeight - this.indicatorHeight;\n\n    this.sizeRatioY = this.maxPosY / this.scroller.maxScrollY;\n  } else {\n    var wrapperWidth = this.wrapper.clientWidth;\n    this.indicatorWidth = Math.max(Math.round(wrapperWidth * wrapperWidth / (this.scroller.scrollerWidth || wrapperWidth || 1)), INDICATOR_MIN_LEN);\n    this.indicatorStyle.width = this.indicatorWidth + 'px';\n\n    this.maxPosX = wrapperWidth - this.indicatorWidth;\n\n    this.sizeRatioX = this.maxPosX / this.scroller.maxScrollX;\n  }\n};\n\nIndicator.prototype._addDOMEvents = function () {\n  var eventOperation = addEvent;\n  this._handleDOMEvents(eventOperation);\n};\n\nIndicator.prototype._removeDOMEvents = function () {\n  var eventOperation = removeEvent;\n  this._handleDOMEvents(eventOperation);\n  this._handleMoveEvents(eventOperation);\n};\n\nIndicator.prototype._handleMoveEvents = function (eventOperation) {\n  if (!this.scroller.options.disableTouch) {\n    eventOperation(window, 'touchmove', this);\n  }\n  if (!this.scroller.options.disableMouse) {\n    eventOperation(window, 'mousemove', this);\n  }\n};\n\nIndicator.prototype._handleDOMEvents = function (eventOperation) {\n  if (!this.scroller.options.disableTouch) {\n    eventOperation(this.indicator, 'touchstart', this);\n    eventOperation(window, 'touchend', this);\n  }\n  if (!this.scroller.options.disableMouse) {\n    eventOperation(this.indicator, 'mousedown', this);\n    eventOperation(window, 'mouseup', this);\n  }\n};\n\nfunction pullDownMixin(BScroll) {\n  BScroll.prototype._initPullDown = function () {\n    // must watch scroll in real time\n    this.options.probeType = PROBE_REALTIME;\n  };\n\n  BScroll.prototype._checkPullDown = function () {\n    var _options$pullDownRefr = this.options.pullDownRefresh,\n        _options$pullDownRefr2 = _options$pullDownRefr.threshold,\n        threshold = _options$pullDownRefr2 === undefined ? 90 : _options$pullDownRefr2,\n        _options$pullDownRefr3 = _options$pullDownRefr.stop,\n        stop = _options$pullDownRefr3 === undefined ? 40 : _options$pullDownRefr3;\n\n    // check if a real pull down action\n\n    if (this.directionY !== DIRECTION_DOWN || this.y < threshold) {\n      return false;\n    }\n\n    if (!this.pulling) {\n      this.pulling = true;\n      this.trigger('pullingDown');\n    }\n    this.scrollTo(this.x, stop, this.options.bounceTime, ease.bounce);\n\n    return this.pulling;\n  };\n\n  BScroll.prototype.finishPullDown = function () {\n    this.pulling = false;\n    this.resetPosition(this.options.bounceTime, ease.bounce);\n  };\n\n  BScroll.prototype.openPullDown = function () {\n    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n\n    this.options.pullDownRefresh = config;\n    this._initPullDown();\n  };\n\n  BScroll.prototype.closePullDown = function () {\n    this.options.pullDownRefresh = false;\n  };\n\n  BScroll.prototype.autoPullDownRefresh = function () {\n    var _options$pullDownRefr4 = this.options.pullDownRefresh,\n        _options$pullDownRefr5 = _options$pullDownRefr4.threshold,\n        threshold = _options$pullDownRefr5 === undefined ? 90 : _options$pullDownRefr5,\n        _options$pullDownRefr6 = _options$pullDownRefr4.stop,\n        stop = _options$pullDownRefr6 === undefined ? 40 : _options$pullDownRefr6;\n\n\n    if (this.pulling) {\n      return;\n    }\n    this.pulling = true;\n\n    this.scrollTo(this.x, threshold);\n    this.trigger('pullingDown');\n    this.scrollTo(this.x, stop, this.options.bounceTime, ease.bounce);\n  };\n}\n\nfunction pullUpMixin(BScroll) {\n  BScroll.prototype._initPullUp = function () {\n    // must watch scroll in real time\n    this.options.probeType = PROBE_REALTIME;\n\n    this.pullupWatching = false;\n    this._watchPullUp();\n  };\n\n  BScroll.prototype._watchPullUp = function () {\n    if (this.pullupWatching) {\n      return;\n    }\n    this.pullupWatching = true;\n    this.on('scroll', this._checkToEnd);\n  };\n\n  BScroll.prototype._checkToEnd = function (pos) {\n    var _this = this;\n\n    var _options$pullUpLoad$t = this.options.pullUpLoad.threshold,\n        threshold = _options$pullUpLoad$t === undefined ? 0 : _options$pullUpLoad$t;\n\n    if (this.movingDirectionY === DIRECTION_UP && pos.y <= this.maxScrollY + threshold) {\n      // reset pullupWatching status after scroll end.\n      this.once('scrollEnd', function () {\n        _this.pullupWatching = false;\n      });\n      this.trigger('pullingUp');\n      this.off('scroll', this._checkToEnd);\n    }\n  };\n\n  BScroll.prototype.finishPullUp = function () {\n    var _this2 = this;\n\n    if (this.pullupWatching) {\n      this.once('scrollEnd', function () {\n        _this2._watchPullUp();\n      });\n    } else {\n      this._watchPullUp();\n    }\n  };\n\n  BScroll.prototype.openPullUp = function () {\n    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n\n    this.options.pullUpLoad = config;\n    this._initPullUp();\n  };\n\n  BScroll.prototype.closePullUp = function () {\n    this.options.pullUpLoad = false;\n    if (!this.pullupWatching) {\n      return;\n    }\n    this.pullupWatching = false;\n    this.off('scroll', this._checkToEnd);\n  };\n}\n\nfunction mouseWheelMixin(BScroll) {\n  BScroll.prototype._initMouseWheel = function () {\n    var _this = this;\n\n    this._handleMouseWheelEvent(addEvent);\n\n    this.on('destroy', function () {\n      clearTimeout(_this.mouseWheelTimer);\n      clearTimeout(_this.mouseWheelEndTimer);\n      _this._handleMouseWheelEvent(removeEvent);\n    });\n\n    this.firstWheelOpreation = true;\n  };\n\n  BScroll.prototype._handleMouseWheelEvent = function (eventOperation) {\n    eventOperation(this.wrapper, 'wheel', this);\n    eventOperation(this.wrapper, 'mousewheel', this);\n    eventOperation(this.wrapper, 'DOMMouseScroll', this);\n  };\n\n  BScroll.prototype._onMouseWheel = function (e) {\n    var _this2 = this;\n\n    if (!this.enabled) {\n      return;\n    }\n    e.preventDefault();\n\n    if (this.options.stopPropagation) {\n      e.stopPropagation();\n    }\n\n    if (this.firstWheelOpreation) {\n      this.trigger('scrollStart');\n    }\n    this.firstWheelOpreation = false;\n\n    var _options$mouseWheel = this.options.mouseWheel,\n        _options$mouseWheel$s = _options$mouseWheel.speed,\n        speed = _options$mouseWheel$s === undefined ? 20 : _options$mouseWheel$s,\n        _options$mouseWheel$i = _options$mouseWheel.invert,\n        invert = _options$mouseWheel$i === undefined ? false : _options$mouseWheel$i,\n        _options$mouseWheel$e = _options$mouseWheel.easeTime,\n        easeTime = _options$mouseWheel$e === undefined ? 300 : _options$mouseWheel$e;\n\n\n    clearTimeout(this.mouseWheelTimer);\n    this.mouseWheelTimer = setTimeout(function () {\n      if (!_this2.options.snap && !easeTime) {\n        _this2.trigger('scrollEnd', {\n          x: _this2.x,\n          y: _this2.y\n        });\n      }\n      _this2.firstWheelOpreation = true;\n    }, 400);\n\n    var wheelDeltaX = void 0;\n    var wheelDeltaY = void 0;\n\n    switch (true) {\n      case 'deltaX' in e:\n        if (e.deltaMode === 1) {\n          wheelDeltaX = -e.deltaX * speed;\n          wheelDeltaY = -e.deltaY * speed;\n        } else {\n          wheelDeltaX = -e.deltaX;\n          wheelDeltaY = -e.deltaY;\n        }\n        break;\n      case 'wheelDeltaX' in e:\n        wheelDeltaX = e.wheelDeltaX / 120 * speed;\n        wheelDeltaY = e.wheelDeltaY / 120 * speed;\n        break;\n      case 'wheelDelta' in e:\n        wheelDeltaX = wheelDeltaY = e.wheelDelta / 120 * speed;\n        break;\n      case 'detail' in e:\n        wheelDeltaX = wheelDeltaY = -e.detail / 3 * speed;\n        break;\n      default:\n        return;\n    }\n\n    var direction = invert ? -1 : 1;\n    wheelDeltaX *= direction;\n    wheelDeltaY *= direction;\n\n    if (!this.hasVerticalScroll) {\n      wheelDeltaX = wheelDeltaY;\n      wheelDeltaY = 0;\n    }\n\n    var newX = void 0;\n    var newY = void 0;\n    if (this.options.snap) {\n      newX = this.currentPage.pageX;\n      newY = this.currentPage.pageY;\n\n      if (wheelDeltaX > 0) {\n        newX--;\n      } else if (wheelDeltaX < 0) {\n        newX++;\n      }\n\n      if (wheelDeltaY > 0) {\n        newY--;\n      } else if (wheelDeltaY < 0) {\n        newY++;\n      }\n\n      this._goToPage(newX, newY);\n      return;\n    }\n\n    newX = this.x + Math.round(this.hasHorizontalScroll ? wheelDeltaX : 0);\n    newY = this.y + Math.round(this.hasVerticalScroll ? wheelDeltaY : 0);\n\n    this.movingDirectionX = this.directionX = wheelDeltaX > 0 ? -1 : wheelDeltaX < 0 ? 1 : 0;\n    this.movingDirectionY = this.directionY = wheelDeltaY > 0 ? -1 : wheelDeltaY < 0 ? 1 : 0;\n\n    if (newX > this.minScrollX) {\n      newX = this.minScrollX;\n    } else if (newX < this.maxScrollX) {\n      newX = this.maxScrollX;\n    }\n\n    if (newY > this.minScrollY) {\n      newY = this.minScrollY;\n    } else if (newY < this.maxScrollY) {\n      newY = this.maxScrollY;\n    }\n\n    var needTriggerEnd = this.y === newY;\n    this.scrollTo(newX, newY, easeTime, ease.swipe);\n    this.trigger('scroll', {\n      x: this.x,\n      y: this.y\n    });\n    clearTimeout(this.mouseWheelEndTimer);\n    if (needTriggerEnd) {\n      this.mouseWheelEndTimer = setTimeout(function () {\n        _this2.trigger('scrollEnd', {\n          x: _this2.x,\n          y: _this2.y\n        });\n      }, easeTime);\n    }\n  };\n}\n\nfunction zoomMixin(BScroll) {\n  BScroll.prototype._initZoom = function () {\n    var _options$zoom = this.options.zoom,\n        _options$zoom$start = _options$zoom.start,\n        start = _options$zoom$start === undefined ? 1 : _options$zoom$start,\n        _options$zoom$min = _options$zoom.min,\n        min = _options$zoom$min === undefined ? 1 : _options$zoom$min,\n        _options$zoom$max = _options$zoom.max,\n        max = _options$zoom$max === undefined ? 4 : _options$zoom$max;\n\n    this.scale = Math.min(Math.max(start, min), max);\n    this.setScale(this.scale);\n    this.scrollerStyle[style.transformOrigin] = '0 0';\n  };\n\n  BScroll.prototype._zoomTo = function (scale, originX, originY, startScale) {\n    this.scaled = true;\n\n    var lastScale = scale / (startScale || this.scale);\n    this.setScale(scale);\n\n    this.refresh();\n\n    var newX = Math.round(this.startX - (originX - this.relativeX) * (lastScale - 1));\n    var newY = Math.round(this.startY - (originY - this.relativeY) * (lastScale - 1));\n\n    if (newX > this.minScrollX) {\n      newX = this.minScrollX;\n    } else if (newX < this.maxScrollX) {\n      newX = this.maxScrollX;\n    }\n\n    if (newY > this.minScrollY) {\n      newY = this.minScrollY;\n    } else if (newY < this.maxScrollY) {\n      newY = this.maxScrollY;\n    }\n\n    if (this.x !== newX || this.y !== newY) {\n      this.scrollTo(newX, newY, this.options.bounceTime);\n    }\n\n    this.scaled = false;\n  };\n\n  BScroll.prototype.zoomTo = function (scale, x, y) {\n    var _offsetToBody = offsetToBody(this.wrapper),\n        left = _offsetToBody.left,\n        top = _offsetToBody.top;\n\n    var originX = x + left - this.x;\n    var originY = y + top - this.y;\n    this._zoomTo(scale, originX, originY);\n  };\n\n  BScroll.prototype._zoomStart = function (e) {\n    var firstFinger = e.touches[0];\n    var secondFinger = e.touches[1];\n    var deltaX = Math.abs(firstFinger.pageX - secondFinger.pageX);\n    var deltaY = Math.abs(firstFinger.pageY - secondFinger.pageY);\n\n    this.startDistance = getDistance(deltaX, deltaY);\n    this.startScale = this.scale;\n\n    var _offsetToBody2 = offsetToBody(this.wrapper),\n        left = _offsetToBody2.left,\n        top = _offsetToBody2.top;\n\n    this.originX = Math.abs(firstFinger.pageX + secondFinger.pageX) / 2 + left - this.x;\n    this.originY = Math.abs(firstFinger.pageY + secondFinger.pageY) / 2 + top - this.y;\n\n    this.trigger('zoomStart');\n  };\n\n  BScroll.prototype._zoom = function (e) {\n    if (!this.enabled || this.destroyed || eventType[e.type] !== this.initiated) {\n      return;\n    }\n\n    if (this.options.preventDefault) {\n      e.preventDefault();\n    }\n\n    if (this.options.stopPropagation) {\n      e.stopPropagation();\n    }\n\n    var firstFinger = e.touches[0];\n    var secondFinger = e.touches[1];\n    var deltaX = Math.abs(firstFinger.pageX - secondFinger.pageX);\n    var deltaY = Math.abs(firstFinger.pageY - secondFinger.pageY);\n    var distance = getDistance(deltaX, deltaY);\n    var scale = distance / this.startDistance * this.startScale;\n\n    this.scaled = true;\n\n    var _options$zoom2 = this.options.zoom,\n        _options$zoom2$min = _options$zoom2.min,\n        min = _options$zoom2$min === undefined ? 1 : _options$zoom2$min,\n        _options$zoom2$max = _options$zoom2.max,\n        max = _options$zoom2$max === undefined ? 4 : _options$zoom2$max;\n\n\n    if (scale < min) {\n      scale = 0.5 * min * Math.pow(2.0, scale / min);\n    } else if (scale > max) {\n      scale = 2.0 * max * Math.pow(0.5, max / scale);\n    }\n\n    var lastScale = scale / this.startScale;\n\n    var x = this.startX - (this.originX - this.relativeX) * (lastScale - 1);\n    var y = this.startY - (this.originY - this.relativeY) * (lastScale - 1);\n\n    this.setScale(scale);\n\n    this.scrollTo(x, y, 0);\n  };\n\n  BScroll.prototype._zoomEnd = function (e) {\n    if (!this.enabled || this.destroyed || eventType[e.type] !== this.initiated) {\n      return;\n    }\n\n    if (this.options.preventDefault) {\n      e.preventDefault();\n    }\n\n    if (this.options.stopPropagation) {\n      e.stopPropagation();\n    }\n\n    this.isInTransition = false;\n    this.isAnimating = false;\n    this.initiated = 0;\n\n    var _options$zoom3 = this.options.zoom,\n        _options$zoom3$min = _options$zoom3.min,\n        min = _options$zoom3$min === undefined ? 1 : _options$zoom3$min,\n        _options$zoom3$max = _options$zoom3.max,\n        max = _options$zoom3$max === undefined ? 4 : _options$zoom3$max;\n\n\n    var scale = this.scale > max ? max : this.scale < min ? min : this.scale;\n\n    this._zoomTo(scale, this.originX, this.originY, this.startScale);\n\n    this.trigger('zoomEnd');\n  };\n}\n\n// import { ease } from '../util/ease'\n\n// Number of items to instantiate beyond current view in the scroll direction.\nvar RUNWAY_ITEMS = 30;\n\n// Number of items to instantiate beyond current view in the opposite direction.\nvar RUNWAY_ITEMS_OPPOSITE = 10;\n\n// The animation interval (in ms) for fading in content from tombstones.\nvar ANIMATION_DURATION_MS = 200;\n\n// The number of pixels of default additional length to allow scrolling to.\nvar DEFAULT_SCROLL_RUNWAY = 2000;\n\nfunction infiniteMixin(BScroll) {\n  BScroll.prototype._initInfinite = function () {\n    this.options.probeType = 3;\n    this.maxScrollY = -DEFAULT_SCROLL_RUNWAY;\n    this.infiniteScroller = new InfiniteScroller(this, this.options.infinity);\n  };\n}\n\nfunction isTombstoneNode(node) {\n  if (node && node.classList) {\n    return node.classList.contains('tombstone');\n  }\n}\n\nfunction InfiniteScroller(scroller, options) {\n  var _this = this;\n\n  this.options = options;\n  assert(typeof this.options.createTombstone === 'function', 'Infinite scroll need createTombstone Function to create tombstone');\n\n  assert(typeof this.options.fetch === 'function', 'Infinite scroll need fetch Function to fetch new data.');\n\n  assert(typeof this.options.render === 'function', 'Infinite scroll need render Function to render each item.');\n\n  this.firstAttachedItem = 0;\n  this.lastAttachedItem = 0;\n\n  this.anchorScrollTop = 0;\n  this.anchorItem = {\n    index: 0,\n    offset: 0\n  };\n  this.tombstoneHeight = 0;\n  this.tombstoneWidth = 0;\n  this.tombstones = [];\n  this.tombstonesAnimationHandlers = [];\n\n  this.items = [];\n  this.loadedItems = 0;\n  this.requestInProgress = false;\n  this.hasMore = true;\n\n  this.scroller = scroller;\n  this.wrapperEl = this.scroller.wrapper;\n  this.scrollerEl = this.scroller.scroller;\n  this.scroller.on('scroll', function () {\n    _this.onScroll();\n  });\n  this.scroller.on('resize', function () {\n    _this.onResize();\n  });\n  this.scroller.on('destroy', function () {\n    _this.destroy();\n  });\n\n  // wait scroll core init\n  this._onResizeHandler = setTimeout(function () {\n    _this.onResize();\n  });\n}\n\nInfiniteScroller.prototype.destroy = function () {\n  var _this2 = this;\n\n  // In extreme scene, destroy is triggered before _onResizeHandler\n  clearTimeout(this._onResizeHandler);\n  this.tombstonesAnimationHandlers.forEach(function (handler) {\n    clearTimeout(handler);\n  });\n  this.tombstonesAnimationHandlers = null;\n  this.items.forEach(function (item) {\n    if (item.node) {\n      _this2.scrollerEl.removeChild(item.node);\n      item.node = null;\n    }\n  });\n  this.scroller.infiniteScroller = null;\n  this.scroller = null;\n  this.wrapperEl = null;\n  this.scrollerEl = null;\n  this.items = null;\n  this.tombstones = null;\n};\n\nInfiniteScroller.prototype.onScroll = function () {\n  var scrollTop = -this.scroller.y;\n  var delta = scrollTop - this.anchorScrollTop;\n  if (scrollTop === 0) {\n    this.anchorItem = {\n      index: 0,\n      offset: 0\n    };\n  } else {\n    this.anchorItem = this._calculateAnchoredItem(this.anchorItem, delta);\n  }\n\n  this.anchorScrollTop = scrollTop;\n  var lastScreenItem = this._calculateAnchoredItem(this.anchorItem, this.scroller.wrapperHeight);\n\n  var start = this.anchorItem.index;\n  var end = lastScreenItem.index;\n  if (delta < 0) {\n    start -= RUNWAY_ITEMS;\n    end += RUNWAY_ITEMS_OPPOSITE;\n  } else {\n    start -= RUNWAY_ITEMS_OPPOSITE;\n    end += RUNWAY_ITEMS;\n  }\n  this.fill(start, end);\n  this.maybeRequestContent();\n};\n\nInfiniteScroller.prototype.onResize = function () {\n  var tombstone = this.options.createTombstone();\n  tombstone.style.position = 'absolute';\n  this.scrollerEl.appendChild(tombstone);\n  tombstone.style.display = '';\n  this.tombstoneHeight = tombstone.offsetHeight;\n  this.tombstoneWidth = tombstone.offsetWidth;\n  this.scrollerEl.removeChild(tombstone);\n\n  for (var i = 0; i < this.items.length; i++) {\n    this.items[i].height = this.items[i].width = 0;\n  }\n\n  this.onScroll();\n};\n\nInfiniteScroller.prototype.fill = function (start, end) {\n  this.firstAttachedItem = Math.max(0, start);\n  if (!this.hasMore) {\n    end = Math.min(end, this.items.length);\n  }\n  this.lastAttachedItem = end;\n  this.attachContent();\n};\n\nInfiniteScroller.prototype.maybeRequestContent = function () {\n  var _this3 = this;\n\n  if (this.requestInProgress || !this.hasMore) {\n    return;\n  }\n  var itemsNeeded = this.lastAttachedItem - this.loadedItems;\n  if (itemsNeeded <= 0) {\n    return;\n  }\n  this.requestInProgress = true;\n  this.options.fetch(itemsNeeded).then(function (items) {\n    _this3.requestInProgress = false;\n    if (items) {\n      _this3.addContent(items);\n    } else {\n      _this3.hasMore = false;\n      var tombstoneLen = _this3._removeTombstones();\n      var curPos = 0;\n      if (_this3.anchorItem.index <= _this3.items.length) {\n        curPos = _this3._fixScrollPosition();\n        _this3._setupAnimations({}, curPos);\n        _this3.scroller.resetPosition(_this3.scroller.options.bounceTime);\n      } else {\n        _this3.anchorItem.index -= tombstoneLen;\n        curPos = _this3._fixScrollPosition();\n        _this3._setupAnimations({}, curPos);\n        _this3.scroller.stop();\n        _this3.scroller.resetPosition();\n        _this3.onScroll();\n      }\n    }\n  });\n};\n\nInfiniteScroller.prototype.addContent = function (items) {\n  for (var i = 0; i < items.length; i++) {\n    if (this.items.length <= this.loadedItems) {\n      this._addItem();\n    }\n    this.items[this.loadedItems++].data = items[i];\n  }\n  this.attachContent();\n  this.maybeRequestContent();\n};\n\nInfiniteScroller.prototype.attachContent = function () {\n  var unusedNodes = this._collectUnusedNodes();\n  var tombstoneAnimations = this._createDOMNodes(unusedNodes);\n  this._cleanupUnusedNodes(unusedNodes);\n  this._cacheNodeSize();\n  var curPos = this._fixScrollPosition();\n  this._setupAnimations(tombstoneAnimations, curPos);\n};\n\nInfiniteScroller.prototype.resetMore = function () {\n  this.hasMore = true;\n};\n\nInfiniteScroller.prototype._removeTombstones = function () {\n  var markIndex = void 0;\n  var tombstoneLen = 0;\n  var itemLen = this.items.length;\n  for (var i = 0; i < itemLen; i++) {\n    var currentNode = this.items[i].node;\n    var currentData = this.items[i].data;\n    if ((!currentNode || isTombstoneNode(currentNode)) && !currentData) {\n      // 0 should be excluded\n      if (markIndex === void 0) {\n        markIndex = i;\n      }\n      if (currentNode) {\n        this.scrollerEl.removeChild(currentNode);\n      }\n    }\n  }\n  tombstoneLen = itemLen - markIndex;\n  this.items.splice(markIndex);\n  this.lastAttachedItem = Math.min(this.lastAttachedItem, this.items.length);\n  return tombstoneLen;\n};\n\nInfiniteScroller.prototype._collectUnusedNodes = function () {\n  var unusedNodes = [];\n  for (var i = 0; i < this.items.length; i++) {\n    // Skip the items which should be visible.\n    if (i === this.firstAttachedItem) {\n      i = this.lastAttachedItem - 1;\n      continue;\n    }\n    var currentNode = this.items[i].node;\n    if (currentNode) {\n      if (isTombstoneNode(currentNode)) {\n        // Cache tombstones for reuse\n        this.tombstones.push(currentNode);\n        this.tombstones[this.tombstones.length - 1].style.display = 'none';\n      } else {\n        unusedNodes.push(currentNode);\n      }\n    }\n    this.items[i].node = null;\n  }\n  return unusedNodes;\n};\n\nInfiniteScroller.prototype._createDOMNodes = function (unusedNodes) {\n  var tombstoneAnimations = {};\n  for (var i = this.firstAttachedItem; i < this.lastAttachedItem; i++) {\n    while (this.items.length <= i) {\n      this._addItem();\n    }\n    var currentNode = this.items[i].node;\n    var currentData = this.items[i].data;\n    if (currentNode) {\n      if (isTombstoneNode(currentNode) && currentData) {\n        currentNode.style.zIndex = 1;\n        tombstoneAnimations[i] = [currentNode, this.items[i].top - this.anchorScrollTop];\n        this.items[i].node = null;\n      } else {\n        continue;\n      }\n    }\n    var node = currentData ? this.options.render(currentData, unusedNodes.pop()) : this._getTombStone();\n    node.style.position = 'absolute';\n    this.items[i].top = -1;\n    this.scrollerEl.appendChild(node);\n    this.items[i].node = node;\n  }\n  return tombstoneAnimations;\n};\n\nInfiniteScroller.prototype._cleanupUnusedNodes = function (unusedNodes) {\n  while (unusedNodes.length) {\n    this.scrollerEl.removeChild(unusedNodes.pop());\n  }\n};\n\nInfiniteScroller.prototype._cacheNodeSize = function () {\n  for (var i = this.firstAttachedItem; i < this.lastAttachedItem; i++) {\n    var item = this.items[i];\n    // Only cache the height if we have the real contents, not a placeholder.\n    if (item.data && !item.height) {\n      var isTombstone = isTombstoneNode(item.node);\n      item.height = isTombstone ? this.tombstoneHeight : item.node.offsetHeight;\n      item.width = isTombstone ? this.tombstoneWidth : item.node.offsetWidth;\n    }\n  }\n};\n\nInfiniteScroller.prototype._fixScrollPosition = function () {\n  this.anchorScrollTop = 0;\n  for (var _i = 0; _i < this.anchorItem.index; _i++) {\n    this.anchorScrollTop += this.items[_i].height || this.tombstoneHeight;\n  }\n  this.anchorScrollTop += this.anchorItem.offset;\n\n  // Position all nodes.\n  var curPos = this.anchorScrollTop - this.anchorItem.offset;\n  var i = this.anchorItem.index;\n  while (i > this.firstAttachedItem) {\n    curPos -= this.items[i - 1].height || this.tombstoneHeight;\n    i--;\n  }\n\n  return curPos;\n};\n\nInfiniteScroller.prototype._setupAnimations = function (tombstoneAnimations, curPos) {\n  var _this4 = this;\n\n  for (var i in tombstoneAnimations) {\n    var animation = tombstoneAnimations[i];\n    this.items[i].node.style[style.transform] = 'translateY(' + (this.anchorScrollTop + animation[1]) + 'px) scale(' + this.tombstoneWidth / this.items[i].width + ', ' + this.tombstoneHeight / this.items[i].height + ')';\n    // Call offsetTop on the nodes to be animated to force them to apply current transforms.\n    /* eslint-disable no-unused-expressions */\n    this.items[i].node.offsetTop;\n    animation[0].offsetTop;\n    this.items[i].node.style[style.transition] = cssVendor + 'transform ' + ANIMATION_DURATION_MS + 'ms';\n  }\n\n  for (var _i2 = this.firstAttachedItem; _i2 < this.lastAttachedItem; _i2++) {\n    var _animation = tombstoneAnimations[_i2];\n    if (_animation) {\n      var tombstoneNode = _animation[0];\n      tombstoneNode.style[style.transition] = cssVendor + 'transform ' + ANIMATION_DURATION_MS + 'ms, opacity ' + ANIMATION_DURATION_MS + 'ms';\n      tombstoneNode.style[style.transform] = 'translateY(' + curPos + 'px) scale(' + this.items[_i2].width / this.tombstoneWidth + ', ' + this.items[_i2].height / this.tombstoneHeight + ')';\n      tombstoneNode.style.opacity = 0;\n    }\n    if (curPos !== this.items[_i2].top) {\n      if (!_animation) {\n        this.items[_i2].node.style[style.transition] = '';\n      }\n      this.items[_i2].node.style[style.transform] = 'translateY(' + curPos + 'px)';\n    }\n    this.items[_i2].top = curPos;\n    curPos += this.items[_i2].height || this.tombstoneHeight;\n  }\n\n  this.scroller.maxScrollY = -(curPos - this.scroller.wrapperHeight + (this.hasMore ? DEFAULT_SCROLL_RUNWAY : 0));\n\n  var tombstoneAnimationsHandler = setTimeout(function () {\n    for (var _i3 in tombstoneAnimations) {\n      var _animation2 = tombstoneAnimations[_i3];\n      _animation2[0].style.display = 'none';\n      // Tombstone can be recycled now.\n      _this4.tombstones.push(_animation2[0]);\n    }\n  }, ANIMATION_DURATION_MS);\n\n  this.tombstonesAnimationHandlers.push(tombstoneAnimationsHandler);\n};\n\nInfiniteScroller.prototype._getTombStone = function () {\n  var tombstone = this.tombstones.pop();\n  if (tombstone) {\n    tombstone.style.display = '';\n    tombstone.style.opacity = 1;\n    tombstone.style[style.transform] = '';\n    tombstone.style[style.transition] = '';\n    return tombstone;\n  }\n  return this.options.createTombstone();\n};\n\nInfiniteScroller.prototype._addItem = function () {\n  this.items.push({\n    data: null,\n    node: null,\n    height: 0,\n    width: 0,\n    top: 0\n  });\n};\n\nInfiniteScroller.prototype._calculateAnchoredItem = function (initialAnchor, delta) {\n  if (delta === 0) {\n    return initialAnchor;\n  }\n  var i = initialAnchor.index;\n  var tombstones = 0;\n\n  delta += initialAnchor.offset;\n  if (delta < 0) {\n    while (delta < 0 && i > 0 && this.items[i - 1].height) {\n      delta += this.items[i - 1].height;\n      i--;\n    }\n    tombstones = Math.max(-i, Math.ceil(Math.min(delta, 0) / this.tombstoneHeight));\n  } else {\n    while (delta > 0 && i < this.items.length && this.items[i].height && this.items[i].height < delta) {\n      delta -= this.items[i].height;\n      i++;\n    }\n    if (i >= this.items.length || !this.items[i].height) {\n      tombstones = Math.floor(Math.max(delta, 0) / this.tombstoneHeight);\n    }\n  }\n  i += tombstones;\n  delta -= tombstones * this.tombstoneHeight;\n\n  return {\n    index: i,\n    offset: delta\n  };\n};\n\nfunction BScroll(el, options) {\n  this.wrapper = typeof el === 'string' ? document.querySelector(el) : el;\n  if (!this.wrapper) {\n    warn('Can not resolve the wrapper DOM.');\n  }\n  this.scroller = this.wrapper.children[0];\n  if (!this.scroller) {\n    warn('The wrapper need at least one child element to be scroller.');\n  }\n  // cache style for better performance\n  this.scrollerStyle = this.scroller.style;\n\n  this._init(options);\n}\n\ninitMixin(BScroll);\ncoreMixin(BScroll);\neventMixin(BScroll);\nsnapMixin(BScroll);\nwheelMixin(BScroll);\nscrollbarMixin(BScroll);\npullDownMixin(BScroll);\npullUpMixin(BScroll);\nmouseWheelMixin(BScroll);\nzoomMixin(BScroll);\ninfiniteMixin(BScroll);\n\nBScroll.Version = '1.14.1';\n\nexport default BScroll;\n","const pre = 'vue-slim-better-scroll'\n\nexport default {\n  methods: {\n    // 生成 css class\n    c (className) {\n      return className ? `${pre}${className}` : `${pre}`\n    },\n  },\n}\n","<template>\n  <div :class=\"c('__loading')\">\n    <i v-for=\"item in 12\" :key=\"item\" />\n  </div>\n</template>\n<script type=\"text/ecmascript-6\">\nimport mixin from '../mixins'\n\nexport default {\n  name: 'Loading',\n  mixins: [mixin],\n}\n</script>\n<style lang=\"stylus\">\n$ = vue-slim-better-scroll;\n$color = #8c8c8c;\n.{$}__loading {\n  width: 20px;\n  height: 20px;\n  position: relative;\n  display: block;\n  box-sizing: border-box;\n  animation: spinner-rotate 1s linear infinite;\n  animation-timing-function: steps(12);\n  color: $color;\n\n  i {\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    position: absolute;\n\n    &::before {\n      width: 9%;\n      height: 25%;\n      content: '';\n      display: block;\n      margin: 0 auto;\n      border-radius: 10px;\n      background-color: currentColor;\n    }\n  }\n\n  for $i in (1 .. 12) {\n    i:nth-of-type({$i}) {\n      opacity: 1 - (0.75 / 12) * ($i - 1);\n      transform: rotate($i * 30deg);\n    }\n  }\n\n  @keyframes spinner-rotate {\n    from {\n      transform: rotate(0deg);\n    }\n\n    to {\n      transform: rotate(360deg);\n    }\n  }\n}\n</style>\n","<template>\n  <canvas\n    ref=\"bubble\"\n    :width=\"width\"\n    :height=\"height\"\n    :style=\"style\" />\n</template>\n\n<script>\nexport default {\n  props: {\n    y: {\n      type: Number,\n      default: 0,\n    },\n  },\n  data () {\n    return {\n      width: 50,\n      height: 80,\n    }\n  },\n  computed: {\n    distance () {\n      return Math.max(0, Math.min(this.y * this.ratio, this.maxDistance))\n    },\n    style () {\n      return `width:${this.width / this.ratio}px;height:${this.height / this.ratio}px`\n    },\n  },\n  watch: {\n    y () {\n      this._draw()\n    },\n  },\n  created () {\n    this.ratio = window.devicePixelRatio\n    this.width *= this.ratio\n    this.height *= this.ratio\n    this.initRadius = 18 * this.ratio\n    this.minHeadRadius = 12 * this.ratio\n    this.minTailRadius = 5 * this.ratio\n    this.initArrowRadius = 10 * this.ratio\n    this.minArrowRadius = 6 * this.ratio\n    this.arrowWidth = 3 * this.ratio\n    this.maxDistance = 40 * this.ratio\n    this.initCenterX = 25 * this.ratio\n    this.initCenterY = 25 * this.ratio\n    this.headCenter = {\n      x: this.initCenterX,\n      y: this.initCenterY,\n    }\n  },\n  mounted () {\n    this._draw()\n  },\n  methods: {\n    _draw () {\n      const bubble = this.$refs.bubble\n      let ctx = bubble.getContext('2d')\n      ctx.clearRect(0, 0, bubble.width, bubble.height)\n\n      this._drawBubble(ctx)\n\n      this._drawArrow(ctx)\n    },\n    _drawBubble (ctx) {\n      ctx.save()\n      ctx.beginPath()\n\n      const rate = this.distance / this.maxDistance\n      const headRadius = this.initRadius - (this.initRadius - this.minHeadRadius) * rate\n\n      this.headCenter.y = this.initCenterY - (this.initRadius - this.minHeadRadius) * rate\n\n      // 画上半弧线\n      ctx.arc(this.headCenter.x, this.headCenter.y, headRadius, 0, Math.PI, true)\n\n      // 画左侧贝塞尔\n      const tailRadius = this.initRadius - (this.initRadius - this.minTailRadius) * rate\n      const tailCenter = {\n        x: this.headCenter.x,\n        y: this.headCenter.y + this.distance,\n      }\n\n      const tailPointL = {\n        x: tailCenter.x - tailRadius,\n        y: tailCenter.y,\n      }\n      const controlPointL = {\n        x: tailPointL.x,\n        y: tailPointL.y - this.distance / 2,\n      }\n\n      ctx.quadraticCurveTo(controlPointL.x, controlPointL.y, tailPointL.x, tailPointL.y)\n\n      // 画下半弧线\n      ctx.arc(tailCenter.x, tailCenter.y, tailRadius, Math.PI, 0, true)\n\n      // 画右侧贝塞尔\n      const headPointR = {\n        x: this.headCenter.x + headRadius,\n        y: this.headCenter.y,\n      }\n      const controlPointR = {\n        x: tailCenter.x + tailRadius,\n        y: headPointR.y + this.distance / 2,\n      }\n      ctx.quadraticCurveTo(controlPointR.x, controlPointR.y, headPointR.x, headPointR.y)\n\n      ctx.fillStyle = 'rgb(170,170,170)'\n      ctx.fill()\n      ctx.strokeStyle = 'rgb(153,153,153)'\n      ctx.stroke()\n      ctx.restore()\n    },\n    _drawArrow (ctx) {\n      ctx.save()\n      ctx.beginPath()\n\n      const rate = this.distance / this.maxDistance\n      const arrowRadius = this.initArrowRadius - (this.initArrowRadius - this.minArrowRadius) * rate\n\n      // 画内圆\n      ctx.arc(this.headCenter.x, this.headCenter.y, arrowRadius - (this.arrowWidth - rate), -Math.PI / 2, 0, true)\n\n      // 画外圆\n      ctx.arc(this.headCenter.x, this.headCenter.y, arrowRadius, 0, Math.PI * 3 / 2, false)\n\n      ctx.lineTo(this.headCenter.x, this.headCenter.y - arrowRadius - this.arrowWidth / 2 + rate)\n      ctx.lineTo(this.headCenter.x + this.arrowWidth * 2 - rate * 2, this.headCenter.y - arrowRadius + this.arrowWidth / 2)\n\n      ctx.lineTo(this.headCenter.x, this.headCenter.y - arrowRadius + this.arrowWidth * 3 / 2 - rate)\n\n      ctx.fillStyle = 'rgb(255,255,255)'\n      ctx.fill()\n      ctx.strokeStyle = 'rgb(170,170,170)'\n      ctx.stroke()\n      ctx.restore()\n    },\n  },\n}\n</script>\n","/**\n * 一些帮助函数\n */\n\n/**\n * setTimeout 的 promise 封装\n * @param {Number} time\n * @returns\n */\nexport function timeout (time) {\n  return new Promise(resolve => {\n    setTimeout(resolve, time)\n  })\n}\n","/**\n * better-scroll vue封装\n * @Author komo\n * @Date 2018/05\n */\n\n<template>\n  <div ref=\"scroll\" :class=\"c()\">\n    <div :class=\"c('__wrapper')\">\n      <div ref=\"scrollContent\">\n        <slot />\n      </div>\n\n      <slot\n        :pullUp=\"pullUp\"\n        :pullUpNow=\"pullUpNow\"\n        name=\"pullup\">\n        <div v-if=\"pullUp\" :class=\"c('__pullup')\">\n          <div v-if=\"!pullUpNow\">\n            <span>{{ pullUpTxt }}</span>\n          </div>\n          <div v-else>\n            <Loading />\n          </div>\n        </div>\n      </slot>\n    </div>\n\n    <slot\n      :pullDown=\"pullDown\"\n      :pullDownStyle=\"pullDownStyle\"\n      :pullDownBefore=\"pullDownBefore\"\n      :pullDownNow=\"pullDownNow\"\n      :bubbleY=\"bubbleY\"\n      name=\"pulldown\">\n      <div\n        v-if=\"pullDown\"\n        ref=\"pulldown\"\n        :style=\"pullDownStyle\"\n        :class=\"c('__pulldown')\">\n        <div v-if=\"pullDownBefore\" :class=\"c('__pulldown__before')\">\n          <Bubble :y=\"bubbleY\" />\n        </div>\n        <div v-else :class=\"c('__pulldown__after')\">\n          <div v-if=\"pullDownNow\">\n            <Loading />\n          </div>\n          <div v-else><span>{{ pullDownTxt }}</span></div>\n        </div>\n      </div>\n    </slot>\n  </div>\n</template>\n\n<script type=\"text/ecmascript-6\">\nimport BScroll from 'better-scroll'\nimport Loading from './Loading'\nimport Bubble from './Bubble'\nimport mixin from './mixins'\nimport { timeout } from './utils'\n\nexport default {\n  name: 'Scroll',\n  components: {\n    Loading,\n    Bubble,\n  },\n  mixins: [mixin],\n  props: {\n    probeType: {\n      // 滚动事件监听类型\n      type: Number,\n      default: 1,\n    },\n    click: {\n      // 开启点击事件代理\n      type: Boolean,\n      default: true,\n    },\n    listenScroll: {\n      // 监听滚动\n      type: Boolean,\n      default: false,\n    },\n    listenBeforeScrollStart: {\n      // 监听滚动开始前\n      type: Boolean,\n      default: false,\n    },\n    scrollX: {\n      // 开启X轴滚动\n      type: Boolean,\n      default: false,\n    },\n    scrollY: {\n      // 开启Y轴滚动\n      type: Boolean,\n      default: true,\n    },\n    scrollbar: {\n      // 开启滚动条\n      type: null,\n      default: false,\n    },\n    pullDown: {\n      // 启用下拉刷新\n      type: Boolean,\n      default: true,\n    },\n    pullDownConfig: {\n      // 下拉刷新配置\n      type: Object,\n      default: () => ({\n        threshold: 90, // 触发 pullingDown 的距离\n        stop: 40, // pullingDown 正在刷新 hold 时的距离\n        txt: '刷新成功',\n      }),\n    },\n    pullUp: {\n      // 启用上拉加载\n      type: Boolean,\n      default: true,\n    },\n    pullUpConfig: {\n      // 上拉加载配置\n      type: Object,\n      default: () => ({\n        threshold: 100, // 提前触发 pullingUp 的距离\n        txt: { more: '上拉加载', noMore: '— 我是有底线的 —' },\n      }),\n    },\n    startY: {\n      // 起始Y位置\n      type: Number,\n      default: 0,\n    },\n    bounce: {\n      // 回弹效果\n      type: Boolean,\n      default: true,\n    },\n    bounceTime: {\n      // 回弹时间\n      type: Number,\n      default: 600,\n    },\n    preventDefaultException: {\n      // 不阻止默认行为\n      type: Object,\n      default: () => ({\n        tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT)$/,\n      }),\n    },\n    mouseWheel: {\n      // 启用 PC 鼠标滚轮\n      type: Boolean,\n      default: false,\n    },\n    betterScrollOptions: {\n      // 任何的 better-scroll 配置项，将合并在初始化 better-scroll 的配置中。注意：与 props 冲突的配置项将被 props 覆盖\n      type: Object,\n      default: null,\n    },\n    autoUpdate: {\n      // 自动刷新高度:适用于简单场景，复杂场景请使用updateData/refreshData\n      type: Boolean,\n      default: false,\n    },\n    updateData: {\n      // 引起更新上拉/下拉加载状态的数据（下拉刷新/上拉加载相关的数据）\n      type: Array,\n      default: null,\n    },\n    refreshData: {\n      // 引起刷新高度的数据（不包含 updateData 内的数据）\n      type: Array,\n      default: null,\n    },\n  },\n  data () {\n    return {\n      pullDownBefore: true, // 下拉之前\n      pullDownNow: false, // 正在下拉\n      pullDownStyle: '', // 下拉样式\n      pullUpNow: false, // 正在上拉\n      pullUpFinally: false, // true表示到了上拉加载到了最底部\n      isRebounding: false, // 正在回弹\n      bubbleY: 0, // 气泡y坐标\n    }\n  },\n  computed: {\n    // 下拉的文本\n    pullDownTxt () {\n      return this.pullDownConfig && this.pullDownConfig.txt\n    },\n    // 上拉的文本\n    pullUpTxt () {\n      const moreTxt = this.pullUpConfig && this.pullUpConfig.txt && this.pullUpConfig.txt.more\n\n      const noMoreTxt = this.pullUpConfig && this.pullUpConfig.txt && this.pullUpConfig.txt.noMore\n\n      return this.pullUpFinally ? noMoreTxt : moreTxt\n    },\n  },\n  watch: {\n    updateData () {\n      this.update()\n    },\n    async refreshData () {\n      if (this.pullDownUpdateState || this.pullUpUpdateState) return\n\n      await this.$nextTick()\n      this.refresh()\n    },\n  },\n  activated () {\n    this.refresh()\n  },\n  async mounted () {\n    this.pullDownInitTop = parseInt(this.$refs.pulldown && getComputedStyle(this.$refs.pulldown).top) || -50\n\n    await this.$nextTick()\n    this.initScroll()\n\n    // 自动刷新高度：深监视 $data，发生改变时更新高度\n    this.autoUpdate && this.$parent && this.$parent.$data && this.$watch(() => this.$parent.$data, (val) => {\n      this.update()\n    }, {\n      deep: true,\n    })\n  },\n  methods: {\n    // 初始化scroll\n    initScroll () {\n      if (!this.$refs.scroll) return\n\n      // 设置scrollContent的最小高，实现高度不足时也有回弹效果\n      if (this.$refs.scrollContent) {\n        this.$refs.scrollContent.style.minHeight = `${this.$refs.scroll.getBoundingClientRect().height + 1}px`\n      }\n\n      const options = {\n        ...this.betterScrollOptions,\n        probeType: this.probeType,\n        click: this.click,\n        scrollX: this.scrollX,\n        scrollY: this.scrollY,\n        scrollbar: this.scrollbar,\n        pullDownRefresh: this.pullDown && this.pullDownConfig,\n        pullUpLoad: this.pullUp && this.pullUpConfig,\n        startY: this.startY,\n        bounce: this.bounce,\n        bounceTime: this.bounceTime,\n        preventDefaultException: this.preventDefaultException,\n        mouseWheel: this.mouseWheel,\n      }\n\n      this.scroll = new BScroll(this.$refs.scroll, options)\n\n      this.listenScroll &&\n        this.scroll.on('scroll', pos => {\n          this.$emit('scroll', pos)\n        })\n\n      this.listenBeforeScrollStart &&\n        this.scroll.on('beforeScrollStart', () => {\n          this.$emit('beforeScrollStart')\n        })\n\n      this.pullDown && this._initPullDown()\n\n      this.pullUp && this._initPullUp()\n    },\n    // 初始化下拉刷新\n    _initPullDown () {\n      this.scroll.on('pullingDown', () => {\n        this.pullDownBefore = false\n        this.pullDownNow = true\n        this.$emit('pullingDown')\n        this.scroll.closePullDown() // 防止在 bounce 前二次触发\n      })\n\n      this.scroll.on('scroll', pos => {\n        if (!this.pullDown || pos.y < 0) return\n\n        const posY = Math.floor(pos.y) // 滚动的y轴位置：Number\n\n        if (this.pullDownBefore) {\n          this.bubbleY = Math.max(0, posY + this.pullDownInitTop)\n          this.pullDownStyle = `transform: translateY(${Math.min(posY, -this.pullDownInitTop)}px)`\n        } else {\n          this.bubbleY = 0\n        }\n\n        if (this.isRebounding) {\n          this.pullDownStyle = `transform: translateY(${Math.min(posY, this.pullDownConfig.stop)}px)`\n        }\n      })\n    },\n    // 初始化上拉加载\n    _initPullUp () {\n      this.scroll.on('pullingUp', () => {\n        if (this.pullUpFinally) {\n          this.scroll.finishPullUp()\n        } else {\n          this.pullUpNow = true\n          this.$emit('pullingUp')\n        }\n      })\n    },\n    // 关闭滚动\n    disable () {\n      this.scroll && this.scroll.disable()\n    },\n    // 开启滚动\n    enable () {\n      this.scroll && this.scroll.enable()\n    },\n    // 销毁滚动示例\n    destroy () {\n      this.scroll && this.scroll.destroy()\n    },\n    // 刷新滚动高度\n    refresh () {\n      this.scroll && this.scroll.refresh()\n    },\n    // 更新加载状态，下拉/下拉成功后使用\n    async update (final) {\n      if (this.pullDown && this.pullDownNow) {\n        if (this.pullDownUpdateState) return\n        this.pullDownUpdateState = true // 正在update状态\n\n        // 下拉刷新触发成功后\n        this.pullDownNow = false\n        await timeout(this.bounceTime / 2) // 刷新成功hold\n        this.isRebounding = true\n        this.scroll.finishPullDown() // 开始回弹\n        await timeout(this.bounceTime)\n        this.pullDownBefore = true\n        this.isRebounding = false\n        this.scroll.openPullDown(this.pullDownConfig)\n\n        this.pullUpFinally = false\n      } else if (this.pullUp && this.pullUpNow) {\n        if (this.pullUpUpdateState) return\n        this.pullUpUpdateState = true // 正在update状态\n\n        // 上拉加载触发成功后\n        this.pullUpNow = false\n        this.scroll.finishPullUp()\n      }\n\n      typeof final !== 'undefined' && (this.pullUpFinally = !!final)\n\n      await this.$nextTick()\n      this.refresh()\n\n      this.pullDownUpdateState = false\n      this.pullUpUpdateState = false\n    },\n    /**\n     * 滚动到指定位置\n     * @param  {Number} x    x轴位置\n     * @param  {Number} y    y轴位置\n     * @param  {Number} time 滚动时间\n     * @return {Void}\n     */\n    scrollTo (x = 0, y = 0, time = this.bounceTime) {\n      this.scroll && this.scroll.scrollTo(x, y, time)\n    },\n    // 滚动到元素\n    scrollToElement () {\n      this.scroll && this.scroll.scrollToElement.apply(this.scroll, arguments)\n    },\n    // 滚动到顶部\n    scrollToTop () {\n      this.scroll && this.scrollTo(0, 0)\n    },\n    // 滚动到底部\n    scrollToBottom () {\n      this.scroll && this.scrollTo(0, this.scroll.maxScrollY)\n    },\n    // 手动触发下拉刷新\n    autoPullDownRefresh () {\n      this.scroll && this.scroll.autoPullDownRefresh()\n    },\n  },\n}\n</script>\n\n<style lang=\"stylus\">\n$ = vue-slim-better-scroll;\n.{$} {\n  width: 100%;\n  height: 100%;\n  overflow: hidden;\n  box-sizing: border-box;\n  position: relative;\n\n  &__wrapper {\n    position: relative;\n    z-index: 1;\n  }\n\n  &__pullup {\n    width: 100%;\n    height: 50px;\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    font-size: 14px;\n    color: rgb(153, 153, 153);\n  }\n\n  &__pulldown {\n    position: absolute;\n    left: 0;\n    top: -50px; /* no */\n    width: 100%;\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    transition: all;\n    font-size: 14px;\n    color: rgb(153, 153, 153);\n\n    &__before {\n      display: flex;\n    }\n\n    &__after {\n      width: 100%;\n      height: 40px; /* no */\n      display: flex;\n      justify-content: center;\n      align-items: center;\n    }\n  }\n}\n</style>\n","import Scroll from './Scroll'\n\nScroll.install = function (Vue) {\n  Vue.component(Scroll.name, Scroll)\n}\n\nexport default Scroll\n","<template>\n  <div id=\"app\">\n    <header class=\"header\" @click=\"scrollToTop\">点我回到顶部</header>\n\n    <!-- 简单场景 -->\n    <Scroll\n      ref=\"scroll\"\n      :auto-update=\"true\"\n      class=\"content\"\n      @pullingDown=\"loadRefresh\"\n      @pullingUp=\"loadMore\">\n      <ul>\n        <li v-for=\"(item, index) in list\" :key=\"index\">{{ item }}</li>\n      </ul>\n    </Scroll>\n\n    <!-- 复杂场景 -->\n    <Scroll\n      v-if=\"false\"\n      ref=\"scroll\"\n      :update-data=\"[list]\"\n      :refresh-data=\"[]\"\n      class=\"content\"\n      @pullingDown=\"loadRefresh\"\n      @pullingUp=\"loadMore\">\n      <ul>\n        <li v-for=\"(item, index) in list\" :key=\"index\">{{ item }}</li>\n      </ul>\n    </Scroll>\n\n    <footer class=\"footer\" @click=\"scrollToBottom\">点我回到底部</footer>\n  </div>\n</template>\n\n<script>\nimport Scroll from '../../src'\nimport { timeout } from '../../src/Scroll/utils'\n\nexport default {\n  name: 'App',\n  components: {\n    Scroll,\n  },\n  data () {\n    return {\n      list: [],\n    }\n  },\n  created () {\n    // 不会引起DOM变化的数据在此定义\n    this.page = 1\n    this.pageSize = 10\n  },\n  mounted () {\n    this.loadRefresh()\n  },\n  methods: {\n    // 滚动到顶部\n    scrollToTop () {\n      this.$refs.scroll.scrollToTop()\n    },\n    // 滚动到底部\n    scrollToBottom () {\n      this.$refs.scroll.scrollToBottom()\n    },\n    // 加载刷新数据\n    async loadRefresh () {\n      const data = await this._fetchList()\n\n      // 初始化数据\n      this.list = data\n      this.page = 1\n    },\n    // 加载更多数据\n    async loadMore () {\n      const page = this.page + 1\n      const data = await this._fetchList(page)\n\n      this.list.push(...data)\n      data.length < this.pageSize ? this.$refs.scroll.update(true) : this.page++ // 判断是否已达最后一页?如果已是最后一页，可调用this.$refs.scroll.update(true)关闭上拉\n    },\n\n    // 模拟一个异步获取列表操作\n    async _fetchList (page = 1, pageSize = this.pageSize) {\n      try {\n        await timeout(1000)\n\n        if (page < 3) {\n          // 模拟数据返回\n          return Array.from({ length: pageSize }, (value, index) => `第${page}页的数据${index}`)\n        } else {\n          // 模拟已到达最后一页时的数据返回\n          return Array.from({ length: pageSize / 2 }, (value, index) => `最后一页,第${page}页的数据${index}`)\n        }\n      } catch (e) {\n        return false\n      }\n    },\n  },\n}\n</script>\n\n<style lang=\"stylus\">\n$headerHeight = 44px;\n$baseColor = #6A9FB5;\n$bgColor = #FAFAFA;\n* {\n  padding: 0;\n  margin: 0;\n}\nhtml, body {\n  width: 100%;\n  height: 100%;\n  overflow: hidden;\n}\n#app {\n  width: 100%;\n  height: 100%;\n  overflow: hidden;\n  box-sizing: border-box;\n  display: flex;\n  flex-direction: column;\n\n  .header {\n    flex: 0 0 $headerHeight;\n    line-height: $headerHeight;\n    text-align: center;\n    color: #fff;\n    background: $baseColor;\n  }\n\n  .footer {\n    flex: 0 0 $headerHeight;\n    line-height: $headerHeight;\n    text-align: center;\n    color: #fff;\n    background: $baseColor;\n  }\n\n  .content {\n    flex: 1;\n    background-color: $bgColor;\n    overflow: hidden;\n    box-sizing: border-box;\n\n    ul {\n      li {\n        background: #fff;\n        height: 44px;\n        line-height: 44px;\n        text-align: center;\n        color: $baseColor;\n        border-bottom: 1px solid #eee;\n      }\n    }\n  }\n}\n</style>\n","import Vue from 'vue'\nimport App from './App'\n\nVue.config.productionTip = true\n\nnew Vue({\n  render: h => h(App),\n}).$mount('#app')\n"]}