{"version":3,"sources":["webpack:///application-96393767cb8330bacf8a.js","webpack:///webpack/bootstrap b1fa04718db38d3455db","webpack:///./node_modules/vue/dist/vue.esm.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/moveto/src/moveTo.js","webpack:///./app/javascript/packs/videobg.vue","webpack:///./node_modules/vue-loader/lib/component-normalizer.js","webpack:///app/javascript/packs/videobg.vue","webpack:///./app/javascript/packs/videobg.vue?1ebb","webpack:///./app/javascript/packs/top.js","webpack:///./app/javascript/packs/tilt.js","webpack:///./app/javascript/packs/effects.js","webpack:///(webpack)/buildin/amd-options.js","webpack:///./app/javascript/packs/application.js","webpack:///./node_modules/vue-parallaxy/dist/vue-parallaxy.min.js","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/animejs/anime.min.js","webpack:///./node_modules/scrollreveal/dist/scrollreveal.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","__webpack_exports__","global","isUndef","v","undefined","isDef","isTrue","isFalse","isPrimitive","value","isObject","obj","_typeof","isPlainObject","_toString","isRegExp","isValidArrayIndex","val","parseFloat","Math","floor","isFinite","toString","JSON","stringify","String","toNumber","isNaN","makeMap","str","expectsLowerCase","map","create","list","split","length","toLowerCase","remove","arr","item","index","indexOf","splice","hasOwn","key","cached","fn","cache","bind","ctx","boundFn","a","arguments","apply","_length","toArray","start","ret","Array","extend","to","_from","toObject","res","noop","b","looseEqual","isObjectA","isObjectB","isArrayA","isArray","isArrayB","every","e","keysA","keys","keysB","looseIndexOf","once","called","this","isReserved","charCodeAt","def","writable","parsePath","path","bailRE","test","segments","handleError","err","vm","info","config","errorHandler","inBrowser","console","error","isNative","Ctor","pushTarget","_target","Dep","target","targetStack","push","popTarget","pop","protoAugment","src","__proto__","copyAugment","observe","asRootData","ob","__ob__","Observer","observerState","shouldConvert","isServerRendering","isExtensible","_isVue","vmCount","defineReactive$$1","customSetter","shallow","dep","getOwnPropertyDescriptor","setter","set","childOb","depend","dependArray","newVal","notify","max","del","mergeData","from","toVal","fromVal","mergeDataOrFn","parentVal","childVal","instanceData","defaultData","mergeHook","concat","mergeAssets","normalizeProps","options","props","camelize","type","normalizeInject","inject","normalized","normalizeDirectives","dirs","directives","update","mergeOptions","parent","child","mergeField","strat","strats","defaultStrat","extendsFrom","extends","mixins","resolveAsset","id","warnMissing","assets","camelizedId","PascalCaseId","capitalize","validateProp","propOptions","propsData","prop","absent","isType","Boolean","hyphenate","getPropDefaultValue","prevShouldConvert","default","$options","_props","getType","match","len","createTextVNode","VNode","cloneVNode","vnode","cloned","tag","data","children","text","elm","context","componentOptions","asyncFactory","ns","isStatic","isComment","isCloned","cloneVNodes","vnodes","createFnInvoker","fns","invoker","arguments$1","slice","updateListeners","on","oldOn","add","remove$$1","cur","old","event","normalizeEvent","capture","passive","mergeVNodeHook","hookKey","hook","wrappedHook","oldHook","merged","extractPropsFromVNodeData","attrs","altKey","checkProp","hash","preserve","simpleNormalizeChildren","normalizeChildren","normalizeArrayChildren","isTextNode","node","nestedIndex","last","_isVList","ensureCtor","comp","base","createAsyncPlaceholder","factory","createEmptyVNode","asyncMeta","resolveAsyncComponent","baseCtor","errorComp","resolved","loading","loadingComp","contexts","sync","forceRender","$forceUpdate","resolve","reject","reason","then","component","delay","setTimeout","timeout","getFirstComponentChild","initEvents","_events","_hasHookEvent","listeners","_parentListeners","updateComponentListeners","once$$1","$once","$on","remove$1","$off","oldListeners","resolveSlots","slots","defaultSlot","functionalContext","slot","isWhitespace","resolveScopedSlots","initLifecycle","abstract","$parent","$children","$root","$refs","_watcher","_inactive","_directInactive","_isMounted","_isDestroyed","_isBeingDestroyed","mountComponent","el","hydrating","$el","render","callHook","updateComponent","_update","_render","Watcher","$vnode","updateChildComponent","parentVnode","renderChildren","hasChildren","_renderChildren","scopedSlots","$scopedSlots","emptyObject","_parentVnode","_vnode","$attrs","$listeners","propKeys","_propKeys","$slots","isInInactiveTree","activateChildComponent","direct","deactivateChildComponent","handlers","j","$emit","resetSchedulerState","queue","activatedChildren","has","waiting","flushing","flushSchedulerQueue","watcher","sort","run","activatedQueue","updatedQueue","callActivatedHooks","callUpdatedHooks","devtools","emit","queueActivatedComponent","queueWatcher","nextTick","traverse","seenObjects","clear","_traverse","seen","isA","depId","proxy","sourceKey","sharedPropertyDefinition","initState","_watchers","opts","initProps","methods","initMethods","initData","_data","computed","initComputed","watch","nativeWatch","initWatch","propsOptions","isRoot","getData","watchers","_computedWatchers","userDef","computedWatcherOptions","defineComputed","createComputedGetter","dirty","evaluate","handler","createWatcher","keyOrFn","$watch","initProvide","provide","_provided","initInjections","result","resolveInject","forEach","hasSymbol","Reflect","ownKeys","provideKey","source","createFunctionalComponent","mergeProps","_context","h","createElement","injections","functionalOptions","createComponent","_base","cid","resolveConstructorOptions","model","transformModel","functional","nativeOn","mergeHooks","createComponentInstanceForVnode","parentElm","refElm","vnodeComponentOptions","_isComponent","_componentTag","_parentElm","_refElm","inlineTemplate","staticRenderFns","hooksToMerge","fromParent","ours","componentVNodeHooks","mergeHook$1","one","two","callback","normalizationType","alwaysNormalize","ALWAYS_NORMALIZE","_createElement","is","SIMPLE_NORMALIZE","getTagNamespace","isReservedTag","parsePlatformTagName","applyNS","renderList","renderSlot","fallback","bindObject","scopedSlotFn","slotNodes","resolveFilter","identity","checkKeyCodes","eventKeyCode","builtInAlias","keyCodes","bindObjectProps","asProp","isSync","isReservedAttribute","mustUseProp","domProps","$event","renderStatic","isInFor","tree","_staticTrees","_renderProxy","markStatic","markOnce","isOnce","markStaticNode","bindObjectListeners","existing","initRender","renderContext","_c","$createElement","parentData","initInternalComponent","constructor","super","superOptions","modifiedOptions","resolveModifiedOptions","extendOptions","components","modified","latest","extended","sealed","sealedOptions","dedupe","Vue$3","_init","initUse","Vue","use","plugin","installedPlugins","_installedPlugins","args","unshift","install","initMixin$1","mixin","initExtend","Super","SuperId","cachedCtors","_Ctor","Sub","initProps$1","initComputed$1","ASSET_TYPES","Comp","initAssetRegisters","definition","getComponentName","matches","pattern","pruneCache","current","filter","cachedNode","pruneCacheEntry","componentInstance","$destroy","genClassForVnode","parentNode","childNode","mergeClassData","renderClass","staticClass","class","dynamicClass","stringifyClass","stringifyArray","stringifyObject","stringified","isSVG","isUnknownElement","unknownElementCache","document","window","HTMLUnknownElement","HTMLElement","query","selected","querySelector","createElement$1","tagName","multiple","setAttribute","createElementNS","namespace","namespaceMap","createTextNode","createComment","insertBefore","newNode","referenceNode","removeChild","appendChild","nextSibling","setTextContent","textContent","registerRef","isRemoval","ref","refs","refInFor","sameVnode","sameInputType","isAsyncPlaceholder","createKeyToOldIdx","beginIdx","endIdx","updateDirectives","oldVnode","oldDir","dir","isCreate","emptyNode","isDestroy","oldDirs","normalizeDirectives$1","newDirs","dirsWithInsert","dirsWithPostpatch","oldValue","callHook$1","componentUpdated","inserted","callInsert","modifiers","emptyModifiers","getRawDirName","rawName","join","updateAttrs","inheritAttrs","oldAttrs","setAttr","isIE9","isXlink","removeAttributeNS","xlinkNS","getXlinkProp","isEnumeratedAttr","removeAttribute","isBooleanAttr","isFalsyAttrValue","setAttributeNS","updateClass","oldData","cls","transitionClass","_transitionClasses","_prevClass","parseFilters","exp","pushFilter","filters","lastFilterIndex","trim","prev","expression","inSingle","inDouble","inTemplateString","inRegex","curly","square","paren","charAt","validDivisionCharRE","wrapFilter","baseWarn","msg","pluckModuleFunction","_","addProp","addAttr","addDirective","arg","addHandler","important","warn","events","native","nativeEvents","newHandler","getBindingAttr","getStatic","dynamicValue","getAndRemoveAttr","staticValue","attrsMap","attrsList","genComponentModel","number","valueExpression","assignment","genAssignmentCode","modelRs","parseModel","idx","index$1","expressionPos","expressionEndPos","lastIndexOf","eof","chr","next","isStringStart","parseString","parseBracket","substring","inBracket","stringQuote","_warn","warn$1","genSelect","genCheckboxModel","genRadioModel","genDefaultModel","valueBinding","trueValueBinding","falseValueBinding","CHECKBOX_RADIO_TOKEN","selectedVal","code","lazy","needCompositionGuard","RANGE_TOKEN","normalizeEvents","isIE","isChrome","add$1","oldHandler","target$1","ev","remove$2","addEventListener","supportsPassive","removeEventListener","updateDOMListeners","updateDOMProps","oldProps","_value","strCur","shouldUpdateValue","checkVal","composing","isDirty","isInputChanged","notInFocus","activeElement","_vModifiers","normalizeStyleData","style","normalizeStyleBinding","staticStyle","bindingStyle","parseStyleText","getStyle","checkChild","styleData","updateStyle","oldStaticStyle","oldStyleBinding","normalizedStyle","oldStyle","newStyle","setProp","addClass","classList","getAttribute","removeClass","tar","replace","resolveTransition","def$$1","css","autoCssTransition","nextFrame","raf","addTransitionClass","transitionClasses","removeTransitionClass","whenTransitionEnds","expectedType","cb","getTransitionInfo","propCount","TRANSITION","transitionEndEvent","animationEndEvent","ended","end","onEnd","styles","getComputedStyle","transitionDelays","transitionProp","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationProp","animationDurations","animationTimeout","ANIMATION","hasTransform","transformRE","delays","durations","toMs","Number","enter","toggleDisplay","_leaveCb","cancelled","transition","_enterCb","nodeType","enterClass","enterToClass","enterActiveClass","appearClass","appearToClass","appearActiveClass","beforeEnter","afterEnter","enterCancelled","beforeAppear","appear","afterAppear","appearCancelled","duration","activeInstance","transitionNode","isAppear","isRootInsert","startClass","activeClass","toClass","beforeEnterHook","enterHook","afterEnterHook","enterCancelledHook","explicitEnterDuration","expectsCSS","userWantsControl","getHookArgumentsLength","show","pendingNode","_pending","isValidDuration","leave","rm","performLeave","beforeLeave","leaveClass","leaveActiveClass","leaveToClass","explicitLeaveDuration","afterLeave","leaveCancelled","delayLeave","invokerFns","_enter","setSelected","binding","isMultiple","option","getValue","selectedIndex","onCompositionStart","onCompositionEnd","trigger","createEvent","initEvent","dispatchEvent","locateNode","getRealChild","compOptions","extractTransitionData","key$1","placeholder","rawChild","hasParentTransition","isSameChild","oldChild","callPendingCbs","_moveCb","recordPosition","newPos","getBoundingClientRect","applyTranslation","oldPos","pos","dx","left","dy","top","moved","transform","WebkitTransform","transitionDuration","parseText","delimiters","tagRE","buildRegex","defaultTagRE","tokens","lastIndex","exec","transformNode","classBinding","genData","transformNode$1","styleBinding","genData$1","html","decodeAttr","shouldDecodeNewlines","re","encodedAttrWithNewLines","encodedAttr","decodingMap","parseHTML","advance","parseEndTag","lowerCasedTagName","stack","lowerCasedTag","lastTag","expectHTML","isUnaryTag$$1","isUnaryTag","no","canBeLeftOpenTag$$1","canBeLeftOpenTag","isPlainTextElement","endTagLength","stackedTag","reStackedTag","reCache","RegExp","rest$1","all","endTag","shouldIgnoreFirstNewline","chars","textEnd","comment","commentEnd","shouldKeepComment","conditionalComment","conditionalEnd","doctypeMatch","doctype","endTagMatch","curIndex","startTagMatch","startTagOpen","attr","startTagClose","attribute","unarySlash","isNonPhrasingTag","unary","IS_REGEX_CAPTURING_BROKEN","rest","parse","template","endPre","element","pre","inVPre","platformIsPreTag","inPre","warn$2","isPreTag","platformMustUseProp","platformGetTagNamespace","transforms","preTransforms","postTransforms","root","currentParent","preserveWhitespace","comments","guardIESVGBug","makeAttrsMap","isForbiddenTag","forbidden","processPre","processRawAttrs","processFor","processIf","processOnce","processKey","plain","processRef","processSlot","processComponent","i$1","processAttrs","if","elseif","else","addIfCondition","block","processIfConditions","slotScope","slotTarget","i$2","lastNode","isTextTag","decodeHTMLCached","checkInFor","inMatch","forAliasRE","for","alias","iteratorMatch","forIteratorRE","iterator1","iterator2","findPrevElement","condition","ifConditions","slotName","isProp","dirRE","hasBindings","parseModifiers","modifierRE","bindRE","camel","onRE","argMatch","argRE","ieNSBug","ieNSPrefix","optimize","isStaticKey","genStaticKeysCached","staticKeys","isPlatformReservedTag","markStatic$1","markStaticRoots","genStaticKeys$1","static","l$1","staticInFor","staticRoot","isBuiltInTag","isDirectChildOfTemplateFor","genHandlers","genHandler","isMethodPath","simplePathRE","isFunctionExpression","fnExpRE","genModifierCode","modifierCode","genKeyFilter","genFilterCode","keyVal","parseInt","wrapListeners","bind$1","wrapData","generate","ast","state","CodegenState","genElement","staticProcessed","genStatic","onceProcessed","genOnce","forProcessed","genFor","ifProcessed","genIf","genSlot","genComponent","genData$2","genChildren","onceId","altGen","altEmpty","genIfConditions","conditions","genTernaryExp","shift","altHelper","genDirectives","dataGenFns","genProps","genScopedSlots","genInlineTemplate","needRuntime","hasRuntime","gen","inlineRenderFns","genScopedSlot","genForScopedSlot","scope","checkSkip","altGenElement","altGenNode","el$1","getNormalizationType","maybeComponent","genNode","needsNormalization","some","genComment","genText","transformSpecialNewlines","bind$$1","componentName","createFunction","errors","Function","createCompileToFunctionFn","compile","compiled","fnGenErrors","getOuterHTML","outerHTML","container","cloneNode","innerHTML","Symbol","iterator","camelizeRE","toUpperCase","hyphenateRE","SSR_ATTR","LIFECYCLE_HOOKS","optionMergeStrategies","silent","productionTip","performance","warnHandler","ignoredElements","isReservedAttr","_lifecycleHooks","freeze","hasProto","UA","navigator","userAgent","isEdge","isAndroid","isIOS","_isServer","_Set","env","VUE_ENV","__VUE_DEVTOOLS_GLOBAL_HOOK__","nextTickHandler","pending","copies","callbacks","timerFunc","Promise","logError","catch","MutationObserver","counter","observer","textNode","characterData","_resolve","Set","uid","subs","addSub","sub","removeSub","addDep","arrayProto","arrayMethods","method","original","observeArray","arrayKeys","getOwnPropertyNames","walk","items","raw","prototypeAccessors","defineProperties","uid$2","expOrFn","deep","user","active","deps","newDeps","depIds","newDepIds","cleanupDeps","this$1","tmp","teardown","init","$mount","keepAlive","mountedNode","prepatch","insert","destroy","uid$1","_uid","_self","dataDef","propsDef","$set","$delete","immediate","hookRE","cbs","prevEl","prevVnode","prevActiveInstance","__patch__","__vue__","$nextTick","_o","_n","_s","_l","_t","_q","_i","_m","_f","_k","_b","_v","_e","_u","_g","patternTypes","KeepAlive","include","exclude","created","destroyed","builtInComponents","configDef","util","defineReactive","delete","ssrContext","version","emptyStyle","acceptValue","svg","math","isHTMLTag","nodeOps","hooks","baseModules","klass","cssText","listDelimiter","propertyDelimiter","cssVarRE","importantRE","setProperty","normalizedName","normalize","vendorNames","capName","hasTransition","ontransitionend","onwebkittransitionend","onanimationend","onwebkitanimationend","requestAnimationFrame","activate","platformModules","patch","backend","emptyNodeAt","createRmCb","childElm","removeNode","createElm","insertedVnodeQueue","nested","setScope","createChildren","invokeCreateHooks","isReactivated","initComponent","reactivateComponent","pendingInsert","isPatchable","innerNode","ref$$1","ancestor","_scopeId","addVnodes","startIdx","invokeDestroyHook","removeVnodes","ch","removeAndInvokeRemoveHook","updateChildren","oldCh","newCh","removeOnly","oldKeyToIdx","idxInOld","elmToMove","oldStartIdx","newStartIdx","oldEndIdx","oldStartVnode","oldEndVnode","newEndIdx","newStartVnode","newEndVnode","canMove","patchVnode","hydrate","postpatch","invokeInsertHook","initial","hasChildNodes","childrenMatch","firstChild","isRenderedModule","isInitialPatch","isRealElement","hasAttribute","oldElm","parentElm$1","isTextInputType","vmodel","model$1","_vOptions","prevOptions","transition$$1","originalDisplay","__vOriginalDisplay","display","unbind","platformDirectives","transitionProps","mode","Transition","_leaving","oldRawChild","delayedLeave","moveClass","TransitionGroup","prevChildren","rawChildren","transitionData","kept","removed","c$1","beforeUpdate","updated","hasMove","body","offsetHeight","propertyName","_hasMove","clone","platformComponents","decoder","content","encoded","div","regexEscapeRE","open","close","klass$1","style$1","modules$1","directives$1","baseOptions","reduce","he","decode","singleAttrIdentifier","singleAttrAssign","singleAttrValues","ncname","qnameCapture","g","&lt;","&gt;","&quot;","&amp;","&#10;","isIgnoreNewlineTag","esc","tab","space","up","right","down","genGuard","stop","prevent","self","ctrl","alt","meta","middle","baseDirectives","cloak","createCompiler","baseCompile","finalOptions","tips","tip","compileToFunctions","ref$1","idToTemplate","mount","documentElement","eval","MoveTo","easeOutQuart","t","getOffsetSum","elem","offsetTop","offsetLeft","offsetParent","mergeObject","obj1","obj2","obj3","kebabCase","$1","easeFunctions","defaults","_getOptionsFromTriggerDom","dom","domOptions","tolerance","easing","registerTrigger","_this","href","getElementById","preventDefault","move","_this2","pageYOffset","change","startTime","lastPageYOffset","loop","currentTime","currentPageYOffset","timeElapsed","scroll","addEaseFunction","injectStyle","__WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_videobg_vue__","__WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_65807d96_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_videobg_vue__","normalizeComponent","__vue_styles__","Component","rawScriptExports","compiledTemplate","injectStyles","scopeId","moduleIdentifier","esModule","scriptExports","__VUE_SSR_CONTEXT__","_registeredComponents","_ssrRegister","beforeCreate","sources","required","img","videoRatio","mounted","setImageUrl","setContainerHeight","videoCanPlay","video","oncanplay","videoWidth","videoHeight","setVideoSize","visibility","resize","beforeDestroy","canPlayType","backgroundImage","height","innerHeight","width","offsetWidth","getMediaType","_vm","_h","autoplay","muted","playsinline","esExports","__WEBPACK_IMPORTED_MODULE_0_vue_dist_vue_esm__","__WEBPACK_IMPORTED_MODULE_1_moveto__","__WEBPACK_IMPORTED_MODULE_1_moveto___default","moveTo","clicked","finished","getMousePos","posx","posy","pageX","pageY","clientX","clientY","scrollLeft","scrollTop","x","y","TiltFx","DOM","movement","imgWrapper","translation","z","rotation","reverseAnimation","elasticity","lines","caption","shine","animatable","overlay","_initEvents","mouseenterFn","anime","mousemoveFn","_layout","mouseleaveFn","targets","scaleX","scaleY","scaleZ","translateX","translateY","translateZ","rotateX","rotateY","rotateZ","mousepos","docScrolls","bounds","relmousepos","r","setRange","k","updateBodyClass","scrollY","initEffects","triggers","getElementsByClassName","onMouseMove","onMouseLeave","doms","transitions","evt","readyState","__webpack_amd_options__","findAncestor","contains","parentElement","hasClass","ele","className","getDescendantWithClass","clName","childNodes","__WEBPACK_IMPORTED_MODULE_1_vue_parallaxy__","__WEBPACK_IMPORTED_MODULE_1_vue_parallaxy___default","__WEBPACK_IMPORTED_MODULE_2__videobg_vue__","__WEBPACK_IMPORTED_MODULE_3_moveto__","__WEBPACK_IMPORTED_MODULE_3_moveto___default","__WEBPACK_IMPORTED_MODULE_4_animejs__","__WEBPACK_IMPORTED_MODULE_5_scrollreveal__","__WEBPACK_IMPORTED_MODULE_5_scrollreveal___default","sr","reveal","reset","Parallax","VideoBg","select","title","toggle","innerWidth","blocks","modal","setBlock","innerText","previous","stopPropagation","easeInQuad","easeOutQuad","ease","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","loaded","parallax","speedFactor","fixed","breakpoint","sectionHeight","sectionClass","containerClass","parallaxClass","fixedClass","mediaQuery","mozRequestAnimationFrame","webkitRequestAnimationFrame","msRequestAnimationFrame","animateElement","scrollHandler","isInView","bottom","clientHeight","setupListener","matchMedia","addListener","Error","u","f","byteLength","toByteArray","fromByteArray","Uint8Array","TYPED_ARRAY_SUPPORT","RangeError","TypeError","ArrayBuffer","fill","isEncoding","A","write","isBuffer","copy","buffer","K","Z","alloc","isView","W","$","Y","T","S","M","P","w","readUInt16BE","substr","B","J","E","Q","R","C","V","X","min","U","tt","fromCharCode","H","I","L","D","O","N","G","F","q","et","Buffer","SlowBuffer","INSPECT_MAX_BYTES","foo","subarray","kMaxLength","poolSize","_augment","species","allocUnsafe","allocUnsafeSlow","_isBuffer","compare","swap16","swap32","swap64","equals","inspect","includes","toJSON","_arr","readUIntLE","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","read","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","names","mappings","file","sourcesContent","sourceRoot","NaN","abs","log","LN2","locals","parts","media","sourceMap","styleSheet","btoa","unescape","encodeURIComponent","head","getElementsByTagName","webpackPolyfill","deprecate","paths","$jscomp$this","col","querySelectorAll","NodeList","HTMLCollection","und","fnc","total","getPropertyValue","getPointAtLength","atan2","PI","totalLength","rgb","hex","hsl","numbers","strings","aa","ba","ca","tweens","isPath","offset","round","da","ea","fa","ga","animatables","animations","reversed","tween","isPath$0","eased","ha","currentValue","progress","remaining","began","direction","pause","completed","seek","paused","tick","speed","play","ia","reverse","restart","begin","complete","SVGElement","Float32Array","sin","asin","In","Out","InOut","linear","cancelAnimationFrame","running","getTotalLength","setDashoffset","bezier","easings","timeline","random","ScrollReveal","getPrototypeOf","tools","Tools","isSupported","_resolveContainer","store","elements","containers","sequences","history","initialized","isNode","_getRevealElements","isNodeList","_nextUid","_configure","extendClone","origin","axis","_style","domEl","inline","opacity","instant","_generateTransition","delayed","_generateTransform","cssDistance","distance","scale","rotate","_updateStore","_record","interval","record","_animate","_handler","_requestAnimationFrame","_setActiveSequences","elemId","sequence","forOwn","sequenceId","elemIds","_isElemVisible","_shouldUseDelay","_shouldReveal","beforeReveal","_queueCallback","revealing","_queueNextInSequence","_shouldReset","beforeReset","elapsed","blocked","useDelay","timer","started","Date","clearTimeout","clock","disabled","_getContainer","clientWidth","_getScrolled","_getOffset","pageXOffset","scrolled","vF","viewFactor","elemHeight","elemWidth","elemTop","elemLeft","elemBottom","elemRight","viewTop","viewOffset","viewLeft","viewBottom","viewRight","position","mobile","afterReveal","afterReset","isMobile","initTimeout","Node","nodeName","prototypeToString","regex"],"mappings":"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","file":"application-96393767cb8330bacf8a.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"/packs/\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 12);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/*!\n * Vue.js v2.4.2\n * (c) 2014-2017 Evan You\n * Released under the MIT License.\n */\n/*  */\n\n// these helpers produces 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 typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';\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 === 'undefined' ? 'undefined' : _typeof(obj)) === 'object';\n}\n\nvar _toString = Object.prototype.toString;\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(val);\n  return n >= 0 && Math.floor(n) === n && isFinite(val);\n}\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction toString(val) {\n  return val == null ? '' : (typeof val === 'undefined' ? 'undefined' : _typeof(val)) === 'object' ? JSON.stringify(val, null, 2) : String(val);\n}\n\n/**\n * Convert a 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(str, expectsLowerCase) {\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 ? function (val) {\n    return map[val.toLowerCase()];\n  } : function (val) {\n    return map[val];\n  };\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 a attribute is a reserved attribute.\n */\nvar isReservedAttribute = makeMap('key,ref,slot,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 the 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) {\n    return c ? c.toUpperCase() : '';\n  });\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 = /([^-])([A-Z])/g;\nvar hyphenate = cached(function (str) {\n  return str.replace(hyphenateRE, '$1-$2').replace(hyphenateRE, '$1-$2').toLowerCase();\n});\n\n/**\n * Simple bind, faster than native\n */\nfunction bind(fn, ctx) {\n  function boundFn(a) {\n    var l = arguments.length;\n    return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx);\n  }\n  // record original fn length\n  boundFn._length = fn.length;\n  return boundFn;\n}\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/**\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 no(a, b, c) {\n  return false;\n};\n\n/**\n * Return same value\n */\nvar identity = function identity(_) {\n  return _;\n};\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys(modules) {\n  return modules.reduce(function (keys, m) {\n    return keys.concat(m.staticKeys || []);\n  }, []).join(',');\n}\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) {\n    return true;\n  }\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 (!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\nfunction looseIndexOf(arr, val) {\n  for (var i = 0; i < arr.length; i++) {\n    if (looseEqual(arr[i], val)) {\n      return i;\n    }\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 = ['component', 'directive', 'filter'];\n\nvar LIFECYCLE_HOOKS = ['beforeCreate', 'created', 'beforeMount', 'mounted', 'beforeUpdate', 'updated', 'beforeDestroy', 'destroyed', 'activated', 'deactivated'];\n\n/*  */\n\nvar config = {\n  /**\n   * Option merge strategies (used in core/util/options)\n   */\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: \"production\" !== 'production',\n\n  /**\n   * Whether to enable devtools\n   */\n  devtools: \"production\" !== '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  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   * Exposed for legacy reasons\n   */\n  _lifecycleHooks: LIFECYCLE_HOOKS\n};\n\n/*  */\n\nvar emptyObject = Object.freeze({});\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 = /[^\\w.$]/;\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) {\n        return;\n      }\n      obj = obj[segments[i]];\n    }\n    return obj;\n  };\n}\n\n/*  */\n\nvar warn = noop;\nvar tip = noop;\nvar formatComponentName = null; // work around flow check\n\nif (false) {\n  var hasConsole = typeof console !== 'undefined';\n  var classifyRE = /(?:^|[-_])(\\w)/g;\n  var classify = function classify(str) {\n    return str.replace(classifyRE, function (c) {\n      return c.toUpperCase();\n    }).replace(/[-_]/g, '');\n  };\n\n  warn = function warn(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 tip(msg, vm) {\n    if (hasConsole && !config.silent) {\n      console.warn(\"[Vue tip]: \" + msg + (vm ? generateComponentTrace(vm) : ''));\n    }\n  };\n\n  formatComponentName = function formatComponentName(vm, includeFile) {\n    if (vm.$root === vm) {\n      return '<Root>';\n    }\n    var name = typeof vm === 'string' ? vm : typeof vm === 'function' && vm.options ? vm.options.name : vm._isVue ? vm.$options.name || vm.$options._componentTag : vm.name;\n\n    var file = vm._isVue && vm.$options.__file;\n    if (!name && file) {\n      var match = file.match(/([^/\\\\]+)\\.vue$/);\n      name = match && match[1];\n    }\n\n    return (name ? \"<\" + classify(name) + \">\" : \"<Anonymous>\") + (file && includeFile !== false ? \" at \" + file : '');\n  };\n\n  var repeat = function repeat(str, n) {\n    var res = '';\n    while (n) {\n      if (n % 2 === 1) {\n        res += str;\n      }\n      if (n > 1) {\n        str += str;\n      }\n      n >>= 1;\n    }\n    return res;\n  };\n\n  var generateComponentTrace = function generateComponentTrace(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.map(function (vm, i) {\n        return \"\" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm) ? formatComponentName(vm[0]) + \"... (\" + vm[1] + \" recursive calls)\" : formatComponentName(vm));\n      }).join('\\n');\n    } else {\n      return \"\\n\\n(found in \" + formatComponentName(vm) + \")\";\n    }\n  };\n}\n\n/*  */\n\nfunction handleError(err, vm, info) {\n  if (config.errorHandler) {\n    config.errorHandler.call(null, err, vm, info);\n  } else {\n    if (false) {\n      warn(\"Error in \" + info + \": \\\"\" + err.toString() + \"\\\"\", vm);\n    }\n    /* istanbul ignore else */\n    if (inBrowser && typeof console !== 'undefined') {\n      console.error(err);\n    } else {\n      throw err;\n    }\n  }\n}\n\n/*  */\n/* globals MutationObserver */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\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;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\nvar isChrome = UA && /chrome\\/\\d+/.test(UA) && !isEdge;\n\n// Firefix 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 isServerRendering() {\n  if (_isServer === undefined) {\n    /* istanbul ignore if */\n    if (!inBrowser && typeof global !== 'undefined') {\n      // detect presence of vue-server-renderer and avoid\n      // Webpack shimming the process\n      _isServer = 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 = typeof Symbol !== 'undefined' && isNative(Symbol) && typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);\n\n/**\n * Defer a task to execute it asynchronously.\n */\nvar nextTick = function () {\n  var callbacks = [];\n  var pending = false;\n  var timerFunc;\n\n  function nextTickHandler() {\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  // 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 if */\n  if (typeof Promise !== 'undefined' && isNative(Promise)) {\n    var p = Promise.resolve();\n    var logError = function logError(err) {\n      console.error(err);\n    };\n    timerFunc = function timerFunc() {\n      p.then(nextTickHandler).catch(logError);\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) {\n        setTimeout(noop);\n      }\n    };\n  } else if (typeof MutationObserver !== 'undefined' && (isNative(MutationObserver) ||\n  // PhantomJS and iOS 7.x\n  MutationObserver.toString() === '[object MutationObserverConstructor]')) {\n    // use MutationObserver where native Promise is not available,\n    // e.g. PhantomJS IE11, iOS7, Android 4.4\n    var counter = 1;\n    var observer = new MutationObserver(nextTickHandler);\n    var textNode = document.createTextNode(String(counter));\n    observer.observe(textNode, {\n      characterData: true\n    });\n    timerFunc = function timerFunc() {\n      counter = (counter + 1) % 2;\n      textNode.data = String(counter);\n    };\n  } else {\n    // fallback to setTimeout\n    /* istanbul ignore next */\n    timerFunc = function timerFunc() {\n      setTimeout(nextTickHandler, 0);\n    };\n  }\n\n  return function queueNextTick(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    if (!cb && typeof Promise !== 'undefined') {\n      return new Promise(function (resolve, reject) {\n        _resolve = resolve;\n      });\n    }\n  };\n}();\n\nvar _Set;\n/* istanbul ignore if */\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 = 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 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  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 there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget(_target) {\n  if (Dep.target) {\n    targetStack.push(Dep.target);\n  }\n  Dep.target = _target;\n}\n\nfunction popTarget() {\n  Dep.target = targetStack.pop();\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);['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'].forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  def(arrayMethods, method, function mutator() {\n    var args = [],\n        len = arguments.length;\n    while (len--) {\n      args[len] = arguments[len];\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) {\n      ob.observeArray(inserted);\n    }\n    // notify change\n    ob.dep.notify();\n    return result;\n  });\n});\n\n/*  */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * By default, when a reactive property is set, the new value is\n * also converted to become reactive. However when passing down props,\n * we don't want to force conversion because the value may be a nested value\n * under a frozen data structure. Converting it would defeat the optimization.\n */\nvar observerState = {\n  shouldConvert: true\n};\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches 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    var augment = hasProto ? protoAugment : copyAugment;\n    augment(value, arrayMethods, arrayKeys);\n    this.observeArray(value);\n  } else {\n    this.walk(value);\n  }\n};\n\n/**\n * Walk through each property 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], 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 an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment(target, src, keys) {\n  /* eslint-disable no-proto */\n  target.__proto__ = src;\n  /* eslint-enable no-proto */\n}\n\n/**\n * Augment an 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)) {\n    return;\n  }\n  var ob;\n  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if (observerState.shouldConvert && !isServerRendering() && (Array.isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value._isVue) {\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(obj, key, val, customSetter, shallow) {\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\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        }\n        if (Array.isArray(value)) {\n          dependArray(value);\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 (false) {\n        customSetter();\n      }\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 (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 (hasOwn(target, key)) {\n    target[key] = val;\n    return val;\n  }\n  var ob = target.__ob__;\n  if (target._isVue || ob && ob.vmCount) {\n    \"production\" !== 'production' && warn('Avoid adding reactive properties to a Vue instance or its root $data ' + 'at runtime - declare it upfront in the data option.');\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 (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    \"production\" !== 'production' && warn('Avoid deleting properties on a Vue instance or its root $data ' + '- just set it to null.');\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 (false) {\n  strats.el = strats.propsData = function (parent, child, vm, key) {\n    if (!vm) {\n      warn(\"option \\\"\" + key + \"\\\" can only be used during instance \" + 'creation with the `new` keyword.');\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) {\n    return to;\n  }\n  var key, toVal, fromVal;\n  var keys = Object.keys(from);\n  for (var i = 0; i < keys.length; i++) {\n    key = keys[i];\n    toVal = to[key];\n    fromVal = from[key];\n    if (!hasOwn(to, key)) {\n      set(to, key, fromVal);\n    } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\n      mergeData(toVal, fromVal);\n    }\n  }\n  return to;\n}\n\n/**\n * Data\n */\nfunction mergeDataOrFn(parentVal, childVal, vm) {\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(typeof childVal === 'function' ? childVal.call(this) : childVal, typeof parentVal === 'function' ? parentVal.call(this) : parentVal);\n    };\n  } else if (parentVal || childVal) {\n    return function mergedInstanceDataFn() {\n      // instance merge\n      var instanceData = typeof childVal === 'function' ? childVal.call(vm) : childVal;\n      var defaultData = typeof parentVal === 'function' ? parentVal.call(vm) : undefined;\n      if (instanceData) {\n        return mergeData(instanceData, defaultData);\n      } else {\n        return defaultData;\n      }\n    };\n  }\n}\n\nstrats.data = function (parentVal, childVal, vm) {\n  if (!vm) {\n    if (childVal && typeof childVal !== 'function') {\n      \"production\" !== 'production' && warn('The \"data\" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm);\n\n      return parentVal;\n    }\n    return mergeDataOrFn.call(this, parentVal, childVal);\n  }\n\n  return mergeDataOrFn(parentVal, childVal, vm);\n};\n\n/**\n * Hooks and props are merged as arrays.\n */\nfunction mergeHook(parentVal, childVal) {\n  return childVal ? parentVal ? parentVal.concat(childVal) : Array.isArray(childVal) ? childVal : [childVal] : parentVal;\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(parentVal, childVal) {\n  var res = Object.create(parentVal || null);\n  return childVal ? extend(res, childVal) : res;\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 (parentVal, childVal) {\n  // work around Firefox's Object.prototype.watch...\n  if (parentVal === nativeWatch) {\n    parentVal = undefined;\n  }\n  if (childVal === nativeWatch) {\n    childVal = undefined;\n  }\n  /* istanbul ignore if */\n  if (!childVal) {\n    return Object.create(parentVal || null);\n  }\n  if (!parentVal) {\n    return childVal;\n  }\n  var ret = {};\n  extend(ret, parentVal);\n  for (var key in childVal) {\n    var parent = ret[key];\n    var child = childVal[key];\n    if (parent && !Array.isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key] = parent ? parent.concat(child) : Array.isArray(child) ? child : [child];\n  }\n  return ret;\n};\n\n/**\n * Other object hashes.\n */\nstrats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal) {\n  if (!parentVal) {\n    return childVal;\n  }\n  var ret = Object.create(null);\n  extend(ret, parentVal);\n  if (childVal) {\n    extend(ret, childVal);\n  }\n  return ret;\n};\nstrats.provide = mergeDataOrFn;\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function defaultStrat(parentVal, childVal) {\n  return childVal === undefined ? parentVal : childVal;\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents(options) {\n  for (var key in options.components) {\n    var lower = key.toLowerCase();\n    if (isBuiltInTag(lower) || config.isReservedTag(lower)) {\n      warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + key);\n    }\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps(options) {\n  var props = options.props;\n  if (!props) {\n    return;\n  }\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 (false) {\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) ? val : { type: val };\n    }\n  }\n  options.props = res;\n}\n\n/**\n * Normalize all injections into Object-based format\n */\nfunction normalizeInject(options) {\n  var inject = options.inject;\n  if (Array.isArray(inject)) {\n    var normalized = options.inject = {};\n    for (var i = 0; i < inject.length; i++) {\n      normalized[inject[i]] = inject[i];\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 = dirs[key];\n      if (typeof def === 'function') {\n        dirs[key] = { bind: def, update: def };\n      }\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(parent, child, vm) {\n  if (false) {\n    checkComponents(child);\n  }\n\n  if (typeof child === 'function') {\n    child = child.options;\n  }\n\n  normalizeProps(child);\n  normalizeInject(child);\n  normalizeDirectives(child);\n  var extendsFrom = child.extends;\n  if (extendsFrom) {\n    parent = mergeOptions(parent, extendsFrom, 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  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(options, type, id, warnMissing) {\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)) {\n    return assets[id];\n  }\n  var camelizedId = camelize(id);\n  if (hasOwn(assets, camelizedId)) {\n    return assets[camelizedId];\n  }\n  var PascalCaseId = capitalize(camelizedId);\n  if (hasOwn(assets, PascalCaseId)) {\n    return assets[PascalCaseId];\n  }\n  // fallback to prototype chain\n  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n  if (false) {\n    warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);\n  }\n  return res;\n}\n\n/*  */\n\nfunction validateProp(key, propOptions, propsData, vm) {\n  var prop = propOptions[key];\n  var absent = !hasOwn(propsData, key);\n  var value = propsData[key];\n  // handle boolean props\n  if (isType(Boolean, prop.type)) {\n    if (absent && !hasOwn(prop, 'default')) {\n      value = false;\n    } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {\n      value = true;\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 prevShouldConvert = observerState.shouldConvert;\n    observerState.shouldConvert = true;\n    observe(value);\n    observerState.shouldConvert = prevShouldConvert;\n  }\n  if (false) {\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 (false) {\n    warn('Invalid default value for prop \"' + key + '\": ' + 'Props with type Object/Array must use a factory function ' + 'to return the default value.', vm);\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 && vm.$options.propsData[key] === undefined && vm._props[key] !== undefined) {\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' ? def.call(vm) : def;\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp(prop, name, value, vm, absent) {\n  if (prop.required && absent) {\n    warn('Missing required prop: \"' + name + '\"', vm);\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  if (!valid) {\n    warn('Invalid prop: type check failed for prop \"' + name + '\".' + ' Expected ' + expectedTypes.map(capitalize).join(', ') + ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.', vm);\n    return;\n  }\n  var validator = prop.validator;\n  if (validator) {\n    if (!validator(value)) {\n      warn('Invalid prop: custom validator check failed for prop \"' + name + '\".', vm);\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    valid = (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === expectedType.toLowerCase();\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 isType(type, fn) {\n  if (!Array.isArray(fn)) {\n    return getType(fn) === getType(type);\n  }\n  for (var i = 0, len = fn.length; i < len; i++) {\n    if (getType(fn[i]) === getType(type)) {\n      return true;\n    }\n  }\n  /* istanbul ignore next */\n  return false;\n}\n\n/*  */\n\nvar mark;\nvar measure;\n\nif (false) {\n  var perf = inBrowser && window.performance;\n  /* istanbul ignore if */\n  if (perf && perf.mark && perf.measure && perf.clearMarks && perf.clearMeasures) {\n    mark = function mark(tag) {\n      return perf.mark(tag);\n    };\n    measure = function measure(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/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (false) {\n  var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' + 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' + 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' + 'require' // for Webpack/Browserify\n  );\n\n  var warnNonPresent = function warnNonPresent(target, key) {\n    warn(\"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" + \"referenced during render. Make sure to declare reactive data \" + \"properties in the data option.\", target);\n  };\n\n  var hasProxy = typeof Proxy !== 'undefined' && Proxy.toString().match(/native code/);\n\n  if (hasProxy) {\n    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');\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) || key.charAt(0) === '_';\n      if (!has && !isAllowed) {\n        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        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 ? getHandler : hasHandler;\n      vm._renderProxy = new Proxy(vm, handlers);\n    } else {\n      vm._renderProxy = vm;\n    }\n  };\n}\n\n/*  */\n\nvar VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {\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.functionalContext = 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: {} };\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 createEmptyVNode(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(vnode.tag, vnode.data, vnode.children, vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);\n  cloned.ns = vnode.ns;\n  cloned.isStatic = vnode.isStatic;\n  cloned.key = vnode.key;\n  cloned.isComment = vnode.isComment;\n  cloned.isCloned = true;\n  return cloned;\n}\n\nfunction cloneVNodes(vnodes) {\n  var len = vnodes.length;\n  var res = new Array(len);\n  for (var i = 0; i < len; i++) {\n    res[i] = cloneVNode(vnodes[i]);\n  }\n  return res;\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) {\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        cloned[i].apply(null, arguments$1);\n      }\n    } else {\n      // return handler return value for single handlers\n      return fns.apply(null, arguments);\n    }\n  }\n  invoker.fns = fns;\n  return invoker;\n}\n\nfunction updateListeners(on, oldOn, add, remove$$1, vm) {\n  var name, cur, old, event;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    event = normalizeEvent(name);\n    if (isUndef(cur)) {\n      \"production\" !== 'production' && warn(\"Invalid handler for event \\\"\" + event.name + \"\\\": got \" + String(cur), vm);\n    } else if (isUndef(old)) {\n      if (isUndef(cur.fns)) {\n        cur = on[name] = createFnInvoker(cur);\n      }\n      add(event.name, cur, event.once, event.capture, event.passive);\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  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(data, Ctor, tag) {\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 (false) {\n        var keyInLowerCase = key.toLowerCase();\n        if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {\n          tip(\"Prop \\\"\" + keyInLowerCase + \"\\\" is passed to component \" + formatComponentName(tag || Ctor) + \", but the declared prop name is\" + \" \\\"\" + key + \"\\\". \" + \"Note that HTML attributes are case-insensitive and camelCased \" + \"props need to use their kebab-case equivalents when using in-DOM \" + \"templates. You should probably use \\\"\" + altKey + \"\\\" instead of \\\"\" + key + \"\\\".\");\n        }\n      }\n      checkProp(res, props, key, altKey, true) || checkProp(res, attrs, key, altKey, false);\n    }\n  }\n  return res;\n}\n\nfunction checkProp(res, hash, key, altKey, preserve) {\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) ? [createTextVNode(children)] : Array.isArray(children) ? normalizeArrayChildren(children) : 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, last;\n  for (i = 0; i < children.length; i++) {\n    c = children[i];\n    if (isUndef(c) || typeof c === 'boolean') {\n      continue;\n    }\n    last = res[res.length - 1];\n    //  nested\n    if (Array.isArray(c)) {\n      res.push.apply(res, normalizeArrayChildren(c, (nestedIndex || '') + \"_\" + i));\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        last.text += String(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[res.length - 1] = createTextVNode(last.text + c.text);\n      } else {\n        // default key for nested array children (likely generated by v-for)\n        if (isTrue(children._isVList) && isDef(c.tag) && isUndef(c.key) && isDef(nestedIndex)) {\n          c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n        }\n        res.push(c);\n      }\n    }\n  }\n  return res;\n}\n\n/*  */\n\nfunction ensureCtor(comp, base) {\n  if (comp.__esModule && comp.default) {\n    comp = comp.default;\n  }\n  return isObject(comp) ? base.extend(comp) : comp;\n}\n\nfunction createAsyncPlaceholder(factory, data, context, children, tag) {\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(factory, baseCtor, context) {\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  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {\n    return factory.loadingComp;\n  }\n\n  if (isDef(factory.contexts)) {\n    // already pending\n    factory.contexts.push(context);\n  } else {\n    var contexts = factory.contexts = [context];\n    var sync = true;\n\n    var forceRender = function forceRender() {\n      for (var i = 0, l = contexts.length; i < l; i++) {\n        contexts[i].$forceUpdate();\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();\n      }\n    });\n\n    var reject = once(function (reason) {\n      \"production\" !== 'production' && warn(\"Failed to resolve async component: \" + String(factory) + (reason ? \"\\nReason: \" + reason : ''));\n      if (isDef(factory.errorComp)) {\n        factory.error = true;\n        forceRender();\n      }\n    });\n\n    var res = factory(resolve, reject);\n\n    if (isObject(res)) {\n      if (typeof res.then === 'function') {\n        // () => Promise\n        if (isUndef(factory.resolved)) {\n          res.then(resolve, reject);\n        }\n      } else if (isDef(res.component) && typeof res.component.then === 'function') {\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();\n              }\n            }, res.delay || 200);\n          }\n        }\n\n        if (isDef(res.timeout)) {\n          setTimeout(function () {\n            if (isUndef(factory.resolved)) {\n              reject( false ? \"timeout (\" + res.timeout + \"ms)\" : null);\n            }\n          }, res.timeout);\n        }\n      }\n    }\n\n    sync = false;\n    // return in case resolved synchronously\n    return factory.loading ? factory.loadingComp : factory.resolved;\n  }\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)) {\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, once$$1) {\n  if (once$$1) {\n    target.$once(event, fn);\n  } else {\n    target.$on(event, fn);\n  }\n}\n\nfunction remove$1(event, fn) {\n  target.$off(event, fn);\n}\n\nfunction updateComponentListeners(vm, listeners, oldListeners) {\n  target = vm;\n  updateListeners(listeners, oldListeners || {}, add, remove$1, vm);\n}\n\nfunction eventsMixin(Vue) {\n  var hookRE = /^hook:/;\n  Vue.prototype.$on = function (event, fn) {\n    var this$1 = this;\n\n    var vm = this;\n    if (Array.isArray(event)) {\n      for (var i = 0, l = event.length; i < l; i++) {\n        this$1.$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 this$1 = this;\n\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        this$1.$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 (arguments.length === 1) {\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 (false) {\n      var lowerCaseEvent = event.toLowerCase();\n      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {\n        tip(\"Event \\\"\" + lowerCaseEvent + \"\\\" is emitted in component \" + formatComponentName(vm) + \" but the handler is registered for \\\"\" + event + \"\\\". \" + \"Note that HTML attributes are case-insensitive and you cannot use \" + \"v-on to listen to camelCase events when using in-DOM templates. \" + \"You should probably use \\\"\" + hyphenate(event) + \"\\\" instead of \\\"\" + event + \"\\\".\");\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      for (var i = 0, l = cbs.length; i < l; i++) {\n        try {\n          cbs[i].apply(vm, args);\n        } catch (e) {\n          handleError(e, vm, \"event handler for \\\"\" + event + \"\\\"\");\n        }\n      }\n    }\n    return vm;\n  };\n}\n\n/*  */\n\n/**\n * Runtime helper for resolving raw children VNodes into a slot object.\n */\nfunction resolveSlots(children, context) {\n  var slots = {};\n  if (!children) {\n    return slots;\n  }\n  var defaultSlot = [];\n  for (var i = 0, l = children.length; i < l; i++) {\n    var child = children[i];\n    // named slots should only be respected if the vnode was rendered in the\n    // same context.\n    if ((child.context === context || child.functionalContext === context) && child.data && child.data.slot != null) {\n      var name = child.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      defaultSlot.push(child);\n    }\n  }\n  // ignore whitespace\n  if (!defaultSlot.every(isWhitespace)) {\n    slots.default = defaultSlot;\n  }\n  return slots;\n}\n\nfunction isWhitespace(node) {\n  return node.isComment || node.text === ' ';\n}\n\nfunction resolveScopedSlots(fns, // see flow/vnode\nres) {\n  res = res || {};\n  for (var i = 0; i < fns.length; i++) {\n    if (Array.isArray(fns[i])) {\n      resolveScopedSlots(fns[i], res);\n    } else {\n      res[fns[i].key] = fns[i].fn;\n    }\n  }\n  return res;\n}\n\n/*  */\n\nvar activeInstance = null;\nvar isUpdatingChildComponent = false;\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    if (vm._isMounted) {\n      callHook(vm, 'beforeUpdate');\n    }\n    var prevEl = vm.$el;\n    var prevVnode = vm._vnode;\n    var prevActiveInstance = activeInstance;\n    activeInstance = 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      , vm.$options._parentElm, vm.$options._refElm);\n      // no need for the ref nodes after initial patch\n      // this prevents keeping a detached DOM tree in memory (#5851)\n      vm.$options._parentElm = vm.$options._refElm = null;\n    } else {\n      // updates\n      vm.$el = vm.__patch__(prevVnode, vnode);\n    }\n    activeInstance = prevActiveInstance;\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  };\n}\n\nfunction mountComponent(vm, el, hydrating) {\n  vm.$el = el;\n  if (!vm.$options.render) {\n    vm.$options.render = createEmptyVNode;\n    if (false) {\n      /* istanbul ignore if */\n      if (vm.$options.template && vm.$options.template.charAt(0) !== '#' || vm.$options.el || el) {\n        warn('You are using the runtime-only build of Vue where the template ' + 'compiler is not available. Either pre-compile the templates into ' + 'render functions, or use the compiler-included build.', vm);\n      } else {\n        warn('Failed to mount component: template or render function not defined.', vm);\n      }\n    }\n  }\n  callHook(vm, 'beforeMount');\n\n  var updateComponent;\n  /* istanbul ignore if */\n  if (false) {\n    updateComponent = function updateComponent() {\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(name + \" render\", startTag, endTag);\n\n      mark(startTag);\n      vm._update(vnode, hydrating);\n      mark(endTag);\n      measure(name + \" patch\", startTag, endTag);\n    };\n  } else {\n    updateComponent = function updateComponent() {\n      vm._update(vm._render(), hydrating);\n    };\n  }\n\n  vm._watcher = new Watcher(vm, updateComponent, noop);\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(vm, propsData, listeners, parentVnode, renderChildren) {\n  if (false) {\n    isUpdatingChildComponent = true;\n  }\n\n  // determine whether component has slot children\n  // we need to do this before overwriting $options._renderChildren\n  var hasChildren = !!(renderChildren || // has new static slots\n  vm.$options._renderChildren || // has old static slots\n  parentVnode.data.scopedSlots || // has new scoped slots\n  vm.$scopedSlots !== emptyObject // has old scoped slots\n  );\n\n  vm.$options._parentVnode = parentVnode;\n  vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n\n  if (vm._vnode) {\n    // update child tree's parent\n    vm._vnode.parent = parentVnode;\n  }\n  vm.$options._renderChildren = renderChildren;\n\n  // update $attrs and $listensers 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 && parentVnode.data.attrs;\n  vm.$listeners = listeners;\n\n  // update props\n  if (propsData && vm.$options.props) {\n    observerState.shouldConvert = 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      props[key] = validateProp(key, vm.$options.props, propsData, vm);\n    }\n    observerState.shouldConvert = true;\n    // keep a copy of raw propsData\n    vm.$options.propsData = propsData;\n  }\n\n  // update listeners\n  if (listeners) {\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 (hasChildren) {\n    vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n    vm.$forceUpdate();\n  }\n\n  if (false) {\n    isUpdatingChildComponent = false;\n  }\n}\n\nfunction isInInactiveTree(vm) {\n  while (vm && (vm = vm.$parent)) {\n    if (vm._inactive) {\n      return true;\n    }\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  var handlers = vm.$options[hook];\n  if (handlers) {\n    for (var i = 0, j = handlers.length; i < j; i++) {\n      try {\n        handlers[i].call(vm);\n      } catch (e) {\n        handleError(e, vm, hook + \" hook\");\n      }\n    }\n  }\n  if (vm._hasHookEvent) {\n    vm.$emit('hook:' + hook);\n  }\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 (false) {\n    circular = {};\n  }\n  waiting = flushing = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue() {\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) {\n    return a.id - b.id;\n  });\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    id = watcher.id;\n    has[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if (false) {\n      circular[id] = (circular[id] || 0) + 1;\n      if (circular[id] > MAX_UPDATE_COUNT) {\n        warn('You may have an infinite update loop ' + (watcher.user ? \"in watcher with expression \\\"\" + watcher.expression + \"\\\"\" : \"in a component render function.\"), watcher.vm);\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) {\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      nextTick(flushSchedulerQueue);\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(vm, expOrFn, cb, options) {\n  this.vm = vm;\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  } 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 =  false ? expOrFn.toString() : '';\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 = function () {};\n      \"production\" !== 'production' && warn(\"Failed watching path: \\\"\" + expOrFn + \"\\\" \" + 'Watcher only accepts simple dot-delimited paths. ' + 'For full control, use a function instead.', vm);\n    }\n  }\n  this.value = this.lazy ? undefined : 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 this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    var dep = this$1.deps[i];\n    if (!this$1.newDepIds.has(dep.id)) {\n      dep.removeSub(this$1);\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 (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) || this.deep) {\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 this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    this$1.deps[i].depend();\n  }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown() {\n  var this$1 = this;\n\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$1.deps[i].removeSub(this$1);\n    }\n    this.active = false;\n  }\n};\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 */\nvar seenObjects = new _Set();\nfunction traverse(val) {\n  seenObjects.clear();\n  _traverse(val, seenObjects);\n}\n\nfunction _traverse(val, seen) {\n  var i, keys;\n  var isA = Array.isArray(val);\n  if (!isA && !isObject(val) || !Object.isExtensible(val)) {\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--) {\n      _traverse(val[i], seen);\n    }\n  } else {\n    keys = Object.keys(val);\n    i = keys.length;\n    while (i--) {\n      _traverse(val[keys[i]], seen);\n    }\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) {\n    initProps(vm, opts.props);\n  }\n  if (opts.methods) {\n    initMethods(vm, opts.methods);\n  }\n  if (opts.data) {\n    initData(vm);\n  } else {\n    observe(vm._data = {}, true /* asRootData */);\n  }\n  if (opts.computed) {\n    initComputed(vm, opts.computed);\n  }\n  if (opts.watch && opts.watch !== nativeWatch) {\n    initWatch(vm, opts.watch);\n  }\n}\n\nfunction checkOptionType(vm, name) {\n  var option = vm.$options[name];\n  if (!isPlainObject(option)) {\n    warn(\"component option \\\"\" + name + \"\\\" should be an object.\", vm);\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  observerState.shouldConvert = isRoot;\n  var loop = function loop(key) {\n    keys.push(key);\n    var value = validateProp(key, propsOptions, propsData, vm);\n    /* istanbul ignore else */\n    if (false) {\n      if (isReservedAttribute(key) || config.isReservedAttr(key)) {\n        warn(\"\\\"\" + key + \"\\\" is a reserved attribute and cannot be used as component prop.\", vm);\n      }\n      defineReactive$$1(props, key, value, function () {\n        if (vm.$parent && !isUpdatingChildComponent) {\n          warn(\"Avoid mutating a prop directly since the value will be \" + \"overwritten whenever the parent component re-renders. \" + \"Instead, use a data or computed property based on the prop's \" + \"value. Prop being mutated: \\\"\" + key + \"\\\"\", vm);\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) {\n    loop(key);\n  }observerState.shouldConvert = true;\n}\n\nfunction initData(vm) {\n  var data = vm.$options.data;\n  data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};\n  if (!isPlainObject(data)) {\n    data = {};\n    \"production\" !== 'production' && warn('data functions should return an object:\\n' + 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);\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 (false) {\n      if (methods && hasOwn(methods, key)) {\n        warn(\"method \\\"\" + key + \"\\\" has already been defined as a data property.\", vm);\n      }\n    }\n    if (props && hasOwn(props, key)) {\n      \"production\" !== 'production' && warn(\"The data property \\\"\" + key + \"\\\" is already declared as a prop. \" + \"Use prop default value instead.\", vm);\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  try {\n    return data.call(vm);\n  } catch (e) {\n    handleError(e, vm, \"data()\");\n    return {};\n  }\n}\n\nvar computedWatcherOptions = { lazy: true };\n\nfunction initComputed(vm, computed) {\n  \"production\" !== 'production' && checkOptionType(vm, 'computed');\n  var watchers = vm._computedWatchers = Object.create(null);\n\n  for (var key in computed) {\n    var userDef = computed[key];\n    var getter = typeof userDef === 'function' ? userDef : userDef.get;\n    if (false) {\n      warn(\"Getter is missing for computed property \\\"\" + key + \"\\\".\", vm);\n    }\n    // create internal watcher for the computed property.\n    watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);\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 (false) {\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(target, key, userDef) {\n  if (typeof userDef === 'function') {\n    sharedPropertyDefinition.get = createComputedGetter(key);\n    sharedPropertyDefinition.set = noop;\n  } else {\n    sharedPropertyDefinition.get = userDef.get ? userDef.cache !== false ? createComputedGetter(key) : userDef.get : noop;\n    sharedPropertyDefinition.set = userDef.set ? userDef.set : noop;\n  }\n  if (false) {\n    sharedPropertyDefinition.set = function () {\n      warn(\"Computed property \\\"\" + key + \"\\\" was assigned to but it has no setter.\", this);\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 initMethods(vm, methods) {\n  \"production\" !== 'production' && checkOptionType(vm, 'methods');\n  var props = vm.$options.props;\n  for (var key in methods) {\n    vm[key] = methods[key] == null ? noop : bind(methods[key], vm);\n    if (false) {\n      if (methods[key] == null) {\n        warn(\"method \\\"\" + key + \"\\\" has an undefined value in the component definition. \" + \"Did you reference the function correctly?\", vm);\n      }\n      if (props && hasOwn(props, key)) {\n        warn(\"method \\\"\" + key + \"\\\" has already been defined as a prop.\", vm);\n      }\n    }\n  }\n}\n\nfunction initWatch(vm, watch) {\n  \"production\" !== 'production' && checkOptionType(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(vm, keyOrFn, handler, options) {\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(keyOrFn, 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 () {\n    return this._data;\n  };\n  var propsDef = {};\n  propsDef.get = function () {\n    return this._props;\n  };\n  if (false) {\n    dataDef.set = function (newData) {\n      warn('Avoid replacing instance root $data. ' + 'Use nested data properties instead.', this);\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 (expOrFn, cb, options) {\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      cb.call(vm, watcher.value);\n    }\n    return function unwatchFn() {\n      watcher.teardown();\n    };\n  };\n}\n\n/*  */\n\nfunction initProvide(vm) {\n  var provide = vm.$options.provide;\n  if (provide) {\n    vm._provided = typeof provide === 'function' ? provide.call(vm) : provide;\n  }\n}\n\nfunction initInjections(vm) {\n  var result = resolveInject(vm.$options.inject, vm);\n  if (result) {\n    observerState.shouldConvert = false;\n    Object.keys(result).forEach(function (key) {\n      /* istanbul ignore else */\n      if (false) {\n        defineReactive$$1(vm, key, result[key], function () {\n          warn(\"Avoid mutating an injected value directly since the changes will be \" + \"overwritten whenever the provided component re-renders. \" + \"injection being mutated: \\\"\" + key + \"\\\"\", vm);\n        });\n      } else {\n        defineReactive$$1(vm, key, result[key]);\n      }\n    });\n    observerState.shouldConvert = 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 ? Reflect.ownKeys(inject) : Object.keys(inject);\n\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i];\n      var provideKey = inject[key];\n      var source = vm;\n      while (source) {\n        if (source._provided && provideKey in source._provided) {\n          result[key] = source._provided[provideKey];\n          break;\n        }\n        source = source.$parent;\n      }\n      if (false) {\n        warn(\"Injection \\\"\" + key + \"\\\" not found\", vm);\n      }\n    }\n    return result;\n  }\n}\n\n/*  */\n\nfunction createFunctionalComponent(Ctor, propsData, data, context, children) {\n  var props = {};\n  var propOptions = Ctor.options.props;\n  if (isDef(propOptions)) {\n    for (var key in propOptions) {\n      props[key] = validateProp(key, propOptions, propsData || {});\n    }\n  } else {\n    if (isDef(data.attrs)) {\n      mergeProps(props, data.attrs);\n    }\n    if (isDef(data.props)) {\n      mergeProps(props, data.props);\n    }\n  }\n  // ensure the createElement function in functional components\n  // gets a unique context - this is necessary for correct named slot check\n  var _context = Object.create(context);\n  var h = function h(a, b, c, d) {\n    return createElement(_context, a, b, c, d, true);\n  };\n  var vnode = Ctor.options.render.call(null, h, {\n    data: data,\n    props: props,\n    children: children,\n    parent: context,\n    listeners: data.on || {},\n    injections: resolveInject(Ctor.options.inject, context),\n    slots: function slots() {\n      return resolveSlots(children, context);\n    }\n  });\n  if (vnode instanceof VNode) {\n    vnode.functionalContext = context;\n    vnode.functionalOptions = Ctor.options;\n    if (data.slot) {\n      (vnode.data || (vnode.data = {})).slot = data.slot;\n    }\n  }\n  return vnode;\n}\n\nfunction mergeProps(to, from) {\n  for (var key in from) {\n    to[camelize(key)] = from[key];\n  }\n}\n\n/*  */\n\n// hooks to be invoked on component VNodes during patch\nvar componentVNodeHooks = {\n  init: function init(vnode, hydrating, parentElm, refElm) {\n    if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {\n      var child = vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance, parentElm, refElm);\n      child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n    } else if (vnode.data.keepAlive) {\n      // kept-alive components, treat as a patch\n      var mountedNode = vnode; // work around flow\n      componentVNodeHooks.prepatch(mountedNode, mountedNode);\n    }\n  },\n\n  prepatch: function prepatch(oldVnode, vnode) {\n    var options = vnode.componentOptions;\n    var child = vnode.componentInstance = oldVnode.componentInstance;\n    updateChildComponent(child, 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(Ctor, data, context, children, tag) {\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 (false) {\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, context);\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(asyncFactory, data, context, children, tag);\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  // merge component management hooks onto the placeholder node\n  mergeHooks(data);\n\n  // return a placeholder vnode\n  var name = Ctor.options.name || tag;\n  var vnode = new VNode(\"vue-component-\" + Ctor.cid + (name ? \"-\" + name : ''), data, undefined, undefined, undefined, context, { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);\n  return vnode;\n}\n\nfunction createComponentInstanceForVnode(vnode, // we know it's MountedComponentVNode but flow doesn't\nparent, // activeInstance in lifecycle state\nparentElm, refElm) {\n  var vnodeComponentOptions = vnode.componentOptions;\n  var options = {\n    _isComponent: true,\n    parent: parent,\n    propsData: vnodeComponentOptions.propsData,\n    _componentTag: vnodeComponentOptions.tag,\n    _parentVnode: vnode,\n    _parentListeners: vnodeComponentOptions.listeners,\n    _renderChildren: vnodeComponentOptions.children,\n    _parentElm: parentElm || null,\n    _refElm: refElm || null\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 vnodeComponentOptions.Ctor(options);\n}\n\nfunction mergeHooks(data) {\n  if (!data.hook) {\n    data.hook = {};\n  }\n  for (var i = 0; i < hooksToMerge.length; i++) {\n    var key = hooksToMerge[i];\n    var fromParent = data.hook[key];\n    var ours = componentVNodeHooks[key];\n    data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;\n  }\n}\n\nfunction mergeHook$1(one, two) {\n  return function (a, b, c, d) {\n    one(a, b, c, d);\n    two(a, b, c, d);\n  };\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';(data.props || (data.props = {}))[prop] = data.model.value;\n  var on = data.on || (data.on = {});\n  if (isDef(on[event])) {\n    on[event] = [data.model.callback].concat(on[event]);\n  } else {\n    on[event] = data.model.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(context, tag, data, children, normalizationType, alwaysNormalize) {\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(context, tag, data, children, normalizationType) {\n  if (isDef(data) && isDef(data.__ob__)) {\n    \"production\" !== 'production' && warn(\"Avoid using observed data object as vnode data: \" + JSON.stringify(data) + \"\\n\" + 'Always create fresh vnode data objects in each render!', context);\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 (false) {\n    warn('Avoid using non-primitive value as key, ' + 'use string/number value instead.', context);\n  }\n  // support single function children as default scoped slot\n  if (Array.isArray(children) && typeof children[0] === 'function') {\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 = config.getTagNamespace(tag);\n    if (config.isReservedTag(tag)) {\n      // platform built-in elements\n      vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);\n    } else if (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(tag, data, children, undefined, undefined, context);\n    }\n  } else {\n    // direct component options / constructor\n    vnode = createComponent(tag, data, context, children);\n  }\n  if (isDef(vnode)) {\n    if (ns) {\n      applyNS(vnode, ns);\n    }\n    return vnode;\n  } else {\n    return createEmptyVNode();\n  }\n}\n\nfunction applyNS(vnode, ns) {\n  vnode.ns = ns;\n  if (vnode.tag === 'foreignObject') {\n    // use default namespace inside foreignObject\n    return;\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) && isUndef(child.ns)) {\n        applyNS(child, ns);\n      }\n    }\n  }\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering v-for lists.\n */\nfunction renderList(val, render) {\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    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  if (isDef(ret)) {\n    ret._isVList = true;\n  }\n  return ret;\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering <slot>\n */\nfunction renderSlot(name, fallback, props, bindObject) {\n  var scopedSlotFn = this.$scopedSlots[name];\n  if (scopedSlotFn) {\n    // scoped slot\n    props = props || {};\n    if (bindObject) {\n      props = extend(extend({}, bindObject), props);\n    }\n    return scopedSlotFn(props) || fallback;\n  } else {\n    var slotNodes = this.$slots[name];\n    // warn duplicate slot usage\n    if (slotNodes && \"production\" !== 'production') {\n      slotNodes._rendered && warn(\"Duplicate presence of slot \\\"\" + name + \"\\\" found in the same render tree \" + \"- this will likely cause render errors.\", this);\n      slotNodes._rendered = true;\n    }\n    return slotNodes || fallback;\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\n/**\n * Runtime helper for checking keyCodes from config.\n */\nfunction checkKeyCodes(eventKeyCode, key, builtInAlias) {\n  var keyCodes = config.keyCodes[key] || builtInAlias;\n  if (Array.isArray(keyCodes)) {\n    return keyCodes.indexOf(eventKeyCode) === -1;\n  } else {\n    return keyCodes !== eventKeyCode;\n  }\n}\n\n/*  */\n\n/**\n * Runtime helper for merging v-bind=\"object\" into a VNode's data.\n */\nfunction bindObjectProps(data, tag, value, asProp, isSync) {\n  if (value) {\n    if (!isObject(value)) {\n      \"production\" !== 'production' && warn('v-bind without argument expects an Object or Array value', this);\n    } else {\n      if (Array.isArray(value)) {\n        value = toObject(value);\n      }\n      var hash;\n      var loop = function loop(key) {\n        if (key === 'class' || key === 'style' || isReservedAttribute(key)) {\n          hash = data;\n        } else {\n          var type = data.attrs && data.attrs.type;\n          hash = asProp || config.mustUseProp(tag, type, key) ? data.domProps || (data.domProps = {}) : data.attrs || (data.attrs = {});\n        }\n        if (!(key in hash)) {\n          hash[key] = value[key];\n\n          if (isSync) {\n            var on = data.on || (data.on = {});\n            on[\"update:\" + key] = function ($event) {\n              value[key] = $event;\n            };\n          }\n        }\n      };\n\n      for (var key in value) {\n        loop(key);\n      }\n    }\n  }\n  return data;\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering static trees.\n */\nfunction renderStatic(index, isInFor) {\n  var tree = this._staticTrees[index];\n  // if has already-rendered static tree and not inside v-for,\n  // we can reuse the same tree by doing a shallow clone.\n  if (tree && !isInFor) {\n    return Array.isArray(tree) ? cloneVNodes(tree) : cloneVNode(tree);\n  }\n  // otherwise, render a fresh tree.\n  tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy);\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(tree, index, key) {\n  markStatic(tree, \"__once__\" + index + (key ? \"_\" + key : \"\"), true);\n  return tree;\n}\n\nfunction markStatic(tree, key, isOnce) {\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      \"production\" !== 'production' && warn('v-on without argument expects an Object value', this);\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(ours, existing) : ours;\n      }\n    }\n  }\n  return data;\n}\n\n/*  */\n\nfunction initRender(vm) {\n  vm._vnode = null; // the root of the child tree\n  vm._staticTrees = null;\n  var parentVnode = vm.$vnode = vm.$options._parentVnode; // the placeholder node in parent tree\n  var renderContext = parentVnode && parentVnode.context;\n  vm.$slots = resolveSlots(vm.$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) {\n    return createElement(vm, a, b, c, d, false);\n  };\n  // normalization is always applied for the public version, used in\n  // user-written render functions.\n  vm.$createElement = function (a, b, c, d) {\n    return createElement(vm, a, b, c, d, true);\n  };\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  /* istanbul ignore else */\n  if (false) {\n    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs, function () {\n      !isUpdatingChildComponent && warn(\"$attrs is readonly.\", vm);\n    }, true);\n    defineReactive$$1(vm, '$listeners', vm.$options._parentListeners, function () {\n      !isUpdatingChildComponent && warn(\"$listeners is readonly.\", vm);\n    }, true);\n  } else {\n    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs, null, true);\n    defineReactive$$1(vm, '$listeners', vm.$options._parentListeners, null, true);\n  }\n}\n\nfunction renderMixin(Vue) {\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 staticRenderFns = ref.staticRenderFns;\n    var _parentVnode = ref._parentVnode;\n\n    if (vm._isMounted) {\n      // clone slot nodes on re-renders\n      for (var key in vm.$slots) {\n        vm.$slots[key] = cloneVNodes(vm.$slots[key]);\n      }\n    }\n\n    vm.$scopedSlots = _parentVnode && _parentVnode.data.scopedSlots || emptyObject;\n\n    if (staticRenderFns && !vm._staticTrees) {\n      vm._staticTrees = [];\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      vnode = render.call(vm._renderProxy, vm.$createElement);\n    } catch (e) {\n      handleError(e, vm, \"render function\");\n      // return error render result,\n      // or previous vnode to prevent render error causing blank component\n      /* istanbul ignore else */\n      if (false) {\n        vnode = vm.$options.renderError ? vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e) : vm._vnode;\n      } else {\n        vnode = vm._vnode;\n      }\n    }\n    // return empty vnode in case the render function errored out\n    if (!(vnode instanceof VNode)) {\n      if (false) {\n        warn('Multiple root nodes returned from render function. Render function ' + 'should return a single root node.', vm);\n      }\n      vnode = createEmptyVNode();\n    }\n    // set parent\n    vnode.parent = _parentVnode;\n    return vnode;\n  };\n\n  // internal render helpers.\n  // these are exposed on the instance prototype to reduce generated render\n  // code size.\n  Vue.prototype._o = markOnce;\n  Vue.prototype._n = toNumber;\n  Vue.prototype._s = toString;\n  Vue.prototype._l = renderList;\n  Vue.prototype._t = renderSlot;\n  Vue.prototype._q = looseEqual;\n  Vue.prototype._i = looseIndexOf;\n  Vue.prototype._m = renderStatic;\n  Vue.prototype._f = resolveFilter;\n  Vue.prototype._k = checkKeyCodes;\n  Vue.prototype._b = bindObjectProps;\n  Vue.prototype._v = createTextVNode;\n  Vue.prototype._e = createEmptyVNode;\n  Vue.prototype._u = resolveScopedSlots;\n  Vue.prototype._g = bindObjectListeners;\n}\n\n/*  */\n\nvar uid$1 = 0;\n\nfunction initMixin(Vue) {\n  Vue.prototype._init = function (options) {\n    var vm = this;\n    // a uid\n    vm._uid = uid$1++;\n\n    var startTag, endTag;\n    /* istanbul ignore if */\n    if (false) {\n      startTag = \"vue-perf-init:\" + 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(resolveConstructorOptions(vm.constructor), options || {}, vm);\n    }\n    /* istanbul ignore else */\n    if (false) {\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 (false) {\n      vm._name = formatComponentName(vm, false);\n      mark(endTag);\n      measure(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  opts.parent = options.parent;\n  opts.propsData = options.propsData;\n  opts._parentVnode = options._parentVnode;\n  opts._parentListeners = options._parentListeners;\n  opts._renderChildren = options._renderChildren;\n  opts._componentTag = options._componentTag;\n  opts._parentElm = options._parentElm;\n  opts._refElm = options._refElm;\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 extended = Ctor.extendOptions;\n  var sealed = Ctor.sealedOptions;\n  for (var key in latest) {\n    if (latest[key] !== sealed[key]) {\n      if (!modified) {\n        modified = {};\n      }\n      modified[key] = dedupe(latest[key], extended[key], sealed[key]);\n    }\n  }\n  return modified;\n}\n\nfunction dedupe(latest, extended, sealed) {\n  // compare latest and sealed to ensure lifecycle hooks won't be duplicated\n  // between merges\n  if (Array.isArray(latest)) {\n    var res = [];\n    sealed = Array.isArray(sealed) ? sealed : [sealed];\n    extended = Array.isArray(extended) ? extended : [extended];\n    for (var i = 0; i < latest.length; i++) {\n      // push original options and not sealed options to exclude duplicated options\n      if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) {\n        res.push(latest[i]);\n      }\n    }\n    return res;\n  } else {\n    return latest;\n  }\n}\n\nfunction Vue$3(options) {\n  if (false) {\n    warn('Vue is a constructor and should be called with the `new` keyword');\n  }\n  this._init(options);\n}\n\ninitMixin(Vue$3);\nstateMixin(Vue$3);\neventsMixin(Vue$3);\nlifecycleMixin(Vue$3);\nrenderMixin(Vue$3);\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 (false) {\n      if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n        warn('Invalid component name: \"' + name + '\". Component names ' + 'can only contain alphanumeric characters and the hyphen, ' + 'and must start with a letter.');\n      }\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(Super.options, extendOptions);\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 (id, definition) {\n      if (!definition) {\n        return this.options[type + 's'][id];\n      } else {\n        /* istanbul ignore if */\n        if (false) {\n          if (type === 'component' && config.isReservedTag(id)) {\n            warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + id);\n          }\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\nvar patternTypes = [String, RegExp, Array];\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(cache, current, filter) {\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        if (cachedNode !== current) {\n          pruneCacheEntry(cachedNode);\n        }\n        cache[key] = null;\n      }\n    }\n  }\n}\n\nfunction pruneCacheEntry(vnode) {\n  if (vnode) {\n    vnode.componentInstance.$destroy();\n  }\n}\n\nvar KeepAlive = {\n  name: 'keep-alive',\n  abstract: true,\n\n  props: {\n    include: patternTypes,\n    exclude: patternTypes\n  },\n\n  created: function created() {\n    this.cache = Object.create(null);\n  },\n\n  destroyed: function destroyed() {\n    var this$1 = this;\n\n    for (var key in this$1.cache) {\n      pruneCacheEntry(this$1.cache[key]);\n    }\n  },\n\n  watch: {\n    include: function include(val) {\n      pruneCache(this.cache, this._vnode, function (name) {\n        return matches(val, name);\n      });\n    },\n    exclude: function exclude(val) {\n      pruneCache(this.cache, this._vnode, function (name) {\n        return !matches(val, name);\n      });\n    }\n  },\n\n  render: function render() {\n    var vnode = getFirstComponentChild(this.$slots.default);\n    var componentOptions = vnode && vnode.componentOptions;\n    if (componentOptions) {\n      // check pattern\n      var name = getComponentName(componentOptions);\n      if (name && (this.include && !matches(this.include, name) || this.exclude && matches(this.exclude, name))) {\n        return vnode;\n      }\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 : '') : vnode.key;\n      if (this.cache[key]) {\n        vnode.componentInstance = this.cache[key].componentInstance;\n      } else {\n        this.cache[key] = vnode;\n      }\n      vnode.data.keepAlive = true;\n    }\n    return vnode;\n  }\n};\n\nvar builtInComponents = {\n  KeepAlive: KeepAlive\n};\n\n/*  */\n\nfunction initGlobalAPI(Vue) {\n  // config\n  var configDef = {};\n  configDef.get = function () {\n    return config;\n  };\n  if (false) {\n    configDef.set = function () {\n      warn('Do not replace the Vue.config object, set individual fields instead.');\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  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$3);\n\nObject.defineProperty(Vue$3.prototype, '$isServer', {\n  get: isServerRendering\n});\n\nObject.defineProperty(Vue$3.prototype, '$ssrContext', {\n  get: function get() {\n    /* istanbul ignore next */\n    return this.$vnode && this.$vnode.ssrContext;\n  }\n});\n\nVue$3.version = '2.4.2';\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');\nvar mustUseProp = function mustUseProp(tag, type, attr) {\n  return attr === 'value' && acceptValue(tag) && type !== 'button' || attr === 'selected' && tag === 'option' || attr === 'checked' && tag === 'input' || attr === 'muted' && tag === 'video';\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' + 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' + 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' + 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' + 'required,reversed,scoped,seamless,selected,sortable,translate,' + 'truespeed,typemustmatch,visible');\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function isXlink(name) {\n  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';\n};\n\nvar getXlinkProp = function getXlinkProp(name) {\n  return isXlink(name) ? name.slice(6, name.length) : '';\n};\n\nvar isFalsyAttrValue = function isFalsyAttrValue(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.data) {\n      data = mergeClassData(childNode.data, data);\n    }\n  }\n  while (isDef(parentNode = parentNode.parent)) {\n    if (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) ? [child.class, parent.class] : parent.class\n  };\n}\n\nfunction renderClass(staticClass, dynamicClass) {\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) {\n        res += ' ';\n      }\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) {\n        res += ' ';\n      }\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('html,body,base,head,link,meta,style,title,' + 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' + 'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' + 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' + 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' + 'embed,object,param,source,canvas,script,noscript,del,ins,' + 'caption,col,colgroup,table,thead,tbody,td,th,tr,' + 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' + 'output,progress,select,textarea,' + 'details,dialog,menu,menuitem,summary,' + 'content,element,shadow,template,blockquote,iframe,tfoot');\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' + 'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' + 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);\n\nvar isPreTag = function isPreTag(tag) {\n  return tag === 'pre';\n};\n\nvar isReservedTag = function isReservedTag(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] = el.constructor === window.HTMLUnknownElement || el.constructor === window.HTMLElement;\n  } else {\n    return unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString());\n  }\n}\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      \"production\" !== 'production' && warn('Cannot find element: ' + el);\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 setAttribute(node, key, val) {\n  node.setAttribute(key, val);\n}\n\nvar nodeOps = 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  setAttribute: setAttribute\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 (!key) {\n    return;\n  }\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\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 a.key === b.key && (a.tag === b.tag && a.isComment === b.isComment && isDef(a.data) === isDef(b.data) && sameInputType(a, b) || isTrue(a.isAsyncPlaceholder) && a.asyncFactory === b.asyncFactory && isUndef(b.asyncFactory.error));\n}\n\n// Some browsers do not support dynamically changing type for <input>\n// so they need to be treated as different nodes\nfunction sameInputType(a, b) {\n  if (a.tag !== 'input') {\n    return true;\n  }\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;\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)) {\n      map[key] = i;\n    }\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  var inPre = 0;\n  function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested) {\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 (false) {\n        if (data && data.pre) {\n          inPre++;\n        }\n        if (!inPre && !vnode.ns && !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) && config.isUnknownElement(tag)) {\n          warn('Unknown custom element: <' + tag + '> - did you ' + 'register the component correctly? For recursive components, ' + 'make sure to provide the \"name\" option.', vnode.context);\n        }\n      }\n      vnode.elm = vnode.ns ? nodeOps.createElementNS(vnode.ns, tag) : 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 (false) {\n        inPre--;\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 */, parentElm, refElm);\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        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 (ref$$1.parentNode === 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      for (var i = 0; i < children.length; ++i) {\n        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);\n      }\n    } else if (isPrimitive(vnode.text)) {\n      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(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)) {\n        i.create(emptyNode, vnode);\n      }\n      if (isDef(i.insert)) {\n        insertedVnodeQueue.push(vnode);\n      }\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    var ancestor = vnode;\n    while (ancestor) {\n      if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {\n        nodeOps.setAttribute(vnode.elm, i, '');\n      }\n      ancestor = ancestor.parent;\n    }\n    // for slot content they should also get the scopeId from the host instance.\n    if (isDef(i = activeInstance) && i !== vnode.context && isDef(i = i.$options._scopeId)) {\n      nodeOps.setAttribute(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);\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)) {\n        i(vnode);\n      }\n      for (i = 0; i < cbs.destroy.length; ++i) {\n        cbs.destroy[i](vnode);\n      }\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 {\n          // 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, elmToMove, 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    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);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) {\n        // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\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)) {\n        // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) {\n          oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        }\n        idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null;\n        if (isUndef(idxInOld)) {\n          // New element\n          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          /* istanbul ignore if */\n          if (false) {\n            warn('It seems there are duplicate keys that is causing an update error. ' + 'Make sure each v-for item has a unique key.');\n          }\n          if (sameVnode(elmToMove, newStartVnode)) {\n            patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n            oldCh[idxInOld] = undefined;\n            canMove && nodeOps.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          } else {\n            // same key but different element. treat as new element\n            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          }\n        }\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 patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n    if (oldVnode === vnode) {\n      return;\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) && isTrue(oldVnode.isStatic) && vnode.key === oldVnode.key && (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {\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) {\n        cbs.update[i](oldVnode, vnode);\n      }\n      if (isDef(i = data.hook) && isDef(i = i.update)) {\n        i(oldVnode, vnode);\n      }\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) {\n          updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);\n        }\n      } else if (isDef(ch)) {\n        if (isDef(oldVnode.text)) {\n          nodeOps.setTextContent(elm, '');\n        }\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)) {\n        i(oldVnode, vnode);\n      }\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 bailed = 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  var isRenderedModule = makeMap('attrs,style,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) {\n    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {\n      vnode.elm = elm;\n      vnode.isAsyncPlaceholder = true;\n      return true;\n    }\n    if (false) {\n      if (!assertNodeMatch(elm, vnode)) {\n        return false;\n      }\n    }\n    vnode.elm = elm;\n    var tag = vnode.tag;\n    var data = vnode.data;\n    var children = vnode.children;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) {\n        i(vnode, true /* hydrating */);\n      }\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          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)) {\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            if (false) {\n              bailed = true;\n              console.warn('Parent: ', elm);\n              console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n            }\n            return false;\n          }\n        }\n      }\n      if (isDef(data)) {\n        for (var key in data) {\n          if (!isRenderedModule(key)) {\n            invokeCreateHooks(vnode, insertedVnodeQueue);\n            break;\n          }\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) {\n    if (isDef(vnode.tag)) {\n      return vnode.tag.indexOf('vue-component') === 0 || vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase());\n    } else {\n      return node.nodeType === (vnode.isComment ? 8 : 3);\n    }\n  }\n\n  return function patch(oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {\n    if (isUndef(vnode)) {\n      if (isDef(oldVnode)) {\n        invokeDestroyHook(oldVnode);\n      }\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, parentElm, refElm);\n    } else {\n      var isRealElement = isDef(oldVnode.nodeType);\n      if (!isRealElement && sameVnode(oldVnode, vnode)) {\n        // patch existing root node\n        patchVnode(oldVnode, vnode, insertedVnodeQueue, 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 (false) {\n              warn('The client-side rendered virtual DOM tree is not matching ' + 'server-rendered content. This is likely caused by incorrect ' + 'HTML markup, for example nesting block-level elements inside ' + '<p>, or missing <tbody>. Bailing hydration and performing ' + 'full client-side render.');\n            }\n          }\n          // either not server-rendered, or hydration failed.\n          // create an empty node and replace it\n          oldVnode = emptyNodeAt(oldVnode);\n        }\n        // replacing existing element\n        var oldElm = oldVnode.elm;\n        var parentElm$1 = nodeOps.parentNode(oldElm);\n        createElm(vnode, 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$1, nodeOps.nextSibling(oldElm));\n\n        if (isDef(vnode.parent)) {\n          // component root element replaced.\n          // update parent placeholder node element, recursively\n          var ancestor = vnode.parent;\n          while (ancestor) {\n            ancestor.elm = vnode.elm;\n            ancestor = ancestor.parent;\n          }\n          if (isPatchable(vnode)) {\n            for (var i = 0; i < cbs.create.length; ++i) {\n              cbs.create[i](emptyNode, vnode.parent);\n            }\n          }\n        }\n\n        if (isDef(parentElm$1)) {\n          removeVnodes(parentElm$1, [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      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 callInsert() {\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.data.hook || (vnode.data.hook = {}), 'insert', callInsert);\n    } else {\n      callInsert();\n    }\n  }\n\n  if (dirsWithPostpatch.length) {\n    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), '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(dirs, vm) {\n  var res = Object.create(null);\n  if (!dirs) {\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      dir.modifiers = emptyModifiers;\n    }\n    res[getRawDirName(dir)] = dir;\n    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n  }\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 = [ref, directives];\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  /* istanbul ignore if */\n  if (isIE9 && 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 (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      el.setAttribute(key, key);\n    }\n  } else if (isEnumeratedAttr(key)) {\n    el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');\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    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      el.setAttribute(key, value);\n    }\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 (isUndef(data.staticClass) && isUndef(data.class) && (isUndef(oldData) || isUndef(oldData.staticClass) && isUndef(oldData.class))) {\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\nvar validDivisionCharRE = /[\\w).+\\-_$\\]]/;\n\nfunction parseFilters(exp) {\n  var inSingle = false;\n  var inDouble = false;\n  var inTemplateString = false;\n  var inRegex = false;\n  var curly = 0;\n  var square = 0;\n  var paren = 0;\n  var lastFilterIndex = 0;\n  var c, prev, i, expression, filters;\n\n  for (i = 0; i < exp.length; i++) {\n    prev = c;\n    c = exp.charCodeAt(i);\n    if (inSingle) {\n      if (c === 0x27 && prev !== 0x5C) {\n        inSingle = false;\n      }\n    } else if (inDouble) {\n      if (c === 0x22 && prev !== 0x5C) {\n        inDouble = false;\n      }\n    } else if (inTemplateString) {\n      if (c === 0x60 && prev !== 0x5C) {\n        inTemplateString = false;\n      }\n    } else if (inRegex) {\n      if (c === 0x2f && prev !== 0x5C) {\n        inRegex = false;\n      }\n    } else if (c === 0x7C && // pipe\n    exp.charCodeAt(i + 1) !== 0x7C && exp.charCodeAt(i - 1) !== 0x7C && !curly && !square && !paren) {\n      if (expression === undefined) {\n        // first filter, end of expression\n        lastFilterIndex = i + 1;\n        expression = exp.slice(0, i).trim();\n      } else {\n        pushFilter();\n      }\n    } else {\n      switch (c) {\n        case 0x22:\n          inDouble = true;break; // \"\n        case 0x27:\n          inSingle = true;break; // '\n        case 0x60:\n          inTemplateString = true;break; // `\n        case 0x28:\n          paren++;break; // (\n        case 0x29:\n          paren--;break; // )\n        case 0x5B:\n          square++;break; // [\n        case 0x5D:\n          square--;break; // ]\n        case 0x7B:\n          curly++;break; // {\n        case 0x7D:\n          curly--;break; // }\n      }\n      if (c === 0x2f) {\n        // /\n        var j = i - 1;\n        var p = void 0;\n        // find first non-whitespace prev char\n        for (; j >= 0; j--) {\n          p = exp.charAt(j);\n          if (p !== ' ') {\n            break;\n          }\n        }\n        if (!p || !validDivisionCharRE.test(p)) {\n          inRegex = true;\n        }\n      }\n    }\n  }\n\n  if (expression === undefined) {\n    expression = exp.slice(0, i).trim();\n  } else if (lastFilterIndex !== 0) {\n    pushFilter();\n  }\n\n  function pushFilter() {\n    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());\n    lastFilterIndex = i + 1;\n  }\n\n  if (filters) {\n    for (i = 0; i < filters.length; i++) {\n      expression = wrapFilter(expression, filters[i]);\n    }\n  }\n\n  return expression;\n}\n\nfunction wrapFilter(exp, filter) {\n  var i = filter.indexOf('(');\n  if (i < 0) {\n    // _f: resolveFilter\n    return \"_f(\\\"\" + filter + \"\\\")(\" + exp + \")\";\n  } else {\n    var name = filter.slice(0, i);\n    var args = filter.slice(i + 1);\n    return \"_f(\\\"\" + name + \"\\\")(\" + exp + \",\" + args;\n  }\n}\n\n/*  */\n\nfunction baseWarn(msg) {\n  console.error(\"[Vue compiler]: \" + msg);\n}\n\nfunction pluckModuleFunction(modules, key) {\n  return modules ? modules.map(function (m) {\n    return m[key];\n  }).filter(function (_) {\n    return _;\n  }) : [];\n}\n\nfunction addProp(el, name, value) {\n  (el.props || (el.props = [])).push({ name: name, value: value });\n}\n\nfunction addAttr(el, name, value) {\n  (el.attrs || (el.attrs = [])).push({ name: name, value: value });\n}\n\nfunction addDirective(el, name, rawName, value, arg, modifiers) {\n  (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers });\n}\n\nfunction addHandler(el, name, value, modifiers, important, warn) {\n  // warn prevent and passive modifier\n  /* istanbul ignore if */\n  if (false) {\n    warn('passive and prevent can\\'t be used together. ' + 'Passive handler can\\'t prevent default event.');\n  }\n  // check capture modifier\n  if (modifiers && modifiers.capture) {\n    delete modifiers.capture;\n    name = '!' + name; // mark the event as captured\n  }\n  if (modifiers && modifiers.once) {\n    delete modifiers.once;\n    name = '~' + name; // mark the event as once\n  }\n  /* istanbul ignore if */\n  if (modifiers && modifiers.passive) {\n    delete modifiers.passive;\n    name = '&' + name; // mark the event as passive\n  }\n  var events;\n  if (modifiers && modifiers.native) {\n    delete modifiers.native;\n    events = el.nativeEvents || (el.nativeEvents = {});\n  } else {\n    events = el.events || (el.events = {});\n  }\n  var newHandler = { value: value, modifiers: modifiers };\n  var handlers = events[name];\n  /* istanbul ignore if */\n  if (Array.isArray(handlers)) {\n    important ? handlers.unshift(newHandler) : handlers.push(newHandler);\n  } else if (handlers) {\n    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];\n  } else {\n    events[name] = newHandler;\n  }\n}\n\nfunction getBindingAttr(el, name, getStatic) {\n  var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);\n  if (dynamicValue != null) {\n    return parseFilters(dynamicValue);\n  } else if (getStatic !== false) {\n    var staticValue = getAndRemoveAttr(el, name);\n    if (staticValue != null) {\n      return JSON.stringify(staticValue);\n    }\n  }\n}\n\nfunction getAndRemoveAttr(el, name) {\n  var val;\n  if ((val = el.attrsMap[name]) != null) {\n    var list = el.attrsList;\n    for (var i = 0, l = list.length; i < l; i++) {\n      if (list[i].name === name) {\n        list.splice(i, 1);\n        break;\n      }\n    }\n  }\n  return val;\n}\n\n/*  */\n\n/**\n * Cross-platform code generation for component v-model\n */\nfunction genComponentModel(el, value, modifiers) {\n  var ref = modifiers || {};\n  var number = ref.number;\n  var trim = ref.trim;\n\n  var baseValueExpression = '$$v';\n  var valueExpression = baseValueExpression;\n  if (trim) {\n    valueExpression = \"(typeof \" + baseValueExpression + \" === 'string'\" + \"? \" + baseValueExpression + \".trim()\" + \": \" + baseValueExpression + \")\";\n  }\n  if (number) {\n    valueExpression = \"_n(\" + valueExpression + \")\";\n  }\n  var assignment = genAssignmentCode(value, valueExpression);\n\n  el.model = {\n    value: \"(\" + value + \")\",\n    expression: \"\\\"\" + value + \"\\\"\",\n    callback: \"function (\" + baseValueExpression + \") {\" + assignment + \"}\"\n  };\n}\n\n/**\n * Cross-platform codegen helper for generating v-model value assignment code.\n */\nfunction genAssignmentCode(value, assignment) {\n  var modelRs = parseModel(value);\n  if (modelRs.idx === null) {\n    return value + \"=\" + assignment;\n  } else {\n    return \"$set(\" + modelRs.exp + \", \" + modelRs.idx + \", \" + assignment + \")\";\n  }\n}\n\n/**\n * parse directive model to do the array update transform. a[idx] = val => $$a.splice($$idx, 1, val)\n *\n * for loop possible cases:\n *\n * - test\n * - test[idx]\n * - test[test1[idx]]\n * - test[\"a\"][idx]\n * - xxx.test[a[a].test1[idx]]\n * - test.xxx.a[\"asa\"][test1[idx]]\n *\n */\n\nvar len;\nvar str;\nvar chr;\nvar index$1;\nvar expressionPos;\nvar expressionEndPos;\n\nfunction parseModel(val) {\n  str = val;\n  len = str.length;\n  index$1 = expressionPos = expressionEndPos = 0;\n\n  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {\n    return {\n      exp: val,\n      idx: null\n    };\n  }\n\n  while (!eof()) {\n    chr = next();\n    /* istanbul ignore if */\n    if (isStringStart(chr)) {\n      parseString(chr);\n    } else if (chr === 0x5B) {\n      parseBracket(chr);\n    }\n  }\n\n  return {\n    exp: val.substring(0, expressionPos),\n    idx: val.substring(expressionPos + 1, expressionEndPos)\n  };\n}\n\nfunction next() {\n  return str.charCodeAt(++index$1);\n}\n\nfunction eof() {\n  return index$1 >= len;\n}\n\nfunction isStringStart(chr) {\n  return chr === 0x22 || chr === 0x27;\n}\n\nfunction parseBracket(chr) {\n  var inBracket = 1;\n  expressionPos = index$1;\n  while (!eof()) {\n    chr = next();\n    if (isStringStart(chr)) {\n      parseString(chr);\n      continue;\n    }\n    if (chr === 0x5B) {\n      inBracket++;\n    }\n    if (chr === 0x5D) {\n      inBracket--;\n    }\n    if (inBracket === 0) {\n      expressionEndPos = index$1;\n      break;\n    }\n  }\n}\n\nfunction parseString(chr) {\n  var stringQuote = chr;\n  while (!eof()) {\n    chr = next();\n    if (chr === stringQuote) {\n      break;\n    }\n  }\n}\n\n/*  */\n\nvar warn$1;\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\nfunction model(el, dir, _warn) {\n  warn$1 = _warn;\n  var value = dir.value;\n  var modifiers = dir.modifiers;\n  var tag = el.tag;\n  var type = el.attrsMap.type;\n\n  if (false) {\n    var dynamicType = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n    if (tag === 'input' && dynamicType) {\n      warn$1(\"<input :type=\\\"\" + dynamicType + \"\\\" v-model=\\\"\" + value + \"\\\">:\\n\" + \"v-model does not support dynamic input types. Use v-if branches instead.\");\n    }\n    // inputs with type=\"file\" are read only and setting the input's\n    // value will throw an error.\n    if (tag === 'input' && type === 'file') {\n      warn$1(\"<\" + el.tag + \" v-model=\\\"\" + value + \"\\\" type=\\\"file\\\">:\\n\" + \"File inputs are read only. Use a v-on:change listener instead.\");\n    }\n  }\n\n  if (el.component) {\n    genComponentModel(el, value, modifiers);\n    // component v-model doesn't need extra runtime\n    return false;\n  } else if (tag === 'select') {\n    genSelect(el, value, modifiers);\n  } else if (tag === 'input' && type === 'checkbox') {\n    genCheckboxModel(el, value, modifiers);\n  } else if (tag === 'input' && type === 'radio') {\n    genRadioModel(el, value, modifiers);\n  } else if (tag === 'input' || tag === 'textarea') {\n    genDefaultModel(el, value, modifiers);\n  } else if (!config.isReservedTag(tag)) {\n    genComponentModel(el, value, modifiers);\n    // component v-model doesn't need extra runtime\n    return false;\n  } else if (false) {\n    warn$1(\"<\" + el.tag + \" v-model=\\\"\" + value + \"\\\">: \" + \"v-model is not supported on this element type. \" + 'If you are working with contenteditable, it\\'s recommended to ' + 'wrap a library dedicated for that purpose inside a custom component.');\n  }\n\n  // ensure runtime directive metadata\n  return true;\n}\n\nfunction genCheckboxModel(el, value, modifiers) {\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';\n  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';\n  addProp(el, 'checked', \"Array.isArray(\" + value + \")\" + \"?_i(\" + value + \",\" + valueBinding + \")>-1\" + (trueValueBinding === 'true' ? \":(\" + value + \")\" : \":_q(\" + value + \",\" + trueValueBinding + \")\"));\n  addHandler(el, CHECKBOX_RADIO_TOKEN, \"var $$a=\" + value + \",\" + '$$el=$event.target,' + \"$$c=$$el.checked?(\" + trueValueBinding + \"):(\" + falseValueBinding + \");\" + 'if(Array.isArray($$a)){' + \"var $$v=\" + (number ? '_n(' + valueBinding + ')' : valueBinding) + \",\" + '$$i=_i($$a,$$v);' + \"if($$el.checked){$$i<0&&(\" + value + \"=$$a.concat($$v))}\" + \"else{$$i>-1&&(\" + value + \"=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}\" + \"}else{\" + genAssignmentCode(value, '$$c') + \"}\", null, true);\n}\n\nfunction genRadioModel(el, value, modifiers) {\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  valueBinding = number ? \"_n(\" + valueBinding + \")\" : valueBinding;\n  addProp(el, 'checked', \"_q(\" + value + \",\" + valueBinding + \")\");\n  addHandler(el, CHECKBOX_RADIO_TOKEN, genAssignmentCode(value, valueBinding), null, true);\n}\n\nfunction genSelect(el, value, modifiers) {\n  var number = modifiers && modifiers.number;\n  var selectedVal = \"Array.prototype.filter\" + \".call($event.target.options,function(o){return o.selected})\" + \".map(function(o){var val = \\\"_value\\\" in o ? o._value : o.value;\" + \"return \" + (number ? '_n(val)' : 'val') + \"})\";\n\n  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';\n  var code = \"var $$selectedVal = \" + selectedVal + \";\";\n  code = code + \" \" + genAssignmentCode(value, assignment);\n  addHandler(el, 'change', code, null, true);\n}\n\nfunction genDefaultModel(el, value, modifiers) {\n  var type = el.attrsMap.type;\n  var ref = modifiers || {};\n  var lazy = ref.lazy;\n  var number = ref.number;\n  var trim = ref.trim;\n  var needCompositionGuard = !lazy && type !== 'range';\n  var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';\n\n  var valueExpression = '$event.target.value';\n  if (trim) {\n    valueExpression = \"$event.target.value.trim()\";\n  }\n  if (number) {\n    valueExpression = \"_n(\" + valueExpression + \")\";\n  }\n\n  var code = genAssignmentCode(value, valueExpression);\n  if (needCompositionGuard) {\n    code = \"if($event.target.composing)return;\" + code;\n  }\n\n  addProp(el, 'value', \"(\" + value + \")\");\n  addHandler(el, event, code, null, true);\n  if (trim || number) {\n    addHandler(el, 'blur', '$forceUpdate()');\n  }\n}\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  var event;\n  /* istanbul ignore if */\n  if (isDef(on[RANGE_TOKEN])) {\n    // IE input[type=range] only supports `change` event\n    event = isIE ? 'change' : 'input';\n    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);\n    delete on[RANGE_TOKEN];\n  }\n  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {\n    // Chrome fires microtasks in between click/change, leads to #4521\n    event = isChrome ? 'click' : 'change';\n    on[event] = [].concat(on[CHECKBOX_RADIO_TOKEN], on[event] || []);\n    delete on[CHECKBOX_RADIO_TOKEN];\n  }\n}\n\nvar target$1;\n\nfunction add$1(event, _handler, once$$1, capture, passive) {\n  if (once$$1) {\n    var oldHandler = _handler;\n    var _target = target$1; // save current target element in closure\n    _handler = function handler(ev) {\n      var res = arguments.length === 1 ? oldHandler(ev) : oldHandler.apply(null, arguments);\n      if (res !== null) {\n        remove$2(event, _handler, capture, _target);\n      }\n    };\n  }\n  target$1.addEventListener(event, _handler, supportsPassive ? { capture: capture, passive: passive } : capture);\n}\n\nfunction remove$2(event, handler, capture, _target) {\n  (_target || target$1).removeEventListener(event, handler, capture);\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, vnode.context);\n}\n\nvar events = {\n  create: updateDOMListeners,\n  update: updateDOMListeners\n};\n\n/*  */\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) {\n        vnode.children.length = 0;\n      }\n      if (cur === oldProps[key]) {\n        continue;\n      }\n    }\n\n    if (key === 'value') {\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, vnode, strCur)) {\n        elm.value = strCur;\n      }\n    } else {\n      elm[key] = cur;\n    }\n  }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue(elm, vnode, checkVal) {\n  return !elm.composing && (vnode.tag === 'option' || isDirty(elm, checkVal) || isInputChanged(elm, checkVal));\n}\n\nfunction isDirty(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 {\n    notInFocus = document.activeElement !== elm;\n  } catch (e) {}\n  return notInFocus && elm.value !== checkVal;\n}\n\nfunction isInputChanged(elm, newVal) {\n  var value = elm.value;\n  var modifiers = elm._vModifiers; // injected by v-model runtime\n  if (isDef(modifiers) && modifiers.number) {\n    return toNumber(value) !== toNumber(newVal);\n  }\n  if (isDef(modifiers) && modifiers.trim) {\n    return value.trim() !== newVal.trim();\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 ? extend(data.staticStyle, style) : 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 (childNode.data && (styleData = normalizeStyleData(childNode.data))) {\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 setProp(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(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) && isUndef(oldData.staticStyle) && isUndef(oldData.style)) {\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 likley wants\n  // to mutate it.\n  vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : 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\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(/\\s+/).forEach(function (c) {\n        return el.classList.add(c);\n      });\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(/\\s+/).forEach(function (c) {\n        return el.classList.remove(c);\n      });\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 === 'undefined' ? 'undefined' : _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 && window.onwebkittransitionend !== undefined) {\n    transitionProp = 'WebkitTransition';\n    transitionEndEvent = 'webkitTransitionEnd';\n  }\n  if (window.onanimationend === undefined && window.onwebkitanimationend !== undefined) {\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 && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : setTimeout;\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(el, expectedType, cb) {\n  var ref = getTransitionInfo(el, expectedType);\n  var type = ref.type;\n  var timeout = ref.timeout;\n  var propCount = ref.propCount;\n  if (!type) {\n    return cb();\n  }\n  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n  var ended = 0;\n  var end = function end() {\n    el.removeEventListener(event, onEnd);\n    cb();\n  };\n  var onEnd = function onEnd(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  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 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;\n    propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;\n  }\n  var hasTransform = type === TRANSITION && 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\nfunction toMs(s) {\n  return Number(s.slice(0, -1)) * 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 ? appearClass : enterClass;\n  var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;\n  var toClass = isAppear && appearToClass ? appearToClass : enterToClass;\n\n  var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;\n  var enterHook = isAppear ? typeof appear === 'function' ? appear : enter : enter;\n  var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;\n  var enterCancelledHook = isAppear ? appearCancelled || enterCancelled : enterCancelled;\n\n  var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);\n\n  if (false) {\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.data.hook || (vnode.data.hook = {}), 'insert', function () {\n      var parent = el.parentNode;\n      var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n      if (pendingNode && pendingNode.tag === vnode.tag && pendingNode.elm._leaveCb) {\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      addTransitionClass(el, toClass);\n      removeTransitionClass(el, startClass);\n      if (!cb.cancelled && !userWantsControl) {\n        if (isValidDuration(explicitEnterDuration)) {\n          setTimeout(cb, explicitEnterDuration);\n        } else {\n          whenTransitionEnds(el, type, cb);\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)) {\n    return rm();\n  }\n\n  /* istanbul ignore if */\n  if (isDef(el._leaveCb) || el.nodeType !== 1) {\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(isObject(duration) ? duration.leave : duration);\n\n  if (false) {\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) {\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        addTransitionClass(el, leaveToClass);\n        removeTransitionClass(el, leaveClass);\n        if (!cb.cancelled && !userWantsControl) {\n          if (isValidDuration(explicitLeaveDuration)) {\n            setTimeout(cb, explicitLeaveDuration);\n          } else {\n            whenTransitionEnds(el, type, cb);\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(\"<transition> explicit \" + name + \" duration is not a valid number - \" + \"got \" + JSON.stringify(val) + \".\", vnode.context);\n  } else if (isNaN(val)) {\n    warn(\"<transition> explicit \" + name + \" duration is NaN - \" + 'the duration expression might be incorrect.', vnode.context);\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(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);\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 = [attrs, klass, events, domProps, style, transition];\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\nvar isTextInputType = makeMap('text,number,password,search,email,tel,url');\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 model$1 = {\n  inserted: function inserted(el, binding, vnode) {\n    if (vnode.tag === 'select') {\n      var cb = function cb() {\n        setSelected(el, binding, vnode.context);\n      };\n      cb();\n      /* istanbul ignore if */\n      if (isIE || isEdge) {\n        setTimeout(cb, 0);\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        // 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        if (!isAndroid) {\n          el.addEventListener('compositionstart', onCompositionStart);\n          el.addEventListener('compositionend', onCompositionEnd);\n        }\n        /* istanbul ignore if */\n        if (isIE9) {\n          el.vmodel = true;\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) {\n        return !looseEqual(o, prevOptions[i]);\n      })) {\n        trigger(el, 'change');\n      }\n    }\n  }\n};\n\nfunction setSelected(el, binding, vm) {\n  var value = binding.value;\n  var isMultiple = el.multiple;\n  if (isMultiple && !Array.isArray(value)) {\n    \"production\" !== 'production' && warn(\"<select multiple v-model=\\\"\" + binding.expression + \"\\\"> \" + \"expects an Array value for its binding, but got \" + Object.prototype.toString.call(value).slice(8, -1), vm);\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 getValue(option) {\n  return '_value' in option ? option._value : 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) {\n    return;\n  }\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) ? locateNode(vnode.componentInstance._vnode) : 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 = 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) {\n      return;\n    }\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(el, binding, vnode, oldVnode, isDestroy) {\n    if (!isDestroy) {\n      el.style.display = el.__vOriginalDisplay;\n    }\n  }\n};\n\nvar platformDirectives = {\n  model: model$1,\n  show: show\n};\n\n/*  */\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\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\nfunction isAsyncPlaceholder(node) {\n  return node.isComment && node.asyncFactory;\n}\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.$options._renderChildren;\n    if (!children) {\n      return;\n    }\n\n    // filter out text nodes (possible whitespaces)\n    children = children.filter(function (c) {\n      return c.tag || isAsyncPlaceholder(c);\n    });\n    /* istanbul ignore if */\n    if (!children.length) {\n      return;\n    }\n\n    // warn multiple elements\n    if (false) {\n      warn('<transition> can only be used on a single element. Use ' + '<transition-group> for lists.', this.$parent);\n    }\n\n    var mode = this.mode;\n\n    // warn invalid mode\n    if (false) {\n      warn('invalid <transition> mode: ' + mode, this.$parent);\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 ? child.isComment ? id + 'comment' : id + child.tag : isPrimitive(child.key) ? String(child.key).indexOf(id) === 0 ? child.key : id + child.key : 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(function (d) {\n      return d.name === 'show';\n    })) {\n      child.data.show = true;\n    }\n\n    if (oldChild && oldChild.data && !isSameChild(child, oldChild) && !isAsyncPlaceholder(oldChild)) {\n      // replace old child transition data with fresh one\n      // important for dynamic transitions!\n      var oldData = oldChild && (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 performLeave() {\n          delayedLeave();\n        };\n        mergeVNodeHook(data, 'afterEnter', performLeave);\n        mergeVNodeHook(data, 'enterCancelled', performLeave);\n        mergeVNodeHook(oldData, 'delayLeave', function (leave) {\n          delayedLeave = leave;\n        });\n      }\n    }\n\n    return rawChild;\n  }\n};\n\n/*  */\n\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final desired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = extend({\n  tag: String,\n  moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n  props: props,\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;(c.data || (c.data = {})).transition = transitionData;\n        } else if (false) {\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  beforeUpdate: function beforeUpdate() {\n    // force removing pass\n    this.__patch__(this._vnode, this.kept, false, // hydrating\n    true // removeOnly (!important, avoids unnecessary moves)\n    );\n    this._vnode = this.kept;\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    var body = document.body;\n    var f = body.offsetHeight; // eslint-disable-line\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 || /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) {\n          removeClass(clone, cls);\n        });\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$3.config.mustUseProp = mustUseProp;\nVue$3.config.isReservedTag = isReservedTag;\nVue$3.config.isReservedAttr = isReservedAttr;\nVue$3.config.getTagNamespace = getTagNamespace;\nVue$3.config.isUnknownElement = isUnknownElement;\n\n// install platform runtime directives & components\nextend(Vue$3.options.directives, platformDirectives);\nextend(Vue$3.options.components, platformComponents);\n\n// install platform patch function\nVue$3.prototype.__patch__ = inBrowser ? patch : noop;\n\n// public mount method\nVue$3.prototype.$mount = function (el, hydrating) {\n  el = el && inBrowser ? query(el) : undefined;\n  return mountComponent(this, el, hydrating);\n};\n\n// devtools global hook\n/* istanbul ignore next */\nsetTimeout(function () {\n  if (config.devtools) {\n    if (devtools) {\n      devtools.emit('init', Vue$3);\n    } else if (false) {\n      console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\\n' + 'https://github.com/vuejs/vue-devtools');\n    }\n  }\n  if (false) {\n    console[console.info ? 'info' : 'log'](\"You are running Vue in development mode.\\n\" + \"Make sure to turn on production mode when deploying for production.\\n\" + \"See more tips at https://vuejs.org/guide/deployment.html\");\n  }\n}, 0);\n\n/*  */\n\n// check whether current browser encodes a char inside attribute values\nfunction shouldDecode(content, encoded) {\n  var div = document.createElement('div');\n  div.innerHTML = \"<div a=\\\"\" + content + \"\\\"/>\";\n  return div.innerHTML.indexOf(encoded) > 0;\n}\n\n// #3663\n// IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? shouldDecode('\\n', '&#10;') : false;\n\n/*  */\n\nvar defaultTagRE = /\\{\\{((?:.|\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = cached(function (delimiters) {\n  var open = delimiters[0].replace(regexEscapeRE, '\\\\$&');\n  var close = delimiters[1].replace(regexEscapeRE, '\\\\$&');\n  return new RegExp(open + '((?:.|\\\\n)+?)' + close, 'g');\n});\n\nfunction parseText(text, delimiters) {\n  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;\n  if (!tagRE.test(text)) {\n    return;\n  }\n  var tokens = [];\n  var lastIndex = tagRE.lastIndex = 0;\n  var match, index;\n  while (match = tagRE.exec(text)) {\n    index = match.index;\n    // push text token\n    if (index > lastIndex) {\n      tokens.push(JSON.stringify(text.slice(lastIndex, index)));\n    }\n    // tag token\n    var exp = parseFilters(match[1].trim());\n    tokens.push(\"_s(\" + exp + \")\");\n    lastIndex = index + match[0].length;\n  }\n  if (lastIndex < text.length) {\n    tokens.push(JSON.stringify(text.slice(lastIndex)));\n  }\n  return tokens.join('+');\n}\n\n/*  */\n\nfunction transformNode(el, options) {\n  var warn = options.warn || baseWarn;\n  var staticClass = getAndRemoveAttr(el, 'class');\n  if (false) {\n    var expression = parseText(staticClass, options.delimiters);\n    if (expression) {\n      warn(\"class=\\\"\" + staticClass + \"\\\": \" + 'Interpolation inside attributes has been removed. ' + 'Use v-bind or the colon shorthand instead. For example, ' + 'instead of <div class=\"{{ val }}\">, use <div :class=\"val\">.');\n    }\n  }\n  if (staticClass) {\n    el.staticClass = JSON.stringify(staticClass);\n  }\n  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);\n  if (classBinding) {\n    el.classBinding = classBinding;\n  }\n}\n\nfunction genData(el) {\n  var data = '';\n  if (el.staticClass) {\n    data += \"staticClass:\" + el.staticClass + \",\";\n  }\n  if (el.classBinding) {\n    data += \"class:\" + el.classBinding + \",\";\n  }\n  return data;\n}\n\nvar klass$1 = {\n  staticKeys: ['staticClass'],\n  transformNode: transformNode,\n  genData: genData\n};\n\n/*  */\n\nfunction transformNode$1(el, options) {\n  var warn = options.warn || baseWarn;\n  var staticStyle = getAndRemoveAttr(el, 'style');\n  if (staticStyle) {\n    /* istanbul ignore if */\n    if (false) {\n      var expression = parseText(staticStyle, options.delimiters);\n      if (expression) {\n        warn(\"style=\\\"\" + staticStyle + \"\\\": \" + 'Interpolation inside attributes has been removed. ' + 'Use v-bind or the colon shorthand instead. For example, ' + 'instead of <div style=\"{{ val }}\">, use <div :style=\"val\">.');\n      }\n    }\n    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));\n  }\n\n  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);\n  if (styleBinding) {\n    el.styleBinding = styleBinding;\n  }\n}\n\nfunction genData$1(el) {\n  var data = '';\n  if (el.staticStyle) {\n    data += \"staticStyle:\" + el.staticStyle + \",\";\n  }\n  if (el.styleBinding) {\n    data += \"style:(\" + el.styleBinding + \"),\";\n  }\n  return data;\n}\n\nvar style$1 = {\n  staticKeys: ['staticStyle'],\n  transformNode: transformNode$1,\n  genData: genData$1\n};\n\nvar modules$1 = [klass$1, style$1];\n\n/*  */\n\nfunction text(el, dir) {\n  if (dir.value) {\n    addProp(el, 'textContent', \"_s(\" + dir.value + \")\");\n  }\n}\n\n/*  */\n\nfunction html(el, dir) {\n  if (dir.value) {\n    addProp(el, 'innerHTML', \"_s(\" + dir.value + \")\");\n  }\n}\n\nvar directives$1 = {\n  model: model,\n  text: text,\n  html: html\n};\n\n/*  */\n\nvar isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' + 'link,meta,param,source,track,wbr');\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\nvar canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');\n\n// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3\n// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content\nvar isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' + 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' + 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' + 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' + 'title,tr,track');\n\n/*  */\n\nvar baseOptions = {\n  expectHTML: true,\n  modules: modules$1,\n  directives: directives$1,\n  isPreTag: isPreTag,\n  isUnaryTag: isUnaryTag,\n  mustUseProp: mustUseProp,\n  canBeLeftOpenTag: canBeLeftOpenTag,\n  isReservedTag: isReservedTag,\n  getTagNamespace: getTagNamespace,\n  staticKeys: genStaticKeys(modules$1)\n};\n\n/*  */\n\nvar decoder;\n\nvar he = {\n  decode: function decode(html) {\n    decoder = decoder || document.createElement('div');\n    decoder.innerHTML = html;\n    return decoder.textContent;\n  }\n};\n\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n/*!\n * HTML Parser By John Resig (ejohn.org)\n * Modified by Juriy \"kangax\" Zaytsev\n * Original code by Erik Arvidsson, Mozilla Public License\n * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js\n */\n\n// Regular Expressions for parsing tags and attributes\nvar singleAttrIdentifier = /([^\\s\"'<>/=]+)/;\nvar singleAttrAssign = /(?:=)/;\nvar singleAttrValues = [\n// attr value double quotes\n/\"([^\"]*)\"+/.source,\n// attr value, single quotes\n/'([^']*)'+/.source,\n// attr value, no quotes\n/([^\\s\"'=<>`]+)/.source];\nvar attribute = new RegExp('^\\\\s*' + singleAttrIdentifier.source + '(?:\\\\s*(' + singleAttrAssign.source + ')' + '\\\\s*(?:' + singleAttrValues.join('|') + '))?');\n\n// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName\n// but for Vue templates we can enforce a simple charset\nvar ncname = '[a-zA-Z_][\\\\w\\\\-\\\\.]*';\nvar qnameCapture = '((?:' + ncname + '\\\\:)?' + ncname + ')';\nvar startTagOpen = new RegExp('^<' + qnameCapture);\nvar startTagClose = /^\\s*(\\/?)>/;\nvar endTag = new RegExp('^<\\\\/' + qnameCapture + '[^>]*>');\nvar doctype = /^<!DOCTYPE [^>]+>/i;\nvar comment = /^<!--/;\nvar conditionalComment = /^<!\\[/;\n\nvar IS_REGEX_CAPTURING_BROKEN = false;\n'x'.replace(/x(.)?/g, function (m, g) {\n  IS_REGEX_CAPTURING_BROKEN = g === '';\n});\n\n// Special Elements (can contain anything)\nvar isPlainTextElement = makeMap('script,style,textarea', true);\nvar reCache = {};\n\nvar decodingMap = {\n  '&lt;': '<',\n  '&gt;': '>',\n  '&quot;': '\"',\n  '&amp;': '&',\n  '&#10;': '\\n'\n};\nvar encodedAttr = /&(?:lt|gt|quot|amp);/g;\nvar encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#10);/g;\n\n// #5992\nvar isIgnoreNewlineTag = makeMap('pre,textarea', true);\nvar shouldIgnoreFirstNewline = function shouldIgnoreFirstNewline(tag, html) {\n  return tag && isIgnoreNewlineTag(tag) && html[0] === '\\n';\n};\n\nfunction decodeAttr(value, shouldDecodeNewlines) {\n  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;\n  return value.replace(re, function (match) {\n    return decodingMap[match];\n  });\n}\n\nfunction parseHTML(html, options) {\n  var stack = [];\n  var expectHTML = options.expectHTML;\n  var isUnaryTag$$1 = options.isUnaryTag || no;\n  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;\n  var index = 0;\n  var last, lastTag;\n  while (html) {\n    last = html;\n    // Make sure we're not in a plaintext content element like script/style\n    if (!lastTag || !isPlainTextElement(lastTag)) {\n      var textEnd = html.indexOf('<');\n      if (textEnd === 0) {\n        // Comment:\n        if (comment.test(html)) {\n          var commentEnd = html.indexOf('-->');\n\n          if (commentEnd >= 0) {\n            if (options.shouldKeepComment) {\n              options.comment(html.substring(4, commentEnd));\n            }\n            advance(commentEnd + 3);\n            continue;\n          }\n        }\n\n        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n        if (conditionalComment.test(html)) {\n          var conditionalEnd = html.indexOf(']>');\n\n          if (conditionalEnd >= 0) {\n            advance(conditionalEnd + 2);\n            continue;\n          }\n        }\n\n        // Doctype:\n        var doctypeMatch = html.match(doctype);\n        if (doctypeMatch) {\n          advance(doctypeMatch[0].length);\n          continue;\n        }\n\n        // End tag:\n        var endTagMatch = html.match(endTag);\n        if (endTagMatch) {\n          var curIndex = index;\n          advance(endTagMatch[0].length);\n          parseEndTag(endTagMatch[1], curIndex, index);\n          continue;\n        }\n\n        // Start tag:\n        var startTagMatch = parseStartTag();\n        if (startTagMatch) {\n          handleStartTag(startTagMatch);\n          if (shouldIgnoreFirstNewline(lastTag, html)) {\n            advance(1);\n          }\n          continue;\n        }\n      }\n\n      var text = void 0,\n          rest = void 0,\n          next = void 0;\n      if (textEnd >= 0) {\n        rest = html.slice(textEnd);\n        while (!endTag.test(rest) && !startTagOpen.test(rest) && !comment.test(rest) && !conditionalComment.test(rest)) {\n          // < in plain text, be forgiving and treat it as text\n          next = rest.indexOf('<', 1);\n          if (next < 0) {\n            break;\n          }\n          textEnd += next;\n          rest = html.slice(textEnd);\n        }\n        text = html.substring(0, textEnd);\n        advance(textEnd);\n      }\n\n      if (textEnd < 0) {\n        text = html;\n        html = '';\n      }\n\n      if (options.chars && text) {\n        options.chars(text);\n      }\n    } else {\n      var endTagLength = 0;\n      var stackedTag = lastTag.toLowerCase();\n      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\\\s\\\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));\n      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {\n        endTagLength = endTag.length;\n        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {\n          text = text.replace(/<!--([\\s\\S]*?)-->/g, '$1').replace(/<!\\[CDATA\\[([\\s\\S]*?)]]>/g, '$1');\n        }\n        if (shouldIgnoreFirstNewline(stackedTag, text)) {\n          text = text.slice(1);\n        }\n        if (options.chars) {\n          options.chars(text);\n        }\n        return '';\n      });\n      index += html.length - rest$1.length;\n      html = rest$1;\n      parseEndTag(stackedTag, index - endTagLength, index);\n    }\n\n    if (html === last) {\n      options.chars && options.chars(html);\n      if (false) {\n        options.warn(\"Mal-formatted tag at end of template: \\\"\" + html + \"\\\"\");\n      }\n      break;\n    }\n  }\n\n  // Clean up any remaining tags\n  parseEndTag();\n\n  function advance(n) {\n    index += n;\n    html = html.substring(n);\n  }\n\n  function parseStartTag() {\n    var start = html.match(startTagOpen);\n    if (start) {\n      var match = {\n        tagName: start[1],\n        attrs: [],\n        start: index\n      };\n      advance(start[0].length);\n      var end, attr;\n      while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {\n        advance(attr[0].length);\n        match.attrs.push(attr);\n      }\n      if (end) {\n        match.unarySlash = end[1];\n        advance(end[0].length);\n        match.end = index;\n        return match;\n      }\n    }\n  }\n\n  function handleStartTag(match) {\n    var tagName = match.tagName;\n    var unarySlash = match.unarySlash;\n\n    if (expectHTML) {\n      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {\n        parseEndTag(lastTag);\n      }\n      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {\n        parseEndTag(tagName);\n      }\n    }\n\n    var unary = isUnaryTag$$1(tagName) || !!unarySlash;\n\n    var l = match.attrs.length;\n    var attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      var args = match.attrs[i];\n      // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n      if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('\"\"') === -1) {\n        if (args[3] === '') {\n          delete args[3];\n        }\n        if (args[4] === '') {\n          delete args[4];\n        }\n        if (args[5] === '') {\n          delete args[5];\n        }\n      }\n      var value = args[3] || args[4] || args[5] || '';\n      attrs[i] = {\n        name: args[1],\n        value: decodeAttr(value, options.shouldDecodeNewlines)\n      };\n    }\n\n    if (!unary) {\n      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs });\n      lastTag = tagName;\n    }\n\n    if (options.start) {\n      options.start(tagName, attrs, unary, match.start, match.end);\n    }\n  }\n\n  function parseEndTag(tagName, start, end) {\n    var pos, lowerCasedTagName;\n    if (start == null) {\n      start = index;\n    }\n    if (end == null) {\n      end = index;\n    }\n\n    if (tagName) {\n      lowerCasedTagName = tagName.toLowerCase();\n    }\n\n    // Find the closest opened tag of the same type\n    if (tagName) {\n      for (pos = stack.length - 1; pos >= 0; pos--) {\n        if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n          break;\n        }\n      }\n    } else {\n      // If no tag name is provided, clean shop\n      pos = 0;\n    }\n\n    if (pos >= 0) {\n      // Close all the open elements, up the stack\n      for (var i = stack.length - 1; i >= pos; i--) {\n        if (false) {\n          options.warn(\"tag <\" + stack[i].tag + \"> has no matching end tag.\");\n        }\n        if (options.end) {\n          options.end(stack[i].tag, start, end);\n        }\n      }\n\n      // Remove the open elements from the stack\n      stack.length = pos;\n      lastTag = pos && stack[pos - 1].tag;\n    } else if (lowerCasedTagName === 'br') {\n      if (options.start) {\n        options.start(tagName, [], true, start, end);\n      }\n    } else if (lowerCasedTagName === 'p') {\n      if (options.start) {\n        options.start(tagName, [], false, start, end);\n      }\n      if (options.end) {\n        options.end(tagName, start, end);\n      }\n    }\n  }\n}\n\n/*  */\n\nvar onRE = /^@|^v-on:/;\nvar dirRE = /^v-|^@|^:/;\nvar forAliasRE = /(.*?)\\s+(?:in|of)\\s+(.*)/;\nvar forIteratorRE = /\\((\\{[^}]*\\}|[^,]*),([^,]*)(?:,([^,]*))?\\)/;\n\nvar argRE = /:(.*)$/;\nvar bindRE = /^:|^v-bind:/;\nvar modifierRE = /\\.[^.]+/g;\n\nvar decodeHTMLCached = cached(he.decode);\n\n// configurable state\nvar warn$2;\nvar delimiters;\nvar transforms;\nvar preTransforms;\nvar postTransforms;\nvar platformIsPreTag;\nvar platformMustUseProp;\nvar platformGetTagNamespace;\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse(template, options) {\n  warn$2 = options.warn || baseWarn;\n\n  platformIsPreTag = options.isPreTag || no;\n  platformMustUseProp = options.mustUseProp || no;\n  platformGetTagNamespace = options.getTagNamespace || no;\n\n  transforms = pluckModuleFunction(options.modules, 'transformNode');\n  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');\n  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');\n\n  delimiters = options.delimiters;\n\n  var stack = [];\n  var preserveWhitespace = options.preserveWhitespace !== false;\n  var root;\n  var currentParent;\n  var inVPre = false;\n  var inPre = false;\n  var warned = false;\n\n  function warnOnce(msg) {\n    if (!warned) {\n      warned = true;\n      warn$2(msg);\n    }\n  }\n\n  function endPre(element) {\n    // check pre state\n    if (element.pre) {\n      inVPre = false;\n    }\n    if (platformIsPreTag(element.tag)) {\n      inPre = false;\n    }\n  }\n\n  parseHTML(template, {\n    warn: warn$2,\n    expectHTML: options.expectHTML,\n    isUnaryTag: options.isUnaryTag,\n    canBeLeftOpenTag: options.canBeLeftOpenTag,\n    shouldDecodeNewlines: options.shouldDecodeNewlines,\n    shouldKeepComment: options.comments,\n    start: function start(tag, attrs, unary) {\n      // check namespace.\n      // inherit parent ns if there is one\n      var ns = currentParent && currentParent.ns || platformGetTagNamespace(tag);\n\n      // handle IE svg bug\n      /* istanbul ignore if */\n      if (isIE && ns === 'svg') {\n        attrs = guardIESVGBug(attrs);\n      }\n\n      var element = {\n        type: 1,\n        tag: tag,\n        attrsList: attrs,\n        attrsMap: makeAttrsMap(attrs),\n        parent: currentParent,\n        children: []\n      };\n      if (ns) {\n        element.ns = ns;\n      }\n\n      if (isForbiddenTag(element) && !isServerRendering()) {\n        element.forbidden = true;\n        \"production\" !== 'production' && warn$2('Templates should only be responsible for mapping the state to the ' + 'UI. Avoid placing tags with side-effects in your templates, such as ' + \"<\" + tag + \">\" + ', as they will not be parsed.');\n      }\n\n      // apply pre-transforms\n      for (var i = 0; i < preTransforms.length; i++) {\n        preTransforms[i](element, options);\n      }\n\n      if (!inVPre) {\n        processPre(element);\n        if (element.pre) {\n          inVPre = true;\n        }\n      }\n      if (platformIsPreTag(element.tag)) {\n        inPre = true;\n      }\n      if (inVPre) {\n        processRawAttrs(element);\n      } else {\n        processFor(element);\n        processIf(element);\n        processOnce(element);\n        processKey(element);\n\n        // determine whether this is a plain element after\n        // removing structural attributes\n        element.plain = !element.key && !attrs.length;\n\n        processRef(element);\n        processSlot(element);\n        processComponent(element);\n        for (var i$1 = 0; i$1 < transforms.length; i$1++) {\n          transforms[i$1](element, options);\n        }\n        processAttrs(element);\n      }\n\n      function checkRootConstraints(el) {\n        if (false) {\n          if (el.tag === 'slot' || el.tag === 'template') {\n            warnOnce(\"Cannot use <\" + el.tag + \"> as component root element because it may \" + 'contain multiple nodes.');\n          }\n          if (el.attrsMap.hasOwnProperty('v-for')) {\n            warnOnce('Cannot use v-for on stateful component root element because ' + 'it renders multiple elements.');\n          }\n        }\n      }\n\n      // tree management\n      if (!root) {\n        root = element;\n        checkRootConstraints(root);\n      } else if (!stack.length) {\n        // allow root elements with v-if, v-else-if and v-else\n        if (root.if && (element.elseif || element.else)) {\n          checkRootConstraints(element);\n          addIfCondition(root, {\n            exp: element.elseif,\n            block: element\n          });\n        } else if (false) {\n          warnOnce(\"Component template should contain exactly one root element. \" + \"If you are using v-if on multiple elements, \" + \"use v-else-if to chain them instead.\");\n        }\n      }\n      if (currentParent && !element.forbidden) {\n        if (element.elseif || element.else) {\n          processIfConditions(element, currentParent);\n        } else if (element.slotScope) {\n          // scoped slot\n          currentParent.plain = false;\n          var name = element.slotTarget || '\"default\"';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;\n        } else {\n          currentParent.children.push(element);\n          element.parent = currentParent;\n        }\n      }\n      if (!unary) {\n        currentParent = element;\n        stack.push(element);\n      } else {\n        endPre(element);\n      }\n      // apply post-transforms\n      for (var i$2 = 0; i$2 < postTransforms.length; i$2++) {\n        postTransforms[i$2](element, options);\n      }\n    },\n\n    end: function end() {\n      // remove trailing whitespace\n      var element = stack[stack.length - 1];\n      var lastNode = element.children[element.children.length - 1];\n      if (lastNode && lastNode.type === 3 && lastNode.text === ' ' && !inPre) {\n        element.children.pop();\n      }\n      // pop stack\n      stack.length -= 1;\n      currentParent = stack[stack.length - 1];\n      endPre(element);\n    },\n\n    chars: function chars(text) {\n      if (!currentParent) {\n        if (false) {\n          if (text === template) {\n            warnOnce('Component template requires a root element, rather than just text.');\n          } else if (text = text.trim()) {\n            warnOnce(\"text \\\"\" + text + \"\\\" outside root element will be ignored.\");\n          }\n        }\n        return;\n      }\n      // IE textarea placeholder bug\n      /* istanbul ignore if */\n      if (isIE && currentParent.tag === 'textarea' && currentParent.attrsMap.placeholder === text) {\n        return;\n      }\n      var children = currentParent.children;\n      text = inPre || text.trim() ? isTextTag(currentParent) ? text : decodeHTMLCached(text)\n      // only preserve whitespace if its not right after a starting tag\n      : preserveWhitespace && children.length ? ' ' : '';\n      if (text) {\n        var expression;\n        if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) {\n          children.push({\n            type: 2,\n            expression: expression,\n            text: text\n          });\n        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {\n          children.push({\n            type: 3,\n            text: text\n          });\n        }\n      }\n    },\n    comment: function comment(text) {\n      currentParent.children.push({\n        type: 3,\n        text: text,\n        isComment: true\n      });\n    }\n  });\n  return root;\n}\n\nfunction processPre(el) {\n  if (getAndRemoveAttr(el, 'v-pre') != null) {\n    el.pre = true;\n  }\n}\n\nfunction processRawAttrs(el) {\n  var l = el.attrsList.length;\n  if (l) {\n    var attrs = el.attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      attrs[i] = {\n        name: el.attrsList[i].name,\n        value: JSON.stringify(el.attrsList[i].value)\n      };\n    }\n  } else if (!el.pre) {\n    // non root node in pre blocks with no attributes\n    el.plain = true;\n  }\n}\n\nfunction processKey(el) {\n  var exp = getBindingAttr(el, 'key');\n  if (exp) {\n    if (false) {\n      warn$2(\"<template> cannot be keyed. Place the key on real elements instead.\");\n    }\n    el.key = exp;\n  }\n}\n\nfunction processRef(el) {\n  var ref = getBindingAttr(el, 'ref');\n  if (ref) {\n    el.ref = ref;\n    el.refInFor = checkInFor(el);\n  }\n}\n\nfunction processFor(el) {\n  var exp;\n  if (exp = getAndRemoveAttr(el, 'v-for')) {\n    var inMatch = exp.match(forAliasRE);\n    if (!inMatch) {\n      \"production\" !== 'production' && warn$2(\"Invalid v-for expression: \" + exp);\n      return;\n    }\n    el.for = inMatch[2].trim();\n    var alias = inMatch[1].trim();\n    var iteratorMatch = alias.match(forIteratorRE);\n    if (iteratorMatch) {\n      el.alias = iteratorMatch[1].trim();\n      el.iterator1 = iteratorMatch[2].trim();\n      if (iteratorMatch[3]) {\n        el.iterator2 = iteratorMatch[3].trim();\n      }\n    } else {\n      el.alias = alias;\n    }\n  }\n}\n\nfunction processIf(el) {\n  var exp = getAndRemoveAttr(el, 'v-if');\n  if (exp) {\n    el.if = exp;\n    addIfCondition(el, {\n      exp: exp,\n      block: el\n    });\n  } else {\n    if (getAndRemoveAttr(el, 'v-else') != null) {\n      el.else = true;\n    }\n    var elseif = getAndRemoveAttr(el, 'v-else-if');\n    if (elseif) {\n      el.elseif = elseif;\n    }\n  }\n}\n\nfunction processIfConditions(el, parent) {\n  var prev = findPrevElement(parent.children);\n  if (prev && prev.if) {\n    addIfCondition(prev, {\n      exp: el.elseif,\n      block: el\n    });\n  } else if (false) {\n    warn$2(\"v-\" + (el.elseif ? 'else-if=\"' + el.elseif + '\"' : 'else') + \" \" + \"used on element <\" + el.tag + \"> without corresponding v-if.\");\n  }\n}\n\nfunction findPrevElement(children) {\n  var i = children.length;\n  while (i--) {\n    if (children[i].type === 1) {\n      return children[i];\n    } else {\n      if (false) {\n        warn$2(\"text \\\"\" + children[i].text.trim() + \"\\\" between v-if and v-else(-if) \" + \"will be ignored.\");\n      }\n      children.pop();\n    }\n  }\n}\n\nfunction addIfCondition(el, condition) {\n  if (!el.ifConditions) {\n    el.ifConditions = [];\n  }\n  el.ifConditions.push(condition);\n}\n\nfunction processOnce(el) {\n  var once$$1 = getAndRemoveAttr(el, 'v-once');\n  if (once$$1 != null) {\n    el.once = true;\n  }\n}\n\nfunction processSlot(el) {\n  if (el.tag === 'slot') {\n    el.slotName = getBindingAttr(el, 'name');\n    if (false) {\n      warn$2(\"`key` does not work on <slot> because slots are abstract outlets \" + \"and can possibly expand into multiple elements. \" + \"Use the key on a wrapping element instead.\");\n    }\n  } else {\n    var slotTarget = getBindingAttr(el, 'slot');\n    if (slotTarget) {\n      el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n    }\n    if (el.tag === 'template') {\n      el.slotScope = getAndRemoveAttr(el, 'scope');\n    }\n  }\n}\n\nfunction processComponent(el) {\n  var binding;\n  if (binding = getBindingAttr(el, 'is')) {\n    el.component = binding;\n  }\n  if (getAndRemoveAttr(el, 'inline-template') != null) {\n    el.inlineTemplate = true;\n  }\n}\n\nfunction processAttrs(el) {\n  var list = el.attrsList;\n  var i, l, name, rawName, value, modifiers, isProp;\n  for (i = 0, l = list.length; i < l; i++) {\n    name = rawName = list[i].name;\n    value = list[i].value;\n    if (dirRE.test(name)) {\n      // mark element as dynamic\n      el.hasBindings = true;\n      // modifiers\n      modifiers = parseModifiers(name);\n      if (modifiers) {\n        name = name.replace(modifierRE, '');\n      }\n      if (bindRE.test(name)) {\n        // v-bind\n        name = name.replace(bindRE, '');\n        value = parseFilters(value);\n        isProp = false;\n        if (modifiers) {\n          if (modifiers.prop) {\n            isProp = true;\n            name = camelize(name);\n            if (name === 'innerHtml') {\n              name = 'innerHTML';\n            }\n          }\n          if (modifiers.camel) {\n            name = camelize(name);\n          }\n          if (modifiers.sync) {\n            addHandler(el, \"update:\" + camelize(name), genAssignmentCode(value, \"$event\"));\n          }\n        }\n        if (isProp || !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n          addProp(el, name, value);\n        } else {\n          addAttr(el, name, value);\n        }\n      } else if (onRE.test(name)) {\n        // v-on\n        name = name.replace(onRE, '');\n        addHandler(el, name, value, modifiers, false, warn$2);\n      } else {\n        // normal directives\n        name = name.replace(dirRE, '');\n        // parse arg\n        var argMatch = name.match(argRE);\n        var arg = argMatch && argMatch[1];\n        if (arg) {\n          name = name.slice(0, -(arg.length + 1));\n        }\n        addDirective(el, name, rawName, value, arg, modifiers);\n        if (false) {\n          checkForAliasModel(el, value);\n        }\n      }\n    } else {\n      // literal attribute\n      if (false) {\n        var expression = parseText(value, delimiters);\n        if (expression) {\n          warn$2(name + \"=\\\"\" + value + \"\\\": \" + 'Interpolation inside attributes has been removed. ' + 'Use v-bind or the colon shorthand instead. For example, ' + 'instead of <div id=\"{{ val }}\">, use <div :id=\"val\">.');\n        }\n      }\n      addAttr(el, name, JSON.stringify(value));\n    }\n  }\n}\n\nfunction checkInFor(el) {\n  var parent = el;\n  while (parent) {\n    if (parent.for !== undefined) {\n      return true;\n    }\n    parent = parent.parent;\n  }\n  return false;\n}\n\nfunction parseModifiers(name) {\n  var match = name.match(modifierRE);\n  if (match) {\n    var ret = {};\n    match.forEach(function (m) {\n      ret[m.slice(1)] = true;\n    });\n    return ret;\n  }\n}\n\nfunction makeAttrsMap(attrs) {\n  var map = {};\n  for (var i = 0, l = attrs.length; i < l; i++) {\n    if (false) {\n      warn$2('duplicate attribute: ' + attrs[i].name);\n    }\n    map[attrs[i].name] = attrs[i].value;\n  }\n  return map;\n}\n\n// for script (e.g. type=\"x/template\") or style, do not decode content\nfunction isTextTag(el) {\n  return el.tag === 'script' || el.tag === 'style';\n}\n\nfunction isForbiddenTag(el) {\n  return el.tag === 'style' || el.tag === 'script' && (!el.attrsMap.type || el.attrsMap.type === 'text/javascript');\n}\n\nvar ieNSBug = /^xmlns:NS\\d+/;\nvar ieNSPrefix = /^NS\\d+:/;\n\n/* istanbul ignore next */\nfunction guardIESVGBug(attrs) {\n  var res = [];\n  for (var i = 0; i < attrs.length; i++) {\n    var attr = attrs[i];\n    if (!ieNSBug.test(attr.name)) {\n      attr.name = attr.name.replace(ieNSPrefix, '');\n      res.push(attr);\n    }\n  }\n  return res;\n}\n\nfunction checkForAliasModel(el, value) {\n  var _el = el;\n  while (_el) {\n    if (_el.for && _el.alias === value) {\n      warn$2(\"<\" + el.tag + \" v-model=\\\"\" + value + \"\\\">: \" + \"You are binding v-model directly to a v-for iteration alias. \" + \"This will not be able to modify the v-for source array because \" + \"writing to the alias is like modifying a function local variable. \" + \"Consider using an array of objects and use v-model on an object property instead.\");\n    }\n    _el = _el.parent;\n  }\n}\n\n/*  */\n\nvar isStaticKey;\nvar isPlatformReservedTag;\n\nvar genStaticKeysCached = cached(genStaticKeys$1);\n\n/**\n * Goal of the optimizer: walk the generated template AST tree\n * and detect sub-trees that are purely static, i.e. parts of\n * the DOM that never needs to change.\n *\n * Once we detect these sub-trees, we can:\n *\n * 1. Hoist them into constants, so that we no longer need to\n *    create fresh nodes for them on each re-render;\n * 2. Completely skip them in the patching process.\n */\nfunction optimize(root, options) {\n  if (!root) {\n    return;\n  }\n  isStaticKey = genStaticKeysCached(options.staticKeys || '');\n  isPlatformReservedTag = options.isReservedTag || no;\n  // first pass: mark all non-static nodes.\n  markStatic$1(root);\n  // second pass: mark static roots.\n  markStaticRoots(root, false);\n}\n\nfunction genStaticKeys$1(keys) {\n  return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs' + (keys ? ',' + keys : ''));\n}\n\nfunction markStatic$1(node) {\n  node.static = isStatic(node);\n  if (node.type === 1) {\n    // do not make component slot content static. this avoids\n    // 1. components not able to mutate slot nodes\n    // 2. static slot content fails for hot-reloading\n    if (!isPlatformReservedTag(node.tag) && node.tag !== 'slot' && node.attrsMap['inline-template'] == null) {\n      return;\n    }\n    for (var i = 0, l = node.children.length; i < l; i++) {\n      var child = node.children[i];\n      markStatic$1(child);\n      if (!child.static) {\n        node.static = false;\n      }\n    }\n    if (node.ifConditions) {\n      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {\n        var block = node.ifConditions[i$1].block;\n        markStatic$1(block);\n        if (!block.static) {\n          node.static = false;\n        }\n      }\n    }\n  }\n}\n\nfunction markStaticRoots(node, isInFor) {\n  if (node.type === 1) {\n    if (node.static || node.once) {\n      node.staticInFor = isInFor;\n    }\n    // For a node to qualify as a static root, it should have children that\n    // are not just static text. Otherwise the cost of hoisting out will\n    // outweigh the benefits and it's better off to just always render it fresh.\n    if (node.static && node.children.length && !(node.children.length === 1 && node.children[0].type === 3)) {\n      node.staticRoot = true;\n      return;\n    } else {\n      node.staticRoot = false;\n    }\n    if (node.children) {\n      for (var i = 0, l = node.children.length; i < l; i++) {\n        markStaticRoots(node.children[i], isInFor || !!node.for);\n      }\n    }\n    if (node.ifConditions) {\n      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {\n        markStaticRoots(node.ifConditions[i$1].block, isInFor);\n      }\n    }\n  }\n}\n\nfunction isStatic(node) {\n  if (node.type === 2) {\n    // expression\n    return false;\n  }\n  if (node.type === 3) {\n    // text\n    return true;\n  }\n  return !!(node.pre || !node.hasBindings && // no dynamic bindings\n  !node.if && !node.for && // not v-if or v-for or v-else\n  !isBuiltInTag(node.tag) && // not a built-in\n  isPlatformReservedTag(node.tag) && // not a component\n  !isDirectChildOfTemplateFor(node) && Object.keys(node).every(isStaticKey));\n}\n\nfunction isDirectChildOfTemplateFor(node) {\n  while (node.parent) {\n    node = node.parent;\n    if (node.tag !== 'template') {\n      return false;\n    }\n    if (node.for) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/*  */\n\nvar fnExpRE = /^\\s*([\\w$_]+|\\([^)]*?\\))\\s*=>|^function\\s*\\(/;\nvar simplePathRE = /^\\s*[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?']|\\[\".*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*\\s*$/;\n\n// keyCode aliases\nvar keyCodes = {\n  esc: 27,\n  tab: 9,\n  enter: 13,\n  space: 32,\n  up: 38,\n  left: 37,\n  right: 39,\n  down: 40,\n  'delete': [8, 46]\n};\n\n// #4868: modifiers that prevent the execution of the listener\n// need to explicitly return null so that we can determine whether to remove\n// the listener for .once\nvar genGuard = function genGuard(condition) {\n  return \"if(\" + condition + \")return null;\";\n};\n\nvar modifierCode = {\n  stop: '$event.stopPropagation();',\n  prevent: '$event.preventDefault();',\n  self: genGuard(\"$event.target !== $event.currentTarget\"),\n  ctrl: genGuard(\"!$event.ctrlKey\"),\n  shift: genGuard(\"!$event.shiftKey\"),\n  alt: genGuard(\"!$event.altKey\"),\n  meta: genGuard(\"!$event.metaKey\"),\n  left: genGuard(\"'button' in $event && $event.button !== 0\"),\n  middle: genGuard(\"'button' in $event && $event.button !== 1\"),\n  right: genGuard(\"'button' in $event && $event.button !== 2\")\n};\n\nfunction genHandlers(events, isNative, warn) {\n  var res = isNative ? 'nativeOn:{' : 'on:{';\n  for (var name in events) {\n    var handler = events[name];\n    // #5330: warn click.right, since right clicks do not actually fire click events.\n    if (false) {\n      warn(\"Use \\\"contextmenu\\\" instead of \\\"click.right\\\" since right clicks \" + \"do not actually fire \\\"click\\\" events.\");\n    }\n    res += \"\\\"\" + name + \"\\\":\" + genHandler(name, handler) + \",\";\n  }\n  return res.slice(0, -1) + '}';\n}\n\nfunction genHandler(name, handler) {\n  if (!handler) {\n    return 'function(){}';\n  }\n\n  if (Array.isArray(handler)) {\n    return \"[\" + handler.map(function (handler) {\n      return genHandler(name, handler);\n    }).join(',') + \"]\";\n  }\n\n  var isMethodPath = simplePathRE.test(handler.value);\n  var isFunctionExpression = fnExpRE.test(handler.value);\n\n  if (!handler.modifiers) {\n    return isMethodPath || isFunctionExpression ? handler.value : \"function($event){\" + handler.value + \"}\"; // inline statement\n  } else {\n    var code = '';\n    var genModifierCode = '';\n    var keys = [];\n    for (var key in handler.modifiers) {\n      if (modifierCode[key]) {\n        genModifierCode += modifierCode[key];\n        // left/right\n        if (keyCodes[key]) {\n          keys.push(key);\n        }\n      } else {\n        keys.push(key);\n      }\n    }\n    if (keys.length) {\n      code += genKeyFilter(keys);\n    }\n    // Make sure modifiers like prevent and stop get executed after key filtering\n    if (genModifierCode) {\n      code += genModifierCode;\n    }\n    var handlerCode = isMethodPath ? handler.value + '($event)' : isFunctionExpression ? \"(\" + handler.value + \")($event)\" : handler.value;\n    return \"function($event){\" + code + handlerCode + \"}\";\n  }\n}\n\nfunction genKeyFilter(keys) {\n  return \"if(!('button' in $event)&&\" + keys.map(genFilterCode).join('&&') + \")return null;\";\n}\n\nfunction genFilterCode(key) {\n  var keyVal = parseInt(key, 10);\n  if (keyVal) {\n    return \"$event.keyCode!==\" + keyVal;\n  }\n  var alias = keyCodes[key];\n  return \"_k($event.keyCode,\" + JSON.stringify(key) + (alias ? ',' + JSON.stringify(alias) : '') + \")\";\n}\n\n/*  */\n\nfunction on(el, dir) {\n  if (false) {\n    warn(\"v-on without argument does not support modifiers.\");\n  }\n  el.wrapListeners = function (code) {\n    return \"_g(\" + code + \",\" + dir.value + \")\";\n  };\n}\n\n/*  */\n\nfunction bind$1(el, dir) {\n  el.wrapData = function (code) {\n    return \"_b(\" + code + \",'\" + el.tag + \"',\" + dir.value + \",\" + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + \")\";\n  };\n}\n\n/*  */\n\nvar baseDirectives = {\n  on: on,\n  bind: bind$1,\n  cloak: noop\n};\n\n/*  */\n\nvar CodegenState = function CodegenState(options) {\n  this.options = options;\n  this.warn = options.warn || baseWarn;\n  this.transforms = pluckModuleFunction(options.modules, 'transformCode');\n  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');\n  this.directives = extend(extend({}, baseDirectives), options.directives);\n  var isReservedTag = options.isReservedTag || no;\n  this.maybeComponent = function (el) {\n    return !isReservedTag(el.tag);\n  };\n  this.onceId = 0;\n  this.staticRenderFns = [];\n};\n\nfunction generate(ast, options) {\n  var state = new CodegenState(options);\n  var code = ast ? genElement(ast, state) : '_c(\"div\")';\n  return {\n    render: \"with(this){return \" + code + \"}\",\n    staticRenderFns: state.staticRenderFns\n  };\n}\n\nfunction genElement(el, state) {\n  if (el.staticRoot && !el.staticProcessed) {\n    return genStatic(el, state);\n  } else if (el.once && !el.onceProcessed) {\n    return genOnce(el, state);\n  } else if (el.for && !el.forProcessed) {\n    return genFor(el, state);\n  } else if (el.if && !el.ifProcessed) {\n    return genIf(el, state);\n  } else if (el.tag === 'template' && !el.slotTarget) {\n    return genChildren(el, state) || 'void 0';\n  } else if (el.tag === 'slot') {\n    return genSlot(el, state);\n  } else {\n    // component or element\n    var code;\n    if (el.component) {\n      code = genComponent(el.component, el, state);\n    } else {\n      var data = el.plain ? undefined : genData$2(el, state);\n\n      var children = el.inlineTemplate ? null : genChildren(el, state, true);\n      code = \"_c('\" + el.tag + \"'\" + (data ? \",\" + data : '') + (children ? \",\" + children : '') + \")\";\n    }\n    // module transforms\n    for (var i = 0; i < state.transforms.length; i++) {\n      code = state.transforms[i](el, code);\n    }\n    return code;\n  }\n}\n\n// hoist static sub-trees out\nfunction genStatic(el, state) {\n  el.staticProcessed = true;\n  state.staticRenderFns.push(\"with(this){return \" + genElement(el, state) + \"}\");\n  return \"_m(\" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + \")\";\n}\n\n// v-once\nfunction genOnce(el, state) {\n  el.onceProcessed = true;\n  if (el.if && !el.ifProcessed) {\n    return genIf(el, state);\n  } else if (el.staticInFor) {\n    var key = '';\n    var parent = el.parent;\n    while (parent) {\n      if (parent.for) {\n        key = parent.key;\n        break;\n      }\n      parent = parent.parent;\n    }\n    if (!key) {\n      \"production\" !== 'production' && state.warn(\"v-once can only be used inside v-for that is keyed. \");\n      return genElement(el, state);\n    }\n    return \"_o(\" + genElement(el, state) + \",\" + state.onceId++ + (key ? \",\" + key : \"\") + \")\";\n  } else {\n    return genStatic(el, state);\n  }\n}\n\nfunction genIf(el, state, altGen, altEmpty) {\n  el.ifProcessed = true; // avoid recursion\n  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);\n}\n\nfunction genIfConditions(conditions, state, altGen, altEmpty) {\n  if (!conditions.length) {\n    return altEmpty || '_e()';\n  }\n\n  var condition = conditions.shift();\n  if (condition.exp) {\n    return \"(\" + condition.exp + \")?\" + genTernaryExp(condition.block) + \":\" + genIfConditions(conditions, state, altGen, altEmpty);\n  } else {\n    return \"\" + genTernaryExp(condition.block);\n  }\n\n  // v-if with v-once should generate code like (a)?_m(0):_m(1)\n  function genTernaryExp(el) {\n    return altGen ? altGen(el, state) : el.once ? genOnce(el, state) : genElement(el, state);\n  }\n}\n\nfunction genFor(el, state, altGen, altHelper) {\n  var exp = el.for;\n  var alias = el.alias;\n  var iterator1 = el.iterator1 ? \",\" + el.iterator1 : '';\n  var iterator2 = el.iterator2 ? \",\" + el.iterator2 : '';\n\n  if (false) {\n    state.warn(\"<\" + el.tag + \" v-for=\\\"\" + alias + \" in \" + exp + \"\\\">: component lists rendered with \" + \"v-for should have explicit keys. \" + \"See https://vuejs.org/guide/list.html#key for more info.\", true /* tip */\n    );\n  }\n\n  el.forProcessed = true; // avoid recursion\n  return (altHelper || '_l') + \"((\" + exp + \"),\" + \"function(\" + alias + iterator1 + iterator2 + \"){\" + \"return \" + (altGen || genElement)(el, state) + '})';\n}\n\nfunction genData$2(el, state) {\n  var data = '{';\n\n  // directives first.\n  // directives may mutate the el's other properties before they are generated.\n  var dirs = genDirectives(el, state);\n  if (dirs) {\n    data += dirs + ',';\n  }\n\n  // key\n  if (el.key) {\n    data += \"key:\" + el.key + \",\";\n  }\n  // ref\n  if (el.ref) {\n    data += \"ref:\" + el.ref + \",\";\n  }\n  if (el.refInFor) {\n    data += \"refInFor:true,\";\n  }\n  // pre\n  if (el.pre) {\n    data += \"pre:true,\";\n  }\n  // record original tag name for components using \"is\" attribute\n  if (el.component) {\n    data += \"tag:\\\"\" + el.tag + \"\\\",\";\n  }\n  // module data generation functions\n  for (var i = 0; i < state.dataGenFns.length; i++) {\n    data += state.dataGenFns[i](el);\n  }\n  // attributes\n  if (el.attrs) {\n    data += \"attrs:{\" + genProps(el.attrs) + \"},\";\n  }\n  // DOM props\n  if (el.props) {\n    data += \"domProps:{\" + genProps(el.props) + \"},\";\n  }\n  // event handlers\n  if (el.events) {\n    data += genHandlers(el.events, false, state.warn) + \",\";\n  }\n  if (el.nativeEvents) {\n    data += genHandlers(el.nativeEvents, true, state.warn) + \",\";\n  }\n  // slot target\n  if (el.slotTarget) {\n    data += \"slot:\" + el.slotTarget + \",\";\n  }\n  // scoped slots\n  if (el.scopedSlots) {\n    data += genScopedSlots(el.scopedSlots, state) + \",\";\n  }\n  // component v-model\n  if (el.model) {\n    data += \"model:{value:\" + el.model.value + \",callback:\" + el.model.callback + \",expression:\" + el.model.expression + \"},\";\n  }\n  // inline-template\n  if (el.inlineTemplate) {\n    var inlineTemplate = genInlineTemplate(el, state);\n    if (inlineTemplate) {\n      data += inlineTemplate + \",\";\n    }\n  }\n  data = data.replace(/,$/, '') + '}';\n  // v-bind data wrap\n  if (el.wrapData) {\n    data = el.wrapData(data);\n  }\n  // v-on data wrap\n  if (el.wrapListeners) {\n    data = el.wrapListeners(data);\n  }\n  return data;\n}\n\nfunction genDirectives(el, state) {\n  var dirs = el.directives;\n  if (!dirs) {\n    return;\n  }\n  var res = 'directives:[';\n  var hasRuntime = false;\n  var i, l, dir, needRuntime;\n  for (i = 0, l = dirs.length; i < l; i++) {\n    dir = dirs[i];\n    needRuntime = true;\n    var gen = state.directives[dir.name];\n    if (gen) {\n      // compile-time directive that manipulates AST.\n      // returns true if it also needs a runtime counterpart.\n      needRuntime = !!gen(el, dir, state.warn);\n    }\n    if (needRuntime) {\n      hasRuntime = true;\n      res += \"{name:\\\"\" + dir.name + \"\\\",rawName:\\\"\" + dir.rawName + \"\\\"\" + (dir.value ? \",value:(\" + dir.value + \"),expression:\" + JSON.stringify(dir.value) : '') + (dir.arg ? \",arg:\\\"\" + dir.arg + \"\\\"\" : '') + (dir.modifiers ? \",modifiers:\" + JSON.stringify(dir.modifiers) : '') + \"},\";\n    }\n  }\n  if (hasRuntime) {\n    return res.slice(0, -1) + ']';\n  }\n}\n\nfunction genInlineTemplate(el, state) {\n  var ast = el.children[0];\n  if (false) {\n    state.warn('Inline-template components must have exactly one child element.');\n  }\n  if (ast.type === 1) {\n    var inlineRenderFns = generate(ast, state.options);\n    return \"inlineTemplate:{render:function(){\" + inlineRenderFns.render + \"},staticRenderFns:[\" + inlineRenderFns.staticRenderFns.map(function (code) {\n      return \"function(){\" + code + \"}\";\n    }).join(',') + \"]}\";\n  }\n}\n\nfunction genScopedSlots(slots, state) {\n  return \"scopedSlots:_u([\" + Object.keys(slots).map(function (key) {\n    return genScopedSlot(key, slots[key], state);\n  }).join(',') + \"])\";\n}\n\nfunction genScopedSlot(key, el, state) {\n  if (el.for && !el.forProcessed) {\n    return genForScopedSlot(key, el, state);\n  }\n  return \"{key:\" + key + \",fn:function(\" + String(el.attrsMap.scope) + \"){\" + \"return \" + (el.tag === 'template' ? genChildren(el, state) || 'void 0' : genElement(el, state)) + \"}}\";\n}\n\nfunction genForScopedSlot(key, el, state) {\n  var exp = el.for;\n  var alias = el.alias;\n  var iterator1 = el.iterator1 ? \",\" + el.iterator1 : '';\n  var iterator2 = el.iterator2 ? \",\" + el.iterator2 : '';\n  el.forProcessed = true; // avoid recursion\n  return \"_l((\" + exp + \"),\" + \"function(\" + alias + iterator1 + iterator2 + \"){\" + \"return \" + genScopedSlot(key, el, state) + '})';\n}\n\nfunction genChildren(el, state, checkSkip, altGenElement, altGenNode) {\n  var children = el.children;\n  if (children.length) {\n    var el$1 = children[0];\n    // optimize single v-for\n    if (children.length === 1 && el$1.for && el$1.tag !== 'template' && el$1.tag !== 'slot') {\n      return (altGenElement || genElement)(el$1, state);\n    }\n    var normalizationType = checkSkip ? getNormalizationType(children, state.maybeComponent) : 0;\n    var gen = altGenNode || genNode;\n    return \"[\" + children.map(function (c) {\n      return gen(c, state);\n    }).join(',') + \"]\" + (normalizationType ? \",\" + normalizationType : '');\n  }\n}\n\n// determine the normalization needed for the children array.\n// 0: no normalization needed\n// 1: simple normalization needed (possible 1-level deep nested array)\n// 2: full normalization needed\nfunction getNormalizationType(children, maybeComponent) {\n  var res = 0;\n  for (var i = 0; i < children.length; i++) {\n    var el = children[i];\n    if (el.type !== 1) {\n      continue;\n    }\n    if (needsNormalization(el) || el.ifConditions && el.ifConditions.some(function (c) {\n      return needsNormalization(c.block);\n    })) {\n      res = 2;\n      break;\n    }\n    if (maybeComponent(el) || el.ifConditions && el.ifConditions.some(function (c) {\n      return maybeComponent(c.block);\n    })) {\n      res = 1;\n    }\n  }\n  return res;\n}\n\nfunction needsNormalization(el) {\n  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';\n}\n\nfunction genNode(node, state) {\n  if (node.type === 1) {\n    return genElement(node, state);\n  }if (node.type === 3 && node.isComment) {\n    return genComment(node);\n  } else {\n    return genText(node);\n  }\n}\n\nfunction genText(text) {\n  return \"_v(\" + (text.type === 2 ? text.expression // no need for () because already wrapped in _s()\n  : transformSpecialNewlines(JSON.stringify(text.text))) + \")\";\n}\n\nfunction genComment(comment) {\n  return \"_e(\" + JSON.stringify(comment.text) + \")\";\n}\n\nfunction genSlot(el, state) {\n  var slotName = el.slotName || '\"default\"';\n  var children = genChildren(el, state);\n  var res = \"_t(\" + slotName + (children ? \",\" + children : '');\n  var attrs = el.attrs && \"{\" + el.attrs.map(function (a) {\n    return camelize(a.name) + \":\" + a.value;\n  }).join(',') + \"}\";\n  var bind$$1 = el.attrsMap['v-bind'];\n  if ((attrs || bind$$1) && !children) {\n    res += \",null\";\n  }\n  if (attrs) {\n    res += \",\" + attrs;\n  }\n  if (bind$$1) {\n    res += (attrs ? '' : ',null') + \",\" + bind$$1;\n  }\n  return res + ')';\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent(componentName, el, state) {\n  var children = el.inlineTemplate ? null : genChildren(el, state, true);\n  return \"_c(\" + componentName + \",\" + genData$2(el, state) + (children ? \",\" + children : '') + \")\";\n}\n\nfunction genProps(props) {\n  var res = '';\n  for (var i = 0; i < props.length; i++) {\n    var prop = props[i];\n    res += \"\\\"\" + prop.name + \"\\\":\" + transformSpecialNewlines(prop.value) + \",\";\n  }\n  return res.slice(0, -1);\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines(text) {\n  return text.replace(/\\u2028/g, '\\\\u2028').replace(/\\u2029/g, '\\\\u2029');\n}\n\n/*  */\n\n// these keywords should not appear inside expressions, but operators like\n// typeof, instanceof and in are allowed\nvar prohibitedKeywordRE = new RegExp('\\\\b' + ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' + 'super,throw,while,yield,delete,export,import,return,switch,default,' + 'extends,finally,continue,debugger,function,arguments').split(',').join('\\\\b|\\\\b') + '\\\\b');\n\n// these unary operators should not be used as property/method names\nvar unaryOperatorsRE = new RegExp('\\\\b' + 'delete,typeof,void'.split(',').join('\\\\s*\\\\([^\\\\)]*\\\\)|\\\\b') + '\\\\s*\\\\([^\\\\)]*\\\\)');\n\n// check valid identifier for v-for\nvar identRE = /[A-Za-z_$][\\w$]*/;\n\n// strip strings in expressions\nvar stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n// detect problematic expressions in a template\nfunction detectErrors(ast) {\n  var errors = [];\n  if (ast) {\n    checkNode(ast, errors);\n  }\n  return errors;\n}\n\nfunction checkNode(node, errors) {\n  if (node.type === 1) {\n    for (var name in node.attrsMap) {\n      if (dirRE.test(name)) {\n        var value = node.attrsMap[name];\n        if (value) {\n          if (name === 'v-for') {\n            checkFor(node, \"v-for=\\\"\" + value + \"\\\"\", errors);\n          } else if (onRE.test(name)) {\n            checkEvent(value, name + \"=\\\"\" + value + \"\\\"\", errors);\n          } else {\n            checkExpression(value, name + \"=\\\"\" + value + \"\\\"\", errors);\n          }\n        }\n      }\n    }\n    if (node.children) {\n      for (var i = 0; i < node.children.length; i++) {\n        checkNode(node.children[i], errors);\n      }\n    }\n  } else if (node.type === 2) {\n    checkExpression(node.expression, node.text, errors);\n  }\n}\n\nfunction checkEvent(exp, text, errors) {\n  var stipped = exp.replace(stripStringRE, '');\n  var keywordMatch = stipped.match(unaryOperatorsRE);\n  if (keywordMatch && stipped.charAt(keywordMatch.index - 1) !== '$') {\n    errors.push(\"avoid using JavaScript unary operator as property name: \" + \"\\\"\" + keywordMatch[0] + \"\\\" in expression \" + text.trim());\n  }\n  checkExpression(exp, text, errors);\n}\n\nfunction checkFor(node, text, errors) {\n  checkExpression(node.for || '', text, errors);\n  checkIdentifier(node.alias, 'v-for alias', text, errors);\n  checkIdentifier(node.iterator1, 'v-for iterator', text, errors);\n  checkIdentifier(node.iterator2, 'v-for iterator', text, errors);\n}\n\nfunction checkIdentifier(ident, type, text, errors) {\n  if (typeof ident === 'string' && !identRE.test(ident)) {\n    errors.push(\"invalid \" + type + \" \\\"\" + ident + \"\\\" in expression: \" + text.trim());\n  }\n}\n\nfunction checkExpression(exp, text, errors) {\n  try {\n    new Function(\"return \" + exp);\n  } catch (e) {\n    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n    if (keywordMatch) {\n      errors.push(\"avoid using JavaScript keyword as property name: \" + \"\\\"\" + keywordMatch[0] + \"\\\" in expression \" + text.trim());\n    } else {\n      errors.push(\"invalid expression: \" + text.trim());\n    }\n  }\n}\n\n/*  */\n\nfunction createFunction(code, errors) {\n  try {\n    return new Function(code);\n  } catch (err) {\n    errors.push({ err: err, code: code });\n    return noop;\n  }\n}\n\nfunction createCompileToFunctionFn(compile) {\n  var cache = Object.create(null);\n\n  return function compileToFunctions(template, options, vm) {\n    options = options || {};\n\n    /* istanbul ignore if */\n    if (false) {\n      // detect possible CSP restriction\n      try {\n        new Function('return 1');\n      } catch (e) {\n        if (e.toString().match(/unsafe-eval|CSP/)) {\n          warn('It seems you are using the standalone build of Vue.js in an ' + 'environment with Content Security Policy that prohibits unsafe-eval. ' + 'The template compiler cannot work in this environment. Consider ' + 'relaxing the policy to allow unsafe-eval or pre-compiling your ' + 'templates into render functions.');\n        }\n      }\n    }\n\n    // check cache\n    var key = options.delimiters ? String(options.delimiters) + template : template;\n    if (cache[key]) {\n      return cache[key];\n    }\n\n    // compile\n    var compiled = compile(template, options);\n\n    // check compilation errors/tips\n    if (false) {\n      if (compiled.errors && compiled.errors.length) {\n        warn(\"Error compiling template:\\n\\n\" + template + \"\\n\\n\" + compiled.errors.map(function (e) {\n          return \"- \" + e;\n        }).join('\\n') + '\\n', vm);\n      }\n      if (compiled.tips && compiled.tips.length) {\n        compiled.tips.forEach(function (msg) {\n          return tip(msg, vm);\n        });\n      }\n    }\n\n    // turn code into functions\n    var res = {};\n    var fnGenErrors = [];\n    res.render = createFunction(compiled.render, fnGenErrors);\n    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {\n      return createFunction(code, fnGenErrors);\n    });\n\n    // check function generation errors.\n    // this should only happen if there is a bug in the compiler itself.\n    // mostly for codegen development use\n    /* istanbul ignore if */\n    if (false) {\n      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {\n        warn(\"Failed to generate render function:\\n\\n\" + fnGenErrors.map(function (ref) {\n          var err = ref.err;\n          var code = ref.code;\n\n          return err.toString() + \" in\\n\\n\" + code + \"\\n\";\n        }).join('\\n'), vm);\n      }\n    }\n\n    return cache[key] = res;\n  };\n}\n\n/*  */\n\nfunction createCompilerCreator(baseCompile) {\n  return function createCompiler(baseOptions) {\n    function compile(template, options) {\n      var finalOptions = Object.create(baseOptions);\n      var errors = [];\n      var tips = [];\n      finalOptions.warn = function (msg, tip) {\n        (tip ? tips : errors).push(msg);\n      };\n\n      if (options) {\n        // merge custom modules\n        if (options.modules) {\n          finalOptions.modules = (baseOptions.modules || []).concat(options.modules);\n        }\n        // merge custom directives\n        if (options.directives) {\n          finalOptions.directives = extend(Object.create(baseOptions.directives), options.directives);\n        }\n        // copy other options\n        for (var key in options) {\n          if (key !== 'modules' && key !== 'directives') {\n            finalOptions[key] = options[key];\n          }\n        }\n      }\n\n      var compiled = baseCompile(template, finalOptions);\n      if (false) {\n        errors.push.apply(errors, detectErrors(compiled.ast));\n      }\n      compiled.errors = errors;\n      compiled.tips = tips;\n      return compiled;\n    }\n\n    return {\n      compile: compile,\n      compileToFunctions: createCompileToFunctionFn(compile)\n    };\n  };\n}\n\n/*  */\n\n// `createCompilerCreator` allows creating compilers that use alternative\n// parser/optimizer/codegen, e.g the SSR optimizing compiler.\n// Here we just export a default compiler using the default parts.\nvar createCompiler = createCompilerCreator(function baseCompile(template, options) {\n  var ast = parse(template.trim(), options);\n  optimize(ast, options);\n  var code = generate(ast, options);\n  return {\n    ast: ast,\n    render: code.render,\n    staticRenderFns: code.staticRenderFns\n  };\n});\n\n/*  */\n\nvar ref$1 = createCompiler(baseOptions);\nvar compileToFunctions = ref$1.compileToFunctions;\n\n/*  */\n\nvar idToTemplate = cached(function (id) {\n  var el = query(id);\n  return el && el.innerHTML;\n});\n\nvar mount = Vue$3.prototype.$mount;\nVue$3.prototype.$mount = function (el, hydrating) {\n  el = el && query(el);\n\n  /* istanbul ignore if */\n  if (el === document.body || el === document.documentElement) {\n    \"production\" !== 'production' && warn(\"Do not mount Vue to <html> or <body> - mount to normal elements instead.\");\n    return this;\n  }\n\n  var options = this.$options;\n  // resolve template/el and convert to render function\n  if (!options.render) {\n    var template = options.template;\n    if (template) {\n      if (typeof template === 'string') {\n        if (template.charAt(0) === '#') {\n          template = idToTemplate(template);\n          /* istanbul ignore if */\n          if (false) {\n            warn(\"Template element not found or is empty: \" + options.template, this);\n          }\n        }\n      } else if (template.nodeType) {\n        template = template.innerHTML;\n      } else {\n        if (false) {\n          warn('invalid template option:' + template, this);\n        }\n        return this;\n      }\n    } else if (el) {\n      template = getOuterHTML(el);\n    }\n    if (template) {\n      /* istanbul ignore if */\n      if (false) {\n        mark('compile');\n      }\n\n      var ref = compileToFunctions(template, {\n        shouldDecodeNewlines: shouldDecodeNewlines,\n        delimiters: options.delimiters,\n        comments: options.comments\n      }, this);\n      var render = ref.render;\n      var staticRenderFns = ref.staticRenderFns;\n      options.render = render;\n      options.staticRenderFns = staticRenderFns;\n\n      /* istanbul ignore if */\n      if (false) {\n        mark('compile end');\n        measure(this._name + \" compile\", 'compile', 'compile end');\n      }\n    }\n  }\n  return mount.call(this, el, hydrating);\n};\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n */\nfunction getOuterHTML(el) {\n  if (el.outerHTML) {\n    return el.outerHTML;\n  } else {\n    var container = document.createElement('div');\n    container.appendChild(el.cloneNode(true));\n    return container.innerHTML;\n  }\n}\n\nVue$3.compile = compileToFunctions;\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (Vue$3);\n/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(1)))\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports) {\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar g;\n\n// This works in non-strict mode\ng = function () {\n\treturn this;\n}();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar MoveTo = function () {\n  /**\n                           * Defaults\n                           * @type {object}\n                           */\n  var defaults = {\n    tolerance: 0,\n    duration: 800,\n    easing: 'easeOutQuart',\n    callback: function callback() {} };\n\n\n  /**\n                                         * easeOutQuart Easing Function\n                                         * @param  {number} t - current time\n                                         * @param  {number} b - start value\n                                         * @param  {number} c - change in value\n                                         * @param  {number} d - duration\n                                         * @return {number} - calculated value\n                                         */\n  function easeOutQuart(t, b, c, d) {\n    t /= d;\n    t--;\n    return -c * (t * t * t * t - 1) + b;\n  }\n\n  /**\n     * Returns html element's top and left offset\n     * @param  {HTMLElement} elem - Element\n     * @return {object} Element top and left offset\n     */\n  function getOffsetSum(elem) {\n    var top = 0;\n    var left = 0;\n    while (elem) {\n      top += elem.offsetTop;\n      left += elem.offsetLeft;\n      elem = elem.offsetParent;\n    }\n    return {\n      top: top, left: left };\n\n  }\n\n  /**\n     * Merge two object\n     *\n     * @param  {object} obj1\n     * @param  {object} obj2\n     * @return {object} merged object\n     */\n  function mergeObject(obj1, obj2) {\n    var obj3 = {};\n    Object.keys(obj1).forEach(function (propertyName) {\n      obj3[propertyName] = obj1[propertyName];\n    });\n\n    Object.keys(obj2).forEach(function (propertyName) {\n      obj3[propertyName] = obj2[propertyName];\n    });\n    return obj3;\n  };\n\n  /**\n      * Converts camel case to kebab case\n      * @param  {string} val the value to be converted\n      * @return {string} the converted value\n      */\n  function kebabCase(val) {\n    return val.replace(/([A-Z])/g, function ($1) {\n      return '-' + $1.toLowerCase();\n    });\n  };\n\n  /**\n      * MoveTo Constructor\n      * @param {object} options Options\n      * @param {object} easeFunctions Custom ease functions\n      */\n  function MoveTo() {var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};var easeFunctions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    this.options = mergeObject(defaults, options);\n    this.easeFunctions = mergeObject({ easeOutQuart: easeOutQuart }, easeFunctions);\n  }\n\n  /**\n     * Register a dom element as trigger\n     * @param  {HTMLElement} dom Dom trigger element\n     * @param  {function} callback Callback function\n     */\n  MoveTo.prototype.registerTrigger = function (dom, callback) {var _this = this;\n    if (!dom) {\n      return;\n    }\n\n    var href = dom.getAttribute('href') || dom.getAttribute('data-target');\n    // The element to be scrolled\n    var target = href && href !== '#' ?\n    document.getElementById(href.substring(1)) :\n    0;\n    var options = mergeObject(this.options, _getOptionsFromTriggerDom(dom, this.options));\n\n    if (typeof callback === 'function') {\n      options.callback = callback;\n    }\n\n    dom.addEventListener('click', function (e) {\n      e.preventDefault();\n      _this.move(target, options);\n    });\n  };\n\n  /**\n      * Move\n      * Scrolls to given element by using easeOutQuart function\n      * @param  {HTMLElement|number} target Target element to be scrolled or target position\n      * @param  {object} options Custom options\n      */\n  MoveTo.prototype.move = function (target) {var _this2 = this;var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    if (target !== 0 && !target) {\n      return;\n    }\n\n    options = mergeObject(this.options, options);\n\n    var to = typeof target === 'number' ? target : getOffsetSum(target).top;\n    var from = window.pageYOffset;\n    to -= options.tolerance;\n    var change = to - from;\n    var startTime = null;\n    var lastPageYOffset = 0;\n\n    // rAF loop\n    var loop = function loop(currentTime) {\n      var currentPageYOffset = window.pageYOffset;\n\n      if (!startTime) {\n        // To starts time from 1, we subtracted -1 from current time\n        // If time starts from 1 The first loop will not do anything,\n        // because easing value will be zero\n        startTime = currentTime - 1;\n      }\n\n      var timeElapsed = currentTime - startTime;\n\n      if (lastPageYOffset !== 0) {\n        if (\n        lastPageYOffset === currentPageYOffset ||\n        change > 0 && lastPageYOffset > currentPageYOffset ||\n        change < 0 && lastPageYOffset < currentPageYOffset)\n        {\n          return options.callback(target);\n        }\n      }\n      lastPageYOffset = currentPageYOffset;\n\n      var val = _this2.easeFunctions[options.easing](\n      timeElapsed, from, change, options.duration);\n\n\n      window.scroll(0, val);\n\n      if (timeElapsed < options.duration) {\n        window.requestAnimationFrame(loop);\n      } else {\n        window.scroll(0, to);\n        options.callback(target);\n      }\n    };\n\n    window.requestAnimationFrame(loop);\n  };\n\n  /**\n      * Adds custom ease function\n      * @param {string}   name Ease function name\n      * @param {function} fn   Ease function\n      */\n  MoveTo.prototype.addEaseFunction = function (name, fn) {\n    this.easeFunctions[name] = fn;\n  };\n\n  /**\n      * Returns options which created from trigger dom element\n      * @param  {HTMLElement} dom Trigger dom element\n      * @param  {object} options The instance's options\n      * @return {object} The options which created from trigger dom element\n      */\n  function _getOptionsFromTriggerDom(dom, options) {\n    var domOptions = {};\n\n    Object.keys(options).forEach(function (key) {\n      var value = dom.getAttribute('data-mt-' + kebabCase(key));\n      if (value) {\n        domOptions[key] = isNaN(value) ? value : parseInt(value, 10);\n      }\n    });\n    return domOptions;\n  }\n\n  return MoveTo;\n}();\n\nif (true) {\n  module.exports = MoveTo;\n} else {\n  window.moveTo = MoveTo;\n}\n\n/***/ }),\n/* 3 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_videobg_vue__ = __webpack_require__(6);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_65807d96_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_videobg_vue__ = __webpack_require__(7);\nfunction injectStyle (ssrContext) {\n  __webpack_require__(4)\n}\nvar normalizeComponent = __webpack_require__(5)\n/* script */\n\n/* template */\n\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n  __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_videobg_vue__[\"a\" /* default */],\n  __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_65807d96_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_videobg_vue__[\"a\" /* default */],\n  __vue_styles__,\n  __vue_scopeId__,\n  __vue_module_identifier__\n)\n\n/* harmony default export */ __webpack_exports__[\"default\"] = (Component.exports);\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports) {\n\n/* globals __VUE_SSR_CONTEXT__ */\n\n// this module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle\n\nmodule.exports = function normalizeComponent (\n  rawScriptExports,\n  compiledTemplate,\n  injectStyles,\n  scopeId,\n  moduleIdentifier /* server only */\n) {\n  var esModule\n  var scriptExports = rawScriptExports = rawScriptExports || {}\n\n  // ES6 modules interop\n  var type = typeof rawScriptExports.default\n  if (type === 'object' || type === 'function') {\n    esModule = rawScriptExports\n    scriptExports = rawScriptExports.default\n  }\n\n  // Vue.extend constructor export interop\n  var options = typeof scriptExports === 'function'\n    ? scriptExports.options\n    : scriptExports\n\n  // render functions\n  if (compiledTemplate) {\n    options.render = compiledTemplate.render\n    options.staticRenderFns = compiledTemplate.staticRenderFns\n  }\n\n  // scopedId\n  if (scopeId) {\n    options._scopeId = scopeId\n  }\n\n  var hook\n  if (moduleIdentifier) { // server build\n    hook = function (context) {\n      // 2.3 injection\n      context =\n        context || // cached call\n        (this.$vnode && this.$vnode.ssrContext) || // stateful\n        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n      // 2.2 with runInNewContext: true\n      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n        context = __VUE_SSR_CONTEXT__\n      }\n      // inject component styles\n      if (injectStyles) {\n        injectStyles.call(this, context)\n      }\n      // register component module identifier for async chunk inferrence\n      if (context && context._registeredComponents) {\n        context._registeredComponents.add(moduleIdentifier)\n      }\n    }\n    // used by ssr in case component is cached and beforeCreate\n    // never gets called\n    options._ssrRegister = hook\n  } else if (injectStyles) {\n    hook = injectStyles\n  }\n\n  if (hook) {\n    var functional = options.functional\n    var existing = functional\n      ? options.render\n      : options.beforeCreate\n    if (!functional) {\n      // inject component registration as beforeCreate hook\n      options.beforeCreate = existing\n        ? [].concat(existing, hook)\n        : [hook]\n    } else {\n      // register for functioal component in vue file\n      options.render = function renderWithStyleInjection (h, context) {\n        hook.call(context)\n        return existing(h, context)\n      }\n    }\n  }\n\n  return {\n    esModule: esModule,\n    exports: scriptExports,\n    options: options\n  }\n}\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n\n/* harmony default export */ __webpack_exports__[\"a\"] = ({\n  props: {\n    sources: {\n      type: Array,\n      required: true\n    },\n    img: {\n      type: String\n    }\n  },\n\n  data: function data() {\n    return {\n      videoRatio: null\n    };\n  },\n  mounted: function mounted() {\n    var _this = this;\n\n    this.setImageUrl();\n    this.setContainerHeight();\n\n    if (this.videoCanPlay()) {\n      this.$refs.video.oncanplay = function () {\n        if (!_this.$refs.video) return;\n\n        _this.videoRatio = _this.$refs.video.videoWidth / _this.$refs.video.videoHeight;\n        _this.setVideoSize();\n        _this.$refs.video.style.visibility = 'visible';\n      };\n    }\n\n    window.addEventListener('resize', this.resize);\n  },\n  beforeDestroy: function beforeDestroy() {\n    window.removeEventListener('resize', this.resize);\n  },\n\n\n  methods: {\n    resize: function resize() {\n      this.setContainerHeight();\n\n      if (this.videoCanPlay()) {\n        this.setVideoSize();\n      }\n    },\n    videoCanPlay: function videoCanPlay() {\n      return !!this.$refs.video.canPlayType;\n    },\n    setImageUrl: function setImageUrl() {\n      if (this.img) {\n        this.$el.style.backgroundImage = 'url(' + this.img + ')';\n      }\n    },\n    setContainerHeight: function setContainerHeight() {\n      this.$el.style.height = window.innerHeight + 'px';\n    },\n    setVideoSize: function setVideoSize() {\n      var width,\n          height,\n          containerRatio = this.$el.offsetWidth / this.$el.offsetHeight;\n\n      if (containerRatio > this.videoRatio) {\n        width = this.$el.offsetWidth;\n      } else {\n        height = this.$el.offsetHeight;\n      }\n\n      this.$refs.video.style.width = width ? width + 'px' : 'auto';\n      this.$refs.video.style.height = height ? height + 'px' : 'auto';\n    },\n    getMediaType: function getMediaType(src) {\n      return 'video/' + src.split('.').pop();\n    }\n  }\n});\n\n/***/ }),\n/* 7 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nvar render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;\n  return _c('section', {\n    staticClass: \"VideoBg\"\n  }, [_c('video', {\n    ref: \"video\",\n    attrs: {\n      \"autoplay\": \"\",\n      \"loop\": \"\",\n      \"muted\": \"\",\n      \"playsinline\": \"\"\n    }\n  }, _vm._l((_vm.sources), function(source) {\n    return _c('source', {\n      attrs: {\n        \"src\": source,\n        \"type\": _vm.getMediaType(source)\n      }\n    })\n  })), _vm._v(\" \"), _c('div', {\n    staticClass: \"VideoBg__content\"\n  }, [_vm._t(\"default\")], 2)])\n}\nvar staticRenderFns = []\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\n/* harmony default export */ __webpack_exports__[\"a\"] = (esExports);\n\n/***/ }),\n/* 8 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_vue_dist_vue_esm__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_moveto__ = __webpack_require__(2);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_moveto___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_moveto__);\n\n\n\nnew __WEBPACK_IMPORTED_MODULE_0_vue_dist_vue_esm__[\"a\" /* default */]({\n  el: '.gototop',\n  data: {\n    moveTo: null\n  },\n  methods: {\n    clicked: function clicked() {\n      var _this = this;\n\n      var target = document.getElementById('navbar');\n\n      this.$el.classList.add('moving');\n      __WEBPACK_IMPORTED_MODULE_0_vue_dist_vue_esm__[\"a\" /* default */].nextTick(function () {\n        _this.moveTo.move(target);\n      });\n    },\n    finished: function finished() {\n      this.$el.classList.remove('moving');\n    }\n  },\n  created: function created() {\n    this.moveTo = new __WEBPACK_IMPORTED_MODULE_1_moveto___default.a({\n      callback: this.finished\n    });\n  }\n});\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports) {\n\n/**\n * main.js\n * http://www.codrops.com\n *\n * Licensed under the MIT license.\n * http://www.opensource.org/licenses/mit-license.php\n *\n * Copyright 2016, Codrops\n * http://www.codrops.com\n */\n;(function (window) {\n\n  'use strict';\n\n  // Helper vars and functions.\n\n  function extend(a, b) {\n    for (var key in b) {\n      if (b.hasOwnProperty(key)) {\n        a[key] = b[key];\n      }\n    }\n    return a;\n  }\n\n  // from http://www.quirksmode.org/js/events_properties.html#position\n  function getMousePos(e) {\n    var posx = 0,\n        posy = 0;\n    if (!e) var e = window.event;\n    if (e.pageX || e.pageY) {\n      posx = e.pageX;\n      posy = e.pageY;\n    } else if (e.clientX || e.clientY) {\n      posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;\n      posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;\n    }\n    return { x: posx, y: posy };\n  }\n\n  /**\n   * TiltFx obj.\n   */\n  function TiltFx(el, options) {\n    this.DOM = {};\n    this.DOM.el = el;\n    this.options = extend({}, this.options);\n    extend(this.options, options);\n    this._init();\n  }\n\n  TiltFx.prototype.options = {\n    movement: {\n      imgWrapper: {\n        translation: { x: 0, y: 0, z: 0 },\n        rotation: { x: -5, y: 5, z: 0 },\n        reverseAnimation: {\n          duration: 1200,\n          easing: 'easeOutElastic',\n          elasticity: 600\n        }\n      },\n      lines: {\n        translation: { x: 10, y: 10, z: [0, 10] },\n        reverseAnimation: {\n          duration: 1000,\n          easing: 'easeOutExpo',\n          elasticity: 600\n        }\n      },\n      caption: {\n        translation: { x: 20, y: 20, z: 0 },\n        rotation: { x: 0, y: 0, z: 0 },\n        reverseAnimation: {\n          duration: 1500,\n          easing: 'easeOutElastic',\n          elasticity: 600\n        }\n      },\n      /*\n      overlay : {\n        translation : {x: 10, y: 10, z: [0,50]},\n        reverseAnimation : {\n          duration : 500,\n          easing : 'easeOutExpo'\n        }\n      },\n      */\n      shine: {\n        translation: { x: 50, y: 50, z: 0 },\n        reverseAnimation: {\n          duration: 1200,\n          easing: 'easeOutElastic',\n          elasticity: 600\n        }\n      }\n    }\n  };\n\n  /**\n   * Init.\n   */\n  TiltFx.prototype._init = function () {\n    this.DOM.animatable = {};\n    this.DOM.animatable.imgWrapper = this.DOM.el.querySelector('.tilter__figure');\n    this.DOM.animatable.lines = this.DOM.el.querySelector('.tilter__deco--lines');\n    this.DOM.animatable.caption = this.DOM.el.querySelector('.tilter__caption');\n    this.DOM.animatable.overlay = this.DOM.el.querySelector('.tilter__deco--overlay');\n    this.DOM.animatable.shine = this.DOM.el.querySelector('.tilter__deco--shine > div');\n    this._initEvents();\n  };\n\n  /**\n   * Init/Bind events.\n   */\n  TiltFx.prototype._initEvents = function () {\n    var self = this;\n\n    this.mouseenterFn = function () {\n      for (var key in self.DOM.animatable) {\n        anime.remove(self.DOM.animatable[key]);\n      }\n    };\n\n    this.mousemoveFn = function (ev) {\n      requestAnimationFrame(function () {\n        self._layout(ev);\n      });\n    };\n\n    this.mouseleaveFn = function (ev) {\n      requestAnimationFrame(function () {\n        for (var key in self.DOM.animatable) {\n          if (self.options.movement[key] == undefined) {\n            continue;\n          }\n          anime({\n            targets: self.DOM.animatable[key],\n            duration: self.options.movement[key].reverseAnimation != undefined ? self.options.movement[key].reverseAnimation.duration || 0 : 1,\n            easing: self.options.movement[key].reverseAnimation != undefined ? self.options.movement[key].reverseAnimation.easing || 'linear' : 'linear',\n            elasticity: self.options.movement[key].reverseAnimation != undefined ? self.options.movement[key].reverseAnimation.elasticity || null : null,\n            scaleX: 1,\n            scaleY: 1,\n            scaleZ: 1,\n            translateX: 0,\n            translateY: 0,\n            translateZ: 0,\n            rotateX: 0,\n            rotateY: 0,\n            rotateZ: 0\n          });\n        }\n      });\n    };\n\n    this.DOM.el.addEventListener('mousemove', this.mousemoveFn);\n    this.DOM.el.addEventListener('mouseleave', this.mouseleaveFn);\n    this.DOM.el.addEventListener('mouseenter', this.mouseenterFn);\n  };\n\n  TiltFx.prototype._layout = function (ev) {\n    // Mouse position relative to the document.\n    var mousepos = getMousePos(ev),\n\n    // Document scrolls.\n    docScrolls = { left: document.body.scrollLeft + document.documentElement.scrollLeft, top: document.body.scrollTop + document.documentElement.scrollTop },\n        bounds = this.DOM.el.getBoundingClientRect(),\n\n    // Mouse position relative to the main element (this.DOM.el).\n    relmousepos = { x: mousepos.x - bounds.left - docScrolls.left, y: mousepos.y - bounds.top - docScrolls.top };\n\n    // Movement settings for the animatable elements.\n    for (var key in this.DOM.animatable) {\n      if (this.DOM.animatable[key] == undefined || this.options.movement[key] == undefined) {\n        continue;\n      }\n      var t = this.options.movement[key] != undefined ? this.options.movement[key].translation || { x: 0, y: 0, z: 0 } : { x: 0, y: 0, z: 0 },\n          r = this.options.movement[key] != undefined ? this.options.movement[key].rotation || { x: 0, y: 0, z: 0 } : { x: 0, y: 0, z: 0 },\n          setRange = function setRange(obj) {\n        for (var k in obj) {\n          if (obj[k] == undefined) {\n            obj[k] = [0, 0];\n          } else if (typeof obj[k] === 'number') {\n            obj[k] = [-1 * obj[k], obj[k]];\n          }\n        }\n      };\n\n      setRange(t);\n      setRange(r);\n\n      var transforms = {\n        translation: {\n          x: (t.x[1] - t.x[0]) / bounds.width * relmousepos.x + t.x[0],\n          y: (t.y[1] - t.y[0]) / bounds.height * relmousepos.y + t.y[0],\n          z: (t.z[1] - t.z[0]) / bounds.height * relmousepos.y + t.z[0]\n        },\n        rotation: {\n          x: (r.x[1] - r.x[0]) / bounds.height * relmousepos.y + r.x[0],\n          y: (r.y[1] - r.y[0]) / bounds.width * relmousepos.x + r.y[0],\n          z: (r.z[1] - r.z[0]) / bounds.width * relmousepos.x + r.z[0]\n        }\n      };\n\n      this.DOM.animatable[key].style.WebkitTransform = this.DOM.animatable[key].style.transform = 'translateX(' + transforms.translation.x + 'px) translateY(' + transforms.translation.y + 'px) translateZ(' + transforms.translation.z + 'px) rotateX(' + transforms.rotation.x + 'deg) rotateY(' + transforms.rotation.y + 'deg) rotateZ(' + transforms.rotation.z + 'deg)';\n    }\n  };\n\n  window.TiltFx = TiltFx;\n})(window);\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports) {\n\ndocument.addEventListener('readystatechange', function (evt) {\n  if (evt.target.readyState == 'complete') {\n    updateBodyClass();\n    initEffects();\n  }\n});\n\nwindow.addEventListener('scroll', function (e) {\n  updateBodyClass();\n});\n\nfunction updateBodyClass() {\n  var body = document.body;\n  if (window.scrollY >= 70) {\n    body.classList.add(\"scrolled\");\n  } else {\n    body.classList.remove(\"scrolled\");\n  }\n}\n\nfunction initEffects() {\n  var triggers = document.getElementsByClassName('animate');\n\n  addEventListener('mousemove', this.mousemoveFn);\n\n  for (var i = 0; i < triggers.length; i++) {\n    triggers[i].addEventListener('mousemove', onMouseMove);\n    triggers[i].addEventListener('mouseleave', onMouseLeave);\n  }\n}\n\nfunction getMousePos(e) {\n  var posx = 0,\n      posy = 0;\n  if (!e) var e = window.event;\n  if (e.pageX || e.pageY) {\n    posx = e.pageX;\n    posy = e.pageY;\n  } else if (e.clientX || e.clientY) {\n    posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;\n    posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;\n  }\n  return { x: posx, y: posy };\n}\n\nvar transitions = [{\n  translation: { x: 10, y: 10, z: 30 },\n  rotation: { x: 10, y: -20, z: 0 }\n}, {\n  translation: { x: 10, y: 10, z: [0, -70] },\n  rotation: { x: 10, y: 20, z: -2 }\n}, {\n  translation: { x: 10, y: -10, z: -10 },\n  rotation: { x: 10, y: 20, z: 2 }\n}];\n\nfunction onMouseMove(ev) {\n  var doms = ev.target.getElementsByClassName('animate-child');\n\n  for (var i = 0; i < doms.length; i++) {\n    var dom = doms[i];\n\n    var mousepos = getMousePos(ev),\n        docScrolls = { left: document.body.scrollLeft + document.documentElement.scrollLeft, top: document.body.scrollTop + document.documentElement.scrollTop },\n        bounds = dom.getBoundingClientRect(),\n        relmousepos = { x: mousepos.x - bounds.left - docScrolls.left, y: mousepos.y - bounds.top - docScrolls.top };\n\n    var transition = transitions[i];\n    var t = transition.translation;\n    r = transition.rotation;\n\n    var setRange = function setRange(obj) {\n      for (var k in obj) {\n        if (obj[k] == undefined) {\n          obj[k] = [0, 0];\n        } else if (typeof obj[k] === 'number') {\n          obj[k] = [-1 * obj[k], obj[k]];\n        }\n      }\n    };\n\n    setRange(t);\n    setRange(r);\n\n    var transforms = {\n      translation: {\n        x: (t.x[1] - t.x[0]) / bounds.width * relmousepos.x + t.x[0],\n        y: (t.y[1] - t.y[0]) / bounds.height * relmousepos.y + t.y[0],\n        z: (t.z[1] - t.z[0]) / bounds.height * relmousepos.y + t.z[0]\n      },\n      rotation: {\n        x: (r.x[1] - r.x[0]) / bounds.height * relmousepos.y + r.x[0],\n        y: (r.y[1] - r.y[0]) / bounds.width * relmousepos.x + r.y[0],\n        z: (r.z[1] - r.z[0]) / bounds.width * relmousepos.x + r.z[0]\n      }\n    };\n\n    dom.style.WebkitTransform = dom.style.transform = 'translateX(' + transforms.translation.x + 'px) translateY(' + transforms.translation.y + 'px) translateZ(' + transforms.translation.z + 'px) rotateX(' + transforms.rotation.x + 'deg) rotateY(' + transforms.rotation.y + 'deg) rotateZ(' + transforms.rotation.z + 'deg)';\n  }\n}\n\nfunction onMouseLeave(ev) {\n  var doms = ev.target.getElementsByClassName('animate-child');\n\n  for (var i = 0; i < doms.length; i++) {\n    var dom = doms[i];\n\n    var transforms = {\n      translation: {\n        x: 0,\n        y: 0,\n        z: 0\n      },\n      rotation: {\n        x: 0,\n        y: 0,\n        z: 0\n      }\n    };\n\n    dom.style.WebkitTransform = dom.style.transform = 'translateX(' + transforms.translation.x + 'px) translateY(' + transforms.translation.y + 'px) translateZ(' + transforms.translation.z + 'px) rotateX(' + transforms.rotation.x + 'deg) rotateY(' + transforms.rotation.y + 'deg) rotateZ(' + transforms.rotation.z + 'deg)';\n  }\n}\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports) {\n\n/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {/* globals __webpack_amd_options__ */\r\nmodule.exports = __webpack_amd_options__;\r\n\n/* WEBPACK VAR INJECTION */}.call(exports, {}))\n\n/***/ }),\n/* 12 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_vue_dist_vue_esm__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_vue_parallaxy__ = __webpack_require__(13);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_vue_parallaxy___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_vue_parallaxy__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__videobg_vue__ = __webpack_require__(3);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_moveto__ = __webpack_require__(2);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_moveto___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_moveto__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_animejs__ = __webpack_require__(15);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_animejs___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_animejs__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_scrollreveal__ = __webpack_require__(16);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_scrollreveal___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_scrollreveal__);\n/* eslint no-console:0 */\n// This file is automatically compiled by Webpack, along with any other files\n// present in this directory. You're encouraged to place your actual application logic in\n// a relevant structure within app/javascript and only use these pack files to reference\n// that code so it'll be compiled.\n//\n// To reference this file, add <%= javascript_pack_tag 'application' %> to the appropriate\n// layout file, like app/views/layouts/application.html.erb\n\n\n\n\n\n__webpack_require__(8);\n__webpack_require__(9);\n__webpack_require__(10);\n\n\n\nwindow.sr = __WEBPACK_IMPORTED_MODULE_5_scrollreveal___default()();\n\ndocument.addEventListener('readystatechange', function (evt) {\n  if (evt.target.readyState == 'complete') {\n    sr.reveal('.block-modal', {\n      reset: true\n    }, 500);\n  }\n});\n\nnew __WEBPACK_IMPORTED_MODULE_0_vue_dist_vue_esm__[\"a\" /* default */]({\n  el: '#tools',\n  components: {\n    Parallax: __WEBPACK_IMPORTED_MODULE_1_vue_parallaxy___default.a\n  }\n});\n\nfunction findAncestor(el, cls) {\n  if (el.classList.contains(cls)) return el;\n  while ((el = el.parentElement) && !el.classList.contains(cls)) {}\n  return el;\n}\n\nfunction hasClass(ele, cls) {\n  return ele.className.match(new RegExp('(\\\\s|^)' + cls + '(\\\\s|$)'));\n}\n\nnew __WEBPACK_IMPORTED_MODULE_0_vue_dist_vue_esm__[\"a\" /* default */]({\n  el: '#entry',\n  components: {\n    VideoBg: __WEBPACK_IMPORTED_MODULE_2__videobg_vue__[\"default\"]\n  }\n});\n\nnew __WEBPACK_IMPORTED_MODULE_0_vue_dist_vue_esm__[\"a\" /* default */]({\n  el: '#oportunities',\n  data: {\n    active: null\n  },\n  methods: {\n    select: function select(index) {\n      if (this.active == index) this.active = null;else this.active = index;\n    }\n  }\n});\n\nnew __WEBPACK_IMPORTED_MODULE_0_vue_dist_vue_esm__[\"a\" /* default */]({\n  el: '#company',\n  data: {\n    active: -1,\n    title: '',\n    content: ''\n  },\n  methods: {\n    toggle: function toggle(e) {\n      if (window.innerWidth < 767) return true;\n      var parent = findAncestor(e.target, 'block-modal');\n\n      var index = Array.prototype.slice.call(this.blocks).indexOf(parent);\n\n      this.active = index;\n\n      if (!hasClass(this.modal, 'active')) {\n        this.modal.classList.add('active');\n      }\n    },\n    setBlock: function setBlock(block) {\n      this.title = getDescendantWithClass(block, 'title').innerText;\n      this.content = getDescendantWithClass(block, 'content').innerText;\n    },\n    close: function close() {\n      this.modal.classList.remove('active');\n    },\n    next: function next() {\n      if (this.active == this.blocks.length - 1) {\n        this.active = 0;\n      } else {\n        this.active = this.active + 1;\n      }\n    },\n    previous: function previous() {\n      if (this.active == 0) {\n        this.active = this.blocks.length - 1;\n      } else {\n        this.active = this.active - 1;\n      }\n    }\n  },\n  watch: {\n    active: function active() {\n      var block = this.blocks[this.active];\n      this.setBlock(block);\n    }\n  },\n  computed: {\n    modal: function modal() {\n      return document.getElementsByClassName('modal-info')[0];\n    },\n    blocks: function blocks() {\n      return document.getElementsByClassName('block-modal');\n    }\n  },\n  mounted: function mounted() {\n    this.modal.addEventListener('click', function (event) {\n      event.stopPropagation();\n    });\n\n    Array.prototype.forEach.call(document.getElementsByClassName('block-modal'), function (item) {\n      item.addEventListener('click', function (event) {\n        event.stopPropagation();\n      });\n    });\n\n    document.body.addEventListener('click', this.close);\n  }\n});\n\nvar easeFunctions = {\n  easeInQuad: function easeInQuad(t, b, c, d) {\n    t /= d;\n    return c * t * t + b;\n  },\n  easeOutQuad: function easeOutQuad(t, b, c, d) {\n    t /= d;\n    return -c * t * (t - 2) + b;\n  }\n};\n\nvar moveTo = new __WEBPACK_IMPORTED_MODULE_3_moveto___default.a({\n  ease: 'easeInQuad'\n}, easeFunctions);\n\nvar triggers = document.getElementsByClassName('js-trigger');\n\nfor (var i = 0; i < triggers.length; i++) {\n  moveTo.registerTrigger(triggers[i]);\n}\n\nfunction getDescendantWithClass(element, clName) {\n  var children = element.childNodes;\n  for (var i = 0; i < children.length; i++) {\n    if (children[i].className && children[i].className.split(' ').indexOf(clName) >= 0) {\n      return children[i];\n    }\n  }\n  for (var i = 0; i < children.length; i++) {\n    var match = getDescendantWithClass(children[i], clName);\n    if (match !== null) {\n      return match;\n    }\n  }\n  return null;\n}\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n!function (t, e) {\n\t\"object\" == ( false ? \"undefined\" : _typeof(exports)) && \"object\" == ( false ? \"undefined\" : _typeof(module)) ? module.exports = e() :  true ? !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (e),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : \"object\" == (typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) ? exports.VueParallaxy = e() : t.VueParallaxy = e();\n}(this, function () {\n\treturn function (t) {\n\t\tfunction e(n) {\n\t\t\tif (r[n]) return r[n].exports;var i = r[n] = { exports: {}, id: n, loaded: !1 };return t[n].call(i.exports, i, i.exports, e), i.loaded = !0, i.exports;\n\t\t}var r = {};return e.m = t, e.c = r, e.p = \"\", e(0);\n\t}([function (t, e, r) {\n\t\t\"use strict\";\n\t\tfunction n(t) {\n\t\t\treturn t && t.__esModule ? t : { default: t };\n\t\t}var i = r(8),\n\t\t    o = n(i);t.exports = o.default;\n\t}, function (t, e) {\n\t\t\"use strict\";\n\t\tObject.defineProperty(e, \"__esModule\", { value: !0 }), e.default = { props: { parallax: { default: !0, type: Boolean }, speedFactor: { default: .15, type: Number }, fixed: { default: !1, type: Boolean }, breakpoint: { default: \"(min-width: 968px)\", type: String }, sectionHeight: { default: 70, type: Number, required: !1 }, sectionClass: { type: String, default: \"Masthead\" }, containerClass: { type: String, default: \"Masthead__image\" }, parallaxClass: { type: String, default: \"is-parallax\" }, fixedClass: { type: String, default: \"is-fixed\" } }, data: function data() {\n\t\t\t\treturn { el: null, mediaQuery: null };\n\t\t\t}, mounted: function mounted() {\n\t\t\t\tthis.parallax && !this.fixed && (this.el = this.$refs.parallax, window.requestAnimationFrame = window.requestAnimationFrame || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || window.msRequestAnimationFrame || function (t) {\n\t\t\t\t\tsetTimeout(t, 1e3 / 60);\n\t\t\t\t}, this.init());\n\t\t\t}, methods: { animateElement: function animateElement() {\n\t\t\t\t\tvar t = this.$refs.block.offsetHeight,\n\t\t\t\t\t    e = this.$refs.parallax.offsetHeight,\n\t\t\t\t\t    r = e - t,\n\t\t\t\t\t    n = window.pageYOffset * this.speedFactor;n <= r && n >= 0 && (this.el.style.transform = \"translate3d(0, \" + n * -1 + \"px ,0)\");\n\t\t\t\t}, scrollHandler: function scrollHandler() {\n\t\t\t\t\tvar t = this;window.requestAnimationFrame(function () {\n\t\t\t\t\t\tt.isInView(t.$refs.parallax) && t.animateElement();\n\t\t\t\t\t});\n\t\t\t\t}, isInView: function isInView(t) {\n\t\t\t\t\tvar e = t.getBoundingClientRect();return e.bottom >= 0 && e.top <= (window.innerHeight || document.documentElement.clientHeight);\n\t\t\t\t}, setupListener: function setupListener() {\n\t\t\t\t\tthis.mediaQuery.matches ? window.addEventListener(\"scroll\", this.scrollHandler, !1) : window.removeEventListener(\"scroll\", this.scrollHandler, !1);\n\t\t\t\t}, init: function init() {\n\t\t\t\t\tthis.mediaQuery = window.matchMedia(this.breakpoint), this.mediaQuery && (this.mediaQuery.addListener(this.setupListener), this.setupListener());\n\t\t\t\t} } };\n\t}, function (t, e) {\n\t\t\"use strict\";\n\t\tfunction r(t) {\n\t\t\tvar e = t.length;if (e % 4 > 0) throw new Error(\"Invalid string. Length must be a multiple of 4\");return \"=\" === t[e - 2] ? 2 : \"=\" === t[e - 1] ? 1 : 0;\n\t\t}function n(t) {\n\t\t\treturn 3 * t.length / 4 - r(t);\n\t\t}function i(t) {\n\t\t\tvar e,\n\t\t\t    n,\n\t\t\t    i,\n\t\t\t    o,\n\t\t\t    a,\n\t\t\t    s,\n\t\t\t    u = t.length;a = r(t), s = new h(3 * u / 4 - a), i = a > 0 ? u - 4 : u;var c = 0;for (e = 0, n = 0; e < i; e += 4, n += 3) {\n\t\t\t\to = f[t.charCodeAt(e)] << 18 | f[t.charCodeAt(e + 1)] << 12 | f[t.charCodeAt(e + 2)] << 6 | f[t.charCodeAt(e + 3)], s[c++] = o >> 16 & 255, s[c++] = o >> 8 & 255, s[c++] = 255 & o;\n\t\t\t}return 2 === a ? (o = f[t.charCodeAt(e)] << 2 | f[t.charCodeAt(e + 1)] >> 4, s[c++] = 255 & o) : 1 === a && (o = f[t.charCodeAt(e)] << 10 | f[t.charCodeAt(e + 1)] << 4 | f[t.charCodeAt(e + 2)] >> 2, s[c++] = o >> 8 & 255, s[c++] = 255 & o), s;\n\t\t}function o(t) {\n\t\t\treturn u[t >> 18 & 63] + u[t >> 12 & 63] + u[t >> 6 & 63] + u[63 & t];\n\t\t}function a(t, e, r) {\n\t\t\tfor (var n, i = [], a = e; a < r; a += 3) {\n\t\t\t\tn = (t[a] << 16) + (t[a + 1] << 8) + t[a + 2], i.push(o(n));\n\t\t\t}return i.join(\"\");\n\t\t}function s(t) {\n\t\t\tfor (var e, r = t.length, n = r % 3, i = \"\", o = [], s = 16383, f = 0, h = r - n; f < h; f += s) {\n\t\t\t\to.push(a(t, f, f + s > h ? h : f + s));\n\t\t\t}return 1 === n ? (e = t[r - 1], i += u[e >> 2], i += u[e << 4 & 63], i += \"==\") : 2 === n && (e = (t[r - 2] << 8) + t[r - 1], i += u[e >> 10], i += u[e >> 4 & 63], i += u[e << 2 & 63], i += \"=\"), o.push(i), o.join(\"\");\n\t\t}e.byteLength = n, e.toByteArray = i, e.fromByteArray = s;for (var u = [], f = [], h = \"undefined\" != typeof Uint8Array ? Uint8Array : Array, c = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\", l = 0, p = c.length; l < p; ++l) {\n\t\t\tu[l] = c[l], f[c.charCodeAt(l)] = l;\n\t\t}f[\"-\".charCodeAt(0)] = 62, f[\"_\".charCodeAt(0)] = 63;\n\t}, function (t, e, r) {\n\t\t(function (t) {\n\t\t\t/*!\n   * The buffer module from node.js, for the browser.\n   *\n   * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n   * @license  MIT\n   */\n\t\t\t\"use strict\";\n\t\t\tfunction n() {\n\t\t\t\ttry {\n\t\t\t\t\tvar t = new Uint8Array(1);return t.__proto__ = { __proto__: Uint8Array.prototype, foo: function foo() {\n\t\t\t\t\t\t\treturn 42;\n\t\t\t\t\t\t} }, 42 === t.foo() && \"function\" == typeof t.subarray && 0 === t.subarray(1, 1).byteLength;\n\t\t\t\t} catch (t) {\n\t\t\t\t\treturn !1;\n\t\t\t\t}\n\t\t\t}function i() {\n\t\t\t\treturn a.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823;\n\t\t\t}function o(t, e) {\n\t\t\t\tif (i() < e) throw new RangeError(\"Invalid typed array length\");return a.TYPED_ARRAY_SUPPORT ? (t = new Uint8Array(e), t.__proto__ = a.prototype) : (null === t && (t = new a(e)), t.length = e), t;\n\t\t\t}function a(t, e, r) {\n\t\t\t\tif (!(a.TYPED_ARRAY_SUPPORT || this instanceof a)) return new a(t, e, r);if (\"number\" == typeof t) {\n\t\t\t\t\tif (\"string\" == typeof e) throw new Error(\"If encoding is specified then the first argument must be a string\");return h(this, t);\n\t\t\t\t}return s(this, t, e, r);\n\t\t\t}function s(t, e, r, n) {\n\t\t\t\tif (\"number\" == typeof e) throw new TypeError('\"value\" argument must not be a number');return \"undefined\" != typeof ArrayBuffer && e instanceof ArrayBuffer ? p(t, e, r, n) : \"string\" == typeof e ? c(t, e, r) : d(t, e);\n\t\t\t}function u(t) {\n\t\t\t\tif (\"number\" != typeof t) throw new TypeError('\"size\" argument must be a number');if (t < 0) throw new RangeError('\"size\" argument must not be negative');\n\t\t\t}function f(t, e, r, n) {\n\t\t\t\treturn u(e), e <= 0 ? o(t, e) : void 0 !== r ? \"string\" == typeof n ? o(t, e).fill(r, n) : o(t, e).fill(r) : o(t, e);\n\t\t\t}function h(t, e) {\n\t\t\t\tif (u(e), t = o(t, e < 0 ? 0 : 0 | g(e)), !a.TYPED_ARRAY_SUPPORT) for (var r = 0; r < e; ++r) {\n\t\t\t\t\tt[r] = 0;\n\t\t\t\t}return t;\n\t\t\t}function c(t, e, r) {\n\t\t\t\tif (\"string\" == typeof r && \"\" !== r || (r = \"utf8\"), !a.isEncoding(r)) throw new TypeError('\"encoding\" must be a valid string encoding');var n = 0 | A(e, r);t = o(t, n);var i = t.write(e, r);return i !== n && (t = t.slice(0, i)), t;\n\t\t\t}function l(t, e) {\n\t\t\t\tvar r = e.length < 0 ? 0 : 0 | g(e.length);t = o(t, r);for (var n = 0; n < r; n += 1) {\n\t\t\t\t\tt[n] = 255 & e[n];\n\t\t\t\t}return t;\n\t\t\t}function p(t, e, r, n) {\n\t\t\t\tif (e.byteLength, r < 0 || e.byteLength < r) throw new RangeError(\"'offset' is out of bounds\");if (e.byteLength < r + (n || 0)) throw new RangeError(\"'length' is out of bounds\");return e = void 0 === r && void 0 === n ? new Uint8Array(e) : void 0 === n ? new Uint8Array(e, r) : new Uint8Array(e, r, n), a.TYPED_ARRAY_SUPPORT ? (t = e, t.__proto__ = a.prototype) : t = l(t, e), t;\n\t\t\t}function d(t, e) {\n\t\t\t\tif (a.isBuffer(e)) {\n\t\t\t\t\tvar r = 0 | g(e.length);return t = o(t, r), 0 === t.length ? t : (e.copy(t, 0, 0, r), t);\n\t\t\t\t}if (e) {\n\t\t\t\t\tif (\"undefined\" != typeof ArrayBuffer && e.buffer instanceof ArrayBuffer || \"length\" in e) return \"number\" != typeof e.length || K(e.length) ? o(t, 0) : l(t, e);if (\"Buffer\" === e.type && Z(e.data)) return l(t, e.data);\n\t\t\t\t}throw new TypeError(\"First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.\");\n\t\t\t}function g(t) {\n\t\t\t\tif (t >= i()) throw new RangeError(\"Attempt to allocate Buffer larger than maximum size: 0x\" + i().toString(16) + \" bytes\");return 0 | t;\n\t\t\t}function y(t) {\n\t\t\t\treturn +t != t && (t = 0), a.alloc(+t);\n\t\t\t}function A(t, e) {\n\t\t\t\tif (a.isBuffer(t)) return t.length;if (\"undefined\" != typeof ArrayBuffer && \"function\" == typeof ArrayBuffer.isView && (ArrayBuffer.isView(t) || t instanceof ArrayBuffer)) return t.byteLength;\"string\" != typeof t && (t = \"\" + t);var r = t.length;if (0 === r) return 0;for (var n = !1;;) {\n\t\t\t\t\tswitch (e) {case \"ascii\":case \"latin1\":case \"binary\":\n\t\t\t\t\t\t\treturn r;case \"utf8\":case \"utf-8\":case void 0:\n\t\t\t\t\t\t\treturn W(t).length;case \"ucs2\":case \"ucs-2\":case \"utf16le\":case \"utf-16le\":\n\t\t\t\t\t\t\treturn 2 * r;case \"hex\":\n\t\t\t\t\t\t\treturn r >>> 1;case \"base64\":\n\t\t\t\t\t\t\treturn $(t).length;default:\n\t\t\t\t\t\t\tif (n) return W(t).length;e = (\"\" + e).toLowerCase(), n = !0;}\n\t\t\t\t}\n\t\t\t}function m(t, e, r) {\n\t\t\t\tvar n = !1;if ((void 0 === e || e < 0) && (e = 0), e > this.length) return \"\";if ((void 0 === r || r > this.length) && (r = this.length), r <= 0) return \"\";if (r >>>= 0, e >>>= 0, r <= e) return \"\";for (t || (t = \"utf8\");;) {\n\t\t\t\t\tswitch (t) {case \"hex\":\n\t\t\t\t\t\t\treturn Y(this, e, r);case \"utf8\":case \"utf-8\":\n\t\t\t\t\t\t\treturn T(this, e, r);case \"ascii\":\n\t\t\t\t\t\t\treturn S(this, e, r);case \"latin1\":case \"binary\":\n\t\t\t\t\t\t\treturn M(this, e, r);case \"base64\":\n\t\t\t\t\t\t\treturn P(this, e, r);case \"ucs2\":case \"ucs-2\":case \"utf16le\":case \"utf-16le\":\n\t\t\t\t\t\t\treturn j(this, e, r);default:\n\t\t\t\t\t\t\tif (n) throw new TypeError(\"Unknown encoding: \" + t);t = (t + \"\").toLowerCase(), n = !0;}\n\t\t\t\t}\n\t\t\t}function v(t, e, r) {\n\t\t\t\tvar n = t[e];t[e] = t[r], t[r] = n;\n\t\t\t}function w(t, e, r, n, i) {\n\t\t\t\tif (0 === t.length) return -1;if (\"string\" == typeof r ? (n = r, r = 0) : r > 2147483647 ? r = 2147483647 : r < -2147483648 && (r = -2147483648), r = +r, isNaN(r) && (r = i ? 0 : t.length - 1), r < 0 && (r = t.length + r), r >= t.length) {\n\t\t\t\t\tif (i) return -1;r = t.length - 1;\n\t\t\t\t} else if (r < 0) {\n\t\t\t\t\tif (!i) return -1;r = 0;\n\t\t\t\t}if (\"string\" == typeof e && (e = a.from(e, n)), a.isBuffer(e)) return 0 === e.length ? -1 : b(t, e, r, n, i);if (\"number\" == typeof e) return e &= 255, a.TYPED_ARRAY_SUPPORT && \"function\" == typeof Uint8Array.prototype.indexOf ? i ? Uint8Array.prototype.indexOf.call(t, e, r) : Uint8Array.prototype.lastIndexOf.call(t, e, r) : b(t, [e], r, n, i);throw new TypeError(\"val must be string, number or Buffer\");\n\t\t\t}function b(t, e, r, n, i) {\n\t\t\t\tfunction o(t, e) {\n\t\t\t\t\treturn 1 === a ? t[e] : t.readUInt16BE(e * a);\n\t\t\t\t}var a = 1,\n\t\t\t\t    s = t.length,\n\t\t\t\t    u = e.length;if (void 0 !== n && (n = String(n).toLowerCase(), \"ucs2\" === n || \"ucs-2\" === n || \"utf16le\" === n || \"utf-16le\" === n)) {\n\t\t\t\t\tif (t.length < 2 || e.length < 2) return -1;a = 2, s /= 2, u /= 2, r /= 2;\n\t\t\t\t}var f;if (i) {\n\t\t\t\t\tvar h = -1;for (f = r; f < s; f++) {\n\t\t\t\t\t\tif (o(t, f) === o(e, h === -1 ? 0 : f - h)) {\n\t\t\t\t\t\t\tif (h === -1 && (h = f), f - h + 1 === u) return h * a;\n\t\t\t\t\t\t} else h !== -1 && (f -= f - h), h = -1;\n\t\t\t\t\t}\n\t\t\t\t} else for (r + u > s && (r = s - u), f = r; f >= 0; f--) {\n\t\t\t\t\tfor (var c = !0, l = 0; l < u; l++) {\n\t\t\t\t\t\tif (o(t, f + l) !== o(e, l)) {\n\t\t\t\t\t\t\tc = !1;break;\n\t\t\t\t\t\t}\n\t\t\t\t\t}if (c) return f;\n\t\t\t\t}return -1;\n\t\t\t}function _(t, e, r, n) {\n\t\t\t\tr = Number(r) || 0;var i = t.length - r;n ? (n = Number(n), n > i && (n = i)) : n = i;var o = e.length;if (o % 2 !== 0) throw new TypeError(\"Invalid hex string\");n > o / 2 && (n = o / 2);for (var a = 0; a < n; ++a) {\n\t\t\t\t\tvar s = parseInt(e.substr(2 * a, 2), 16);if (isNaN(s)) return a;t[r + a] = s;\n\t\t\t\t}return a;\n\t\t\t}function B(t, e, r, n) {\n\t\t\t\treturn J(W(e, t.length - r), t, r, n);\n\t\t\t}function E(t, e, r, n) {\n\t\t\t\treturn J(Q(e), t, r, n);\n\t\t\t}function R(t, e, r, n) {\n\t\t\t\treturn E(t, e, r, n);\n\t\t\t}function x(t, e, r, n) {\n\t\t\t\treturn J($(e), t, r, n);\n\t\t\t}function C(t, e, r, n) {\n\t\t\t\treturn J(V(e, t.length - r), t, r, n);\n\t\t\t}function P(t, e, r) {\n\t\t\t\treturn 0 === e && r === t.length ? X.fromByteArray(t) : X.fromByteArray(t.slice(e, r));\n\t\t\t}function T(t, e, r) {\n\t\t\t\tr = Math.min(t.length, r);for (var n = [], i = e; i < r;) {\n\t\t\t\t\tvar o = t[i],\n\t\t\t\t\t    a = null,\n\t\t\t\t\t    s = o > 239 ? 4 : o > 223 ? 3 : o > 191 ? 2 : 1;if (i + s <= r) {\n\t\t\t\t\t\tvar u, f, h, c;switch (s) {case 1:\n\t\t\t\t\t\t\t\to < 128 && (a = o);break;case 2:\n\t\t\t\t\t\t\t\tu = t[i + 1], 128 === (192 & u) && (c = (31 & o) << 6 | 63 & u, c > 127 && (a = c));break;case 3:\n\t\t\t\t\t\t\t\tu = t[i + 1], f = t[i + 2], 128 === (192 & u) && 128 === (192 & f) && (c = (15 & o) << 12 | (63 & u) << 6 | 63 & f, c > 2047 && (c < 55296 || c > 57343) && (a = c));break;case 4:\n\t\t\t\t\t\t\t\tu = t[i + 1], f = t[i + 2], h = t[i + 3], 128 === (192 & u) && 128 === (192 & f) && 128 === (192 & h) && (c = (15 & o) << 18 | (63 & u) << 12 | (63 & f) << 6 | 63 & h, c > 65535 && c < 1114112 && (a = c));}\n\t\t\t\t\t}null === a ? (a = 65533, s = 1) : a > 65535 && (a -= 65536, n.push(a >>> 10 & 1023 | 55296), a = 56320 | 1023 & a), n.push(a), i += s;\n\t\t\t\t}return U(n);\n\t\t\t}function U(t) {\n\t\t\t\tvar e = t.length;if (e <= tt) return String.fromCharCode.apply(String, t);for (var r = \"\", n = 0; n < e;) {\n\t\t\t\t\tr += String.fromCharCode.apply(String, t.slice(n, n += tt));\n\t\t\t\t}return r;\n\t\t\t}function S(t, e, r) {\n\t\t\t\tvar n = \"\";r = Math.min(t.length, r);for (var i = e; i < r; ++i) {\n\t\t\t\t\tn += String.fromCharCode(127 & t[i]);\n\t\t\t\t}return n;\n\t\t\t}function M(t, e, r) {\n\t\t\t\tvar n = \"\";r = Math.min(t.length, r);for (var i = e; i < r; ++i) {\n\t\t\t\t\tn += String.fromCharCode(t[i]);\n\t\t\t\t}return n;\n\t\t\t}function Y(t, e, r) {\n\t\t\t\tvar n = t.length;(!e || e < 0) && (e = 0), (!r || r < 0 || r > n) && (r = n);for (var i = \"\", o = e; o < r; ++o) {\n\t\t\t\t\ti += H(t[o]);\n\t\t\t\t}return i;\n\t\t\t}function j(t, e, r) {\n\t\t\t\tfor (var n = t.slice(e, r), i = \"\", o = 0; o < n.length; o += 2) {\n\t\t\t\t\ti += String.fromCharCode(n[o] + 256 * n[o + 1]);\n\t\t\t\t}return i;\n\t\t\t}function I(t, e, r) {\n\t\t\t\tif (t % 1 !== 0 || t < 0) throw new RangeError(\"offset is not uint\");if (t + e > r) throw new RangeError(\"Trying to access beyond buffer length\");\n\t\t\t}function L(t, e, r, n, i, o) {\n\t\t\t\tif (!a.isBuffer(t)) throw new TypeError('\"buffer\" argument must be a Buffer instance');if (e > i || e < o) throw new RangeError('\"value\" argument is out of bounds');if (r + n > t.length) throw new RangeError(\"Index out of range\");\n\t\t\t}function D(t, e, r, n) {\n\t\t\t\te < 0 && (e = 65535 + e + 1);for (var i = 0, o = Math.min(t.length - r, 2); i < o; ++i) {\n\t\t\t\t\tt[r + i] = (e & 255 << 8 * (n ? i : 1 - i)) >>> 8 * (n ? i : 1 - i);\n\t\t\t\t}\n\t\t\t}function O(t, e, r, n) {\n\t\t\t\te < 0 && (e = 4294967295 + e + 1);for (var i = 0, o = Math.min(t.length - r, 4); i < o; ++i) {\n\t\t\t\t\tt[r + i] = e >>> 8 * (n ? i : 3 - i) & 255;\n\t\t\t\t}\n\t\t\t}function k(t, e, r, n, i, o) {\n\t\t\t\tif (r + n > t.length) throw new RangeError(\"Index out of range\");if (r < 0) throw new RangeError(\"Index out of range\");\n\t\t\t}function N(t, e, r, n, i) {\n\t\t\t\treturn i || k(t, e, r, 4, 3.4028234663852886e38, -3.4028234663852886e38), G.write(t, e, r, n, 23, 4), r + 4;\n\t\t\t}function F(t, e, r, n, i) {\n\t\t\t\treturn i || k(t, e, r, 8, 1.7976931348623157e308, -1.7976931348623157e308), G.write(t, e, r, n, 52, 8), r + 8;\n\t\t\t}function z(t) {\n\t\t\t\tif (t = q(t).replace(et, \"\"), t.length < 2) return \"\";for (; t.length % 4 !== 0;) {\n\t\t\t\t\tt += \"=\";\n\t\t\t\t}return t;\n\t\t\t}function q(t) {\n\t\t\t\treturn t.trim ? t.trim() : t.replace(/^\\s+|\\s+$/g, \"\");\n\t\t\t}function H(t) {\n\t\t\t\treturn t < 16 ? \"0\" + t.toString(16) : t.toString(16);\n\t\t\t}function W(t, e) {\n\t\t\t\te = e || 1 / 0;for (var r, n = t.length, i = null, o = [], a = 0; a < n; ++a) {\n\t\t\t\t\tif (r = t.charCodeAt(a), r > 55295 && r < 57344) {\n\t\t\t\t\t\tif (!i) {\n\t\t\t\t\t\t\tif (r > 56319) {\n\t\t\t\t\t\t\t\t(e -= 3) > -1 && o.push(239, 191, 189);continue;\n\t\t\t\t\t\t\t}if (a + 1 === n) {\n\t\t\t\t\t\t\t\t(e -= 3) > -1 && o.push(239, 191, 189);continue;\n\t\t\t\t\t\t\t}i = r;continue;\n\t\t\t\t\t\t}if (r < 56320) {\n\t\t\t\t\t\t\t(e -= 3) > -1 && o.push(239, 191, 189), i = r;continue;\n\t\t\t\t\t\t}r = (i - 55296 << 10 | r - 56320) + 65536;\n\t\t\t\t\t} else i && (e -= 3) > -1 && o.push(239, 191, 189);if (i = null, r < 128) {\n\t\t\t\t\t\tif ((e -= 1) < 0) break;o.push(r);\n\t\t\t\t\t} else if (r < 2048) {\n\t\t\t\t\t\tif ((e -= 2) < 0) break;o.push(r >> 6 | 192, 63 & r | 128);\n\t\t\t\t\t} else if (r < 65536) {\n\t\t\t\t\t\tif ((e -= 3) < 0) break;o.push(r >> 12 | 224, r >> 6 & 63 | 128, 63 & r | 128);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif (!(r < 1114112)) throw new Error(\"Invalid code point\");if ((e -= 4) < 0) break;o.push(r >> 18 | 240, r >> 12 & 63 | 128, r >> 6 & 63 | 128, 63 & r | 128);\n\t\t\t\t\t}\n\t\t\t\t}return o;\n\t\t\t}function Q(t) {\n\t\t\t\tfor (var e = [], r = 0; r < t.length; ++r) {\n\t\t\t\t\te.push(255 & t.charCodeAt(r));\n\t\t\t\t}return e;\n\t\t\t}function V(t, e) {\n\t\t\t\tfor (var r, n, i, o = [], a = 0; a < t.length && !((e -= 2) < 0); ++a) {\n\t\t\t\t\tr = t.charCodeAt(a), n = r >> 8, i = r % 256, o.push(i), o.push(n);\n\t\t\t\t}return o;\n\t\t\t}function $(t) {\n\t\t\t\treturn X.toByteArray(z(t));\n\t\t\t}function J(t, e, r, n) {\n\t\t\t\tfor (var i = 0; i < n && !(i + r >= e.length || i >= t.length); ++i) {\n\t\t\t\t\te[i + r] = t[i];\n\t\t\t\t}return i;\n\t\t\t}function K(t) {\n\t\t\t\treturn t !== t;\n\t\t\t}var X = r(2),\n\t\t\t    G = r(6),\n\t\t\t    Z = r(7);e.Buffer = a, e.SlowBuffer = y, e.INSPECT_MAX_BYTES = 50, a.TYPED_ARRAY_SUPPORT = void 0 !== t.TYPED_ARRAY_SUPPORT ? t.TYPED_ARRAY_SUPPORT : n(), e.kMaxLength = i(), a.poolSize = 8192, a._augment = function (t) {\n\t\t\t\treturn t.__proto__ = a.prototype, t;\n\t\t\t}, a.from = function (t, e, r) {\n\t\t\t\treturn s(null, t, e, r);\n\t\t\t}, a.TYPED_ARRAY_SUPPORT && (a.prototype.__proto__ = Uint8Array.prototype, a.__proto__ = Uint8Array, \"undefined\" != typeof Symbol && Symbol.species && a[Symbol.species] === a && Object.defineProperty(a, Symbol.species, { value: null, configurable: !0 })), a.alloc = function (t, e, r) {\n\t\t\t\treturn f(null, t, e, r);\n\t\t\t}, a.allocUnsafe = function (t) {\n\t\t\t\treturn h(null, t);\n\t\t\t}, a.allocUnsafeSlow = function (t) {\n\t\t\t\treturn h(null, t);\n\t\t\t}, a.isBuffer = function (t) {\n\t\t\t\treturn !(null == t || !t._isBuffer);\n\t\t\t}, a.compare = function (t, e) {\n\t\t\t\tif (!a.isBuffer(t) || !a.isBuffer(e)) throw new TypeError(\"Arguments must be Buffers\");if (t === e) return 0;for (var r = t.length, n = e.length, i = 0, o = Math.min(r, n); i < o; ++i) {\n\t\t\t\t\tif (t[i] !== e[i]) {\n\t\t\t\t\t\tr = t[i], n = e[i];break;\n\t\t\t\t\t}\n\t\t\t\t}return r < n ? -1 : n < r ? 1 : 0;\n\t\t\t}, a.isEncoding = function (t) {\n\t\t\t\tswitch (String(t).toLowerCase()) {case \"hex\":case \"utf8\":case \"utf-8\":case \"ascii\":case \"latin1\":case \"binary\":case \"base64\":case \"ucs2\":case \"ucs-2\":case \"utf16le\":case \"utf-16le\":\n\t\t\t\t\t\treturn !0;default:\n\t\t\t\t\t\treturn !1;}\n\t\t\t}, a.concat = function (t, e) {\n\t\t\t\tif (!Z(t)) throw new TypeError('\"list\" argument must be an Array of Buffers');if (0 === t.length) return a.alloc(0);var r;if (void 0 === e) for (e = 0, r = 0; r < t.length; ++r) {\n\t\t\t\t\te += t[r].length;\n\t\t\t\t}var n = a.allocUnsafe(e),\n\t\t\t\t    i = 0;for (r = 0; r < t.length; ++r) {\n\t\t\t\t\tvar o = t[r];if (!a.isBuffer(o)) throw new TypeError('\"list\" argument must be an Array of Buffers');o.copy(n, i), i += o.length;\n\t\t\t\t}return n;\n\t\t\t}, a.byteLength = A, a.prototype._isBuffer = !0, a.prototype.swap16 = function () {\n\t\t\t\tvar t = this.length;if (t % 2 !== 0) throw new RangeError(\"Buffer size must be a multiple of 16-bits\");for (var e = 0; e < t; e += 2) {\n\t\t\t\t\tv(this, e, e + 1);\n\t\t\t\t}return this;\n\t\t\t}, a.prototype.swap32 = function () {\n\t\t\t\tvar t = this.length;if (t % 4 !== 0) throw new RangeError(\"Buffer size must be a multiple of 32-bits\");for (var e = 0; e < t; e += 4) {\n\t\t\t\t\tv(this, e, e + 3), v(this, e + 1, e + 2);\n\t\t\t\t}return this;\n\t\t\t}, a.prototype.swap64 = function () {\n\t\t\t\tvar t = this.length;if (t % 8 !== 0) throw new RangeError(\"Buffer size must be a multiple of 64-bits\");for (var e = 0; e < t; e += 8) {\n\t\t\t\t\tv(this, e, e + 7), v(this, e + 1, e + 6), v(this, e + 2, e + 5), v(this, e + 3, e + 4);\n\t\t\t\t}return this;\n\t\t\t}, a.prototype.toString = function () {\n\t\t\t\tvar t = 0 | this.length;return 0 === t ? \"\" : 0 === arguments.length ? T(this, 0, t) : m.apply(this, arguments);\n\t\t\t}, a.prototype.equals = function (t) {\n\t\t\t\tif (!a.isBuffer(t)) throw new TypeError(\"Argument must be a Buffer\");return this === t || 0 === a.compare(this, t);\n\t\t\t}, a.prototype.inspect = function () {\n\t\t\t\tvar t = \"\",\n\t\t\t\t    r = e.INSPECT_MAX_BYTES;return this.length > 0 && (t = this.toString(\"hex\", 0, r).match(/.{2}/g).join(\" \"), this.length > r && (t += \" ... \")), \"<Buffer \" + t + \">\";\n\t\t\t}, a.prototype.compare = function (t, e, r, n, i) {\n\t\t\t\tif (!a.isBuffer(t)) throw new TypeError(\"Argument must be a Buffer\");if (void 0 === e && (e = 0), void 0 === r && (r = t ? t.length : 0), void 0 === n && (n = 0), void 0 === i && (i = this.length), e < 0 || r > t.length || n < 0 || i > this.length) throw new RangeError(\"out of range index\");if (n >= i && e >= r) return 0;if (n >= i) return -1;if (e >= r) return 1;if (e >>>= 0, r >>>= 0, n >>>= 0, i >>>= 0, this === t) return 0;for (var o = i - n, s = r - e, u = Math.min(o, s), f = this.slice(n, i), h = t.slice(e, r), c = 0; c < u; ++c) {\n\t\t\t\t\tif (f[c] !== h[c]) {\n\t\t\t\t\t\to = f[c], s = h[c];break;\n\t\t\t\t\t}\n\t\t\t\t}return o < s ? -1 : s < o ? 1 : 0;\n\t\t\t}, a.prototype.includes = function (t, e, r) {\n\t\t\t\treturn this.indexOf(t, e, r) !== -1;\n\t\t\t}, a.prototype.indexOf = function (t, e, r) {\n\t\t\t\treturn w(this, t, e, r, !0);\n\t\t\t}, a.prototype.lastIndexOf = function (t, e, r) {\n\t\t\t\treturn w(this, t, e, r, !1);\n\t\t\t}, a.prototype.write = function (t, e, r, n) {\n\t\t\t\tif (void 0 === e) n = \"utf8\", r = this.length, e = 0;else if (void 0 === r && \"string\" == typeof e) n = e, r = this.length, e = 0;else {\n\t\t\t\t\tif (!isFinite(e)) throw new Error(\"Buffer.write(string, encoding, offset[, length]) is no longer supported\");e |= 0, isFinite(r) ? (r |= 0, void 0 === n && (n = \"utf8\")) : (n = r, r = void 0);\n\t\t\t\t}var i = this.length - e;if ((void 0 === r || r > i) && (r = i), t.length > 0 && (r < 0 || e < 0) || e > this.length) throw new RangeError(\"Attempt to write outside buffer bounds\");n || (n = \"utf8\");for (var o = !1;;) {\n\t\t\t\t\tswitch (n) {case \"hex\":\n\t\t\t\t\t\t\treturn _(this, t, e, r);case \"utf8\":case \"utf-8\":\n\t\t\t\t\t\t\treturn B(this, t, e, r);case \"ascii\":\n\t\t\t\t\t\t\treturn E(this, t, e, r);case \"latin1\":case \"binary\":\n\t\t\t\t\t\t\treturn R(this, t, e, r);case \"base64\":\n\t\t\t\t\t\t\treturn x(this, t, e, r);case \"ucs2\":case \"ucs-2\":case \"utf16le\":case \"utf-16le\":\n\t\t\t\t\t\t\treturn C(this, t, e, r);default:\n\t\t\t\t\t\t\tif (o) throw new TypeError(\"Unknown encoding: \" + n);n = (\"\" + n).toLowerCase(), o = !0;}\n\t\t\t\t}\n\t\t\t}, a.prototype.toJSON = function () {\n\t\t\t\treturn { type: \"Buffer\", data: Array.prototype.slice.call(this._arr || this, 0) };\n\t\t\t};var tt = 4096;a.prototype.slice = function (t, e) {\n\t\t\t\tvar r = this.length;t = ~~t, e = void 0 === e ? r : ~~e, t < 0 ? (t += r, t < 0 && (t = 0)) : t > r && (t = r), e < 0 ? (e += r, e < 0 && (e = 0)) : e > r && (e = r), e < t && (e = t);var n;if (a.TYPED_ARRAY_SUPPORT) n = this.subarray(t, e), n.__proto__ = a.prototype;else {\n\t\t\t\t\tvar i = e - t;n = new a(i, void 0);for (var o = 0; o < i; ++o) {\n\t\t\t\t\t\tn[o] = this[o + t];\n\t\t\t\t\t}\n\t\t\t\t}return n;\n\t\t\t}, a.prototype.readUIntLE = function (t, e, r) {\n\t\t\t\tt |= 0, e |= 0, r || I(t, e, this.length);for (var n = this[t], i = 1, o = 0; ++o < e && (i *= 256);) {\n\t\t\t\t\tn += this[t + o] * i;\n\t\t\t\t}return n;\n\t\t\t}, a.prototype.readUIntBE = function (t, e, r) {\n\t\t\t\tt |= 0, e |= 0, r || I(t, e, this.length);for (var n = this[t + --e], i = 1; e > 0 && (i *= 256);) {\n\t\t\t\t\tn += this[t + --e] * i;\n\t\t\t\t}return n;\n\t\t\t}, a.prototype.readUInt8 = function (t, e) {\n\t\t\t\treturn e || I(t, 1, this.length), this[t];\n\t\t\t}, a.prototype.readUInt16LE = function (t, e) {\n\t\t\t\treturn e || I(t, 2, this.length), this[t] | this[t + 1] << 8;\n\t\t\t}, a.prototype.readUInt16BE = function (t, e) {\n\t\t\t\treturn e || I(t, 2, this.length), this[t] << 8 | this[t + 1];\n\t\t\t}, a.prototype.readUInt32LE = function (t, e) {\n\t\t\t\treturn e || I(t, 4, this.length), (this[t] | this[t + 1] << 8 | this[t + 2] << 16) + 16777216 * this[t + 3];\n\t\t\t}, a.prototype.readUInt32BE = function (t, e) {\n\t\t\t\treturn e || I(t, 4, this.length), 16777216 * this[t] + (this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3]);\n\t\t\t}, a.prototype.readIntLE = function (t, e, r) {\n\t\t\t\tt |= 0, e |= 0, r || I(t, e, this.length);for (var n = this[t], i = 1, o = 0; ++o < e && (i *= 256);) {\n\t\t\t\t\tn += this[t + o] * i;\n\t\t\t\t}return i *= 128, n >= i && (n -= Math.pow(2, 8 * e)), n;\n\t\t\t}, a.prototype.readIntBE = function (t, e, r) {\n\t\t\t\tt |= 0, e |= 0, r || I(t, e, this.length);for (var n = e, i = 1, o = this[t + --n]; n > 0 && (i *= 256);) {\n\t\t\t\t\to += this[t + --n] * i;\n\t\t\t\t}return i *= 128, o >= i && (o -= Math.pow(2, 8 * e)), o;\n\t\t\t}, a.prototype.readInt8 = function (t, e) {\n\t\t\t\treturn e || I(t, 1, this.length), 128 & this[t] ? (255 - this[t] + 1) * -1 : this[t];\n\t\t\t}, a.prototype.readInt16LE = function (t, e) {\n\t\t\t\te || I(t, 2, this.length);var r = this[t] | this[t + 1] << 8;return 32768 & r ? 4294901760 | r : r;\n\t\t\t}, a.prototype.readInt16BE = function (t, e) {\n\t\t\t\te || I(t, 2, this.length);var r = this[t + 1] | this[t] << 8;return 32768 & r ? 4294901760 | r : r;\n\t\t\t}, a.prototype.readInt32LE = function (t, e) {\n\t\t\t\treturn e || I(t, 4, this.length), this[t] | this[t + 1] << 8 | this[t + 2] << 16 | this[t + 3] << 24;\n\t\t\t}, a.prototype.readInt32BE = function (t, e) {\n\t\t\t\treturn e || I(t, 4, this.length), this[t] << 24 | this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3];\n\t\t\t}, a.prototype.readFloatLE = function (t, e) {\n\t\t\t\treturn e || I(t, 4, this.length), G.read(this, t, !0, 23, 4);\n\t\t\t}, a.prototype.readFloatBE = function (t, e) {\n\t\t\t\treturn e || I(t, 4, this.length), G.read(this, t, !1, 23, 4);\n\t\t\t}, a.prototype.readDoubleLE = function (t, e) {\n\t\t\t\treturn e || I(t, 8, this.length), G.read(this, t, !0, 52, 8);\n\t\t\t}, a.prototype.readDoubleBE = function (t, e) {\n\t\t\t\treturn e || I(t, 8, this.length), G.read(this, t, !1, 52, 8);\n\t\t\t}, a.prototype.writeUIntLE = function (t, e, r, n) {\n\t\t\t\tif (t = +t, e |= 0, r |= 0, !n) {\n\t\t\t\t\tvar i = Math.pow(2, 8 * r) - 1;L(this, t, e, r, i, 0);\n\t\t\t\t}var o = 1,\n\t\t\t\t    a = 0;for (this[e] = 255 & t; ++a < r && (o *= 256);) {\n\t\t\t\t\tthis[e + a] = t / o & 255;\n\t\t\t\t}return e + r;\n\t\t\t}, a.prototype.writeUIntBE = function (t, e, r, n) {\n\t\t\t\tif (t = +t, e |= 0, r |= 0, !n) {\n\t\t\t\t\tvar i = Math.pow(2, 8 * r) - 1;L(this, t, e, r, i, 0);\n\t\t\t\t}var o = r - 1,\n\t\t\t\t    a = 1;for (this[e + o] = 255 & t; --o >= 0 && (a *= 256);) {\n\t\t\t\t\tthis[e + o] = t / a & 255;\n\t\t\t\t}return e + r;\n\t\t\t}, a.prototype.writeUInt8 = function (t, e, r) {\n\t\t\t\treturn t = +t, e |= 0, r || L(this, t, e, 1, 255, 0), a.TYPED_ARRAY_SUPPORT || (t = Math.floor(t)), this[e] = 255 & t, e + 1;\n\t\t\t}, a.prototype.writeUInt16LE = function (t, e, r) {\n\t\t\t\treturn t = +t, e |= 0, r || L(this, t, e, 2, 65535, 0), a.TYPED_ARRAY_SUPPORT ? (this[e] = 255 & t, this[e + 1] = t >>> 8) : D(this, t, e, !0), e + 2;\n\t\t\t}, a.prototype.writeUInt16BE = function (t, e, r) {\n\t\t\t\treturn t = +t, e |= 0, r || L(this, t, e, 2, 65535, 0), a.TYPED_ARRAY_SUPPORT ? (this[e] = t >>> 8, this[e + 1] = 255 & t) : D(this, t, e, !1), e + 2;\n\t\t\t}, a.prototype.writeUInt32LE = function (t, e, r) {\n\t\t\t\treturn t = +t, e |= 0, r || L(this, t, e, 4, 4294967295, 0), a.TYPED_ARRAY_SUPPORT ? (this[e + 3] = t >>> 24, this[e + 2] = t >>> 16, this[e + 1] = t >>> 8, this[e] = 255 & t) : O(this, t, e, !0), e + 4;\n\t\t\t}, a.prototype.writeUInt32BE = function (t, e, r) {\n\t\t\t\treturn t = +t, e |= 0, r || L(this, t, e, 4, 4294967295, 0), a.TYPED_ARRAY_SUPPORT ? (this[e] = t >>> 24, this[e + 1] = t >>> 16, this[e + 2] = t >>> 8, this[e + 3] = 255 & t) : O(this, t, e, !1), e + 4;\n\t\t\t}, a.prototype.writeIntLE = function (t, e, r, n) {\n\t\t\t\tif (t = +t, e |= 0, !n) {\n\t\t\t\t\tvar i = Math.pow(2, 8 * r - 1);L(this, t, e, r, i - 1, -i);\n\t\t\t\t}var o = 0,\n\t\t\t\t    a = 1,\n\t\t\t\t    s = 0;for (this[e] = 255 & t; ++o < r && (a *= 256);) {\n\t\t\t\t\tt < 0 && 0 === s && 0 !== this[e + o - 1] && (s = 1), this[e + o] = (t / a >> 0) - s & 255;\n\t\t\t\t}return e + r;\n\t\t\t}, a.prototype.writeIntBE = function (t, e, r, n) {\n\t\t\t\tif (t = +t, e |= 0, !n) {\n\t\t\t\t\tvar i = Math.pow(2, 8 * r - 1);L(this, t, e, r, i - 1, -i);\n\t\t\t\t}var o = r - 1,\n\t\t\t\t    a = 1,\n\t\t\t\t    s = 0;for (this[e + o] = 255 & t; --o >= 0 && (a *= 256);) {\n\t\t\t\t\tt < 0 && 0 === s && 0 !== this[e + o + 1] && (s = 1), this[e + o] = (t / a >> 0) - s & 255;\n\t\t\t\t}return e + r;\n\t\t\t}, a.prototype.writeInt8 = function (t, e, r) {\n\t\t\t\treturn t = +t, e |= 0, r || L(this, t, e, 1, 127, -128), a.TYPED_ARRAY_SUPPORT || (t = Math.floor(t)), t < 0 && (t = 255 + t + 1), this[e] = 255 & t, e + 1;\n\t\t\t}, a.prototype.writeInt16LE = function (t, e, r) {\n\t\t\t\treturn t = +t, e |= 0, r || L(this, t, e, 2, 32767, -32768), a.TYPED_ARRAY_SUPPORT ? (this[e] = 255 & t, this[e + 1] = t >>> 8) : D(this, t, e, !0), e + 2;\n\t\t\t}, a.prototype.writeInt16BE = function (t, e, r) {\n\t\t\t\treturn t = +t, e |= 0, r || L(this, t, e, 2, 32767, -32768), a.TYPED_ARRAY_SUPPORT ? (this[e] = t >>> 8, this[e + 1] = 255 & t) : D(this, t, e, !1), e + 2;\n\t\t\t}, a.prototype.writeInt32LE = function (t, e, r) {\n\t\t\t\treturn t = +t, e |= 0, r || L(this, t, e, 4, 2147483647, -2147483648), a.TYPED_ARRAY_SUPPORT ? (this[e] = 255 & t, this[e + 1] = t >>> 8, this[e + 2] = t >>> 16, this[e + 3] = t >>> 24) : O(this, t, e, !0), e + 4;\n\t\t\t}, a.prototype.writeInt32BE = function (t, e, r) {\n\t\t\t\treturn t = +t, e |= 0, r || L(this, t, e, 4, 2147483647, -2147483648), t < 0 && (t = 4294967295 + t + 1), a.TYPED_ARRAY_SUPPORT ? (this[e] = t >>> 24, this[e + 1] = t >>> 16, this[e + 2] = t >>> 8, this[e + 3] = 255 & t) : O(this, t, e, !1), e + 4;\n\t\t\t}, a.prototype.writeFloatLE = function (t, e, r) {\n\t\t\t\treturn N(this, t, e, !0, r);\n\t\t\t}, a.prototype.writeFloatBE = function (t, e, r) {\n\t\t\t\treturn N(this, t, e, !1, r);\n\t\t\t}, a.prototype.writeDoubleLE = function (t, e, r) {\n\t\t\t\treturn F(this, t, e, !0, r);\n\t\t\t}, a.prototype.writeDoubleBE = function (t, e, r) {\n\t\t\t\treturn F(this, t, e, !1, r);\n\t\t\t}, a.prototype.copy = function (t, e, r, n) {\n\t\t\t\tif (r || (r = 0), n || 0 === n || (n = this.length), e >= t.length && (e = t.length), e || (e = 0), n > 0 && n < r && (n = r), n === r) return 0;if (0 === t.length || 0 === this.length) return 0;if (e < 0) throw new RangeError(\"targetStart out of bounds\");if (r < 0 || r >= this.length) throw new RangeError(\"sourceStart out of bounds\");if (n < 0) throw new RangeError(\"sourceEnd out of bounds\");n > this.length && (n = this.length), t.length - e < n - r && (n = t.length - e + r);var i,\n\t\t\t\t    o = n - r;if (this === t && r < e && e < n) for (i = o - 1; i >= 0; --i) {\n\t\t\t\t\tt[i + e] = this[i + r];\n\t\t\t\t} else if (o < 1e3 || !a.TYPED_ARRAY_SUPPORT) for (i = 0; i < o; ++i) {\n\t\t\t\t\tt[i + e] = this[i + r];\n\t\t\t\t} else Uint8Array.prototype.set.call(t, this.subarray(r, r + o), e);return o;\n\t\t\t}, a.prototype.fill = function (t, e, r, n) {\n\t\t\t\tif (\"string\" == typeof t) {\n\t\t\t\t\tif (\"string\" == typeof e ? (n = e, e = 0, r = this.length) : \"string\" == typeof r && (n = r, r = this.length), 1 === t.length) {\n\t\t\t\t\t\tvar i = t.charCodeAt(0);i < 256 && (t = i);\n\t\t\t\t\t}if (void 0 !== n && \"string\" != typeof n) throw new TypeError(\"encoding must be a string\");if (\"string\" == typeof n && !a.isEncoding(n)) throw new TypeError(\"Unknown encoding: \" + n);\n\t\t\t\t} else \"number\" == typeof t && (t &= 255);if (e < 0 || this.length < e || this.length < r) throw new RangeError(\"Out of range index\");if (r <= e) return this;e >>>= 0, r = void 0 === r ? this.length : r >>> 0, t || (t = 0);var o;if (\"number\" == typeof t) for (o = e; o < r; ++o) {\n\t\t\t\t\tthis[o] = t;\n\t\t\t\t} else {\n\t\t\t\t\tvar s = a.isBuffer(t) ? t : W(new a(t, n).toString()),\n\t\t\t\t\t    u = s.length;for (o = 0; o < r - e; ++o) {\n\t\t\t\t\t\tthis[o + e] = s[o % u];\n\t\t\t\t\t}\n\t\t\t\t}return this;\n\t\t\t};var et = /[^+\\/0-9A-Za-z-_]/g;\n\t\t}).call(e, function () {\n\t\t\treturn this;\n\t\t}());\n\t}, function (t, e, r) {\n\t\te = t.exports = r(5)(!0), e.push([t.id, '.Masthead{position:relative;min-height:21.875rem;scroll-behavior:smooth;overflow:hidden;z-index:-1}@media screen and (min-width:768px){.Masthead{min-height:100vh}}.Masthead__image{width:100%;overflow:hidden;height:120%}.Masthead__image>img{height:100%;max-width:none;width:100%;-o-object-fit:cover;object-fit:cover;-o-object-position:bottom;object-position:bottom;font-family:\"object-fit: cover; object-position: bottom\"}.Masthead__image.is-parallax{left:0;position:absolute;will-change:transform;right:0;top:0}.Masthead__image.is-parallax>img{height:100%;max-width:none;width:100%;-o-object-fit:cover;object-fit:cover;-o-object-position:bottom;object-position:bottom;font-family:\"object-fit: cover; object-position: bottom\"}.Masthead__image.is-fixed{position:fixed}.Masthead__image.is-fixed>img{height:100vh;max-width:none}', \"\", { version: 3, sources: [\"/Users/jjuszczak/Projekte/Privat/vue-parallax/src/components/Parallax.vue\"], names: [], mappings: \"AACA,UAAU,kBAAkB,qBAAqB,uBAAuB,gBAAgB,UAAU,CACjG,AACD,oCACA,UAAU,gBAAgB,CACzB,CACA,AACD,iBAAiB,WAAW,gBAAgB,WAAW,CACtD,AACD,qBAAqB,YAAY,eAAe,WAAW,oBAAoB,iBAAiB,0BAA0B,uBAAuB,wDAAwD,CACxM,AACD,6BAA6B,OAAO,kBAAkB,sBAAsB,QAAQ,KAAK,CACxF,AACD,iCAAiC,YAAY,eAAe,WAAW,oBAAoB,iBAAiB,0BAA0B,uBAAuB,wDAAwD,CACpN,AACD,0BAA0B,cAAc,CACvC,AACD,8BAA8B,aAAa,cAAc,CACxD\", file: \"Parallax.vue\", sourcesContent: ['\\n.Masthead{position:relative;min-height:21.875rem;scroll-behavior:smooth;overflow:hidden;z-index:-1\\n}\\n@media screen and (min-width: 768px){\\n.Masthead{min-height:100vh\\n}\\n}\\n.Masthead__image{width:100%;overflow:hidden;height:120%\\n}\\n.Masthead__image>img{height:100%;max-width:none;width:100%;-o-object-fit:cover;object-fit:cover;-o-object-position:bottom;object-position:bottom;font-family:\"object-fit: cover; object-position: bottom\"\\n}\\n.Masthead__image.is-parallax{left:0;position:absolute;will-change:transform;right:0;top:0\\n}\\n.Masthead__image.is-parallax>img{height:100%;max-width:none;width:100%;-o-object-fit:cover;object-fit:cover;-o-object-position:bottom;object-position:bottom;font-family:\"object-fit: cover; object-position: bottom\"\\n}\\n.Masthead__image.is-fixed{position:fixed\\n}\\n.Masthead__image.is-fixed>img{height:100vh;max-width:none\\n}\\n'], sourceRoot: \"\" }]);\n\t}, function (t, e, r) {\n\t\t(function (e) {\n\t\t\tfunction r(t, e) {\n\t\t\t\tvar r = t[1] || \"\",\n\t\t\t\t    i = t[3];if (!i) return r;if (e) {\n\t\t\t\t\tvar o = n(i),\n\t\t\t\t\t    a = i.sources.map(function (t) {\n\t\t\t\t\t\treturn \"/*# sourceURL=\" + i.sourceRoot + t + \" */\";\n\t\t\t\t\t});return [r].concat(a).concat([o]).join(\"\\n\");\n\t\t\t\t}return [r].join(\"\\n\");\n\t\t\t}function n(t) {\n\t\t\t\tvar r = new e(JSON.stringify(t)).toString(\"base64\"),\n\t\t\t\t    n = \"sourceMappingURL=data:application/json;charset=utf-8;base64,\" + r;return \"/*# \" + n + \" */\";\n\t\t\t}t.exports = function (t) {\n\t\t\t\tvar e = [];return e.toString = function () {\n\t\t\t\t\treturn this.map(function (e) {\n\t\t\t\t\t\tvar n = r(e, t);return e[2] ? \"@media \" + e[2] + \"{\" + n + \"}\" : n;\n\t\t\t\t\t}).join(\"\");\n\t\t\t\t}, e.i = function (t, r) {\n\t\t\t\t\t\"string\" == typeof t && (t = [[null, t, \"\"]]);for (var n = {}, i = 0; i < this.length; i++) {\n\t\t\t\t\t\tvar o = this[i][0];\"number\" == typeof o && (n[o] = !0);\n\t\t\t\t\t}for (i = 0; i < t.length; i++) {\n\t\t\t\t\t\tvar a = t[i];\"number\" == typeof a[0] && n[a[0]] || (r && !a[2] ? a[2] = r : r && (a[2] = \"(\" + a[2] + \") and (\" + r + \")\"), e.push(a));\n\t\t\t\t\t}\n\t\t\t\t}, e;\n\t\t\t};\n\t\t}).call(e, r(3).Buffer);\n\t}, function (t, e) {\n\t\te.read = function (t, e, r, n, i) {\n\t\t\tvar o,\n\t\t\t    a,\n\t\t\t    s = 8 * i - n - 1,\n\t\t\t    u = (1 << s) - 1,\n\t\t\t    f = u >> 1,\n\t\t\t    h = -7,\n\t\t\t    c = r ? i - 1 : 0,\n\t\t\t    l = r ? -1 : 1,\n\t\t\t    p = t[e + c];for (c += l, o = p & (1 << -h) - 1, p >>= -h, h += s; h > 0; o = 256 * o + t[e + c], c += l, h -= 8) {}for (a = o & (1 << -h) - 1, o >>= -h, h += n; h > 0; a = 256 * a + t[e + c], c += l, h -= 8) {}if (0 === o) o = 1 - f;else {\n\t\t\t\tif (o === u) return a ? NaN : (p ? -1 : 1) * (1 / 0);a += Math.pow(2, n), o -= f;\n\t\t\t}return (p ? -1 : 1) * a * Math.pow(2, o - n);\n\t\t}, e.write = function (t, e, r, n, i, o) {\n\t\t\tvar a,\n\t\t\t    s,\n\t\t\t    u,\n\t\t\t    f = 8 * o - i - 1,\n\t\t\t    h = (1 << f) - 1,\n\t\t\t    c = h >> 1,\n\t\t\t    l = 23 === i ? Math.pow(2, -24) - Math.pow(2, -77) : 0,\n\t\t\t    p = n ? 0 : o - 1,\n\t\t\t    d = n ? 1 : -1,\n\t\t\t    g = e < 0 || 0 === e && 1 / e < 0 ? 1 : 0;for (e = Math.abs(e), isNaN(e) || e === 1 / 0 ? (s = isNaN(e) ? 1 : 0, a = h) : (a = Math.floor(Math.log(e) / Math.LN2), e * (u = Math.pow(2, -a)) < 1 && (a--, u *= 2), e += a + c >= 1 ? l / u : l * Math.pow(2, 1 - c), e * u >= 2 && (a++, u /= 2), a + c >= h ? (s = 0, a = h) : a + c >= 1 ? (s = (e * u - 1) * Math.pow(2, i), a += c) : (s = e * Math.pow(2, c - 1) * Math.pow(2, i), a = 0)); i >= 8; t[r + p] = 255 & s, p += d, s /= 256, i -= 8) {}for (a = a << i | s, f += i; f > 0; t[r + p] = 255 & a, p += d, a /= 256, f -= 8) {}t[r + p - d] |= 128 * g;\n\t\t};\n\t}, function (t, e) {\n\t\tvar r = {}.toString;t.exports = Array.isArray || function (t) {\n\t\t\treturn \"[object Array]\" == r.call(t);\n\t\t};\n\t}, function (t, e, r) {\n\t\tr(11);var n = r(9)(r(1), r(10), null, null);t.exports = n.exports;\n\t}, function (t, e) {\n\t\tt.exports = function (t, e, r, n) {\n\t\t\tvar i,\n\t\t\t    o = t = t || {},\n\t\t\t    a = _typeof(t.default);\"object\" !== a && \"function\" !== a || (i = t, o = t.default);var s = \"function\" == typeof o ? o.options : o;if (e && (s.render = e.render, s.staticRenderFns = e.staticRenderFns), r && (s._scopeId = r), n) {\n\t\t\t\tvar u = Object.create(s.computed || null);Object.keys(n).forEach(function (t) {\n\t\t\t\t\tvar e = n[t];u[t] = function () {\n\t\t\t\t\t\treturn e;\n\t\t\t\t\t};\n\t\t\t\t}), s.computed = u;\n\t\t\t}return { esModule: i, exports: o, options: s };\n\t\t};\n\t}, function (t, e) {\n\t\tt.exports = { render: function render() {\n\t\t\t\tvar t = this,\n\t\t\t\t    e = (t.$createElement, t._c);return e(\"section\", { ref: \"block\", class: [t.sectionClass], style: { height: t.sectionHeight + \"vh\" } }, [e(\"div\", { ref: \"parallax\", class: [t.parallax ? t.parallaxClass : \"\", t.fixed ? t.fixedClass : \"\", t.containerClass] }, [t._t(\"default\")], 2)]);\n\t\t\t}, staticRenderFns: [] };\n\t}, function (t, e, r) {\n\t\tvar n = r(4);\"string\" == typeof n && (n = [[t.id, n, \"\"]]), n.locals && (t.exports = n.locals);r(12)(\"b568b5da\", n, !0);\n\t}, function (t, e, r) {\n\t\tfunction n(t) {\n\t\t\tfor (var e = 0; e < t.length; e++) {\n\t\t\t\tvar r = t[e],\n\t\t\t\t    n = h[r.id];if (n) {\n\t\t\t\t\tn.refs++;for (var i = 0; i < n.parts.length; i++) {\n\t\t\t\t\t\tn.parts[i](r.parts[i]);\n\t\t\t\t\t}for (; i < r.parts.length; i++) {\n\t\t\t\t\t\tn.parts.push(o(r.parts[i]));\n\t\t\t\t\t}n.parts.length > r.parts.length && (n.parts.length = r.parts.length);\n\t\t\t\t} else {\n\t\t\t\t\tfor (var a = [], i = 0; i < r.parts.length; i++) {\n\t\t\t\t\t\ta.push(o(r.parts[i]));\n\t\t\t\t\t}h[r.id] = { id: r.id, refs: 1, parts: a };\n\t\t\t\t}\n\t\t\t}\n\t\t}function i() {\n\t\t\tvar t = document.createElement(\"style\");return t.type = \"text/css\", c.appendChild(t), t;\n\t\t}function o(t) {\n\t\t\tvar e,\n\t\t\t    r,\n\t\t\t    n = document.querySelector('style[data-vue-ssr-id~=\"' + t.id + '\"]');if (n) {\n\t\t\t\tif (d) return g;n.parentNode.removeChild(n);\n\t\t\t}if (y) {\n\t\t\t\tvar o = p++;n = l || (l = i()), e = a.bind(null, n, o, !1), r = a.bind(null, n, o, !0);\n\t\t\t} else n = i(), e = s.bind(null, n), r = function r() {\n\t\t\t\tn.parentNode.removeChild(n);\n\t\t\t};return e(t), function (n) {\n\t\t\t\tif (n) {\n\t\t\t\t\tif (n.css === t.css && n.media === t.media && n.sourceMap === t.sourceMap) return;e(t = n);\n\t\t\t\t} else r();\n\t\t\t};\n\t\t}function a(t, e, r, n) {\n\t\t\tvar i = r ? \"\" : n.css;if (t.styleSheet) t.styleSheet.cssText = A(e, i);else {\n\t\t\t\tvar o = document.createTextNode(i),\n\t\t\t\t    a = t.childNodes;a[e] && t.removeChild(a[e]), a.length ? t.insertBefore(o, a[e]) : t.appendChild(o);\n\t\t\t}\n\t\t}function s(t, e) {\n\t\t\tvar r = e.css,\n\t\t\t    n = e.media,\n\t\t\t    i = e.sourceMap;if (n && t.setAttribute(\"media\", n), i && (r += \"\\n/*# sourceURL=\" + i.sources[0] + \" */\", r += \"\\n/*# sourceMappingURL=data:application/json;base64,\" + btoa(unescape(encodeURIComponent(JSON.stringify(i)))) + \" */\"), t.styleSheet) t.styleSheet.cssText = r;else {\n\t\t\t\tfor (; t.firstChild;) {\n\t\t\t\t\tt.removeChild(t.firstChild);\n\t\t\t\t}t.appendChild(document.createTextNode(r));\n\t\t\t}\n\t\t}var u = \"undefined\" != typeof document,\n\t\t    f = r(13),\n\t\t    h = {},\n\t\t    c = u && (document.head || document.getElementsByTagName(\"head\")[0]),\n\t\t    l = null,\n\t\t    p = 0,\n\t\t    d = !1,\n\t\t    g = function g() {},\n\t\t    y = \"undefined\" != typeof navigator && /msie [6-9]\\b/.test(navigator.userAgent.toLowerCase());t.exports = function (t, e, r) {\n\t\t\td = r;var i = f(t, e);return n(i), function (e) {\n\t\t\t\tfor (var r = [], o = 0; o < i.length; o++) {\n\t\t\t\t\tvar a = i[o],\n\t\t\t\t\t    s = h[a.id];s.refs--, r.push(s);\n\t\t\t\t}e ? (i = f(t, e), n(i)) : i = [];for (var o = 0; o < r.length; o++) {\n\t\t\t\t\tvar s = r[o];if (0 === s.refs) {\n\t\t\t\t\t\tfor (var u = 0; u < s.parts.length; u++) {\n\t\t\t\t\t\t\ts.parts[u]();\n\t\t\t\t\t\t}delete h[s.id];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t};var A = function () {\n\t\t\tvar t = [];return function (e, r) {\n\t\t\t\treturn t[e] = r, t.filter(Boolean).join(\"\\n\");\n\t\t\t};\n\t\t}();\n\t}, function (t, e) {\n\t\tt.exports = function (t, e) {\n\t\t\tfor (var r = [], n = {}, i = 0; i < e.length; i++) {\n\t\t\t\tvar o = e[i],\n\t\t\t\t    a = o[0],\n\t\t\t\t    s = o[1],\n\t\t\t\t    u = o[2],\n\t\t\t\t    f = o[3],\n\t\t\t\t    h = { id: t + \":\" + i, css: s, media: u, sourceMap: f };n[a] ? n[a].parts.push(h) : r.push(n[a] = { id: a, parts: [h] });\n\t\t\t}return r;\n\t\t};\n\t}]);\n});\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(14)(module)))\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports) {\n\nmodule.exports = function (module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function () {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function get() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function get() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/*\n 2017 Julian Garnier\n Released under the MIT license\n*/\nvar $jscomp$this = this;\n(function (u, r) {\n   true ? !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (r),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : \"object\" === (typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) && module.exports ? module.exports = r() : u.anime = r();\n})(this, function () {\n  function u(a) {\n    if (!g.col(a)) try {\n      return document.querySelectorAll(a);\n    } catch (b) {}\n  }function r(a) {\n    return a.reduce(function (a, c) {\n      return a.concat(g.arr(c) ? r(c) : c);\n    }, []);\n  }function v(a) {\n    if (g.arr(a)) return a;g.str(a) && (a = u(a) || a);return a instanceof NodeList || a instanceof HTMLCollection ? [].slice.call(a) : [a];\n  }function E(a, b) {\n    return a.some(function (a) {\n      return a === b;\n    });\n  }\n  function z(a) {\n    var b = {},\n        c;for (c in a) {\n      b[c] = a[c];\n    }return b;\n  }function F(a, b) {\n    var c = z(a),\n        d;for (d in a) {\n      c[d] = b.hasOwnProperty(d) ? b[d] : a[d];\n    }return c;\n  }function A(a, b) {\n    var c = z(a),\n        d;for (d in b) {\n      c[d] = g.und(a[d]) ? b[d] : a[d];\n    }return c;\n  }function R(a) {\n    a = a.replace(/^#?([a-f\\d])([a-f\\d])([a-f\\d])$/i, function (a, b, c, h) {\n      return b + b + c + c + h + h;\n    });var b = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(a);a = parseInt(b[1], 16);var c = parseInt(b[2], 16),\n        b = parseInt(b[3], 16);return \"rgb(\" + a + \",\" + c + \",\" + b + \")\";\n  }function S(a) {\n    function b(a, b, c) {\n      0 > c && (c += 1);1 < c && --c;return c < 1 / 6 ? a + 6 * (b - a) * c : .5 > c ? b : c < 2 / 3 ? a + (b - a) * (2 / 3 - c) * 6 : a;\n    }var c = /hsl\\((\\d+),\\s*([\\d.]+)%,\\s*([\\d.]+)%\\)/g.exec(a);a = parseInt(c[1]) / 360;var d = parseInt(c[2]) / 100,\n        c = parseInt(c[3]) / 100;if (0 == d) d = c = a = c;else {\n      var e = .5 > c ? c * (1 + d) : c + d - c * d,\n          k = 2 * c - e,\n          d = b(k, e, a + 1 / 3),\n          c = b(k, e, a);a = b(k, e, a - 1 / 3);\n    }return \"rgb(\" + 255 * d + \",\" + 255 * c + \",\" + 255 * a + \")\";\n  }function w(a) {\n    if (a = /([\\+\\-]?[0-9#\\.]+)(%|px|pt|em|rem|in|cm|mm|ex|pc|vw|vh|deg|rad|turn)?/.exec(a)) return a[2];\n  }function T(a) {\n    if (-1 < a.indexOf(\"translate\")) return \"px\";\n    if (-1 < a.indexOf(\"rotate\") || -1 < a.indexOf(\"skew\")) return \"deg\";\n  }function G(a, b) {\n    return g.fnc(a) ? a(b.target, b.id, b.total) : a;\n  }function B(a, b) {\n    if (b in a.style) return getComputedStyle(a).getPropertyValue(b.replace(/([a-z])([A-Z])/g, \"$1-$2\").toLowerCase()) || \"0\";\n  }function H(a, b) {\n    if (g.dom(a) && E(U, b)) return \"transform\";if (g.dom(a) && (a.getAttribute(b) || g.svg(a) && a[b])) return \"attribute\";if (g.dom(a) && \"transform\" !== b && B(a, b)) return \"css\";if (null != a[b]) return \"object\";\n  }function V(a, b) {\n    var c = T(b),\n        c = -1 < b.indexOf(\"scale\") ? 1 : 0 + c;a = a.style.transform;if (!a) return c;for (var d = [], e = [], k = [], h = /(\\w+)\\((.+?)\\)/g; d = h.exec(a);) {\n      e.push(d[1]), k.push(d[2]);\n    }a = k.filter(function (a, c) {\n      return e[c] === b;\n    });return a.length ? a[0] : c;\n  }function I(a, b) {\n    switch (H(a, b)) {case \"transform\":\n        return V(a, b);case \"css\":\n        return B(a, b);case \"attribute\":\n        return a.getAttribute(b);}return a[b] || 0;\n  }function J(a, b) {\n    var c = /^(\\*=|\\+=|-=)/.exec(a);if (!c) return a;b = parseFloat(b);a = parseFloat(a.replace(c[0], \"\"));switch (c[0][0]) {case \"+\":\n        return b + a;case \"-\":\n        return b - a;case \"*\":\n        return b * a;}\n  }function C(a) {\n    return g.obj(a) && a.hasOwnProperty(\"totalLength\");\n  }function W(a, b) {\n    function c(c) {\n      c = void 0 === c ? 0 : c;return a.el.getPointAtLength(1 <= b + c ? b + c : 0);\n    }var d = c(),\n        e = c(-1),\n        k = c(1);switch (a.property) {case \"x\":\n        return d.x;case \"y\":\n        return d.y;case \"angle\":\n        return 180 * Math.atan2(k.y - e.y, k.x - e.x) / Math.PI;}\n  }function K(a, b) {\n    var c = /-?\\d*\\.?\\d+/g;a = C(a) ? a.totalLength : a;if (g.col(a)) b = g.rgb(a) ? a : g.hex(a) ? R(a) : g.hsl(a) ? S(a) : void 0;else {\n      var d = w(a);a = d ? a.substr(0, a.length - d.length) : a;b = b ? a + b : a;\n    }b += \"\";return { original: b,\n      numbers: b.match(c) ? b.match(c).map(Number) : [0], strings: b.split(c) };\n  }function X(a, b) {\n    return b.reduce(function (b, d, e) {\n      return b + a[e - 1] + d;\n    });\n  }function L(a) {\n    return (a ? r(g.arr(a) ? a.map(v) : v(a)) : []).filter(function (a, c, d) {\n      return d.indexOf(a) === c;\n    });\n  }function Y(a) {\n    var b = L(a);return b.map(function (a, d) {\n      return { target: a, id: d, total: b.length };\n    });\n  }function Z(a, b) {\n    var c = z(b);if (g.arr(a)) {\n      var d = a.length;2 !== d || g.obj(a[0]) ? g.fnc(b.duration) || (c.duration = b.duration / d) : a = { value: a };\n    }return v(a).map(function (a, c) {\n      c = c ? 0 : b.delay;\n      a = g.obj(a) && !C(a) ? a : { value: a };g.und(a.delay) && (a.delay = c);return a;\n    }).map(function (a) {\n      return A(a, c);\n    });\n  }function aa(a, b) {\n    var c = {},\n        d;for (d in a) {\n      var e = G(a[d], b);g.arr(e) && (e = e.map(function (a) {\n        return G(a, b);\n      }), 1 === e.length && (e = e[0]));c[d] = e;\n    }c.duration = parseFloat(c.duration);c.delay = parseFloat(c.delay);return c;\n  }function ba(a) {\n    return g.arr(a) ? x.apply(this, a) : M[a];\n  }function ca(a, b) {\n    var c;return a.tweens.map(function (d) {\n      d = aa(d, b);var e = d.value,\n          k = I(b.target, a.name),\n          h = c ? c.to.original : k,\n          h = g.arr(e) ? e[0] : h,\n          n = J(g.arr(e) ? e[1] : e, h),\n          k = w(n) || w(h) || w(k);d.isPath = C(e);d.from = K(h, k);d.to = K(n, k);d.start = c ? c.end : a.offset;d.end = d.start + d.delay + d.duration;d.easing = ba(d.easing);d.elasticity = (1E3 - Math.min(Math.max(d.elasticity, 1), 999)) / 1E3;g.col(d.from.original) && (d.round = 1);return c = d;\n    });\n  }function da(a, b) {\n    return r(a.map(function (a) {\n      return b.map(function (b) {\n        var c = H(a.target, b.name);if (c) {\n          var d = ca(b, a);b = { type: c, property: b.name, animatable: a, tweens: d, duration: d[d.length - 1].end, delay: d[0].delay };\n        } else b = void 0;return b;\n      });\n    })).filter(function (a) {\n      return !g.und(a);\n    });\n  }\n  function N(a, b, c) {\n    var d = \"delay\" === a ? Math.min : Math.max;return b.length ? d.apply(Math, b.map(function (b) {\n      return b[a];\n    })) : c[a];\n  }function ea(a) {\n    var b = F(fa, a),\n        c = F(ga, a),\n        d = Y(a.targets),\n        e = [],\n        g = A(b, c),\n        h;for (h in a) {\n      g.hasOwnProperty(h) || \"targets\" === h || e.push({ name: h, offset: g.offset, tweens: Z(a[h], c) });\n    }a = da(d, e);return A(b, { animatables: d, animations: a, duration: N(\"duration\", a, c), delay: N(\"delay\", a, c) });\n  }function m(a) {\n    function b() {\n      return window.Promise && new Promise(function (a) {\n        return P = a;\n      });\n    }function c(a) {\n      return f.reversed ? f.duration - a : a;\n    }function d(a) {\n      for (var b = 0, c = {}, d = f.animations, e = {}; b < d.length;) {\n        var g = d[b],\n            h = g.animatable,\n            n = g.tweens;e.tween = n.filter(function (b) {\n          return a < b.end;\n        })[0] || n[n.length - 1];e.isPath$0 = e.tween.isPath;e.round = e.tween.round;e.eased = e.tween.easing(Math.min(Math.max(a - e.tween.start - e.tween.delay, 0), e.tween.duration) / e.tween.duration, e.tween.elasticity);n = X(e.tween.to.numbers.map(function (a) {\n          return function (b, c) {\n            c = a.isPath$0 ? 0 : a.tween.from.numbers[c];b = c + a.eased * (b - c);a.isPath$0 && (b = W(a.tween.value, b));a.round && (b = Math.round(b * a.round) / a.round);return b;\n          };\n        }(e)), e.tween.to.strings);ha[g.type](h.target, g.property, n, c, h.id);g.currentValue = n;b++;e = { isPath$0: e.isPath$0, tween: e.tween, eased: e.eased, round: e.round };\n      }if (c) for (var k in c) {\n        D || (D = B(document.body, \"transform\") ? \"transform\" : \"-webkit-transform\"), f.animatables[k].target.style[D] = c[k].join(\" \");\n      }f.currentTime = a;f.progress = a / f.duration * 100;\n    }function e(a) {\n      if (f[a]) f[a](f);\n    }function g() {\n      f.remaining && !0 !== f.remaining && f.remaining--;\n    }function h(a) {\n      var h = f.duration,\n          k = f.offset,\n          m = f.delay,\n          O = f.currentTime,\n          p = f.reversed,\n          q = c(a),\n          q = Math.min(Math.max(q, 0), h);q > k && q < h ? (d(q), !f.began && q >= m && (f.began = !0, e(\"begin\")), e(\"run\")) : (q <= k && 0 !== O && (d(0), p && g()), q >= h && O !== h && (d(h), p || g()));a >= h && (f.remaining ? (t = n, \"alternate\" === f.direction && (f.reversed = !f.reversed)) : (f.pause(), P(), Q = b(), f.completed || (f.completed = !0, e(\"complete\"))), l = 0);if (f.children) for (a = f.children, h = 0; h < a.length; h++) {\n        a[h].seek(q);\n      }e(\"update\");\n    }a = void 0 === a ? {} : a;var n,\n        t,\n        l = 0,\n        P = null,\n        Q = b(),\n        f = ea(a);f.reset = function () {\n      var a = f.direction,\n          b = f.loop;f.currentTime = 0;f.progress = 0;f.paused = !0;f.began = !1;f.completed = !1;f.reversed = \"reverse\" === a;f.remaining = \"alternate\" === a && 1 === b ? 2 : b;\n    };f.tick = function (a) {\n      n = a;t || (t = n);h((l + n - t) * m.speed);\n    };f.seek = function (a) {\n      h(c(a));\n    };f.pause = function () {\n      var a = p.indexOf(f);-1 < a && p.splice(a, 1);f.paused = !0;\n    };f.play = function () {\n      f.paused && (f.paused = !1, t = 0, l = f.completed ? 0 : c(f.currentTime), p.push(f), y || ia());\n    };f.reverse = function () {\n      f.reversed = !f.reversed;t = 0;l = c(f.currentTime);\n    };f.restart = function () {\n      f.pause();\n      f.reset();f.play();\n    };f.finished = Q;f.reset();f.autoplay && f.play();return f;\n  }var fa = { update: void 0, begin: void 0, run: void 0, complete: void 0, loop: 1, direction: \"normal\", autoplay: !0, offset: 0 },\n      ga = { duration: 1E3, delay: 0, easing: \"easeOutElastic\", elasticity: 500, round: 0 },\n      U = \"translateX translateY translateZ rotate rotateX rotateY rotateZ scale scaleX scaleY scaleZ skewX skewY\".split(\" \"),\n      D,\n      g = { arr: function arr(a) {\n      return Array.isArray(a);\n    }, obj: function obj(a) {\n      return -1 < Object.prototype.toString.call(a).indexOf(\"Object\");\n    }, svg: function svg(a) {\n      return a instanceof SVGElement;\n    }, dom: function dom(a) {\n      return a.nodeType || g.svg(a);\n    }, str: function str(a) {\n      return \"string\" === typeof a;\n    }, fnc: function fnc(a) {\n      return \"function\" === typeof a;\n    }, und: function und(a) {\n      return \"undefined\" === typeof a;\n    }, hex: function hex(a) {\n      return (/(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(a)\n      );\n    }, rgb: function rgb(a) {\n      return (/^rgb/.test(a)\n      );\n    }, hsl: function hsl(a) {\n      return (/^hsl/.test(a)\n      );\n    }, col: function col(a) {\n      return g.hex(a) || g.rgb(a) || g.hsl(a);\n    } },\n      x = function () {\n    function a(a, c, d) {\n      return (((1 - 3 * d + 3 * c) * a + (3 * d - 6 * c)) * a + 3 * c) * a;\n    }return function (b, c, d, e) {\n      if (0 <= b && 1 >= b && 0 <= d && 1 >= d) {\n        var g = new Float32Array(11);if (b !== c || d !== e) for (var h = 0; 11 > h; ++h) {\n          g[h] = a(.1 * h, b, d);\n        }return function (h) {\n          if (b === c && d === e) return h;if (0 === h) return 0;if (1 === h) return 1;for (var k = 0, l = 1; 10 !== l && g[l] <= h; ++l) {\n            k += .1;\n          }--l;var l = k + (h - g[l]) / (g[l + 1] - g[l]) * .1,\n              n = 3 * (1 - 3 * d + 3 * b) * l * l + 2 * (3 * d - 6 * b) * l + 3 * b;if (.001 <= n) {\n            for (k = 0; 4 > k; ++k) {\n              n = 3 * (1 - 3 * d + 3 * b) * l * l + 2 * (3 * d - 6 * b) * l + 3 * b;if (0 === n) break;var m = a(l, b, d) - h,\n                  l = l - m / n;\n            }h = l;\n          } else if (0 === n) h = l;else {\n            var l = k,\n                k = k + .1,\n                f = 0;do {\n              m = l + (k - l) / 2, n = a(m, b, d) - h, 0 < n ? k = m : l = m;\n            } while (1e-7 < Math.abs(n) && 10 > ++f);h = m;\n          }return a(h, c, e);\n        };\n      }\n    };\n  }(),\n      M = function () {\n    function a(a, b) {\n      return 0 === a || 1 === a ? a : -Math.pow(2, 10 * (a - 1)) * Math.sin(2 * (a - 1 - b / (2 * Math.PI) * Math.asin(1)) * Math.PI / b);\n    }var b = \"Quad Cubic Quart Quint Sine Expo Circ Back Elastic\".split(\" \"),\n        c = { In: [[.55, .085, .68, .53], [.55, .055, .675, .19], [.895, .03, .685, .22], [.755, .05, .855, .06], [.47, 0, .745, .715], [.95, .05, .795, .035], [.6, .04, .98, .335], [.6, -.28, .735, .045], a], Out: [[.25, .46, .45, .94], [.215, .61, .355, 1], [.165, .84, .44, 1], [.23, 1, .32, 1], [.39, .575, .565, 1], [.19, 1, .22, 1], [.075, .82, .165, 1], [.175, .885, .32, 1.275], function (b, c) {\n        return 1 - a(1 - b, c);\n      }], InOut: [[.455, .03, .515, .955], [.645, .045, .355, 1], [.77, 0, .175, 1], [.86, 0, .07, 1], [.445, .05, .55, .95], [1, 0, 0, 1], [.785, .135, .15, .86], [.68, -.55, .265, 1.55], function (b, c) {\n        return .5 > b ? a(2 * b, c) / 2 : 1 - a(-2 * b + 2, c) / 2;\n      }] },\n        d = { linear: x(.25, .25, .75, .75) },\n        e = {},\n        k;for (k in c) {\n      e.type = k, c[e.type].forEach(function (a) {\n        return function (c, e) {\n          d[\"ease\" + a.type + b[e]] = g.fnc(c) ? c : x.apply($jscomp$this, c);\n        };\n      }(e)), e = { type: e.type };\n    }return d;\n  }(),\n      ha = { css: function css(a, b, c) {\n      return a.style[b] = c;\n    }, attribute: function attribute(a, b, c) {\n      return a.setAttribute(b, c);\n    }, object: function object(a, b, c) {\n      return a[b] = c;\n    }, transform: function transform(a, b, c, d, e) {\n      d[e] || (d[e] = []);d[e].push(b + \"(\" + c + \")\");\n    } },\n      p = [],\n      y = 0,\n      ia = function () {\n    function a() {\n      y = requestAnimationFrame(b);\n    }function b(b) {\n      var c = p.length;if (c) {\n        for (var e = 0; e < c;) {\n          p[e] && p[e].tick(b), e++;\n        }a();\n      } else cancelAnimationFrame(y), y = 0;\n    }return a;\n  }();m.version = \"2.0.1\";m.speed = 1;m.running = p;m.remove = function (a) {\n    a = L(a);for (var b = p.length - 1; 0 <= b; b--) {\n      for (var c = p[b], d = c.animations, e = d.length - 1; 0 <= e; e--) {\n        E(a, d[e].animatable.target) && (d.splice(e, 1), d.length || c.pause());\n      }\n    }\n  };m.getValue = I;m.path = function (a, b) {\n    var c = g.str(a) ? u(a)[0] : a,\n        d = b || 100;return function (a) {\n      return { el: c, property: a, totalLength: c.getTotalLength() * (d / 100) };\n    };\n  };m.setDashoffset = function (a) {\n    var b = a.getTotalLength();a.setAttribute(\"stroke-dasharray\", b);return b;\n  };m.bezier = x;m.easings = M;m.timeline = function (a) {\n    var b = m(a);b.duration = 0;b.children = [];b.add = function (a) {\n      v(a).forEach(function (a) {\n        var c = a.offset,\n            d = b.duration;a.autoplay = !1;a.offset = g.und(c) ? d : J(c, d);a = m(a);a.duration > d && (b.duration = a.duration);b.children.push(a);\n      });return b;\n    };return b;\n  };m.random = function (a, b) {\n    return Math.floor(Math.random() * (b - a + 1)) + a;\n  };return m;\n});\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_RESULT__;var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/////    /////    /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n/////             /////    /////\n/////             /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n/////    /////\n/////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n\n/**\n * ScrollReveal\n * ------------\n * Version : 3.3.6\n * Website : scrollrevealjs.org\n * Repo    : github.com/jlmakes/scrollreveal.js\n * Author  : Julian Lloyd (@jlmakes)\n */\n\n;(function () {\n  'use strict';\n\n  var sr;\n  var _requestAnimationFrame;\n\n  function ScrollReveal(config) {\n    // Support instantiation without the `new` keyword.\n    if (typeof this === 'undefined' || Object.getPrototypeOf(this) !== ScrollReveal.prototype) {\n      return new ScrollReveal(config);\n    }\n\n    sr = this; // Save reference to instance.\n    sr.version = '3.3.6';\n    sr.tools = new Tools(); // *required utilities\n\n    if (sr.isSupported()) {\n      sr.tools.extend(sr.defaults, config || {});\n\n      sr.defaults.container = _resolveContainer(sr.defaults);\n\n      sr.store = {\n        elements: {},\n        containers: []\n      };\n\n      sr.sequences = {};\n      sr.history = [];\n      sr.uid = 0;\n      sr.initialized = false;\n    } else if (typeof console !== 'undefined' && console !== null) {\n      // Note: IE9 only supports console if devtools are open.\n      console.log('ScrollReveal is not supported in this browser.');\n    }\n\n    return sr;\n  }\n\n  /**\n   * Configuration\n   * -------------\n   * This object signature can be passed directly to the ScrollReveal constructor,\n   * or as the second argument of the `reveal()` method.\n   */\n\n  ScrollReveal.prototype.defaults = {\n    // 'bottom', 'left', 'top', 'right'\n    origin: 'bottom',\n\n    // Can be any valid CSS distance, e.g. '5rem', '10%', '20vw', etc.\n    distance: '20px',\n\n    // Time in milliseconds.\n    duration: 500,\n    delay: 0,\n\n    // Starting angles in degrees, will transition from these values to 0 in all axes.\n    rotate: { x: 0, y: 0, z: 0 },\n\n    // Starting opacity value, before transitioning to the computed opacity.\n    opacity: 0,\n\n    // Starting scale value, will transition from this value to 1\n    scale: 0.9,\n\n    // Accepts any valid CSS easing, e.g. 'ease', 'ease-in-out', 'linear', etc.\n    easing: 'cubic-bezier(0.6, 0.2, 0.1, 1)',\n\n    // `<html>` is the default reveal container. You can pass either:\n    // DOM Node, e.g. document.querySelector('.fooContainer')\n    // Selector, e.g. '.fooContainer'\n    container: window.document.documentElement,\n\n    // true/false to control reveal animations on mobile.\n    mobile: true,\n\n    // true:  reveals occur every time elements become visible\n    // false: reveals occur once as elements become visible\n    reset: false,\n\n    // 'always' — delay for all reveal animations\n    // 'once'   — delay only the first time reveals occur\n    // 'onload' - delay only for animations triggered by first load\n    useDelay: 'always',\n\n    // Change when an element is considered in the viewport. The default value\n    // of 0.20 means 20% of an element must be visible for its reveal to occur.\n    viewFactor: 0.2,\n\n    // Pixel values that alter the container boundaries.\n    // e.g. Set `{ top: 48 }`, if you have a 48px tall fixed toolbar.\n    // --\n    // Visual Aid: https://scrollrevealjs.org/assets/viewoffset.png\n    viewOffset: { top: 0, right: 0, bottom: 0, left: 0 },\n\n    // Callbacks that fire for each triggered element reveal, and reset.\n    beforeReveal: function beforeReveal(domEl) {},\n    beforeReset: function beforeReset(domEl) {},\n\n    // Callbacks that fire for each completed element reveal, and reset.\n    afterReveal: function afterReveal(domEl) {},\n    afterReset: function afterReset(domEl) {}\n\n    /**\n     * Check if client supports CSS Transform and CSS Transition.\n     * @return {boolean}\n     */\n  };ScrollReveal.prototype.isSupported = function () {\n    var style = document.documentElement.style;\n    return 'WebkitTransition' in style && 'WebkitTransform' in style || 'transition' in style && 'transform' in style;\n  };\n\n  /**\n   * Creates a reveal set, a group of elements that will animate when they\n   * become visible. If [interval] is provided, a new sequence is created\n   * that will ensure elements reveal in the order they appear in the DOM.\n   *\n   * @param {Node|NodeList|string} [target]   The node, node list or selector to use for animation.\n   * @param {Object}               [config]   Override the defaults for this reveal set.\n   * @param {number}               [interval] Time between sequenced element animations (milliseconds).\n   * @param {boolean}              [sync]     Used internally when updating reveals for async content.\n   *\n   * @return {Object} The current ScrollReveal instance.\n   */\n  ScrollReveal.prototype.reveal = function (target, config, interval, sync) {\n    var container;\n    var elements;\n    var elem;\n    var elemId;\n    var sequence;\n    var sequenceId;\n\n    // No custom configuration was passed, but a sequence interval instead.\n    // let’s shuffle things around to make sure everything works.\n    if (config !== undefined && typeof config === 'number') {\n      interval = config;\n      config = {};\n    } else if (config === undefined || config === null) {\n      config = {};\n    }\n\n    container = _resolveContainer(config);\n    elements = _getRevealElements(target, container);\n\n    if (!elements.length) {\n      console.log('ScrollReveal: reveal on \"' + target + '\" failed, no elements found.');\n      return sr;\n    }\n\n    // Prepare a new sequence if an interval is passed.\n    if (interval && typeof interval === 'number') {\n      sequenceId = _nextUid();\n\n      sequence = sr.sequences[sequenceId] = {\n        id: sequenceId,\n        interval: interval,\n        elemIds: [],\n        active: false\n      };\n    }\n\n    // Begin main loop to configure ScrollReveal elements.\n    for (var i = 0; i < elements.length; i++) {\n      // Check if the element has already been configured and grab it from the store.\n      elemId = elements[i].getAttribute('data-sr-id');\n      if (elemId) {\n        elem = sr.store.elements[elemId];\n      } else {\n        // Otherwise, let’s do some basic setup.\n        elem = {\n          id: _nextUid(),\n          domEl: elements[i],\n          seen: false,\n          revealing: false\n        };\n        elem.domEl.setAttribute('data-sr-id', elem.id);\n      }\n\n      // Sequence only setup\n      if (sequence) {\n        elem.sequence = {\n          id: sequence.id,\n          index: sequence.elemIds.length\n        };\n\n        sequence.elemIds.push(elem.id);\n      }\n\n      // New or existing element, it’s time to update its configuration, styles,\n      // and send the updates to our store.\n      _configure(elem, config, container);\n      _style(elem);\n      _updateStore(elem);\n\n      // We need to make sure elements are set to visibility: visible, even when\n      // on mobile and `config.mobile === false`, or if unsupported.\n      if (sr.tools.isMobile() && !elem.config.mobile || !sr.isSupported()) {\n        elem.domEl.setAttribute('style', elem.styles.inline);\n        elem.disabled = true;\n      } else if (!elem.revealing) {\n        // Otherwise, proceed normally.\n        elem.domEl.setAttribute('style', elem.styles.inline + elem.styles.transform.initial);\n      }\n    }\n\n    // Each `reveal()` is recorded so that when calling `sync()` while working\n    // with asynchronously loaded content, it can re-trace your steps but with\n    // all your new elements now in the DOM.\n\n    // Since `reveal()` is called internally by `sync()`, we don’t want to\n    // record or intiialize each reveal during syncing.\n    if (!sync && sr.isSupported()) {\n      _record(target, config, interval);\n\n      // We push initialization to the event queue using setTimeout, so that we can\n      // give ScrollReveal room to process all reveal calls before putting things into motion.\n      // --\n      // Philip Roberts - What the heck is the event loop anyway? (JSConf EU 2014)\n      // https://www.youtube.com/watch?v=8aGhZQkoFbQ\n      if (sr.initTimeout) {\n        window.clearTimeout(sr.initTimeout);\n      }\n      sr.initTimeout = window.setTimeout(_init, 0);\n    }\n\n    return sr;\n  };\n\n  /**\n   * Re-runs `reveal()` for each record stored in history, effectively capturing\n   * any content loaded asynchronously that matches existing reveal set targets.\n   * @return {Object} The current ScrollReveal instance.\n   */\n  ScrollReveal.prototype.sync = function () {\n    if (sr.history.length && sr.isSupported()) {\n      for (var i = 0; i < sr.history.length; i++) {\n        var record = sr.history[i];\n        sr.reveal(record.target, record.config, record.interval, true);\n      }\n      _init();\n    } else {\n      console.log('ScrollReveal: sync failed, no reveals found.');\n    }\n    return sr;\n  };\n\n  /**\n   * Private Methods\n   * ---------------\n   */\n\n  function _resolveContainer(config) {\n    if (config && config.container) {\n      if (typeof config.container === 'string') {\n        return window.document.documentElement.querySelector(config.container);\n      } else if (sr.tools.isNode(config.container)) {\n        return config.container;\n      } else {\n        console.log('ScrollReveal: invalid container \"' + config.container + '\" provided.');\n        console.log('ScrollReveal: falling back to default container.');\n      }\n    }\n    return sr.defaults.container;\n  }\n\n  /**\n   * check to see if a node or node list was passed in as the target,\n   * otherwise query the container using target as a selector.\n   *\n   * @param {Node|NodeList|string} [target]    client input for reveal target.\n   * @param {Node}                 [container] parent element for selector queries.\n   *\n   * @return {array} elements to be revealed.\n   */\n  function _getRevealElements(target, container) {\n    if (typeof target === 'string') {\n      return Array.prototype.slice.call(container.querySelectorAll(target));\n    } else if (sr.tools.isNode(target)) {\n      return [target];\n    } else if (sr.tools.isNodeList(target)) {\n      return Array.prototype.slice.call(target);\n    }\n    return [];\n  }\n\n  /**\n   * A consistent way of creating unique IDs.\n   * @returns {number}\n   */\n  function _nextUid() {\n    return ++sr.uid;\n  }\n\n  function _configure(elem, config, container) {\n    // If a container was passed as a part of the config object,\n    // let’s overwrite it with the resolved container passed in.\n    if (config.container) config.container = container;\n    // If the element hasn’t already been configured, let’s use a clone of the\n    // defaults extended by the configuration passed as the second argument.\n    if (!elem.config) {\n      elem.config = sr.tools.extendClone(sr.defaults, config);\n    } else {\n      // Otherwise, let’s use a clone of the existing element configuration extended\n      // by the configuration passed as the second argument.\n      elem.config = sr.tools.extendClone(elem.config, config);\n    }\n\n    // Infer CSS Transform axis from origin string.\n    if (elem.config.origin === 'top' || elem.config.origin === 'bottom') {\n      elem.config.axis = 'Y';\n    } else {\n      elem.config.axis = 'X';\n    }\n  }\n\n  function _style(elem) {\n    var computed = window.getComputedStyle(elem.domEl);\n\n    if (!elem.styles) {\n      elem.styles = {\n        transition: {},\n        transform: {},\n        computed: {}\n\n        // Capture any existing inline styles, and add our visibility override.\n        // --\n        // See section 4.2. in the Documentation:\n        // https://github.com/jlmakes/scrollreveal.js#42-improve-user-experience\n      };elem.styles.inline = elem.domEl.getAttribute('style') || '';\n      elem.styles.inline += '; visibility: visible; ';\n\n      // grab the elements existing opacity.\n      elem.styles.computed.opacity = computed.opacity;\n\n      // grab the elements existing transitions.\n      if (!computed.transition || computed.transition === 'all 0s ease 0s') {\n        elem.styles.computed.transition = '';\n      } else {\n        elem.styles.computed.transition = computed.transition + ', ';\n      }\n    }\n\n    // Create transition styles\n    elem.styles.transition.instant = _generateTransition(elem, 0);\n    elem.styles.transition.delayed = _generateTransition(elem, elem.config.delay);\n\n    // Generate transform styles, first with the webkit prefix.\n    elem.styles.transform.initial = ' -webkit-transform:';\n    elem.styles.transform.target = ' -webkit-transform:';\n    _generateTransform(elem);\n\n    // And again without any prefix.\n    elem.styles.transform.initial += 'transform:';\n    elem.styles.transform.target += 'transform:';\n    _generateTransform(elem);\n  }\n\n  function _generateTransition(elem, delay) {\n    var config = elem.config;\n\n    return '-webkit-transition: ' + elem.styles.computed.transition + '-webkit-transform ' + config.duration / 1000 + 's ' + config.easing + ' ' + delay / 1000 + 's, opacity ' + config.duration / 1000 + 's ' + config.easing + ' ' + delay / 1000 + 's; ' + 'transition: ' + elem.styles.computed.transition + 'transform ' + config.duration / 1000 + 's ' + config.easing + ' ' + delay / 1000 + 's, opacity ' + config.duration / 1000 + 's ' + config.easing + ' ' + delay / 1000 + 's; ';\n  }\n\n  function _generateTransform(elem) {\n    var config = elem.config;\n    var cssDistance;\n    var transform = elem.styles.transform;\n\n    // Let’s make sure our our pixel distances are negative for top and left.\n    // e.g. origin = 'top' and distance = '25px' starts at `top: -25px` in CSS.\n    if (config.origin === 'top' || config.origin === 'left') {\n      cssDistance = /^-/.test(config.distance) ? config.distance.substr(1) : '-' + config.distance;\n    } else {\n      cssDistance = config.distance;\n    }\n\n    if (parseInt(config.distance)) {\n      transform.initial += ' translate' + config.axis + '(' + cssDistance + ')';\n      transform.target += ' translate' + config.axis + '(0)';\n    }\n    if (config.scale) {\n      transform.initial += ' scale(' + config.scale + ')';\n      transform.target += ' scale(1)';\n    }\n    if (config.rotate.x) {\n      transform.initial += ' rotateX(' + config.rotate.x + 'deg)';\n      transform.target += ' rotateX(0)';\n    }\n    if (config.rotate.y) {\n      transform.initial += ' rotateY(' + config.rotate.y + 'deg)';\n      transform.target += ' rotateY(0)';\n    }\n    if (config.rotate.z) {\n      transform.initial += ' rotateZ(' + config.rotate.z + 'deg)';\n      transform.target += ' rotateZ(0)';\n    }\n    transform.initial += '; opacity: ' + config.opacity + ';';\n    transform.target += '; opacity: ' + elem.styles.computed.opacity + ';';\n  }\n\n  function _updateStore(elem) {\n    var container = elem.config.container;\n\n    // If this element’s container isn’t already in the store, let’s add it.\n    if (container && sr.store.containers.indexOf(container) === -1) {\n      sr.store.containers.push(elem.config.container);\n    }\n\n    // Update the element stored with our new element.\n    sr.store.elements[elem.id] = elem;\n  }\n\n  function _record(target, config, interval) {\n    // Save the `reveal()` arguments that triggered this `_record()` call, so we\n    // can re-trace our steps when calling the `sync()` method.\n    var record = {\n      target: target,\n      config: config,\n      interval: interval\n    };\n    sr.history.push(record);\n  }\n\n  function _init() {\n    if (sr.isSupported()) {\n      // Initial animate call triggers valid reveal animations on first load.\n      // Subsequent animate calls are made inside the event handler.\n      _animate();\n\n      // Then we loop through all container nodes in the store and bind event\n      // listeners to each.\n      for (var i = 0; i < sr.store.containers.length; i++) {\n        sr.store.containers[i].addEventListener('scroll', _handler);\n        sr.store.containers[i].addEventListener('resize', _handler);\n      }\n\n      // Let’s also do a one-time binding of window event listeners.\n      if (!sr.initialized) {\n        window.addEventListener('scroll', _handler);\n        window.addEventListener('resize', _handler);\n        sr.initialized = true;\n      }\n    }\n    return sr;\n  }\n\n  function _handler() {\n    _requestAnimationFrame(_animate);\n  }\n\n  function _setActiveSequences() {\n    var active;\n    var elem;\n    var elemId;\n    var sequence;\n\n    // Loop through all sequences\n    sr.tools.forOwn(sr.sequences, function (sequenceId) {\n      sequence = sr.sequences[sequenceId];\n      active = false;\n\n      // For each sequenced elemenet, let’s check visibility and if\n      // any are visible, set it’s sequence to active.\n      for (var i = 0; i < sequence.elemIds.length; i++) {\n        elemId = sequence.elemIds[i];\n        elem = sr.store.elements[elemId];\n        if (_isElemVisible(elem) && !active) {\n          active = true;\n        }\n      }\n\n      sequence.active = active;\n    });\n  }\n\n  function _animate() {\n    var delayed;\n    var elem;\n\n    _setActiveSequences();\n\n    // Loop through all elements in the store\n    sr.tools.forOwn(sr.store.elements, function (elemId) {\n      elem = sr.store.elements[elemId];\n      delayed = _shouldUseDelay(elem);\n\n      // Let’s see if we should revealand if so,\n      // trigger the `beforeReveal` callback and\n      // determine whether or not to use delay.\n      if (_shouldReveal(elem)) {\n        elem.config.beforeReveal(elem.domEl);\n        if (delayed) {\n          elem.domEl.setAttribute('style', elem.styles.inline + elem.styles.transform.target + elem.styles.transition.delayed);\n        } else {\n          elem.domEl.setAttribute('style', elem.styles.inline + elem.styles.transform.target + elem.styles.transition.instant);\n        }\n\n        // Let’s queue the `afterReveal` callback\n        // and mark the element as seen and revealing.\n        _queueCallback('reveal', elem, delayed);\n        elem.revealing = true;\n        elem.seen = true;\n\n        if (elem.sequence) {\n          _queueNextInSequence(elem, delayed);\n        }\n      } else if (_shouldReset(elem)) {\n        //Otherwise reset our element and\n        // trigger the `beforeReset` callback.\n        elem.config.beforeReset(elem.domEl);\n        elem.domEl.setAttribute('style', elem.styles.inline + elem.styles.transform.initial + elem.styles.transition.instant);\n        // And queue the `afterReset` callback.\n        _queueCallback('reset', elem);\n        elem.revealing = false;\n      }\n    });\n  }\n\n  function _queueNextInSequence(elem, delayed) {\n    var elapsed = 0;\n    var delay = 0;\n    var sequence = sr.sequences[elem.sequence.id];\n\n    // We’re processing a sequenced element, so let's block other elements in this sequence.\n    sequence.blocked = true;\n\n    // Since we’re triggering animations a part of a sequence after animations on first load,\n    // we need to check for that condition and explicitly add the delay to our timer.\n    if (delayed && elem.config.useDelay === 'onload') {\n      delay = elem.config.delay;\n    }\n\n    // If a sequence timer is already running, capture the elapsed time and clear it.\n    if (elem.sequence.timer) {\n      elapsed = Math.abs(elem.sequence.timer.started - new Date());\n      window.clearTimeout(elem.sequence.timer);\n    }\n\n    // Start a new timer.\n    elem.sequence.timer = { started: new Date() };\n    elem.sequence.timer.clock = window.setTimeout(function () {\n      // Sequence interval has passed, so unblock the sequence and re-run the handler.\n      sequence.blocked = false;\n      elem.sequence.timer = null;\n      _handler();\n    }, Math.abs(sequence.interval) + delay - elapsed);\n  }\n\n  function _queueCallback(type, elem, delayed) {\n    var elapsed = 0;\n    var duration = 0;\n    var callback = 'after';\n\n    // Check which callback we’re working with.\n    switch (type) {\n      case 'reveal':\n        duration = elem.config.duration;\n        if (delayed) {\n          duration += elem.config.delay;\n        }\n        callback += 'Reveal';\n        break;\n\n      case 'reset':\n        duration = elem.config.duration;\n        callback += 'Reset';\n        break;\n    }\n\n    // If a timer is already running, capture the elapsed time and clear it.\n    if (elem.timer) {\n      elapsed = Math.abs(elem.timer.started - new Date());\n      window.clearTimeout(elem.timer.clock);\n    }\n\n    // Start a new timer.\n    elem.timer = { started: new Date() };\n    elem.timer.clock = window.setTimeout(function () {\n      // The timer completed, so let’s fire the callback and null the timer.\n      elem.config[callback](elem.domEl);\n      elem.timer = null;\n    }, duration - elapsed);\n  }\n\n  function _shouldReveal(elem) {\n    if (elem.sequence) {\n      var sequence = sr.sequences[elem.sequence.id];\n      return sequence.active && !sequence.blocked && !elem.revealing && !elem.disabled;\n    }\n    return _isElemVisible(elem) && !elem.revealing && !elem.disabled;\n  }\n\n  function _shouldUseDelay(elem) {\n    var config = elem.config.useDelay;\n    return config === 'always' || config === 'onload' && !sr.initialized || config === 'once' && !elem.seen;\n  }\n\n  function _shouldReset(elem) {\n    if (elem.sequence) {\n      var sequence = sr.sequences[elem.sequence.id];\n      return !sequence.active && elem.config.reset && elem.revealing && !elem.disabled;\n    }\n    return !_isElemVisible(elem) && elem.config.reset && elem.revealing && !elem.disabled;\n  }\n\n  function _getContainer(container) {\n    return {\n      width: container.clientWidth,\n      height: container.clientHeight\n    };\n  }\n\n  function _getScrolled(container) {\n    // Return the container scroll values, plus the its offset.\n    if (container && container !== window.document.documentElement) {\n      var offset = _getOffset(container);\n      return {\n        x: container.scrollLeft + offset.left,\n        y: container.scrollTop + offset.top\n      };\n    } else {\n      // Otherwise, default to the window object’s scroll values.\n      return {\n        x: window.pageXOffset,\n        y: window.pageYOffset\n      };\n    }\n  }\n\n  function _getOffset(domEl) {\n    var offsetTop = 0;\n    var offsetLeft = 0;\n\n    // Grab the element’s dimensions.\n    var offsetHeight = domEl.offsetHeight;\n    var offsetWidth = domEl.offsetWidth;\n\n    // Now calculate the distance between the element and its parent, then\n    // again for the parent to its parent, and again etc... until we have the\n    // total distance of the element to the document’s top and left origin.\n    do {\n      if (!isNaN(domEl.offsetTop)) {\n        offsetTop += domEl.offsetTop;\n      }\n      if (!isNaN(domEl.offsetLeft)) {\n        offsetLeft += domEl.offsetLeft;\n      }\n      domEl = domEl.offsetParent;\n    } while (domEl);\n\n    return {\n      top: offsetTop,\n      left: offsetLeft,\n      height: offsetHeight,\n      width: offsetWidth\n    };\n  }\n\n  function _isElemVisible(elem) {\n    var offset = _getOffset(elem.domEl);\n    var container = _getContainer(elem.config.container);\n    var scrolled = _getScrolled(elem.config.container);\n    var vF = elem.config.viewFactor;\n\n    // Define the element geometry.\n    var elemHeight = offset.height;\n    var elemWidth = offset.width;\n    var elemTop = offset.top;\n    var elemLeft = offset.left;\n    var elemBottom = elemTop + elemHeight;\n    var elemRight = elemLeft + elemWidth;\n\n    return confirmBounds() || isPositionFixed();\n\n    function confirmBounds() {\n      // Define the element’s functional boundaries using its view factor.\n      var top = elemTop + elemHeight * vF;\n      var left = elemLeft + elemWidth * vF;\n      var bottom = elemBottom - elemHeight * vF;\n      var right = elemRight - elemWidth * vF;\n\n      // Define the container functional boundaries using its view offset.\n      var viewTop = scrolled.y + elem.config.viewOffset.top;\n      var viewLeft = scrolled.x + elem.config.viewOffset.left;\n      var viewBottom = scrolled.y - elem.config.viewOffset.bottom + container.height;\n      var viewRight = scrolled.x - elem.config.viewOffset.right + container.width;\n\n      return top < viewBottom && bottom > viewTop && left < viewRight && right > viewLeft;\n    }\n\n    function isPositionFixed() {\n      return window.getComputedStyle(elem.domEl).position === 'fixed';\n    }\n  }\n\n  /**\n   * Utilities\n   * ---------\n   */\n\n  function Tools() {}\n\n  Tools.prototype.isObject = function (object) {\n    return object !== null && (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && object.constructor === Object;\n  };\n\n  Tools.prototype.isNode = function (object) {\n    return _typeof(window.Node) === 'object' ? object instanceof window.Node : object && (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string';\n  };\n\n  Tools.prototype.isNodeList = function (object) {\n    var prototypeToString = Object.prototype.toString.call(object);\n    var regex = /^\\[object (HTMLCollection|NodeList|Object)\\]$/;\n\n    return _typeof(window.NodeList) === 'object' ? object instanceof window.NodeList : object && (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && regex.test(prototypeToString) && typeof object.length === 'number' && (object.length === 0 || this.isNode(object[0]));\n  };\n\n  Tools.prototype.forOwn = function (object, callback) {\n    if (!this.isObject(object)) {\n      throw new TypeError('Expected \"object\", but received \"' + (typeof object === 'undefined' ? 'undefined' : _typeof(object)) + '\".');\n    } else {\n      for (var property in object) {\n        if (object.hasOwnProperty(property)) {\n          callback(property);\n        }\n      }\n    }\n  };\n\n  Tools.prototype.extend = function (target, source) {\n    this.forOwn(source, function (property) {\n      if (this.isObject(source[property])) {\n        if (!target[property] || !this.isObject(target[property])) {\n          target[property] = {};\n        }\n        this.extend(target[property], source[property]);\n      } else {\n        target[property] = source[property];\n      }\n    }.bind(this));\n    return target;\n  };\n\n  Tools.prototype.extendClone = function (target, source) {\n    return this.extend(this.extend({}, target), source);\n  };\n\n  Tools.prototype.isMobile = function () {\n    return (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)\n    );\n  };\n\n  /**\n   * Polyfills\n   * --------\n   */\n\n  _requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || function (callback) {\n    window.setTimeout(callback, 1000 / 60);\n  };\n\n  /**\n   * Module Wrapper\n   * --------------\n   */\n  if (\"function\" === 'function' && _typeof(__webpack_require__(11)) === 'object' && __webpack_require__(11)) {\n    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {\n      return ScrollReveal;\n    }.call(exports, __webpack_require__, exports, module),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n  } else if (typeof module !== 'undefined' && module.exports) {\n    module.exports = ScrollReveal;\n  } else {\n    window.ScrollReveal = ScrollReveal;\n  }\n})();\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// application-96393767cb8330bacf8a.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/packs/\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 12);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap b1fa04718db38d3455db","/*!\n * Vue.js v2.4.2\n * (c) 2014-2017 Evan You\n * Released under the MIT License.\n */\n/*  */\n\n// these helpers produces 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    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\nvar _toString = Object.prototype.toString;\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(val);\n  return n >= 0 && Math.floor(n) === n && isFinite(val)\n}\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction toString (val) {\n  return val == null\n    ? ''\n    : typeof val === 'object'\n      ? JSON.stringify(val, null, 2)\n      : String(val)\n}\n\n/**\n * Convert a 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 a attribute is a reserved attribute.\n */\nvar isReservedAttribute = makeMap('key,ref,slot,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 the 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 = /([^-])([A-Z])/g;\nvar hyphenate = cached(function (str) {\n  return str\n    .replace(hyphenateRE, '$1-$2')\n    .replace(hyphenateRE, '$1-$2')\n    .toLowerCase()\n});\n\n/**\n * Simple bind, faster than native\n */\nfunction bind (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  // record original fn length\n  boundFn._length = fn.length;\n  return boundFn\n}\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/**\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/**\n * Return same value\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys (modules) {\n  return modules.reduce(function (keys, m) {\n    return keys.concat(m.staticKeys || [])\n  }, []).join(',')\n}\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 (!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\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];\n\n/*  */\n\nvar config = ({\n  /**\n   * Option merge strategies (used in core/util/options)\n   */\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  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   * Exposed for legacy reasons\n   */\n  _lifecycleHooks: LIFECYCLE_HOOKS\n});\n\n/*  */\n\nvar emptyObject = Object.freeze({});\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 = /[^\\w.$]/;\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\nvar warn = noop;\nvar tip = noop;\nvar formatComponentName = (null); // work around flow check\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 name = typeof vm === 'string'\n      ? vm\n      : typeof vm === 'function' && vm.options\n        ? vm.options.name\n        : vm._isVue\n          ? vm.$options.name || vm.$options._componentTag\n          : vm.name;\n\n    var file = vm._isVue && vm.$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  var 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\nfunction handleError (err, vm, info) {\n  if (config.errorHandler) {\n    config.errorHandler.call(null, err, vm, info);\n  } else {\n    if (process.env.NODE_ENV !== 'production') {\n      warn((\"Error in \" + info + \": \\\"\" + (err.toString()) + \"\\\"\"), vm);\n    }\n    /* istanbul ignore else */\n    if (inBrowser && typeof console !== 'undefined') {\n      console.error(err);\n    } else {\n      throw err\n    }\n  }\n}\n\n/*  */\n/* globals MutationObserver */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\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;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\nvar isChrome = UA && /chrome\\/\\d+/.test(UA) && !isEdge;\n\n// Firefix 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 && typeof global !== 'undefined') {\n      // detect presence of vue-server-renderer and avoid\n      // Webpack shimming the process\n      _isServer = 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\n/**\n * Defer a task to execute it asynchronously.\n */\nvar nextTick = (function () {\n  var callbacks = [];\n  var pending = false;\n  var timerFunc;\n\n  function nextTickHandler () {\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  // 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 if */\n  if (typeof Promise !== 'undefined' && isNative(Promise)) {\n    var p = Promise.resolve();\n    var logError = function (err) { console.error(err); };\n    timerFunc = function () {\n      p.then(nextTickHandler).catch(logError);\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  } else if (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 IE11, iOS7, Android 4.4\n    var counter = 1;\n    var observer = new MutationObserver(nextTickHandler);\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  } else {\n    // fallback to setTimeout\n    /* istanbul ignore next */\n    timerFunc = function () {\n      setTimeout(nextTickHandler, 0);\n    };\n  }\n\n  return function queueNextTick (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    if (!cb && typeof Promise !== 'undefined') {\n      return new Promise(function (resolve, reject) {\n        _resolve = resolve;\n      })\n    }\n  }\n})();\n\nvar _Set;\n/* istanbul ignore if */\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 = (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\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  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 there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (_target) {\n  if (Dep.target) { targetStack.push(Dep.target); }\n  Dep.target = _target;\n}\n\nfunction popTarget () {\n  Dep.target = targetStack.pop();\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  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse'\n]\n.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 * By default, when a reactive property is set, the new value is\n * also converted to become reactive. However when passing down props,\n * we don't want to force conversion because the value may be a nested value\n * under a frozen data structure. Converting it would defeat the optimization.\n */\nvar observerState = {\n  shouldConvert: true\n};\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches 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    var augment = hasProto\n      ? protoAugment\n      : copyAugment;\n    augment(value, arrayMethods, arrayKeys);\n    this.observeArray(value);\n  } else {\n    this.walk(value);\n  }\n};\n\n/**\n * Walk through each property 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], 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 an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src, keys) {\n  /* eslint-disable no-proto */\n  target.__proto__ = src;\n  /* eslint-enable no-proto */\n}\n\n/**\n * Augment an 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)) {\n    return\n  }\n  var ob;\n  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if (\n    observerState.shouldConvert &&\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\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        }\n        if (Array.isArray(value)) {\n          dependArray(value);\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      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 (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 (hasOwn(target, key)) {\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 (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  var keys = Object.keys(from);\n  for (var i = 0; i < keys.length; i++) {\n    key = keys[i];\n    toVal = to[key];\n    fromVal = from[key];\n    if (!hasOwn(to, key)) {\n      set(to, key, fromVal);\n    } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\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) : childVal,\n        typeof parentVal === 'function' ? parentVal.call(this) : parentVal\n      )\n    }\n  } else if (parentVal || childVal) {\n    return function mergedInstanceDataFn () {\n      // instance merge\n      var instanceData = typeof childVal === 'function'\n        ? childVal.call(vm)\n        : childVal;\n      var defaultData = typeof parentVal === 'function'\n        ? parentVal.call(vm)\n        : undefined;\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.call(this, 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  return childVal\n    ? parentVal\n      ? parentVal.concat(childVal)\n      : Array.isArray(childVal)\n        ? childVal\n        : [childVal]\n    : parentVal\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 (parentVal, childVal) {\n  var res = Object.create(parentVal || null);\n  return childVal\n    ? extend(res, childVal)\n    : res\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 (parentVal, childVal) {\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 (!parentVal) { return childVal }\n  var ret = {};\n  extend(ret, parentVal);\n  for (var key in childVal) {\n    var parent = ret[key];\n    var child = childVal[key];\n    if (parent && !Array.isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key] = 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 (parentVal, childVal) {\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    var lower = key.toLowerCase();\n    if (isBuiltInTag(lower) || config.isReservedTag(lower)) {\n      warn(\n        'Do not use built-in or reserved HTML elements as component ' +\n        'id: ' + key\n      );\n    }\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps (options) {\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  }\n  options.props = res;\n}\n\n/**\n * Normalize all injections into Object-based format\n */\nfunction normalizeInject (options) {\n  var inject = options.inject;\n  if (Array.isArray(inject)) {\n    var normalized = options.inject = {};\n    for (var i = 0; i < inject.length; i++) {\n      normalized[inject[i]] = inject[i];\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 = dirs[key];\n      if (typeof def === 'function') {\n        dirs[key] = { bind: def, update: def };\n      }\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);\n  normalizeInject(child);\n  normalizeDirectives(child);\n  var extendsFrom = child.extends;\n  if (extendsFrom) {\n    parent = mergeOptions(parent, extendsFrom, 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  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\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  // handle boolean props\n  if (isType(Boolean, prop.type)) {\n    if (absent && !hasOwn(prop, 'default')) {\n      value = false;\n    } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {\n      value = true;\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 prevShouldConvert = observerState.shouldConvert;\n    observerState.shouldConvert = true;\n    observe(value);\n    observerState.shouldConvert = prevShouldConvert;\n  }\n  if (process.env.NODE_ENV !== 'production') {\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  if (!valid) {\n    warn(\n      'Invalid prop: type check failed for prop \"' + name + '\".' +\n      ' Expected ' + expectedTypes.map(capitalize).join(', ') +\n      ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',\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    valid = typeof value === expectedType.toLowerCase();\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 isType (type, fn) {\n  if (!Array.isArray(fn)) {\n    return getType(fn) === getType(type)\n  }\n  for (var i = 0, len = fn.length; i < len; i++) {\n    if (getType(fn[i]) === getType(type)) {\n      return true\n    }\n  }\n  /* istanbul ignore next */\n  return false\n}\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/* 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 to declare reactive data \" +\n      \"properties in the data option.\",\n      target\n    );\n  };\n\n  var hasProxy =\n    typeof Proxy !== 'undefined' &&\n    Proxy.toString().match(/native code/);\n\n  if (hasProxy) {\n    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');\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) || key.charAt(0) === '_';\n      if (!has && !isAllowed) {\n        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        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 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.functionalContext = 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: {} };\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    vnode.children,\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.isCloned = true;\n  return cloned\n}\n\nfunction cloneVNodes (vnodes) {\n  var len = vnodes.length;\n  var res = new Array(len);\n  for (var i = 0; i < len; i++) {\n    res[i] = cloneVNode(vnodes[i]);\n  }\n  return res\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) {\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        cloned[i].apply(null, arguments$1);\n      }\n    } else {\n      // return handler return value for single handlers\n      return fns.apply(null, arguments)\n    }\n  }\n  invoker.fns = fns;\n  return invoker\n}\n\nfunction updateListeners (\n  on,\n  oldOn,\n  add,\n  remove$$1,\n  vm\n) {\n  var name, cur, old, event;\n  for (name in on) {\n    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);\n      }\n      add(event.name, cur, event.once, event.capture, event.passive);\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  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, last;\n  for (i = 0; i < children.length; i++) {\n    c = children[i];\n    if (isUndef(c) || typeof c === 'boolean') { continue }\n    last = res[res.length - 1];\n    //  nested\n    if (Array.isArray(c)) {\n      res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i)));\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        (last).text += String(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[res.length - 1] = 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 ensureCtor (comp, base) {\n  if (comp.__esModule && comp.default) {\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  context\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  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {\n    return factory.loadingComp\n  }\n\n  if (isDef(factory.contexts)) {\n    // already pending\n    factory.contexts.push(context);\n  } else {\n    var contexts = factory.contexts = [context];\n    var sync = true;\n\n    var forceRender = function () {\n      for (var i = 0, l = contexts.length; i < l; i++) {\n        contexts[i].$forceUpdate();\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();\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();\n      }\n    });\n\n    var res = factory(resolve, reject);\n\n    if (isObject(res)) {\n      if (typeof res.then === 'function') {\n        // () => Promise\n        if (isUndef(factory.resolved)) {\n          res.then(resolve, reject);\n        }\n      } else if (isDef(res.component) && typeof res.component.then === 'function') {\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();\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 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)) {\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, once$$1) {\n  if (once$$1) {\n    target.$once(event, fn);\n  } else {\n    target.$on(event, fn);\n  }\n}\n\nfunction remove$1 (event, fn) {\n  target.$off(event, fn);\n}\n\nfunction updateComponentListeners (\n  vm,\n  listeners,\n  oldListeners\n) {\n  target = vm;\n  updateListeners(listeners, oldListeners || {}, add, remove$1, vm);\n}\n\nfunction eventsMixin (Vue) {\n  var hookRE = /^hook:/;\n  Vue.prototype.$on = function (event, fn) {\n    var this$1 = this;\n\n    var vm = this;\n    if (Array.isArray(event)) {\n      for (var i = 0, l = event.length; i < l; i++) {\n        this$1.$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 this$1 = this;\n\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        this$1.$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 (arguments.length === 1) {\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      for (var i = 0, l = cbs.length; i < l; i++) {\n        try {\n          cbs[i].apply(vm, args);\n        } catch (e) {\n          handleError(e, vm, (\"event handler for \\\"\" + event + \"\\\"\"));\n        }\n      }\n    }\n    return vm\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  var slots = {};\n  if (!children) {\n    return slots\n  }\n  var defaultSlot = [];\n  for (var i = 0, l = children.length; i < l; i++) {\n    var child = children[i];\n    // named slots should only be respected if the vnode was rendered in the\n    // same context.\n    if ((child.context === context || child.functionalContext === context) &&\n      child.data && child.data.slot != null\n    ) {\n      var name = child.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      defaultSlot.push(child);\n    }\n  }\n  // ignore whitespace\n  if (!defaultSlot.every(isWhitespace)) {\n    slots.default = defaultSlot;\n  }\n  return slots\n}\n\nfunction isWhitespace (node) {\n  return node.isComment || node.text === ' '\n}\n\nfunction resolveScopedSlots (\n  fns, // see flow/vnode\n  res\n) {\n  res = res || {};\n  for (var i = 0; i < fns.length; i++) {\n    if (Array.isArray(fns[i])) {\n      resolveScopedSlots(fns[i], res);\n    } else {\n      res[fns[i].key] = fns[i].fn;\n    }\n  }\n  return res\n}\n\n/*  */\n\nvar activeInstance = null;\nvar isUpdatingChildComponent = false;\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    if (vm._isMounted) {\n      callHook(vm, 'beforeUpdate');\n    }\n    var prevEl = vm.$el;\n    var prevVnode = vm._vnode;\n    var prevActiveInstance = activeInstance;\n    activeInstance = 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__(\n        vm.$el, vnode, hydrating, false /* removeOnly */,\n        vm.$options._parentElm,\n        vm.$options._refElm\n      );\n      // no need for the ref nodes after initial patch\n      // this prevents keeping a detached DOM tree in memory (#5851)\n      vm.$options._parentElm = vm.$options._refElm = null;\n    } else {\n      // updates\n      vm.$el = vm.__patch__(prevVnode, vnode);\n    }\n    activeInstance = prevActiveInstance;\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  };\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((name + \" render\"), startTag, endTag);\n\n      mark(startTag);\n      vm._update(vnode, hydrating);\n      mark(endTag);\n      measure((name + \" patch\"), startTag, endTag);\n    };\n  } else {\n    updateComponent = function () {\n      vm._update(vm._render(), hydrating);\n    };\n  }\n\n  vm._watcher = new Watcher(vm, updateComponent, noop);\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  var hasChildren = !!(\n    renderChildren ||               // has new static slots\n    vm.$options._renderChildren ||  // has old static slots\n    parentVnode.data.scopedSlots || // has new scoped slots\n    vm.$scopedSlots !== emptyObject // has old scoped slots\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 $listensers 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 && parentVnode.data.attrs;\n  vm.$listeners = listeners;\n\n  // update props\n  if (propsData && vm.$options.props) {\n    observerState.shouldConvert = 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      props[key] = validateProp(key, vm.$options.props, propsData, vm);\n    }\n    observerState.shouldConvert = true;\n    // keep a copy of raw propsData\n    vm.$options.propsData = propsData;\n  }\n\n  // update listeners\n  if (listeners) {\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 (hasChildren) {\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  var handlers = vm.$options[hook];\n  if (handlers) {\n    for (var i = 0, j = handlers.length; i < j; i++) {\n      try {\n        handlers[i].call(vm);\n      } catch (e) {\n        handleError(e, vm, (hook + \" hook\"));\n      }\n    }\n  }\n  if (vm._hasHookEvent) {\n    vm.$emit('hook:' + hook);\n  }\n}\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/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\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    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) {\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      nextTick(flushSchedulerQueue);\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) {\n  this.vm = vm;\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  } 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 = function () {};\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 this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    var dep = this$1.deps[i];\n    if (!this$1.newDepIds.has(dep.id)) {\n      dep.removeSub(this$1);\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 this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    this$1.deps[i].depend();\n  }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown () {\n    var this$1 = this;\n\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$1.deps[i].removeSub(this$1);\n    }\n    this.active = false;\n  }\n};\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 */\nvar seenObjects = new _Set();\nfunction traverse (val) {\n  seenObjects.clear();\n  _traverse(val, seenObjects);\n}\n\nfunction _traverse (val, seen) {\n  var i, keys;\n  var isA = Array.isArray(val);\n  if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {\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\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 checkOptionType (vm, name) {\n  var option = vm.$options[name];\n  if (!isPlainObject(option)) {\n    warn(\n      (\"component option \\\"\" + name + \"\\\" should be an object.\"),\n      vm\n    );\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  observerState.shouldConvert = isRoot;\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      if (isReservedAttribute(key) || config.isReservedAttr(key)) {\n        warn(\n          (\"\\\"\" + key + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n          vm\n        );\n      }\n      defineReactive$$1(props, key, value, function () {\n        if (vm.$parent && !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  observerState.shouldConvert = 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  try {\n    return data.call(vm)\n  } catch (e) {\n    handleError(e, vm, \"data()\");\n    return {}\n  }\n}\n\nvar computedWatcherOptions = { lazy: true };\n\nfunction initComputed (vm, computed) {\n  process.env.NODE_ENV !== 'production' && checkOptionType(vm, 'computed');\n  var watchers = vm._computedWatchers = Object.create(null);\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    // create internal watcher for the computed property.\n    watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);\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 (target, key, userDef) {\n  if (typeof userDef === 'function') {\n    sharedPropertyDefinition.get = createComputedGetter(key);\n    sharedPropertyDefinition.set = noop;\n  } else {\n    sharedPropertyDefinition.get = userDef.get\n      ? userDef.cache !== false\n        ? createComputedGetter(key)\n        : userDef.get\n      : noop;\n    sharedPropertyDefinition.set = userDef.set\n      ? userDef.set\n      : 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 initMethods (vm, methods) {\n  process.env.NODE_ENV !== 'production' && checkOptionType(vm, 'methods');\n  var props = vm.$options.props;\n  for (var key in methods) {\n    vm[key] = methods[key] == null ? noop : bind(methods[key], vm);\n    if (process.env.NODE_ENV !== 'production') {\n      if (methods[key] == null) {\n        warn(\n          \"method \\\"\" + key + \"\\\" has an undefined value 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    }\n  }\n}\n\nfunction initWatch (vm, watch) {\n  process.env.NODE_ENV !== 'production' && checkOptionType(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  keyOrFn,\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(keyOrFn, 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 (newData) {\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      cb.call(vm, watcher.value);\n    }\n    return function unwatchFn () {\n      watcher.teardown();\n    }\n  };\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    observerState.shouldConvert = 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    observerState.shouldConvert = 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      var provideKey = inject[key];\n      var source = vm;\n      while (source) {\n        if (source._provided && provideKey in source._provided) {\n          result[key] = source._provided[provideKey];\n          break\n        }\n        source = source.$parent;\n      }\n      if (process.env.NODE_ENV !== 'production' && !source) {\n        warn((\"Injection \\\"\" + key + \"\\\" not found\"), vm);\n      }\n    }\n    return result\n  }\n}\n\n/*  */\n\nfunction createFunctionalComponent (\n  Ctor,\n  propsData,\n  data,\n  context,\n  children\n) {\n  var props = {};\n  var propOptions = Ctor.options.props;\n  if (isDef(propOptions)) {\n    for (var key in propOptions) {\n      props[key] = validateProp(key, propOptions, propsData || {});\n    }\n  } else {\n    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }\n    if (isDef(data.props)) { mergeProps(props, data.props); }\n  }\n  // ensure the createElement function in functional components\n  // gets a unique context - this is necessary for correct named slot check\n  var _context = Object.create(context);\n  var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };\n  var vnode = Ctor.options.render.call(null, h, {\n    data: data,\n    props: props,\n    children: children,\n    parent: context,\n    listeners: data.on || {},\n    injections: resolveInject(Ctor.options.inject, context),\n    slots: function () { return resolveSlots(children, context); }\n  });\n  if (vnode instanceof VNode) {\n    vnode.functionalContext = context;\n    vnode.functionalOptions = Ctor.options;\n    if (data.slot) {\n      (vnode.data || (vnode.data = {})).slot = data.slot;\n    }\n  }\n  return vnode\n}\n\nfunction mergeProps (to, from) {\n  for (var key in from) {\n    to[camelize(key)] = from[key];\n  }\n}\n\n/*  */\n\n// hooks to be invoked on component VNodes during patch\nvar componentVNodeHooks = {\n  init: function init (\n    vnode,\n    hydrating,\n    parentElm,\n    refElm\n  ) {\n    if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {\n      var child = vnode.componentInstance = createComponentInstanceForVnode(\n        vnode,\n        activeInstance,\n        parentElm,\n        refElm\n      );\n      child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n    } else if (vnode.data.keepAlive) {\n      // kept-alive components, treat as a patch\n      var mountedNode = vnode; // work around flow\n      componentVNodeHooks.prepatch(mountedNode, mountedNode);\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, context);\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  // merge component management hooks onto the placeholder node\n  mergeHooks(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  return vnode\n}\n\nfunction createComponentInstanceForVnode (\n  vnode, // we know it's MountedComponentVNode but flow doesn't\n  parent, // activeInstance in lifecycle state\n  parentElm,\n  refElm\n) {\n  var vnodeComponentOptions = vnode.componentOptions;\n  var options = {\n    _isComponent: true,\n    parent: parent,\n    propsData: vnodeComponentOptions.propsData,\n    _componentTag: vnodeComponentOptions.tag,\n    _parentVnode: vnode,\n    _parentListeners: vnodeComponentOptions.listeners,\n    _renderChildren: vnodeComponentOptions.children,\n    _parentElm: parentElm || null,\n    _refElm: refElm || null\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 vnodeComponentOptions.Ctor(options)\n}\n\nfunction mergeHooks (data) {\n  if (!data.hook) {\n    data.hook = {};\n  }\n  for (var i = 0; i < hooksToMerge.length; i++) {\n    var key = hooksToMerge[i];\n    var fromParent = data.hook[key];\n    var ours = componentVNodeHooks[key];\n    data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;\n  }\n}\n\nfunction mergeHook$1 (one, two) {\n  return function (a, b, c, d) {\n    one(a, b, c, d);\n    two(a, b, c, d);\n  }\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';(data.props || (data.props = {}))[prop] = data.model.value;\n  var on = data.on || (data.on = {});\n  if (isDef(on[event])) {\n    on[event] = [data.model.callback].concat(on[event]);\n  } else {\n    on[event] = data.model.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    warn(\n      'Avoid using non-primitive value as key, ' +\n      'use string/number value instead.',\n      context\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 = 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 (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 (isDef(vnode)) {\n    if (ns) { applyNS(vnode, ns); }\n    return vnode\n  } else {\n    return createEmptyVNode()\n  }\n}\n\nfunction applyNS (vnode, ns) {\n  vnode.ns = ns;\n  if (vnode.tag === 'foreignObject') {\n    // use default namespace inside foreignObject\n    return\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) && isUndef(child.ns)) {\n        applyNS(child, ns);\n      }\n    }\n  }\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    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  if (isDef(ret)) {\n    (ret)._isVList = true;\n  }\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  if (scopedSlotFn) { // scoped slot\n    props = props || {};\n    if (bindObject) {\n      props = extend(extend({}, bindObject), props);\n    }\n    return scopedSlotFn(props) || fallback\n  } else {\n    var slotNodes = this.$slots[name];\n    // warn duplicate slot usage\n    if (slotNodes && process.env.NODE_ENV !== 'production') {\n      slotNodes._rendered && warn(\n        \"Duplicate presence of slot \\\"\" + name + \"\\\" found in the same render tree \" +\n        \"- this will likely cause render errors.\",\n        this\n      );\n      slotNodes._rendered = true;\n    }\n    return slotNodes || fallback\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\n/**\n * Runtime helper for checking keyCodes from config.\n */\nfunction checkKeyCodes (\n  eventKeyCode,\n  key,\n  builtInAlias\n) {\n  var keyCodes = config.keyCodes[key] || builtInAlias;\n  if (Array.isArray(keyCodes)) {\n    return keyCodes.indexOf(eventKeyCode) === -1\n  } else {\n    return keyCodes !== eventKeyCode\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        if (!(key in hash)) {\n          hash[key] = value[key];\n\n          if (isSync) {\n            var on = data.on || (data.on = {});\n            on[(\"update:\" + key)] = 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 tree = this._staticTrees[index];\n  // if has already-rendered static tree and not inside v-for,\n  // we can reuse the same tree by doing a shallow clone.\n  if (tree && !isInFor) {\n    return Array.isArray(tree)\n      ? cloneVNodes(tree)\n      : cloneVNode(tree)\n  }\n  // otherwise, render a fresh tree.\n  tree = this._staticTrees[index] =\n    this.$options.staticRenderFns[index].call(this._renderProxy);\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(ours, existing) : ours;\n      }\n    }\n  }\n  return data\n}\n\n/*  */\n\nfunction initRender (vm) {\n  vm._vnode = null; // the root of the child tree\n  vm._staticTrees = null;\n  var parentVnode = vm.$vnode = vm.$options._parentVnode; // the placeholder node in parent tree\n  var renderContext = parentVnode && parentVnode.context;\n  vm.$slots = resolveSlots(vm.$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  /* istanbul ignore else */\n  if (process.env.NODE_ENV !== 'production') {\n    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs, function () {\n      !isUpdatingChildComponent && warn(\"$attrs is readonly.\", vm);\n    }, true);\n    defineReactive$$1(vm, '$listeners', vm.$options._parentListeners, function () {\n      !isUpdatingChildComponent && warn(\"$listeners is readonly.\", vm);\n    }, true);\n  } else {\n    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs, null, true);\n    defineReactive$$1(vm, '$listeners', vm.$options._parentListeners, null, true);\n  }\n}\n\nfunction renderMixin (Vue) {\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 staticRenderFns = ref.staticRenderFns;\n    var _parentVnode = ref._parentVnode;\n\n    if (vm._isMounted) {\n      // clone slot nodes on re-renders\n      for (var key in vm.$slots) {\n        vm.$slots[key] = cloneVNodes(vm.$slots[key]);\n      }\n    }\n\n    vm.$scopedSlots = (_parentVnode && _parentVnode.data.scopedSlots) || emptyObject;\n\n    if (staticRenderFns && !vm._staticTrees) {\n      vm._staticTrees = [];\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      vnode = render.call(vm._renderProxy, vm.$createElement);\n    } catch (e) {\n      handleError(e, vm, \"render function\");\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') {\n        vnode = vm.$options.renderError\n          ? vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e)\n          : vm._vnode;\n      } else {\n        vnode = vm._vnode;\n      }\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  // internal render helpers.\n  // these are exposed on the instance prototype to reduce generated render\n  // code size.\n  Vue.prototype._o = markOnce;\n  Vue.prototype._n = toNumber;\n  Vue.prototype._s = toString;\n  Vue.prototype._l = renderList;\n  Vue.prototype._t = renderSlot;\n  Vue.prototype._q = looseEqual;\n  Vue.prototype._i = looseIndexOf;\n  Vue.prototype._m = renderStatic;\n  Vue.prototype._f = resolveFilter;\n  Vue.prototype._k = checkKeyCodes;\n  Vue.prototype._b = bindObjectProps;\n  Vue.prototype._v = createTextVNode;\n  Vue.prototype._e = createEmptyVNode;\n  Vue.prototype._u = resolveScopedSlots;\n  Vue.prototype._g = bindObjectListeners;\n}\n\n/*  */\n\nvar uid$1 = 0;\n\nfunction initMixin (Vue) {\n  Vue.prototype._init = function (options) {\n    var vm = this;\n    // a uid\n    vm._uid = uid$1++;\n\n    var startTag, endTag;\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n      startTag = \"vue-perf-init:\" + (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(((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  opts.parent = options.parent;\n  opts.propsData = options.propsData;\n  opts._parentVnode = options._parentVnode;\n  opts._parentListeners = options._parentListeners;\n  opts._renderChildren = options._renderChildren;\n  opts._componentTag = options._componentTag;\n  opts._parentElm = options._parentElm;\n  opts._refElm = options._refElm;\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 extended = Ctor.extendOptions;\n  var sealed = Ctor.sealedOptions;\n  for (var key in latest) {\n    if (latest[key] !== sealed[key]) {\n      if (!modified) { modified = {}; }\n      modified[key] = dedupe(latest[key], extended[key], sealed[key]);\n    }\n  }\n  return modified\n}\n\nfunction dedupe (latest, extended, sealed) {\n  // compare latest and sealed to ensure lifecycle hooks won't be duplicated\n  // between merges\n  if (Array.isArray(latest)) {\n    var res = [];\n    sealed = Array.isArray(sealed) ? sealed : [sealed];\n    extended = Array.isArray(extended) ? extended : [extended];\n    for (var i = 0; i < latest.length; i++) {\n      // push original options and not sealed options to exclude duplicated options\n      if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) {\n        res.push(latest[i]);\n      }\n    }\n    return res\n  } else {\n    return latest\n  }\n}\n\nfunction Vue$3 (options) {\n  if (process.env.NODE_ENV !== 'production' &&\n    !(this instanceof Vue$3)\n  ) {\n    warn('Vue is a constructor and should be called with the `new` keyword');\n  }\n  this._init(options);\n}\n\ninitMixin(Vue$3);\nstateMixin(Vue$3);\neventsMixin(Vue$3);\nlifecycleMixin(Vue$3);\nrenderMixin(Vue$3);\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') {\n      if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n        warn(\n          'Invalid component name: \"' + name + '\". Component names ' +\n          'can only contain alphanumeric characters and the hyphen, ' +\n          'and must start with a letter.'\n        );\n      }\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') {\n          if (type === 'component' && config.isReservedTag(id)) {\n            warn(\n              'Do not use built-in or reserved HTML elements as component ' +\n              'id: ' + id\n            );\n          }\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\nvar patternTypes = [String, RegExp, Array];\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 (cache, current, filter) {\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        if (cachedNode !== current) {\n          pruneCacheEntry(cachedNode);\n        }\n        cache[key] = null;\n      }\n    }\n  }\n}\n\nfunction pruneCacheEntry (vnode) {\n  if (vnode) {\n    vnode.componentInstance.$destroy();\n  }\n}\n\nvar KeepAlive = {\n  name: 'keep-alive',\n  abstract: true,\n\n  props: {\n    include: patternTypes,\n    exclude: patternTypes\n  },\n\n  created: function created () {\n    this.cache = Object.create(null);\n  },\n\n  destroyed: function destroyed () {\n    var this$1 = this;\n\n    for (var key in this$1.cache) {\n      pruneCacheEntry(this$1.cache[key]);\n    }\n  },\n\n  watch: {\n    include: function include (val) {\n      pruneCache(this.cache, this._vnode, function (name) { return matches(val, name); });\n    },\n    exclude: function exclude (val) {\n      pruneCache(this.cache, this._vnode, function (name) { return !matches(val, name); });\n    }\n  },\n\n  render: function render () {\n    var vnode = getFirstComponentChild(this.$slots.default);\n    var componentOptions = vnode && vnode.componentOptions;\n    if (componentOptions) {\n      // check pattern\n      var name = getComponentName(componentOptions);\n      if (name && (\n        (this.include && !matches(this.include, name)) ||\n        (this.exclude && matches(this.exclude, name))\n      )) {\n        return vnode\n      }\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 (this.cache[key]) {\n        vnode.componentInstance = this.cache[key].componentInstance;\n      } else {\n        this.cache[key] = vnode;\n      }\n      vnode.data.keepAlive = true;\n    }\n    return vnode\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  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$3);\n\nObject.defineProperty(Vue$3.prototype, '$isServer', {\n  get: isServerRendering\n});\n\nObject.defineProperty(Vue$3.prototype, '$ssrContext', {\n  get: function get () {\n    /* istanbul ignore next */\n    return this.$vnode && this.$vnode.ssrContext\n  }\n});\n\nVue$3.version = '2.4.2';\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');\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 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.data) {\n      data = mergeClassData(childNode.data, data);\n    }\n  }\n  while (isDef(parentNode = parentNode.parent)) {\n    if (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 isPreTag = function (tag) { return tag === 'pre'; };\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\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 setAttribute (node, key, val) {\n  node.setAttribute(key, val);\n}\n\n\nvar nodeOps = Object.freeze({\n\tcreateElement: createElement$1,\n\tcreateElementNS: createElementNS,\n\tcreateTextNode: createTextNode,\n\tcreateComment: createComment,\n\tinsertBefore: insertBefore,\n\tremoveChild: removeChild,\n\tappendChild: appendChild,\n\tparentNode: parentNode,\n\tnextSibling: nextSibling,\n\ttagName: tagName,\n\tsetTextContent: setTextContent,\n\tsetAttribute: setAttribute\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 (!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\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\n// Some browsers do not support dynamically changing type for <input>\n// so they need to be treated as different nodes\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\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  var inPre = 0;\n  function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {\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          inPre++;\n        }\n        if (\n          !inPre &&\n          !vnode.ns &&\n          !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&\n          config.isUnknownElement(tag)\n        ) {\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      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        inPre--;\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 */, parentElm, refElm);\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        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 (ref$$1.parentNode === 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      for (var i = 0; i < children.length; ++i) {\n        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);\n      }\n    } else if (isPrimitive(vnode.text)) {\n      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(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    var ancestor = vnode;\n    while (ancestor) {\n      if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {\n        nodeOps.setAttribute(vnode.elm, i, '');\n      }\n      ancestor = ancestor.parent;\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      isDef(i = i.$options._scopeId)\n    ) {\n      nodeOps.setAttribute(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);\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, elmToMove, 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    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);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\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);\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) ? oldKeyToIdx[newStartVnode.key] : null;\n        if (isUndef(idxInOld)) { // New element\n          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          /* istanbul ignore if */\n          if (process.env.NODE_ENV !== 'production' && !elmToMove) {\n            warn(\n              'It seems there are duplicate keys that is causing an update error. ' +\n              'Make sure each v-for item has a unique key.'\n            );\n          }\n          if (sameVnode(elmToMove, newStartVnode)) {\n            patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n            oldCh[idxInOld] = undefined;\n            canMove && nodeOps.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          } else {\n            // same key but different element. treat as new element\n            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          }\n        }\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 patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n    if (oldVnode === vnode) {\n      return\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 (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 bailed = 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  var isRenderedModule = makeMap('attrs,style,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) {\n    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {\n      vnode.elm = elm;\n      vnode.isAsyncPlaceholder = true;\n      return true\n    }\n    if (process.env.NODE_ENV !== 'production') {\n      if (!assertNodeMatch(elm, vnode)) {\n        return false\n      }\n    }\n    vnode.elm = elm;\n    var tag = vnode.tag;\n    var data = vnode.data;\n    var children = vnode.children;\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          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)) {\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            if (process.env.NODE_ENV !== 'production' &&\n              typeof console !== 'undefined' &&\n              !bailed\n            ) {\n              bailed = true;\n              console.warn('Parent: ', elm);\n              console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n            }\n            return false\n          }\n        }\n      }\n      if (isDef(data)) {\n        for (var key in data) {\n          if (!isRenderedModule(key)) {\n            invokeCreateHooks(vnode, insertedVnodeQueue);\n            break\n          }\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) {\n    if (isDef(vnode.tag)) {\n      return (\n        vnode.tag.indexOf('vue-component') === 0 ||\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, parentElm, refElm) {\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, parentElm, refElm);\n    } else {\n      var isRealElement = isDef(oldVnode.nodeType);\n      if (!isRealElement && sameVnode(oldVnode, vnode)) {\n        // patch existing root node\n        patchVnode(oldVnode, vnode, insertedVnodeQueue, 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        // replacing existing element\n        var oldElm = oldVnode.elm;\n        var parentElm$1 = nodeOps.parentNode(oldElm);\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$1,\n          nodeOps.nextSibling(oldElm)\n        );\n\n        if (isDef(vnode.parent)) {\n          // component root element replaced.\n          // update parent placeholder node element, recursively\n          var ancestor = vnode.parent;\n          while (ancestor) {\n            ancestor.elm = vnode.elm;\n            ancestor = ancestor.parent;\n          }\n          if (isPatchable(vnode)) {\n            for (var i = 0; i < cbs.create.length; ++i) {\n              cbs.create[i](emptyNode, vnode.parent);\n            }\n          }\n        }\n\n        if (isDef(parentElm$1)) {\n          removeVnodes(parentElm$1, [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      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.data.hook || (vnode.data.hook = {}), 'insert', callInsert);\n    } else {\n      callInsert();\n    }\n  }\n\n  if (dirsWithPostpatch.length) {\n    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), '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    return res\n  }\n  var i, dir;\n  for (i = 0; i < dirs.length; i++) {\n    dir = dirs[i];\n    if (!dir.modifiers) {\n      dir.modifiers = emptyModifiers;\n    }\n    res[getRawDirName(dir)] = dir;\n    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n  }\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  /* istanbul ignore if */\n  if (isIE9 && 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 (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      el.setAttribute(key, key);\n    }\n  } else if (isEnumeratedAttr(key)) {\n    el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');\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    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      el.setAttribute(key, value);\n    }\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\nvar validDivisionCharRE = /[\\w).+\\-_$\\]]/;\n\nfunction parseFilters (exp) {\n  var inSingle = false;\n  var inDouble = false;\n  var inTemplateString = false;\n  var inRegex = false;\n  var curly = 0;\n  var square = 0;\n  var paren = 0;\n  var lastFilterIndex = 0;\n  var c, prev, i, expression, filters;\n\n  for (i = 0; i < exp.length; i++) {\n    prev = c;\n    c = exp.charCodeAt(i);\n    if (inSingle) {\n      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }\n    } else if (inDouble) {\n      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }\n    } else if (inTemplateString) {\n      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }\n    } else if (inRegex) {\n      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }\n    } else if (\n      c === 0x7C && // pipe\n      exp.charCodeAt(i + 1) !== 0x7C &&\n      exp.charCodeAt(i - 1) !== 0x7C &&\n      !curly && !square && !paren\n    ) {\n      if (expression === undefined) {\n        // first filter, end of expression\n        lastFilterIndex = i + 1;\n        expression = exp.slice(0, i).trim();\n      } else {\n        pushFilter();\n      }\n    } else {\n      switch (c) {\n        case 0x22: inDouble = true; break         // \"\n        case 0x27: inSingle = true; break         // '\n        case 0x60: inTemplateString = true; break // `\n        case 0x28: paren++; break                 // (\n        case 0x29: paren--; break                 // )\n        case 0x5B: square++; break                // [\n        case 0x5D: square--; break                // ]\n        case 0x7B: curly++; break                 // {\n        case 0x7D: curly--; break                 // }\n      }\n      if (c === 0x2f) { // /\n        var j = i - 1;\n        var p = (void 0);\n        // find first non-whitespace prev char\n        for (; j >= 0; j--) {\n          p = exp.charAt(j);\n          if (p !== ' ') { break }\n        }\n        if (!p || !validDivisionCharRE.test(p)) {\n          inRegex = true;\n        }\n      }\n    }\n  }\n\n  if (expression === undefined) {\n    expression = exp.slice(0, i).trim();\n  } else if (lastFilterIndex !== 0) {\n    pushFilter();\n  }\n\n  function pushFilter () {\n    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());\n    lastFilterIndex = i + 1;\n  }\n\n  if (filters) {\n    for (i = 0; i < filters.length; i++) {\n      expression = wrapFilter(expression, filters[i]);\n    }\n  }\n\n  return expression\n}\n\nfunction wrapFilter (exp, filter) {\n  var i = filter.indexOf('(');\n  if (i < 0) {\n    // _f: resolveFilter\n    return (\"_f(\\\"\" + filter + \"\\\")(\" + exp + \")\")\n  } else {\n    var name = filter.slice(0, i);\n    var args = filter.slice(i + 1);\n    return (\"_f(\\\"\" + name + \"\\\")(\" + exp + \",\" + args)\n  }\n}\n\n/*  */\n\nfunction baseWarn (msg) {\n  console.error((\"[Vue compiler]: \" + msg));\n}\n\nfunction pluckModuleFunction (\n  modules,\n  key\n) {\n  return modules\n    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })\n    : []\n}\n\nfunction addProp (el, name, value) {\n  (el.props || (el.props = [])).push({ name: name, value: value });\n}\n\nfunction addAttr (el, name, value) {\n  (el.attrs || (el.attrs = [])).push({ name: name, value: value });\n}\n\nfunction addDirective (\n  el,\n  name,\n  rawName,\n  value,\n  arg,\n  modifiers\n) {\n  (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers });\n}\n\nfunction addHandler (\n  el,\n  name,\n  value,\n  modifiers,\n  important,\n  warn\n) {\n  // warn prevent and passive modifier\n  /* istanbul ignore if */\n  if (\n    process.env.NODE_ENV !== 'production' && warn &&\n    modifiers && modifiers.prevent && modifiers.passive\n  ) {\n    warn(\n      'passive and prevent can\\'t be used together. ' +\n      'Passive handler can\\'t prevent default event.'\n    );\n  }\n  // check capture modifier\n  if (modifiers && modifiers.capture) {\n    delete modifiers.capture;\n    name = '!' + name; // mark the event as captured\n  }\n  if (modifiers && modifiers.once) {\n    delete modifiers.once;\n    name = '~' + name; // mark the event as once\n  }\n  /* istanbul ignore if */\n  if (modifiers && modifiers.passive) {\n    delete modifiers.passive;\n    name = '&' + name; // mark the event as passive\n  }\n  var events;\n  if (modifiers && modifiers.native) {\n    delete modifiers.native;\n    events = el.nativeEvents || (el.nativeEvents = {});\n  } else {\n    events = el.events || (el.events = {});\n  }\n  var newHandler = { value: value, modifiers: modifiers };\n  var handlers = events[name];\n  /* istanbul ignore if */\n  if (Array.isArray(handlers)) {\n    important ? handlers.unshift(newHandler) : handlers.push(newHandler);\n  } else if (handlers) {\n    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];\n  } else {\n    events[name] = newHandler;\n  }\n}\n\nfunction getBindingAttr (\n  el,\n  name,\n  getStatic\n) {\n  var dynamicValue =\n    getAndRemoveAttr(el, ':' + name) ||\n    getAndRemoveAttr(el, 'v-bind:' + name);\n  if (dynamicValue != null) {\n    return parseFilters(dynamicValue)\n  } else if (getStatic !== false) {\n    var staticValue = getAndRemoveAttr(el, name);\n    if (staticValue != null) {\n      return JSON.stringify(staticValue)\n    }\n  }\n}\n\nfunction getAndRemoveAttr (el, name) {\n  var val;\n  if ((val = el.attrsMap[name]) != null) {\n    var list = el.attrsList;\n    for (var i = 0, l = list.length; i < l; i++) {\n      if (list[i].name === name) {\n        list.splice(i, 1);\n        break\n      }\n    }\n  }\n  return val\n}\n\n/*  */\n\n/**\n * Cross-platform code generation for component v-model\n */\nfunction genComponentModel (\n  el,\n  value,\n  modifiers\n) {\n  var ref = modifiers || {};\n  var number = ref.number;\n  var trim = ref.trim;\n\n  var baseValueExpression = '$$v';\n  var valueExpression = baseValueExpression;\n  if (trim) {\n    valueExpression =\n      \"(typeof \" + baseValueExpression + \" === 'string'\" +\n        \"? \" + baseValueExpression + \".trim()\" +\n        \": \" + baseValueExpression + \")\";\n  }\n  if (number) {\n    valueExpression = \"_n(\" + valueExpression + \")\";\n  }\n  var assignment = genAssignmentCode(value, valueExpression);\n\n  el.model = {\n    value: (\"(\" + value + \")\"),\n    expression: (\"\\\"\" + value + \"\\\"\"),\n    callback: (\"function (\" + baseValueExpression + \") {\" + assignment + \"}\")\n  };\n}\n\n/**\n * Cross-platform codegen helper for generating v-model value assignment code.\n */\nfunction genAssignmentCode (\n  value,\n  assignment\n) {\n  var modelRs = parseModel(value);\n  if (modelRs.idx === null) {\n    return (value + \"=\" + assignment)\n  } else {\n    return (\"$set(\" + (modelRs.exp) + \", \" + (modelRs.idx) + \", \" + assignment + \")\")\n  }\n}\n\n/**\n * parse directive model to do the array update transform. a[idx] = val => $$a.splice($$idx, 1, val)\n *\n * for loop possible cases:\n *\n * - test\n * - test[idx]\n * - test[test1[idx]]\n * - test[\"a\"][idx]\n * - xxx.test[a[a].test1[idx]]\n * - test.xxx.a[\"asa\"][test1[idx]]\n *\n */\n\nvar len;\nvar str;\nvar chr;\nvar index$1;\nvar expressionPos;\nvar expressionEndPos;\n\nfunction parseModel (val) {\n  str = val;\n  len = str.length;\n  index$1 = expressionPos = expressionEndPos = 0;\n\n  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {\n    return {\n      exp: val,\n      idx: null\n    }\n  }\n\n  while (!eof()) {\n    chr = next();\n    /* istanbul ignore if */\n    if (isStringStart(chr)) {\n      parseString(chr);\n    } else if (chr === 0x5B) {\n      parseBracket(chr);\n    }\n  }\n\n  return {\n    exp: val.substring(0, expressionPos),\n    idx: val.substring(expressionPos + 1, expressionEndPos)\n  }\n}\n\nfunction next () {\n  return str.charCodeAt(++index$1)\n}\n\nfunction eof () {\n  return index$1 >= len\n}\n\nfunction isStringStart (chr) {\n  return chr === 0x22 || chr === 0x27\n}\n\nfunction parseBracket (chr) {\n  var inBracket = 1;\n  expressionPos = index$1;\n  while (!eof()) {\n    chr = next();\n    if (isStringStart(chr)) {\n      parseString(chr);\n      continue\n    }\n    if (chr === 0x5B) { inBracket++; }\n    if (chr === 0x5D) { inBracket--; }\n    if (inBracket === 0) {\n      expressionEndPos = index$1;\n      break\n    }\n  }\n}\n\nfunction parseString (chr) {\n  var stringQuote = chr;\n  while (!eof()) {\n    chr = next();\n    if (chr === stringQuote) {\n      break\n    }\n  }\n}\n\n/*  */\n\nvar warn$1;\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\nfunction model (\n  el,\n  dir,\n  _warn\n) {\n  warn$1 = _warn;\n  var value = dir.value;\n  var modifiers = dir.modifiers;\n  var tag = el.tag;\n  var type = el.attrsMap.type;\n\n  if (process.env.NODE_ENV !== 'production') {\n    var dynamicType = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n    if (tag === 'input' && dynamicType) {\n      warn$1(\n        \"<input :type=\\\"\" + dynamicType + \"\\\" v-model=\\\"\" + value + \"\\\">:\\n\" +\n        \"v-model does not support dynamic input types. Use v-if branches instead.\"\n      );\n    }\n    // inputs with type=\"file\" are read only and setting the input's\n    // value will throw an error.\n    if (tag === 'input' && type === 'file') {\n      warn$1(\n        \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" type=\\\"file\\\">:\\n\" +\n        \"File inputs are read only. Use a v-on:change listener instead.\"\n      );\n    }\n  }\n\n  if (el.component) {\n    genComponentModel(el, value, modifiers);\n    // component v-model doesn't need extra runtime\n    return false\n  } else if (tag === 'select') {\n    genSelect(el, value, modifiers);\n  } else if (tag === 'input' && type === 'checkbox') {\n    genCheckboxModel(el, value, modifiers);\n  } else if (tag === 'input' && type === 'radio') {\n    genRadioModel(el, value, modifiers);\n  } else if (tag === 'input' || tag === 'textarea') {\n    genDefaultModel(el, value, modifiers);\n  } else if (!config.isReservedTag(tag)) {\n    genComponentModel(el, value, modifiers);\n    // component v-model doesn't need extra runtime\n    return false\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn$1(\n      \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n      \"v-model is not supported on this element type. \" +\n      'If you are working with contenteditable, it\\'s recommended to ' +\n      'wrap a library dedicated for that purpose inside a custom component.'\n    );\n  }\n\n  // ensure runtime directive metadata\n  return true\n}\n\nfunction genCheckboxModel (\n  el,\n  value,\n  modifiers\n) {\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';\n  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';\n  addProp(el, 'checked',\n    \"Array.isArray(\" + value + \")\" +\n      \"?_i(\" + value + \",\" + valueBinding + \")>-1\" + (\n        trueValueBinding === 'true'\n          ? (\":(\" + value + \")\")\n          : (\":_q(\" + value + \",\" + trueValueBinding + \")\")\n      )\n  );\n  addHandler(el, CHECKBOX_RADIO_TOKEN,\n    \"var $$a=\" + value + \",\" +\n        '$$el=$event.target,' +\n        \"$$c=$$el.checked?(\" + trueValueBinding + \"):(\" + falseValueBinding + \");\" +\n    'if(Array.isArray($$a)){' +\n      \"var $$v=\" + (number ? '_n(' + valueBinding + ')' : valueBinding) + \",\" +\n          '$$i=_i($$a,$$v);' +\n      \"if($$el.checked){$$i<0&&(\" + value + \"=$$a.concat($$v))}\" +\n      \"else{$$i>-1&&(\" + value + \"=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}\" +\n    \"}else{\" + (genAssignmentCode(value, '$$c')) + \"}\",\n    null, true\n  );\n}\n\nfunction genRadioModel (\n    el,\n    value,\n    modifiers\n) {\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  valueBinding = number ? (\"_n(\" + valueBinding + \")\") : valueBinding;\n  addProp(el, 'checked', (\"_q(\" + value + \",\" + valueBinding + \")\"));\n  addHandler(el, CHECKBOX_RADIO_TOKEN, genAssignmentCode(value, valueBinding), null, true);\n}\n\nfunction genSelect (\n    el,\n    value,\n    modifiers\n) {\n  var number = modifiers && modifiers.number;\n  var selectedVal = \"Array.prototype.filter\" +\n    \".call($event.target.options,function(o){return o.selected})\" +\n    \".map(function(o){var val = \\\"_value\\\" in o ? o._value : o.value;\" +\n    \"return \" + (number ? '_n(val)' : 'val') + \"})\";\n\n  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';\n  var code = \"var $$selectedVal = \" + selectedVal + \";\";\n  code = code + \" \" + (genAssignmentCode(value, assignment));\n  addHandler(el, 'change', code, null, true);\n}\n\nfunction genDefaultModel (\n  el,\n  value,\n  modifiers\n) {\n  var type = el.attrsMap.type;\n  var ref = modifiers || {};\n  var lazy = ref.lazy;\n  var number = ref.number;\n  var trim = ref.trim;\n  var needCompositionGuard = !lazy && type !== 'range';\n  var event = lazy\n    ? 'change'\n    : type === 'range'\n      ? RANGE_TOKEN\n      : 'input';\n\n  var valueExpression = '$event.target.value';\n  if (trim) {\n    valueExpression = \"$event.target.value.trim()\";\n  }\n  if (number) {\n    valueExpression = \"_n(\" + valueExpression + \")\";\n  }\n\n  var code = genAssignmentCode(value, valueExpression);\n  if (needCompositionGuard) {\n    code = \"if($event.target.composing)return;\" + code;\n  }\n\n  addProp(el, 'value', (\"(\" + value + \")\"));\n  addHandler(el, event, code, null, true);\n  if (trim || number) {\n    addHandler(el, 'blur', '$forceUpdate()');\n  }\n}\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  var event;\n  /* istanbul ignore if */\n  if (isDef(on[RANGE_TOKEN])) {\n    // IE input[type=range] only supports `change` event\n    event = isIE ? 'change' : 'input';\n    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);\n    delete on[RANGE_TOKEN];\n  }\n  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {\n    // Chrome fires microtasks in between click/change, leads to #4521\n    event = isChrome ? 'click' : 'change';\n    on[event] = [].concat(on[CHECKBOX_RADIO_TOKEN], on[event] || []);\n    delete on[CHECKBOX_RADIO_TOKEN];\n  }\n}\n\nvar target$1;\n\nfunction add$1 (\n  event,\n  handler,\n  once$$1,\n  capture,\n  passive\n) {\n  if (once$$1) {\n    var oldHandler = handler;\n    var _target = target$1; // save current target element in closure\n    handler = function (ev) {\n      var res = arguments.length === 1\n        ? oldHandler(ev)\n        : oldHandler.apply(null, arguments);\n      if (res !== null) {\n        remove$2(event, handler, capture, _target);\n      }\n    };\n  }\n  target$1.addEventListener(\n    event,\n    handler,\n    supportsPassive\n      ? { capture: capture, passive: passive }\n      : capture\n  );\n}\n\nfunction remove$2 (\n  event,\n  handler,\n  capture,\n  _target\n) {\n  (_target || target$1).removeEventListener(event, handler, capture);\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, vnode.context);\n}\n\nvar events = {\n  create: updateDOMListeners,\n  update: updateDOMListeners\n};\n\n/*  */\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    }\n\n    if (key === 'value') {\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, vnode, strCur)) {\n        elm.value = strCur;\n      }\n    } else {\n      elm[key] = cur;\n    }\n  }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (\n  elm,\n  vnode,\n  checkVal\n) {\n  return (!elm.composing && (\n    vnode.tag === 'option' ||\n    isDirty(elm, checkVal) ||\n    isInputChanged(elm, checkVal)\n  ))\n}\n\nfunction isDirty (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 isInputChanged (elm, newVal) {\n  var value = elm.value;\n  var modifiers = elm._vModifiers; // injected by v-model runtime\n  if (isDef(modifiers) && modifiers.number) {\n    return toNumber(value) !== toNumber(newVal)\n  }\n  if (isDef(modifiers) && modifiers.trim) {\n    return value.trim() !== newVal.trim()\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 (childNode.data && (styleData = normalizeStyleData(childNode.data))) {\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(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 likley 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\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(/\\s+/).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(/\\s+/).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 && window.requestAnimationFrame\n  ? window.requestAnimationFrame.bind(window)\n  : setTimeout;\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  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\nfunction toMs (s) {\n  return Number(s.slice(0, -1)) * 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.data.hook || (vnode.data.hook = {}), '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      addTransitionClass(el, toClass);\n      removeTransitionClass(el, startClass);\n      if (!cb.cancelled && !userWantsControl) {\n        if (isValidDuration(explicitEnterDuration)) {\n          setTimeout(cb, explicitEnterDuration);\n        } else {\n          whenTransitionEnds(el, type, cb);\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)) {\n    return rm()\n  }\n\n  /* istanbul ignore if */\n  if (isDef(el._leaveCb) || el.nodeType !== 1) {\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) {\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        addTransitionClass(el, leaveToClass);\n        removeTransitionClass(el, leaveClass);\n        if (!cb.cancelled && !userWantsControl) {\n          if (isValidDuration(explicitLeaveDuration)) {\n            setTimeout(cb, explicitLeaveDuration);\n          } else {\n            whenTransitionEnds(el, type, cb);\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\nvar isTextInputType = makeMap('text,number,password,search,email,tel,url');\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 model$1 = {\n  inserted: function inserted (el, binding, vnode) {\n    if (vnode.tag === 'select') {\n      var cb = function () {\n        setSelected(el, binding, vnode.context);\n      };\n      cb();\n      /* istanbul ignore if */\n      if (isIE || isEdge) {\n        setTimeout(cb, 0);\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        // 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        if (!isAndroid) {\n          el.addEventListener('compositionstart', onCompositionStart);\n          el.addEventListener('compositionend', onCompositionEnd);\n        }\n        /* istanbul ignore if */\n        if (isIE9) {\n          el.vmodel = true;\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(el, 'change');\n      }\n    }\n  }\n};\n\nfunction setSelected (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 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: model$1,\n  show: show\n};\n\n/*  */\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\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\nfunction isAsyncPlaceholder (node) {\n  return node.isComment && node.asyncFactory\n}\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.$options._renderChildren;\n    if (!children) {\n      return\n    }\n\n    // filter out text nodes (possible whitespaces)\n    children = children.filter(function (c) { return c.tag || isAsyncPlaceholder(c); });\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(function (d) { return d.name === 'show'; })) {\n      child.data.show = true;\n    }\n\n    if (\n      oldChild &&\n      oldChild.data &&\n      !isSameChild(child, oldChild) &&\n      !isAsyncPlaceholder(oldChild)\n    ) {\n      // replace old child transition data with fresh one\n      // important for dynamic transitions!\n      var oldData = oldChild && (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\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final desired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = extend({\n  tag: String,\n  moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n  props: props,\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  beforeUpdate: function beforeUpdate () {\n    // force removing pass\n    this.__patch__(\n      this._vnode,\n      this.kept,\n      false, // hydrating\n      true // removeOnly (!important, avoids unnecessary moves)\n    );\n    this._vnode = this.kept;\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    var body = document.body;\n    var f = body.offsetHeight; // eslint-disable-line\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 || /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$3.config.mustUseProp = mustUseProp;\nVue$3.config.isReservedTag = isReservedTag;\nVue$3.config.isReservedAttr = isReservedAttr;\nVue$3.config.getTagNamespace = getTagNamespace;\nVue$3.config.isUnknownElement = isUnknownElement;\n\n// install platform runtime directives & components\nextend(Vue$3.options.directives, platformDirectives);\nextend(Vue$3.options.components, platformComponents);\n\n// install platform patch function\nVue$3.prototype.__patch__ = inBrowser ? patch : noop;\n\n// public mount method\nVue$3.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 */\nsetTimeout(function () {\n  if (config.devtools) {\n    if (devtools) {\n      devtools.emit('init', Vue$3);\n    } else if (process.env.NODE_ENV !== 'production' && isChrome) {\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    config.productionTip !== false &&\n    inBrowser && 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// check whether current browser encodes a char inside attribute values\nfunction shouldDecode (content, encoded) {\n  var div = document.createElement('div');\n  div.innerHTML = \"<div a=\\\"\" + content + \"\\\"/>\";\n  return div.innerHTML.indexOf(encoded) > 0\n}\n\n// #3663\n// IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? shouldDecode('\\n', '&#10;') : false;\n\n/*  */\n\nvar defaultTagRE = /\\{\\{((?:.|\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = cached(function (delimiters) {\n  var open = delimiters[0].replace(regexEscapeRE, '\\\\$&');\n  var close = delimiters[1].replace(regexEscapeRE, '\\\\$&');\n  return new RegExp(open + '((?:.|\\\\n)+?)' + close, 'g')\n});\n\nfunction parseText (\n  text,\n  delimiters\n) {\n  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;\n  if (!tagRE.test(text)) {\n    return\n  }\n  var tokens = [];\n  var lastIndex = tagRE.lastIndex = 0;\n  var match, index;\n  while ((match = tagRE.exec(text))) {\n    index = match.index;\n    // push text token\n    if (index > lastIndex) {\n      tokens.push(JSON.stringify(text.slice(lastIndex, index)));\n    }\n    // tag token\n    var exp = parseFilters(match[1].trim());\n    tokens.push((\"_s(\" + exp + \")\"));\n    lastIndex = index + match[0].length;\n  }\n  if (lastIndex < text.length) {\n    tokens.push(JSON.stringify(text.slice(lastIndex)));\n  }\n  return tokens.join('+')\n}\n\n/*  */\n\nfunction transformNode (el, options) {\n  var warn = options.warn || baseWarn;\n  var staticClass = getAndRemoveAttr(el, 'class');\n  if (process.env.NODE_ENV !== 'production' && staticClass) {\n    var expression = parseText(staticClass, options.delimiters);\n    if (expression) {\n      warn(\n        \"class=\\\"\" + staticClass + \"\\\": \" +\n        'Interpolation inside attributes has been removed. ' +\n        'Use v-bind or the colon shorthand instead. For example, ' +\n        'instead of <div class=\"{{ val }}\">, use <div :class=\"val\">.'\n      );\n    }\n  }\n  if (staticClass) {\n    el.staticClass = JSON.stringify(staticClass);\n  }\n  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);\n  if (classBinding) {\n    el.classBinding = classBinding;\n  }\n}\n\nfunction genData (el) {\n  var data = '';\n  if (el.staticClass) {\n    data += \"staticClass:\" + (el.staticClass) + \",\";\n  }\n  if (el.classBinding) {\n    data += \"class:\" + (el.classBinding) + \",\";\n  }\n  return data\n}\n\nvar klass$1 = {\n  staticKeys: ['staticClass'],\n  transformNode: transformNode,\n  genData: genData\n};\n\n/*  */\n\nfunction transformNode$1 (el, options) {\n  var warn = options.warn || baseWarn;\n  var staticStyle = getAndRemoveAttr(el, 'style');\n  if (staticStyle) {\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production') {\n      var expression = parseText(staticStyle, options.delimiters);\n      if (expression) {\n        warn(\n          \"style=\\\"\" + staticStyle + \"\\\": \" +\n          'Interpolation inside attributes has been removed. ' +\n          'Use v-bind or the colon shorthand instead. For example, ' +\n          'instead of <div style=\"{{ val }}\">, use <div :style=\"val\">.'\n        );\n      }\n    }\n    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));\n  }\n\n  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);\n  if (styleBinding) {\n    el.styleBinding = styleBinding;\n  }\n}\n\nfunction genData$1 (el) {\n  var data = '';\n  if (el.staticStyle) {\n    data += \"staticStyle:\" + (el.staticStyle) + \",\";\n  }\n  if (el.styleBinding) {\n    data += \"style:(\" + (el.styleBinding) + \"),\";\n  }\n  return data\n}\n\nvar style$1 = {\n  staticKeys: ['staticStyle'],\n  transformNode: transformNode$1,\n  genData: genData$1\n};\n\nvar modules$1 = [\n  klass$1,\n  style$1\n];\n\n/*  */\n\nfunction text (el, dir) {\n  if (dir.value) {\n    addProp(el, 'textContent', (\"_s(\" + (dir.value) + \")\"));\n  }\n}\n\n/*  */\n\nfunction html (el, dir) {\n  if (dir.value) {\n    addProp(el, 'innerHTML', (\"_s(\" + (dir.value) + \")\"));\n  }\n}\n\nvar directives$1 = {\n  model: model,\n  text: text,\n  html: html\n};\n\n/*  */\n\nvar isUnaryTag = makeMap(\n  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +\n  'link,meta,param,source,track,wbr'\n);\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\nvar canBeLeftOpenTag = makeMap(\n  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'\n);\n\n// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3\n// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content\nvar isNonPhrasingTag = makeMap(\n  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n  'title,tr,track'\n);\n\n/*  */\n\nvar baseOptions = {\n  expectHTML: true,\n  modules: modules$1,\n  directives: directives$1,\n  isPreTag: isPreTag,\n  isUnaryTag: isUnaryTag,\n  mustUseProp: mustUseProp,\n  canBeLeftOpenTag: canBeLeftOpenTag,\n  isReservedTag: isReservedTag,\n  getTagNamespace: getTagNamespace,\n  staticKeys: genStaticKeys(modules$1)\n};\n\n/*  */\n\nvar decoder;\n\nvar he = {\n  decode: function decode (html) {\n    decoder = decoder || document.createElement('div');\n    decoder.innerHTML = html;\n    return decoder.textContent\n  }\n};\n\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n/*!\n * HTML Parser By John Resig (ejohn.org)\n * Modified by Juriy \"kangax\" Zaytsev\n * Original code by Erik Arvidsson, Mozilla Public License\n * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js\n */\n\n// Regular Expressions for parsing tags and attributes\nvar singleAttrIdentifier = /([^\\s\"'<>/=]+)/;\nvar singleAttrAssign = /(?:=)/;\nvar singleAttrValues = [\n  // attr value double quotes\n  /\"([^\"]*)\"+/.source,\n  // attr value, single quotes\n  /'([^']*)'+/.source,\n  // attr value, no quotes\n  /([^\\s\"'=<>`]+)/.source\n];\nvar attribute = new RegExp(\n  '^\\\\s*' + singleAttrIdentifier.source +\n  '(?:\\\\s*(' + singleAttrAssign.source + ')' +\n  '\\\\s*(?:' + singleAttrValues.join('|') + '))?'\n);\n\n// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName\n// but for Vue templates we can enforce a simple charset\nvar ncname = '[a-zA-Z_][\\\\w\\\\-\\\\.]*';\nvar qnameCapture = '((?:' + ncname + '\\\\:)?' + ncname + ')';\nvar startTagOpen = new RegExp('^<' + qnameCapture);\nvar startTagClose = /^\\s*(\\/?)>/;\nvar endTag = new RegExp('^<\\\\/' + qnameCapture + '[^>]*>');\nvar doctype = /^<!DOCTYPE [^>]+>/i;\nvar comment = /^<!--/;\nvar conditionalComment = /^<!\\[/;\n\nvar IS_REGEX_CAPTURING_BROKEN = false;\n'x'.replace(/x(.)?/g, function (m, g) {\n  IS_REGEX_CAPTURING_BROKEN = g === '';\n});\n\n// Special Elements (can contain anything)\nvar isPlainTextElement = makeMap('script,style,textarea', true);\nvar reCache = {};\n\nvar decodingMap = {\n  '&lt;': '<',\n  '&gt;': '>',\n  '&quot;': '\"',\n  '&amp;': '&',\n  '&#10;': '\\n'\n};\nvar encodedAttr = /&(?:lt|gt|quot|amp);/g;\nvar encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#10);/g;\n\n// #5992\nvar isIgnoreNewlineTag = makeMap('pre,textarea', true);\nvar shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\\n'; };\n\nfunction decodeAttr (value, shouldDecodeNewlines) {\n  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;\n  return value.replace(re, function (match) { return decodingMap[match]; })\n}\n\nfunction parseHTML (html, options) {\n  var stack = [];\n  var expectHTML = options.expectHTML;\n  var isUnaryTag$$1 = options.isUnaryTag || no;\n  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;\n  var index = 0;\n  var last, lastTag;\n  while (html) {\n    last = html;\n    // Make sure we're not in a plaintext content element like script/style\n    if (!lastTag || !isPlainTextElement(lastTag)) {\n      var textEnd = html.indexOf('<');\n      if (textEnd === 0) {\n        // Comment:\n        if (comment.test(html)) {\n          var commentEnd = html.indexOf('-->');\n\n          if (commentEnd >= 0) {\n            if (options.shouldKeepComment) {\n              options.comment(html.substring(4, commentEnd));\n            }\n            advance(commentEnd + 3);\n            continue\n          }\n        }\n\n        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n        if (conditionalComment.test(html)) {\n          var conditionalEnd = html.indexOf(']>');\n\n          if (conditionalEnd >= 0) {\n            advance(conditionalEnd + 2);\n            continue\n          }\n        }\n\n        // Doctype:\n        var doctypeMatch = html.match(doctype);\n        if (doctypeMatch) {\n          advance(doctypeMatch[0].length);\n          continue\n        }\n\n        // End tag:\n        var endTagMatch = html.match(endTag);\n        if (endTagMatch) {\n          var curIndex = index;\n          advance(endTagMatch[0].length);\n          parseEndTag(endTagMatch[1], curIndex, index);\n          continue\n        }\n\n        // Start tag:\n        var startTagMatch = parseStartTag();\n        if (startTagMatch) {\n          handleStartTag(startTagMatch);\n          if (shouldIgnoreFirstNewline(lastTag, html)) {\n            advance(1);\n          }\n          continue\n        }\n      }\n\n      var text = (void 0), rest = (void 0), next = (void 0);\n      if (textEnd >= 0) {\n        rest = html.slice(textEnd);\n        while (\n          !endTag.test(rest) &&\n          !startTagOpen.test(rest) &&\n          !comment.test(rest) &&\n          !conditionalComment.test(rest)\n        ) {\n          // < in plain text, be forgiving and treat it as text\n          next = rest.indexOf('<', 1);\n          if (next < 0) { break }\n          textEnd += next;\n          rest = html.slice(textEnd);\n        }\n        text = html.substring(0, textEnd);\n        advance(textEnd);\n      }\n\n      if (textEnd < 0) {\n        text = html;\n        html = '';\n      }\n\n      if (options.chars && text) {\n        options.chars(text);\n      }\n    } else {\n      var endTagLength = 0;\n      var stackedTag = lastTag.toLowerCase();\n      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\\\s\\\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));\n      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {\n        endTagLength = endTag.length;\n        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {\n          text = text\n            .replace(/<!--([\\s\\S]*?)-->/g, '$1')\n            .replace(/<!\\[CDATA\\[([\\s\\S]*?)]]>/g, '$1');\n        }\n        if (shouldIgnoreFirstNewline(stackedTag, text)) {\n          text = text.slice(1);\n        }\n        if (options.chars) {\n          options.chars(text);\n        }\n        return ''\n      });\n      index += html.length - rest$1.length;\n      html = rest$1;\n      parseEndTag(stackedTag, index - endTagLength, index);\n    }\n\n    if (html === last) {\n      options.chars && options.chars(html);\n      if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {\n        options.warn((\"Mal-formatted tag at end of template: \\\"\" + html + \"\\\"\"));\n      }\n      break\n    }\n  }\n\n  // Clean up any remaining tags\n  parseEndTag();\n\n  function advance (n) {\n    index += n;\n    html = html.substring(n);\n  }\n\n  function parseStartTag () {\n    var start = html.match(startTagOpen);\n    if (start) {\n      var match = {\n        tagName: start[1],\n        attrs: [],\n        start: index\n      };\n      advance(start[0].length);\n      var end, attr;\n      while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {\n        advance(attr[0].length);\n        match.attrs.push(attr);\n      }\n      if (end) {\n        match.unarySlash = end[1];\n        advance(end[0].length);\n        match.end = index;\n        return match\n      }\n    }\n  }\n\n  function handleStartTag (match) {\n    var tagName = match.tagName;\n    var unarySlash = match.unarySlash;\n\n    if (expectHTML) {\n      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {\n        parseEndTag(lastTag);\n      }\n      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {\n        parseEndTag(tagName);\n      }\n    }\n\n    var unary = isUnaryTag$$1(tagName) || !!unarySlash;\n\n    var l = match.attrs.length;\n    var attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      var args = match.attrs[i];\n      // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n      if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('\"\"') === -1) {\n        if (args[3] === '') { delete args[3]; }\n        if (args[4] === '') { delete args[4]; }\n        if (args[5] === '') { delete args[5]; }\n      }\n      var value = args[3] || args[4] || args[5] || '';\n      attrs[i] = {\n        name: args[1],\n        value: decodeAttr(\n          value,\n          options.shouldDecodeNewlines\n        )\n      };\n    }\n\n    if (!unary) {\n      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs });\n      lastTag = tagName;\n    }\n\n    if (options.start) {\n      options.start(tagName, attrs, unary, match.start, match.end);\n    }\n  }\n\n  function parseEndTag (tagName, start, end) {\n    var pos, lowerCasedTagName;\n    if (start == null) { start = index; }\n    if (end == null) { end = index; }\n\n    if (tagName) {\n      lowerCasedTagName = tagName.toLowerCase();\n    }\n\n    // Find the closest opened tag of the same type\n    if (tagName) {\n      for (pos = stack.length - 1; pos >= 0; pos--) {\n        if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n          break\n        }\n      }\n    } else {\n      // If no tag name is provided, clean shop\n      pos = 0;\n    }\n\n    if (pos >= 0) {\n      // Close all the open elements, up the stack\n      for (var i = stack.length - 1; i >= pos; i--) {\n        if (process.env.NODE_ENV !== 'production' &&\n          (i > pos || !tagName) &&\n          options.warn\n        ) {\n          options.warn(\n            (\"tag <\" + (stack[i].tag) + \"> has no matching end tag.\")\n          );\n        }\n        if (options.end) {\n          options.end(stack[i].tag, start, end);\n        }\n      }\n\n      // Remove the open elements from the stack\n      stack.length = pos;\n      lastTag = pos && stack[pos - 1].tag;\n    } else if (lowerCasedTagName === 'br') {\n      if (options.start) {\n        options.start(tagName, [], true, start, end);\n      }\n    } else if (lowerCasedTagName === 'p') {\n      if (options.start) {\n        options.start(tagName, [], false, start, end);\n      }\n      if (options.end) {\n        options.end(tagName, start, end);\n      }\n    }\n  }\n}\n\n/*  */\n\nvar onRE = /^@|^v-on:/;\nvar dirRE = /^v-|^@|^:/;\nvar forAliasRE = /(.*?)\\s+(?:in|of)\\s+(.*)/;\nvar forIteratorRE = /\\((\\{[^}]*\\}|[^,]*),([^,]*)(?:,([^,]*))?\\)/;\n\nvar argRE = /:(.*)$/;\nvar bindRE = /^:|^v-bind:/;\nvar modifierRE = /\\.[^.]+/g;\n\nvar decodeHTMLCached = cached(he.decode);\n\n// configurable state\nvar warn$2;\nvar delimiters;\nvar transforms;\nvar preTransforms;\nvar postTransforms;\nvar platformIsPreTag;\nvar platformMustUseProp;\nvar platformGetTagNamespace;\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse (\n  template,\n  options\n) {\n  warn$2 = options.warn || baseWarn;\n\n  platformIsPreTag = options.isPreTag || no;\n  platformMustUseProp = options.mustUseProp || no;\n  platformGetTagNamespace = options.getTagNamespace || no;\n\n  transforms = pluckModuleFunction(options.modules, 'transformNode');\n  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');\n  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');\n\n  delimiters = options.delimiters;\n\n  var stack = [];\n  var preserveWhitespace = options.preserveWhitespace !== false;\n  var root;\n  var currentParent;\n  var inVPre = false;\n  var inPre = false;\n  var warned = false;\n\n  function warnOnce (msg) {\n    if (!warned) {\n      warned = true;\n      warn$2(msg);\n    }\n  }\n\n  function endPre (element) {\n    // check pre state\n    if (element.pre) {\n      inVPre = false;\n    }\n    if (platformIsPreTag(element.tag)) {\n      inPre = false;\n    }\n  }\n\n  parseHTML(template, {\n    warn: warn$2,\n    expectHTML: options.expectHTML,\n    isUnaryTag: options.isUnaryTag,\n    canBeLeftOpenTag: options.canBeLeftOpenTag,\n    shouldDecodeNewlines: options.shouldDecodeNewlines,\n    shouldKeepComment: options.comments,\n    start: function start (tag, attrs, unary) {\n      // check namespace.\n      // inherit parent ns if there is one\n      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);\n\n      // handle IE svg bug\n      /* istanbul ignore if */\n      if (isIE && ns === 'svg') {\n        attrs = guardIESVGBug(attrs);\n      }\n\n      var element = {\n        type: 1,\n        tag: tag,\n        attrsList: attrs,\n        attrsMap: makeAttrsMap(attrs),\n        parent: currentParent,\n        children: []\n      };\n      if (ns) {\n        element.ns = ns;\n      }\n\n      if (isForbiddenTag(element) && !isServerRendering()) {\n        element.forbidden = true;\n        process.env.NODE_ENV !== 'production' && warn$2(\n          'Templates should only be responsible for mapping the state to the ' +\n          'UI. Avoid placing tags with side-effects in your templates, such as ' +\n          \"<\" + tag + \">\" + ', as they will not be parsed.'\n        );\n      }\n\n      // apply pre-transforms\n      for (var i = 0; i < preTransforms.length; i++) {\n        preTransforms[i](element, options);\n      }\n\n      if (!inVPre) {\n        processPre(element);\n        if (element.pre) {\n          inVPre = true;\n        }\n      }\n      if (platformIsPreTag(element.tag)) {\n        inPre = true;\n      }\n      if (inVPre) {\n        processRawAttrs(element);\n      } else {\n        processFor(element);\n        processIf(element);\n        processOnce(element);\n        processKey(element);\n\n        // determine whether this is a plain element after\n        // removing structural attributes\n        element.plain = !element.key && !attrs.length;\n\n        processRef(element);\n        processSlot(element);\n        processComponent(element);\n        for (var i$1 = 0; i$1 < transforms.length; i$1++) {\n          transforms[i$1](element, options);\n        }\n        processAttrs(element);\n      }\n\n      function checkRootConstraints (el) {\n        if (process.env.NODE_ENV !== 'production') {\n          if (el.tag === 'slot' || el.tag === 'template') {\n            warnOnce(\n              \"Cannot use <\" + (el.tag) + \"> as component root element because it may \" +\n              'contain multiple nodes.'\n            );\n          }\n          if (el.attrsMap.hasOwnProperty('v-for')) {\n            warnOnce(\n              'Cannot use v-for on stateful component root element because ' +\n              'it renders multiple elements.'\n            );\n          }\n        }\n      }\n\n      // tree management\n      if (!root) {\n        root = element;\n        checkRootConstraints(root);\n      } else if (!stack.length) {\n        // allow root elements with v-if, v-else-if and v-else\n        if (root.if && (element.elseif || element.else)) {\n          checkRootConstraints(element);\n          addIfCondition(root, {\n            exp: element.elseif,\n            block: element\n          });\n        } else if (process.env.NODE_ENV !== 'production') {\n          warnOnce(\n            \"Component template should contain exactly one root element. \" +\n            \"If you are using v-if on multiple elements, \" +\n            \"use v-else-if to chain them instead.\"\n          );\n        }\n      }\n      if (currentParent && !element.forbidden) {\n        if (element.elseif || element.else) {\n          processIfConditions(element, currentParent);\n        } else if (element.slotScope) { // scoped slot\n          currentParent.plain = false;\n          var name = element.slotTarget || '\"default\"';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;\n        } else {\n          currentParent.children.push(element);\n          element.parent = currentParent;\n        }\n      }\n      if (!unary) {\n        currentParent = element;\n        stack.push(element);\n      } else {\n        endPre(element);\n      }\n      // apply post-transforms\n      for (var i$2 = 0; i$2 < postTransforms.length; i$2++) {\n        postTransforms[i$2](element, options);\n      }\n    },\n\n    end: function end () {\n      // remove trailing whitespace\n      var element = stack[stack.length - 1];\n      var lastNode = element.children[element.children.length - 1];\n      if (lastNode && lastNode.type === 3 && lastNode.text === ' ' && !inPre) {\n        element.children.pop();\n      }\n      // pop stack\n      stack.length -= 1;\n      currentParent = stack[stack.length - 1];\n      endPre(element);\n    },\n\n    chars: function chars (text) {\n      if (!currentParent) {\n        if (process.env.NODE_ENV !== 'production') {\n          if (text === template) {\n            warnOnce(\n              'Component template requires a root element, rather than just text.'\n            );\n          } else if ((text = text.trim())) {\n            warnOnce(\n              (\"text \\\"\" + text + \"\\\" outside root element will be ignored.\")\n            );\n          }\n        }\n        return\n      }\n      // IE textarea placeholder bug\n      /* istanbul ignore if */\n      if (isIE &&\n        currentParent.tag === 'textarea' &&\n        currentParent.attrsMap.placeholder === text\n      ) {\n        return\n      }\n      var children = currentParent.children;\n      text = inPre || text.trim()\n        ? isTextTag(currentParent) ? text : decodeHTMLCached(text)\n        // only preserve whitespace if its not right after a starting tag\n        : preserveWhitespace && children.length ? ' ' : '';\n      if (text) {\n        var expression;\n        if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) {\n          children.push({\n            type: 2,\n            expression: expression,\n            text: text\n          });\n        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {\n          children.push({\n            type: 3,\n            text: text\n          });\n        }\n      }\n    },\n    comment: function comment (text) {\n      currentParent.children.push({\n        type: 3,\n        text: text,\n        isComment: true\n      });\n    }\n  });\n  return root\n}\n\nfunction processPre (el) {\n  if (getAndRemoveAttr(el, 'v-pre') != null) {\n    el.pre = true;\n  }\n}\n\nfunction processRawAttrs (el) {\n  var l = el.attrsList.length;\n  if (l) {\n    var attrs = el.attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      attrs[i] = {\n        name: el.attrsList[i].name,\n        value: JSON.stringify(el.attrsList[i].value)\n      };\n    }\n  } else if (!el.pre) {\n    // non root node in pre blocks with no attributes\n    el.plain = true;\n  }\n}\n\nfunction processKey (el) {\n  var exp = getBindingAttr(el, 'key');\n  if (exp) {\n    if (process.env.NODE_ENV !== 'production' && el.tag === 'template') {\n      warn$2(\"<template> cannot be keyed. Place the key on real elements instead.\");\n    }\n    el.key = exp;\n  }\n}\n\nfunction processRef (el) {\n  var ref = getBindingAttr(el, 'ref');\n  if (ref) {\n    el.ref = ref;\n    el.refInFor = checkInFor(el);\n  }\n}\n\nfunction processFor (el) {\n  var exp;\n  if ((exp = getAndRemoveAttr(el, 'v-for'))) {\n    var inMatch = exp.match(forAliasRE);\n    if (!inMatch) {\n      process.env.NODE_ENV !== 'production' && warn$2(\n        (\"Invalid v-for expression: \" + exp)\n      );\n      return\n    }\n    el.for = inMatch[2].trim();\n    var alias = inMatch[1].trim();\n    var iteratorMatch = alias.match(forIteratorRE);\n    if (iteratorMatch) {\n      el.alias = iteratorMatch[1].trim();\n      el.iterator1 = iteratorMatch[2].trim();\n      if (iteratorMatch[3]) {\n        el.iterator2 = iteratorMatch[3].trim();\n      }\n    } else {\n      el.alias = alias;\n    }\n  }\n}\n\nfunction processIf (el) {\n  var exp = getAndRemoveAttr(el, 'v-if');\n  if (exp) {\n    el.if = exp;\n    addIfCondition(el, {\n      exp: exp,\n      block: el\n    });\n  } else {\n    if (getAndRemoveAttr(el, 'v-else') != null) {\n      el.else = true;\n    }\n    var elseif = getAndRemoveAttr(el, 'v-else-if');\n    if (elseif) {\n      el.elseif = elseif;\n    }\n  }\n}\n\nfunction processIfConditions (el, parent) {\n  var prev = findPrevElement(parent.children);\n  if (prev && prev.if) {\n    addIfCondition(prev, {\n      exp: el.elseif,\n      block: el\n    });\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn$2(\n      \"v-\" + (el.elseif ? ('else-if=\"' + el.elseif + '\"') : 'else') + \" \" +\n      \"used on element <\" + (el.tag) + \"> without corresponding v-if.\"\n    );\n  }\n}\n\nfunction findPrevElement (children) {\n  var i = children.length;\n  while (i--) {\n    if (children[i].type === 1) {\n      return children[i]\n    } else {\n      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {\n        warn$2(\n          \"text \\\"\" + (children[i].text.trim()) + \"\\\" between v-if and v-else(-if) \" +\n          \"will be ignored.\"\n        );\n      }\n      children.pop();\n    }\n  }\n}\n\nfunction addIfCondition (el, condition) {\n  if (!el.ifConditions) {\n    el.ifConditions = [];\n  }\n  el.ifConditions.push(condition);\n}\n\nfunction processOnce (el) {\n  var once$$1 = getAndRemoveAttr(el, 'v-once');\n  if (once$$1 != null) {\n    el.once = true;\n  }\n}\n\nfunction processSlot (el) {\n  if (el.tag === 'slot') {\n    el.slotName = getBindingAttr(el, 'name');\n    if (process.env.NODE_ENV !== 'production' && el.key) {\n      warn$2(\n        \"`key` does not work on <slot> because slots are abstract outlets \" +\n        \"and can possibly expand into multiple elements. \" +\n        \"Use the key on a wrapping element instead.\"\n      );\n    }\n  } else {\n    var slotTarget = getBindingAttr(el, 'slot');\n    if (slotTarget) {\n      el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n    }\n    if (el.tag === 'template') {\n      el.slotScope = getAndRemoveAttr(el, 'scope');\n    }\n  }\n}\n\nfunction processComponent (el) {\n  var binding;\n  if ((binding = getBindingAttr(el, 'is'))) {\n    el.component = binding;\n  }\n  if (getAndRemoveAttr(el, 'inline-template') != null) {\n    el.inlineTemplate = true;\n  }\n}\n\nfunction processAttrs (el) {\n  var list = el.attrsList;\n  var i, l, name, rawName, value, modifiers, isProp;\n  for (i = 0, l = list.length; i < l; i++) {\n    name = rawName = list[i].name;\n    value = list[i].value;\n    if (dirRE.test(name)) {\n      // mark element as dynamic\n      el.hasBindings = true;\n      // modifiers\n      modifiers = parseModifiers(name);\n      if (modifiers) {\n        name = name.replace(modifierRE, '');\n      }\n      if (bindRE.test(name)) { // v-bind\n        name = name.replace(bindRE, '');\n        value = parseFilters(value);\n        isProp = false;\n        if (modifiers) {\n          if (modifiers.prop) {\n            isProp = true;\n            name = camelize(name);\n            if (name === 'innerHtml') { name = 'innerHTML'; }\n          }\n          if (modifiers.camel) {\n            name = camelize(name);\n          }\n          if (modifiers.sync) {\n            addHandler(\n              el,\n              (\"update:\" + (camelize(name))),\n              genAssignmentCode(value, \"$event\")\n            );\n          }\n        }\n        if (isProp || (\n          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)\n        )) {\n          addProp(el, name, value);\n        } else {\n          addAttr(el, name, value);\n        }\n      } else if (onRE.test(name)) { // v-on\n        name = name.replace(onRE, '');\n        addHandler(el, name, value, modifiers, false, warn$2);\n      } else { // normal directives\n        name = name.replace(dirRE, '');\n        // parse arg\n        var argMatch = name.match(argRE);\n        var arg = argMatch && argMatch[1];\n        if (arg) {\n          name = name.slice(0, -(arg.length + 1));\n        }\n        addDirective(el, name, rawName, value, arg, modifiers);\n        if (process.env.NODE_ENV !== 'production' && name === 'model') {\n          checkForAliasModel(el, value);\n        }\n      }\n    } else {\n      // literal attribute\n      if (process.env.NODE_ENV !== 'production') {\n        var expression = parseText(value, delimiters);\n        if (expression) {\n          warn$2(\n            name + \"=\\\"\" + value + \"\\\": \" +\n            'Interpolation inside attributes has been removed. ' +\n            'Use v-bind or the colon shorthand instead. For example, ' +\n            'instead of <div id=\"{{ val }}\">, use <div :id=\"val\">.'\n          );\n        }\n      }\n      addAttr(el, name, JSON.stringify(value));\n    }\n  }\n}\n\nfunction checkInFor (el) {\n  var parent = el;\n  while (parent) {\n    if (parent.for !== undefined) {\n      return true\n    }\n    parent = parent.parent;\n  }\n  return false\n}\n\nfunction parseModifiers (name) {\n  var match = name.match(modifierRE);\n  if (match) {\n    var ret = {};\n    match.forEach(function (m) { ret[m.slice(1)] = true; });\n    return ret\n  }\n}\n\nfunction makeAttrsMap (attrs) {\n  var map = {};\n  for (var i = 0, l = attrs.length; i < l; i++) {\n    if (\n      process.env.NODE_ENV !== 'production' &&\n      map[attrs[i].name] && !isIE && !isEdge\n    ) {\n      warn$2('duplicate attribute: ' + attrs[i].name);\n    }\n    map[attrs[i].name] = attrs[i].value;\n  }\n  return map\n}\n\n// for script (e.g. type=\"x/template\") or style, do not decode content\nfunction isTextTag (el) {\n  return el.tag === 'script' || el.tag === 'style'\n}\n\nfunction isForbiddenTag (el) {\n  return (\n    el.tag === 'style' ||\n    (el.tag === 'script' && (\n      !el.attrsMap.type ||\n      el.attrsMap.type === 'text/javascript'\n    ))\n  )\n}\n\nvar ieNSBug = /^xmlns:NS\\d+/;\nvar ieNSPrefix = /^NS\\d+:/;\n\n/* istanbul ignore next */\nfunction guardIESVGBug (attrs) {\n  var res = [];\n  for (var i = 0; i < attrs.length; i++) {\n    var attr = attrs[i];\n    if (!ieNSBug.test(attr.name)) {\n      attr.name = attr.name.replace(ieNSPrefix, '');\n      res.push(attr);\n    }\n  }\n  return res\n}\n\nfunction checkForAliasModel (el, value) {\n  var _el = el;\n  while (_el) {\n    if (_el.for && _el.alias === value) {\n      warn$2(\n        \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n        \"You are binding v-model directly to a v-for iteration alias. \" +\n        \"This will not be able to modify the v-for source array because \" +\n        \"writing to the alias is like modifying a function local variable. \" +\n        \"Consider using an array of objects and use v-model on an object property instead.\"\n      );\n    }\n    _el = _el.parent;\n  }\n}\n\n/*  */\n\nvar isStaticKey;\nvar isPlatformReservedTag;\n\nvar genStaticKeysCached = cached(genStaticKeys$1);\n\n/**\n * Goal of the optimizer: walk the generated template AST tree\n * and detect sub-trees that are purely static, i.e. parts of\n * the DOM that never needs to change.\n *\n * Once we detect these sub-trees, we can:\n *\n * 1. Hoist them into constants, so that we no longer need to\n *    create fresh nodes for them on each re-render;\n * 2. Completely skip them in the patching process.\n */\nfunction optimize (root, options) {\n  if (!root) { return }\n  isStaticKey = genStaticKeysCached(options.staticKeys || '');\n  isPlatformReservedTag = options.isReservedTag || no;\n  // first pass: mark all non-static nodes.\n  markStatic$1(root);\n  // second pass: mark static roots.\n  markStaticRoots(root, false);\n}\n\nfunction genStaticKeys$1 (keys) {\n  return makeMap(\n    'type,tag,attrsList,attrsMap,plain,parent,children,attrs' +\n    (keys ? ',' + keys : '')\n  )\n}\n\nfunction markStatic$1 (node) {\n  node.static = isStatic(node);\n  if (node.type === 1) {\n    // do not make component slot content static. this avoids\n    // 1. components not able to mutate slot nodes\n    // 2. static slot content fails for hot-reloading\n    if (\n      !isPlatformReservedTag(node.tag) &&\n      node.tag !== 'slot' &&\n      node.attrsMap['inline-template'] == null\n    ) {\n      return\n    }\n    for (var i = 0, l = node.children.length; i < l; i++) {\n      var child = node.children[i];\n      markStatic$1(child);\n      if (!child.static) {\n        node.static = false;\n      }\n    }\n    if (node.ifConditions) {\n      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {\n        var block = node.ifConditions[i$1].block;\n        markStatic$1(block);\n        if (!block.static) {\n          node.static = false;\n        }\n      }\n    }\n  }\n}\n\nfunction markStaticRoots (node, isInFor) {\n  if (node.type === 1) {\n    if (node.static || node.once) {\n      node.staticInFor = isInFor;\n    }\n    // For a node to qualify as a static root, it should have children that\n    // are not just static text. Otherwise the cost of hoisting out will\n    // outweigh the benefits and it's better off to just always render it fresh.\n    if (node.static && node.children.length && !(\n      node.children.length === 1 &&\n      node.children[0].type === 3\n    )) {\n      node.staticRoot = true;\n      return\n    } else {\n      node.staticRoot = false;\n    }\n    if (node.children) {\n      for (var i = 0, l = node.children.length; i < l; i++) {\n        markStaticRoots(node.children[i], isInFor || !!node.for);\n      }\n    }\n    if (node.ifConditions) {\n      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {\n        markStaticRoots(node.ifConditions[i$1].block, isInFor);\n      }\n    }\n  }\n}\n\nfunction isStatic (node) {\n  if (node.type === 2) { // expression\n    return false\n  }\n  if (node.type === 3) { // text\n    return true\n  }\n  return !!(node.pre || (\n    !node.hasBindings && // no dynamic bindings\n    !node.if && !node.for && // not v-if or v-for or v-else\n    !isBuiltInTag(node.tag) && // not a built-in\n    isPlatformReservedTag(node.tag) && // not a component\n    !isDirectChildOfTemplateFor(node) &&\n    Object.keys(node).every(isStaticKey)\n  ))\n}\n\nfunction isDirectChildOfTemplateFor (node) {\n  while (node.parent) {\n    node = node.parent;\n    if (node.tag !== 'template') {\n      return false\n    }\n    if (node.for) {\n      return true\n    }\n  }\n  return false\n}\n\n/*  */\n\nvar fnExpRE = /^\\s*([\\w$_]+|\\([^)]*?\\))\\s*=>|^function\\s*\\(/;\nvar simplePathRE = /^\\s*[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?']|\\[\".*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*\\s*$/;\n\n// keyCode aliases\nvar keyCodes = {\n  esc: 27,\n  tab: 9,\n  enter: 13,\n  space: 32,\n  up: 38,\n  left: 37,\n  right: 39,\n  down: 40,\n  'delete': [8, 46]\n};\n\n// #4868: modifiers that prevent the execution of the listener\n// need to explicitly return null so that we can determine whether to remove\n// the listener for .once\nvar genGuard = function (condition) { return (\"if(\" + condition + \")return null;\"); };\n\nvar modifierCode = {\n  stop: '$event.stopPropagation();',\n  prevent: '$event.preventDefault();',\n  self: genGuard(\"$event.target !== $event.currentTarget\"),\n  ctrl: genGuard(\"!$event.ctrlKey\"),\n  shift: genGuard(\"!$event.shiftKey\"),\n  alt: genGuard(\"!$event.altKey\"),\n  meta: genGuard(\"!$event.metaKey\"),\n  left: genGuard(\"'button' in $event && $event.button !== 0\"),\n  middle: genGuard(\"'button' in $event && $event.button !== 1\"),\n  right: genGuard(\"'button' in $event && $event.button !== 2\")\n};\n\nfunction genHandlers (\n  events,\n  isNative,\n  warn\n) {\n  var res = isNative ? 'nativeOn:{' : 'on:{';\n  for (var name in events) {\n    var handler = events[name];\n    // #5330: warn click.right, since right clicks do not actually fire click events.\n    if (process.env.NODE_ENV !== 'production' &&\n      name === 'click' &&\n      handler && handler.modifiers && handler.modifiers.right\n    ) {\n      warn(\n        \"Use \\\"contextmenu\\\" instead of \\\"click.right\\\" since right clicks \" +\n        \"do not actually fire \\\"click\\\" events.\"\n      );\n    }\n    res += \"\\\"\" + name + \"\\\":\" + (genHandler(name, handler)) + \",\";\n  }\n  return res.slice(0, -1) + '}'\n}\n\nfunction genHandler (\n  name,\n  handler\n) {\n  if (!handler) {\n    return 'function(){}'\n  }\n\n  if (Array.isArray(handler)) {\n    return (\"[\" + (handler.map(function (handler) { return genHandler(name, handler); }).join(',')) + \"]\")\n  }\n\n  var isMethodPath = simplePathRE.test(handler.value);\n  var isFunctionExpression = fnExpRE.test(handler.value);\n\n  if (!handler.modifiers) {\n    return isMethodPath || isFunctionExpression\n      ? handler.value\n      : (\"function($event){\" + (handler.value) + \"}\") // inline statement\n  } else {\n    var code = '';\n    var genModifierCode = '';\n    var keys = [];\n    for (var key in handler.modifiers) {\n      if (modifierCode[key]) {\n        genModifierCode += modifierCode[key];\n        // left/right\n        if (keyCodes[key]) {\n          keys.push(key);\n        }\n      } else {\n        keys.push(key);\n      }\n    }\n    if (keys.length) {\n      code += genKeyFilter(keys);\n    }\n    // Make sure modifiers like prevent and stop get executed after key filtering\n    if (genModifierCode) {\n      code += genModifierCode;\n    }\n    var handlerCode = isMethodPath\n      ? handler.value + '($event)'\n      : isFunctionExpression\n        ? (\"(\" + (handler.value) + \")($event)\")\n        : handler.value;\n    return (\"function($event){\" + code + handlerCode + \"}\")\n  }\n}\n\nfunction genKeyFilter (keys) {\n  return (\"if(!('button' in $event)&&\" + (keys.map(genFilterCode).join('&&')) + \")return null;\")\n}\n\nfunction genFilterCode (key) {\n  var keyVal = parseInt(key, 10);\n  if (keyVal) {\n    return (\"$event.keyCode!==\" + keyVal)\n  }\n  var alias = keyCodes[key];\n  return (\"_k($event.keyCode,\" + (JSON.stringify(key)) + (alias ? ',' + JSON.stringify(alias) : '') + \")\")\n}\n\n/*  */\n\nfunction on (el, dir) {\n  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {\n    warn(\"v-on without argument does not support modifiers.\");\n  }\n  el.wrapListeners = function (code) { return (\"_g(\" + code + \",\" + (dir.value) + \")\"); };\n}\n\n/*  */\n\nfunction bind$1 (el, dir) {\n  el.wrapData = function (code) {\n    return (\"_b(\" + code + \",'\" + (el.tag) + \"',\" + (dir.value) + \",\" + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + \")\")\n  };\n}\n\n/*  */\n\nvar baseDirectives = {\n  on: on,\n  bind: bind$1,\n  cloak: noop\n};\n\n/*  */\n\nvar CodegenState = function CodegenState (options) {\n  this.options = options;\n  this.warn = options.warn || baseWarn;\n  this.transforms = pluckModuleFunction(options.modules, 'transformCode');\n  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');\n  this.directives = extend(extend({}, baseDirectives), options.directives);\n  var isReservedTag = options.isReservedTag || no;\n  this.maybeComponent = function (el) { return !isReservedTag(el.tag); };\n  this.onceId = 0;\n  this.staticRenderFns = [];\n};\n\n\n\nfunction generate (\n  ast,\n  options\n) {\n  var state = new CodegenState(options);\n  var code = ast ? genElement(ast, state) : '_c(\"div\")';\n  return {\n    render: (\"with(this){return \" + code + \"}\"),\n    staticRenderFns: state.staticRenderFns\n  }\n}\n\nfunction genElement (el, state) {\n  if (el.staticRoot && !el.staticProcessed) {\n    return genStatic(el, state)\n  } else if (el.once && !el.onceProcessed) {\n    return genOnce(el, state)\n  } else if (el.for && !el.forProcessed) {\n    return genFor(el, state)\n  } else if (el.if && !el.ifProcessed) {\n    return genIf(el, state)\n  } else if (el.tag === 'template' && !el.slotTarget) {\n    return genChildren(el, state) || 'void 0'\n  } else if (el.tag === 'slot') {\n    return genSlot(el, state)\n  } else {\n    // component or element\n    var code;\n    if (el.component) {\n      code = genComponent(el.component, el, state);\n    } else {\n      var data = el.plain ? undefined : genData$2(el, state);\n\n      var children = el.inlineTemplate ? null : genChildren(el, state, true);\n      code = \"_c('\" + (el.tag) + \"'\" + (data ? (\",\" + data) : '') + (children ? (\",\" + children) : '') + \")\";\n    }\n    // module transforms\n    for (var i = 0; i < state.transforms.length; i++) {\n      code = state.transforms[i](el, code);\n    }\n    return code\n  }\n}\n\n// hoist static sub-trees out\nfunction genStatic (el, state) {\n  el.staticProcessed = true;\n  state.staticRenderFns.push((\"with(this){return \" + (genElement(el, state)) + \"}\"));\n  return (\"_m(\" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + \")\")\n}\n\n// v-once\nfunction genOnce (el, state) {\n  el.onceProcessed = true;\n  if (el.if && !el.ifProcessed) {\n    return genIf(el, state)\n  } else if (el.staticInFor) {\n    var key = '';\n    var parent = el.parent;\n    while (parent) {\n      if (parent.for) {\n        key = parent.key;\n        break\n      }\n      parent = parent.parent;\n    }\n    if (!key) {\n      process.env.NODE_ENV !== 'production' && state.warn(\n        \"v-once can only be used inside v-for that is keyed. \"\n      );\n      return genElement(el, state)\n    }\n    return (\"_o(\" + (genElement(el, state)) + \",\" + (state.onceId++) + (key ? (\",\" + key) : \"\") + \")\")\n  } else {\n    return genStatic(el, state)\n  }\n}\n\nfunction genIf (\n  el,\n  state,\n  altGen,\n  altEmpty\n) {\n  el.ifProcessed = true; // avoid recursion\n  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)\n}\n\nfunction genIfConditions (\n  conditions,\n  state,\n  altGen,\n  altEmpty\n) {\n  if (!conditions.length) {\n    return altEmpty || '_e()'\n  }\n\n  var condition = conditions.shift();\n  if (condition.exp) {\n    return (\"(\" + (condition.exp) + \")?\" + (genTernaryExp(condition.block)) + \":\" + (genIfConditions(conditions, state, altGen, altEmpty)))\n  } else {\n    return (\"\" + (genTernaryExp(condition.block)))\n  }\n\n  // v-if with v-once should generate code like (a)?_m(0):_m(1)\n  function genTernaryExp (el) {\n    return altGen\n      ? altGen(el, state)\n      : el.once\n        ? genOnce(el, state)\n        : genElement(el, state)\n  }\n}\n\nfunction genFor (\n  el,\n  state,\n  altGen,\n  altHelper\n) {\n  var exp = el.for;\n  var alias = el.alias;\n  var iterator1 = el.iterator1 ? (\",\" + (el.iterator1)) : '';\n  var iterator2 = el.iterator2 ? (\",\" + (el.iterator2)) : '';\n\n  if (process.env.NODE_ENV !== 'production' &&\n    state.maybeComponent(el) &&\n    el.tag !== 'slot' &&\n    el.tag !== 'template' &&\n    !el.key\n  ) {\n    state.warn(\n      \"<\" + (el.tag) + \" v-for=\\\"\" + alias + \" in \" + exp + \"\\\">: component lists rendered with \" +\n      \"v-for should have explicit keys. \" +\n      \"See https://vuejs.org/guide/list.html#key for more info.\",\n      true /* tip */\n    );\n  }\n\n  el.forProcessed = true; // avoid recursion\n  return (altHelper || '_l') + \"((\" + exp + \"),\" +\n    \"function(\" + alias + iterator1 + iterator2 + \"){\" +\n      \"return \" + ((altGen || genElement)(el, state)) +\n    '})'\n}\n\nfunction genData$2 (el, state) {\n  var data = '{';\n\n  // directives first.\n  // directives may mutate the el's other properties before they are generated.\n  var dirs = genDirectives(el, state);\n  if (dirs) { data += dirs + ','; }\n\n  // key\n  if (el.key) {\n    data += \"key:\" + (el.key) + \",\";\n  }\n  // ref\n  if (el.ref) {\n    data += \"ref:\" + (el.ref) + \",\";\n  }\n  if (el.refInFor) {\n    data += \"refInFor:true,\";\n  }\n  // pre\n  if (el.pre) {\n    data += \"pre:true,\";\n  }\n  // record original tag name for components using \"is\" attribute\n  if (el.component) {\n    data += \"tag:\\\"\" + (el.tag) + \"\\\",\";\n  }\n  // module data generation functions\n  for (var i = 0; i < state.dataGenFns.length; i++) {\n    data += state.dataGenFns[i](el);\n  }\n  // attributes\n  if (el.attrs) {\n    data += \"attrs:{\" + (genProps(el.attrs)) + \"},\";\n  }\n  // DOM props\n  if (el.props) {\n    data += \"domProps:{\" + (genProps(el.props)) + \"},\";\n  }\n  // event handlers\n  if (el.events) {\n    data += (genHandlers(el.events, false, state.warn)) + \",\";\n  }\n  if (el.nativeEvents) {\n    data += (genHandlers(el.nativeEvents, true, state.warn)) + \",\";\n  }\n  // slot target\n  if (el.slotTarget) {\n    data += \"slot:\" + (el.slotTarget) + \",\";\n  }\n  // scoped slots\n  if (el.scopedSlots) {\n    data += (genScopedSlots(el.scopedSlots, state)) + \",\";\n  }\n  // component v-model\n  if (el.model) {\n    data += \"model:{value:\" + (el.model.value) + \",callback:\" + (el.model.callback) + \",expression:\" + (el.model.expression) + \"},\";\n  }\n  // inline-template\n  if (el.inlineTemplate) {\n    var inlineTemplate = genInlineTemplate(el, state);\n    if (inlineTemplate) {\n      data += inlineTemplate + \",\";\n    }\n  }\n  data = data.replace(/,$/, '') + '}';\n  // v-bind data wrap\n  if (el.wrapData) {\n    data = el.wrapData(data);\n  }\n  // v-on data wrap\n  if (el.wrapListeners) {\n    data = el.wrapListeners(data);\n  }\n  return data\n}\n\nfunction genDirectives (el, state) {\n  var dirs = el.directives;\n  if (!dirs) { return }\n  var res = 'directives:[';\n  var hasRuntime = false;\n  var i, l, dir, needRuntime;\n  for (i = 0, l = dirs.length; i < l; i++) {\n    dir = dirs[i];\n    needRuntime = true;\n    var gen = state.directives[dir.name];\n    if (gen) {\n      // compile-time directive that manipulates AST.\n      // returns true if it also needs a runtime counterpart.\n      needRuntime = !!gen(el, dir, state.warn);\n    }\n    if (needRuntime) {\n      hasRuntime = true;\n      res += \"{name:\\\"\" + (dir.name) + \"\\\",rawName:\\\"\" + (dir.rawName) + \"\\\"\" + (dir.value ? (\",value:(\" + (dir.value) + \"),expression:\" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (\",arg:\\\"\" + (dir.arg) + \"\\\"\") : '') + (dir.modifiers ? (\",modifiers:\" + (JSON.stringify(dir.modifiers))) : '') + \"},\";\n    }\n  }\n  if (hasRuntime) {\n    return res.slice(0, -1) + ']'\n  }\n}\n\nfunction genInlineTemplate (el, state) {\n  var ast = el.children[0];\n  if (process.env.NODE_ENV !== 'production' && (\n    el.children.length > 1 || ast.type !== 1\n  )) {\n    state.warn('Inline-template components must have exactly one child element.');\n  }\n  if (ast.type === 1) {\n    var inlineRenderFns = generate(ast, state.options);\n    return (\"inlineTemplate:{render:function(){\" + (inlineRenderFns.render) + \"},staticRenderFns:[\" + (inlineRenderFns.staticRenderFns.map(function (code) { return (\"function(){\" + code + \"}\"); }).join(',')) + \"]}\")\n  }\n}\n\nfunction genScopedSlots (\n  slots,\n  state\n) {\n  return (\"scopedSlots:_u([\" + (Object.keys(slots).map(function (key) {\n      return genScopedSlot(key, slots[key], state)\n    }).join(',')) + \"])\")\n}\n\nfunction genScopedSlot (\n  key,\n  el,\n  state\n) {\n  if (el.for && !el.forProcessed) {\n    return genForScopedSlot(key, el, state)\n  }\n  return \"{key:\" + key + \",fn:function(\" + (String(el.attrsMap.scope)) + \"){\" +\n    \"return \" + (el.tag === 'template'\n      ? genChildren(el, state) || 'void 0'\n      : genElement(el, state)) + \"}}\"\n}\n\nfunction genForScopedSlot (\n  key,\n  el,\n  state\n) {\n  var exp = el.for;\n  var alias = el.alias;\n  var iterator1 = el.iterator1 ? (\",\" + (el.iterator1)) : '';\n  var iterator2 = el.iterator2 ? (\",\" + (el.iterator2)) : '';\n  el.forProcessed = true; // avoid recursion\n  return \"_l((\" + exp + \"),\" +\n    \"function(\" + alias + iterator1 + iterator2 + \"){\" +\n      \"return \" + (genScopedSlot(key, el, state)) +\n    '})'\n}\n\nfunction genChildren (\n  el,\n  state,\n  checkSkip,\n  altGenElement,\n  altGenNode\n) {\n  var children = el.children;\n  if (children.length) {\n    var el$1 = children[0];\n    // optimize single v-for\n    if (children.length === 1 &&\n      el$1.for &&\n      el$1.tag !== 'template' &&\n      el$1.tag !== 'slot'\n    ) {\n      return (altGenElement || genElement)(el$1, state)\n    }\n    var normalizationType = checkSkip\n      ? getNormalizationType(children, state.maybeComponent)\n      : 0;\n    var gen = altGenNode || genNode;\n    return (\"[\" + (children.map(function (c) { return gen(c, state); }).join(',')) + \"]\" + (normalizationType ? (\",\" + normalizationType) : ''))\n  }\n}\n\n// determine the normalization needed for the children array.\n// 0: no normalization needed\n// 1: simple normalization needed (possible 1-level deep nested array)\n// 2: full normalization needed\nfunction getNormalizationType (\n  children,\n  maybeComponent\n) {\n  var res = 0;\n  for (var i = 0; i < children.length; i++) {\n    var el = children[i];\n    if (el.type !== 1) {\n      continue\n    }\n    if (needsNormalization(el) ||\n        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {\n      res = 2;\n      break\n    }\n    if (maybeComponent(el) ||\n        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {\n      res = 1;\n    }\n  }\n  return res\n}\n\nfunction needsNormalization (el) {\n  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'\n}\n\nfunction genNode (node, state) {\n  if (node.type === 1) {\n    return genElement(node, state)\n  } if (node.type === 3 && node.isComment) {\n    return genComment(node)\n  } else {\n    return genText(node)\n  }\n}\n\nfunction genText (text) {\n  return (\"_v(\" + (text.type === 2\n    ? text.expression // no need for () because already wrapped in _s()\n    : transformSpecialNewlines(JSON.stringify(text.text))) + \")\")\n}\n\nfunction genComment (comment) {\n  return (\"_e(\" + (JSON.stringify(comment.text)) + \")\")\n}\n\nfunction genSlot (el, state) {\n  var slotName = el.slotName || '\"default\"';\n  var children = genChildren(el, state);\n  var res = \"_t(\" + slotName + (children ? (\",\" + children) : '');\n  var attrs = el.attrs && (\"{\" + (el.attrs.map(function (a) { return ((camelize(a.name)) + \":\" + (a.value)); }).join(',')) + \"}\");\n  var bind$$1 = el.attrsMap['v-bind'];\n  if ((attrs || bind$$1) && !children) {\n    res += \",null\";\n  }\n  if (attrs) {\n    res += \",\" + attrs;\n  }\n  if (bind$$1) {\n    res += (attrs ? '' : ',null') + \",\" + bind$$1;\n  }\n  return res + ')'\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent (\n  componentName,\n  el,\n  state\n) {\n  var children = el.inlineTemplate ? null : genChildren(el, state, true);\n  return (\"_c(\" + componentName + \",\" + (genData$2(el, state)) + (children ? (\",\" + children) : '') + \")\")\n}\n\nfunction genProps (props) {\n  var res = '';\n  for (var i = 0; i < props.length; i++) {\n    var prop = props[i];\n    res += \"\\\"\" + (prop.name) + \"\\\":\" + (transformSpecialNewlines(prop.value)) + \",\";\n  }\n  return res.slice(0, -1)\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines (text) {\n  return text\n    .replace(/\\u2028/g, '\\\\u2028')\n    .replace(/\\u2029/g, '\\\\u2029')\n}\n\n/*  */\n\n// these keywords should not appear inside expressions, but operators like\n// typeof, instanceof and in are allowed\nvar prohibitedKeywordRE = new RegExp('\\\\b' + (\n  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +\n  'super,throw,while,yield,delete,export,import,return,switch,default,' +\n  'extends,finally,continue,debugger,function,arguments'\n).split(',').join('\\\\b|\\\\b') + '\\\\b');\n\n// these unary operators should not be used as property/method names\nvar unaryOperatorsRE = new RegExp('\\\\b' + (\n  'delete,typeof,void'\n).split(',').join('\\\\s*\\\\([^\\\\)]*\\\\)|\\\\b') + '\\\\s*\\\\([^\\\\)]*\\\\)');\n\n// check valid identifier for v-for\nvar identRE = /[A-Za-z_$][\\w$]*/;\n\n// strip strings in expressions\nvar stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n// detect problematic expressions in a template\nfunction detectErrors (ast) {\n  var errors = [];\n  if (ast) {\n    checkNode(ast, errors);\n  }\n  return errors\n}\n\nfunction checkNode (node, errors) {\n  if (node.type === 1) {\n    for (var name in node.attrsMap) {\n      if (dirRE.test(name)) {\n        var value = node.attrsMap[name];\n        if (value) {\n          if (name === 'v-for') {\n            checkFor(node, (\"v-for=\\\"\" + value + \"\\\"\"), errors);\n          } else if (onRE.test(name)) {\n            checkEvent(value, (name + \"=\\\"\" + value + \"\\\"\"), errors);\n          } else {\n            checkExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), errors);\n          }\n        }\n      }\n    }\n    if (node.children) {\n      for (var i = 0; i < node.children.length; i++) {\n        checkNode(node.children[i], errors);\n      }\n    }\n  } else if (node.type === 2) {\n    checkExpression(node.expression, node.text, errors);\n  }\n}\n\nfunction checkEvent (exp, text, errors) {\n  var stipped = exp.replace(stripStringRE, '');\n  var keywordMatch = stipped.match(unaryOperatorsRE);\n  if (keywordMatch && stipped.charAt(keywordMatch.index - 1) !== '$') {\n    errors.push(\n      \"avoid using JavaScript unary operator as property name: \" +\n      \"\\\"\" + (keywordMatch[0]) + \"\\\" in expression \" + (text.trim())\n    );\n  }\n  checkExpression(exp, text, errors);\n}\n\nfunction checkFor (node, text, errors) {\n  checkExpression(node.for || '', text, errors);\n  checkIdentifier(node.alias, 'v-for alias', text, errors);\n  checkIdentifier(node.iterator1, 'v-for iterator', text, errors);\n  checkIdentifier(node.iterator2, 'v-for iterator', text, errors);\n}\n\nfunction checkIdentifier (ident, type, text, errors) {\n  if (typeof ident === 'string' && !identRE.test(ident)) {\n    errors.push((\"invalid \" + type + \" \\\"\" + ident + \"\\\" in expression: \" + (text.trim())));\n  }\n}\n\nfunction checkExpression (exp, text, errors) {\n  try {\n    new Function((\"return \" + exp));\n  } catch (e) {\n    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n    if (keywordMatch) {\n      errors.push(\n        \"avoid using JavaScript keyword as property name: \" +\n        \"\\\"\" + (keywordMatch[0]) + \"\\\" in expression \" + (text.trim())\n      );\n    } else {\n      errors.push((\"invalid expression: \" + (text.trim())));\n    }\n  }\n}\n\n/*  */\n\nfunction createFunction (code, errors) {\n  try {\n    return new Function(code)\n  } catch (err) {\n    errors.push({ err: err, code: code });\n    return noop\n  }\n}\n\nfunction createCompileToFunctionFn (compile) {\n  var cache = Object.create(null);\n\n  return function compileToFunctions (\n    template,\n    options,\n    vm\n  ) {\n    options = options || {};\n\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production') {\n      // detect possible CSP restriction\n      try {\n        new Function('return 1');\n      } catch (e) {\n        if (e.toString().match(/unsafe-eval|CSP/)) {\n          warn(\n            'It seems you are using the standalone build of Vue.js in an ' +\n            'environment with Content Security Policy that prohibits unsafe-eval. ' +\n            'The template compiler cannot work in this environment. Consider ' +\n            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +\n            'templates into render functions.'\n          );\n        }\n      }\n    }\n\n    // check cache\n    var key = options.delimiters\n      ? String(options.delimiters) + template\n      : template;\n    if (cache[key]) {\n      return cache[key]\n    }\n\n    // compile\n    var compiled = compile(template, options);\n\n    // check compilation errors/tips\n    if (process.env.NODE_ENV !== 'production') {\n      if (compiled.errors && compiled.errors.length) {\n        warn(\n          \"Error compiling template:\\n\\n\" + template + \"\\n\\n\" +\n          compiled.errors.map(function (e) { return (\"- \" + e); }).join('\\n') + '\\n',\n          vm\n        );\n      }\n      if (compiled.tips && compiled.tips.length) {\n        compiled.tips.forEach(function (msg) { return tip(msg, vm); });\n      }\n    }\n\n    // turn code into functions\n    var res = {};\n    var fnGenErrors = [];\n    res.render = createFunction(compiled.render, fnGenErrors);\n    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {\n      return createFunction(code, fnGenErrors)\n    });\n\n    // check function generation errors.\n    // this should only happen if there is a bug in the compiler itself.\n    // mostly for codegen development use\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production') {\n      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {\n        warn(\n          \"Failed to generate render function:\\n\\n\" +\n          fnGenErrors.map(function (ref) {\n            var err = ref.err;\n            var code = ref.code;\n\n            return ((err.toString()) + \" in\\n\\n\" + code + \"\\n\");\n        }).join('\\n'),\n          vm\n        );\n      }\n    }\n\n    return (cache[key] = res)\n  }\n}\n\n/*  */\n\nfunction createCompilerCreator (baseCompile) {\n  return function createCompiler (baseOptions) {\n    function compile (\n      template,\n      options\n    ) {\n      var finalOptions = Object.create(baseOptions);\n      var errors = [];\n      var tips = [];\n      finalOptions.warn = function (msg, tip) {\n        (tip ? tips : errors).push(msg);\n      };\n\n      if (options) {\n        // merge custom modules\n        if (options.modules) {\n          finalOptions.modules =\n            (baseOptions.modules || []).concat(options.modules);\n        }\n        // merge custom directives\n        if (options.directives) {\n          finalOptions.directives = extend(\n            Object.create(baseOptions.directives),\n            options.directives\n          );\n        }\n        // copy other options\n        for (var key in options) {\n          if (key !== 'modules' && key !== 'directives') {\n            finalOptions[key] = options[key];\n          }\n        }\n      }\n\n      var compiled = baseCompile(template, finalOptions);\n      if (process.env.NODE_ENV !== 'production') {\n        errors.push.apply(errors, detectErrors(compiled.ast));\n      }\n      compiled.errors = errors;\n      compiled.tips = tips;\n      return compiled\n    }\n\n    return {\n      compile: compile,\n      compileToFunctions: createCompileToFunctionFn(compile)\n    }\n  }\n}\n\n/*  */\n\n// `createCompilerCreator` allows creating compilers that use alternative\n// parser/optimizer/codegen, e.g the SSR optimizing compiler.\n// Here we just export a default compiler using the default parts.\nvar createCompiler = createCompilerCreator(function baseCompile (\n  template,\n  options\n) {\n  var ast = parse(template.trim(), options);\n  optimize(ast, options);\n  var code = generate(ast, options);\n  return {\n    ast: ast,\n    render: code.render,\n    staticRenderFns: code.staticRenderFns\n  }\n});\n\n/*  */\n\nvar ref$1 = createCompiler(baseOptions);\nvar compileToFunctions = ref$1.compileToFunctions;\n\n/*  */\n\nvar idToTemplate = cached(function (id) {\n  var el = query(id);\n  return el && el.innerHTML\n});\n\nvar mount = Vue$3.prototype.$mount;\nVue$3.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && query(el);\n\n  /* istanbul ignore if */\n  if (el === document.body || el === document.documentElement) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"Do not mount Vue to <html> or <body> - mount to normal elements instead.\"\n    );\n    return this\n  }\n\n  var options = this.$options;\n  // resolve template/el and convert to render function\n  if (!options.render) {\n    var template = options.template;\n    if (template) {\n      if (typeof template === 'string') {\n        if (template.charAt(0) === '#') {\n          template = idToTemplate(template);\n          /* istanbul ignore if */\n          if (process.env.NODE_ENV !== 'production' && !template) {\n            warn(\n              (\"Template element not found or is empty: \" + (options.template)),\n              this\n            );\n          }\n        }\n      } else if (template.nodeType) {\n        template = template.innerHTML;\n      } else {\n        if (process.env.NODE_ENV !== 'production') {\n          warn('invalid template option:' + template, this);\n        }\n        return this\n      }\n    } else if (el) {\n      template = getOuterHTML(el);\n    }\n    if (template) {\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n        mark('compile');\n      }\n\n      var ref = compileToFunctions(template, {\n        shouldDecodeNewlines: shouldDecodeNewlines,\n        delimiters: options.delimiters,\n        comments: options.comments\n      }, this);\n      var render = ref.render;\n      var staticRenderFns = ref.staticRenderFns;\n      options.render = render;\n      options.staticRenderFns = staticRenderFns;\n\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n        mark('compile end');\n        measure(((this._name) + \" compile\"), 'compile', 'compile end');\n      }\n    }\n  }\n  return mount.call(this, el, hydrating)\n};\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n */\nfunction getOuterHTML (el) {\n  if (el.outerHTML) {\n    return el.outerHTML\n  } else {\n    var container = document.createElement('div');\n    container.appendChild(el.cloneNode(true));\n    return container.innerHTML\n  }\n}\n\nVue$3.compile = compileToFunctions;\n\nexport default Vue$3;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/vue/dist/vue.esm.js","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n// WEBPACK FOOTER //\n// (webpack)/buildin/global.js","\nconst MoveTo = (() => {\n  /**\n   * Defaults\n   * @type {object}\n   */\n  const defaults = {\n    tolerance: 0,\n    duration: 800,\n    easing: 'easeOutQuart',\n    callback: function() {},\n  };\n\n  /**\n   * easeOutQuart Easing Function\n   * @param  {number} t - current time\n   * @param  {number} b - start value\n   * @param  {number} c - change in value\n   * @param  {number} d - duration\n   * @return {number} - calculated value\n   */\n  function easeOutQuart(t, b, c, d) {\n    t /= d;\n    t--;\n    return -c * (t * t * t * t - 1) + b;\n  }\n\n  /**\n   * Returns html element's top and left offset\n   * @param  {HTMLElement} elem - Element\n   * @return {object} Element top and left offset\n   */\n  function getOffsetSum(elem) {\n    let top = 0;\n    let left = 0;\n    while (elem) {\n      top += elem.offsetTop;\n      left += elem.offsetLeft;\n      elem = elem.offsetParent;\n    }\n    return {\n      top, left,\n    };\n  }\n\n  /**\n   * Merge two object\n   *\n   * @param  {object} obj1\n   * @param  {object} obj2\n   * @return {object} merged object\n   */\n  function mergeObject(obj1, obj2) {\n    const obj3 = {};\n    Object.keys(obj1).forEach((propertyName) => {\n      obj3[propertyName] = obj1[propertyName];\n    });\n\n    Object.keys(obj2).forEach((propertyName) => {\n      obj3[propertyName] = obj2[propertyName];\n    });\n    return obj3;\n  };\n\n  /**\n   * Converts camel case to kebab case\n   * @param  {string} val the value to be converted\n   * @return {string} the converted value\n   */\n  function kebabCase(val) {\n    return val.replace(/([A-Z])/g, function($1) {\n      return '-' + $1.toLowerCase();\n    });\n  };\n\n  /**\n   * MoveTo Constructor\n   * @param {object} options Options\n   * @param {object} easeFunctions Custom ease functions\n   */\n  function MoveTo(options = {}, easeFunctions = {}) {\n    this.options = mergeObject(defaults, options);\n    this.easeFunctions = mergeObject({easeOutQuart}, easeFunctions);\n  }\n\n  /**\n   * Register a dom element as trigger\n   * @param  {HTMLElement} dom Dom trigger element\n   * @param  {function} callback Callback function\n   */\n  MoveTo.prototype.registerTrigger = function(dom, callback) {\n    if (!dom) {\n      return;\n    }\n\n    const href = dom.getAttribute('href') || dom.getAttribute('data-target');\n    // The element to be scrolled\n    const target = (href && href !== '#')\n      ? document.getElementById(href.substring(1))\n      : 0;\n    const options = mergeObject(this.options, _getOptionsFromTriggerDom(dom, this.options));\n\n    if (typeof callback === 'function') {\n      options.callback = callback;\n    }\n\n    dom.addEventListener('click', (e) => {\n      e.preventDefault();\n      this.move(target, options);\n    });\n  };\n\n  /**\n   * Move\n   * Scrolls to given element by using easeOutQuart function\n   * @param  {HTMLElement|number} target Target element to be scrolled or target position\n   * @param  {object} options Custom options\n   */\n  MoveTo.prototype.move = function(target, options = {}) {\n    if (target !== 0 && !target) {\n      return;\n    }\n\n    options = mergeObject(this.options, options);\n\n    let to = typeof target === 'number' ? target : getOffsetSum(target).top;\n    const from = window.pageYOffset;\n    to -= options.tolerance;\n    const change = to - from;\n    let startTime = null;\n    let lastPageYOffset = 0;\n\n    // rAF loop\n    const loop = (currentTime) => {\n      let currentPageYOffset = window.pageYOffset;\n\n      if (!startTime) {\n        // To starts time from 1, we subtracted -1 from current time\n        // If time starts from 1 The first loop will not do anything,\n        // because easing value will be zero\n        startTime = currentTime - 1;\n      }\n\n      const timeElapsed = currentTime - startTime;\n\n      if (lastPageYOffset !== 0) {\n        if (\n          (lastPageYOffset === currentPageYOffset) ||\n          (change > 0 && lastPageYOffset > currentPageYOffset) ||\n          (change < 0 && lastPageYOffset < currentPageYOffset)\n        ) {\n          return options.callback(target);\n        }\n      }\n      lastPageYOffset = currentPageYOffset;\n\n      const val = this.easeFunctions[options.easing](\n        timeElapsed, from, change, options.duration\n      );\n\n      window.scroll(0, val);\n\n      if (timeElapsed < options.duration) {\n        window.requestAnimationFrame(loop);\n      } else {\n        window.scroll(0, to);\n        options.callback(target);\n      }\n    };\n\n    window.requestAnimationFrame(loop);\n  };\n\n  /**\n   * Adds custom ease function\n   * @param {string}   name Ease function name\n   * @param {function} fn   Ease function\n   */\n  MoveTo.prototype.addEaseFunction = function(name, fn) {\n    this.easeFunctions[name] = fn;\n  };\n\n  /**\n   * Returns options which created from trigger dom element\n   * @param  {HTMLElement} dom Trigger dom element\n   * @param  {object} options The instance's options\n   * @return {object} The options which created from trigger dom element\n   */\n  function _getOptionsFromTriggerDom(dom, options) {\n    const domOptions = {};\n\n    Object.keys(options).forEach((key) => {\n      let value = dom.getAttribute(`data-mt-${kebabCase(key)}`);\n      if (value) {\n        domOptions[key] = isNaN(value) ? value : parseInt(value, 10);\n      }\n    });\n    return domOptions;\n  }\n\n  return MoveTo;\n})();\n\nif (typeof module !== 'undefined') {\n  module.exports = MoveTo;\n} else {\n  window.moveTo = MoveTo;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/moveto/src/moveTo.js","function injectStyle (ssrContext) {\n  require(\"!!../../../node_modules/extract-text-webpack-plugin/dist/loader.js?{\\\"omit\\\":1,\\\"remove\\\":true}!vue-style-loader!css-loader?minimize!../../../node_modules/vue-loader/lib/style-compiler/index?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-65807d96\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/vue-loader/lib/selector?type=styles&index=0!./videobg.vue\")\n}\nvar normalizeComponent = require(\"!../../../node_modules/vue-loader/lib/component-normalizer\")\n/* script */\nimport __vue_script__ from \"!!babel-loader!../../../node_modules/vue-loader/lib/selector?type=script&index=0!./videobg.vue\"\n/* template */\nimport __vue_template__ from \"!!../../../node_modules/vue-loader/lib/template-compiler/index?{\\\"id\\\":\\\"data-v-65807d96\\\",\\\"hasScoped\\\":false}!../../../node_modules/vue-loader/lib/selector?type=template&index=0!./videobg.vue\"\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n  __vue_script__,\n  __vue_template__,\n  __vue_styles__,\n  __vue_scopeId__,\n  __vue_module_identifier__\n)\n\nexport default Component.exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/javascript/packs/videobg.vue\n// module id = 3\n// module chunks = 0 1","/* globals __VUE_SSR_CONTEXT__ */\n\n// this module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle\n\nmodule.exports = function normalizeComponent (\n  rawScriptExports,\n  compiledTemplate,\n  injectStyles,\n  scopeId,\n  moduleIdentifier /* server only */\n) {\n  var esModule\n  var scriptExports = rawScriptExports = rawScriptExports || {}\n\n  // ES6 modules interop\n  var type = typeof rawScriptExports.default\n  if (type === 'object' || type === 'function') {\n    esModule = rawScriptExports\n    scriptExports = rawScriptExports.default\n  }\n\n  // Vue.extend constructor export interop\n  var options = typeof scriptExports === 'function'\n    ? scriptExports.options\n    : scriptExports\n\n  // render functions\n  if (compiledTemplate) {\n    options.render = compiledTemplate.render\n    options.staticRenderFns = compiledTemplate.staticRenderFns\n  }\n\n  // scopedId\n  if (scopeId) {\n    options._scopeId = scopeId\n  }\n\n  var hook\n  if (moduleIdentifier) { // server build\n    hook = function (context) {\n      // 2.3 injection\n      context =\n        context || // cached call\n        (this.$vnode && this.$vnode.ssrContext) || // stateful\n        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n      // 2.2 with runInNewContext: true\n      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n        context = __VUE_SSR_CONTEXT__\n      }\n      // inject component styles\n      if (injectStyles) {\n        injectStyles.call(this, context)\n      }\n      // register component module identifier for async chunk inferrence\n      if (context && context._registeredComponents) {\n        context._registeredComponents.add(moduleIdentifier)\n      }\n    }\n    // used by ssr in case component is cached and beforeCreate\n    // never gets called\n    options._ssrRegister = hook\n  } else if (injectStyles) {\n    hook = injectStyles\n  }\n\n  if (hook) {\n    var functional = options.functional\n    var existing = functional\n      ? options.render\n      : options.beforeCreate\n    if (!functional) {\n      // inject component registration as beforeCreate hook\n      options.beforeCreate = existing\n        ? [].concat(existing, hook)\n        : [hook]\n    } else {\n      // register for functioal component in vue file\n      options.render = function renderWithStyleInjection (h, context) {\n        hook.call(context)\n        return existing(h, context)\n      }\n    }\n  }\n\n  return {\n    esModule: esModule,\n    exports: scriptExports,\n    options: options\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-loader/lib/component-normalizer.js\n// module id = 5\n// module chunks = 0 1","<template>\n  <section class=\"VideoBg\">\n    <video autoplay loop muted playsinline ref=video>\n      <source v-for=\"source in sources\" :src=\"source\" :type=\"getMediaType(source)\">\n    </video>\n    <div class=\"VideoBg__content\">\n      <slot></slot>\n    </div>\n  </section>\n</template>\n\n\n<script>\n  export default {\n    props: {\n      sources: {\n        type: Array,\n        required: true\n      },\n      img: {\n        type: String\n      }\n    },\n\n    data () {\n      return {\n        videoRatio: null\n      }\n    },\n\n    mounted () {\n      this.setImageUrl()\n      this.setContainerHeight()\n\n      if (this.videoCanPlay()) {\n        this.$refs.video.oncanplay = () => {\n          if (!this.$refs.video) return\n\n          this.videoRatio = this.$refs.video.videoWidth / this.$refs.video.videoHeight\n          this.setVideoSize()\n          this.$refs.video.style.visibility = 'visible'\n        }\n      }\n\n      window.addEventListener('resize', this.resize)\n    },\n\n    beforeDestroy () {\n      window.removeEventListener('resize', this.resize)\n    },\n\n    methods: {\n      resize () {\n        this.setContainerHeight()\n\n        if (this.videoCanPlay()) {\n          this.setVideoSize()\n        }\n      },\n\n      videoCanPlay () {\n        return !!this.$refs.video.canPlayType\n      },\n\n      setImageUrl () {\n        if (this.img) {\n          this.$el.style.backgroundImage = `url(${this.img})`\n        }\n      },\n\n      setContainerHeight () {\n        this.$el.style.height = `${window.innerHeight}px`\n      },\n\n      setVideoSize () {\n        var width, height, containerRatio = this.$el.offsetWidth / this.$el.offsetHeight\n\n        if (containerRatio > this.videoRatio) {\n          width = this.$el.offsetWidth\n        } else {\n          height = this.$el.offsetHeight\n        }\n\n        this.$refs.video.style.width = width ? `${width}px` : 'auto'\n        this.$refs.video.style.height = height ? `${height}px` : 'auto'\n      },\n\n      getMediaType (src) {\n        return 'video/' + src.split('.').pop()\n      }\n    }\n  }\n</script>\n\n\n<style>\n  .VideoBg {\n    position: relative;\n    background-size: cover;\n    background-position: center;\n    overflow: hidden;\n  }\n\n  .VideoBg video {\n    position: absolute;\n    top: 50%;\n    left: 50%;\n    visibility: hidden;\n    transform: translate(-50%, -50%);\n  }\n\n  .VideoBg__content {\n    position: absolute;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n  }\n</style>\n\n\n// WEBPACK FOOTER //\n// app/javascript/packs/videobg.vue?8a409a3a","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;\n  return _c('section', {\n    staticClass: \"VideoBg\"\n  }, [_c('video', {\n    ref: \"video\",\n    attrs: {\n      \"autoplay\": \"\",\n      \"loop\": \"\",\n      \"muted\": \"\",\n      \"playsinline\": \"\"\n    }\n  }, _vm._l((_vm.sources), function(source) {\n    return _c('source', {\n      attrs: {\n        \"src\": source,\n        \"type\": _vm.getMediaType(source)\n      }\n    })\n  })), _vm._v(\" \"), _c('div', {\n    staticClass: \"VideoBg__content\"\n  }, [_vm._t(\"default\")], 2)])\n}\nvar staticRenderFns = []\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\nexport default esExports\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-loader/lib/template-compiler?{\"id\":\"data-v-65807d96\",\"hasScoped\":false}!./node_modules/vue-loader/lib/selector.js?type=template&index=0!./app/javascript/packs/videobg.vue\n// module id = 7\n// module chunks = 0 1","import Vue from 'vue/dist/vue.esm'\nimport MoveTo from 'moveto'\n\nnew Vue({\n  el: '.gototop',\n  data: {\n    moveTo: null\n  },\n  methods: {\n    clicked: function() {\n      const target = document.getElementById('navbar');\n\n      this.$el.classList.add('moving')\n      Vue.nextTick(() => {\n        this.moveTo.move(target);\n      })\n    },\n    finished: function() {\n      this.$el.classList.remove('moving')\n    }\n  },\n  created: function() {\n    this.moveTo = new MoveTo({\n      callback: this.finished\n    });\n  }\n})\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/packs/top.js","/**\n * main.js\n * http://www.codrops.com\n *\n * Licensed under the MIT license.\n * http://www.opensource.org/licenses/mit-license.php\n *\n * Copyright 2016, Codrops\n * http://www.codrops.com\n */\n;(function(window) {\n\n  'use strict';\n\n  // Helper vars and functions.\n  function extend( a, b ) {\n    for( var key in b ) {\n      if( b.hasOwnProperty( key ) ) {\n        a[key] = b[key];\n      }\n    }\n    return a;\n  }\n\n  // from http://www.quirksmode.org/js/events_properties.html#position\n  function getMousePos(e) {\n    var posx = 0, posy = 0;\n    if (!e) var e = window.event;\n    if (e.pageX || e.pageY)   {\n      posx = e.pageX;\n      posy = e.pageY;\n    }\n    else if (e.clientX || e.clientY)  {\n      posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;\n      posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;\n    }\n    return { x : posx, y : posy }\n  }\n\n  /**\n   * TiltFx obj.\n   */\n  function TiltFx(el, options) {\n    this.DOM = {};\n    this.DOM.el = el;\n    this.options = extend({}, this.options);\n    extend(this.options, options);\n    this._init();\n  }\n\n  TiltFx.prototype.options = {\n    movement: {\n      imgWrapper : {\n        translation : {x: 0, y: 0, z: 0},\n        rotation : {x: -5, y: 5, z: 0},\n        reverseAnimation : {\n          duration : 1200,\n          easing : 'easeOutElastic',\n          elasticity : 600\n        }\n      },\n      lines : {\n        translation : {x: 10, y: 10, z: [0,10]},\n        reverseAnimation : {\n          duration : 1000,\n          easing : 'easeOutExpo',\n          elasticity : 600\n        }\n      },\n      caption : {\n        translation : {x: 20, y: 20, z: 0},\n        rotation : {x: 0, y: 0, z: 0},\n        reverseAnimation : {\n          duration : 1500,\n          easing : 'easeOutElastic',\n          elasticity : 600\n        }\n      },\n      /*\n      overlay : {\n        translation : {x: 10, y: 10, z: [0,50]},\n        reverseAnimation : {\n          duration : 500,\n          easing : 'easeOutExpo'\n        }\n      },\n      */\n      shine : {\n        translation : {x: 50, y: 50, z: 0},\n        reverseAnimation : {\n          duration : 1200,\n          easing : 'easeOutElastic',\n          elasticity: 600\n        }\n      }\n    }\n  };\n\n  /**\n   * Init.\n   */\n  TiltFx.prototype._init = function() {\n    this.DOM.animatable = {};\n    this.DOM.animatable.imgWrapper = this.DOM.el.querySelector('.tilter__figure');\n    this.DOM.animatable.lines = this.DOM.el.querySelector('.tilter__deco--lines');\n    this.DOM.animatable.caption = this.DOM.el.querySelector('.tilter__caption');\n    this.DOM.animatable.overlay = this.DOM.el.querySelector('.tilter__deco--overlay');\n    this.DOM.animatable.shine = this.DOM.el.querySelector('.tilter__deco--shine > div');\n    this._initEvents();\n  };\n\n  /**\n   * Init/Bind events.\n   */\n  TiltFx.prototype._initEvents = function() {\n    var self = this;\n\n    this.mouseenterFn = function() {\n      for(var key in self.DOM.animatable) {\n        anime.remove(self.DOM.animatable[key]);\n      }\n    };\n\n    this.mousemoveFn = function(ev) {\n      requestAnimationFrame(function() { self._layout(ev); });\n    };\n\n    this.mouseleaveFn = function(ev) {\n      requestAnimationFrame(function() {\n        for(var key in self.DOM.animatable) {\n          if( self.options.movement[key] == undefined ) {continue;}\n          anime({\n            targets: self.DOM.animatable[key],\n            duration: self.options.movement[key].reverseAnimation != undefined ? self.options.movement[key].reverseAnimation.duration || 0 : 1,\n            easing: self.options.movement[key].reverseAnimation != undefined ? self.options.movement[key].reverseAnimation.easing || 'linear' : 'linear',\n            elasticity: self.options.movement[key].reverseAnimation != undefined ? self.options.movement[key].reverseAnimation.elasticity || null : null,\n            scaleX: 1,\n            scaleY: 1,\n            scaleZ: 1,\n            translateX: 0,\n            translateY: 0,\n            translateZ: 0,\n            rotateX: 0,\n            rotateY: 0,\n            rotateZ: 0\n          });\n        }\n      });\n    };\n\n    this.DOM.el.addEventListener('mousemove', this.mousemoveFn);\n    this.DOM.el.addEventListener('mouseleave', this.mouseleaveFn);\n    this.DOM.el.addEventListener('mouseenter', this.mouseenterFn);\n  };\n\n  TiltFx.prototype._layout = function(ev) {\n    // Mouse position relative to the document.\n    var mousepos = getMousePos(ev),\n      // Document scrolls.\n      docScrolls = {left : document.body.scrollLeft + document.documentElement.scrollLeft, top : document.body.scrollTop + document.documentElement.scrollTop},\n      bounds = this.DOM.el.getBoundingClientRect(),\n      // Mouse position relative to the main element (this.DOM.el).\n      relmousepos = { x : mousepos.x - bounds.left - docScrolls.left, y : mousepos.y - bounds.top - docScrolls.top };\n\n    // Movement settings for the animatable elements.\n    for(var key in this.DOM.animatable) {\n      if( this.DOM.animatable[key] == undefined || this.options.movement[key] == undefined ) {\n        continue;\n      }\n      var t = this.options.movement[key] != undefined ? this.options.movement[key].translation || {x:0,y:0,z:0} : {x:0,y:0,z:0},\n        r = this.options.movement[key] != undefined ? this.options.movement[key].rotation || {x:0,y:0,z:0} : {x:0,y:0,z:0},\n        setRange = function (obj) {\n          for(var k in obj) {\n            if( obj[k] == undefined ) {\n              obj[k] = [0,0];\n            }\n            else if( typeof obj[k] === 'number' ) {\n              obj[k] = [-1*obj[k],obj[k]];\n            }\n          }\n        };\n\n      setRange(t);\n      setRange(r);\n\n      var transforms = {\n        translation : {\n          x: (t.x[1]-t.x[0])/bounds.width*relmousepos.x + t.x[0],\n          y: (t.y[1]-t.y[0])/bounds.height*relmousepos.y + t.y[0],\n          z: (t.z[1]-t.z[0])/bounds.height*relmousepos.y + t.z[0],\n        },\n        rotation : {\n          x: (r.x[1]-r.x[0])/bounds.height*relmousepos.y + r.x[0],\n          y: (r.y[1]-r.y[0])/bounds.width*relmousepos.x + r.y[0],\n          z: (r.z[1]-r.z[0])/bounds.width*relmousepos.x + r.z[0]\n        }\n      };\n\n      this.DOM.animatable[key].style.WebkitTransform = this.DOM.animatable[key].style.transform = 'translateX(' + transforms.translation.x + 'px) translateY(' + transforms.translation.y + 'px) translateZ(' + transforms.translation.z + 'px) rotateX(' + transforms.rotation.x + 'deg) rotateY(' + transforms.rotation.y + 'deg) rotateZ(' + transforms.rotation.z + 'deg)';\n    }\n  };\n\n  window.TiltFx = TiltFx;\n\n})(window);\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/packs/tilt.js","document.addEventListener('readystatechange', function(evt) {\n  if(evt.target.readyState == 'complete') {\n    updateBodyClass()\n    initEffects()\n  }\n})\n\nwindow.addEventListener('scroll', function(e) {\n  updateBodyClass()\n})\n\nfunction updateBodyClass() {\n  var body = document.body;\n  if ( window.scrollY >= 70 ) {\n    body.classList.add(\"scrolled\");\n  }\n  else {\n    body.classList.remove(\"scrolled\");\n  }\n}\n\nfunction initEffects() {\n  var triggers = document.getElementsByClassName('animate');\n\n  addEventListener('mousemove', this.mousemoveFn);\n\n  for (var i = 0; i < triggers.length; i++) {\n    triggers[i].addEventListener('mousemove', onMouseMove);\n    triggers[i].addEventListener('mouseleave', onMouseLeave);\n  }\n}\n\nfunction getMousePos(e) {\n  var posx = 0, posy = 0;\n  if (!e) var e = window.event;\n  if (e.pageX || e.pageY)   {\n    posx = e.pageX;\n    posy = e.pageY;\n  }\n  else if (e.clientX || e.clientY)  {\n    posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;\n    posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;\n  }\n  return { x : posx, y : posy }\n}\n\nvar transitions = [\n  {\n    translation : {x: 10, y: 10, z: 30},\n    rotation : {x: 10, y: -20, z: 0}\n  },\n  {\n    translation : {x: 10, y: 10, z: [0,-70]},\n    rotation : {x: 10, y: 20, z: -2}\n  },\n  {\n    translation : {x: 10, y: -10, z: -10},\n    rotation : {x: 10, y: 20, z: 2}\n  }\n]\n\nfunction onMouseMove(ev) {\n  var doms = ev.target.getElementsByClassName('animate-child')\n\n  for(var i = 0; i < doms.length; i++) {\n    var dom = doms[i];\n\n    var mousepos = getMousePos(ev),\n      docScrolls = {left : document.body.scrollLeft + document.documentElement.scrollLeft, top : document.body.scrollTop + document.documentElement.scrollTop},\n      bounds = dom.getBoundingClientRect(),\n      relmousepos = { x : mousepos.x - bounds.left - docScrolls.left, y : mousepos.y - bounds.top - docScrolls.top };\n\n    var transition = transitions[i]\n    var t = transition.translation\n        r = transition.rotation\n\n    var setRange = function (obj) {\n      for(var k in obj) {\n        if( obj[k] == undefined ) {\n          obj[k] = [0,0];\n        }\n        else if( typeof obj[k] === 'number' ) {\n          obj[k] = [-1*obj[k],obj[k]];\n        }\n      }\n    };\n\n    setRange(t);\n    setRange(r);\n\n    var transforms = {\n      translation : {\n        x: (t.x[1]-t.x[0])/bounds.width*relmousepos.x + t.x[0],\n        y: (t.y[1]-t.y[0])/bounds.height*relmousepos.y + t.y[0],\n        z: (t.z[1]-t.z[0])/bounds.height*relmousepos.y + t.z[0],\n      },\n      rotation : {\n        x: (r.x[1]-r.x[0])/bounds.height*relmousepos.y + r.x[0],\n        y: (r.y[1]-r.y[0])/bounds.width*relmousepos.x + r.y[0],\n        z: (r.z[1]-r.z[0])/bounds.width*relmousepos.x + r.z[0]\n      }\n    };\n\n    dom.style.WebkitTransform = dom.style.transform = 'translateX(' + transforms.translation.x + 'px) translateY(' + transforms.translation.y + 'px) translateZ(' + transforms.translation.z + 'px) rotateX(' + transforms.rotation.x + 'deg) rotateY(' + transforms.rotation.y + 'deg) rotateZ(' + transforms.rotation.z + 'deg)';\n  }\n}\n\nfunction onMouseLeave(ev) {\n  var doms = ev.target.getElementsByClassName('animate-child')\n\n  for(var i = 0; i < doms.length; i++) {\n    var dom = doms[i];\n\n    var transforms = {\n      translation : {\n        x: 0,\n        y: 0,\n        z: 0,\n      },\n      rotation : {\n        x: 0,\n        y: 0,\n        z: 0\n      }\n    };\n\n    dom.style.WebkitTransform = dom.style.transform = 'translateX(' + transforms.translation.x + 'px) translateY(' + transforms.translation.y + 'px) translateZ(' + transforms.translation.z + 'px) rotateX(' + transforms.rotation.x + 'deg) rotateY(' + transforms.rotation.y + 'deg) rotateZ(' + transforms.rotation.z + 'deg)';\n\n  }\n}\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/packs/effects.js","/* globals __webpack_amd_options__ */\r\nmodule.exports = __webpack_amd_options__;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/amd-options.js\n// module id = 11\n// module chunks = 0","/* eslint no-console:0 */\n// This file is automatically compiled by Webpack, along with any other files\n// present in this directory. You're encouraged to place your actual application logic in\n// a relevant structure within app/javascript and only use these pack files to reference\n// that code so it'll be compiled.\n//\n// To reference this file, add <%= javascript_pack_tag 'application' %> to the appropriate\n// layout file, like app/views/layouts/application.html.erb\n\nimport Vue from 'vue/dist/vue.esm'\nimport Parallax from 'vue-parallaxy'\nimport VideoBg from './videobg.vue'\nimport MoveTo from 'moveto'\nrequire('./top.js')\nrequire('./tilt.js')\nrequire('./effects.js')\nimport anime from 'animejs'\nimport ScrollReveal from 'scrollreveal'\n\nwindow.sr = ScrollReveal()\n\ndocument.addEventListener('readystatechange', function(evt) {\n  if(evt.target.readyState == 'complete') {\n    sr.reveal('.block-modal', {\n      reset: true\n    }, 500);\n  }\n})\n\nnew Vue({\n  el: '#tools',\n  components: {\n    Parallax\n  }\n})\n\nfunction findAncestor (el, cls) {\n  if(el.classList.contains(cls)) return el;\n  while ((el = el.parentElement) && !el.classList.contains(cls));\n  return el;\n}\n\nfunction hasClass(ele,cls) {\n  return ele.className.match(new RegExp('(\\\\s|^)'+cls+'(\\\\s|$)'));\n}\n\nnew Vue({\n  el: '#entry',\n  components: {\n    VideoBg\n  }\n})\n\nnew Vue({\n  el: '#oportunities',\n  data: {\n    active: null\n  },\n  methods: {\n    select: function(index) {\n      if(this.active == index)\n        this.active = null\n      else\n        this.active = index\n    }\n  }\n})\n\nnew Vue({\n  el: '#company',\n  data: {\n    active: -1,\n    title: '',\n    content: ''\n  },\n  methods: {\n    toggle: function(e) {\n      if(window.innerWidth < 767) return true;\n      var parent = findAncestor(e.target, 'block-modal')\n\n      var index = Array.prototype.slice.call(this.blocks).indexOf(parent)\n\n      this.active = index\n\n      if(!hasClass(this.modal, 'active')) {\n        this.modal.classList.add('active')\n      }\n    },\n    setBlock: function(block) {\n      this.title = getDescendantWithClass(block, 'title').innerText\n      this.content = getDescendantWithClass(block, 'content').innerText\n    },\n    close: function() {\n      this.modal.classList.remove('active')\n    },\n    next: function() {\n      if(this.active == this.blocks.length -1) {\n        this.active = 0\n      } else {\n        this.active = this.active + 1\n      }\n    },\n    previous: function() {\n      if(this.active == 0) {\n        this.active = this.blocks.length - 1\n      } else {\n        this.active = this.active - 1\n      }\n    }\n  },\n  watch: {\n    active: function() {\n      var block = this.blocks[this.active]\n      this.setBlock(block)\n    }\n  },\n  computed: {\n    modal: function() {\n      return document.getElementsByClassName('modal-info')[0];\n    },\n    blocks: function() {\n      return document.getElementsByClassName('block-modal')\n    }\n  },\n  mounted: function() {\n    this.modal.addEventListener('click', (event) => { event.stopPropagation(); })\n\n    Array.prototype.forEach.call(document.getElementsByClassName('block-modal'), (item) => {\n      item.addEventListener('click', (event) => { event.stopPropagation(); })\n    })\n\n    document.body.addEventListener('click', this.close)\n  }\n})\n\nconst easeFunctions = {\n  easeInQuad: function (t, b, c, d) {\n    t /= d;\n    return c * t * t + b;\n  },\n  easeOutQuad: function (t, b, c, d) {\n    t /= d;\n    return -c * t* (t - 2) + b;\n  }\n}\n\nconst moveTo = new MoveTo({\n  ease: 'easeInQuad',\n}, easeFunctions);\n\nconst triggers = document.getElementsByClassName('js-trigger');\n\nfor (var i = 0; i < triggers.length; i++) {\n  moveTo.registerTrigger(triggers[i]);\n}\n\nfunction getDescendantWithClass(element, clName) {\n  var children = element.childNodes;\n  for (var i = 0; i < children.length; i++) {\n      if (children[i].className &&\n          children[i].className.split(' ').indexOf(clName) >= 0) {\n          return children[i];\n       }\n   }\n   for (var i = 0; i < children.length; i++) {\n       var match = getDescendantWithClass(children[i], clName);\n       if (match !== null) {\n           return match;\n       }\n   }\n   return null;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./app/javascript/packs/application.js","!function(t,e){\"object\"==typeof exports&&\"object\"==typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(\"VueParallaxy\",[],e):\"object\"==typeof exports?exports.VueParallaxy=e():t.VueParallaxy=e()}(this,function(){return function(t){function e(n){if(r[n])return r[n].exports;var i=r[n]={exports:{},id:n,loaded:!1};return t[n].call(i.exports,i,i.exports,e),i.loaded=!0,i.exports}var r={};return e.m=t,e.c=r,e.p=\"\",e(0)}([function(t,e,r){\"use strict\";function n(t){return t&&t.__esModule?t:{default:t}}var i=r(8),o=n(i);t.exports=o.default},function(t,e){\"use strict\";Object.defineProperty(e,\"__esModule\",{value:!0}),e.default={props:{parallax:{default:!0,type:Boolean},speedFactor:{default:.15,type:Number},fixed:{default:!1,type:Boolean},breakpoint:{default:\"(min-width: 968px)\",type:String},sectionHeight:{default:70,type:Number,required:!1},sectionClass:{type:String,default:\"Masthead\"},containerClass:{type:String,default:\"Masthead__image\"},parallaxClass:{type:String,default:\"is-parallax\"},fixedClass:{type:String,default:\"is-fixed\"}},data:function(){return{el:null,mediaQuery:null}},mounted:function(){this.parallax&&!this.fixed&&(this.el=this.$refs.parallax,window.requestAnimationFrame=window.requestAnimationFrame||window.mozRequestAnimationFrame||window.webkitRequestAnimationFrame||window.msRequestAnimationFrame||function(t){setTimeout(t,1e3/60)},this.init())},methods:{animateElement:function(){var t=this.$refs.block.offsetHeight,e=this.$refs.parallax.offsetHeight,r=e-t,n=window.pageYOffset*this.speedFactor;n<=r&&n>=0&&(this.el.style.transform=\"translate3d(0, \"+n*-1+\"px ,0)\")},scrollHandler:function(){var t=this;window.requestAnimationFrame(function(){t.isInView(t.$refs.parallax)&&t.animateElement()})},isInView:function(t){var e=t.getBoundingClientRect();return e.bottom>=0&&e.top<=(window.innerHeight||document.documentElement.clientHeight)},setupListener:function(){this.mediaQuery.matches?window.addEventListener(\"scroll\",this.scrollHandler,!1):window.removeEventListener(\"scroll\",this.scrollHandler,!1)},init:function(){this.mediaQuery=window.matchMedia(this.breakpoint),this.mediaQuery&&(this.mediaQuery.addListener(this.setupListener),this.setupListener())}}}},function(t,e){\"use strict\";function r(t){var e=t.length;if(e%4>0)throw new Error(\"Invalid string. Length must be a multiple of 4\");return\"=\"===t[e-2]?2:\"=\"===t[e-1]?1:0}function n(t){return 3*t.length/4-r(t)}function i(t){var e,n,i,o,a,s,u=t.length;a=r(t),s=new h(3*u/4-a),i=a>0?u-4:u;var c=0;for(e=0,n=0;e<i;e+=4,n+=3)o=f[t.charCodeAt(e)]<<18|f[t.charCodeAt(e+1)]<<12|f[t.charCodeAt(e+2)]<<6|f[t.charCodeAt(e+3)],s[c++]=o>>16&255,s[c++]=o>>8&255,s[c++]=255&o;return 2===a?(o=f[t.charCodeAt(e)]<<2|f[t.charCodeAt(e+1)]>>4,s[c++]=255&o):1===a&&(o=f[t.charCodeAt(e)]<<10|f[t.charCodeAt(e+1)]<<4|f[t.charCodeAt(e+2)]>>2,s[c++]=o>>8&255,s[c++]=255&o),s}function o(t){return u[t>>18&63]+u[t>>12&63]+u[t>>6&63]+u[63&t]}function a(t,e,r){for(var n,i=[],a=e;a<r;a+=3)n=(t[a]<<16)+(t[a+1]<<8)+t[a+2],i.push(o(n));return i.join(\"\")}function s(t){for(var e,r=t.length,n=r%3,i=\"\",o=[],s=16383,f=0,h=r-n;f<h;f+=s)o.push(a(t,f,f+s>h?h:f+s));return 1===n?(e=t[r-1],i+=u[e>>2],i+=u[e<<4&63],i+=\"==\"):2===n&&(e=(t[r-2]<<8)+t[r-1],i+=u[e>>10],i+=u[e>>4&63],i+=u[e<<2&63],i+=\"=\"),o.push(i),o.join(\"\")}e.byteLength=n,e.toByteArray=i,e.fromByteArray=s;for(var u=[],f=[],h=\"undefined\"!=typeof Uint8Array?Uint8Array:Array,c=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\",l=0,p=c.length;l<p;++l)u[l]=c[l],f[c.charCodeAt(l)]=l;f[\"-\".charCodeAt(0)]=62,f[\"_\".charCodeAt(0)]=63},function(t,e,r){(function(t){/*!\n\t * The buffer module from node.js, for the browser.\n\t *\n\t * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n\t * @license  MIT\n\t */\n\"use strict\";function n(){try{var t=new Uint8Array(1);return t.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===t.foo()&&\"function\"==typeof t.subarray&&0===t.subarray(1,1).byteLength}catch(t){return!1}}function i(){return a.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function o(t,e){if(i()<e)throw new RangeError(\"Invalid typed array length\");return a.TYPED_ARRAY_SUPPORT?(t=new Uint8Array(e),t.__proto__=a.prototype):(null===t&&(t=new a(e)),t.length=e),t}function a(t,e,r){if(!(a.TYPED_ARRAY_SUPPORT||this instanceof a))return new a(t,e,r);if(\"number\"==typeof t){if(\"string\"==typeof e)throw new Error(\"If encoding is specified then the first argument must be a string\");return h(this,t)}return s(this,t,e,r)}function s(t,e,r,n){if(\"number\"==typeof e)throw new TypeError('\"value\" argument must not be a number');return\"undefined\"!=typeof ArrayBuffer&&e instanceof ArrayBuffer?p(t,e,r,n):\"string\"==typeof e?c(t,e,r):d(t,e)}function u(t){if(\"number\"!=typeof t)throw new TypeError('\"size\" argument must be a number');if(t<0)throw new RangeError('\"size\" argument must not be negative')}function f(t,e,r,n){return u(e),e<=0?o(t,e):void 0!==r?\"string\"==typeof n?o(t,e).fill(r,n):o(t,e).fill(r):o(t,e)}function h(t,e){if(u(e),t=o(t,e<0?0:0|g(e)),!a.TYPED_ARRAY_SUPPORT)for(var r=0;r<e;++r)t[r]=0;return t}function c(t,e,r){if(\"string\"==typeof r&&\"\"!==r||(r=\"utf8\"),!a.isEncoding(r))throw new TypeError('\"encoding\" must be a valid string encoding');var n=0|A(e,r);t=o(t,n);var i=t.write(e,r);return i!==n&&(t=t.slice(0,i)),t}function l(t,e){var r=e.length<0?0:0|g(e.length);t=o(t,r);for(var n=0;n<r;n+=1)t[n]=255&e[n];return t}function p(t,e,r,n){if(e.byteLength,r<0||e.byteLength<r)throw new RangeError(\"'offset' is out of bounds\");if(e.byteLength<r+(n||0))throw new RangeError(\"'length' is out of bounds\");return e=void 0===r&&void 0===n?new Uint8Array(e):void 0===n?new Uint8Array(e,r):new Uint8Array(e,r,n),a.TYPED_ARRAY_SUPPORT?(t=e,t.__proto__=a.prototype):t=l(t,e),t}function d(t,e){if(a.isBuffer(e)){var r=0|g(e.length);return t=o(t,r),0===t.length?t:(e.copy(t,0,0,r),t)}if(e){if(\"undefined\"!=typeof ArrayBuffer&&e.buffer instanceof ArrayBuffer||\"length\"in e)return\"number\"!=typeof e.length||K(e.length)?o(t,0):l(t,e);if(\"Buffer\"===e.type&&Z(e.data))return l(t,e.data)}throw new TypeError(\"First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.\")}function g(t){if(t>=i())throw new RangeError(\"Attempt to allocate Buffer larger than maximum size: 0x\"+i().toString(16)+\" bytes\");return 0|t}function y(t){return+t!=t&&(t=0),a.alloc(+t)}function A(t,e){if(a.isBuffer(t))return t.length;if(\"undefined\"!=typeof ArrayBuffer&&\"function\"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(t)||t instanceof ArrayBuffer))return t.byteLength;\"string\"!=typeof t&&(t=\"\"+t);var r=t.length;if(0===r)return 0;for(var n=!1;;)switch(e){case\"ascii\":case\"latin1\":case\"binary\":return r;case\"utf8\":case\"utf-8\":case void 0:return W(t).length;case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return 2*r;case\"hex\":return r>>>1;case\"base64\":return $(t).length;default:if(n)return W(t).length;e=(\"\"+e).toLowerCase(),n=!0}}function m(t,e,r){var n=!1;if((void 0===e||e<0)&&(e=0),e>this.length)return\"\";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return\"\";if(r>>>=0,e>>>=0,r<=e)return\"\";for(t||(t=\"utf8\");;)switch(t){case\"hex\":return Y(this,e,r);case\"utf8\":case\"utf-8\":return T(this,e,r);case\"ascii\":return S(this,e,r);case\"latin1\":case\"binary\":return M(this,e,r);case\"base64\":return P(this,e,r);case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return j(this,e,r);default:if(n)throw new TypeError(\"Unknown encoding: \"+t);t=(t+\"\").toLowerCase(),n=!0}}function v(t,e,r){var n=t[e];t[e]=t[r],t[r]=n}function w(t,e,r,n,i){if(0===t.length)return-1;if(\"string\"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=i?0:t.length-1),r<0&&(r=t.length+r),r>=t.length){if(i)return-1;r=t.length-1}else if(r<0){if(!i)return-1;r=0}if(\"string\"==typeof e&&(e=a.from(e,n)),a.isBuffer(e))return 0===e.length?-1:b(t,e,r,n,i);if(\"number\"==typeof e)return e&=255,a.TYPED_ARRAY_SUPPORT&&\"function\"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(t,e,r):Uint8Array.prototype.lastIndexOf.call(t,e,r):b(t,[e],r,n,i);throw new TypeError(\"val must be string, number or Buffer\")}function b(t,e,r,n,i){function o(t,e){return 1===a?t[e]:t.readUInt16BE(e*a)}var a=1,s=t.length,u=e.length;if(void 0!==n&&(n=String(n).toLowerCase(),\"ucs2\"===n||\"ucs-2\"===n||\"utf16le\"===n||\"utf-16le\"===n)){if(t.length<2||e.length<2)return-1;a=2,s/=2,u/=2,r/=2}var f;if(i){var h=-1;for(f=r;f<s;f++)if(o(t,f)===o(e,h===-1?0:f-h)){if(h===-1&&(h=f),f-h+1===u)return h*a}else h!==-1&&(f-=f-h),h=-1}else for(r+u>s&&(r=s-u),f=r;f>=0;f--){for(var c=!0,l=0;l<u;l++)if(o(t,f+l)!==o(e,l)){c=!1;break}if(c)return f}return-1}function _(t,e,r,n){r=Number(r)||0;var i=t.length-r;n?(n=Number(n),n>i&&(n=i)):n=i;var o=e.length;if(o%2!==0)throw new TypeError(\"Invalid hex string\");n>o/2&&(n=o/2);for(var a=0;a<n;++a){var s=parseInt(e.substr(2*a,2),16);if(isNaN(s))return a;t[r+a]=s}return a}function B(t,e,r,n){return J(W(e,t.length-r),t,r,n)}function E(t,e,r,n){return J(Q(e),t,r,n)}function R(t,e,r,n){return E(t,e,r,n)}function x(t,e,r,n){return J($(e),t,r,n)}function C(t,e,r,n){return J(V(e,t.length-r),t,r,n)}function P(t,e,r){return 0===e&&r===t.length?X.fromByteArray(t):X.fromByteArray(t.slice(e,r))}function T(t,e,r){r=Math.min(t.length,r);for(var n=[],i=e;i<r;){var o=t[i],a=null,s=o>239?4:o>223?3:o>191?2:1;if(i+s<=r){var u,f,h,c;switch(s){case 1:o<128&&(a=o);break;case 2:u=t[i+1],128===(192&u)&&(c=(31&o)<<6|63&u,c>127&&(a=c));break;case 3:u=t[i+1],f=t[i+2],128===(192&u)&&128===(192&f)&&(c=(15&o)<<12|(63&u)<<6|63&f,c>2047&&(c<55296||c>57343)&&(a=c));break;case 4:u=t[i+1],f=t[i+2],h=t[i+3],128===(192&u)&&128===(192&f)&&128===(192&h)&&(c=(15&o)<<18|(63&u)<<12|(63&f)<<6|63&h,c>65535&&c<1114112&&(a=c))}}null===a?(a=65533,s=1):a>65535&&(a-=65536,n.push(a>>>10&1023|55296),a=56320|1023&a),n.push(a),i+=s}return U(n)}function U(t){var e=t.length;if(e<=tt)return String.fromCharCode.apply(String,t);for(var r=\"\",n=0;n<e;)r+=String.fromCharCode.apply(String,t.slice(n,n+=tt));return r}function S(t,e,r){var n=\"\";r=Math.min(t.length,r);for(var i=e;i<r;++i)n+=String.fromCharCode(127&t[i]);return n}function M(t,e,r){var n=\"\";r=Math.min(t.length,r);for(var i=e;i<r;++i)n+=String.fromCharCode(t[i]);return n}function Y(t,e,r){var n=t.length;(!e||e<0)&&(e=0),(!r||r<0||r>n)&&(r=n);for(var i=\"\",o=e;o<r;++o)i+=H(t[o]);return i}function j(t,e,r){for(var n=t.slice(e,r),i=\"\",o=0;o<n.length;o+=2)i+=String.fromCharCode(n[o]+256*n[o+1]);return i}function I(t,e,r){if(t%1!==0||t<0)throw new RangeError(\"offset is not uint\");if(t+e>r)throw new RangeError(\"Trying to access beyond buffer length\")}function L(t,e,r,n,i,o){if(!a.isBuffer(t))throw new TypeError('\"buffer\" argument must be a Buffer instance');if(e>i||e<o)throw new RangeError('\"value\" argument is out of bounds');if(r+n>t.length)throw new RangeError(\"Index out of range\")}function D(t,e,r,n){e<0&&(e=65535+e+1);for(var i=0,o=Math.min(t.length-r,2);i<o;++i)t[r+i]=(e&255<<8*(n?i:1-i))>>>8*(n?i:1-i)}function O(t,e,r,n){e<0&&(e=4294967295+e+1);for(var i=0,o=Math.min(t.length-r,4);i<o;++i)t[r+i]=e>>>8*(n?i:3-i)&255}function k(t,e,r,n,i,o){if(r+n>t.length)throw new RangeError(\"Index out of range\");if(r<0)throw new RangeError(\"Index out of range\")}function N(t,e,r,n,i){return i||k(t,e,r,4,3.4028234663852886e38,-3.4028234663852886e38),G.write(t,e,r,n,23,4),r+4}function F(t,e,r,n,i){return i||k(t,e,r,8,1.7976931348623157e308,-1.7976931348623157e308),G.write(t,e,r,n,52,8),r+8}function z(t){if(t=q(t).replace(et,\"\"),t.length<2)return\"\";for(;t.length%4!==0;)t+=\"=\";return t}function q(t){return t.trim?t.trim():t.replace(/^\\s+|\\s+$/g,\"\")}function H(t){return t<16?\"0\"+t.toString(16):t.toString(16)}function W(t,e){e=e||1/0;for(var r,n=t.length,i=null,o=[],a=0;a<n;++a){if(r=t.charCodeAt(a),r>55295&&r<57344){if(!i){if(r>56319){(e-=3)>-1&&o.push(239,191,189);continue}if(a+1===n){(e-=3)>-1&&o.push(239,191,189);continue}i=r;continue}if(r<56320){(e-=3)>-1&&o.push(239,191,189),i=r;continue}r=(i-55296<<10|r-56320)+65536}else i&&(e-=3)>-1&&o.push(239,191,189);if(i=null,r<128){if((e-=1)<0)break;o.push(r)}else if(r<2048){if((e-=2)<0)break;o.push(r>>6|192,63&r|128)}else if(r<65536){if((e-=3)<0)break;o.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error(\"Invalid code point\");if((e-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return o}function Q(t){for(var e=[],r=0;r<t.length;++r)e.push(255&t.charCodeAt(r));return e}function V(t,e){for(var r,n,i,o=[],a=0;a<t.length&&!((e-=2)<0);++a)r=t.charCodeAt(a),n=r>>8,i=r%256,o.push(i),o.push(n);return o}function $(t){return X.toByteArray(z(t))}function J(t,e,r,n){for(var i=0;i<n&&!(i+r>=e.length||i>=t.length);++i)e[i+r]=t[i];return i}function K(t){return t!==t}var X=r(2),G=r(6),Z=r(7);e.Buffer=a,e.SlowBuffer=y,e.INSPECT_MAX_BYTES=50,a.TYPED_ARRAY_SUPPORT=void 0!==t.TYPED_ARRAY_SUPPORT?t.TYPED_ARRAY_SUPPORT:n(),e.kMaxLength=i(),a.poolSize=8192,a._augment=function(t){return t.__proto__=a.prototype,t},a.from=function(t,e,r){return s(null,t,e,r)},a.TYPED_ARRAY_SUPPORT&&(a.prototype.__proto__=Uint8Array.prototype,a.__proto__=Uint8Array,\"undefined\"!=typeof Symbol&&Symbol.species&&a[Symbol.species]===a&&Object.defineProperty(a,Symbol.species,{value:null,configurable:!0})),a.alloc=function(t,e,r){return f(null,t,e,r)},a.allocUnsafe=function(t){return h(null,t)},a.allocUnsafeSlow=function(t){return h(null,t)},a.isBuffer=function(t){return!(null==t||!t._isBuffer)},a.compare=function(t,e){if(!a.isBuffer(t)||!a.isBuffer(e))throw new TypeError(\"Arguments must be Buffers\");if(t===e)return 0;for(var r=t.length,n=e.length,i=0,o=Math.min(r,n);i<o;++i)if(t[i]!==e[i]){r=t[i],n=e[i];break}return r<n?-1:n<r?1:0},a.isEncoding=function(t){switch(String(t).toLowerCase()){case\"hex\":case\"utf8\":case\"utf-8\":case\"ascii\":case\"latin1\":case\"binary\":case\"base64\":case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return!0;default:return!1}},a.concat=function(t,e){if(!Z(t))throw new TypeError('\"list\" argument must be an Array of Buffers');if(0===t.length)return a.alloc(0);var r;if(void 0===e)for(e=0,r=0;r<t.length;++r)e+=t[r].length;var n=a.allocUnsafe(e),i=0;for(r=0;r<t.length;++r){var o=t[r];if(!a.isBuffer(o))throw new TypeError('\"list\" argument must be an Array of Buffers');o.copy(n,i),i+=o.length}return n},a.byteLength=A,a.prototype._isBuffer=!0,a.prototype.swap16=function(){var t=this.length;if(t%2!==0)throw new RangeError(\"Buffer size must be a multiple of 16-bits\");for(var e=0;e<t;e+=2)v(this,e,e+1);return this},a.prototype.swap32=function(){var t=this.length;if(t%4!==0)throw new RangeError(\"Buffer size must be a multiple of 32-bits\");for(var e=0;e<t;e+=4)v(this,e,e+3),v(this,e+1,e+2);return this},a.prototype.swap64=function(){var t=this.length;if(t%8!==0)throw new RangeError(\"Buffer size must be a multiple of 64-bits\");for(var e=0;e<t;e+=8)v(this,e,e+7),v(this,e+1,e+6),v(this,e+2,e+5),v(this,e+3,e+4);return this},a.prototype.toString=function(){var t=0|this.length;return 0===t?\"\":0===arguments.length?T(this,0,t):m.apply(this,arguments)},a.prototype.equals=function(t){if(!a.isBuffer(t))throw new TypeError(\"Argument must be a Buffer\");return this===t||0===a.compare(this,t)},a.prototype.inspect=function(){var t=\"\",r=e.INSPECT_MAX_BYTES;return this.length>0&&(t=this.toString(\"hex\",0,r).match(/.{2}/g).join(\" \"),this.length>r&&(t+=\" ... \")),\"<Buffer \"+t+\">\"},a.prototype.compare=function(t,e,r,n,i){if(!a.isBuffer(t))throw new TypeError(\"Argument must be a Buffer\");if(void 0===e&&(e=0),void 0===r&&(r=t?t.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),e<0||r>t.length||n<0||i>this.length)throw new RangeError(\"out of range index\");if(n>=i&&e>=r)return 0;if(n>=i)return-1;if(e>=r)return 1;if(e>>>=0,r>>>=0,n>>>=0,i>>>=0,this===t)return 0;for(var o=i-n,s=r-e,u=Math.min(o,s),f=this.slice(n,i),h=t.slice(e,r),c=0;c<u;++c)if(f[c]!==h[c]){o=f[c],s=h[c];break}return o<s?-1:s<o?1:0},a.prototype.includes=function(t,e,r){return this.indexOf(t,e,r)!==-1},a.prototype.indexOf=function(t,e,r){return w(this,t,e,r,!0)},a.prototype.lastIndexOf=function(t,e,r){return w(this,t,e,r,!1)},a.prototype.write=function(t,e,r,n){if(void 0===e)n=\"utf8\",r=this.length,e=0;else if(void 0===r&&\"string\"==typeof e)n=e,r=this.length,e=0;else{if(!isFinite(e))throw new Error(\"Buffer.write(string, encoding, offset[, length]) is no longer supported\");e|=0,isFinite(r)?(r|=0,void 0===n&&(n=\"utf8\")):(n=r,r=void 0)}var i=this.length-e;if((void 0===r||r>i)&&(r=i),t.length>0&&(r<0||e<0)||e>this.length)throw new RangeError(\"Attempt to write outside buffer bounds\");n||(n=\"utf8\");for(var o=!1;;)switch(n){case\"hex\":return _(this,t,e,r);case\"utf8\":case\"utf-8\":return B(this,t,e,r);case\"ascii\":return E(this,t,e,r);case\"latin1\":case\"binary\":return R(this,t,e,r);case\"base64\":return x(this,t,e,r);case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return C(this,t,e,r);default:if(o)throw new TypeError(\"Unknown encoding: \"+n);n=(\"\"+n).toLowerCase(),o=!0}},a.prototype.toJSON=function(){return{type:\"Buffer\",data:Array.prototype.slice.call(this._arr||this,0)}};var tt=4096;a.prototype.slice=function(t,e){var r=this.length;t=~~t,e=void 0===e?r:~~e,t<0?(t+=r,t<0&&(t=0)):t>r&&(t=r),e<0?(e+=r,e<0&&(e=0)):e>r&&(e=r),e<t&&(e=t);var n;if(a.TYPED_ARRAY_SUPPORT)n=this.subarray(t,e),n.__proto__=a.prototype;else{var i=e-t;n=new a(i,void 0);for(var o=0;o<i;++o)n[o]=this[o+t]}return n},a.prototype.readUIntLE=function(t,e,r){t|=0,e|=0,r||I(t,e,this.length);for(var n=this[t],i=1,o=0;++o<e&&(i*=256);)n+=this[t+o]*i;return n},a.prototype.readUIntBE=function(t,e,r){t|=0,e|=0,r||I(t,e,this.length);for(var n=this[t+--e],i=1;e>0&&(i*=256);)n+=this[t+--e]*i;return n},a.prototype.readUInt8=function(t,e){return e||I(t,1,this.length),this[t]},a.prototype.readUInt16LE=function(t,e){return e||I(t,2,this.length),this[t]|this[t+1]<<8},a.prototype.readUInt16BE=function(t,e){return e||I(t,2,this.length),this[t]<<8|this[t+1]},a.prototype.readUInt32LE=function(t,e){return e||I(t,4,this.length),(this[t]|this[t+1]<<8|this[t+2]<<16)+16777216*this[t+3]},a.prototype.readUInt32BE=function(t,e){return e||I(t,4,this.length),16777216*this[t]+(this[t+1]<<16|this[t+2]<<8|this[t+3])},a.prototype.readIntLE=function(t,e,r){t|=0,e|=0,r||I(t,e,this.length);for(var n=this[t],i=1,o=0;++o<e&&(i*=256);)n+=this[t+o]*i;return i*=128,n>=i&&(n-=Math.pow(2,8*e)),n},a.prototype.readIntBE=function(t,e,r){t|=0,e|=0,r||I(t,e,this.length);for(var n=e,i=1,o=this[t+--n];n>0&&(i*=256);)o+=this[t+--n]*i;return i*=128,o>=i&&(o-=Math.pow(2,8*e)),o},a.prototype.readInt8=function(t,e){return e||I(t,1,this.length),128&this[t]?(255-this[t]+1)*-1:this[t]},a.prototype.readInt16LE=function(t,e){e||I(t,2,this.length);var r=this[t]|this[t+1]<<8;return 32768&r?4294901760|r:r},a.prototype.readInt16BE=function(t,e){e||I(t,2,this.length);var r=this[t+1]|this[t]<<8;return 32768&r?4294901760|r:r},a.prototype.readInt32LE=function(t,e){return e||I(t,4,this.length),this[t]|this[t+1]<<8|this[t+2]<<16|this[t+3]<<24},a.prototype.readInt32BE=function(t,e){return e||I(t,4,this.length),this[t]<<24|this[t+1]<<16|this[t+2]<<8|this[t+3]},a.prototype.readFloatLE=function(t,e){return e||I(t,4,this.length),G.read(this,t,!0,23,4)},a.prototype.readFloatBE=function(t,e){return e||I(t,4,this.length),G.read(this,t,!1,23,4)},a.prototype.readDoubleLE=function(t,e){return e||I(t,8,this.length),G.read(this,t,!0,52,8)},a.prototype.readDoubleBE=function(t,e){return e||I(t,8,this.length),G.read(this,t,!1,52,8)},a.prototype.writeUIntLE=function(t,e,r,n){if(t=+t,e|=0,r|=0,!n){var i=Math.pow(2,8*r)-1;L(this,t,e,r,i,0)}var o=1,a=0;for(this[e]=255&t;++a<r&&(o*=256);)this[e+a]=t/o&255;return e+r},a.prototype.writeUIntBE=function(t,e,r,n){if(t=+t,e|=0,r|=0,!n){var i=Math.pow(2,8*r)-1;L(this,t,e,r,i,0)}var o=r-1,a=1;for(this[e+o]=255&t;--o>=0&&(a*=256);)this[e+o]=t/a&255;return e+r},a.prototype.writeUInt8=function(t,e,r){return t=+t,e|=0,r||L(this,t,e,1,255,0),a.TYPED_ARRAY_SUPPORT||(t=Math.floor(t)),this[e]=255&t,e+1},a.prototype.writeUInt16LE=function(t,e,r){return t=+t,e|=0,r||L(this,t,e,2,65535,0),a.TYPED_ARRAY_SUPPORT?(this[e]=255&t,this[e+1]=t>>>8):D(this,t,e,!0),e+2},a.prototype.writeUInt16BE=function(t,e,r){return t=+t,e|=0,r||L(this,t,e,2,65535,0),a.TYPED_ARRAY_SUPPORT?(this[e]=t>>>8,this[e+1]=255&t):D(this,t,e,!1),e+2},a.prototype.writeUInt32LE=function(t,e,r){return t=+t,e|=0,r||L(this,t,e,4,4294967295,0),a.TYPED_ARRAY_SUPPORT?(this[e+3]=t>>>24,this[e+2]=t>>>16,this[e+1]=t>>>8,this[e]=255&t):O(this,t,e,!0),e+4},a.prototype.writeUInt32BE=function(t,e,r){return t=+t,e|=0,r||L(this,t,e,4,4294967295,0),a.TYPED_ARRAY_SUPPORT?(this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t):O(this,t,e,!1),e+4},a.prototype.writeIntLE=function(t,e,r,n){if(t=+t,e|=0,!n){var i=Math.pow(2,8*r-1);L(this,t,e,r,i-1,-i)}var o=0,a=1,s=0;for(this[e]=255&t;++o<r&&(a*=256);)t<0&&0===s&&0!==this[e+o-1]&&(s=1),this[e+o]=(t/a>>0)-s&255;return e+r},a.prototype.writeIntBE=function(t,e,r,n){if(t=+t,e|=0,!n){var i=Math.pow(2,8*r-1);L(this,t,e,r,i-1,-i)}var o=r-1,a=1,s=0;for(this[e+o]=255&t;--o>=0&&(a*=256);)t<0&&0===s&&0!==this[e+o+1]&&(s=1),this[e+o]=(t/a>>0)-s&255;return e+r},a.prototype.writeInt8=function(t,e,r){return t=+t,e|=0,r||L(this,t,e,1,127,-128),a.TYPED_ARRAY_SUPPORT||(t=Math.floor(t)),t<0&&(t=255+t+1),this[e]=255&t,e+1},a.prototype.writeInt16LE=function(t,e,r){return t=+t,e|=0,r||L(this,t,e,2,32767,-32768),a.TYPED_ARRAY_SUPPORT?(this[e]=255&t,this[e+1]=t>>>8):D(this,t,e,!0),e+2},a.prototype.writeInt16BE=function(t,e,r){return t=+t,e|=0,r||L(this,t,e,2,32767,-32768),a.TYPED_ARRAY_SUPPORT?(this[e]=t>>>8,this[e+1]=255&t):D(this,t,e,!1),e+2},a.prototype.writeInt32LE=function(t,e,r){return t=+t,e|=0,r||L(this,t,e,4,2147483647,-2147483648),a.TYPED_ARRAY_SUPPORT?(this[e]=255&t,this[e+1]=t>>>8,this[e+2]=t>>>16,this[e+3]=t>>>24):O(this,t,e,!0),e+4},a.prototype.writeInt32BE=function(t,e,r){return t=+t,e|=0,r||L(this,t,e,4,2147483647,-2147483648),t<0&&(t=4294967295+t+1),a.TYPED_ARRAY_SUPPORT?(this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t):O(this,t,e,!1),e+4},a.prototype.writeFloatLE=function(t,e,r){return N(this,t,e,!0,r)},a.prototype.writeFloatBE=function(t,e,r){return N(this,t,e,!1,r)},a.prototype.writeDoubleLE=function(t,e,r){return F(this,t,e,!0,r)},a.prototype.writeDoubleBE=function(t,e,r){return F(this,t,e,!1,r)},a.prototype.copy=function(t,e,r,n){if(r||(r=0),n||0===n||(n=this.length),e>=t.length&&(e=t.length),e||(e=0),n>0&&n<r&&(n=r),n===r)return 0;if(0===t.length||0===this.length)return 0;if(e<0)throw new RangeError(\"targetStart out of bounds\");if(r<0||r>=this.length)throw new RangeError(\"sourceStart out of bounds\");if(n<0)throw new RangeError(\"sourceEnd out of bounds\");n>this.length&&(n=this.length),t.length-e<n-r&&(n=t.length-e+r);var i,o=n-r;if(this===t&&r<e&&e<n)for(i=o-1;i>=0;--i)t[i+e]=this[i+r];else if(o<1e3||!a.TYPED_ARRAY_SUPPORT)for(i=0;i<o;++i)t[i+e]=this[i+r];else Uint8Array.prototype.set.call(t,this.subarray(r,r+o),e);return o},a.prototype.fill=function(t,e,r,n){if(\"string\"==typeof t){if(\"string\"==typeof e?(n=e,e=0,r=this.length):\"string\"==typeof r&&(n=r,r=this.length),1===t.length){var i=t.charCodeAt(0);i<256&&(t=i)}if(void 0!==n&&\"string\"!=typeof n)throw new TypeError(\"encoding must be a string\");if(\"string\"==typeof n&&!a.isEncoding(n))throw new TypeError(\"Unknown encoding: \"+n)}else\"number\"==typeof t&&(t&=255);if(e<0||this.length<e||this.length<r)throw new RangeError(\"Out of range index\");if(r<=e)return this;e>>>=0,r=void 0===r?this.length:r>>>0,t||(t=0);var o;if(\"number\"==typeof t)for(o=e;o<r;++o)this[o]=t;else{var s=a.isBuffer(t)?t:W(new a(t,n).toString()),u=s.length;for(o=0;o<r-e;++o)this[o+e]=s[o%u]}return this};var et=/[^+\\/0-9A-Za-z-_]/g}).call(e,function(){return this}())},function(t,e,r){e=t.exports=r(5)(!0),e.push([t.id,'.Masthead{position:relative;min-height:21.875rem;scroll-behavior:smooth;overflow:hidden;z-index:-1}@media screen and (min-width:768px){.Masthead{min-height:100vh}}.Masthead__image{width:100%;overflow:hidden;height:120%}.Masthead__image>img{height:100%;max-width:none;width:100%;-o-object-fit:cover;object-fit:cover;-o-object-position:bottom;object-position:bottom;font-family:\"object-fit: cover; object-position: bottom\"}.Masthead__image.is-parallax{left:0;position:absolute;will-change:transform;right:0;top:0}.Masthead__image.is-parallax>img{height:100%;max-width:none;width:100%;-o-object-fit:cover;object-fit:cover;-o-object-position:bottom;object-position:bottom;font-family:\"object-fit: cover; object-position: bottom\"}.Masthead__image.is-fixed{position:fixed}.Masthead__image.is-fixed>img{height:100vh;max-width:none}',\"\",{version:3,sources:[\"/Users/jjuszczak/Projekte/Privat/vue-parallax/src/components/Parallax.vue\"],names:[],mappings:\"AACA,UAAU,kBAAkB,qBAAqB,uBAAuB,gBAAgB,UAAU,CACjG,AACD,oCACA,UAAU,gBAAgB,CACzB,CACA,AACD,iBAAiB,WAAW,gBAAgB,WAAW,CACtD,AACD,qBAAqB,YAAY,eAAe,WAAW,oBAAoB,iBAAiB,0BAA0B,uBAAuB,wDAAwD,CACxM,AACD,6BAA6B,OAAO,kBAAkB,sBAAsB,QAAQ,KAAK,CACxF,AACD,iCAAiC,YAAY,eAAe,WAAW,oBAAoB,iBAAiB,0BAA0B,uBAAuB,wDAAwD,CACpN,AACD,0BAA0B,cAAc,CACvC,AACD,8BAA8B,aAAa,cAAc,CACxD\",file:\"Parallax.vue\",sourcesContent:['\\n.Masthead{position:relative;min-height:21.875rem;scroll-behavior:smooth;overflow:hidden;z-index:-1\\n}\\n@media screen and (min-width: 768px){\\n.Masthead{min-height:100vh\\n}\\n}\\n.Masthead__image{width:100%;overflow:hidden;height:120%\\n}\\n.Masthead__image>img{height:100%;max-width:none;width:100%;-o-object-fit:cover;object-fit:cover;-o-object-position:bottom;object-position:bottom;font-family:\"object-fit: cover; object-position: bottom\"\\n}\\n.Masthead__image.is-parallax{left:0;position:absolute;will-change:transform;right:0;top:0\\n}\\n.Masthead__image.is-parallax>img{height:100%;max-width:none;width:100%;-o-object-fit:cover;object-fit:cover;-o-object-position:bottom;object-position:bottom;font-family:\"object-fit: cover; object-position: bottom\"\\n}\\n.Masthead__image.is-fixed{position:fixed\\n}\\n.Masthead__image.is-fixed>img{height:100vh;max-width:none\\n}\\n'],sourceRoot:\"\"}])},function(t,e,r){(function(e){function r(t,e){var r=t[1]||\"\",i=t[3];if(!i)return r;if(e){var o=n(i),a=i.sources.map(function(t){return\"/*# sourceURL=\"+i.sourceRoot+t+\" */\"});return[r].concat(a).concat([o]).join(\"\\n\")}return[r].join(\"\\n\")}function n(t){var r=new e(JSON.stringify(t)).toString(\"base64\"),n=\"sourceMappingURL=data:application/json;charset=utf-8;base64,\"+r;return\"/*# \"+n+\" */\"}t.exports=function(t){var e=[];return e.toString=function(){return this.map(function(e){var n=r(e,t);return e[2]?\"@media \"+e[2]+\"{\"+n+\"}\":n}).join(\"\")},e.i=function(t,r){\"string\"==typeof t&&(t=[[null,t,\"\"]]);for(var n={},i=0;i<this.length;i++){var o=this[i][0];\"number\"==typeof o&&(n[o]=!0)}for(i=0;i<t.length;i++){var a=t[i];\"number\"==typeof a[0]&&n[a[0]]||(r&&!a[2]?a[2]=r:r&&(a[2]=\"(\"+a[2]+\") and (\"+r+\")\"),e.push(a))}},e}}).call(e,r(3).Buffer)},function(t,e){e.read=function(t,e,r,n,i){var o,a,s=8*i-n-1,u=(1<<s)-1,f=u>>1,h=-7,c=r?i-1:0,l=r?-1:1,p=t[e+c];for(c+=l,o=p&(1<<-h)-1,p>>=-h,h+=s;h>0;o=256*o+t[e+c],c+=l,h-=8);for(a=o&(1<<-h)-1,o>>=-h,h+=n;h>0;a=256*a+t[e+c],c+=l,h-=8);if(0===o)o=1-f;else{if(o===u)return a?NaN:(p?-1:1)*(1/0);a+=Math.pow(2,n),o-=f}return(p?-1:1)*a*Math.pow(2,o-n)},e.write=function(t,e,r,n,i,o){var a,s,u,f=8*o-i-1,h=(1<<f)-1,c=h>>1,l=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:o-1,d=n?1:-1,g=e<0||0===e&&1/e<0?1:0;for(e=Math.abs(e),isNaN(e)||e===1/0?(s=isNaN(e)?1:0,a=h):(a=Math.floor(Math.log(e)/Math.LN2),e*(u=Math.pow(2,-a))<1&&(a--,u*=2),e+=a+c>=1?l/u:l*Math.pow(2,1-c),e*u>=2&&(a++,u/=2),a+c>=h?(s=0,a=h):a+c>=1?(s=(e*u-1)*Math.pow(2,i),a+=c):(s=e*Math.pow(2,c-1)*Math.pow(2,i),a=0));i>=8;t[r+p]=255&s,p+=d,s/=256,i-=8);for(a=a<<i|s,f+=i;f>0;t[r+p]=255&a,p+=d,a/=256,f-=8);t[r+p-d]|=128*g}},function(t,e){var r={}.toString;t.exports=Array.isArray||function(t){return\"[object Array]\"==r.call(t)}},function(t,e,r){r(11);var n=r(9)(r(1),r(10),null,null);t.exports=n.exports},function(t,e){t.exports=function(t,e,r,n){var i,o=t=t||{},a=typeof t.default;\"object\"!==a&&\"function\"!==a||(i=t,o=t.default);var s=\"function\"==typeof o?o.options:o;if(e&&(s.render=e.render,s.staticRenderFns=e.staticRenderFns),r&&(s._scopeId=r),n){var u=Object.create(s.computed||null);Object.keys(n).forEach(function(t){var e=n[t];u[t]=function(){return e}}),s.computed=u}return{esModule:i,exports:o,options:s}}},function(t,e){t.exports={render:function(){var t=this,e=(t.$createElement,t._c);return e(\"section\",{ref:\"block\",class:[t.sectionClass],style:{height:t.sectionHeight+\"vh\"}},[e(\"div\",{ref:\"parallax\",class:[t.parallax?t.parallaxClass:\"\",t.fixed?t.fixedClass:\"\",t.containerClass]},[t._t(\"default\")],2)])},staticRenderFns:[]}},function(t,e,r){var n=r(4);\"string\"==typeof n&&(n=[[t.id,n,\"\"]]),n.locals&&(t.exports=n.locals);r(12)(\"b568b5da\",n,!0)},function(t,e,r){function n(t){for(var e=0;e<t.length;e++){var r=t[e],n=h[r.id];if(n){n.refs++;for(var i=0;i<n.parts.length;i++)n.parts[i](r.parts[i]);for(;i<r.parts.length;i++)n.parts.push(o(r.parts[i]));n.parts.length>r.parts.length&&(n.parts.length=r.parts.length)}else{for(var a=[],i=0;i<r.parts.length;i++)a.push(o(r.parts[i]));h[r.id]={id:r.id,refs:1,parts:a}}}}function i(){var t=document.createElement(\"style\");return t.type=\"text/css\",c.appendChild(t),t}function o(t){var e,r,n=document.querySelector('style[data-vue-ssr-id~=\"'+t.id+'\"]');if(n){if(d)return g;n.parentNode.removeChild(n)}if(y){var o=p++;n=l||(l=i()),e=a.bind(null,n,o,!1),r=a.bind(null,n,o,!0)}else n=i(),e=s.bind(null,n),r=function(){n.parentNode.removeChild(n)};return e(t),function(n){if(n){if(n.css===t.css&&n.media===t.media&&n.sourceMap===t.sourceMap)return;e(t=n)}else r()}}function a(t,e,r,n){var i=r?\"\":n.css;if(t.styleSheet)t.styleSheet.cssText=A(e,i);else{var o=document.createTextNode(i),a=t.childNodes;a[e]&&t.removeChild(a[e]),a.length?t.insertBefore(o,a[e]):t.appendChild(o)}}function s(t,e){var r=e.css,n=e.media,i=e.sourceMap;if(n&&t.setAttribute(\"media\",n),i&&(r+=\"\\n/*# sourceURL=\"+i.sources[0]+\" */\",r+=\"\\n/*# sourceMappingURL=data:application/json;base64,\"+btoa(unescape(encodeURIComponent(JSON.stringify(i))))+\" */\"),t.styleSheet)t.styleSheet.cssText=r;else{for(;t.firstChild;)t.removeChild(t.firstChild);t.appendChild(document.createTextNode(r))}}var u=\"undefined\"!=typeof document,f=r(13),h={},c=u&&(document.head||document.getElementsByTagName(\"head\")[0]),l=null,p=0,d=!1,g=function(){},y=\"undefined\"!=typeof navigator&&/msie [6-9]\\b/.test(navigator.userAgent.toLowerCase());t.exports=function(t,e,r){d=r;var i=f(t,e);return n(i),function(e){for(var r=[],o=0;o<i.length;o++){var a=i[o],s=h[a.id];s.refs--,r.push(s)}e?(i=f(t,e),n(i)):i=[];for(var o=0;o<r.length;o++){var s=r[o];if(0===s.refs){for(var u=0;u<s.parts.length;u++)s.parts[u]();delete h[s.id]}}}};var A=function(){var t=[];return function(e,r){return t[e]=r,t.filter(Boolean).join(\"\\n\")}}()},function(t,e){t.exports=function(t,e){for(var r=[],n={},i=0;i<e.length;i++){var o=e[i],a=o[0],s=o[1],u=o[2],f=o[3],h={id:t+\":\"+i,css:s,media:u,sourceMap:f};n[a]?n[a].parts.push(h):r.push(n[a]={id:a,parts:[h]})}return r}}])});\n\n\n// WEBPACK FOOTER //\n// ./node_modules/vue-parallaxy/dist/vue-parallaxy.min.js","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n\n// WEBPACK FOOTER //\n// (webpack)/buildin/module.js","/*\n 2017 Julian Garnier\n Released under the MIT license\n*/\nvar $jscomp$this=this;\n(function(u,r){\"function\"===typeof define&&define.amd?define([],r):\"object\"===typeof module&&module.exports?module.exports=r():u.anime=r()})(this,function(){function u(a){if(!g.col(a))try{return document.querySelectorAll(a)}catch(b){}}function r(a){return a.reduce(function(a,c){return a.concat(g.arr(c)?r(c):c)},[])}function v(a){if(g.arr(a))return a;g.str(a)&&(a=u(a)||a);return a instanceof NodeList||a instanceof HTMLCollection?[].slice.call(a):[a]}function E(a,b){return a.some(function(a){return a===b})}\nfunction z(a){var b={},c;for(c in a)b[c]=a[c];return b}function F(a,b){var c=z(a),d;for(d in a)c[d]=b.hasOwnProperty(d)?b[d]:a[d];return c}function A(a,b){var c=z(a),d;for(d in b)c[d]=g.und(a[d])?b[d]:a[d];return c}function R(a){a=a.replace(/^#?([a-f\\d])([a-f\\d])([a-f\\d])$/i,function(a,b,c,h){return b+b+c+c+h+h});var b=/^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(a);a=parseInt(b[1],16);var c=parseInt(b[2],16),b=parseInt(b[3],16);return\"rgb(\"+a+\",\"+c+\",\"+b+\")\"}function S(a){function b(a,b,c){0>\nc&&(c+=1);1<c&&--c;return c<1/6?a+6*(b-a)*c:.5>c?b:c<2/3?a+(b-a)*(2/3-c)*6:a}var c=/hsl\\((\\d+),\\s*([\\d.]+)%,\\s*([\\d.]+)%\\)/g.exec(a);a=parseInt(c[1])/360;var d=parseInt(c[2])/100,c=parseInt(c[3])/100;if(0==d)d=c=a=c;else{var e=.5>c?c*(1+d):c+d-c*d,k=2*c-e,d=b(k,e,a+1/3),c=b(k,e,a);a=b(k,e,a-1/3)}return\"rgb(\"+255*d+\",\"+255*c+\",\"+255*a+\")\"}function w(a){if(a=/([\\+\\-]?[0-9#\\.]+)(%|px|pt|em|rem|in|cm|mm|ex|pc|vw|vh|deg|rad|turn)?/.exec(a))return a[2]}function T(a){if(-1<a.indexOf(\"translate\"))return\"px\";\nif(-1<a.indexOf(\"rotate\")||-1<a.indexOf(\"skew\"))return\"deg\"}function G(a,b){return g.fnc(a)?a(b.target,b.id,b.total):a}function B(a,b){if(b in a.style)return getComputedStyle(a).getPropertyValue(b.replace(/([a-z])([A-Z])/g,\"$1-$2\").toLowerCase())||\"0\"}function H(a,b){if(g.dom(a)&&E(U,b))return\"transform\";if(g.dom(a)&&(a.getAttribute(b)||g.svg(a)&&a[b]))return\"attribute\";if(g.dom(a)&&\"transform\"!==b&&B(a,b))return\"css\";if(null!=a[b])return\"object\"}function V(a,b){var c=T(b),c=-1<b.indexOf(\"scale\")?\n1:0+c;a=a.style.transform;if(!a)return c;for(var d=[],e=[],k=[],h=/(\\w+)\\((.+?)\\)/g;d=h.exec(a);)e.push(d[1]),k.push(d[2]);a=k.filter(function(a,c){return e[c]===b});return a.length?a[0]:c}function I(a,b){switch(H(a,b)){case \"transform\":return V(a,b);case \"css\":return B(a,b);case \"attribute\":return a.getAttribute(b)}return a[b]||0}function J(a,b){var c=/^(\\*=|\\+=|-=)/.exec(a);if(!c)return a;b=parseFloat(b);a=parseFloat(a.replace(c[0],\"\"));switch(c[0][0]){case \"+\":return b+a;case \"-\":return b-a;case \"*\":return b*\na}}function C(a){return g.obj(a)&&a.hasOwnProperty(\"totalLength\")}function W(a,b){function c(c){c=void 0===c?0:c;return a.el.getPointAtLength(1<=b+c?b+c:0)}var d=c(),e=c(-1),k=c(1);switch(a.property){case \"x\":return d.x;case \"y\":return d.y;case \"angle\":return 180*Math.atan2(k.y-e.y,k.x-e.x)/Math.PI}}function K(a,b){var c=/-?\\d*\\.?\\d+/g;a=C(a)?a.totalLength:a;if(g.col(a))b=g.rgb(a)?a:g.hex(a)?R(a):g.hsl(a)?S(a):void 0;else{var d=w(a);a=d?a.substr(0,a.length-d.length):a;b=b?a+b:a}b+=\"\";return{original:b,\nnumbers:b.match(c)?b.match(c).map(Number):[0],strings:b.split(c)}}function X(a,b){return b.reduce(function(b,d,e){return b+a[e-1]+d})}function L(a){return(a?r(g.arr(a)?a.map(v):v(a)):[]).filter(function(a,c,d){return d.indexOf(a)===c})}function Y(a){var b=L(a);return b.map(function(a,d){return{target:a,id:d,total:b.length}})}function Z(a,b){var c=z(b);if(g.arr(a)){var d=a.length;2!==d||g.obj(a[0])?g.fnc(b.duration)||(c.duration=b.duration/d):a={value:a}}return v(a).map(function(a,c){c=c?0:b.delay;\na=g.obj(a)&&!C(a)?a:{value:a};g.und(a.delay)&&(a.delay=c);return a}).map(function(a){return A(a,c)})}function aa(a,b){var c={},d;for(d in a){var e=G(a[d],b);g.arr(e)&&(e=e.map(function(a){return G(a,b)}),1===e.length&&(e=e[0]));c[d]=e}c.duration=parseFloat(c.duration);c.delay=parseFloat(c.delay);return c}function ba(a){return g.arr(a)?x.apply(this,a):M[a]}function ca(a,b){var c;return a.tweens.map(function(d){d=aa(d,b);var e=d.value,k=I(b.target,a.name),h=c?c.to.original:k,h=g.arr(e)?e[0]:h,n=J(g.arr(e)?\ne[1]:e,h),k=w(n)||w(h)||w(k);d.isPath=C(e);d.from=K(h,k);d.to=K(n,k);d.start=c?c.end:a.offset;d.end=d.start+d.delay+d.duration;d.easing=ba(d.easing);d.elasticity=(1E3-Math.min(Math.max(d.elasticity,1),999))/1E3;g.col(d.from.original)&&(d.round=1);return c=d})}function da(a,b){return r(a.map(function(a){return b.map(function(b){var c=H(a.target,b.name);if(c){var d=ca(b,a);b={type:c,property:b.name,animatable:a,tweens:d,duration:d[d.length-1].end,delay:d[0].delay}}else b=void 0;return b})})).filter(function(a){return!g.und(a)})}\nfunction N(a,b,c){var d=\"delay\"===a?Math.min:Math.max;return b.length?d.apply(Math,b.map(function(b){return b[a]})):c[a]}function ea(a){var b=F(fa,a),c=F(ga,a),d=Y(a.targets),e=[],g=A(b,c),h;for(h in a)g.hasOwnProperty(h)||\"targets\"===h||e.push({name:h,offset:g.offset,tweens:Z(a[h],c)});a=da(d,e);return A(b,{animatables:d,animations:a,duration:N(\"duration\",a,c),delay:N(\"delay\",a,c)})}function m(a){function b(){return window.Promise&&new Promise(function(a){return P=a})}function c(a){return f.reversed?\nf.duration-a:a}function d(a){for(var b=0,c={},d=f.animations,e={};b<d.length;){var g=d[b],h=g.animatable,n=g.tweens;e.tween=n.filter(function(b){return a<b.end})[0]||n[n.length-1];e.isPath$0=e.tween.isPath;e.round=e.tween.round;e.eased=e.tween.easing(Math.min(Math.max(a-e.tween.start-e.tween.delay,0),e.tween.duration)/e.tween.duration,e.tween.elasticity);n=X(e.tween.to.numbers.map(function(a){return function(b,c){c=a.isPath$0?0:a.tween.from.numbers[c];b=c+a.eased*(b-c);a.isPath$0&&(b=W(a.tween.value,\nb));a.round&&(b=Math.round(b*a.round)/a.round);return b}}(e)),e.tween.to.strings);ha[g.type](h.target,g.property,n,c,h.id);g.currentValue=n;b++;e={isPath$0:e.isPath$0,tween:e.tween,eased:e.eased,round:e.round}}if(c)for(var k in c)D||(D=B(document.body,\"transform\")?\"transform\":\"-webkit-transform\"),f.animatables[k].target.style[D]=c[k].join(\" \");f.currentTime=a;f.progress=a/f.duration*100}function e(a){if(f[a])f[a](f)}function g(){f.remaining&&!0!==f.remaining&&f.remaining--}function h(a){var h=f.duration,\nk=f.offset,m=f.delay,O=f.currentTime,p=f.reversed,q=c(a),q=Math.min(Math.max(q,0),h);q>k&&q<h?(d(q),!f.began&&q>=m&&(f.began=!0,e(\"begin\")),e(\"run\")):(q<=k&&0!==O&&(d(0),p&&g()),q>=h&&O!==h&&(d(h),p||g()));a>=h&&(f.remaining?(t=n,\"alternate\"===f.direction&&(f.reversed=!f.reversed)):(f.pause(),P(),Q=b(),f.completed||(f.completed=!0,e(\"complete\"))),l=0);if(f.children)for(a=f.children,h=0;h<a.length;h++)a[h].seek(q);e(\"update\")}a=void 0===a?{}:a;var n,t,l=0,P=null,Q=b(),f=ea(a);f.reset=function(){var a=\nf.direction,b=f.loop;f.currentTime=0;f.progress=0;f.paused=!0;f.began=!1;f.completed=!1;f.reversed=\"reverse\"===a;f.remaining=\"alternate\"===a&&1===b?2:b};f.tick=function(a){n=a;t||(t=n);h((l+n-t)*m.speed)};f.seek=function(a){h(c(a))};f.pause=function(){var a=p.indexOf(f);-1<a&&p.splice(a,1);f.paused=!0};f.play=function(){f.paused&&(f.paused=!1,t=0,l=f.completed?0:c(f.currentTime),p.push(f),y||ia())};f.reverse=function(){f.reversed=!f.reversed;t=0;l=c(f.currentTime)};f.restart=function(){f.pause();\nf.reset();f.play()};f.finished=Q;f.reset();f.autoplay&&f.play();return f}var fa={update:void 0,begin:void 0,run:void 0,complete:void 0,loop:1,direction:\"normal\",autoplay:!0,offset:0},ga={duration:1E3,delay:0,easing:\"easeOutElastic\",elasticity:500,round:0},U=\"translateX translateY translateZ rotate rotateX rotateY rotateZ scale scaleX scaleY scaleZ skewX skewY\".split(\" \"),D,g={arr:function(a){return Array.isArray(a)},obj:function(a){return-1<Object.prototype.toString.call(a).indexOf(\"Object\")},svg:function(a){return a instanceof\nSVGElement},dom:function(a){return a.nodeType||g.svg(a)},str:function(a){return\"string\"===typeof a},fnc:function(a){return\"function\"===typeof a},und:function(a){return\"undefined\"===typeof a},hex:function(a){return/(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(a)},rgb:function(a){return/^rgb/.test(a)},hsl:function(a){return/^hsl/.test(a)},col:function(a){return g.hex(a)||g.rgb(a)||g.hsl(a)}},x=function(){function a(a,c,d){return(((1-3*d+3*c)*a+(3*d-6*c))*a+3*c)*a}return function(b,c,d,e){if(0<=b&&1>=b&&\n0<=d&&1>=d){var g=new Float32Array(11);if(b!==c||d!==e)for(var h=0;11>h;++h)g[h]=a(.1*h,b,d);return function(h){if(b===c&&d===e)return h;if(0===h)return 0;if(1===h)return 1;for(var k=0,l=1;10!==l&&g[l]<=h;++l)k+=.1;--l;var l=k+(h-g[l])/(g[l+1]-g[l])*.1,n=3*(1-3*d+3*b)*l*l+2*(3*d-6*b)*l+3*b;if(.001<=n){for(k=0;4>k;++k){n=3*(1-3*d+3*b)*l*l+2*(3*d-6*b)*l+3*b;if(0===n)break;var m=a(l,b,d)-h,l=l-m/n}h=l}else if(0===n)h=l;else{var l=k,k=k+.1,f=0;do m=l+(k-l)/2,n=a(m,b,d)-h,0<n?k=m:l=m;while(1e-7<Math.abs(n)&&\n10>++f);h=m}return a(h,c,e)}}}}(),M=function(){function a(a,b){return 0===a||1===a?a:-Math.pow(2,10*(a-1))*Math.sin(2*(a-1-b/(2*Math.PI)*Math.asin(1))*Math.PI/b)}var b=\"Quad Cubic Quart Quint Sine Expo Circ Back Elastic\".split(\" \"),c={In:[[.55,.085,.68,.53],[.55,.055,.675,.19],[.895,.03,.685,.22],[.755,.05,.855,.06],[.47,0,.745,.715],[.95,.05,.795,.035],[.6,.04,.98,.335],[.6,-.28,.735,.045],a],Out:[[.25,.46,.45,.94],[.215,.61,.355,1],[.165,.84,.44,1],[.23,1,.32,1],[.39,.575,.565,1],[.19,1,.22,1],\n[.075,.82,.165,1],[.175,.885,.32,1.275],function(b,c){return 1-a(1-b,c)}],InOut:[[.455,.03,.515,.955],[.645,.045,.355,1],[.77,0,.175,1],[.86,0,.07,1],[.445,.05,.55,.95],[1,0,0,1],[.785,.135,.15,.86],[.68,-.55,.265,1.55],function(b,c){return.5>b?a(2*b,c)/2:1-a(-2*b+2,c)/2}]},d={linear:x(.25,.25,.75,.75)},e={},k;for(k in c)e.type=k,c[e.type].forEach(function(a){return function(c,e){d[\"ease\"+a.type+b[e]]=g.fnc(c)?c:x.apply($jscomp$this,c)}}(e)),e={type:e.type};return d}(),ha={css:function(a,b,c){return a.style[b]=\nc},attribute:function(a,b,c){return a.setAttribute(b,c)},object:function(a,b,c){return a[b]=c},transform:function(a,b,c,d,e){d[e]||(d[e]=[]);d[e].push(b+\"(\"+c+\")\")}},p=[],y=0,ia=function(){function a(){y=requestAnimationFrame(b)}function b(b){var c=p.length;if(c){for(var e=0;e<c;)p[e]&&p[e].tick(b),e++;a()}else cancelAnimationFrame(y),y=0}return a}();m.version=\"2.0.1\";m.speed=1;m.running=p;m.remove=function(a){a=L(a);for(var b=p.length-1;0<=b;b--)for(var c=p[b],d=c.animations,e=d.length-1;0<=e;e--)E(a,\nd[e].animatable.target)&&(d.splice(e,1),d.length||c.pause())};m.getValue=I;m.path=function(a,b){var c=g.str(a)?u(a)[0]:a,d=b||100;return function(a){return{el:c,property:a,totalLength:c.getTotalLength()*(d/100)}}};m.setDashoffset=function(a){var b=a.getTotalLength();a.setAttribute(\"stroke-dasharray\",b);return b};m.bezier=x;m.easings=M;m.timeline=function(a){var b=m(a);b.duration=0;b.children=[];b.add=function(a){v(a).forEach(function(a){var c=a.offset,d=b.duration;a.autoplay=!1;a.offset=g.und(c)?\nd:J(c,d);a=m(a);a.duration>d&&(b.duration=a.duration);b.children.push(a)});return b};return b};m.random=function(a,b){return Math.floor(Math.random()*(b-a+1))+a};return m});\n\n\n// WEBPACK FOOTER //\n// ./node_modules/animejs/anime.min.js","/////    /////    /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n/////             /////    /////\n/////             /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n         /////    /////\n         /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n/////    /////    /////    /////\n\n/**\n * ScrollReveal\n * ------------\n * Version : 3.3.6\n * Website : scrollrevealjs.org\n * Repo    : github.com/jlmakes/scrollreveal.js\n * Author  : Julian Lloyd (@jlmakes)\n */\n\n;(function () {\n  'use strict'\n\n  var sr\n  var _requestAnimationFrame\n\n  function ScrollReveal (config) {\n    // Support instantiation without the `new` keyword.\n    if (typeof this === 'undefined' || Object.getPrototypeOf(this) !== ScrollReveal.prototype) {\n      return new ScrollReveal(config)\n    }\n\n    sr = this // Save reference to instance.\n    sr.version = '3.3.6'\n    sr.tools = new Tools() // *required utilities\n\n    if (sr.isSupported()) {\n      sr.tools.extend(sr.defaults, config || {})\n\n      sr.defaults.container = _resolveContainer(sr.defaults)\n\n      sr.store = {\n        elements: {},\n        containers: []\n      }\n\n      sr.sequences = {}\n      sr.history = []\n      sr.uid = 0\n      sr.initialized = false\n    } else if (typeof console !== 'undefined' && console !== null) {\n      // Note: IE9 only supports console if devtools are open.\n      console.log('ScrollReveal is not supported in this browser.')\n    }\n\n    return sr\n  }\n\n  /**\n   * Configuration\n   * -------------\n   * This object signature can be passed directly to the ScrollReveal constructor,\n   * or as the second argument of the `reveal()` method.\n   */\n\n  ScrollReveal.prototype.defaults = {\n    // 'bottom', 'left', 'top', 'right'\n    origin: 'bottom',\n\n    // Can be any valid CSS distance, e.g. '5rem', '10%', '20vw', etc.\n    distance: '20px',\n\n    // Time in milliseconds.\n    duration: 500,\n    delay: 0,\n\n    // Starting angles in degrees, will transition from these values to 0 in all axes.\n    rotate: { x: 0, y: 0, z: 0 },\n\n    // Starting opacity value, before transitioning to the computed opacity.\n    opacity: 0,\n\n    // Starting scale value, will transition from this value to 1\n    scale: 0.9,\n\n    // Accepts any valid CSS easing, e.g. 'ease', 'ease-in-out', 'linear', etc.\n    easing: 'cubic-bezier(0.6, 0.2, 0.1, 1)',\n\n    // `<html>` is the default reveal container. You can pass either:\n    // DOM Node, e.g. document.querySelector('.fooContainer')\n    // Selector, e.g. '.fooContainer'\n    container: window.document.documentElement,\n\n    // true/false to control reveal animations on mobile.\n    mobile: true,\n\n    // true:  reveals occur every time elements become visible\n    // false: reveals occur once as elements become visible\n    reset: false,\n\n    // 'always' — delay for all reveal animations\n    // 'once'   — delay only the first time reveals occur\n    // 'onload' - delay only for animations triggered by first load\n    useDelay: 'always',\n\n    // Change when an element is considered in the viewport. The default value\n    // of 0.20 means 20% of an element must be visible for its reveal to occur.\n    viewFactor: 0.2,\n\n    // Pixel values that alter the container boundaries.\n    // e.g. Set `{ top: 48 }`, if you have a 48px tall fixed toolbar.\n    // --\n    // Visual Aid: https://scrollrevealjs.org/assets/viewoffset.png\n    viewOffset: { top: 0, right: 0, bottom: 0, left: 0 },\n\n    // Callbacks that fire for each triggered element reveal, and reset.\n    beforeReveal: function (domEl) {},\n    beforeReset: function (domEl) {},\n\n    // Callbacks that fire for each completed element reveal, and reset.\n    afterReveal: function (domEl) {},\n    afterReset: function (domEl) {}\n  }\n\n  /**\n   * Check if client supports CSS Transform and CSS Transition.\n   * @return {boolean}\n   */\n  ScrollReveal.prototype.isSupported = function () {\n    var style = document.documentElement.style\n    return 'WebkitTransition' in style && 'WebkitTransform' in style ||\n      'transition' in style && 'transform' in style\n  }\n\n  /**\n   * Creates a reveal set, a group of elements that will animate when they\n   * become visible. If [interval] is provided, a new sequence is created\n   * that will ensure elements reveal in the order they appear in the DOM.\n   *\n   * @param {Node|NodeList|string} [target]   The node, node list or selector to use for animation.\n   * @param {Object}               [config]   Override the defaults for this reveal set.\n   * @param {number}               [interval] Time between sequenced element animations (milliseconds).\n   * @param {boolean}              [sync]     Used internally when updating reveals for async content.\n   *\n   * @return {Object} The current ScrollReveal instance.\n   */\n  ScrollReveal.prototype.reveal = function (target, config, interval, sync) {\n    var container\n    var elements\n    var elem\n    var elemId\n    var sequence\n    var sequenceId\n\n    // No custom configuration was passed, but a sequence interval instead.\n    // let’s shuffle things around to make sure everything works.\n    if (config !== undefined && typeof config === 'number') {\n      interval = config\n      config = {}\n    } else if (config === undefined || config === null) {\n      config = {}\n    }\n\n    container = _resolveContainer(config)\n    elements = _getRevealElements(target, container)\n\n    if (!elements.length) {\n      console.log('ScrollReveal: reveal on \"' + target + '\" failed, no elements found.')\n      return sr\n    }\n\n    // Prepare a new sequence if an interval is passed.\n    if (interval && typeof interval === 'number') {\n      sequenceId = _nextUid()\n\n      sequence = sr.sequences[sequenceId] = {\n        id: sequenceId,\n        interval: interval,\n        elemIds: [],\n        active: false\n      }\n    }\n\n    // Begin main loop to configure ScrollReveal elements.\n    for (var i = 0; i < elements.length; i++) {\n      // Check if the element has already been configured and grab it from the store.\n      elemId = elements[i].getAttribute('data-sr-id')\n      if (elemId) {\n        elem = sr.store.elements[elemId]\n      } else {\n        // Otherwise, let’s do some basic setup.\n        elem = {\n          id: _nextUid(),\n          domEl: elements[i],\n          seen: false,\n          revealing: false\n        }\n        elem.domEl.setAttribute('data-sr-id', elem.id)\n      }\n\n      // Sequence only setup\n      if (sequence) {\n        elem.sequence = {\n          id: sequence.id,\n          index: sequence.elemIds.length\n        }\n\n        sequence.elemIds.push(elem.id)\n      }\n\n      // New or existing element, it’s time to update its configuration, styles,\n      // and send the updates to our store.\n      _configure(elem, config, container)\n      _style(elem)\n      _updateStore(elem)\n\n      // We need to make sure elements are set to visibility: visible, even when\n      // on mobile and `config.mobile === false`, or if unsupported.\n      if (sr.tools.isMobile() && !elem.config.mobile || !sr.isSupported()) {\n        elem.domEl.setAttribute('style', elem.styles.inline)\n        elem.disabled = true\n      } else if (!elem.revealing) {\n        // Otherwise, proceed normally.\n        elem.domEl.setAttribute('style',\n          elem.styles.inline +\n          elem.styles.transform.initial\n        )\n      }\n    }\n\n    // Each `reveal()` is recorded so that when calling `sync()` while working\n    // with asynchronously loaded content, it can re-trace your steps but with\n    // all your new elements now in the DOM.\n\n    // Since `reveal()` is called internally by `sync()`, we don’t want to\n    // record or intiialize each reveal during syncing.\n    if (!sync && sr.isSupported()) {\n      _record(target, config, interval)\n\n      // We push initialization to the event queue using setTimeout, so that we can\n      // give ScrollReveal room to process all reveal calls before putting things into motion.\n      // --\n      // Philip Roberts - What the heck is the event loop anyway? (JSConf EU 2014)\n      // https://www.youtube.com/watch?v=8aGhZQkoFbQ\n      if (sr.initTimeout) {\n        window.clearTimeout(sr.initTimeout)\n      }\n      sr.initTimeout = window.setTimeout(_init, 0)\n    }\n\n    return sr\n  }\n\n  /**\n   * Re-runs `reveal()` for each record stored in history, effectively capturing\n   * any content loaded asynchronously that matches existing reveal set targets.\n   * @return {Object} The current ScrollReveal instance.\n   */\n  ScrollReveal.prototype.sync = function () {\n    if (sr.history.length && sr.isSupported()) {\n      for (var i = 0; i < sr.history.length; i++) {\n        var record = sr.history[i]\n        sr.reveal(record.target, record.config, record.interval, true)\n      }\n      _init()\n    } else {\n      console.log('ScrollReveal: sync failed, no reveals found.')\n    }\n    return sr\n  }\n\n  /**\n   * Private Methods\n   * ---------------\n   */\n\n  function _resolveContainer (config) {\n    if (config && config.container) {\n      if (typeof config.container === 'string') {\n        return window.document.documentElement.querySelector(config.container)\n      } else if (sr.tools.isNode(config.container)) {\n        return config.container\n      } else {\n        console.log('ScrollReveal: invalid container \"' + config.container + '\" provided.')\n        console.log('ScrollReveal: falling back to default container.')\n      }\n    }\n    return sr.defaults.container\n  }\n\n  /**\n   * check to see if a node or node list was passed in as the target,\n   * otherwise query the container using target as a selector.\n   *\n   * @param {Node|NodeList|string} [target]    client input for reveal target.\n   * @param {Node}                 [container] parent element for selector queries.\n   *\n   * @return {array} elements to be revealed.\n   */\n  function _getRevealElements (target, container) {\n    if (typeof target === 'string') {\n      return Array.prototype.slice.call(container.querySelectorAll(target))\n    } else if (sr.tools.isNode(target)) {\n      return [target]\n    } else if (sr.tools.isNodeList(target)) {\n      return Array.prototype.slice.call(target)\n    }\n    return []\n  }\n\n  /**\n   * A consistent way of creating unique IDs.\n   * @returns {number}\n   */\n  function _nextUid () {\n    return ++sr.uid\n  }\n\n  function _configure (elem, config, container) {\n    // If a container was passed as a part of the config object,\n    // let’s overwrite it with the resolved container passed in.\n    if (config.container) config.container = container\n    // If the element hasn’t already been configured, let’s use a clone of the\n    // defaults extended by the configuration passed as the second argument.\n    if (!elem.config) {\n      elem.config = sr.tools.extendClone(sr.defaults, config)\n    } else {\n      // Otherwise, let’s use a clone of the existing element configuration extended\n      // by the configuration passed as the second argument.\n      elem.config = sr.tools.extendClone(elem.config, config)\n    }\n\n    // Infer CSS Transform axis from origin string.\n    if (elem.config.origin === 'top' || elem.config.origin === 'bottom') {\n      elem.config.axis = 'Y'\n    } else {\n      elem.config.axis = 'X'\n    }\n  }\n\n  function _style (elem) {\n    var computed = window.getComputedStyle(elem.domEl)\n\n    if (!elem.styles) {\n      elem.styles = {\n        transition: {},\n        transform: {},\n        computed: {}\n      }\n\n      // Capture any existing inline styles, and add our visibility override.\n      // --\n      // See section 4.2. in the Documentation:\n      // https://github.com/jlmakes/scrollreveal.js#42-improve-user-experience\n      elem.styles.inline = elem.domEl.getAttribute('style') || ''\n      elem.styles.inline += '; visibility: visible; '\n\n      // grab the elements existing opacity.\n      elem.styles.computed.opacity = computed.opacity\n\n      // grab the elements existing transitions.\n      if (!computed.transition || computed.transition === 'all 0s ease 0s') {\n        elem.styles.computed.transition = ''\n      } else {\n        elem.styles.computed.transition = computed.transition + ', '\n      }\n    }\n\n    // Create transition styles\n    elem.styles.transition.instant = _generateTransition(elem, 0)\n    elem.styles.transition.delayed = _generateTransition(elem, elem.config.delay)\n\n    // Generate transform styles, first with the webkit prefix.\n    elem.styles.transform.initial = ' -webkit-transform:'\n    elem.styles.transform.target = ' -webkit-transform:'\n    _generateTransform(elem)\n\n    // And again without any prefix.\n    elem.styles.transform.initial += 'transform:'\n    elem.styles.transform.target += 'transform:'\n    _generateTransform(elem)\n  }\n\n  function _generateTransition (elem, delay) {\n    var config = elem.config\n\n    return '-webkit-transition: ' + elem.styles.computed.transition +\n      '-webkit-transform ' + config.duration / 1000 + 's ' +\n      config.easing + ' ' +\n      delay / 1000 + 's, opacity ' +\n      config.duration / 1000 + 's ' +\n      config.easing + ' ' +\n      delay / 1000 + 's; ' +\n\n      'transition: ' + elem.styles.computed.transition +\n      'transform ' + config.duration / 1000 + 's ' +\n      config.easing + ' ' +\n      delay / 1000 + 's, opacity ' +\n      config.duration / 1000 + 's ' +\n      config.easing + ' ' +\n      delay / 1000 + 's; '\n  }\n\n  function _generateTransform (elem) {\n    var config = elem.config\n    var cssDistance\n    var transform = elem.styles.transform\n\n    // Let’s make sure our our pixel distances are negative for top and left.\n    // e.g. origin = 'top' and distance = '25px' starts at `top: -25px` in CSS.\n    if (config.origin === 'top' || config.origin === 'left') {\n      cssDistance = /^-/.test(config.distance)\n        ? config.distance.substr(1)\n        : '-' + config.distance\n    } else {\n      cssDistance = config.distance\n    }\n\n    if (parseInt(config.distance)) {\n      transform.initial += ' translate' + config.axis + '(' + cssDistance + ')'\n      transform.target += ' translate' + config.axis + '(0)'\n    }\n    if (config.scale) {\n      transform.initial += ' scale(' + config.scale + ')'\n      transform.target += ' scale(1)'\n    }\n    if (config.rotate.x) {\n      transform.initial += ' rotateX(' + config.rotate.x + 'deg)'\n      transform.target += ' rotateX(0)'\n    }\n    if (config.rotate.y) {\n      transform.initial += ' rotateY(' + config.rotate.y + 'deg)'\n      transform.target += ' rotateY(0)'\n    }\n    if (config.rotate.z) {\n      transform.initial += ' rotateZ(' + config.rotate.z + 'deg)'\n      transform.target += ' rotateZ(0)'\n    }\n    transform.initial += '; opacity: ' + config.opacity + ';'\n    transform.target += '; opacity: ' + elem.styles.computed.opacity + ';'\n  }\n\n  function _updateStore (elem) {\n    var container = elem.config.container\n\n    // If this element’s container isn’t already in the store, let’s add it.\n    if (container && sr.store.containers.indexOf(container) === -1) {\n      sr.store.containers.push(elem.config.container)\n    }\n\n    // Update the element stored with our new element.\n    sr.store.elements[elem.id] = elem\n  }\n\n  function _record (target, config, interval) {\n    // Save the `reveal()` arguments that triggered this `_record()` call, so we\n    // can re-trace our steps when calling the `sync()` method.\n    var record = {\n      target: target,\n      config: config,\n      interval: interval\n    }\n    sr.history.push(record)\n  }\n\n  function _init () {\n    if (sr.isSupported()) {\n      // Initial animate call triggers valid reveal animations on first load.\n      // Subsequent animate calls are made inside the event handler.\n      _animate()\n\n      // Then we loop through all container nodes in the store and bind event\n      // listeners to each.\n      for (var i = 0; i < sr.store.containers.length; i++) {\n        sr.store.containers[i].addEventListener('scroll', _handler)\n        sr.store.containers[i].addEventListener('resize', _handler)\n      }\n\n      // Let’s also do a one-time binding of window event listeners.\n      if (!sr.initialized) {\n        window.addEventListener('scroll', _handler)\n        window.addEventListener('resize', _handler)\n        sr.initialized = true\n      }\n    }\n    return sr\n  }\n\n  function _handler () {\n    _requestAnimationFrame(_animate)\n  }\n\n  function _setActiveSequences () {\n    var active\n    var elem\n    var elemId\n    var sequence\n\n    // Loop through all sequences\n    sr.tools.forOwn(sr.sequences, function (sequenceId) {\n      sequence = sr.sequences[sequenceId]\n      active = false\n\n      // For each sequenced elemenet, let’s check visibility and if\n      // any are visible, set it’s sequence to active.\n      for (var i = 0; i < sequence.elemIds.length; i++) {\n        elemId = sequence.elemIds[i]\n        elem = sr.store.elements[elemId]\n        if (_isElemVisible(elem) && !active) {\n          active = true\n        }\n      }\n\n      sequence.active = active\n    })\n  }\n\n  function _animate () {\n    var delayed\n    var elem\n\n    _setActiveSequences()\n\n    // Loop through all elements in the store\n    sr.tools.forOwn(sr.store.elements, function (elemId) {\n      elem = sr.store.elements[elemId]\n      delayed = _shouldUseDelay(elem)\n\n      // Let’s see if we should revealand if so,\n      // trigger the `beforeReveal` callback and\n      // determine whether or not to use delay.\n      if (_shouldReveal(elem)) {\n        elem.config.beforeReveal(elem.domEl)\n        if (delayed) {\n          elem.domEl.setAttribute('style',\n            elem.styles.inline +\n            elem.styles.transform.target +\n            elem.styles.transition.delayed\n          )\n        } else {\n          elem.domEl.setAttribute('style',\n            elem.styles.inline +\n            elem.styles.transform.target +\n            elem.styles.transition.instant\n          )\n        }\n\n        // Let’s queue the `afterReveal` callback\n        // and mark the element as seen and revealing.\n        _queueCallback('reveal', elem, delayed)\n        elem.revealing = true\n        elem.seen = true\n\n        if (elem.sequence) {\n          _queueNextInSequence(elem, delayed)\n        }\n      } else if (_shouldReset(elem)) {\n        //Otherwise reset our element and\n        // trigger the `beforeReset` callback.\n        elem.config.beforeReset(elem.domEl)\n        elem.domEl.setAttribute('style',\n          elem.styles.inline +\n          elem.styles.transform.initial +\n          elem.styles.transition.instant\n        )\n        // And queue the `afterReset` callback.\n        _queueCallback('reset', elem)\n        elem.revealing = false\n      }\n    })\n  }\n\n  function _queueNextInSequence (elem, delayed) {\n    var elapsed = 0\n    var delay = 0\n    var sequence = sr.sequences[elem.sequence.id]\n\n    // We’re processing a sequenced element, so let's block other elements in this sequence.\n    sequence.blocked = true\n\n    // Since we’re triggering animations a part of a sequence after animations on first load,\n    // we need to check for that condition and explicitly add the delay to our timer.\n    if (delayed && elem.config.useDelay === 'onload') {\n      delay = elem.config.delay\n    }\n\n    // If a sequence timer is already running, capture the elapsed time and clear it.\n    if (elem.sequence.timer) {\n      elapsed = Math.abs(elem.sequence.timer.started - new Date())\n      window.clearTimeout(elem.sequence.timer)\n    }\n\n    // Start a new timer.\n    elem.sequence.timer = { started: new Date() }\n    elem.sequence.timer.clock = window.setTimeout(function () {\n      // Sequence interval has passed, so unblock the sequence and re-run the handler.\n      sequence.blocked = false\n      elem.sequence.timer = null\n      _handler()\n    }, Math.abs(sequence.interval) + delay - elapsed)\n  }\n\n  function _queueCallback (type, elem, delayed) {\n    var elapsed = 0\n    var duration = 0\n    var callback = 'after'\n\n    // Check which callback we’re working with.\n    switch (type) {\n      case 'reveal':\n        duration = elem.config.duration\n        if (delayed) {\n          duration += elem.config.delay\n        }\n        callback += 'Reveal'\n        break\n\n      case 'reset':\n        duration = elem.config.duration\n        callback += 'Reset'\n        break\n    }\n\n    // If a timer is already running, capture the elapsed time and clear it.\n    if (elem.timer) {\n      elapsed = Math.abs(elem.timer.started - new Date())\n      window.clearTimeout(elem.timer.clock)\n    }\n\n    // Start a new timer.\n    elem.timer = { started: new Date() }\n    elem.timer.clock = window.setTimeout(function () {\n      // The timer completed, so let’s fire the callback and null the timer.\n      elem.config[callback](elem.domEl)\n      elem.timer = null\n    }, duration - elapsed)\n  }\n\n  function _shouldReveal (elem) {\n    if (elem.sequence) {\n      var sequence = sr.sequences[elem.sequence.id]\n      return sequence.active &&\n        !sequence.blocked &&\n        !elem.revealing &&\n        !elem.disabled\n    }\n    return _isElemVisible(elem) &&\n      !elem.revealing &&\n      !elem.disabled\n  }\n\n  function _shouldUseDelay (elem) {\n    var config = elem.config.useDelay\n    return config === 'always' ||\n      (config === 'onload' && !sr.initialized) ||\n      (config === 'once' && !elem.seen)\n  }\n\n  function _shouldReset (elem) {\n    if (elem.sequence) {\n      var sequence = sr.sequences[elem.sequence.id]\n      return !sequence.active &&\n        elem.config.reset &&\n        elem.revealing &&\n        !elem.disabled\n    }\n    return !_isElemVisible(elem) &&\n      elem.config.reset &&\n      elem.revealing &&\n      !elem.disabled\n  }\n\n  function _getContainer (container) {\n    return {\n      width: container.clientWidth,\n      height: container.clientHeight\n    }\n  }\n\n  function _getScrolled (container) {\n    // Return the container scroll values, plus the its offset.\n    if (container && container !== window.document.documentElement) {\n      var offset = _getOffset(container)\n      return {\n        x: container.scrollLeft + offset.left,\n        y: container.scrollTop + offset.top\n      }\n    } else {\n      // Otherwise, default to the window object’s scroll values.\n      return {\n        x: window.pageXOffset,\n        y: window.pageYOffset\n      }\n    }\n  }\n\n  function _getOffset (domEl) {\n    var offsetTop = 0\n    var offsetLeft = 0\n\n      // Grab the element’s dimensions.\n    var offsetHeight = domEl.offsetHeight\n    var offsetWidth = domEl.offsetWidth\n\n    // Now calculate the distance between the element and its parent, then\n    // again for the parent to its parent, and again etc... until we have the\n    // total distance of the element to the document’s top and left origin.\n    do {\n      if (!isNaN(domEl.offsetTop)) {\n        offsetTop += domEl.offsetTop\n      }\n      if (!isNaN(domEl.offsetLeft)) {\n        offsetLeft += domEl.offsetLeft\n      }\n      domEl = domEl.offsetParent\n    } while (domEl)\n\n    return {\n      top: offsetTop,\n      left: offsetLeft,\n      height: offsetHeight,\n      width: offsetWidth\n    }\n  }\n\n  function _isElemVisible (elem) {\n    var offset = _getOffset(elem.domEl)\n    var container = _getContainer(elem.config.container)\n    var scrolled = _getScrolled(elem.config.container)\n    var vF = elem.config.viewFactor\n\n      // Define the element geometry.\n    var elemHeight = offset.height\n    var elemWidth = offset.width\n    var elemTop = offset.top\n    var elemLeft = offset.left\n    var elemBottom = elemTop + elemHeight\n    var elemRight = elemLeft + elemWidth\n\n    return confirmBounds() || isPositionFixed()\n\n    function confirmBounds () {\n      // Define the element’s functional boundaries using its view factor.\n      var top = elemTop + elemHeight * vF\n      var left = elemLeft + elemWidth * vF\n      var bottom = elemBottom - elemHeight * vF\n      var right = elemRight - elemWidth * vF\n\n      // Define the container functional boundaries using its view offset.\n      var viewTop = scrolled.y + elem.config.viewOffset.top\n      var viewLeft = scrolled.x + elem.config.viewOffset.left\n      var viewBottom = scrolled.y - elem.config.viewOffset.bottom + container.height\n      var viewRight = scrolled.x - elem.config.viewOffset.right + container.width\n\n      return top < viewBottom &&\n        bottom > viewTop &&\n        left < viewRight &&\n        right > viewLeft\n    }\n\n    function isPositionFixed () {\n      return (window.getComputedStyle(elem.domEl).position === 'fixed')\n    }\n  }\n\n  /**\n   * Utilities\n   * ---------\n   */\n\n  function Tools () {}\n\n  Tools.prototype.isObject = function (object) {\n    return object !== null && typeof object === 'object' && object.constructor === Object\n  }\n\n  Tools.prototype.isNode = function (object) {\n    return typeof window.Node === 'object'\n      ? object instanceof window.Node\n      : object && typeof object === 'object' &&\n        typeof object.nodeType === 'number' &&\n        typeof object.nodeName === 'string'\n  }\n\n  Tools.prototype.isNodeList = function (object) {\n    var prototypeToString = Object.prototype.toString.call(object)\n    var regex = /^\\[object (HTMLCollection|NodeList|Object)\\]$/\n\n    return typeof window.NodeList === 'object'\n      ? object instanceof window.NodeList\n      : object && typeof object === 'object' &&\n        regex.test(prototypeToString) &&\n        typeof object.length === 'number' &&\n        (object.length === 0 || this.isNode(object[0]))\n  }\n\n  Tools.prototype.forOwn = function (object, callback) {\n    if (!this.isObject(object)) {\n      throw new TypeError('Expected \"object\", but received \"' + typeof object + '\".')\n    } else {\n      for (var property in object) {\n        if (object.hasOwnProperty(property)) {\n          callback(property)\n        }\n      }\n    }\n  }\n\n  Tools.prototype.extend = function (target, source) {\n    this.forOwn(source, function (property) {\n      if (this.isObject(source[property])) {\n        if (!target[property] || !this.isObject(target[property])) {\n          target[property] = {}\n        }\n        this.extend(target[property], source[property])\n      } else {\n        target[property] = source[property]\n      }\n    }.bind(this))\n    return target\n  }\n\n  Tools.prototype.extendClone = function (target, source) {\n    return this.extend(this.extend({}, target), source)\n  }\n\n  Tools.prototype.isMobile = function () {\n    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)\n  }\n\n  /**\n   * Polyfills\n   * --------\n   */\n\n  _requestAnimationFrame = window.requestAnimationFrame ||\n    window.webkitRequestAnimationFrame ||\n    window.mozRequestAnimationFrame ||\n    function (callback) {\n      window.setTimeout(callback, 1000 / 60)\n    }\n\n  /**\n   * Module Wrapper\n   * --------------\n   */\n  if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n    define(function () {\n      return ScrollReveal\n    })\n  } else if (typeof module !== 'undefined' && module.exports) {\n    module.exports = ScrollReveal\n  } else {\n    window.ScrollReveal = ScrollReveal\n  }\n})();\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/scrollreveal/dist/scrollreveal.js"],"sourceRoot":""}