{"version":3,"sources":["webpack:///src/vendors.3cf7aefbf5d07021599c.js","webpack:///webpack/bootstrap 3cf7aefbf5d07021599c","webpack:///./node_modules/moment/locale/ru.js","webpack:///./node_modules/superagent/lib/is-object.js","webpack:///./node_modules/vue-router/dist/vue-router.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/style-loader/lib/addStyles.js","webpack:///./node_modules/raven-js/src/singleton.js","webpack:///./node_modules/moment/moment.js","webpack:///./node_modules/raven-js/src/utils.js","webpack:///./node_modules/lodash.invert/index.js","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/superagent/lib/client.js","webpack:///./node_modules/superagent-prefix/index.js","webpack:///./node_modules/superagent-use/index.js","webpack:///./node_modules/vue/dist/vue.esm.js","webpack:///./node_modules/vue-the-mask/dist/vue-the-mask.js","webpack:///./node_modules/vuex/dist/vuex.esm.js","webpack:///./src/styles.js","webpack:///./node_modules/css-loader/lib/css-base.js","webpack:///./node_modules/style-loader/lib/urls.js","webpack:///./src/styles/favicon.ico","webpack:///./node_modules/raven-js/src/raven.js","webpack:///./node_modules/raven-js/vendor/TraceKit/tracekit.js","webpack:///./node_modules/raven-js/vendor/json-stringify-safe/stringify.js","webpack:///./node_modules/raven-js/src/configError.js","webpack:///./node_modules/raven-js/src/console.js","webpack:///./node_modules/moment/locale ru","webpack:///./node_modules/component-emitter/index.js","webpack:///./node_modules/superagent/lib/request-base.js","webpack:///./node_modules/superagent/lib/is-function.js","webpack:///./node_modules/superagent/lib/response-base.js","webpack:///./node_modules/superagent/lib/utils.js","webpack:///./node_modules/superagent/lib/should-retry.js","webpack:///./node_modules/methods/index.js","webpack:///./node_modules/extend/index.js","webpack:///./node_modules/js-cookie/src/js.cookie.js","webpack:///./node_modules/lodash.camelcase/index.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","parentJsonpFunction","window","chunkIds","moreModules","executeModules","chunkId","result","resolves","length","installedChunks","push","Object","prototype","hasOwnProperty","shift","s","1","e","onScriptComplete","script","onerror","onload","clearTimeout","timeout","chunk","Error","undefined","installedChunkData","Promise","resolve","promise","reject","head","document","getElementsByTagName","createElement","type","charset","async","nc","setAttribute","src","p","setTimeout","appendChild","m","c","d","name","getter","o","defineProperty","configurable","enumerable","get","n","__esModule","object","property","oe","err","100","global","factory","this","moment","plural","word","num","forms","split","relativeTimeWithPlural","number","withoutSuffix","key","format","monthsParse","defineLocale","months","standalone","monthsShort","weekdays","isFormat","weekdaysShort","weekdaysMin","longMonthsParse","shortMonthsParse","monthsRegex","monthsShortRegex","monthsStrictRegex","monthsShortStrictRegex","longDateFormat","LT","LTS","L","LL","LLL","LLLL","calendar","sameDay","nextDay","lastDay","nextWeek","now","week","day","lastWeek","sameElse","relativeTime","future","past","mm","h","hh","dd","M","MM","y","yy","meridiemParse","isPM","input","test","meridiem","hour","minute","isLower","dayOfMonthOrdinalParse","ordinal","period","dow","doy","101","isObject","obj","102","assert","condition","message","warn","isError","toString","indexOf","resolveProps","route","config","params","resolveQuery","query","extraQuery","_parseQuery","parsedQuery","parse","parseQuery","val","Array","isArray","slice","res","trim","replace","forEach","param","parts","decode","join","stringifyQuery","keys","map","encode","val2","filter","x","createRoute","record","location","redirectedFrom","router","stringifyQuery$$1","options","meta","path","hash","fullPath","getFullPath","matched","formatMatch","freeze","unshift","parent","ref","_stringifyQuery","stringify","isSameRoute","a","b","START","trailingSlashRE","isObjectEqual","aKeys","bKeys","every","aVal","bVal","String","isIncludedRoute","current","target","queryIncludes","guardEvent","metaKey","altKey","ctrlKey","shiftKey","defaultPrevented","button","currentTarget","getAttribute","preventDefault","findAnchor","children","child","tag","install","Vue","installed","_Vue","isDef","v","registerInstance","vm","callVal","$options","_parentVnode","data","registerRouteInstance","mixin","beforeCreate","_routerRoot","_router","init","util","defineReactive","history","$parent","destroyed","_route","component","View","Link","strats","optionMergeStrategies","beforeRouteEnter","beforeRouteLeave","beforeRouteUpdate","created","resolvePath","relative","base","append","firstChar","charAt","stack","pop","segments","segment","parsePath","hashIndex","queryIndex","cleanPath","str","tokens","index","defaultDelimiter","delimiter","PATH_REGEXP","exec","escaped","offset","next","prefix","capture","group","modifier","asterisk","partial","repeat","optional","pattern","escapeGroup","escapeString","substr","compile","tokensToFunction","encodeURIComponentPretty","encodeURI","charCodeAt","toUpperCase","encodeAsterisk","matches","RegExp","opts","pretty","encodeURIComponent","token","value","TypeError","index$1","JSON","j","attachKeys","re","flags","sensitive","regexpToRegexp","groups","source","match","arrayToRegexp","pathToRegexp","stringToRegexp","tokensToRegExp","strict","end","endsWithDelimiter","fillParams","routeMsg","regexpCompileCache","createRouteMap","routes","oldPathList","oldPathMap","oldNameMap","pathList","pathMap","create","nameMap","addRouteRecord","splice","matchAs","normalizedPath","normalizePath","pathToRegexpOptions","caseSensitive","regex","compileRouteRegex","components","default","instances","redirect","beforeEnter","props","some","childMatchAs","alias","aliasRoute","normalizeLocation","raw","_normalized","assign","rawPath","parsedPath","basePath","createMatcher","addRoutes","currentRoute","_createRoute","paramNames","record$1","matchRoute","originalRedirect","resolveRecordPath","aliasedPath","aliasedMatch","aliasedRecord","len","decodeURIComponent","setupScroll","addEventListener","saveScrollPosition","state","setStateKey","handleScroll","to","from","isPop","app","behavior","scrollBehavior","$nextTick","position","getScrollPosition","shouldScroll","selector","el","querySelector","normalizeOffset","getElementPosition","isValidPosition","normalizePosition","scrollTo","getStateKey","positionStore","pageXOffset","pageYOffset","docEl","documentElement","docRect","getBoundingClientRect","elRect","left","top","isNumber","genKey","Time","toFixed","_key","pushState","url","replaceState","runQueue","queue","fn","cb","step","resolveAsyncComponents","hasAsync","pending","error","flatMapComponents","def","_","cid","once","resolvedDef","resolved","extend","reason","msg","then","comp","flatten","arr","concat","apply","called","args","arguments","normalizeBase","inBrowser","baseEl","resolveQueue","max","Math","updated","activated","deactivated","extractGuards","records","bind","reverse","guards","instance","guard","extractGuard","extractLeaveGuards","bindGuard","extractUpdateHooks","extractEnterGuards","cbs","isValid","bindEnterGuard","poll","getLocation","pathname","search","checkFallback","ensureSlash","getHash","replaceHash","href","pushHash","registerHook","list","createHref","mode","functional","render","routerView","$createElement","$route","cache","_routerViewCache","depth","inactive","$vnode","_inactive","routerViewDepth","hook","prepatch","vnode","componentInstance","encodeReserveRE","encodeReserveReplacer","commaRE","toTypes","eventTypes","required","exact","Boolean","activeClass","exactActiveClass","event","this$1","$router","classes","globalActiveClass","linkActiveClass","globalExactActiveClass","linkExactActiveClass","activeClassFallback","exactActiveClassFallback","compareTarget","handler","on","click","class","attrs","$slots","isStatic","parse_1","compile_1","tokensToFunction_1","tokensToRegExp_1","supportsPushState","ua","navigator","userAgent","performance","Date","History","ready","readyCbs","readyErrorCbs","errorCbs","listen","onReady","errorCb","onError","transitionTo","onComplete","onAbort","confirmTransition","updateRoute","ensureURL","abort","beforeHooks","iterator","postEnterCbs","resolveHooks","prev","afterHooks","HTML5History","History$$1","expectScroll","__proto__","constructor","go","fromRoute","getCurrentLocation","HashHistory","fallback","setupListeners","AbstractHistory","targetIndex","VueRouter","apps","matcher","prototypeAccessors","setupHashListener","beforeEach","beforeResolve","afterEach","back","forward","getMatchedComponents","normalizedTo","defineProperties","version","use","11","g","Function","eval","1171","addStylesToDom","styles","item","domStyle","stylesInDom","id","refs","addStyle","listToStyles","newStyles","css","media","sourceMap","part","insertStyleElement","style","getElement","insertInto","lastStyleElementInsertedAtTop","stylesInsertedAtTop","insertAt","nextSibling","insertBefore","firstChild","removeStyleElement","parentNode","removeChild","idx","createStyleElement","addAttrs","createLinkElement","link","rel","update","remove","transform","singleton","styleIndex","singletonCounter","applyToSingletonTag","URL","createObjectURL","revokeObjectURL","Blob","btoa","updateLink","applyToTag","newObj","styleSheet","cssText","replaceText","cssNode","createTextNode","childNodes","autoFixUrls","convertToAbsoluteUrls","fixUrls","unescape","blob","oldSrc","isOldIE","memo","all","atob","DEBUG","newList","mayRemove","textStore","replacement","139","RavenConstructor","_window","self","_Raven","Raven","noConflict","afterLoad","14","hooks","hookCallback","isObjectEmpty","k","isUndefined","isDate","hasOwnProp","valueOf","createUTC","locale","createLocalOrUTC","utc","defaultParsingFlags","empty","unusedTokens","unusedInput","overflow","charsLeftOver","nullInput","invalidMonth","invalidFormat","userInvalidated","iso","parsedDateParts","rfc2822","weekdayMismatch","getParsingFlags","_pf","_isValid","parsedParts","some$1","isNowValid","isNaN","_d","getTime","invalidWeekday","_strict","bigHour","isFrozen","createInvalid","NaN","copyConfig","prop","_isAMomentObject","_i","_f","_l","_tzm","_isUTC","_offset","_locale","momentProperties","Moment","updateInProgress","updateOffset","isMoment","absFloor","ceil","floor","toInt","argumentForCoercion","coercedNumber","isFinite","compareArrays","array1","array2","dontConvert","min","lengthDiff","abs","diffs","suppressDeprecationWarnings","console","deprecate","firstTime","deprecationHandler","arg","deprecateSimple","deprecations","isFunction","set","_config","_dayOfMonthOrdinalParseLenient","_dayOfMonthOrdinalParse","_ordinalParse","mergeConfigs","parentConfig","childConfig","Locale","mom","output","_calendar","_longDateFormat","formatUpper","invalidDate","_invalidDate","_ordinal","string","isFuture","_relativeTime","pastFuture","diff","addUnitAlias","unit","shorthand","lowerCase","toLowerCase","aliases","normalizeUnits","units","normalizeObjectUnits","inputObject","normalizedProp","normalizedInput","addUnitPriority","priority","priorities","getPrioritizedUnits","unitsObj","u","sort","makeGetSet","keepTime","set$1","stringGet","stringSet","prioritized","zeroFill","targetLength","forceSign","absNumber","zerosToFill","pow","addFormatToken","padded","callback","func","formatTokenFunctions","localeData","removeFormattingTokens","makeFormatFunction","array","formattingTokens","formatMoment","expandFormat","formatFunctions","replaceLongDateFormatTokens","localFormattingTokens","lastIndex","addRegexToken","strictRegex","regexes","isStrict","getParseRegexForToken","unescapeFormat","regexEscape","p1","p2","p3","p4","addParseToken","addWeekParseToken","_w","addTimeToArrayFromToken","_a","daysInMonth","year","month","UTC","getUTCDate","localeMonths","_months","MONTHS_IN_FORMAT","localeMonthsShort","_monthsShort","handleStrictParse","monthName","ii","llc","toLocaleLowerCase","_monthsParse","_longMonthsParse","_shortMonthsParse","indexOf$1","localeMonthsParse","_monthsParseExact","setMonth","dayOfMonth","date","getSetMonth","getDaysInMonth","computeMonthsParse","_monthsShortStrictRegex","_monthsShortRegex","defaultMonthsShortRegex","_monthsStrictRegex","_monthsRegex","defaultMonthsRegex","cmpLenRev","shortPieces","longPieces","mixedPieces","daysInYear","isLeapYear","getIsLeapYear","createDate","ms","getFullYear","setFullYear","createUTCDate","getUTCFullYear","setUTCFullYear","firstWeekOffset","fwd","getUTCDay","dayOfYearFromWeeks","weekday","resYear","resDayOfYear","localWeekday","weekOffset","dayOfYear","weekOfYear","resWeek","weeksInYear","weekOffsetNext","localeWeek","_week","localeFirstDayOfWeek","localeFirstDayOfYear","getSetWeek","add","getSetISOWeek","parseWeekday","weekdaysParse","parseInt","parseIsoWeekday","localeWeekdays","_weekdays","localeWeekdaysShort","_weekdaysShort","localeWeekdaysMin","_weekdaysMin","handleStrictParse$1","weekdayName","_weekdaysParse","_shortWeekdaysParse","_minWeekdaysParse","localeWeekdaysParse","_weekdaysParseExact","_fullWeekdaysParse","getSetDayOfWeek","getDay","getSetLocaleDayOfWeek","getSetISODayOfWeek","weekdaysRegex","computeWeekdaysParse","_weekdaysStrictRegex","_weekdaysRegex","defaultWeekdaysRegex","weekdaysShortRegex","_weekdaysShortStrictRegex","_weekdaysShortRegex","defaultWeekdaysShortRegex","weekdaysMinRegex","_weekdaysMinStrictRegex","_weekdaysMinRegex","defaultWeekdaysMinRegex","minp","shortp","longp","minPieces","hFormat","hours","kFormat","lowercase","minutes","matchMeridiem","_meridiemParse","localeIsPM","localeMeridiem","normalizeLocale","chooseLocale","names","loadLocale","oldLocale","locales","globalLocale","_abbr","getSetGlobalLocale","values","getLocale","baseConfig","abbr","parentLocale","localeFamilies","updateLocale","listLocales","keys$1","checkOverflow","MONTH","DATE","YEAR","HOUR","MINUTE","SECOND","MILLISECOND","_overflowDayOfYear","_overflowWeeks","WEEK","_overflowWeekday","WEEKDAY","configFromISO","allowTime","dateFormat","timeFormat","tzFormat","extendedIsoRegex","basicIsoRegex","isoDates","isoTimes","tzRegex","configFromStringAndFormat","configFromRFC2822","dayFormat","timezone","timezoneIndex","timezones","military","basicRfcRegex","momentDate","momentDay","configFromString","aspNetJsonRegex","createFromInputFallback","defaults","currentDateArray","nowValue","_useUTC","getUTCMonth","getMonth","getDate","configFromArray","currentDate","yearToUse","dayOfYearFromWeekInfo","_dayOfYear","_nextDay","setUTCMinutes","getUTCMinutes","w","weekYear","temp","weekdayOverflow","GG","W","E","createLocal","curWeek","gg","ISO_8601","RFC_2822","parsedInput","skipped","stringLength","totalParsedInputLength","_meridiem","meridiemFixWrap","isPm","meridiemHour","configFromStringAndArray","tempConfig","bestMoment","scoreToBeat","currentScore","score","configFromObject","second","millisecond","createFromConfig","prepareConfig","preparse","configFromInput","isUTC","pickBy","moments","isDurationValid","ordering","unitHasDecimal","parseFloat","isValid$1","createInvalid$1","createDuration","Duration","duration","years","quarters","quarter","weeks","days","seconds","milliseconds","_milliseconds","_days","_data","_bubble","isDuration","absRound","round","separator","utcOffset","sign","offsetFromString","chunkOffset","cloneWithOffset","model","clone","setTime","local","getDateOffset","getTimezoneOffset","getSetOffset","keepLocalTime","keepMinutes","localAdjust","matchShortOffset","_changeInProgress","addSubtract","getSetZone","setOffsetToUTC","setOffsetToLocal","subtract","setOffsetToParsedOffset","tZone","matchOffset","hasAlignedHourOffset","isDaylightSavingTime","isDaylightSavingTimeShifted","_isDSTShifted","other","toArray","isLocal","isUtcOffset","isUtc","ret","diffRes","aspNetRegex","isoRegex","parseIso","momentsDifference","inp","positiveMomentsDifference","isAfter","isBefore","createAdder","direction","dur","tmp","isAdding","getCalendarFormat","myMoment","calendar$1","time","formats","sod","startOf","calendarFormat","localInput","endOf","isBetween","inclusivity","isSame","inputMs","isSameOrAfter","isSameOrBefore","asFloat","that","zoneDelta","delta","monthDiff","anchor2","adjust","wholeMonthDiff","anchor","toISOString","toDate","inspect","zone","suffix","inputString","defaultFormatUtc","defaultFormat","postformat","humanize","fromNow","toNow","newLocaleData","isoWeekday","unix","toObject","toJSON","isValid$2","parsingFlags","invalidAt","creationData","addWeekYearFormatToken","getSetWeekYear","getSetWeekYearHelper","getSetISOWeekYear","isoWeek","getISOWeeksInYear","getWeeksInYear","weekInfo","weeksTarget","setWeekAll","dayOfYearData","getSetQuarter","getSetDayOfYear","parseMs","getZoneAbbr","getZoneName","createUnix","createInZone","parseZone","preParsePostFormat","get$1","field","setter","listMonthsImpl","out","listWeekdaysImpl","localeSorted","listMonths","listMonthsShort","listWeekdays","listWeekdaysShort","listWeekdaysMin","mathAbs","addSubtract$1","add$1","subtract$1","absCeil","bubble","monthsFromDays","monthsToDays","daysToMonths","as","valueOf$1","makeAs","get$2","makeGetter","substituteTimeAgo","relativeTime$1","posNegDuration","thresholds","ss","getSetRelativeTimeRounding","roundingFunction","getSetRelativeTimeThreshold","threshold","limit","withSuffix","toISOString$1","abs$1","Y","D","total","asSeconds","fun","t","defaultCalendar","defaultLongDateFormat","defaultDayOfMonthOrdinalParse","defaultRelativeTime","match1","match2","match3","match4","match6","match1to2","match3to4","match5to6","match1to3","match1to4","match1to6","matchUnsigned","matchSigned","matchTimestamp","matchWord","defaultLocaleMonths","defaultLocaleMonthsShort","parseTwoDigitYear","getSetYear","defaultLocaleWeek","defaultLocaleWeekdays","defaultLocaleWeekdaysShort","defaultLocaleWeekdaysMin","kInput","_isPm","pos","pos1","pos2","defaultLocaleMeridiemParse","getSetHour","prototypeMin","prototypeMax","invalid","lang","isoWeekYear","getSetDayOfMonth","getSetMinute","getSetSecond","getSetMillisecond","proto","isoWeeks","isoWeeksInYear","isDST","zoneAbbr","zoneName","dates","isDSTShifted","proto$1","firstDayOfYear","firstDayOfWeek","langData","asMilliseconds","asMinutes","asHours","asDays","asWeeks","asMonths","asYears","proto$2","toIsoString","relativeTimeRounding","relativeTimeThreshold","140","what","wrappedCallback","dataCallback","original","normalizedData","141","baseTimes","iteratee","arrayLikeKeys","inherited","isArguments","skipIndexes","isIndex","baseForOwn","baseFor","baseInverter","accumulator","baseKeys","isPrototype","nativeKeys","MAX_SAFE_INTEGER","reIsUint","Ctor","objectProto","isArrayLikeObject","propertyIsEnumerable","objectToString","argsTag","isArrayLike","isLength","isObjectLike","funcTag","genTag","identity","fromRight","keysFunc","iterable","invert","toIteratee","142","webpackPolyfill","paths","143","noop","serialize","pairs","pushEncodedKeyValuePair","subkey","parseString","pair","parseHeader","line","lines","fields","isJSON","mime","Response","req","xhr","text","method","responseType","responseText","statusText","status","_setStatusProperties","header","headers","getAllResponseHeaders","getResponseHeader","_setHeaderProperties","_responseType","body","response","_parseBody","Request","_query","_header","rawResponse","statusCode","emit","new_err","_isResponseOK","del","request","send","root","Emitter","RequestBase","ResponseBase","shouldRetry","getXHR","XMLHttpRequest","protocol","ActiveXObject","serializeObject","types","html","json","xml","urlencoded","_parser","toError","accept","auth","user","pass","username","password","attach","file","_getFormData","_formData","FormData","_maxRetries","_retries","_retry","_callback","retries","crossDomainError","crossDomain","buffer","ca","agent","pipe","write","_appendQueryString","_sort","queryArr","substring","_isHost","_endCalled","_end","_setTimeouts","onreadystatechange","readyState","_responseTimeoutTimer","timedout","_aborted","handleProgress","percent","loaded","hasListeners","onprogress","upload","open","_withCredentials","withCredentials","contentType","_serializer","setRequestHeader","patch","post","put","144","145","methods","_superagent","superagent","uses","146","__webpack_exports__","isUndef","isTrue","isFalse","isPrimitive","isPlainObject","_toString","isRegExp","isValidArrayIndex","toNumber","makeMap","expectsLowerCase","hasOwn","cached","ctx","boundFn","_length","start","_from","looseEqual","isObjectA","isObjectB","isArrayA","isArrayB","keysA","keysB","looseIndexOf","isReserved","writable","bailRE","handleError","info","errorHandler","isNative","pushTarget","_target","Dep","targetStack","popTarget","protoAugment","copyAugment","observe","asRootData","ob","__ob__","Observer","observerState","shouldConvert","isServerRendering","isExtensible","_isVue","vmCount","defineReactive$$1","customSetter","shallow","dep","getOwnPropertyDescriptor","childOb","depend","dependArray","newVal","notify","mergeData","toVal","fromVal","mergeDataOrFn","parentVal","childVal","instanceData","defaultData","mergeHook","mergeAssets","normalizeProps","camelize","normalizeInject","inject","normalized","normalizeDirectives","dirs","directives","mergeOptions","mergeField","strat","defaultStrat","extendsFrom","extends","mixins","resolveAsset","warnMissing","assets","camelizedId","PascalCaseId","capitalize","validateProp","propOptions","propsData","absent","isType","hyphenate","getPropDefaultValue","prevShouldConvert","_props","getType","createTextVNode","VNode","cloneVNode","cloned","elm","context","componentOptions","asyncFactory","ns","isComment","isCloned","cloneVNodes","vnodes","createFnInvoker","fns","invoker","arguments$1","updateListeners","oldOn","remove$$1","cur","old","normalizeEvent","passive","mergeVNodeHook","hookKey","wrappedHook","oldHook","merged","extractPropsFromVNodeData","checkProp","preserve","simpleNormalizeChildren","normalizeChildren","normalizeArrayChildren","isTextNode","node","nestedIndex","last","_isVList","ensureCtor","createAsyncPlaceholder","createEmptyVNode","asyncMeta","resolveAsyncComponent","baseCtor","errorComp","loading","loadingComp","contexts","sync","forceRender","$forceUpdate","delay","getFirstComponentChild","initEvents","_events","_hasHookEvent","listeners","_parentListeners","updateComponentListeners","once$$1","$once","$on","remove$1","$off","oldListeners","resolveSlots","slots","defaultSlot","functionalContext","slot","isWhitespace","resolveScopedSlots","initLifecycle","abstract","$children","$root","$refs","_watcher","_directInactive","_isMounted","_isDestroyed","_isBeingDestroyed","mountComponent","hydrating","$el","callHook","updateComponent","_update","_render","Watcher","updateChildComponent","parentVnode","renderChildren","hasChildren","_renderChildren","scopedSlots","$scopedSlots","emptyObject","_vnode","$attrs","$listeners","propKeys","_propKeys","isInInactiveTree","activateChildComponent","direct","deactivateChildComponent","handlers","$emit","resetSchedulerState","activatedChildren","has","waiting","flushing","flushSchedulerQueue","watcher","run","activatedQueue","updatedQueue","callActivatedHooks","callUpdatedHooks","devtools","queueActivatedComponent","queueWatcher","nextTick","traverse","seenObjects","clear","_traverse","seen","isA","depId","proxy","sourceKey","sharedPropertyDefinition","initState","_watchers","initProps","initMethods","initData","computed","initComputed","watch","nativeWatch","initWatch","propsOptions","isRoot","getData","watchers","_computedWatchers","userDef","computedWatcherOptions","defineComputed","createComputedGetter","dirty","evaluate","createWatcher","keyOrFn","$watch","initProvide","provide","_provided","initInjections","resolveInject","hasSymbol","Reflect","ownKeys","provideKey","createFunctionalComponent","mergeProps","_context","injections","functionalOptions","createComponent","_base","resolveConstructorOptions","transformModel","nativeOn","mergeHooks","createComponentInstanceForVnode","parentElm","refElm","vnodeComponentOptions","_isComponent","_componentTag","_parentElm","_refElm","inlineTemplate","staticRenderFns","hooksToMerge","fromParent","ours","componentVNodeHooks","mergeHook$1","one","two","normalizationType","alwaysNormalize","ALWAYS_NORMALIZE","_createElement","is","SIMPLE_NORMALIZE","getTagNamespace","isReservedTag","parsePlatformTagName","applyNS","renderList","renderSlot","bindObject","scopedSlotFn","slotNodes","resolveFilter","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","parentData","initInternalComponent","super","superOptions","modifiedOptions","resolveModifiedOptions","extendOptions","modified","latest","extended","sealed","sealedOptions","dedupe","Vue$3","_init","initUse","plugin","installedPlugins","_installedPlugins","initMixin$1","initExtend","Super","SuperId","cachedCtors","_Ctor","Sub","initProps$1","initComputed$1","ASSET_TYPES","Comp","initAssetRegisters","definition","getComponentName","pruneCache","cachedNode","pruneCacheEntry","$destroy","genClassForVnode","childNode","mergeClassData","renderClass","staticClass","dynamicClass","stringifyClass","stringifyArray","stringifyObject","stringified","isSVG","isUnknownElement","unknownElementCache","HTMLUnknownElement","HTMLElement","selected","createElement$1","tagName","multiple","createElementNS","namespace","namespaceMap","createComment","newNode","referenceNode","setTextContent","textContent","registerRef","isRemoval","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","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","expression","inSingle","inDouble","inTemplateString","inRegex","curly","square","paren","validDivisionCharRE","wrapFilter","baseWarn","pluckModuleFunction","addProp","addAttr","addDirective","addHandler","important","events","native","nativeEvents","newHandler","getBindingAttr","getStatic","dynamicValue","getAndRemoveAttr","staticValue","attrsMap","attrsList","genComponentModel","valueExpression","assignment","genAssignmentCode","modelRs","parseModel","expressionPos","expressionEndPos","lastIndexOf","eof","chr","isStringStart","parseBracket","inBracket","stringQuote","_warn","warn$1","genSelect","genCheckboxModel","genRadioModel","genDefaultModel","valueBinding","trueValueBinding","falseValueBinding","CHECKBOX_RADIO_TOKEN","selectedVal","code","lazy","needCompositionGuard","RANGE_TOKEN","normalizeEvents","isIE","isChrome","oldHandler","target$1","ev","remove$2","supportsPassive","removeEventListener","updateDOMListeners","updateDOMProps","oldProps","_value","strCur","shouldUpdateValue","checkVal","composing","isDirty","isInputChanged","notInFocus","activeElement","_vModifiers","normalizeStyleData","normalizeStyleBinding","staticStyle","bindingStyle","parseStyleText","getStyle","checkChild","styleData","updateStyle","oldStaticStyle","oldStyleBinding","normalizedStyle","oldStyle","newStyle","setProp","addClass","classList","removeClass","tar","resolveTransition","def$$1","autoCssTransition","nextFrame","raf","addTransitionClass","transitionClasses","removeTransitionClass","whenTransitionEnds","expectedType","getTransitionInfo","propCount","TRANSITION","transitionEndEvent","animationEndEvent","ended","onEnd","getComputedStyle","transitionDelays","transitionProp","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationProp","animationDurations","animationTimeout","ANIMATION","hasTransform","transformRE","delays","durations","toMs","enter","toggleDisplay","_leaveCb","cancelled","transition","_enterCb","nodeType","enterClass","enterToClass","enterActiveClass","appearClass","appearToClass","appearActiveClass","afterEnter","enterCancelled","beforeAppear","appear","afterAppear","appearCancelled","activeInstance","transitionNode","isAppear","isRootInsert","startClass","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","applyTranslation","oldPos","dx","dy","moved","WebkitTransform","transitionDuration","parseText","delimiters","tagRE","buildRegex","defaultTagRE","transformNode","classBinding","genData","transformNode$1","styleBinding","genData$1","decodeAttr","shouldDecodeNewlines","encodedAttrWithNewLines","encodedAttr","decodingMap","parseHTML","advance","parseEndTag","lowerCasedTagName","lowerCasedTag","lastTag","expectHTML","isUnaryTag$$1","isUnaryTag","no","canBeLeftOpenTag$$1","canBeLeftOpenTag","isPlainTextElement","endTagLength","stackedTag","reStackedTag","reCache","rest$1","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","template","endPre","element","pre","inVPre","platformIsPreTag","inPre","warn$2","isPreTag","platformMustUseProp","platformGetTagNamespace","transforms","preTransforms","postTransforms","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","iteratorMatch","forIteratorRE","iterator1","iterator2","findPrevElement","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","wrapListeners","bind$1","wrapData","generate","ast","CodegenState","genElement","staticProcessed","genStatic","onceProcessed","genOnce","forProcessed","genFor","ifProcessed","genIf","genSlot","genComponent","genData$2","genChildren","onceId","altGen","altEmpty","genIfConditions","conditions","genTernaryExp","altHelper","genDirectives","dataGenFns","genProps","genScopedSlots","genInlineTemplate","needRuntime","hasRuntime","gen","inlineRenderFns","genScopedSlot","genForScopedSlot","scope","checkSkip","altGenElement","altGenNode","el$1","getNormalizationType","maybeComponent","genNode","needsNormalization","genComment","genText","transformSpecialNewlines","bind$$1","componentName","createFunction","errors","createCompileToFunctionFn","compiled","fnGenErrors","getOuterHTML","outerHTML","container","cloneNode","innerHTML","camelizeRE","hyphenateRE","SSR_ATTR","LIFECYCLE_HOOKS","silent","productionTip","warnHandler","ignoredElements","isReservedAttr","_lifecycleHooks","hasProto","UA","isEdge","isAndroid","isIOS","_isServer","_Set","env","VUE_ENV","__VUE_DEVTOOLS_GLOBAL_HOOK__","Symbol","nextTickHandler","copies","callbacks","timerFunc","logError","catch","MutationObserver","counter","observer","textNode","characterData","_resolve","Set","uid","subs","addSub","sub","removeSub","addDep","arrayProto","arrayMethods","observeArray","arrayKeys","getOwnPropertyNames","walk","items","uid$2","expOrFn","deep","active","deps","newDeps","depIds","newDepIds","cleanupDeps","teardown","$mount","keepAlive","mountedNode","insert","destroy","uid$1","_uid","_self","dataDef","propsDef","$set","$delete","immediate","hookRE","prevEl","prevVnode","prevActiveInstance","__patch__","__vue__","_o","_n","_s","_t","_q","_m","_k","_b","_v","_e","_u","_g","patternTypes","KeepAlive","include","exclude","builtInComponents","configDef","delete","ssrContext","emptyStyle","acceptValue","svg","math","isHTMLTag","nodeOps","baseModules","klass","listDelimiter","propertyDelimiter","cssVarRE","importantRE","setProperty","normalizedName","normalize","vendorNames","capName","hasTransition","ontransitionend","onwebkittransitionend","onanimationend","onwebkitanimationend","requestAnimationFrame","activate","platformModules","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","isRenderedModule","isInitialPatch","isRealElement","hasAttribute","oldElm","parentElm$1","isTextInputType","vmodel","model$1","_vOptions","prevOptions","transition$$1","originalDisplay","__vOriginalDisplay","display","unbind","platformDirectives","transitionProps","Number","Transition","_leaving","oldRawChild","delayedLeave","moveClass","TransitionGroup","prevChildren","rawChildren","transitionData","kept","removed","c$1","beforeUpdate","hasMove","offsetHeight","propertyName","_hasMove","platformComponents","decoder","content","encoded","div","regexEscapeRE","close","klass$1","style$1","modules$1","directives$1","baseOptions","reduce","he","singleAttrIdentifier","singleAttrAssign","singleAttrValues","ncname","qnameCapture","isIgnoreNewlineTag","esc","tab","space","up","right","down","genGuard","stop","prevent","ctrl","alt","middle","baseDirectives","cloak","createCompiler","baseCompile","finalOptions","tips","tip","compileToFunctions","ref$1","idToTemplate","mount","147","r","X","S","A","toLocaleUpperCase","escape","mask","oninput","isTrusted","selectionEnd","setSelectionRange","directive","masked","lastValue","refresh","onInput","f","esModule","2","devtoolPlugin","store","devtoolHook","_devtoolHook","targetState","subscribe","mutation","forEachValue","isPromise","targetModule","newModule","getChild","resetStore","hot","_actions","_mutations","_wrappedGetters","_modulesNamespaceMap","installModule","_modules","resetStoreVM","oldVm","_vm","getters","wrappedGetters","$$state","enableStrictMode","_withCommit","rootState","getNamespace","namespaced","parentState","getNestedState","moduleName","makeLocalContext","forEachMutation","registerMutation","forEachAction","action","registerAction","forEachGetter","registerGetter","forEachChild","noNamespace","dispatch","_type","_payload","_options","unifyObjectStyle","payload","commit","makeLocalGetters","gettersProxy","splitPos","localType","rootGetters","rawGetter","_committing","applyMixin","normalizeMap","normalizeNamespace","getModuleByNamespace","helper","vuexInit","$store","usesInit","Module","rawModule","runtime","_children","_rawModule","rawState","prototypeAccessors$1","addChild","actions","mutations","ModuleCollection","rawRootModule","register","rawChildModule","unregister","Store","plugins","_subscribers","_watcherVM","entry","registerModule","unregisterModule","hotUpdate","newOptions","committing","mapState","states","vuex","mapMutations","mapGetters","mapActions","index_esm","229","230","231","232","cssWithMappingToString","useSourceMap","cssMapping","sourceMapping","toComment","sources","sourceRoot","mediaQuery","alreadyImportedModules","233","baseUrl","host","currentDir","fullMatch","origUrl","unquotedOrigUrl","$1","newUrl","234","235","keepOriginalCallback","_hasJSON","_hasDocument","_document","_hasNavigator","_navigator","_lastCapturedException","_lastData","_lastEventId","_globalServer","_globalKey","_globalProject","_globalContext","_globalOptions","logger","ignoreErrors","ignoreUrls","whitelistUrls","includePaths","crossOrigin","collectWindowErrors","maxMessageLength","maxUrlLength","stackTraceLimit","autoBreadcrumbs","instrument","sampleRate","_ignoreOnError","_isRavenInstalled","_originalErrorStackTraceLimit","_originalConsole","_originalConsoleMethods","_plugins","_startTime","_wrappedBuiltIns","_breadcrumbs","_lastCapturedEvent","_keypressTimeout","_location","_lastHref","_resetBackoff","isString","objectPrototype","isEmptyObject","each","hasKey","objectMerge","obj1","obj2","objectFrozen","truncate","joinRegExp","patterns","urlencode","parseUrl","fragment","uuid4","crypto","msCrypto","getRandomValues","Uint16Array","pad","random","htmlTreeAsString","elem","nextStr","height","htmlElementAsString","className","attrWhitelist","isOnlyOneTruthy","isSameException","ex1","ex2","isSameStacktrace","stacktrace","stack1","stack2","frames1","frames","frames2","filename","lineno","colno","fill","track","orig","TraceKit","RavenConfigError","utils","wrapConsoleMethod","wrapMethod","dsnKeys","dsnPattern","VERSION","debug","dsn","_logDebug","globalOptions","setDSN","maxBreadcrumbs","autoBreadcrumbDefaults","dom","instrumentDefaults","tryCatch","isSetup","report","_handleOnErrorStackInfo","_instrumentTryCatch","_instrumentBreadcrumbs","_drainPlugins","uri","_parseDSN","lastSlash","_dsn","_globalSecret","_getGlobalServer","_globalEndpoint","wrap","_before","wrapped","_ignoreNextOnError","captureException","__raven__","__raven_wrapper__","__inner__","uninstall","_restoreBuiltIns","ex","captureMessage","trimHeadFrames","computeStackTrace","_handleStackInfo","fingerprint","_prepareFrames","_send","captureBreadcrumb","crumb","timestamp","breadcrumbCallback","addPlugin","pluginArgs","setUserContext","setExtraContext","extra","_mergeContext","setTagsContext","tags","clearContext","getContext","setEnvironment","environment","setRelease","release","setDataCallback","setBreadcrumbCallback","setShouldSendCallback","shouldSendCallback","setTransport","transport","lastException","lastEventId","ravenNotConfiguredError","RavenConfig","showReportDialog","eventId","qs","email","globalServer","_triggerEvent","eventType","evt","createEventObject","fireEvent","_breadcrumbEventHandler","evtName","category","_keypressEventHandler","isContentEditable","_captureUrlChange","parsedLoc","parsedTo","parsedFrom","wrapTimeFn","originalCallback","wrappedBuiltIns","eventTargets","secure","handleEvent","before","clickHandler","keypressHandler","wrapProp","xhrproto","origOpen","__raven_xhr","status_code","origSend","onreadystatechangeHandler","origFetch","fetchInput","fetchData","attachEvent","chrome","isChromePackagedApp","hasPushState","oldOnPopState","onpopstate","currentHref","origPushState","log","consoleMethodCallback","level","builtin","installer","allowSecretKey","port","stackInfo","_processException","frame","_normalizeFrame","in_app","column","fileurl","exception","culprit","_trimPacket","Referer","breadcrumbs","_trimBreadcrumbs","urlProp","urlProps","_getHttpData","httpData","referrer","_backoffDuration","_backoffStart","_shouldBackoff","_isRepeatData","_setBackoffState","retry","baseData","project","platform","serverName","server_name","_sendProcessedPayload","_getUuid","event_id","allowDuplicates","sentry_version","sentry_client","sentry_key","sentry_secret","_makeRequest","onSuccess","XDomainRequest","__DEV__","setUser","setReleaseContext","236","getLocationHref","_slice","UNKNOWN_FUNCTION","ERROR_TYPES_RE","installGlobalHandler","unsubscribe","unsubscribeAll","uninstallGlobalHandler","notifyHandlers","isWindowError","inner","traceKitWindowOnError","lineNo","colNo","lastExceptionStack","augmentStackTraceWithInitialElement","processLastException","_oldOnerrorHandler","_onErrorHandlerInstalled","_lastExceptionStack","_lastArgs","lastArgs","rethrow","incomplete","computeStackTraceFromStackProp","submatch","gecko","winjs","geckoEval","chromeEval","isEval","columnNumber","computeStackTraceByWalkingCallerChain","functionName","funcs","recursion","curr","caller","sourceURL","fileName","lineNumber","description","237","haystack","needle","replacer","spaces","cycleReplacer","serializer","thisPos","Infinity","getSerialize","238","239","originalConsoleLevel","originalConsole","sentryLevel","240","webpackContext","webpackContextResolve","241","_callbacks","off","removeListener","removeAllListeners","242","_timer","_timeout","_responseTimeout","deadline","count","_fullfilledPromise","innerResolve","innerReject","ok","_okCallback","getHeader","unset","redirects","_maxRedirects","isObj","sortQuery","_timeoutError","errno","243","244","ct","links","parseLinks","statusType","clientError","serverError","accepted","noContent","badRequest","unauthorized","notAcceptable","notFound","245","cleanHeader","shouldStripCookie","246","ERROR_CODES","247","http","METHODS","248","249","toStr","gOPD","hasOwnConstructor","hasIsPrototypeOf","newValue","getProperty","copy","copyIsArray","67","registeredInModuleLoader","OldCookies","Cookies","api","attributes","converter","expires","setMilliseconds","getMilliseconds","toUTCString","stringifiedAttributes","attributeName","cookie","cookies","rdecode","read","getJSON","withConverter","99","arrayReduce","initAccum","asciiToArray","asciiWords","reAsciiWord","hasUnicode","reHasUnicode","hasUnicodeWord","reHasUnicodeWord","stringToArray","unicodeToArray","reUnicode","unicodeWords","reUnicodeWord","baseSlice","baseToString","isSymbol","symbolToString","INFINITY","castSlice","symbolTag","upperFirst","deburr","reLatin","deburrLetter","reComboMark","words","rsCombo","rsFitz","reOptMod","rsModifier","rsSeq","reApos","deburredLetters","freeGlobal","freeSelf","symbolProto","camelCase","methodName","strSymbols","trailing"],"mappings":"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","file":"src/vendors.3cf7aefbf5d07021599c.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// install a JSONP callback for chunk loading\n/******/ \tvar parentJsonpFunction = window[\"webpackJsonp\"];\n/******/ \twindow[\"webpackJsonp\"] = function webpackJsonpCallback(chunkIds, moreModules, executeModules) {\n/******/ \t\t// add \"moreModules\" to the modules object,\n/******/ \t\t// then flag all \"chunkIds\" as loaded and fire callback\n/******/ \t\tvar moduleId, chunkId, i = 0, resolves = [], result;\n/******/ \t\tfor(;i < chunkIds.length; i++) {\n/******/ \t\t\tchunkId = chunkIds[i];\n/******/ \t\t\tif(installedChunks[chunkId]) {\n/******/ \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n/******/ \t\t\t}\n/******/ \t\t\tinstalledChunks[chunkId] = 0;\n/******/ \t\t}\n/******/ \t\tfor(moduleId in moreModules) {\n/******/ \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n/******/ \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n/******/ \t\t\t}\n/******/ \t\t}\n/******/ \t\tif(parentJsonpFunction) parentJsonpFunction(chunkIds, moreModules, executeModules);\n/******/ \t\twhile(resolves.length) {\n/******/ \t\t\tresolves.shift()();\n/******/ \t\t}\n/******/ \t\tif(executeModules) {\n/******/ \t\t\tfor(i=0; i < executeModules.length; i++) {\n/******/ \t\t\t\tresult = __webpack_require__(__webpack_require__.s = executeModules[i]);\n/******/ \t\t\t}\n/******/ \t\t}\n/******/ \t\treturn result;\n/******/ \t};\n/******/\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// objects to store loaded and loading chunks\n/******/ \tvar installedChunks = {\n/******/ \t\t1: 0\n/******/ \t};\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/******/ \t// This file contains only the entry chunk.\n/******/ \t// The chunk loading function for additional chunks\n/******/ \t__webpack_require__.e = function requireEnsure(chunkId) {\n/******/ \t\tvar installedChunkData = installedChunks[chunkId];\n/******/ \t\tif(installedChunkData === 0) {\n/******/ \t\t\treturn new Promise(function(resolve) { resolve(); });\n/******/ \t\t}\n/******/\n/******/ \t\t// a Promise means \"currently loading\".\n/******/ \t\tif(installedChunkData) {\n/******/ \t\t\treturn installedChunkData[2];\n/******/ \t\t}\n/******/\n/******/ \t\t// setup Promise in chunk cache\n/******/ \t\tvar promise = new Promise(function(resolve, reject) {\n/******/ \t\t\tinstalledChunkData = installedChunks[chunkId] = [resolve, reject];\n/******/ \t\t});\n/******/ \t\tinstalledChunkData[2] = promise;\n/******/\n/******/ \t\t// start chunk loading\n/******/ \t\tvar head = document.getElementsByTagName('head')[0];\n/******/ \t\tvar script = document.createElement('script');\n/******/ \t\tscript.type = 'text/javascript';\n/******/ \t\tscript.charset = 'utf-8';\n/******/ \t\tscript.async = true;\n/******/ \t\tscript.timeout = 120000;\n/******/\n/******/ \t\tif (__webpack_require__.nc) {\n/******/ \t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n/******/ \t\t}\n/******/ \t\tscript.src = __webpack_require__.p + \"src/\" + chunkId + \".\" + \"3cf7aefbf5d07021599c\" + \".js\";\n/******/ \t\tvar timeout = setTimeout(onScriptComplete, 120000);\n/******/ \t\tscript.onerror = script.onload = onScriptComplete;\n/******/ \t\tfunction onScriptComplete() {\n/******/ \t\t\t// avoid mem leaks in IE.\n/******/ \t\t\tscript.onerror = script.onload = null;\n/******/ \t\t\tclearTimeout(timeout);\n/******/ \t\t\tvar chunk = installedChunks[chunkId];\n/******/ \t\t\tif(chunk !== 0) {\n/******/ \t\t\t\tif(chunk) {\n/******/ \t\t\t\t\tchunk[1](new Error('Loading chunk ' + chunkId + ' failed.'));\n/******/ \t\t\t\t}\n/******/ \t\t\t\tinstalledChunks[chunkId] = undefined;\n/******/ \t\t\t}\n/******/ \t\t};\n/******/ \t\thead.appendChild(script);\n/******/\n/******/ \t\treturn promise;\n/******/ \t};\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 = \"/\";\n/******/\n/******/ \t// on error function for async loading\n/******/ \t__webpack_require__.oe = function(err) { console.error(err); throw err; };\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 229);\n/******/ })\n/************************************************************************/\n/******/ ({\n\n/***/ 100:\n/***/ (function(module, exports, __webpack_require__) {\n\n//! moment.js locale configuration\n//! locale : Russian [ru]\n//! author : Viktorminator : https://github.com/Viktorminator\n//! Author : Menelion Elensúle : https://github.com/Oire\n//! author : Коренберг Марк : https://github.com/socketpair\n\n;(function (global, factory) {\n    true ? factory(__webpack_require__(14)) :\n   typeof define === 'function' && define.amd ? define(['../moment'], factory) :\n   factory(global.moment)\n}(this, (function (moment) { 'use strict';\n\n\nfunction plural(word, num) {\n    var forms = word.split('_');\n    return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);\n}\nfunction relativeTimeWithPlural(number, withoutSuffix, key) {\n    var format = {\n        'mm': withoutSuffix ? 'минута_минуты_минут' : 'минуту_минуты_минут',\n        'hh': 'час_часа_часов',\n        'dd': 'день_дня_дней',\n        'MM': 'месяц_месяца_месяцев',\n        'yy': 'год_года_лет'\n    };\n    if (key === 'm') {\n        return withoutSuffix ? 'минута' : 'минуту';\n    }\n    else {\n        return number + ' ' + plural(format[key], +number);\n    }\n}\nvar monthsParse = [/^янв/i, /^фев/i, /^мар/i, /^апр/i, /^ма[йя]/i, /^июн/i, /^июл/i, /^авг/i, /^сен/i, /^окт/i, /^ноя/i, /^дек/i];\n\n// http://new.gramota.ru/spravka/rules/139-prop : § 103\n// Сокращения месяцев: http://new.gramota.ru/spravka/buro/search-answer?s=242637\n// CLDR data:          http://www.unicode.org/cldr/charts/28/summary/ru.html#1753\nvar ru = moment.defineLocale('ru', {\n    months : {\n        format: 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_'),\n        standalone: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_')\n    },\n    monthsShort : {\n        // по CLDR именно \"июл.\" и \"июн.\", но какой смысл менять букву на точку ?\n        format: 'янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.'.split('_'),\n        standalone: 'янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.'.split('_')\n    },\n    weekdays : {\n        standalone: 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split('_'),\n        format: 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split('_'),\n        isFormat: /\\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\\] ?dddd/\n    },\n    weekdaysShort : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),\n    weekdaysMin : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),\n    monthsParse : monthsParse,\n    longMonthsParse : monthsParse,\n    shortMonthsParse : monthsParse,\n\n    // полные названия с падежами, по три буквы, для некоторых, по 4 буквы, сокращения с точкой и без точки\n    monthsRegex: /^(январ[ья]|янв\\.?|феврал[ья]|февр?\\.?|марта?|мар\\.?|апрел[ья]|апр\\.?|ма[йя]|июн[ья]|июн\\.?|июл[ья]|июл\\.?|августа?|авг\\.?|сентябр[ья]|сент?\\.?|октябр[ья]|окт\\.?|ноябр[ья]|нояб?\\.?|декабр[ья]|дек\\.?)/i,\n\n    // копия предыдущего\n    monthsShortRegex: /^(январ[ья]|янв\\.?|феврал[ья]|февр?\\.?|марта?|мар\\.?|апрел[ья]|апр\\.?|ма[йя]|июн[ья]|июн\\.?|июл[ья]|июл\\.?|августа?|авг\\.?|сентябр[ья]|сент?\\.?|октябр[ья]|окт\\.?|ноябр[ья]|нояб?\\.?|декабр[ья]|дек\\.?)/i,\n\n    // полные названия с падежами\n    monthsStrictRegex: /^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,\n\n    // Выражение, которое соотвествует только сокращённым формам\n    monthsShortStrictRegex: /^(янв\\.|февр?\\.|мар[т.]|апр\\.|ма[яй]|июн[ья.]|июл[ья.]|авг\\.|сент?\\.|окт\\.|нояб?\\.|дек\\.)/i,\n    longDateFormat : {\n        LT : 'HH:mm',\n        LTS : 'HH:mm:ss',\n        L : 'DD.MM.YYYY',\n        LL : 'D MMMM YYYY г.',\n        LLL : 'D MMMM YYYY г., HH:mm',\n        LLLL : 'dddd, D MMMM YYYY г., HH:mm'\n    },\n    calendar : {\n        sameDay: '[Сегодня в] LT',\n        nextDay: '[Завтра в] LT',\n        lastDay: '[Вчера в] LT',\n        nextWeek: function (now) {\n            if (now.week() !== this.week()) {\n                switch (this.day()) {\n                    case 0:\n                        return '[В следующее] dddd [в] LT';\n                    case 1:\n                    case 2:\n                    case 4:\n                        return '[В следующий] dddd [в] LT';\n                    case 3:\n                    case 5:\n                    case 6:\n                        return '[В следующую] dddd [в] LT';\n                }\n            } else {\n                if (this.day() === 2) {\n                    return '[Во] dddd [в] LT';\n                } else {\n                    return '[В] dddd [в] LT';\n                }\n            }\n        },\n        lastWeek: function (now) {\n            if (now.week() !== this.week()) {\n                switch (this.day()) {\n                    case 0:\n                        return '[В прошлое] dddd [в] LT';\n                    case 1:\n                    case 2:\n                    case 4:\n                        return '[В прошлый] dddd [в] LT';\n                    case 3:\n                    case 5:\n                    case 6:\n                        return '[В прошлую] dddd [в] LT';\n                }\n            } else {\n                if (this.day() === 2) {\n                    return '[Во] dddd [в] LT';\n                } else {\n                    return '[В] dddd [в] LT';\n                }\n            }\n        },\n        sameElse: 'L'\n    },\n    relativeTime : {\n        future : 'через %s',\n        past : '%s назад',\n        s : 'несколько секунд',\n        m : relativeTimeWithPlural,\n        mm : relativeTimeWithPlural,\n        h : 'час',\n        hh : relativeTimeWithPlural,\n        d : 'день',\n        dd : relativeTimeWithPlural,\n        M : 'месяц',\n        MM : relativeTimeWithPlural,\n        y : 'год',\n        yy : relativeTimeWithPlural\n    },\n    meridiemParse: /ночи|утра|дня|вечера/i,\n    isPM : function (input) {\n        return /^(дня|вечера)$/.test(input);\n    },\n    meridiem : function (hour, minute, isLower) {\n        if (hour < 4) {\n            return 'ночи';\n        } else if (hour < 12) {\n            return 'утра';\n        } else if (hour < 17) {\n            return 'дня';\n        } else {\n            return 'вечера';\n        }\n    },\n    dayOfMonthOrdinalParse: /\\d{1,2}-(й|го|я)/,\n    ordinal: function (number, period) {\n        switch (period) {\n            case 'M':\n            case 'd':\n            case 'DDD':\n                return number + '-й';\n            case 'D':\n                return number + '-го';\n            case 'w':\n            case 'W':\n                return number + '-я';\n            default:\n                return number;\n        }\n    },\n    week : {\n        dow : 1, // Monday is the first day of the week.\n        doy : 7  // The week that contains Jan 1st is the first week of the year.\n    }\n});\n\nreturn ru;\n\n})));\n\n\n/***/ }),\n\n/***/ 101:\n/***/ (function(module, exports) {\n\n/**\n * Check if `obj` is an object.\n *\n * @param {Object} obj\n * @return {Boolean}\n * @api private\n */\n\nfunction isObject(obj) {\n  return null !== obj && 'object' === typeof obj;\n}\n\nmodule.exports = isObject;\n\n\n/***/ }),\n\n/***/ 102:\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n  * vue-router v2.7.0\n  * (c) 2017 Evan You\n  * @license MIT\n  */\n(function (global, factory) {\n\t true ? module.exports = factory() :\n\ttypeof define === 'function' && define.amd ? define(factory) :\n\t(global.VueRouter = factory());\n}(this, (function () { 'use strict';\n\n/*  */\n\nfunction assert (condition, message) {\n  if (!condition) {\n    throw new Error((\"[vue-router] \" + message))\n  }\n}\n\nfunction warn (condition, message) {\n  if (\"development\" !== 'production' && !condition) {\n    typeof console !== 'undefined' && console.warn((\"[vue-router] \" + message));\n  }\n}\n\nfunction isError (err) {\n  return Object.prototype.toString.call(err).indexOf('Error') > -1\n}\n\nvar View = {\n  name: 'router-view',\n  functional: true,\n  props: {\n    name: {\n      type: String,\n      default: 'default'\n    }\n  },\n  render: function render (_, ref) {\n    var props = ref.props;\n    var children = ref.children;\n    var parent = ref.parent;\n    var data = ref.data;\n\n    data.routerView = true;\n\n    // directly use parent context's createElement() function\n    // so that components rendered by router-view can resolve named slots\n    var h = parent.$createElement;\n    var name = props.name;\n    var route = parent.$route;\n    var cache = parent._routerViewCache || (parent._routerViewCache = {});\n\n    // determine current view depth, also check to see if the tree\n    // has been toggled inactive but kept-alive.\n    var depth = 0;\n    var inactive = false;\n    while (parent && parent._routerRoot !== parent) {\n      if (parent.$vnode && parent.$vnode.data.routerView) {\n        depth++;\n      }\n      if (parent._inactive) {\n        inactive = true;\n      }\n      parent = parent.$parent;\n    }\n    data.routerViewDepth = depth;\n\n    // render previous view if the tree is inactive and kept-alive\n    if (inactive) {\n      return h(cache[name], data, children)\n    }\n\n    var matched = route.matched[depth];\n    // render empty node if no matched route\n    if (!matched) {\n      cache[name] = null;\n      return h()\n    }\n\n    var component = cache[name] = matched.components[name];\n\n    // attach instance registration hook\n    // this will be called in the instance's injected lifecycle hooks\n    data.registerRouteInstance = function (vm, val) {\n      // val could be undefined for unregistration\n      var current = matched.instances[name];\n      if (\n        (val && current !== vm) ||\n        (!val && current === vm)\n      ) {\n        matched.instances[name] = val;\n      }\n    }\n\n    // also regiseter instance in prepatch hook\n    // in case the same component instance is reused across different routes\n    ;(data.hook || (data.hook = {})).prepatch = function (_, vnode) {\n      matched.instances[name] = vnode.componentInstance;\n    };\n\n    // resolve props\n    data.props = resolveProps(route, matched.props && matched.props[name]);\n\n    return h(component, data, children)\n  }\n};\n\nfunction resolveProps (route, config) {\n  switch (typeof config) {\n    case 'undefined':\n      return\n    case 'object':\n      return config\n    case 'function':\n      return config(route)\n    case 'boolean':\n      return config ? route.params : undefined\n    default:\n      {\n        warn(\n          false,\n          \"props in \\\"\" + (route.path) + \"\\\" is a \" + (typeof config) + \", \" +\n          \"expecting an object, function or boolean.\"\n        );\n      }\n  }\n}\n\n/*  */\n\nvar encodeReserveRE = /[!'()*]/g;\nvar encodeReserveReplacer = function (c) { return '%' + c.charCodeAt(0).toString(16); };\nvar commaRE = /%2C/g;\n\n// fixed encodeURIComponent which is more conformant to RFC3986:\n// - escapes [!'()*]\n// - preserve commas\nvar encode = function (str) { return encodeURIComponent(str)\n  .replace(encodeReserveRE, encodeReserveReplacer)\n  .replace(commaRE, ','); };\n\nvar decode = decodeURIComponent;\n\nfunction resolveQuery (\n  query,\n  extraQuery,\n  _parseQuery\n) {\n  if ( extraQuery === void 0 ) extraQuery = {};\n\n  var parse = _parseQuery || parseQuery;\n  var parsedQuery;\n  try {\n    parsedQuery = parse(query || '');\n  } catch (e) {\n    \"development\" !== 'production' && warn(false, e.message);\n    parsedQuery = {};\n  }\n  for (var key in extraQuery) {\n    var val = extraQuery[key];\n    parsedQuery[key] = Array.isArray(val) ? val.slice() : val;\n  }\n  return parsedQuery\n}\n\nfunction parseQuery (query) {\n  var res = {};\n\n  query = query.trim().replace(/^(\\?|#|&)/, '');\n\n  if (!query) {\n    return res\n  }\n\n  query.split('&').forEach(function (param) {\n    var parts = param.replace(/\\+/g, ' ').split('=');\n    var key = decode(parts.shift());\n    var val = parts.length > 0\n      ? decode(parts.join('='))\n      : null;\n\n    if (res[key] === undefined) {\n      res[key] = val;\n    } else if (Array.isArray(res[key])) {\n      res[key].push(val);\n    } else {\n      res[key] = [res[key], val];\n    }\n  });\n\n  return res\n}\n\nfunction stringifyQuery (obj) {\n  var res = obj ? Object.keys(obj).map(function (key) {\n    var val = obj[key];\n\n    if (val === undefined) {\n      return ''\n    }\n\n    if (val === null) {\n      return encode(key)\n    }\n\n    if (Array.isArray(val)) {\n      var result = [];\n      val.forEach(function (val2) {\n        if (val2 === undefined) {\n          return\n        }\n        if (val2 === null) {\n          result.push(encode(key));\n        } else {\n          result.push(encode(key) + '=' + encode(val2));\n        }\n      });\n      return result.join('&')\n    }\n\n    return encode(key) + '=' + encode(val)\n  }).filter(function (x) { return x.length > 0; }).join('&') : null;\n  return res ? (\"?\" + res) : ''\n}\n\n/*  */\n\n\nvar trailingSlashRE = /\\/?$/;\n\nfunction createRoute (\n  record,\n  location,\n  redirectedFrom,\n  router\n) {\n  var stringifyQuery$$1 = router && router.options.stringifyQuery;\n  var route = {\n    name: location.name || (record && record.name),\n    meta: (record && record.meta) || {},\n    path: location.path || '/',\n    hash: location.hash || '',\n    query: location.query || {},\n    params: location.params || {},\n    fullPath: getFullPath(location, stringifyQuery$$1),\n    matched: record ? formatMatch(record) : []\n  };\n  if (redirectedFrom) {\n    route.redirectedFrom = getFullPath(redirectedFrom, stringifyQuery$$1);\n  }\n  return Object.freeze(route)\n}\n\n// the starting route that represents the initial state\nvar START = createRoute(null, {\n  path: '/'\n});\n\nfunction formatMatch (record) {\n  var res = [];\n  while (record) {\n    res.unshift(record);\n    record = record.parent;\n  }\n  return res\n}\n\nfunction getFullPath (\n  ref,\n  _stringifyQuery\n) {\n  var path = ref.path;\n  var query = ref.query; if ( query === void 0 ) query = {};\n  var hash = ref.hash; if ( hash === void 0 ) hash = '';\n\n  var stringify = _stringifyQuery || stringifyQuery;\n  return (path || '/') + stringify(query) + hash\n}\n\nfunction isSameRoute (a, b) {\n  if (b === START) {\n    return a === b\n  } else if (!b) {\n    return false\n  } else if (a.path && b.path) {\n    return (\n      a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') &&\n      a.hash === b.hash &&\n      isObjectEqual(a.query, b.query)\n    )\n  } else if (a.name && b.name) {\n    return (\n      a.name === b.name &&\n      a.hash === b.hash &&\n      isObjectEqual(a.query, b.query) &&\n      isObjectEqual(a.params, b.params)\n    )\n  } else {\n    return false\n  }\n}\n\nfunction isObjectEqual (a, b) {\n  if ( a === void 0 ) a = {};\n  if ( b === void 0 ) b = {};\n\n  var aKeys = Object.keys(a);\n  var bKeys = Object.keys(b);\n  if (aKeys.length !== bKeys.length) {\n    return false\n  }\n  return aKeys.every(function (key) {\n    var aVal = a[key];\n    var bVal = b[key];\n    // check nested equality\n    if (typeof aVal === 'object' && typeof bVal === 'object') {\n      return isObjectEqual(aVal, bVal)\n    }\n    return String(aVal) === String(bVal)\n  })\n}\n\nfunction isIncludedRoute (current, target) {\n  return (\n    current.path.replace(trailingSlashRE, '/').indexOf(\n      target.path.replace(trailingSlashRE, '/')\n    ) === 0 &&\n    (!target.hash || current.hash === target.hash) &&\n    queryIncludes(current.query, target.query)\n  )\n}\n\nfunction queryIncludes (current, target) {\n  for (var key in target) {\n    if (!(key in current)) {\n      return false\n    }\n  }\n  return true\n}\n\n/*  */\n\n// work around weird flow bug\nvar toTypes = [String, Object];\nvar eventTypes = [String, Array];\n\nvar Link = {\n  name: 'router-link',\n  props: {\n    to: {\n      type: toTypes,\n      required: true\n    },\n    tag: {\n      type: String,\n      default: 'a'\n    },\n    exact: Boolean,\n    append: Boolean,\n    replace: Boolean,\n    activeClass: String,\n    exactActiveClass: String,\n    event: {\n      type: eventTypes,\n      default: 'click'\n    }\n  },\n  render: function render (h) {\n    var this$1 = this;\n\n    var router = this.$router;\n    var current = this.$route;\n    var ref = router.resolve(this.to, current, this.append);\n    var location = ref.location;\n    var route = ref.route;\n    var href = ref.href;\n\n    var classes = {};\n    var globalActiveClass = router.options.linkActiveClass;\n    var globalExactActiveClass = router.options.linkExactActiveClass;\n    // Support global empty active class\n    var activeClassFallback = globalActiveClass == null\n            ? 'router-link-active'\n            : globalActiveClass;\n    var exactActiveClassFallback = globalExactActiveClass == null\n            ? 'router-link-exact-active'\n            : globalExactActiveClass;\n    var activeClass = this.activeClass == null\n            ? activeClassFallback\n            : this.activeClass;\n    var exactActiveClass = this.exactActiveClass == null\n            ? exactActiveClassFallback\n            : this.exactActiveClass;\n    var compareTarget = location.path\n      ? createRoute(null, location, null, router)\n      : route;\n\n    classes[exactActiveClass] = isSameRoute(current, compareTarget);\n    classes[activeClass] = this.exact\n      ? classes[exactActiveClass]\n      : isIncludedRoute(current, compareTarget);\n\n    var handler = function (e) {\n      if (guardEvent(e)) {\n        if (this$1.replace) {\n          router.replace(location);\n        } else {\n          router.push(location);\n        }\n      }\n    };\n\n    var on = { click: guardEvent };\n    if (Array.isArray(this.event)) {\n      this.event.forEach(function (e) { on[e] = handler; });\n    } else {\n      on[this.event] = handler;\n    }\n\n    var data = {\n      class: classes\n    };\n\n    if (this.tag === 'a') {\n      data.on = on;\n      data.attrs = { href: href };\n    } else {\n      // find the first <a> child and apply listener and href\n      var a = findAnchor(this.$slots.default);\n      if (a) {\n        // in case the <a> is a static node\n        a.isStatic = false;\n        var extend = _Vue.util.extend;\n        var aData = a.data = extend({}, a.data);\n        aData.on = on;\n        var aAttrs = a.data.attrs = extend({}, a.data.attrs);\n        aAttrs.href = href;\n      } else {\n        // doesn't have <a> child, apply listener to self\n        data.on = on;\n      }\n    }\n\n    return h(this.tag, data, this.$slots.default)\n  }\n};\n\nfunction guardEvent (e) {\n  // don't redirect with control keys\n  if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) { return }\n  // don't redirect when preventDefault called\n  if (e.defaultPrevented) { return }\n  // don't redirect on right click\n  if (e.button !== undefined && e.button !== 0) { return }\n  // don't redirect if `target=\"_blank\"`\n  if (e.currentTarget && e.currentTarget.getAttribute) {\n    var target = e.currentTarget.getAttribute('target');\n    if (/\\b_blank\\b/i.test(target)) { return }\n  }\n  // this may be a Weex event which doesn't have this method\n  if (e.preventDefault) {\n    e.preventDefault();\n  }\n  return true\n}\n\nfunction findAnchor (children) {\n  if (children) {\n    var child;\n    for (var i = 0; i < children.length; i++) {\n      child = children[i];\n      if (child.tag === 'a') {\n        return child\n      }\n      if (child.children && (child = findAnchor(child.children))) {\n        return child\n      }\n    }\n  }\n}\n\nvar _Vue;\n\nfunction install (Vue) {\n  if (install.installed) { return }\n  install.installed = true;\n\n  _Vue = Vue;\n\n  var isDef = function (v) { return v !== undefined; };\n\n  var registerInstance = function (vm, callVal) {\n    var i = vm.$options._parentVnode;\n    if (isDef(i) && isDef(i = i.data) && isDef(i = i.registerRouteInstance)) {\n      i(vm, callVal);\n    }\n  };\n\n  Vue.mixin({\n    beforeCreate: function beforeCreate () {\n      if (isDef(this.$options.router)) {\n        this._routerRoot = this;\n        this._router = this.$options.router;\n        this._router.init(this);\n        Vue.util.defineReactive(this, '_route', this._router.history.current);\n      } else {\n        this._routerRoot = (this.$parent && this.$parent._routerRoot) || this;\n      }\n      registerInstance(this, this);\n    },\n    destroyed: function destroyed () {\n      registerInstance(this);\n    }\n  });\n\n  Object.defineProperty(Vue.prototype, '$router', {\n    get: function get () { return this._routerRoot._router }\n  });\n\n  Object.defineProperty(Vue.prototype, '$route', {\n    get: function get () { return this._routerRoot._route }\n  });\n\n  Vue.component('router-view', View);\n  Vue.component('router-link', Link);\n\n  var strats = Vue.config.optionMergeStrategies;\n  // use the same hook merging strategy for route hooks\n  strats.beforeRouteEnter = strats.beforeRouteLeave = strats.beforeRouteUpdate = strats.created;\n}\n\n/*  */\n\nvar inBrowser = typeof window !== 'undefined';\n\n/*  */\n\nfunction resolvePath (\n  relative,\n  base,\n  append\n) {\n  var firstChar = relative.charAt(0);\n  if (firstChar === '/') {\n    return relative\n  }\n\n  if (firstChar === '?' || firstChar === '#') {\n    return base + relative\n  }\n\n  var stack = base.split('/');\n\n  // remove trailing segment if:\n  // - not appending\n  // - appending to trailing slash (last segment is empty)\n  if (!append || !stack[stack.length - 1]) {\n    stack.pop();\n  }\n\n  // resolve relative path\n  var segments = relative.replace(/^\\//, '').split('/');\n  for (var i = 0; i < segments.length; i++) {\n    var segment = segments[i];\n    if (segment === '..') {\n      stack.pop();\n    } else if (segment !== '.') {\n      stack.push(segment);\n    }\n  }\n\n  // ensure leading slash\n  if (stack[0] !== '') {\n    stack.unshift('');\n  }\n\n  return stack.join('/')\n}\n\nfunction parsePath (path) {\n  var hash = '';\n  var query = '';\n\n  var hashIndex = path.indexOf('#');\n  if (hashIndex >= 0) {\n    hash = path.slice(hashIndex);\n    path = path.slice(0, hashIndex);\n  }\n\n  var queryIndex = path.indexOf('?');\n  if (queryIndex >= 0) {\n    query = path.slice(queryIndex + 1);\n    path = path.slice(0, queryIndex);\n  }\n\n  return {\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\nfunction cleanPath (path) {\n  return path.replace(/\\/\\//g, '/')\n}\n\nvar index$1 = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\n/**\n * Expose `pathToRegexp`.\n */\nvar index = pathToRegexp;\nvar parse_1 = parse;\nvar compile_1 = compile;\nvar tokensToFunction_1 = tokensToFunction;\nvar tokensToRegExp_1 = tokensToRegExp;\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n  // \"/route(\\\\d+)\"  => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n  // \"/*\"            => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n  '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g');\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = [];\n  var key = 0;\n  var index = 0;\n  var path = '';\n  var defaultDelimiter = options && options.delimiter || '/';\n  var res;\n\n  while ((res = PATH_REGEXP.exec(str)) != null) {\n    var m = res[0];\n    var escaped = res[1];\n    var offset = res.index;\n    path += str.slice(index, offset);\n    index = offset + m.length;\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1];\n      continue\n    }\n\n    var next = str[index];\n    var prefix = res[2];\n    var name = res[3];\n    var capture = res[4];\n    var group = res[5];\n    var modifier = res[6];\n    var asterisk = res[7];\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path);\n      path = '';\n    }\n\n    var partial = prefix != null && next != null && next !== prefix;\n    var repeat = modifier === '+' || modifier === '*';\n    var optional = modifier === '?' || modifier === '*';\n    var delimiter = res[2] || defaultDelimiter;\n    var pattern = capture || group;\n\n    tokens.push({\n      name: name || key++,\n      prefix: prefix || '',\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      asterisk: !!asterisk,\n      pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n    });\n  }\n\n  // Match any characters still remaining.\n  if (index < str.length) {\n    path += str.substr(index);\n  }\n\n  // If the path exists, push it onto the end.\n  if (path) {\n    tokens.push(path);\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options))\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n  return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n  return encodeURI(str).replace(/[?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length);\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$');\n    }\n  }\n\n  return function (obj, opts) {\n    var path = '';\n    var data = obj || {};\n    var options = opts || {};\n    var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i];\n\n      if (typeof token === 'string') {\n        path += token;\n\n        continue\n      }\n\n      var value = data[token.name];\n      var segment;\n\n      if (value == null) {\n        if (token.optional) {\n          // Prepend partial segment prefixes.\n          if (token.partial) {\n            path += token.prefix;\n          }\n\n          continue\n        } else {\n          throw new TypeError('Expected \"' + token.name + '\" to be defined')\n        }\n      }\n\n      if (index$1(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) {\n            continue\n          } else {\n            throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n          }\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j]);\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment;\n        }\n\n        continue\n      }\n\n      segment = token.asterisk ? encodeAsterisk(value) : encode(value);\n\n      if (!matches[i].test(segment)) {\n        throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n      }\n\n      path += token.prefix + segment;\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param  {!RegExp} re\n * @param  {Array}   keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n  re.keys = keys;\n  return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {!Array}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g);\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        asterisk: false,\n        pattern: null\n      });\n    }\n  }\n\n  return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array}   keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = [];\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp(path[i], keys, options).source);\n  }\n\n  var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));\n\n  return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {!Array}  keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}          tokens\n * @param  {(Array|Object)=} keys\n * @param  {Object=}         options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  if (!index$1(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  var strict = options.strict;\n  var end = options.end !== false;\n  var route = '';\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i];\n\n    if (typeof token === 'string') {\n      route += escapeString(token);\n    } else {\n      var prefix = escapeString(token.prefix);\n      var capture = '(?:' + token.pattern + ')';\n\n      keys.push(token);\n\n      if (token.repeat) {\n        capture += '(?:' + prefix + capture + ')*';\n      }\n\n      if (token.optional) {\n        if (!token.partial) {\n          capture = '(?:' + prefix + '(' + capture + '))?';\n        } else {\n          capture = prefix + '(' + capture + ')?';\n        }\n      } else {\n        capture = prefix + '(' + capture + ')';\n      }\n\n      route += capture;\n    }\n  }\n\n  var delimiter = escapeString(options.delimiter || '/');\n  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;\n\n  // In non-strict mode we allow a slash at the end of match. If the path to\n  // match already ends with a slash, we remove it for consistency. The slash\n  // is valid at the end of a path match, not in the middle. This is important\n  // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n  if (!strict) {\n    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';\n  }\n\n  if (end) {\n    route += '$';\n  } else {\n    // In non-ending mode, we need the capturing groups to match as much as\n    // possible by using a positive lookahead to the end or next path segment.\n    route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';\n  }\n\n  return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {(Array|Object)=}       keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n  if (!index$1(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, /** @type {!Array} */ (keys))\n  }\n\n  if (index$1(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\n\nindex.parse = parse_1;\nindex.compile = compile_1;\nindex.tokensToFunction = tokensToFunction_1;\nindex.tokensToRegExp = tokensToRegExp_1;\n\n/*  */\n\nvar regexpCompileCache = Object.create(null);\n\nfunction fillParams (\n  path,\n  params,\n  routeMsg\n) {\n  try {\n    var filler =\n      regexpCompileCache[path] ||\n      (regexpCompileCache[path] = index.compile(path));\n    return filler(params || {}, { pretty: true })\n  } catch (e) {\n    {\n      warn(false, (\"missing param for \" + routeMsg + \": \" + (e.message)));\n    }\n    return ''\n  }\n}\n\n/*  */\n\nfunction createRouteMap (\n  routes,\n  oldPathList,\n  oldPathMap,\n  oldNameMap\n) {\n  // the path list is used to control path matching priority\n  var pathList = oldPathList || [];\n  var pathMap = oldPathMap || Object.create(null);\n  var nameMap = oldNameMap || Object.create(null);\n\n  routes.forEach(function (route) {\n    addRouteRecord(pathList, pathMap, nameMap, route);\n  });\n\n  // ensure wildcard routes are always at the end\n  for (var i = 0, l = pathList.length; i < l; i++) {\n    if (pathList[i] === '*') {\n      pathList.push(pathList.splice(i, 1)[0]);\n      l--;\n      i--;\n    }\n  }\n\n  return {\n    pathList: pathList,\n    pathMap: pathMap,\n    nameMap: nameMap\n  }\n}\n\nfunction addRouteRecord (\n  pathList,\n  pathMap,\n  nameMap,\n  route,\n  parent,\n  matchAs\n) {\n  var path = route.path;\n  var name = route.name;\n  {\n    assert(path != null, \"\\\"path\\\" is required in a route configuration.\");\n    assert(\n      typeof route.component !== 'string',\n      \"route config \\\"component\\\" for path: \" + (String(path || name)) + \" cannot be a \" +\n      \"string id. Use an actual component instead.\"\n    );\n  }\n\n  var normalizedPath = normalizePath(path, parent);\n  var pathToRegexpOptions = route.pathToRegexpOptions || {};\n\n  if (typeof route.caseSensitive === 'boolean') {\n    pathToRegexpOptions.sensitive = route.caseSensitive;\n  }\n\n  var record = {\n    path: normalizedPath,\n    regex: compileRouteRegex(normalizedPath, pathToRegexpOptions),\n    components: route.components || { default: route.component },\n    instances: {},\n    name: name,\n    parent: parent,\n    matchAs: matchAs,\n    redirect: route.redirect,\n    beforeEnter: route.beforeEnter,\n    meta: route.meta || {},\n    props: route.props == null\n      ? {}\n      : route.components\n        ? route.props\n        : { default: route.props }\n  };\n\n  if (route.children) {\n    // Warn if route is named, does not redirect and has a default child route.\n    // If users navigate to this route by name, the default child will\n    // not be rendered (GH Issue #629)\n    {\n      if (route.name && !route.redirect && route.children.some(function (child) { return /^\\/?$/.test(child.path); })) {\n        warn(\n          false,\n          \"Named Route '\" + (route.name) + \"' has a default child route. \" +\n          \"When navigating to this named route (:to=\\\"{name: '\" + (route.name) + \"'\\\"), \" +\n          \"the default child route will not be rendered. Remove the name from \" +\n          \"this route and use the name of the default child route for named \" +\n          \"links instead.\"\n        );\n      }\n    }\n    route.children.forEach(function (child) {\n      var childMatchAs = matchAs\n        ? cleanPath((matchAs + \"/\" + (child.path)))\n        : undefined;\n      addRouteRecord(pathList, pathMap, nameMap, child, record, childMatchAs);\n    });\n  }\n\n  if (route.alias !== undefined) {\n    var aliases = Array.isArray(route.alias)\n      ? route.alias\n      : [route.alias];\n\n    aliases.forEach(function (alias) {\n      var aliasRoute = {\n        path: alias,\n        children: route.children\n      };\n      addRouteRecord(\n        pathList,\n        pathMap,\n        nameMap,\n        aliasRoute,\n        parent,\n        record.path || '/' // matchAs\n      );\n    });\n  }\n\n  if (!pathMap[record.path]) {\n    pathList.push(record.path);\n    pathMap[record.path] = record;\n  }\n\n  if (name) {\n    if (!nameMap[name]) {\n      nameMap[name] = record;\n    } else if (\"development\" !== 'production' && !matchAs) {\n      warn(\n        false,\n        \"Duplicate named routes definition: \" +\n        \"{ name: \\\"\" + name + \"\\\", path: \\\"\" + (record.path) + \"\\\" }\"\n      );\n    }\n  }\n}\n\nfunction compileRouteRegex (path, pathToRegexpOptions) {\n  var regex = index(path, [], pathToRegexpOptions);\n  {\n    var keys = {};\n    regex.keys.forEach(function (key) {\n      warn(!keys[key.name], (\"Duplicate param keys in route with path: \\\"\" + path + \"\\\"\"));\n      keys[key.name] = true;\n    });\n  }\n  return regex\n}\n\nfunction normalizePath (path, parent) {\n  path = path.replace(/\\/$/, '');\n  if (path[0] === '/') { return path }\n  if (parent == null) { return path }\n  return cleanPath(((parent.path) + \"/\" + path))\n}\n\n/*  */\n\n\nfunction normalizeLocation (\n  raw,\n  current,\n  append,\n  router\n) {\n  var next = typeof raw === 'string' ? { path: raw } : raw;\n  // named target\n  if (next.name || next._normalized) {\n    return next\n  }\n\n  // relative params\n  if (!next.path && next.params && current) {\n    next = assign({}, next);\n    next._normalized = true;\n    var params = assign(assign({}, current.params), next.params);\n    if (current.name) {\n      next.name = current.name;\n      next.params = params;\n    } else if (current.matched.length) {\n      var rawPath = current.matched[current.matched.length - 1].path;\n      next.path = fillParams(rawPath, params, (\"path \" + (current.path)));\n    } else {\n      warn(false, \"relative params navigation requires a current route.\");\n    }\n    return next\n  }\n\n  var parsedPath = parsePath(next.path || '');\n  var basePath = (current && current.path) || '/';\n  var path = parsedPath.path\n    ? resolvePath(parsedPath.path, basePath, append || next.append)\n    : basePath;\n\n  var query = resolveQuery(\n    parsedPath.query,\n    next.query,\n    router && router.options.parseQuery\n  );\n\n  var hash = next.hash || parsedPath.hash;\n  if (hash && hash.charAt(0) !== '#') {\n    hash = \"#\" + hash;\n  }\n\n  return {\n    _normalized: true,\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\nfunction assign (a, b) {\n  for (var key in b) {\n    a[key] = b[key];\n  }\n  return a\n}\n\n/*  */\n\n\nfunction createMatcher (\n  routes,\n  router\n) {\n  var ref = createRouteMap(routes);\n  var pathList = ref.pathList;\n  var pathMap = ref.pathMap;\n  var nameMap = ref.nameMap;\n\n  function addRoutes (routes) {\n    createRouteMap(routes, pathList, pathMap, nameMap);\n  }\n\n  function match (\n    raw,\n    currentRoute,\n    redirectedFrom\n  ) {\n    var location = normalizeLocation(raw, currentRoute, false, router);\n    var name = location.name;\n\n    if (name) {\n      var record = nameMap[name];\n      {\n        warn(record, (\"Route with name '\" + name + \"' does not exist\"));\n      }\n      if (!record) { return _createRoute(null, location) }\n      var paramNames = record.regex.keys\n        .filter(function (key) { return !key.optional; })\n        .map(function (key) { return key.name; });\n\n      if (typeof location.params !== 'object') {\n        location.params = {};\n      }\n\n      if (currentRoute && typeof currentRoute.params === 'object') {\n        for (var key in currentRoute.params) {\n          if (!(key in location.params) && paramNames.indexOf(key) > -1) {\n            location.params[key] = currentRoute.params[key];\n          }\n        }\n      }\n\n      if (record) {\n        location.path = fillParams(record.path, location.params, (\"named route \\\"\" + name + \"\\\"\"));\n        return _createRoute(record, location, redirectedFrom)\n      }\n    } else if (location.path) {\n      location.params = {};\n      for (var i = 0; i < pathList.length; i++) {\n        var path = pathList[i];\n        var record$1 = pathMap[path];\n        if (matchRoute(record$1.regex, location.path, location.params)) {\n          return _createRoute(record$1, location, redirectedFrom)\n        }\n      }\n    }\n    // no match\n    return _createRoute(null, location)\n  }\n\n  function redirect (\n    record,\n    location\n  ) {\n    var originalRedirect = record.redirect;\n    var redirect = typeof originalRedirect === 'function'\n        ? originalRedirect(createRoute(record, location, null, router))\n        : originalRedirect;\n\n    if (typeof redirect === 'string') {\n      redirect = { path: redirect };\n    }\n\n    if (!redirect || typeof redirect !== 'object') {\n      {\n        warn(\n          false, (\"invalid redirect option: \" + (JSON.stringify(redirect)))\n        );\n      }\n      return _createRoute(null, location)\n    }\n\n    var re = redirect;\n    var name = re.name;\n    var path = re.path;\n    var query = location.query;\n    var hash = location.hash;\n    var params = location.params;\n    query = re.hasOwnProperty('query') ? re.query : query;\n    hash = re.hasOwnProperty('hash') ? re.hash : hash;\n    params = re.hasOwnProperty('params') ? re.params : params;\n\n    if (name) {\n      // resolved named direct\n      var targetRecord = nameMap[name];\n      {\n        assert(targetRecord, (\"redirect failed: named route \\\"\" + name + \"\\\" not found.\"));\n      }\n      return match({\n        _normalized: true,\n        name: name,\n        query: query,\n        hash: hash,\n        params: params\n      }, undefined, location)\n    } else if (path) {\n      // 1. resolve relative redirect\n      var rawPath = resolveRecordPath(path, record);\n      // 2. resolve params\n      var resolvedPath = fillParams(rawPath, params, (\"redirect route with path \\\"\" + rawPath + \"\\\"\"));\n      // 3. rematch with existing query and hash\n      return match({\n        _normalized: true,\n        path: resolvedPath,\n        query: query,\n        hash: hash\n      }, undefined, location)\n    } else {\n      {\n        warn(false, (\"invalid redirect option: \" + (JSON.stringify(redirect))));\n      }\n      return _createRoute(null, location)\n    }\n  }\n\n  function alias (\n    record,\n    location,\n    matchAs\n  ) {\n    var aliasedPath = fillParams(matchAs, location.params, (\"aliased route with path \\\"\" + matchAs + \"\\\"\"));\n    var aliasedMatch = match({\n      _normalized: true,\n      path: aliasedPath\n    });\n    if (aliasedMatch) {\n      var matched = aliasedMatch.matched;\n      var aliasedRecord = matched[matched.length - 1];\n      location.params = aliasedMatch.params;\n      return _createRoute(aliasedRecord, location)\n    }\n    return _createRoute(null, location)\n  }\n\n  function _createRoute (\n    record,\n    location,\n    redirectedFrom\n  ) {\n    if (record && record.redirect) {\n      return redirect(record, redirectedFrom || location)\n    }\n    if (record && record.matchAs) {\n      return alias(record, location, record.matchAs)\n    }\n    return createRoute(record, location, redirectedFrom, router)\n  }\n\n  return {\n    match: match,\n    addRoutes: addRoutes\n  }\n}\n\nfunction matchRoute (\n  regex,\n  path,\n  params\n) {\n  var m = path.match(regex);\n\n  if (!m) {\n    return false\n  } else if (!params) {\n    return true\n  }\n\n  for (var i = 1, len = m.length; i < len; ++i) {\n    var key = regex.keys[i - 1];\n    var val = typeof m[i] === 'string' ? decodeURIComponent(m[i]) : m[i];\n    if (key) {\n      params[key.name] = val;\n    }\n  }\n\n  return true\n}\n\nfunction resolveRecordPath (path, record) {\n  return resolvePath(path, record.parent ? record.parent.path : '/', true)\n}\n\n/*  */\n\n\nvar positionStore = Object.create(null);\n\nfunction setupScroll () {\n  window.addEventListener('popstate', function (e) {\n    saveScrollPosition();\n    if (e.state && e.state.key) {\n      setStateKey(e.state.key);\n    }\n  });\n}\n\nfunction handleScroll (\n  router,\n  to,\n  from,\n  isPop\n) {\n  if (!router.app) {\n    return\n  }\n\n  var behavior = router.options.scrollBehavior;\n  if (!behavior) {\n    return\n  }\n\n  {\n    assert(typeof behavior === 'function', \"scrollBehavior must be a function\");\n  }\n\n  // wait until re-render finishes before scrolling\n  router.app.$nextTick(function () {\n    var position = getScrollPosition();\n    var shouldScroll = behavior(to, from, isPop ? position : null);\n    if (!shouldScroll) {\n      return\n    }\n    var isObject = typeof shouldScroll === 'object';\n    if (isObject && typeof shouldScroll.selector === 'string') {\n      var el = document.querySelector(shouldScroll.selector);\n      if (el) {\n        var offset = shouldScroll.offset && typeof shouldScroll.offset === 'object' ? shouldScroll.offset : {};\n        offset = normalizeOffset(offset);\n        position = getElementPosition(el, offset);\n      } else if (isValidPosition(shouldScroll)) {\n        position = normalizePosition(shouldScroll);\n      }\n    } else if (isObject && isValidPosition(shouldScroll)) {\n      position = normalizePosition(shouldScroll);\n    }\n\n    if (position) {\n      window.scrollTo(position.x, position.y);\n    }\n  });\n}\n\nfunction saveScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    positionStore[key] = {\n      x: window.pageXOffset,\n      y: window.pageYOffset\n    };\n  }\n}\n\nfunction getScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    return positionStore[key]\n  }\n}\n\nfunction getElementPosition (el, offset) {\n  var docEl = document.documentElement;\n  var docRect = docEl.getBoundingClientRect();\n  var elRect = el.getBoundingClientRect();\n  return {\n    x: elRect.left - docRect.left - offset.x,\n    y: elRect.top - docRect.top - offset.y\n  }\n}\n\nfunction isValidPosition (obj) {\n  return isNumber(obj.x) || isNumber(obj.y)\n}\n\nfunction normalizePosition (obj) {\n  return {\n    x: isNumber(obj.x) ? obj.x : window.pageXOffset,\n    y: isNumber(obj.y) ? obj.y : window.pageYOffset\n  }\n}\n\nfunction normalizeOffset (obj) {\n  return {\n    x: isNumber(obj.x) ? obj.x : 0,\n    y: isNumber(obj.y) ? obj.y : 0\n  }\n}\n\nfunction isNumber (v) {\n  return typeof v === 'number'\n}\n\n/*  */\n\nvar supportsPushState = inBrowser && (function () {\n  var ua = window.navigator.userAgent;\n\n  if (\n    (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&\n    ua.indexOf('Mobile Safari') !== -1 &&\n    ua.indexOf('Chrome') === -1 &&\n    ua.indexOf('Windows Phone') === -1\n  ) {\n    return false\n  }\n\n  return window.history && 'pushState' in window.history\n})();\n\n// use User Timing api (if present) for more accurate key precision\nvar Time = inBrowser && window.performance && window.performance.now\n  ? window.performance\n  : Date;\n\nvar _key = genKey();\n\nfunction genKey () {\n  return Time.now().toFixed(3)\n}\n\nfunction getStateKey () {\n  return _key\n}\n\nfunction setStateKey (key) {\n  _key = key;\n}\n\nfunction pushState (url, replace) {\n  saveScrollPosition();\n  // try...catch the pushState call to get around Safari\n  // DOM Exception 18 where it limits to 100 pushState calls\n  var history = window.history;\n  try {\n    if (replace) {\n      history.replaceState({ key: _key }, '', url);\n    } else {\n      _key = genKey();\n      history.pushState({ key: _key }, '', url);\n    }\n  } catch (e) {\n    window.location[replace ? 'replace' : 'assign'](url);\n  }\n}\n\nfunction replaceState (url) {\n  pushState(url, true);\n}\n\n/*  */\n\nfunction runQueue (queue, fn, cb) {\n  var step = function (index) {\n    if (index >= queue.length) {\n      cb();\n    } else {\n      if (queue[index]) {\n        fn(queue[index], function () {\n          step(index + 1);\n        });\n      } else {\n        step(index + 1);\n      }\n    }\n  };\n  step(0);\n}\n\n/*  */\n\nfunction resolveAsyncComponents (matched) {\n  return function (to, from, next) {\n    var hasAsync = false;\n    var pending = 0;\n    var error = null;\n\n    flatMapComponents(matched, function (def, _, match, key) {\n      // if it's a function and doesn't have cid attached,\n      // assume it's an async component resolve function.\n      // we are not using Vue's default async resolving mechanism because\n      // we want to halt the navigation until the incoming component has been\n      // resolved.\n      if (typeof def === 'function' && def.cid === undefined) {\n        hasAsync = true;\n        pending++;\n\n        var resolve = once(function (resolvedDef) {\n          if (resolvedDef.__esModule && resolvedDef.default) {\n            resolvedDef = resolvedDef.default;\n          }\n          // save resolved on async factory in case it's used elsewhere\n          def.resolved = typeof resolvedDef === 'function'\n            ? resolvedDef\n            : _Vue.extend(resolvedDef);\n          match.components[key] = resolvedDef;\n          pending--;\n          if (pending <= 0) {\n            next();\n          }\n        });\n\n        var reject = once(function (reason) {\n          var msg = \"Failed to resolve async component \" + key + \": \" + reason;\n          \"development\" !== 'production' && warn(false, msg);\n          if (!error) {\n            error = isError(reason)\n              ? reason\n              : new Error(msg);\n            next(error);\n          }\n        });\n\n        var res;\n        try {\n          res = def(resolve, reject);\n        } catch (e) {\n          reject(e);\n        }\n        if (res) {\n          if (typeof res.then === 'function') {\n            res.then(resolve, reject);\n          } else {\n            // new syntax in Vue 2.3\n            var comp = res.component;\n            if (comp && typeof comp.then === 'function') {\n              comp.then(resolve, reject);\n            }\n          }\n        }\n      }\n    });\n\n    if (!hasAsync) { next(); }\n  }\n}\n\nfunction flatMapComponents (\n  matched,\n  fn\n) {\n  return flatten(matched.map(function (m) {\n    return Object.keys(m.components).map(function (key) { return fn(\n      m.components[key],\n      m.instances[key],\n      m, key\n    ); })\n  }))\n}\n\nfunction flatten (arr) {\n  return Array.prototype.concat.apply([], arr)\n}\n\n// in Webpack 2, require.ensure now also returns a Promise\n// so the resolve/reject functions may get called an extra time\n// if the user uses an arrow function shorthand that happens to\n// return that Promise.\nfunction once (fn) {\n  var called = false;\n  return function () {\n    var args = [], len = arguments.length;\n    while ( len-- ) args[ len ] = arguments[ len ];\n\n    if (called) { return }\n    called = true;\n    return fn.apply(this, args)\n  }\n}\n\n/*  */\n\nvar History = function History (router, base) {\n  this.router = router;\n  this.base = normalizeBase(base);\n  // start with a route object that stands for \"nowhere\"\n  this.current = START;\n  this.pending = null;\n  this.ready = false;\n  this.readyCbs = [];\n  this.readyErrorCbs = [];\n  this.errorCbs = [];\n};\n\nHistory.prototype.listen = function listen (cb) {\n  this.cb = cb;\n};\n\nHistory.prototype.onReady = function onReady (cb, errorCb) {\n  if (this.ready) {\n    cb();\n  } else {\n    this.readyCbs.push(cb);\n    if (errorCb) {\n      this.readyErrorCbs.push(errorCb);\n    }\n  }\n};\n\nHistory.prototype.onError = function onError (errorCb) {\n  this.errorCbs.push(errorCb);\n};\n\nHistory.prototype.transitionTo = function transitionTo (location, onComplete, onAbort) {\n    var this$1 = this;\n\n  var route = this.router.match(location, this.current);\n  this.confirmTransition(route, function () {\n    this$1.updateRoute(route);\n    onComplete && onComplete(route);\n    this$1.ensureURL();\n\n    // fire ready cbs once\n    if (!this$1.ready) {\n      this$1.ready = true;\n      this$1.readyCbs.forEach(function (cb) { cb(route); });\n    }\n  }, function (err) {\n    if (onAbort) {\n      onAbort(err);\n    }\n    if (err && !this$1.ready) {\n      this$1.ready = true;\n      this$1.readyErrorCbs.forEach(function (cb) { cb(err); });\n    }\n  });\n};\n\nHistory.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {\n    var this$1 = this;\n\n  var current = this.current;\n  var abort = function (err) {\n    if (isError(err)) {\n      if (this$1.errorCbs.length) {\n        this$1.errorCbs.forEach(function (cb) { cb(err); });\n      } else {\n        warn(false, 'uncaught error during route navigation:');\n        console.error(err);\n      }\n    }\n    onAbort && onAbort(err);\n  };\n  if (\n    isSameRoute(route, current) &&\n    // in the case the route map has been dynamically appended to\n    route.matched.length === current.matched.length\n  ) {\n    this.ensureURL();\n    return abort()\n  }\n\n  var ref = resolveQueue(this.current.matched, route.matched);\n    var updated = ref.updated;\n    var deactivated = ref.deactivated;\n    var activated = ref.activated;\n\n  var queue = [].concat(\n    // in-component leave guards\n    extractLeaveGuards(deactivated),\n    // global before hooks\n    this.router.beforeHooks,\n    // in-component update hooks\n    extractUpdateHooks(updated),\n    // in-config enter guards\n    activated.map(function (m) { return m.beforeEnter; }),\n    // async components\n    resolveAsyncComponents(activated)\n  );\n\n  this.pending = route;\n  var iterator = function (hook, next) {\n    if (this$1.pending !== route) {\n      return abort()\n    }\n    try {\n      hook(route, current, function (to) {\n        if (to === false || isError(to)) {\n          // next(false) -> abort navigation, ensure current URL\n          this$1.ensureURL(true);\n          abort(to);\n        } else if (\n          typeof to === 'string' ||\n          (typeof to === 'object' && (\n            typeof to.path === 'string' ||\n            typeof to.name === 'string'\n          ))\n        ) {\n          // next('/') or next({ path: '/' }) -> redirect\n          abort();\n          if (typeof to === 'object' && to.replace) {\n            this$1.replace(to);\n          } else {\n            this$1.push(to);\n          }\n        } else {\n          // confirm transition and pass on the value\n          next(to);\n        }\n      });\n    } catch (e) {\n      abort(e);\n    }\n  };\n\n  runQueue(queue, iterator, function () {\n    var postEnterCbs = [];\n    var isValid = function () { return this$1.current === route; };\n    // wait until async components are resolved before\n    // extracting in-component enter guards\n    var enterGuards = extractEnterGuards(activated, postEnterCbs, isValid);\n    var queue = enterGuards.concat(this$1.router.resolveHooks);\n    runQueue(queue, iterator, function () {\n      if (this$1.pending !== route) {\n        return abort()\n      }\n      this$1.pending = null;\n      onComplete(route);\n      if (this$1.router.app) {\n        this$1.router.app.$nextTick(function () {\n          postEnterCbs.forEach(function (cb) { cb(); });\n        });\n      }\n    });\n  });\n};\n\nHistory.prototype.updateRoute = function updateRoute (route) {\n  var prev = this.current;\n  this.current = route;\n  this.cb && this.cb(route);\n  this.router.afterHooks.forEach(function (hook) {\n    hook && hook(route, prev);\n  });\n};\n\nfunction normalizeBase (base) {\n  if (!base) {\n    if (inBrowser) {\n      // respect <base> tag\n      var baseEl = document.querySelector('base');\n      base = (baseEl && baseEl.getAttribute('href')) || '/';\n      // strip full URL origin\n      base = base.replace(/^https?:\\/\\/[^\\/]+/, '');\n    } else {\n      base = '/';\n    }\n  }\n  // make sure there's the starting slash\n  if (base.charAt(0) !== '/') {\n    base = '/' + base;\n  }\n  // remove trailing slash\n  return base.replace(/\\/$/, '')\n}\n\nfunction resolveQueue (\n  current,\n  next\n) {\n  var i;\n  var max = Math.max(current.length, next.length);\n  for (i = 0; i < max; i++) {\n    if (current[i] !== next[i]) {\n      break\n    }\n  }\n  return {\n    updated: next.slice(0, i),\n    activated: next.slice(i),\n    deactivated: current.slice(i)\n  }\n}\n\nfunction extractGuards (\n  records,\n  name,\n  bind,\n  reverse\n) {\n  var guards = flatMapComponents(records, function (def, instance, match, key) {\n    var guard = extractGuard(def, name);\n    if (guard) {\n      return Array.isArray(guard)\n        ? guard.map(function (guard) { return bind(guard, instance, match, key); })\n        : bind(guard, instance, match, key)\n    }\n  });\n  return flatten(reverse ? guards.reverse() : guards)\n}\n\nfunction extractGuard (\n  def,\n  key\n) {\n  if (typeof def !== 'function') {\n    // extend now so that global mixins are applied.\n    def = _Vue.extend(def);\n  }\n  return def.options[key]\n}\n\nfunction extractLeaveGuards (deactivated) {\n  return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)\n}\n\nfunction extractUpdateHooks (updated) {\n  return extractGuards(updated, 'beforeRouteUpdate', bindGuard)\n}\n\nfunction bindGuard (guard, instance) {\n  if (instance) {\n    return function boundRouteGuard () {\n      return guard.apply(instance, arguments)\n    }\n  }\n}\n\nfunction extractEnterGuards (\n  activated,\n  cbs,\n  isValid\n) {\n  return extractGuards(activated, 'beforeRouteEnter', function (guard, _, match, key) {\n    return bindEnterGuard(guard, match, key, cbs, isValid)\n  })\n}\n\nfunction bindEnterGuard (\n  guard,\n  match,\n  key,\n  cbs,\n  isValid\n) {\n  return function routeEnterGuard (to, from, next) {\n    return guard(to, from, function (cb) {\n      next(cb);\n      if (typeof cb === 'function') {\n        cbs.push(function () {\n          // #750\n          // if a router-view is wrapped with an out-in transition,\n          // the instance may not have been registered at this time.\n          // we will need to poll for registration until current route\n          // is no longer valid.\n          poll(cb, match.instances, key, isValid);\n        });\n      }\n    })\n  }\n}\n\nfunction poll (\n  cb, // somehow flow cannot infer this is a function\n  instances,\n  key,\n  isValid\n) {\n  if (instances[key]) {\n    cb(instances[key]);\n  } else if (isValid()) {\n    setTimeout(function () {\n      poll(cb, instances, key, isValid);\n    }, 16);\n  }\n}\n\n/*  */\n\n\nvar HTML5History = (function (History$$1) {\n  function HTML5History (router, base) {\n    var this$1 = this;\n\n    History$$1.call(this, router, base);\n\n    var expectScroll = router.options.scrollBehavior;\n\n    if (expectScroll) {\n      setupScroll();\n    }\n\n    window.addEventListener('popstate', function (e) {\n      var current = this$1.current;\n      this$1.transitionTo(getLocation(this$1.base), function (route) {\n        if (expectScroll) {\n          handleScroll(router, route, current, true);\n        }\n      });\n    });\n  }\n\n  if ( History$$1 ) HTML5History.__proto__ = History$$1;\n  HTML5History.prototype = Object.create( History$$1 && History$$1.prototype );\n  HTML5History.prototype.constructor = HTML5History;\n\n  HTML5History.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HTML5History.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(location, function (route) {\n      pushState(cleanPath(this$1.base + route.fullPath));\n      handleScroll(this$1.router, route, fromRoute, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(location, function (route) {\n      replaceState(cleanPath(this$1.base + route.fullPath));\n      handleScroll(this$1.router, route, fromRoute, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.ensureURL = function ensureURL (push) {\n    if (getLocation(this.base) !== this.current.fullPath) {\n      var current = cleanPath(this.base + this.current.fullPath);\n      push ? pushState(current) : replaceState(current);\n    }\n  };\n\n  HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getLocation(this.base)\n  };\n\n  return HTML5History;\n}(History));\n\nfunction getLocation (base) {\n  var path = window.location.pathname;\n  if (base && path.indexOf(base) === 0) {\n    path = path.slice(base.length);\n  }\n  return (path || '/') + window.location.search + window.location.hash\n}\n\n/*  */\n\n\nvar HashHistory = (function (History$$1) {\n  function HashHistory (router, base, fallback) {\n    History$$1.call(this, router, base);\n    // check history fallback deeplinking\n    if (fallback && checkFallback(this.base)) {\n      return\n    }\n    ensureSlash();\n  }\n\n  if ( History$$1 ) HashHistory.__proto__ = History$$1;\n  HashHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n  HashHistory.prototype.constructor = HashHistory;\n\n  // this is delayed until the app mounts\n  // to avoid the hashchange listener being fired too early\n  HashHistory.prototype.setupListeners = function setupListeners () {\n    var this$1 = this;\n\n    window.addEventListener('hashchange', function () {\n      if (!ensureSlash()) {\n        return\n      }\n      this$1.transitionTo(getHash(), function (route) {\n        replaceHash(route.fullPath);\n      });\n    });\n  };\n\n  HashHistory.prototype.push = function push (location, onComplete, onAbort) {\n    this.transitionTo(location, function (route) {\n      pushHash(route.fullPath);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    this.transitionTo(location, function (route) {\n      replaceHash(route.fullPath);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HashHistory.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HashHistory.prototype.ensureURL = function ensureURL (push) {\n    var current = this.current.fullPath;\n    if (getHash() !== current) {\n      push ? pushHash(current) : replaceHash(current);\n    }\n  };\n\n  HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getHash()\n  };\n\n  return HashHistory;\n}(History));\n\nfunction checkFallback (base) {\n  var location = getLocation(base);\n  if (!/^\\/#/.test(location)) {\n    window.location.replace(\n      cleanPath(base + '/#' + location)\n    );\n    return true\n  }\n}\n\nfunction ensureSlash () {\n  var path = getHash();\n  if (path.charAt(0) === '/') {\n    return true\n  }\n  replaceHash('/' + path);\n  return false\n}\n\nfunction getHash () {\n  // We can't use window.location.hash here because it's not\n  // consistent across browsers - Firefox will pre-decode it!\n  var href = window.location.href;\n  var index = href.indexOf('#');\n  return index === -1 ? '' : href.slice(index + 1)\n}\n\nfunction pushHash (path) {\n  window.location.hash = path;\n}\n\nfunction replaceHash (path) {\n  var href = window.location.href;\n  var i = href.indexOf('#');\n  var base = i >= 0 ? href.slice(0, i) : href;\n  window.location.replace((base + \"#\" + path));\n}\n\n/*  */\n\n\nvar AbstractHistory = (function (History$$1) {\n  function AbstractHistory (router, base) {\n    History$$1.call(this, router, base);\n    this.stack = [];\n    this.index = -1;\n  }\n\n  if ( History$$1 ) AbstractHistory.__proto__ = History$$1;\n  AbstractHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n  AbstractHistory.prototype.constructor = AbstractHistory;\n\n  AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      this$1.stack = this$1.stack.slice(0, this$1.index + 1).concat(route);\n      this$1.index++;\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      this$1.stack = this$1.stack.slice(0, this$1.index).concat(route);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  AbstractHistory.prototype.go = function go (n) {\n    var this$1 = this;\n\n    var targetIndex = this.index + n;\n    if (targetIndex < 0 || targetIndex >= this.stack.length) {\n      return\n    }\n    var route = this.stack[targetIndex];\n    this.confirmTransition(route, function () {\n      this$1.index = targetIndex;\n      this$1.updateRoute(route);\n    });\n  };\n\n  AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    var current = this.stack[this.stack.length - 1];\n    return current ? current.fullPath : '/'\n  };\n\n  AbstractHistory.prototype.ensureURL = function ensureURL () {\n    // noop\n  };\n\n  return AbstractHistory;\n}(History));\n\n/*  */\n\nvar VueRouter = function VueRouter (options) {\n  if ( options === void 0 ) options = {};\n\n  this.app = null;\n  this.apps = [];\n  this.options = options;\n  this.beforeHooks = [];\n  this.resolveHooks = [];\n  this.afterHooks = [];\n  this.matcher = createMatcher(options.routes || [], this);\n\n  var mode = options.mode || 'hash';\n  this.fallback = mode === 'history' && !supportsPushState && options.fallback !== false;\n  if (this.fallback) {\n    mode = 'hash';\n  }\n  if (!inBrowser) {\n    mode = 'abstract';\n  }\n  this.mode = mode;\n\n  switch (mode) {\n    case 'history':\n      this.history = new HTML5History(this, options.base);\n      break\n    case 'hash':\n      this.history = new HashHistory(this, options.base, this.fallback);\n      break\n    case 'abstract':\n      this.history = new AbstractHistory(this, options.base);\n      break\n    default:\n      {\n        assert(false, (\"invalid mode: \" + mode));\n      }\n  }\n};\n\nvar prototypeAccessors = { currentRoute: {} };\n\nVueRouter.prototype.match = function match (\n  raw,\n  current,\n  redirectedFrom\n) {\n  return this.matcher.match(raw, current, redirectedFrom)\n};\n\nprototypeAccessors.currentRoute.get = function () {\n  return this.history && this.history.current\n};\n\nVueRouter.prototype.init = function init (app /* Vue component instance */) {\n    var this$1 = this;\n\n  \"development\" !== 'production' && assert(\n    install.installed,\n    \"not installed. Make sure to call `Vue.use(VueRouter)` \" +\n    \"before creating root instance.\"\n  );\n\n  this.apps.push(app);\n\n  // main app already initialized.\n  if (this.app) {\n    return\n  }\n\n  this.app = app;\n\n  var history = this.history;\n\n  if (history instanceof HTML5History) {\n    history.transitionTo(history.getCurrentLocation());\n  } else if (history instanceof HashHistory) {\n    var setupHashListener = function () {\n      history.setupListeners();\n    };\n    history.transitionTo(\n      history.getCurrentLocation(),\n      setupHashListener,\n      setupHashListener\n    );\n  }\n\n  history.listen(function (route) {\n    this$1.apps.forEach(function (app) {\n      app._route = route;\n    });\n  });\n};\n\nVueRouter.prototype.beforeEach = function beforeEach (fn) {\n  return registerHook(this.beforeHooks, fn)\n};\n\nVueRouter.prototype.beforeResolve = function beforeResolve (fn) {\n  return registerHook(this.resolveHooks, fn)\n};\n\nVueRouter.prototype.afterEach = function afterEach (fn) {\n  return registerHook(this.afterHooks, fn)\n};\n\nVueRouter.prototype.onReady = function onReady (cb, errorCb) {\n  this.history.onReady(cb, errorCb);\n};\n\nVueRouter.prototype.onError = function onError (errorCb) {\n  this.history.onError(errorCb);\n};\n\nVueRouter.prototype.push = function push (location, onComplete, onAbort) {\n  this.history.push(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.replace = function replace (location, onComplete, onAbort) {\n  this.history.replace(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.go = function go (n) {\n  this.history.go(n);\n};\n\nVueRouter.prototype.back = function back () {\n  this.go(-1);\n};\n\nVueRouter.prototype.forward = function forward () {\n  this.go(1);\n};\n\nVueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {\n  var route = to\n    ? to.matched\n      ? to\n      : this.resolve(to).route\n    : this.currentRoute;\n  if (!route) {\n    return []\n  }\n  return [].concat.apply([], route.matched.map(function (m) {\n    return Object.keys(m.components).map(function (key) {\n      return m.components[key]\n    })\n  }))\n};\n\nVueRouter.prototype.resolve = function resolve (\n  to,\n  current,\n  append\n) {\n  var location = normalizeLocation(\n    to,\n    current || this.history.current,\n    append,\n    this\n  );\n  var route = this.match(location, current);\n  var fullPath = route.redirectedFrom || route.fullPath;\n  var base = this.history.base;\n  var href = createHref(base, fullPath, this.mode);\n  return {\n    location: location,\n    route: route,\n    href: href,\n    // for backwards compat\n    normalizedTo: location,\n    resolved: route\n  }\n};\n\nVueRouter.prototype.addRoutes = function addRoutes (routes) {\n  this.matcher.addRoutes(routes);\n  if (this.history.current !== START) {\n    this.history.transitionTo(this.history.getCurrentLocation());\n  }\n};\n\nObject.defineProperties( VueRouter.prototype, prototypeAccessors );\n\nfunction registerHook (list, fn) {\n  list.push(fn);\n  return function () {\n    var i = list.indexOf(fn);\n    if (i > -1) { list.splice(i, 1); }\n  }\n}\n\nfunction createHref (base, fullPath, mode) {\n  var path = mode === 'hash' ? '#' + fullPath : fullPath;\n  return base ? cleanPath(base + '/' + path) : path\n}\n\nVueRouter.install = install;\nVueRouter.version = '2.7.0';\n\nif (inBrowser && window.Vue) {\n  window.Vue.use(VueRouter);\n}\n\nreturn VueRouter;\n\n})));\n\n\n/***/ }),\n\n/***/ 11:\n/***/ (function(module, exports) {\n\nvar 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\n/***/ 1171:\n/***/ (function(module, exports, __webpack_require__) {\n\n/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\n\nvar stylesInDom = {};\n\nvar\tmemoize = function (fn) {\n\tvar memo;\n\n\treturn function () {\n\t\tif (typeof memo === \"undefined\") memo = fn.apply(this, arguments);\n\t\treturn memo;\n\t};\n};\n\nvar isOldIE = memoize(function () {\n\t// Test for IE <= 9 as proposed by Browserhacks\n\t// @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805\n\t// Tests for existence of standard globals is to allow style-loader\n\t// to operate correctly into non-standard environments\n\t// @see https://github.com/webpack-contrib/style-loader/issues/177\n\treturn window && document && document.all && !window.atob;\n});\n\nvar getElement = (function (fn) {\n\tvar memo = {};\n\n\treturn function(selector) {\n\t\tif (typeof memo[selector] === \"undefined\") {\n\t\t\tmemo[selector] = fn.call(this, selector);\n\t\t}\n\n\t\treturn memo[selector]\n\t};\n})(function (target) {\n\treturn document.querySelector(target)\n});\n\nvar singleton = null;\nvar\tsingletonCounter = 0;\nvar\tstylesInsertedAtTop = [];\n\nvar\tfixUrls = __webpack_require__(233);\n\nmodule.exports = function(list, options) {\n\tif (typeof DEBUG !== \"undefined\" && DEBUG) {\n\t\tif (typeof document !== \"object\") throw new Error(\"The style-loader cannot be used in a non-browser environment\");\n\t}\n\n\toptions = options || {};\n\n\toptions.attrs = typeof options.attrs === \"object\" ? options.attrs : {};\n\n\t// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\n\t// tags it will allow on a page\n\tif (!options.singleton) options.singleton = isOldIE();\n\n\t// By default, add <style> tags to the <head> element\n\tif (!options.insertInto) options.insertInto = \"head\";\n\n\t// By default, add <style> tags to the bottom of the target\n\tif (!options.insertAt) options.insertAt = \"bottom\";\n\n\tvar styles = listToStyles(list, options);\n\n\taddStylesToDom(styles, options);\n\n\treturn function update (newList) {\n\t\tvar mayRemove = [];\n\n\t\tfor (var i = 0; i < styles.length; i++) {\n\t\t\tvar item = styles[i];\n\t\t\tvar domStyle = stylesInDom[item.id];\n\n\t\t\tdomStyle.refs--;\n\t\t\tmayRemove.push(domStyle);\n\t\t}\n\n\t\tif(newList) {\n\t\t\tvar newStyles = listToStyles(newList, options);\n\t\t\taddStylesToDom(newStyles, options);\n\t\t}\n\n\t\tfor (var i = 0; i < mayRemove.length; i++) {\n\t\t\tvar domStyle = mayRemove[i];\n\n\t\t\tif(domStyle.refs === 0) {\n\t\t\t\tfor (var j = 0; j < domStyle.parts.length; j++) domStyle.parts[j]();\n\n\t\t\t\tdelete stylesInDom[domStyle.id];\n\t\t\t}\n\t\t}\n\t};\n};\n\nfunction addStylesToDom (styles, options) {\n\tfor (var i = 0; i < styles.length; i++) {\n\t\tvar item = styles[i];\n\t\tvar domStyle = stylesInDom[item.id];\n\n\t\tif(domStyle) {\n\t\t\tdomStyle.refs++;\n\n\t\t\tfor(var j = 0; j < domStyle.parts.length; j++) {\n\t\t\t\tdomStyle.parts[j](item.parts[j]);\n\t\t\t}\n\n\t\t\tfor(; j < item.parts.length; j++) {\n\t\t\t\tdomStyle.parts.push(addStyle(item.parts[j], options));\n\t\t\t}\n\t\t} else {\n\t\t\tvar parts = [];\n\n\t\t\tfor(var j = 0; j < item.parts.length; j++) {\n\t\t\t\tparts.push(addStyle(item.parts[j], options));\n\t\t\t}\n\n\t\t\tstylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};\n\t\t}\n\t}\n}\n\nfunction listToStyles (list, options) {\n\tvar styles = [];\n\tvar newStyles = {};\n\n\tfor (var i = 0; i < list.length; i++) {\n\t\tvar item = list[i];\n\t\tvar id = options.base ? item[0] + options.base : item[0];\n\t\tvar css = item[1];\n\t\tvar media = item[2];\n\t\tvar sourceMap = item[3];\n\t\tvar part = {css: css, media: media, sourceMap: sourceMap};\n\n\t\tif(!newStyles[id]) styles.push(newStyles[id] = {id: id, parts: [part]});\n\t\telse newStyles[id].parts.push(part);\n\t}\n\n\treturn styles;\n}\n\nfunction insertStyleElement (options, style) {\n\tvar target = getElement(options.insertInto)\n\n\tif (!target) {\n\t\tthrow new Error(\"Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid.\");\n\t}\n\n\tvar lastStyleElementInsertedAtTop = stylesInsertedAtTop[stylesInsertedAtTop.length - 1];\n\n\tif (options.insertAt === \"top\") {\n\t\tif (!lastStyleElementInsertedAtTop) {\n\t\t\ttarget.insertBefore(style, target.firstChild);\n\t\t} else if (lastStyleElementInsertedAtTop.nextSibling) {\n\t\t\ttarget.insertBefore(style, lastStyleElementInsertedAtTop.nextSibling);\n\t\t} else {\n\t\t\ttarget.appendChild(style);\n\t\t}\n\t\tstylesInsertedAtTop.push(style);\n\t} else if (options.insertAt === \"bottom\") {\n\t\ttarget.appendChild(style);\n\t} else {\n\t\tthrow new Error(\"Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.\");\n\t}\n}\n\nfunction removeStyleElement (style) {\n\tif (style.parentNode === null) return false;\n\tstyle.parentNode.removeChild(style);\n\n\tvar idx = stylesInsertedAtTop.indexOf(style);\n\tif(idx >= 0) {\n\t\tstylesInsertedAtTop.splice(idx, 1);\n\t}\n}\n\nfunction createStyleElement (options) {\n\tvar style = document.createElement(\"style\");\n\n\toptions.attrs.type = \"text/css\";\n\n\taddAttrs(style, options.attrs);\n\tinsertStyleElement(options, style);\n\n\treturn style;\n}\n\nfunction createLinkElement (options) {\n\tvar link = document.createElement(\"link\");\n\n\toptions.attrs.type = \"text/css\";\n\toptions.attrs.rel = \"stylesheet\";\n\n\taddAttrs(link, options.attrs);\n\tinsertStyleElement(options, link);\n\n\treturn link;\n}\n\nfunction addAttrs (el, attrs) {\n\tObject.keys(attrs).forEach(function (key) {\n\t\tel.setAttribute(key, attrs[key]);\n\t});\n}\n\nfunction addStyle (obj, options) {\n\tvar style, update, remove, result;\n\n\t// If a transform function was defined, run it on the css\n\tif (options.transform && obj.css) {\n\t    result = options.transform(obj.css);\n\n\t    if (result) {\n\t    \t// If transform returns a value, use that instead of the original css.\n\t    \t// This allows running runtime transformations on the css.\n\t    \tobj.css = result;\n\t    } else {\n\t    \t// If the transform function returns a falsy value, don't add this css.\n\t    \t// This allows conditional loading of css\n\t    \treturn function() {\n\t    \t\t// noop\n\t    \t};\n\t    }\n\t}\n\n\tif (options.singleton) {\n\t\tvar styleIndex = singletonCounter++;\n\n\t\tstyle = singleton || (singleton = createStyleElement(options));\n\n\t\tupdate = applyToSingletonTag.bind(null, style, styleIndex, false);\n\t\tremove = applyToSingletonTag.bind(null, style, styleIndex, true);\n\n\t} else if (\n\t\tobj.sourceMap &&\n\t\ttypeof URL === \"function\" &&\n\t\ttypeof URL.createObjectURL === \"function\" &&\n\t\ttypeof URL.revokeObjectURL === \"function\" &&\n\t\ttypeof Blob === \"function\" &&\n\t\ttypeof btoa === \"function\"\n\t) {\n\t\tstyle = createLinkElement(options);\n\t\tupdate = updateLink.bind(null, style, options);\n\t\tremove = function () {\n\t\t\tremoveStyleElement(style);\n\n\t\t\tif(style.href) URL.revokeObjectURL(style.href);\n\t\t};\n\t} else {\n\t\tstyle = createStyleElement(options);\n\t\tupdate = applyToTag.bind(null, style);\n\t\tremove = function () {\n\t\t\tremoveStyleElement(style);\n\t\t};\n\t}\n\n\tupdate(obj);\n\n\treturn function updateStyle (newObj) {\n\t\tif (newObj) {\n\t\t\tif (\n\t\t\t\tnewObj.css === obj.css &&\n\t\t\t\tnewObj.media === obj.media &&\n\t\t\t\tnewObj.sourceMap === obj.sourceMap\n\t\t\t) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tupdate(obj = newObj);\n\t\t} else {\n\t\t\tremove();\n\t\t}\n\t};\n}\n\nvar replaceText = (function () {\n\tvar textStore = [];\n\n\treturn function (index, replacement) {\n\t\ttextStore[index] = replacement;\n\n\t\treturn textStore.filter(Boolean).join('\\n');\n\t};\n})();\n\nfunction applyToSingletonTag (style, index, remove, obj) {\n\tvar css = remove ? \"\" : obj.css;\n\n\tif (style.styleSheet) {\n\t\tstyle.styleSheet.cssText = replaceText(index, css);\n\t} else {\n\t\tvar cssNode = document.createTextNode(css);\n\t\tvar childNodes = style.childNodes;\n\n\t\tif (childNodes[index]) style.removeChild(childNodes[index]);\n\n\t\tif (childNodes.length) {\n\t\t\tstyle.insertBefore(cssNode, childNodes[index]);\n\t\t} else {\n\t\t\tstyle.appendChild(cssNode);\n\t\t}\n\t}\n}\n\nfunction applyToTag (style, obj) {\n\tvar css = obj.css;\n\tvar media = obj.media;\n\n\tif(media) {\n\t\tstyle.setAttribute(\"media\", media)\n\t}\n\n\tif(style.styleSheet) {\n\t\tstyle.styleSheet.cssText = css;\n\t} else {\n\t\twhile(style.firstChild) {\n\t\t\tstyle.removeChild(style.firstChild);\n\t\t}\n\n\t\tstyle.appendChild(document.createTextNode(css));\n\t}\n}\n\nfunction updateLink (link, options, obj) {\n\tvar css = obj.css;\n\tvar sourceMap = obj.sourceMap;\n\n\t/*\n\t\tIf convertToAbsoluteUrls isn't defined, but sourcemaps are enabled\n\t\tand there is no publicPath defined then lets turn convertToAbsoluteUrls\n\t\ton by default.  Otherwise default to the convertToAbsoluteUrls option\n\t\tdirectly\n\t*/\n\tvar autoFixUrls = options.convertToAbsoluteUrls === undefined && sourceMap;\n\n\tif (options.convertToAbsoluteUrls || autoFixUrls) {\n\t\tcss = fixUrls(css);\n\t}\n\n\tif (sourceMap) {\n\t\t// http://stackoverflow.com/a/26603875\n\t\tcss += \"\\n/*# sourceMappingURL=data:application/json;base64,\" + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + \" */\";\n\t}\n\n\tvar blob = new Blob([css], { type: \"text/css\" });\n\n\tvar oldSrc = link.href;\n\n\tlink.href = URL.createObjectURL(blob);\n\n\tif(oldSrc) URL.revokeObjectURL(oldSrc);\n}\n\n\n/***/ }),\n\n/***/ 139:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Enforces a single instance of the Raven client, and the\n * main entry point for Raven. If you are a consumer of the\n * Raven library, you SHOULD load this file (vs raven.js).\n **/\n\n\n\nvar RavenConstructor = __webpack_require__(235);\n\n// This is to be defensive in environments where window does not exist (see https://github.com/getsentry/raven-js/pull/785)\nvar _window = typeof window !== 'undefined' ? window\n            : typeof global !== 'undefined' ? global\n            : typeof self !== 'undefined' ? self\n            : {};\nvar _Raven = _window.Raven;\n\nvar Raven = new RavenConstructor();\n\n/*\n * Allow multiple versions of Raven to be installed.\n * Strip Raven from the global context and returns the instance.\n *\n * @return {Raven}\n */\nRaven.noConflict = function () {\n\t_window.Raven = _Raven;\n\treturn Raven;\n};\n\nRaven.afterLoad();\n\nmodule.exports = Raven;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(11)))\n\n/***/ }),\n\n/***/ 14:\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(module) {//! moment.js\n//! version : 2.18.1\n//! authors : Tim Wood, Iskren Chernev, Moment.js contributors\n//! license : MIT\n//! momentjs.com\n\n;(function (global, factory) {\n     true ? module.exports = factory() :\n    typeof define === 'function' && define.amd ? define(factory) :\n    global.moment = factory()\n}(this, (function () { 'use strict';\n\nvar hookCallback;\n\nfunction hooks () {\n    return hookCallback.apply(null, arguments);\n}\n\n// This is done to register the method called with moment()\n// without creating circular dependencies.\nfunction setHookCallback (callback) {\n    hookCallback = callback;\n}\n\nfunction isArray(input) {\n    return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';\n}\n\nfunction isObject(input) {\n    // IE8 will treat undefined and null as object if it wasn't for\n    // input != null\n    return input != null && Object.prototype.toString.call(input) === '[object Object]';\n}\n\nfunction isObjectEmpty(obj) {\n    var k;\n    for (k in obj) {\n        // even if its not own property I'd still call it non-empty\n        return false;\n    }\n    return true;\n}\n\nfunction isUndefined(input) {\n    return input === void 0;\n}\n\nfunction isNumber(input) {\n    return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';\n}\n\nfunction isDate(input) {\n    return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';\n}\n\nfunction map(arr, fn) {\n    var res = [], i;\n    for (i = 0; i < arr.length; ++i) {\n        res.push(fn(arr[i], i));\n    }\n    return res;\n}\n\nfunction hasOwnProp(a, b) {\n    return Object.prototype.hasOwnProperty.call(a, b);\n}\n\nfunction extend(a, b) {\n    for (var i in b) {\n        if (hasOwnProp(b, i)) {\n            a[i] = b[i];\n        }\n    }\n\n    if (hasOwnProp(b, 'toString')) {\n        a.toString = b.toString;\n    }\n\n    if (hasOwnProp(b, 'valueOf')) {\n        a.valueOf = b.valueOf;\n    }\n\n    return a;\n}\n\nfunction createUTC (input, format, locale, strict) {\n    return createLocalOrUTC(input, format, locale, strict, true).utc();\n}\n\nfunction defaultParsingFlags() {\n    // We need to deep clone this object.\n    return {\n        empty           : false,\n        unusedTokens    : [],\n        unusedInput     : [],\n        overflow        : -2,\n        charsLeftOver   : 0,\n        nullInput       : false,\n        invalidMonth    : null,\n        invalidFormat   : false,\n        userInvalidated : false,\n        iso             : false,\n        parsedDateParts : [],\n        meridiem        : null,\n        rfc2822         : false,\n        weekdayMismatch : false\n    };\n}\n\nfunction getParsingFlags(m) {\n    if (m._pf == null) {\n        m._pf = defaultParsingFlags();\n    }\n    return m._pf;\n}\n\nvar some;\nif (Array.prototype.some) {\n    some = Array.prototype.some;\n} else {\n    some = function (fun) {\n        var t = Object(this);\n        var len = t.length >>> 0;\n\n        for (var i = 0; i < len; i++) {\n            if (i in t && fun.call(this, t[i], i, t)) {\n                return true;\n            }\n        }\n\n        return false;\n    };\n}\n\nvar some$1 = some;\n\nfunction isValid(m) {\n    if (m._isValid == null) {\n        var flags = getParsingFlags(m);\n        var parsedParts = some$1.call(flags.parsedDateParts, function (i) {\n            return i != null;\n        });\n        var isNowValid = !isNaN(m._d.getTime()) &&\n            flags.overflow < 0 &&\n            !flags.empty &&\n            !flags.invalidMonth &&\n            !flags.invalidWeekday &&\n            !flags.nullInput &&\n            !flags.invalidFormat &&\n            !flags.userInvalidated &&\n            (!flags.meridiem || (flags.meridiem && parsedParts));\n\n        if (m._strict) {\n            isNowValid = isNowValid &&\n                flags.charsLeftOver === 0 &&\n                flags.unusedTokens.length === 0 &&\n                flags.bigHour === undefined;\n        }\n\n        if (Object.isFrozen == null || !Object.isFrozen(m)) {\n            m._isValid = isNowValid;\n        }\n        else {\n            return isNowValid;\n        }\n    }\n    return m._isValid;\n}\n\nfunction createInvalid (flags) {\n    var m = createUTC(NaN);\n    if (flags != null) {\n        extend(getParsingFlags(m), flags);\n    }\n    else {\n        getParsingFlags(m).userInvalidated = true;\n    }\n\n    return m;\n}\n\n// Plugins that add properties should also add the key here (null value),\n// so we can properly clone ourselves.\nvar momentProperties = hooks.momentProperties = [];\n\nfunction copyConfig(to, from) {\n    var i, prop, val;\n\n    if (!isUndefined(from._isAMomentObject)) {\n        to._isAMomentObject = from._isAMomentObject;\n    }\n    if (!isUndefined(from._i)) {\n        to._i = from._i;\n    }\n    if (!isUndefined(from._f)) {\n        to._f = from._f;\n    }\n    if (!isUndefined(from._l)) {\n        to._l = from._l;\n    }\n    if (!isUndefined(from._strict)) {\n        to._strict = from._strict;\n    }\n    if (!isUndefined(from._tzm)) {\n        to._tzm = from._tzm;\n    }\n    if (!isUndefined(from._isUTC)) {\n        to._isUTC = from._isUTC;\n    }\n    if (!isUndefined(from._offset)) {\n        to._offset = from._offset;\n    }\n    if (!isUndefined(from._pf)) {\n        to._pf = getParsingFlags(from);\n    }\n    if (!isUndefined(from._locale)) {\n        to._locale = from._locale;\n    }\n\n    if (momentProperties.length > 0) {\n        for (i = 0; i < momentProperties.length; i++) {\n            prop = momentProperties[i];\n            val = from[prop];\n            if (!isUndefined(val)) {\n                to[prop] = val;\n            }\n        }\n    }\n\n    return to;\n}\n\nvar updateInProgress = false;\n\n// Moment prototype object\nfunction Moment(config) {\n    copyConfig(this, config);\n    this._d = new Date(config._d != null ? config._d.getTime() : NaN);\n    if (!this.isValid()) {\n        this._d = new Date(NaN);\n    }\n    // Prevent infinite loop in case updateOffset creates new moment\n    // objects.\n    if (updateInProgress === false) {\n        updateInProgress = true;\n        hooks.updateOffset(this);\n        updateInProgress = false;\n    }\n}\n\nfunction isMoment (obj) {\n    return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);\n}\n\nfunction absFloor (number) {\n    if (number < 0) {\n        // -0 -> 0\n        return Math.ceil(number) || 0;\n    } else {\n        return Math.floor(number);\n    }\n}\n\nfunction toInt(argumentForCoercion) {\n    var coercedNumber = +argumentForCoercion,\n        value = 0;\n\n    if (coercedNumber !== 0 && isFinite(coercedNumber)) {\n        value = absFloor(coercedNumber);\n    }\n\n    return value;\n}\n\n// compare two arrays, return the number of differences\nfunction compareArrays(array1, array2, dontConvert) {\n    var len = Math.min(array1.length, array2.length),\n        lengthDiff = Math.abs(array1.length - array2.length),\n        diffs = 0,\n        i;\n    for (i = 0; i < len; i++) {\n        if ((dontConvert && array1[i] !== array2[i]) ||\n            (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {\n            diffs++;\n        }\n    }\n    return diffs + lengthDiff;\n}\n\nfunction warn(msg) {\n    if (hooks.suppressDeprecationWarnings === false &&\n            (typeof console !==  'undefined') && console.warn) {\n        console.warn('Deprecation warning: ' + msg);\n    }\n}\n\nfunction deprecate(msg, fn) {\n    var firstTime = true;\n\n    return extend(function () {\n        if (hooks.deprecationHandler != null) {\n            hooks.deprecationHandler(null, msg);\n        }\n        if (firstTime) {\n            var args = [];\n            var arg;\n            for (var i = 0; i < arguments.length; i++) {\n                arg = '';\n                if (typeof arguments[i] === 'object') {\n                    arg += '\\n[' + i + '] ';\n                    for (var key in arguments[0]) {\n                        arg += key + ': ' + arguments[0][key] + ', ';\n                    }\n                    arg = arg.slice(0, -2); // Remove trailing comma and space\n                } else {\n                    arg = arguments[i];\n                }\n                args.push(arg);\n            }\n            warn(msg + '\\nArguments: ' + Array.prototype.slice.call(args).join('') + '\\n' + (new Error()).stack);\n            firstTime = false;\n        }\n        return fn.apply(this, arguments);\n    }, fn);\n}\n\nvar deprecations = {};\n\nfunction deprecateSimple(name, msg) {\n    if (hooks.deprecationHandler != null) {\n        hooks.deprecationHandler(name, msg);\n    }\n    if (!deprecations[name]) {\n        warn(msg);\n        deprecations[name] = true;\n    }\n}\n\nhooks.suppressDeprecationWarnings = false;\nhooks.deprecationHandler = null;\n\nfunction isFunction(input) {\n    return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';\n}\n\nfunction set (config) {\n    var prop, i;\n    for (i in config) {\n        prop = config[i];\n        if (isFunction(prop)) {\n            this[i] = prop;\n        } else {\n            this['_' + i] = prop;\n        }\n    }\n    this._config = config;\n    // Lenient ordinal parsing accepts just a number in addition to\n    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.\n    // TODO: Remove \"ordinalParse\" fallback in next major release.\n    this._dayOfMonthOrdinalParseLenient = new RegExp(\n        (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +\n            '|' + (/\\d{1,2}/).source);\n}\n\nfunction mergeConfigs(parentConfig, childConfig) {\n    var res = extend({}, parentConfig), prop;\n    for (prop in childConfig) {\n        if (hasOwnProp(childConfig, prop)) {\n            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {\n                res[prop] = {};\n                extend(res[prop], parentConfig[prop]);\n                extend(res[prop], childConfig[prop]);\n            } else if (childConfig[prop] != null) {\n                res[prop] = childConfig[prop];\n            } else {\n                delete res[prop];\n            }\n        }\n    }\n    for (prop in parentConfig) {\n        if (hasOwnProp(parentConfig, prop) &&\n                !hasOwnProp(childConfig, prop) &&\n                isObject(parentConfig[prop])) {\n            // make sure changes to properties don't modify parent config\n            res[prop] = extend({}, res[prop]);\n        }\n    }\n    return res;\n}\n\nfunction Locale(config) {\n    if (config != null) {\n        this.set(config);\n    }\n}\n\nvar keys;\n\nif (Object.keys) {\n    keys = Object.keys;\n} else {\n    keys = function (obj) {\n        var i, res = [];\n        for (i in obj) {\n            if (hasOwnProp(obj, i)) {\n                res.push(i);\n            }\n        }\n        return res;\n    };\n}\n\nvar keys$1 = keys;\n\nvar defaultCalendar = {\n    sameDay : '[Today at] LT',\n    nextDay : '[Tomorrow at] LT',\n    nextWeek : 'dddd [at] LT',\n    lastDay : '[Yesterday at] LT',\n    lastWeek : '[Last] dddd [at] LT',\n    sameElse : 'L'\n};\n\nfunction calendar (key, mom, now) {\n    var output = this._calendar[key] || this._calendar['sameElse'];\n    return isFunction(output) ? output.call(mom, now) : output;\n}\n\nvar defaultLongDateFormat = {\n    LTS  : 'h:mm:ss A',\n    LT   : 'h:mm A',\n    L    : 'MM/DD/YYYY',\n    LL   : 'MMMM D, YYYY',\n    LLL  : 'MMMM D, YYYY h:mm A',\n    LLLL : 'dddd, MMMM D, YYYY h:mm A'\n};\n\nfunction longDateFormat (key) {\n    var format = this._longDateFormat[key],\n        formatUpper = this._longDateFormat[key.toUpperCase()];\n\n    if (format || !formatUpper) {\n        return format;\n    }\n\n    this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {\n        return val.slice(1);\n    });\n\n    return this._longDateFormat[key];\n}\n\nvar defaultInvalidDate = 'Invalid date';\n\nfunction invalidDate () {\n    return this._invalidDate;\n}\n\nvar defaultOrdinal = '%d';\nvar defaultDayOfMonthOrdinalParse = /\\d{1,2}/;\n\nfunction ordinal (number) {\n    return this._ordinal.replace('%d', number);\n}\n\nvar defaultRelativeTime = {\n    future : 'in %s',\n    past   : '%s ago',\n    s  : 'a few seconds',\n    ss : '%d seconds',\n    m  : 'a minute',\n    mm : '%d minutes',\n    h  : 'an hour',\n    hh : '%d hours',\n    d  : 'a day',\n    dd : '%d days',\n    M  : 'a month',\n    MM : '%d months',\n    y  : 'a year',\n    yy : '%d years'\n};\n\nfunction relativeTime (number, withoutSuffix, string, isFuture) {\n    var output = this._relativeTime[string];\n    return (isFunction(output)) ?\n        output(number, withoutSuffix, string, isFuture) :\n        output.replace(/%d/i, number);\n}\n\nfunction pastFuture (diff, output) {\n    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];\n    return isFunction(format) ? format(output) : format.replace(/%s/i, output);\n}\n\nvar aliases = {};\n\nfunction addUnitAlias (unit, shorthand) {\n    var lowerCase = unit.toLowerCase();\n    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;\n}\n\nfunction normalizeUnits(units) {\n    return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;\n}\n\nfunction normalizeObjectUnits(inputObject) {\n    var normalizedInput = {},\n        normalizedProp,\n        prop;\n\n    for (prop in inputObject) {\n        if (hasOwnProp(inputObject, prop)) {\n            normalizedProp = normalizeUnits(prop);\n            if (normalizedProp) {\n                normalizedInput[normalizedProp] = inputObject[prop];\n            }\n        }\n    }\n\n    return normalizedInput;\n}\n\nvar priorities = {};\n\nfunction addUnitPriority(unit, priority) {\n    priorities[unit] = priority;\n}\n\nfunction getPrioritizedUnits(unitsObj) {\n    var units = [];\n    for (var u in unitsObj) {\n        units.push({unit: u, priority: priorities[u]});\n    }\n    units.sort(function (a, b) {\n        return a.priority - b.priority;\n    });\n    return units;\n}\n\nfunction makeGetSet (unit, keepTime) {\n    return function (value) {\n        if (value != null) {\n            set$1(this, unit, value);\n            hooks.updateOffset(this, keepTime);\n            return this;\n        } else {\n            return get(this, unit);\n        }\n    };\n}\n\nfunction get (mom, unit) {\n    return mom.isValid() ?\n        mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;\n}\n\nfunction set$1 (mom, unit, value) {\n    if (mom.isValid()) {\n        mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);\n    }\n}\n\n// MOMENTS\n\nfunction stringGet (units) {\n    units = normalizeUnits(units);\n    if (isFunction(this[units])) {\n        return this[units]();\n    }\n    return this;\n}\n\n\nfunction stringSet (units, value) {\n    if (typeof units === 'object') {\n        units = normalizeObjectUnits(units);\n        var prioritized = getPrioritizedUnits(units);\n        for (var i = 0; i < prioritized.length; i++) {\n            this[prioritized[i].unit](units[prioritized[i].unit]);\n        }\n    } else {\n        units = normalizeUnits(units);\n        if (isFunction(this[units])) {\n            return this[units](value);\n        }\n    }\n    return this;\n}\n\nfunction zeroFill(number, targetLength, forceSign) {\n    var absNumber = '' + Math.abs(number),\n        zerosToFill = targetLength - absNumber.length,\n        sign = number >= 0;\n    return (sign ? (forceSign ? '+' : '') : '-') +\n        Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;\n}\n\nvar formattingTokens = /(\\[[^\\[]*\\])|(\\\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;\n\nvar localFormattingTokens = /(\\[[^\\[]*\\])|(\\\\)?(LTS|LT|LL?L?L?|l{1,4})/g;\n\nvar formatFunctions = {};\n\nvar formatTokenFunctions = {};\n\n// token:    'M'\n// padded:   ['MM', 2]\n// ordinal:  'Mo'\n// callback: function () { this.month() + 1 }\nfunction addFormatToken (token, padded, ordinal, callback) {\n    var func = callback;\n    if (typeof callback === 'string') {\n        func = function () {\n            return this[callback]();\n        };\n    }\n    if (token) {\n        formatTokenFunctions[token] = func;\n    }\n    if (padded) {\n        formatTokenFunctions[padded[0]] = function () {\n            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);\n        };\n    }\n    if (ordinal) {\n        formatTokenFunctions[ordinal] = function () {\n            return this.localeData().ordinal(func.apply(this, arguments), token);\n        };\n    }\n}\n\nfunction removeFormattingTokens(input) {\n    if (input.match(/\\[[\\s\\S]/)) {\n        return input.replace(/^\\[|\\]$/g, '');\n    }\n    return input.replace(/\\\\/g, '');\n}\n\nfunction makeFormatFunction(format) {\n    var array = format.match(formattingTokens), i, length;\n\n    for (i = 0, length = array.length; i < length; i++) {\n        if (formatTokenFunctions[array[i]]) {\n            array[i] = formatTokenFunctions[array[i]];\n        } else {\n            array[i] = removeFormattingTokens(array[i]);\n        }\n    }\n\n    return function (mom) {\n        var output = '', i;\n        for (i = 0; i < length; i++) {\n            output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];\n        }\n        return output;\n    };\n}\n\n// format date using native date object\nfunction formatMoment(m, format) {\n    if (!m.isValid()) {\n        return m.localeData().invalidDate();\n    }\n\n    format = expandFormat(format, m.localeData());\n    formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);\n\n    return formatFunctions[format](m);\n}\n\nfunction expandFormat(format, locale) {\n    var i = 5;\n\n    function replaceLongDateFormatTokens(input) {\n        return locale.longDateFormat(input) || input;\n    }\n\n    localFormattingTokens.lastIndex = 0;\n    while (i >= 0 && localFormattingTokens.test(format)) {\n        format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);\n        localFormattingTokens.lastIndex = 0;\n        i -= 1;\n    }\n\n    return format;\n}\n\nvar match1         = /\\d/;            //       0 - 9\nvar match2         = /\\d\\d/;          //      00 - 99\nvar match3         = /\\d{3}/;         //     000 - 999\nvar match4         = /\\d{4}/;         //    0000 - 9999\nvar match6         = /[+-]?\\d{6}/;    // -999999 - 999999\nvar match1to2      = /\\d\\d?/;         //       0 - 99\nvar match3to4      = /\\d\\d\\d\\d?/;     //     999 - 9999\nvar match5to6      = /\\d\\d\\d\\d\\d\\d?/; //   99999 - 999999\nvar match1to3      = /\\d{1,3}/;       //       0 - 999\nvar match1to4      = /\\d{1,4}/;       //       0 - 9999\nvar match1to6      = /[+-]?\\d{1,6}/;  // -999999 - 999999\n\nvar matchUnsigned  = /\\d+/;           //       0 - inf\nvar matchSigned    = /[+-]?\\d+/;      //    -inf - inf\n\nvar matchOffset    = /Z|[+-]\\d\\d:?\\d\\d/gi; // +00:00 -00:00 +0000 -0000 or Z\nvar matchShortOffset = /Z|[+-]\\d\\d(?::?\\d\\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z\n\nvar matchTimestamp = /[+-]?\\d+(\\.\\d{1,3})?/; // 123456789 123456789.123\n\n// any word (or two) characters or numbers including two/three word month in arabic.\n// includes scottish gaelic two word and hyphenated months\nvar matchWord = /[0-9]*['a-z\\u00A0-\\u05FF\\u0700-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]+|[\\u0600-\\u06FF\\/]+(\\s*?[\\u0600-\\u06FF]+){1,2}/i;\n\n\nvar regexes = {};\n\nfunction addRegexToken (token, regex, strictRegex) {\n    regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {\n        return (isStrict && strictRegex) ? strictRegex : regex;\n    };\n}\n\nfunction getParseRegexForToken (token, config) {\n    if (!hasOwnProp(regexes, token)) {\n        return new RegExp(unescapeFormat(token));\n    }\n\n    return regexes[token](config._strict, config._locale);\n}\n\n// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript\nfunction unescapeFormat(s) {\n    return regexEscape(s.replace('\\\\', '').replace(/\\\\(\\[)|\\\\(\\])|\\[([^\\]\\[]*)\\]|\\\\(.)/g, function (matched, p1, p2, p3, p4) {\n        return p1 || p2 || p3 || p4;\n    }));\n}\n\nfunction regexEscape(s) {\n    return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n}\n\nvar tokens = {};\n\nfunction addParseToken (token, callback) {\n    var i, func = callback;\n    if (typeof token === 'string') {\n        token = [token];\n    }\n    if (isNumber(callback)) {\n        func = function (input, array) {\n            array[callback] = toInt(input);\n        };\n    }\n    for (i = 0; i < token.length; i++) {\n        tokens[token[i]] = func;\n    }\n}\n\nfunction addWeekParseToken (token, callback) {\n    addParseToken(token, function (input, array, config, token) {\n        config._w = config._w || {};\n        callback(input, config._w, config, token);\n    });\n}\n\nfunction addTimeToArrayFromToken(token, input, config) {\n    if (input != null && hasOwnProp(tokens, token)) {\n        tokens[token](input, config._a, config, token);\n    }\n}\n\nvar YEAR = 0;\nvar MONTH = 1;\nvar DATE = 2;\nvar HOUR = 3;\nvar MINUTE = 4;\nvar SECOND = 5;\nvar MILLISECOND = 6;\nvar WEEK = 7;\nvar WEEKDAY = 8;\n\nvar indexOf;\n\nif (Array.prototype.indexOf) {\n    indexOf = Array.prototype.indexOf;\n} else {\n    indexOf = function (o) {\n        // I know\n        var i;\n        for (i = 0; i < this.length; ++i) {\n            if (this[i] === o) {\n                return i;\n            }\n        }\n        return -1;\n    };\n}\n\nvar indexOf$1 = indexOf;\n\nfunction daysInMonth(year, month) {\n    return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();\n}\n\n// FORMATTING\n\naddFormatToken('M', ['MM', 2], 'Mo', function () {\n    return this.month() + 1;\n});\n\naddFormatToken('MMM', 0, 0, function (format) {\n    return this.localeData().monthsShort(this, format);\n});\n\naddFormatToken('MMMM', 0, 0, function (format) {\n    return this.localeData().months(this, format);\n});\n\n// ALIASES\n\naddUnitAlias('month', 'M');\n\n// PRIORITY\n\naddUnitPriority('month', 8);\n\n// PARSING\n\naddRegexToken('M',    match1to2);\naddRegexToken('MM',   match1to2, match2);\naddRegexToken('MMM',  function (isStrict, locale) {\n    return locale.monthsShortRegex(isStrict);\n});\naddRegexToken('MMMM', function (isStrict, locale) {\n    return locale.monthsRegex(isStrict);\n});\n\naddParseToken(['M', 'MM'], function (input, array) {\n    array[MONTH] = toInt(input) - 1;\n});\n\naddParseToken(['MMM', 'MMMM'], function (input, array, config, token) {\n    var month = config._locale.monthsParse(input, token, config._strict);\n    // if we didn't find a month name, mark the date as invalid.\n    if (month != null) {\n        array[MONTH] = month;\n    } else {\n        getParsingFlags(config).invalidMonth = input;\n    }\n});\n\n// LOCALES\n\nvar MONTHS_IN_FORMAT = /D[oD]?(\\[[^\\[\\]]*\\]|\\s)+MMMM?/;\nvar defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');\nfunction localeMonths (m, format) {\n    if (!m) {\n        return isArray(this._months) ? this._months :\n            this._months['standalone'];\n    }\n    return isArray(this._months) ? this._months[m.month()] :\n        this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];\n}\n\nvar defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');\nfunction localeMonthsShort (m, format) {\n    if (!m) {\n        return isArray(this._monthsShort) ? this._monthsShort :\n            this._monthsShort['standalone'];\n    }\n    return isArray(this._monthsShort) ? this._monthsShort[m.month()] :\n        this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];\n}\n\nfunction handleStrictParse(monthName, format, strict) {\n    var i, ii, mom, llc = monthName.toLocaleLowerCase();\n    if (!this._monthsParse) {\n        // this is not used\n        this._monthsParse = [];\n        this._longMonthsParse = [];\n        this._shortMonthsParse = [];\n        for (i = 0; i < 12; ++i) {\n            mom = createUTC([2000, i]);\n            this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();\n            this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();\n        }\n    }\n\n    if (strict) {\n        if (format === 'MMM') {\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    } else {\n        if (format === 'MMM') {\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    }\n}\n\nfunction localeMonthsParse (monthName, format, strict) {\n    var i, mom, regex;\n\n    if (this._monthsParseExact) {\n        return handleStrictParse.call(this, monthName, format, strict);\n    }\n\n    if (!this._monthsParse) {\n        this._monthsParse = [];\n        this._longMonthsParse = [];\n        this._shortMonthsParse = [];\n    }\n\n    // TODO: add sorting\n    // Sorting makes sure if one month (or abbr) is a prefix of another\n    // see sorting in computeMonthsParse\n    for (i = 0; i < 12; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, i]);\n        if (strict && !this._longMonthsParse[i]) {\n            this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');\n            this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');\n        }\n        if (!strict && !this._monthsParse[i]) {\n            regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');\n            this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');\n        }\n        // test the regex\n        if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {\n            return i;\n        } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {\n            return i;\n        } else if (!strict && this._monthsParse[i].test(monthName)) {\n            return i;\n        }\n    }\n}\n\n// MOMENTS\n\nfunction setMonth (mom, value) {\n    var dayOfMonth;\n\n    if (!mom.isValid()) {\n        // No op\n        return mom;\n    }\n\n    if (typeof value === 'string') {\n        if (/^\\d+$/.test(value)) {\n            value = toInt(value);\n        } else {\n            value = mom.localeData().monthsParse(value);\n            // TODO: Another silent failure?\n            if (!isNumber(value)) {\n                return mom;\n            }\n        }\n    }\n\n    dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));\n    mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);\n    return mom;\n}\n\nfunction getSetMonth (value) {\n    if (value != null) {\n        setMonth(this, value);\n        hooks.updateOffset(this, true);\n        return this;\n    } else {\n        return get(this, 'Month');\n    }\n}\n\nfunction getDaysInMonth () {\n    return daysInMonth(this.year(), this.month());\n}\n\nvar defaultMonthsShortRegex = matchWord;\nfunction monthsShortRegex (isStrict) {\n    if (this._monthsParseExact) {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            computeMonthsParse.call(this);\n        }\n        if (isStrict) {\n            return this._monthsShortStrictRegex;\n        } else {\n            return this._monthsShortRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_monthsShortRegex')) {\n            this._monthsShortRegex = defaultMonthsShortRegex;\n        }\n        return this._monthsShortStrictRegex && isStrict ?\n            this._monthsShortStrictRegex : this._monthsShortRegex;\n    }\n}\n\nvar defaultMonthsRegex = matchWord;\nfunction monthsRegex (isStrict) {\n    if (this._monthsParseExact) {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            computeMonthsParse.call(this);\n        }\n        if (isStrict) {\n            return this._monthsStrictRegex;\n        } else {\n            return this._monthsRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            this._monthsRegex = defaultMonthsRegex;\n        }\n        return this._monthsStrictRegex && isStrict ?\n            this._monthsStrictRegex : this._monthsRegex;\n    }\n}\n\nfunction computeMonthsParse () {\n    function cmpLenRev(a, b) {\n        return b.length - a.length;\n    }\n\n    var shortPieces = [], longPieces = [], mixedPieces = [],\n        i, mom;\n    for (i = 0; i < 12; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, i]);\n        shortPieces.push(this.monthsShort(mom, ''));\n        longPieces.push(this.months(mom, ''));\n        mixedPieces.push(this.months(mom, ''));\n        mixedPieces.push(this.monthsShort(mom, ''));\n    }\n    // Sorting makes sure if one month (or abbr) is a prefix of another it\n    // will match the longer piece.\n    shortPieces.sort(cmpLenRev);\n    longPieces.sort(cmpLenRev);\n    mixedPieces.sort(cmpLenRev);\n    for (i = 0; i < 12; i++) {\n        shortPieces[i] = regexEscape(shortPieces[i]);\n        longPieces[i] = regexEscape(longPieces[i]);\n    }\n    for (i = 0; i < 24; i++) {\n        mixedPieces[i] = regexEscape(mixedPieces[i]);\n    }\n\n    this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._monthsShortRegex = this._monthsRegex;\n    this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n    this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n}\n\n// FORMATTING\n\naddFormatToken('Y', 0, 0, function () {\n    var y = this.year();\n    return y <= 9999 ? '' + y : '+' + y;\n});\n\naddFormatToken(0, ['YY', 2], 0, function () {\n    return this.year() % 100;\n});\n\naddFormatToken(0, ['YYYY',   4],       0, 'year');\naddFormatToken(0, ['YYYYY',  5],       0, 'year');\naddFormatToken(0, ['YYYYYY', 6, true], 0, 'year');\n\n// ALIASES\n\naddUnitAlias('year', 'y');\n\n// PRIORITIES\n\naddUnitPriority('year', 1);\n\n// PARSING\n\naddRegexToken('Y',      matchSigned);\naddRegexToken('YY',     match1to2, match2);\naddRegexToken('YYYY',   match1to4, match4);\naddRegexToken('YYYYY',  match1to6, match6);\naddRegexToken('YYYYYY', match1to6, match6);\n\naddParseToken(['YYYYY', 'YYYYYY'], YEAR);\naddParseToken('YYYY', function (input, array) {\n    array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);\n});\naddParseToken('YY', function (input, array) {\n    array[YEAR] = hooks.parseTwoDigitYear(input);\n});\naddParseToken('Y', function (input, array) {\n    array[YEAR] = parseInt(input, 10);\n});\n\n// HELPERS\n\nfunction daysInYear(year) {\n    return isLeapYear(year) ? 366 : 365;\n}\n\nfunction isLeapYear(year) {\n    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n}\n\n// HOOKS\n\nhooks.parseTwoDigitYear = function (input) {\n    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);\n};\n\n// MOMENTS\n\nvar getSetYear = makeGetSet('FullYear', true);\n\nfunction getIsLeapYear () {\n    return isLeapYear(this.year());\n}\n\nfunction createDate (y, m, d, h, M, s, ms) {\n    // can't just apply() to create a date:\n    // https://stackoverflow.com/q/181348\n    var date = new Date(y, m, d, h, M, s, ms);\n\n    // the date constructor remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {\n        date.setFullYear(y);\n    }\n    return date;\n}\n\nfunction createUTCDate (y) {\n    var date = new Date(Date.UTC.apply(null, arguments));\n\n    // the Date.UTC function remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {\n        date.setUTCFullYear(y);\n    }\n    return date;\n}\n\n// start-of-first-week - start-of-year\nfunction firstWeekOffset(year, dow, doy) {\n    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)\n        fwd = 7 + dow - doy,\n        // first-week day local weekday -- which local weekday is fwd\n        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;\n\n    return -fwdlw + fwd - 1;\n}\n\n// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday\nfunction dayOfYearFromWeeks(year, week, weekday, dow, doy) {\n    var localWeekday = (7 + weekday - dow) % 7,\n        weekOffset = firstWeekOffset(year, dow, doy),\n        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,\n        resYear, resDayOfYear;\n\n    if (dayOfYear <= 0) {\n        resYear = year - 1;\n        resDayOfYear = daysInYear(resYear) + dayOfYear;\n    } else if (dayOfYear > daysInYear(year)) {\n        resYear = year + 1;\n        resDayOfYear = dayOfYear - daysInYear(year);\n    } else {\n        resYear = year;\n        resDayOfYear = dayOfYear;\n    }\n\n    return {\n        year: resYear,\n        dayOfYear: resDayOfYear\n    };\n}\n\nfunction weekOfYear(mom, dow, doy) {\n    var weekOffset = firstWeekOffset(mom.year(), dow, doy),\n        week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,\n        resWeek, resYear;\n\n    if (week < 1) {\n        resYear = mom.year() - 1;\n        resWeek = week + weeksInYear(resYear, dow, doy);\n    } else if (week > weeksInYear(mom.year(), dow, doy)) {\n        resWeek = week - weeksInYear(mom.year(), dow, doy);\n        resYear = mom.year() + 1;\n    } else {\n        resYear = mom.year();\n        resWeek = week;\n    }\n\n    return {\n        week: resWeek,\n        year: resYear\n    };\n}\n\nfunction weeksInYear(year, dow, doy) {\n    var weekOffset = firstWeekOffset(year, dow, doy),\n        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);\n    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;\n}\n\n// FORMATTING\n\naddFormatToken('w', ['ww', 2], 'wo', 'week');\naddFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');\n\n// ALIASES\n\naddUnitAlias('week', 'w');\naddUnitAlias('isoWeek', 'W');\n\n// PRIORITIES\n\naddUnitPriority('week', 5);\naddUnitPriority('isoWeek', 5);\n\n// PARSING\n\naddRegexToken('w',  match1to2);\naddRegexToken('ww', match1to2, match2);\naddRegexToken('W',  match1to2);\naddRegexToken('WW', match1to2, match2);\n\naddWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {\n    week[token.substr(0, 1)] = toInt(input);\n});\n\n// HELPERS\n\n// LOCALES\n\nfunction localeWeek (mom) {\n    return weekOfYear(mom, this._week.dow, this._week.doy).week;\n}\n\nvar defaultLocaleWeek = {\n    dow : 0, // Sunday is the first day of the week.\n    doy : 6  // The week that contains Jan 1st is the first week of the year.\n};\n\nfunction localeFirstDayOfWeek () {\n    return this._week.dow;\n}\n\nfunction localeFirstDayOfYear () {\n    return this._week.doy;\n}\n\n// MOMENTS\n\nfunction getSetWeek (input) {\n    var week = this.localeData().week(this);\n    return input == null ? week : this.add((input - week) * 7, 'd');\n}\n\nfunction getSetISOWeek (input) {\n    var week = weekOfYear(this, 1, 4).week;\n    return input == null ? week : this.add((input - week) * 7, 'd');\n}\n\n// FORMATTING\n\naddFormatToken('d', 0, 'do', 'day');\n\naddFormatToken('dd', 0, 0, function (format) {\n    return this.localeData().weekdaysMin(this, format);\n});\n\naddFormatToken('ddd', 0, 0, function (format) {\n    return this.localeData().weekdaysShort(this, format);\n});\n\naddFormatToken('dddd', 0, 0, function (format) {\n    return this.localeData().weekdays(this, format);\n});\n\naddFormatToken('e', 0, 0, 'weekday');\naddFormatToken('E', 0, 0, 'isoWeekday');\n\n// ALIASES\n\naddUnitAlias('day', 'd');\naddUnitAlias('weekday', 'e');\naddUnitAlias('isoWeekday', 'E');\n\n// PRIORITY\naddUnitPriority('day', 11);\naddUnitPriority('weekday', 11);\naddUnitPriority('isoWeekday', 11);\n\n// PARSING\n\naddRegexToken('d',    match1to2);\naddRegexToken('e',    match1to2);\naddRegexToken('E',    match1to2);\naddRegexToken('dd',   function (isStrict, locale) {\n    return locale.weekdaysMinRegex(isStrict);\n});\naddRegexToken('ddd',   function (isStrict, locale) {\n    return locale.weekdaysShortRegex(isStrict);\n});\naddRegexToken('dddd',   function (isStrict, locale) {\n    return locale.weekdaysRegex(isStrict);\n});\n\naddWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {\n    var weekday = config._locale.weekdaysParse(input, token, config._strict);\n    // if we didn't get a weekday name, mark the date as invalid\n    if (weekday != null) {\n        week.d = weekday;\n    } else {\n        getParsingFlags(config).invalidWeekday = input;\n    }\n});\n\naddWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {\n    week[token] = toInt(input);\n});\n\n// HELPERS\n\nfunction parseWeekday(input, locale) {\n    if (typeof input !== 'string') {\n        return input;\n    }\n\n    if (!isNaN(input)) {\n        return parseInt(input, 10);\n    }\n\n    input = locale.weekdaysParse(input);\n    if (typeof input === 'number') {\n        return input;\n    }\n\n    return null;\n}\n\nfunction parseIsoWeekday(input, locale) {\n    if (typeof input === 'string') {\n        return locale.weekdaysParse(input) % 7 || 7;\n    }\n    return isNaN(input) ? null : input;\n}\n\n// LOCALES\n\nvar defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');\nfunction localeWeekdays (m, format) {\n    if (!m) {\n        return isArray(this._weekdays) ? this._weekdays :\n            this._weekdays['standalone'];\n    }\n    return isArray(this._weekdays) ? this._weekdays[m.day()] :\n        this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];\n}\n\nvar defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');\nfunction localeWeekdaysShort (m) {\n    return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;\n}\n\nvar defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');\nfunction localeWeekdaysMin (m) {\n    return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;\n}\n\nfunction handleStrictParse$1(weekdayName, format, strict) {\n    var i, ii, mom, llc = weekdayName.toLocaleLowerCase();\n    if (!this._weekdaysParse) {\n        this._weekdaysParse = [];\n        this._shortWeekdaysParse = [];\n        this._minWeekdaysParse = [];\n\n        for (i = 0; i < 7; ++i) {\n            mom = createUTC([2000, 1]).day(i);\n            this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();\n            this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();\n            this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();\n        }\n    }\n\n    if (strict) {\n        if (format === 'dddd') {\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else if (format === 'ddd') {\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    } else {\n        if (format === 'dddd') {\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else if (format === 'ddd') {\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    }\n}\n\nfunction localeWeekdaysParse (weekdayName, format, strict) {\n    var i, mom, regex;\n\n    if (this._weekdaysParseExact) {\n        return handleStrictParse$1.call(this, weekdayName, format, strict);\n    }\n\n    if (!this._weekdaysParse) {\n        this._weekdaysParse = [];\n        this._minWeekdaysParse = [];\n        this._shortWeekdaysParse = [];\n        this._fullWeekdaysParse = [];\n    }\n\n    for (i = 0; i < 7; i++) {\n        // make the regex if we don't have it already\n\n        mom = createUTC([2000, 1]).day(i);\n        if (strict && !this._fullWeekdaysParse[i]) {\n            this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 'i');\n            this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 'i');\n            this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 'i');\n        }\n        if (!this._weekdaysParse[i]) {\n            regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');\n            this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');\n        }\n        // test the regex\n        if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {\n            return i;\n        }\n    }\n}\n\n// MOMENTS\n\nfunction getSetDayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();\n    if (input != null) {\n        input = parseWeekday(input, this.localeData());\n        return this.add(input - day, 'd');\n    } else {\n        return day;\n    }\n}\n\nfunction getSetLocaleDayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;\n    return input == null ? weekday : this.add(input - weekday, 'd');\n}\n\nfunction getSetISODayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n\n    // behaves the same as moment#day except\n    // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)\n    // as a setter, sunday should belong to the previous week.\n\n    if (input != null) {\n        var weekday = parseIsoWeekday(input, this.localeData());\n        return this.day(this.day() % 7 ? weekday : weekday - 7);\n    } else {\n        return this.day() || 7;\n    }\n}\n\nvar defaultWeekdaysRegex = matchWord;\nfunction weekdaysRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysStrictRegex;\n        } else {\n            return this._weekdaysRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            this._weekdaysRegex = defaultWeekdaysRegex;\n        }\n        return this._weekdaysStrictRegex && isStrict ?\n            this._weekdaysStrictRegex : this._weekdaysRegex;\n    }\n}\n\nvar defaultWeekdaysShortRegex = matchWord;\nfunction weekdaysShortRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysShortStrictRegex;\n        } else {\n            return this._weekdaysShortRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysShortRegex')) {\n            this._weekdaysShortRegex = defaultWeekdaysShortRegex;\n        }\n        return this._weekdaysShortStrictRegex && isStrict ?\n            this._weekdaysShortStrictRegex : this._weekdaysShortRegex;\n    }\n}\n\nvar defaultWeekdaysMinRegex = matchWord;\nfunction weekdaysMinRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysMinStrictRegex;\n        } else {\n            return this._weekdaysMinRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysMinRegex')) {\n            this._weekdaysMinRegex = defaultWeekdaysMinRegex;\n        }\n        return this._weekdaysMinStrictRegex && isStrict ?\n            this._weekdaysMinStrictRegex : this._weekdaysMinRegex;\n    }\n}\n\n\nfunction computeWeekdaysParse () {\n    function cmpLenRev(a, b) {\n        return b.length - a.length;\n    }\n\n    var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],\n        i, mom, minp, shortp, longp;\n    for (i = 0; i < 7; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, 1]).day(i);\n        minp = this.weekdaysMin(mom, '');\n        shortp = this.weekdaysShort(mom, '');\n        longp = this.weekdays(mom, '');\n        minPieces.push(minp);\n        shortPieces.push(shortp);\n        longPieces.push(longp);\n        mixedPieces.push(minp);\n        mixedPieces.push(shortp);\n        mixedPieces.push(longp);\n    }\n    // Sorting makes sure if one weekday (or abbr) is a prefix of another it\n    // will match the longer piece.\n    minPieces.sort(cmpLenRev);\n    shortPieces.sort(cmpLenRev);\n    longPieces.sort(cmpLenRev);\n    mixedPieces.sort(cmpLenRev);\n    for (i = 0; i < 7; i++) {\n        shortPieces[i] = regexEscape(shortPieces[i]);\n        longPieces[i] = regexEscape(longPieces[i]);\n        mixedPieces[i] = regexEscape(mixedPieces[i]);\n    }\n\n    this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._weekdaysShortRegex = this._weekdaysRegex;\n    this._weekdaysMinRegex = this._weekdaysRegex;\n\n    this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n    this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n    this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');\n}\n\n// FORMATTING\n\nfunction hFormat() {\n    return this.hours() % 12 || 12;\n}\n\nfunction kFormat() {\n    return this.hours() || 24;\n}\n\naddFormatToken('H', ['HH', 2], 0, 'hour');\naddFormatToken('h', ['hh', 2], 0, hFormat);\naddFormatToken('k', ['kk', 2], 0, kFormat);\n\naddFormatToken('hmm', 0, 0, function () {\n    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);\n});\n\naddFormatToken('hmmss', 0, 0, function () {\n    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +\n        zeroFill(this.seconds(), 2);\n});\n\naddFormatToken('Hmm', 0, 0, function () {\n    return '' + this.hours() + zeroFill(this.minutes(), 2);\n});\n\naddFormatToken('Hmmss', 0, 0, function () {\n    return '' + this.hours() + zeroFill(this.minutes(), 2) +\n        zeroFill(this.seconds(), 2);\n});\n\nfunction meridiem (token, lowercase) {\n    addFormatToken(token, 0, 0, function () {\n        return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);\n    });\n}\n\nmeridiem('a', true);\nmeridiem('A', false);\n\n// ALIASES\n\naddUnitAlias('hour', 'h');\n\n// PRIORITY\naddUnitPriority('hour', 13);\n\n// PARSING\n\nfunction matchMeridiem (isStrict, locale) {\n    return locale._meridiemParse;\n}\n\naddRegexToken('a',  matchMeridiem);\naddRegexToken('A',  matchMeridiem);\naddRegexToken('H',  match1to2);\naddRegexToken('h',  match1to2);\naddRegexToken('k',  match1to2);\naddRegexToken('HH', match1to2, match2);\naddRegexToken('hh', match1to2, match2);\naddRegexToken('kk', match1to2, match2);\n\naddRegexToken('hmm', match3to4);\naddRegexToken('hmmss', match5to6);\naddRegexToken('Hmm', match3to4);\naddRegexToken('Hmmss', match5to6);\n\naddParseToken(['H', 'HH'], HOUR);\naddParseToken(['k', 'kk'], function (input, array, config) {\n    var kInput = toInt(input);\n    array[HOUR] = kInput === 24 ? 0 : kInput;\n});\naddParseToken(['a', 'A'], function (input, array, config) {\n    config._isPm = config._locale.isPM(input);\n    config._meridiem = input;\n});\naddParseToken(['h', 'hh'], function (input, array, config) {\n    array[HOUR] = toInt(input);\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('hmm', function (input, array, config) {\n    var pos = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos));\n    array[MINUTE] = toInt(input.substr(pos));\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('hmmss', function (input, array, config) {\n    var pos1 = input.length - 4;\n    var pos2 = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos1));\n    array[MINUTE] = toInt(input.substr(pos1, 2));\n    array[SECOND] = toInt(input.substr(pos2));\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('Hmm', function (input, array, config) {\n    var pos = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos));\n    array[MINUTE] = toInt(input.substr(pos));\n});\naddParseToken('Hmmss', function (input, array, config) {\n    var pos1 = input.length - 4;\n    var pos2 = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos1));\n    array[MINUTE] = toInt(input.substr(pos1, 2));\n    array[SECOND] = toInt(input.substr(pos2));\n});\n\n// LOCALES\n\nfunction localeIsPM (input) {\n    // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays\n    // Using charAt should be more compatible.\n    return ((input + '').toLowerCase().charAt(0) === 'p');\n}\n\nvar defaultLocaleMeridiemParse = /[ap]\\.?m?\\.?/i;\nfunction localeMeridiem (hours, minutes, isLower) {\n    if (hours > 11) {\n        return isLower ? 'pm' : 'PM';\n    } else {\n        return isLower ? 'am' : 'AM';\n    }\n}\n\n\n// MOMENTS\n\n// Setting the hour should keep the time, because the user explicitly\n// specified which hour he wants. So trying to maintain the same hour (in\n// a new timezone) makes sense. Adding/subtracting hours does not follow\n// this rule.\nvar getSetHour = makeGetSet('Hours', true);\n\n// months\n// week\n// weekdays\n// meridiem\nvar baseConfig = {\n    calendar: defaultCalendar,\n    longDateFormat: defaultLongDateFormat,\n    invalidDate: defaultInvalidDate,\n    ordinal: defaultOrdinal,\n    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,\n    relativeTime: defaultRelativeTime,\n\n    months: defaultLocaleMonths,\n    monthsShort: defaultLocaleMonthsShort,\n\n    week: defaultLocaleWeek,\n\n    weekdays: defaultLocaleWeekdays,\n    weekdaysMin: defaultLocaleWeekdaysMin,\n    weekdaysShort: defaultLocaleWeekdaysShort,\n\n    meridiemParse: defaultLocaleMeridiemParse\n};\n\n// internal storage for locale config files\nvar locales = {};\nvar localeFamilies = {};\nvar globalLocale;\n\nfunction normalizeLocale(key) {\n    return key ? key.toLowerCase().replace('_', '-') : key;\n}\n\n// pick the locale from the array\n// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each\n// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root\nfunction chooseLocale(names) {\n    var i = 0, j, next, locale, split;\n\n    while (i < names.length) {\n        split = normalizeLocale(names[i]).split('-');\n        j = split.length;\n        next = normalizeLocale(names[i + 1]);\n        next = next ? next.split('-') : null;\n        while (j > 0) {\n            locale = loadLocale(split.slice(0, j).join('-'));\n            if (locale) {\n                return locale;\n            }\n            if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {\n                //the next array item is better than a shallower substring of this one\n                break;\n            }\n            j--;\n        }\n        i++;\n    }\n    return null;\n}\n\nfunction loadLocale(name) {\n    var oldLocale = null;\n    // TODO: Find a better way to register and load all the locales in Node\n    if (!locales[name] && (typeof module !== 'undefined') &&\n            module && module.exports) {\n        try {\n            oldLocale = globalLocale._abbr;\n            __webpack_require__(240)(\"./\" + name);\n            // because defineLocale currently also sets the global locale, we\n            // want to undo that for lazy loaded locales\n            getSetGlobalLocale(oldLocale);\n        } catch (e) { }\n    }\n    return locales[name];\n}\n\n// This function will load locale and then set the global locale.  If\n// no arguments are passed in, it will simply return the current global\n// locale key.\nfunction getSetGlobalLocale (key, values) {\n    var data;\n    if (key) {\n        if (isUndefined(values)) {\n            data = getLocale(key);\n        }\n        else {\n            data = defineLocale(key, values);\n        }\n\n        if (data) {\n            // moment.duration._locale = moment._locale = data;\n            globalLocale = data;\n        }\n    }\n\n    return globalLocale._abbr;\n}\n\nfunction defineLocale (name, config) {\n    if (config !== null) {\n        var parentConfig = baseConfig;\n        config.abbr = name;\n        if (locales[name] != null) {\n            deprecateSimple('defineLocaleOverride',\n                    'use moment.updateLocale(localeName, config) to change ' +\n                    'an existing locale. moment.defineLocale(localeName, ' +\n                    'config) should only be used for creating a new locale ' +\n                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');\n            parentConfig = locales[name]._config;\n        } else if (config.parentLocale != null) {\n            if (locales[config.parentLocale] != null) {\n                parentConfig = locales[config.parentLocale]._config;\n            } else {\n                if (!localeFamilies[config.parentLocale]) {\n                    localeFamilies[config.parentLocale] = [];\n                }\n                localeFamilies[config.parentLocale].push({\n                    name: name,\n                    config: config\n                });\n                return null;\n            }\n        }\n        locales[name] = new Locale(mergeConfigs(parentConfig, config));\n\n        if (localeFamilies[name]) {\n            localeFamilies[name].forEach(function (x) {\n                defineLocale(x.name, x.config);\n            });\n        }\n\n        // backwards compat for now: also set the locale\n        // make sure we set the locale AFTER all child locales have been\n        // created, so we won't end up with the child locale set.\n        getSetGlobalLocale(name);\n\n\n        return locales[name];\n    } else {\n        // useful for testing\n        delete locales[name];\n        return null;\n    }\n}\n\nfunction updateLocale(name, config) {\n    if (config != null) {\n        var locale, parentConfig = baseConfig;\n        // MERGE\n        if (locales[name] != null) {\n            parentConfig = locales[name]._config;\n        }\n        config = mergeConfigs(parentConfig, config);\n        locale = new Locale(config);\n        locale.parentLocale = locales[name];\n        locales[name] = locale;\n\n        // backwards compat for now: also set the locale\n        getSetGlobalLocale(name);\n    } else {\n        // pass null for config to unupdate, useful for tests\n        if (locales[name] != null) {\n            if (locales[name].parentLocale != null) {\n                locales[name] = locales[name].parentLocale;\n            } else if (locales[name] != null) {\n                delete locales[name];\n            }\n        }\n    }\n    return locales[name];\n}\n\n// returns locale data\nfunction getLocale (key) {\n    var locale;\n\n    if (key && key._locale && key._locale._abbr) {\n        key = key._locale._abbr;\n    }\n\n    if (!key) {\n        return globalLocale;\n    }\n\n    if (!isArray(key)) {\n        //short-circuit everything else\n        locale = loadLocale(key);\n        if (locale) {\n            return locale;\n        }\n        key = [key];\n    }\n\n    return chooseLocale(key);\n}\n\nfunction listLocales() {\n    return keys$1(locales);\n}\n\nfunction checkOverflow (m) {\n    var overflow;\n    var a = m._a;\n\n    if (a && getParsingFlags(m).overflow === -2) {\n        overflow =\n            a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :\n            a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :\n            a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :\n            a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :\n            a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :\n            a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :\n            -1;\n\n        if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {\n            overflow = DATE;\n        }\n        if (getParsingFlags(m)._overflowWeeks && overflow === -1) {\n            overflow = WEEK;\n        }\n        if (getParsingFlags(m)._overflowWeekday && overflow === -1) {\n            overflow = WEEKDAY;\n        }\n\n        getParsingFlags(m).overflow = overflow;\n    }\n\n    return m;\n}\n\n// iso 8601 regex\n// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)\nvar extendedIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})-(?:\\d\\d-\\d\\d|W\\d\\d-\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?::\\d\\d(?::\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\nvar basicIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})(?:\\d\\d\\d\\d|W\\d\\d\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?:\\d\\d(?:\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\n\nvar tzRegex = /Z|[+-]\\d\\d(?::?\\d\\d)?/;\n\nvar isoDates = [\n    ['YYYYYY-MM-DD', /[+-]\\d{6}-\\d\\d-\\d\\d/],\n    ['YYYY-MM-DD', /\\d{4}-\\d\\d-\\d\\d/],\n    ['GGGG-[W]WW-E', /\\d{4}-W\\d\\d-\\d/],\n    ['GGGG-[W]WW', /\\d{4}-W\\d\\d/, false],\n    ['YYYY-DDD', /\\d{4}-\\d{3}/],\n    ['YYYY-MM', /\\d{4}-\\d\\d/, false],\n    ['YYYYYYMMDD', /[+-]\\d{10}/],\n    ['YYYYMMDD', /\\d{8}/],\n    // YYYYMM is NOT allowed by the standard\n    ['GGGG[W]WWE', /\\d{4}W\\d{3}/],\n    ['GGGG[W]WW', /\\d{4}W\\d{2}/, false],\n    ['YYYYDDD', /\\d{7}/]\n];\n\n// iso time formats and regexes\nvar isoTimes = [\n    ['HH:mm:ss.SSSS', /\\d\\d:\\d\\d:\\d\\d\\.\\d+/],\n    ['HH:mm:ss,SSSS', /\\d\\d:\\d\\d:\\d\\d,\\d+/],\n    ['HH:mm:ss', /\\d\\d:\\d\\d:\\d\\d/],\n    ['HH:mm', /\\d\\d:\\d\\d/],\n    ['HHmmss.SSSS', /\\d\\d\\d\\d\\d\\d\\.\\d+/],\n    ['HHmmss,SSSS', /\\d\\d\\d\\d\\d\\d,\\d+/],\n    ['HHmmss', /\\d\\d\\d\\d\\d\\d/],\n    ['HHmm', /\\d\\d\\d\\d/],\n    ['HH', /\\d\\d/]\n];\n\nvar aspNetJsonRegex = /^\\/?Date\\((\\-?\\d+)/i;\n\n// date from iso format\nfunction configFromISO(config) {\n    var i, l,\n        string = config._i,\n        match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),\n        allowTime, dateFormat, timeFormat, tzFormat;\n\n    if (match) {\n        getParsingFlags(config).iso = true;\n\n        for (i = 0, l = isoDates.length; i < l; i++) {\n            if (isoDates[i][1].exec(match[1])) {\n                dateFormat = isoDates[i][0];\n                allowTime = isoDates[i][2] !== false;\n                break;\n            }\n        }\n        if (dateFormat == null) {\n            config._isValid = false;\n            return;\n        }\n        if (match[3]) {\n            for (i = 0, l = isoTimes.length; i < l; i++) {\n                if (isoTimes[i][1].exec(match[3])) {\n                    // match[2] should be 'T' or space\n                    timeFormat = (match[2] || ' ') + isoTimes[i][0];\n                    break;\n                }\n            }\n            if (timeFormat == null) {\n                config._isValid = false;\n                return;\n            }\n        }\n        if (!allowTime && timeFormat != null) {\n            config._isValid = false;\n            return;\n        }\n        if (match[4]) {\n            if (tzRegex.exec(match[4])) {\n                tzFormat = 'Z';\n            } else {\n                config._isValid = false;\n                return;\n            }\n        }\n        config._f = dateFormat + (timeFormat || '') + (tzFormat || '');\n        configFromStringAndFormat(config);\n    } else {\n        config._isValid = false;\n    }\n}\n\n// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3\nvar basicRfcRegex = /^((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\\s)?(\\d?\\d\\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\s(?:\\d\\d)?\\d\\d\\s)(\\d\\d:\\d\\d)(\\:\\d\\d)?(\\s(?:UT|GMT|[ECMP][SD]T|[A-IK-Za-ik-z]|[+-]\\d{4}))$/;\n\n// date and time from ref 2822 format\nfunction configFromRFC2822(config) {\n    var string, match, dayFormat,\n        dateFormat, timeFormat, tzFormat;\n    var timezones = {\n        ' GMT': ' +0000',\n        ' EDT': ' -0400',\n        ' EST': ' -0500',\n        ' CDT': ' -0500',\n        ' CST': ' -0600',\n        ' MDT': ' -0600',\n        ' MST': ' -0700',\n        ' PDT': ' -0700',\n        ' PST': ' -0800'\n    };\n    var military = 'YXWVUTSRQPONZABCDEFGHIKLM';\n    var timezone, timezoneIndex;\n\n    string = config._i\n        .replace(/\\([^\\)]*\\)|[\\n\\t]/g, ' ') // Remove comments and folding whitespace\n        .replace(/(\\s\\s+)/g, ' ') // Replace multiple-spaces with a single space\n        .replace(/^\\s|\\s$/g, ''); // Remove leading and trailing spaces\n    match = basicRfcRegex.exec(string);\n\n    if (match) {\n        dayFormat = match[1] ? 'ddd' + ((match[1].length === 5) ? ', ' : ' ') : '';\n        dateFormat = 'D MMM ' + ((match[2].length > 10) ? 'YYYY ' : 'YY ');\n        timeFormat = 'HH:mm' + (match[4] ? ':ss' : '');\n\n        // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.\n        if (match[1]) { // day of week given\n            var momentDate = new Date(match[2]);\n            var momentDay = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'][momentDate.getDay()];\n\n            if (match[1].substr(0,3) !== momentDay) {\n                getParsingFlags(config).weekdayMismatch = true;\n                config._isValid = false;\n                return;\n            }\n        }\n\n        switch (match[5].length) {\n            case 2: // military\n                if (timezoneIndex === 0) {\n                    timezone = ' +0000';\n                } else {\n                    timezoneIndex = military.indexOf(match[5][1].toUpperCase()) - 12;\n                    timezone = ((timezoneIndex < 0) ? ' -' : ' +') +\n                        (('' + timezoneIndex).replace(/^-?/, '0')).match(/..$/)[0] + '00';\n                }\n                break;\n            case 4: // Zone\n                timezone = timezones[match[5]];\n                break;\n            default: // UT or +/-9999\n                timezone = timezones[' GMT'];\n        }\n        match[5] = timezone;\n        config._i = match.splice(1).join('');\n        tzFormat = ' ZZ';\n        config._f = dayFormat + dateFormat + timeFormat + tzFormat;\n        configFromStringAndFormat(config);\n        getParsingFlags(config).rfc2822 = true;\n    } else {\n        config._isValid = false;\n    }\n}\n\n// date from iso format or fallback\nfunction configFromString(config) {\n    var matched = aspNetJsonRegex.exec(config._i);\n\n    if (matched !== null) {\n        config._d = new Date(+matched[1]);\n        return;\n    }\n\n    configFromISO(config);\n    if (config._isValid === false) {\n        delete config._isValid;\n    } else {\n        return;\n    }\n\n    configFromRFC2822(config);\n    if (config._isValid === false) {\n        delete config._isValid;\n    } else {\n        return;\n    }\n\n    // Final attempt, use Input Fallback\n    hooks.createFromInputFallback(config);\n}\n\nhooks.createFromInputFallback = deprecate(\n    'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +\n    'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +\n    'discouraged and will be removed in an upcoming major release. Please refer to ' +\n    'http://momentjs.com/guides/#/warnings/js-date/ for more info.',\n    function (config) {\n        config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));\n    }\n);\n\n// Pick the first defined of two or three arguments.\nfunction defaults(a, b, c) {\n    if (a != null) {\n        return a;\n    }\n    if (b != null) {\n        return b;\n    }\n    return c;\n}\n\nfunction currentDateArray(config) {\n    // hooks is actually the exported moment object\n    var nowValue = new Date(hooks.now());\n    if (config._useUTC) {\n        return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];\n    }\n    return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];\n}\n\n// convert an array to a date.\n// the array should mirror the parameters below\n// note: all values past the year are optional and will default to the lowest possible value.\n// [year, month, day , hour, minute, second, millisecond]\nfunction configFromArray (config) {\n    var i, date, input = [], currentDate, yearToUse;\n\n    if (config._d) {\n        return;\n    }\n\n    currentDate = currentDateArray(config);\n\n    //compute day of the year from weeks and weekdays\n    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {\n        dayOfYearFromWeekInfo(config);\n    }\n\n    //if the day of the year is set, figure out what it is\n    if (config._dayOfYear != null) {\n        yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);\n\n        if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {\n            getParsingFlags(config)._overflowDayOfYear = true;\n        }\n\n        date = createUTCDate(yearToUse, 0, config._dayOfYear);\n        config._a[MONTH] = date.getUTCMonth();\n        config._a[DATE] = date.getUTCDate();\n    }\n\n    // Default to current date.\n    // * if no year, month, day of month are given, default to today\n    // * if day of month is given, default month and year\n    // * if month is given, default only year\n    // * if year is given, don't default anything\n    for (i = 0; i < 3 && config._a[i] == null; ++i) {\n        config._a[i] = input[i] = currentDate[i];\n    }\n\n    // Zero out whatever was not defaulted, including time\n    for (; i < 7; i++) {\n        config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];\n    }\n\n    // Check for 24:00:00.000\n    if (config._a[HOUR] === 24 &&\n            config._a[MINUTE] === 0 &&\n            config._a[SECOND] === 0 &&\n            config._a[MILLISECOND] === 0) {\n        config._nextDay = true;\n        config._a[HOUR] = 0;\n    }\n\n    config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);\n    // Apply timezone offset from input. The actual utcOffset can be changed\n    // with parseZone.\n    if (config._tzm != null) {\n        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n    }\n\n    if (config._nextDay) {\n        config._a[HOUR] = 24;\n    }\n}\n\nfunction dayOfYearFromWeekInfo(config) {\n    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;\n\n    w = config._w;\n    if (w.GG != null || w.W != null || w.E != null) {\n        dow = 1;\n        doy = 4;\n\n        // TODO: We need to take the current isoWeekYear, but that depends on\n        // how we interpret now (local, utc, fixed offset). So create\n        // a now version of current config (take local/utc/offset flags, and\n        // create now).\n        weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);\n        week = defaults(w.W, 1);\n        weekday = defaults(w.E, 1);\n        if (weekday < 1 || weekday > 7) {\n            weekdayOverflow = true;\n        }\n    } else {\n        dow = config._locale._week.dow;\n        doy = config._locale._week.doy;\n\n        var curWeek = weekOfYear(createLocal(), dow, doy);\n\n        weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);\n\n        // Default to current week.\n        week = defaults(w.w, curWeek.week);\n\n        if (w.d != null) {\n            // weekday -- low day numbers are considered next week\n            weekday = w.d;\n            if (weekday < 0 || weekday > 6) {\n                weekdayOverflow = true;\n            }\n        } else if (w.e != null) {\n            // local weekday -- counting starts from begining of week\n            weekday = w.e + dow;\n            if (w.e < 0 || w.e > 6) {\n                weekdayOverflow = true;\n            }\n        } else {\n            // default to begining of week\n            weekday = dow;\n        }\n    }\n    if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {\n        getParsingFlags(config)._overflowWeeks = true;\n    } else if (weekdayOverflow != null) {\n        getParsingFlags(config)._overflowWeekday = true;\n    } else {\n        temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);\n        config._a[YEAR] = temp.year;\n        config._dayOfYear = temp.dayOfYear;\n    }\n}\n\n// constant that refers to the ISO standard\nhooks.ISO_8601 = function () {};\n\n// constant that refers to the RFC 2822 form\nhooks.RFC_2822 = function () {};\n\n// date from string and format string\nfunction configFromStringAndFormat(config) {\n    // TODO: Move this to another part of the creation flow to prevent circular deps\n    if (config._f === hooks.ISO_8601) {\n        configFromISO(config);\n        return;\n    }\n    if (config._f === hooks.RFC_2822) {\n        configFromRFC2822(config);\n        return;\n    }\n    config._a = [];\n    getParsingFlags(config).empty = true;\n\n    // This array is used to make a Date, either with `new Date` or `Date.UTC`\n    var string = '' + config._i,\n        i, parsedInput, tokens, token, skipped,\n        stringLength = string.length,\n        totalParsedInputLength = 0;\n\n    tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];\n\n    for (i = 0; i < tokens.length; i++) {\n        token = tokens[i];\n        parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];\n        // console.log('token', token, 'parsedInput', parsedInput,\n        //         'regex', getParseRegexForToken(token, config));\n        if (parsedInput) {\n            skipped = string.substr(0, string.indexOf(parsedInput));\n            if (skipped.length > 0) {\n                getParsingFlags(config).unusedInput.push(skipped);\n            }\n            string = string.slice(string.indexOf(parsedInput) + parsedInput.length);\n            totalParsedInputLength += parsedInput.length;\n        }\n        // don't parse if it's not a known token\n        if (formatTokenFunctions[token]) {\n            if (parsedInput) {\n                getParsingFlags(config).empty = false;\n            }\n            else {\n                getParsingFlags(config).unusedTokens.push(token);\n            }\n            addTimeToArrayFromToken(token, parsedInput, config);\n        }\n        else if (config._strict && !parsedInput) {\n            getParsingFlags(config).unusedTokens.push(token);\n        }\n    }\n\n    // add remaining unparsed input length to the string\n    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;\n    if (string.length > 0) {\n        getParsingFlags(config).unusedInput.push(string);\n    }\n\n    // clear _12h flag if hour is <= 12\n    if (config._a[HOUR] <= 12 &&\n        getParsingFlags(config).bigHour === true &&\n        config._a[HOUR] > 0) {\n        getParsingFlags(config).bigHour = undefined;\n    }\n\n    getParsingFlags(config).parsedDateParts = config._a.slice(0);\n    getParsingFlags(config).meridiem = config._meridiem;\n    // handle meridiem\n    config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);\n\n    configFromArray(config);\n    checkOverflow(config);\n}\n\n\nfunction meridiemFixWrap (locale, hour, meridiem) {\n    var isPm;\n\n    if (meridiem == null) {\n        // nothing to do\n        return hour;\n    }\n    if (locale.meridiemHour != null) {\n        return locale.meridiemHour(hour, meridiem);\n    } else if (locale.isPM != null) {\n        // Fallback\n        isPm = locale.isPM(meridiem);\n        if (isPm && hour < 12) {\n            hour += 12;\n        }\n        if (!isPm && hour === 12) {\n            hour = 0;\n        }\n        return hour;\n    } else {\n        // this is not supposed to happen\n        return hour;\n    }\n}\n\n// date from string and array of format strings\nfunction configFromStringAndArray(config) {\n    var tempConfig,\n        bestMoment,\n\n        scoreToBeat,\n        i,\n        currentScore;\n\n    if (config._f.length === 0) {\n        getParsingFlags(config).invalidFormat = true;\n        config._d = new Date(NaN);\n        return;\n    }\n\n    for (i = 0; i < config._f.length; i++) {\n        currentScore = 0;\n        tempConfig = copyConfig({}, config);\n        if (config._useUTC != null) {\n            tempConfig._useUTC = config._useUTC;\n        }\n        tempConfig._f = config._f[i];\n        configFromStringAndFormat(tempConfig);\n\n        if (!isValid(tempConfig)) {\n            continue;\n        }\n\n        // if there is any input that was not parsed add a penalty for that format\n        currentScore += getParsingFlags(tempConfig).charsLeftOver;\n\n        //or tokens\n        currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;\n\n        getParsingFlags(tempConfig).score = currentScore;\n\n        if (scoreToBeat == null || currentScore < scoreToBeat) {\n            scoreToBeat = currentScore;\n            bestMoment = tempConfig;\n        }\n    }\n\n    extend(config, bestMoment || tempConfig);\n}\n\nfunction configFromObject(config) {\n    if (config._d) {\n        return;\n    }\n\n    var i = normalizeObjectUnits(config._i);\n    config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {\n        return obj && parseInt(obj, 10);\n    });\n\n    configFromArray(config);\n}\n\nfunction createFromConfig (config) {\n    var res = new Moment(checkOverflow(prepareConfig(config)));\n    if (res._nextDay) {\n        // Adding is smart enough around DST\n        res.add(1, 'd');\n        res._nextDay = undefined;\n    }\n\n    return res;\n}\n\nfunction prepareConfig (config) {\n    var input = config._i,\n        format = config._f;\n\n    config._locale = config._locale || getLocale(config._l);\n\n    if (input === null || (format === undefined && input === '')) {\n        return createInvalid({nullInput: true});\n    }\n\n    if (typeof input === 'string') {\n        config._i = input = config._locale.preparse(input);\n    }\n\n    if (isMoment(input)) {\n        return new Moment(checkOverflow(input));\n    } else if (isDate(input)) {\n        config._d = input;\n    } else if (isArray(format)) {\n        configFromStringAndArray(config);\n    } else if (format) {\n        configFromStringAndFormat(config);\n    }  else {\n        configFromInput(config);\n    }\n\n    if (!isValid(config)) {\n        config._d = null;\n    }\n\n    return config;\n}\n\nfunction configFromInput(config) {\n    var input = config._i;\n    if (isUndefined(input)) {\n        config._d = new Date(hooks.now());\n    } else if (isDate(input)) {\n        config._d = new Date(input.valueOf());\n    } else if (typeof input === 'string') {\n        configFromString(config);\n    } else if (isArray(input)) {\n        config._a = map(input.slice(0), function (obj) {\n            return parseInt(obj, 10);\n        });\n        configFromArray(config);\n    } else if (isObject(input)) {\n        configFromObject(config);\n    } else if (isNumber(input)) {\n        // from milliseconds\n        config._d = new Date(input);\n    } else {\n        hooks.createFromInputFallback(config);\n    }\n}\n\nfunction createLocalOrUTC (input, format, locale, strict, isUTC) {\n    var c = {};\n\n    if (locale === true || locale === false) {\n        strict = locale;\n        locale = undefined;\n    }\n\n    if ((isObject(input) && isObjectEmpty(input)) ||\n            (isArray(input) && input.length === 0)) {\n        input = undefined;\n    }\n    // object construction must be done this way.\n    // https://github.com/moment/moment/issues/1423\n    c._isAMomentObject = true;\n    c._useUTC = c._isUTC = isUTC;\n    c._l = locale;\n    c._i = input;\n    c._f = format;\n    c._strict = strict;\n\n    return createFromConfig(c);\n}\n\nfunction createLocal (input, format, locale, strict) {\n    return createLocalOrUTC(input, format, locale, strict, false);\n}\n\nvar prototypeMin = deprecate(\n    'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',\n    function () {\n        var other = createLocal.apply(null, arguments);\n        if (this.isValid() && other.isValid()) {\n            return other < this ? this : other;\n        } else {\n            return createInvalid();\n        }\n    }\n);\n\nvar prototypeMax = deprecate(\n    'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',\n    function () {\n        var other = createLocal.apply(null, arguments);\n        if (this.isValid() && other.isValid()) {\n            return other > this ? this : other;\n        } else {\n            return createInvalid();\n        }\n    }\n);\n\n// Pick a moment m from moments so that m[fn](other) is true for all\n// other. This relies on the function fn to be transitive.\n//\n// moments should either be an array of moment objects or an array, whose\n// first element is an array of moment objects.\nfunction pickBy(fn, moments) {\n    var res, i;\n    if (moments.length === 1 && isArray(moments[0])) {\n        moments = moments[0];\n    }\n    if (!moments.length) {\n        return createLocal();\n    }\n    res = moments[0];\n    for (i = 1; i < moments.length; ++i) {\n        if (!moments[i].isValid() || moments[i][fn](res)) {\n            res = moments[i];\n        }\n    }\n    return res;\n}\n\n// TODO: Use [].sort instead?\nfunction min () {\n    var args = [].slice.call(arguments, 0);\n\n    return pickBy('isBefore', args);\n}\n\nfunction max () {\n    var args = [].slice.call(arguments, 0);\n\n    return pickBy('isAfter', args);\n}\n\nvar now = function () {\n    return Date.now ? Date.now() : +(new Date());\n};\n\nvar ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];\n\nfunction isDurationValid(m) {\n    for (var key in m) {\n        if (!(ordering.indexOf(key) !== -1 && (m[key] == null || !isNaN(m[key])))) {\n            return false;\n        }\n    }\n\n    var unitHasDecimal = false;\n    for (var i = 0; i < ordering.length; ++i) {\n        if (m[ordering[i]]) {\n            if (unitHasDecimal) {\n                return false; // only allow non-integers for smallest unit\n            }\n            if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {\n                unitHasDecimal = true;\n            }\n        }\n    }\n\n    return true;\n}\n\nfunction isValid$1() {\n    return this._isValid;\n}\n\nfunction createInvalid$1() {\n    return createDuration(NaN);\n}\n\nfunction Duration (duration) {\n    var normalizedInput = normalizeObjectUnits(duration),\n        years = normalizedInput.year || 0,\n        quarters = normalizedInput.quarter || 0,\n        months = normalizedInput.month || 0,\n        weeks = normalizedInput.week || 0,\n        days = normalizedInput.day || 0,\n        hours = normalizedInput.hour || 0,\n        minutes = normalizedInput.minute || 0,\n        seconds = normalizedInput.second || 0,\n        milliseconds = normalizedInput.millisecond || 0;\n\n    this._isValid = isDurationValid(normalizedInput);\n\n    // representation for dateAddRemove\n    this._milliseconds = +milliseconds +\n        seconds * 1e3 + // 1000\n        minutes * 6e4 + // 1000 * 60\n        hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978\n    // Because of dateAddRemove treats 24 hours as different from a\n    // day when working around DST, we need to store them separately\n    this._days = +days +\n        weeks * 7;\n    // It is impossible translate months into days without knowing\n    // which months you are are talking about, so we have to store\n    // it separately.\n    this._months = +months +\n        quarters * 3 +\n        years * 12;\n\n    this._data = {};\n\n    this._locale = getLocale();\n\n    this._bubble();\n}\n\nfunction isDuration (obj) {\n    return obj instanceof Duration;\n}\n\nfunction absRound (number) {\n    if (number < 0) {\n        return Math.round(-1 * number) * -1;\n    } else {\n        return Math.round(number);\n    }\n}\n\n// FORMATTING\n\nfunction offset (token, separator) {\n    addFormatToken(token, 0, 0, function () {\n        var offset = this.utcOffset();\n        var sign = '+';\n        if (offset < 0) {\n            offset = -offset;\n            sign = '-';\n        }\n        return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);\n    });\n}\n\noffset('Z', ':');\noffset('ZZ', '');\n\n// PARSING\n\naddRegexToken('Z',  matchShortOffset);\naddRegexToken('ZZ', matchShortOffset);\naddParseToken(['Z', 'ZZ'], function (input, array, config) {\n    config._useUTC = true;\n    config._tzm = offsetFromString(matchShortOffset, input);\n});\n\n// HELPERS\n\n// timezone chunker\n// '+10:00' > ['10',  '00']\n// '-1530'  > ['-15', '30']\nvar chunkOffset = /([\\+\\-]|\\d\\d)/gi;\n\nfunction offsetFromString(matcher, string) {\n    var matches = (string || '').match(matcher);\n\n    if (matches === null) {\n        return null;\n    }\n\n    var chunk   = matches[matches.length - 1] || [];\n    var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];\n    var minutes = +(parts[1] * 60) + toInt(parts[2]);\n\n    return minutes === 0 ?\n      0 :\n      parts[0] === '+' ? minutes : -minutes;\n}\n\n// Return a moment from input, that is local/utc/zone equivalent to model.\nfunction cloneWithOffset(input, model) {\n    var res, diff;\n    if (model._isUTC) {\n        res = model.clone();\n        diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();\n        // Use low-level api, because this fn is low-level api.\n        res._d.setTime(res._d.valueOf() + diff);\n        hooks.updateOffset(res, false);\n        return res;\n    } else {\n        return createLocal(input).local();\n    }\n}\n\nfunction getDateOffset (m) {\n    // On Firefox.24 Date#getTimezoneOffset returns a floating point.\n    // https://github.com/moment/moment/pull/1871\n    return -Math.round(m._d.getTimezoneOffset() / 15) * 15;\n}\n\n// HOOKS\n\n// This function will be called whenever a moment is mutated.\n// It is intended to keep the offset in sync with the timezone.\nhooks.updateOffset = function () {};\n\n// MOMENTS\n\n// keepLocalTime = true means only change the timezone, without\n// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->\n// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset\n// +0200, so we adjust the time as needed, to be valid.\n//\n// Keeping the time actually adds/subtracts (one hour)\n// from the actual represented time. That is why we call updateOffset\n// a second time. In case it wants us to change the offset again\n// _changeInProgress == true case, then we have to adjust, because\n// there is no such time in the given timezone.\nfunction getSetOffset (input, keepLocalTime, keepMinutes) {\n    var offset = this._offset || 0,\n        localAdjust;\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    if (input != null) {\n        if (typeof input === 'string') {\n            input = offsetFromString(matchShortOffset, input);\n            if (input === null) {\n                return this;\n            }\n        } else if (Math.abs(input) < 16 && !keepMinutes) {\n            input = input * 60;\n        }\n        if (!this._isUTC && keepLocalTime) {\n            localAdjust = getDateOffset(this);\n        }\n        this._offset = input;\n        this._isUTC = true;\n        if (localAdjust != null) {\n            this.add(localAdjust, 'm');\n        }\n        if (offset !== input) {\n            if (!keepLocalTime || this._changeInProgress) {\n                addSubtract(this, createDuration(input - offset, 'm'), 1, false);\n            } else if (!this._changeInProgress) {\n                this._changeInProgress = true;\n                hooks.updateOffset(this, true);\n                this._changeInProgress = null;\n            }\n        }\n        return this;\n    } else {\n        return this._isUTC ? offset : getDateOffset(this);\n    }\n}\n\nfunction getSetZone (input, keepLocalTime) {\n    if (input != null) {\n        if (typeof input !== 'string') {\n            input = -input;\n        }\n\n        this.utcOffset(input, keepLocalTime);\n\n        return this;\n    } else {\n        return -this.utcOffset();\n    }\n}\n\nfunction setOffsetToUTC (keepLocalTime) {\n    return this.utcOffset(0, keepLocalTime);\n}\n\nfunction setOffsetToLocal (keepLocalTime) {\n    if (this._isUTC) {\n        this.utcOffset(0, keepLocalTime);\n        this._isUTC = false;\n\n        if (keepLocalTime) {\n            this.subtract(getDateOffset(this), 'm');\n        }\n    }\n    return this;\n}\n\nfunction setOffsetToParsedOffset () {\n    if (this._tzm != null) {\n        this.utcOffset(this._tzm, false, true);\n    } else if (typeof this._i === 'string') {\n        var tZone = offsetFromString(matchOffset, this._i);\n        if (tZone != null) {\n            this.utcOffset(tZone);\n        }\n        else {\n            this.utcOffset(0, true);\n        }\n    }\n    return this;\n}\n\nfunction hasAlignedHourOffset (input) {\n    if (!this.isValid()) {\n        return false;\n    }\n    input = input ? createLocal(input).utcOffset() : 0;\n\n    return (this.utcOffset() - input) % 60 === 0;\n}\n\nfunction isDaylightSavingTime () {\n    return (\n        this.utcOffset() > this.clone().month(0).utcOffset() ||\n        this.utcOffset() > this.clone().month(5).utcOffset()\n    );\n}\n\nfunction isDaylightSavingTimeShifted () {\n    if (!isUndefined(this._isDSTShifted)) {\n        return this._isDSTShifted;\n    }\n\n    var c = {};\n\n    copyConfig(c, this);\n    c = prepareConfig(c);\n\n    if (c._a) {\n        var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);\n        this._isDSTShifted = this.isValid() &&\n            compareArrays(c._a, other.toArray()) > 0;\n    } else {\n        this._isDSTShifted = false;\n    }\n\n    return this._isDSTShifted;\n}\n\nfunction isLocal () {\n    return this.isValid() ? !this._isUTC : false;\n}\n\nfunction isUtcOffset () {\n    return this.isValid() ? this._isUTC : false;\n}\n\nfunction isUtc () {\n    return this.isValid() ? this._isUTC && this._offset === 0 : false;\n}\n\n// ASP.NET json date format regex\nvar aspNetRegex = /^(\\-)?(?:(\\d*)[. ])?(\\d+)\\:(\\d+)(?:\\:(\\d+)(\\.\\d*)?)?$/;\n\n// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html\n// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere\n// and further modified to allow for strings containing both week and day\nvar isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;\n\nfunction createDuration (input, key) {\n    var duration = input,\n        // matching against regexp is expensive, do it on demand\n        match = null,\n        sign,\n        ret,\n        diffRes;\n\n    if (isDuration(input)) {\n        duration = {\n            ms : input._milliseconds,\n            d  : input._days,\n            M  : input._months\n        };\n    } else if (isNumber(input)) {\n        duration = {};\n        if (key) {\n            duration[key] = input;\n        } else {\n            duration.milliseconds = input;\n        }\n    } else if (!!(match = aspNetRegex.exec(input))) {\n        sign = (match[1] === '-') ? -1 : 1;\n        duration = {\n            y  : 0,\n            d  : toInt(match[DATE])                         * sign,\n            h  : toInt(match[HOUR])                         * sign,\n            m  : toInt(match[MINUTE])                       * sign,\n            s  : toInt(match[SECOND])                       * sign,\n            ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match\n        };\n    } else if (!!(match = isoRegex.exec(input))) {\n        sign = (match[1] === '-') ? -1 : 1;\n        duration = {\n            y : parseIso(match[2], sign),\n            M : parseIso(match[3], sign),\n            w : parseIso(match[4], sign),\n            d : parseIso(match[5], sign),\n            h : parseIso(match[6], sign),\n            m : parseIso(match[7], sign),\n            s : parseIso(match[8], sign)\n        };\n    } else if (duration == null) {// checks for null or undefined\n        duration = {};\n    } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {\n        diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));\n\n        duration = {};\n        duration.ms = diffRes.milliseconds;\n        duration.M = diffRes.months;\n    }\n\n    ret = new Duration(duration);\n\n    if (isDuration(input) && hasOwnProp(input, '_locale')) {\n        ret._locale = input._locale;\n    }\n\n    return ret;\n}\n\ncreateDuration.fn = Duration.prototype;\ncreateDuration.invalid = createInvalid$1;\n\nfunction parseIso (inp, sign) {\n    // We'd normally use ~~inp for this, but unfortunately it also\n    // converts floats to ints.\n    // inp may be undefined, so careful calling replace on it.\n    var res = inp && parseFloat(inp.replace(',', '.'));\n    // apply sign while we're at it\n    return (isNaN(res) ? 0 : res) * sign;\n}\n\nfunction positiveMomentsDifference(base, other) {\n    var res = {milliseconds: 0, months: 0};\n\n    res.months = other.month() - base.month() +\n        (other.year() - base.year()) * 12;\n    if (base.clone().add(res.months, 'M').isAfter(other)) {\n        --res.months;\n    }\n\n    res.milliseconds = +other - +(base.clone().add(res.months, 'M'));\n\n    return res;\n}\n\nfunction momentsDifference(base, other) {\n    var res;\n    if (!(base.isValid() && other.isValid())) {\n        return {milliseconds: 0, months: 0};\n    }\n\n    other = cloneWithOffset(other, base);\n    if (base.isBefore(other)) {\n        res = positiveMomentsDifference(base, other);\n    } else {\n        res = positiveMomentsDifference(other, base);\n        res.milliseconds = -res.milliseconds;\n        res.months = -res.months;\n    }\n\n    return res;\n}\n\n// TODO: remove 'name' arg after deprecation is removed\nfunction createAdder(direction, name) {\n    return function (val, period) {\n        var dur, tmp;\n        //invert the arguments, but complain about it\n        if (period !== null && !isNaN(+period)) {\n            deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +\n            'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');\n            tmp = val; val = period; period = tmp;\n        }\n\n        val = typeof val === 'string' ? +val : val;\n        dur = createDuration(val, period);\n        addSubtract(this, dur, direction);\n        return this;\n    };\n}\n\nfunction addSubtract (mom, duration, isAdding, updateOffset) {\n    var milliseconds = duration._milliseconds,\n        days = absRound(duration._days),\n        months = absRound(duration._months);\n\n    if (!mom.isValid()) {\n        // No op\n        return;\n    }\n\n    updateOffset = updateOffset == null ? true : updateOffset;\n\n    if (milliseconds) {\n        mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);\n    }\n    if (days) {\n        set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);\n    }\n    if (months) {\n        setMonth(mom, get(mom, 'Month') + months * isAdding);\n    }\n    if (updateOffset) {\n        hooks.updateOffset(mom, days || months);\n    }\n}\n\nvar add      = createAdder(1, 'add');\nvar subtract = createAdder(-1, 'subtract');\n\nfunction getCalendarFormat(myMoment, now) {\n    var diff = myMoment.diff(now, 'days', true);\n    return diff < -6 ? 'sameElse' :\n            diff < -1 ? 'lastWeek' :\n            diff < 0 ? 'lastDay' :\n            diff < 1 ? 'sameDay' :\n            diff < 2 ? 'nextDay' :\n            diff < 7 ? 'nextWeek' : 'sameElse';\n}\n\nfunction calendar$1 (time, formats) {\n    // We want to compare the start of today, vs this.\n    // Getting start-of-today depends on whether we're local/utc/offset or not.\n    var now = time || createLocal(),\n        sod = cloneWithOffset(now, this).startOf('day'),\n        format = hooks.calendarFormat(this, sod) || 'sameElse';\n\n    var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);\n\n    return this.format(output || this.localeData().calendar(format, this, createLocal(now)));\n}\n\nfunction clone () {\n    return new Moment(this);\n}\n\nfunction isAfter (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input);\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() > localInput.valueOf();\n    } else {\n        return localInput.valueOf() < this.clone().startOf(units).valueOf();\n    }\n}\n\nfunction isBefore (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input);\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() < localInput.valueOf();\n    } else {\n        return this.clone().endOf(units).valueOf() < localInput.valueOf();\n    }\n}\n\nfunction isBetween (from, to, units, inclusivity) {\n    inclusivity = inclusivity || '()';\n    return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&\n        (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));\n}\n\nfunction isSame (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input),\n        inputMs;\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(units || 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() === localInput.valueOf();\n    } else {\n        inputMs = localInput.valueOf();\n        return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();\n    }\n}\n\nfunction isSameOrAfter (input, units) {\n    return this.isSame(input, units) || this.isAfter(input,units);\n}\n\nfunction isSameOrBefore (input, units) {\n    return this.isSame(input, units) || this.isBefore(input,units);\n}\n\nfunction diff (input, units, asFloat) {\n    var that,\n        zoneDelta,\n        delta, output;\n\n    if (!this.isValid()) {\n        return NaN;\n    }\n\n    that = cloneWithOffset(input, this);\n\n    if (!that.isValid()) {\n        return NaN;\n    }\n\n    zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;\n\n    units = normalizeUnits(units);\n\n    if (units === 'year' || units === 'month' || units === 'quarter') {\n        output = monthDiff(this, that);\n        if (units === 'quarter') {\n            output = output / 3;\n        } else if (units === 'year') {\n            output = output / 12;\n        }\n    } else {\n        delta = this - that;\n        output = units === 'second' ? delta / 1e3 : // 1000\n            units === 'minute' ? delta / 6e4 : // 1000 * 60\n            units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60\n            units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst\n            units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst\n            delta;\n    }\n    return asFloat ? output : absFloor(output);\n}\n\nfunction monthDiff (a, b) {\n    // difference in months\n    var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),\n        // b is in (anchor - 1 month, anchor + 1 month)\n        anchor = a.clone().add(wholeMonthDiff, 'months'),\n        anchor2, adjust;\n\n    if (b - anchor < 0) {\n        anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');\n        // linear across the month\n        adjust = (b - anchor) / (anchor - anchor2);\n    } else {\n        anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');\n        // linear across the month\n        adjust = (b - anchor) / (anchor2 - anchor);\n    }\n\n    //check for negative zero, return zero if negative zero\n    return -(wholeMonthDiff + adjust) || 0;\n}\n\nhooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';\nhooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';\n\nfunction toString () {\n    return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');\n}\n\nfunction toISOString() {\n    if (!this.isValid()) {\n        return null;\n    }\n    var m = this.clone().utc();\n    if (m.year() < 0 || m.year() > 9999) {\n        return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n    }\n    if (isFunction(Date.prototype.toISOString)) {\n        // native implementation is ~50x faster, use it when we can\n        return this.toDate().toISOString();\n    }\n    return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n}\n\n/**\n * Return a human readable representation of a moment that can\n * also be evaluated to get a new moment which is the same\n *\n * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects\n */\nfunction inspect () {\n    if (!this.isValid()) {\n        return 'moment.invalid(/* ' + this._i + ' */)';\n    }\n    var func = 'moment';\n    var zone = '';\n    if (!this.isLocal()) {\n        func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';\n        zone = 'Z';\n    }\n    var prefix = '[' + func + '(\"]';\n    var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';\n    var datetime = '-MM-DD[T]HH:mm:ss.SSS';\n    var suffix = zone + '[\")]';\n\n    return this.format(prefix + year + datetime + suffix);\n}\n\nfunction format (inputString) {\n    if (!inputString) {\n        inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;\n    }\n    var output = formatMoment(this, inputString);\n    return this.localeData().postformat(output);\n}\n\nfunction from (time, withoutSuffix) {\n    if (this.isValid() &&\n            ((isMoment(time) && time.isValid()) ||\n             createLocal(time).isValid())) {\n        return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);\n    } else {\n        return this.localeData().invalidDate();\n    }\n}\n\nfunction fromNow (withoutSuffix) {\n    return this.from(createLocal(), withoutSuffix);\n}\n\nfunction to (time, withoutSuffix) {\n    if (this.isValid() &&\n            ((isMoment(time) && time.isValid()) ||\n             createLocal(time).isValid())) {\n        return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);\n    } else {\n        return this.localeData().invalidDate();\n    }\n}\n\nfunction toNow (withoutSuffix) {\n    return this.to(createLocal(), withoutSuffix);\n}\n\n// If passed a locale key, it will set the locale for this\n// instance.  Otherwise, it will return the locale configuration\n// variables for this instance.\nfunction locale (key) {\n    var newLocaleData;\n\n    if (key === undefined) {\n        return this._locale._abbr;\n    } else {\n        newLocaleData = getLocale(key);\n        if (newLocaleData != null) {\n            this._locale = newLocaleData;\n        }\n        return this;\n    }\n}\n\nvar lang = deprecate(\n    'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',\n    function (key) {\n        if (key === undefined) {\n            return this.localeData();\n        } else {\n            return this.locale(key);\n        }\n    }\n);\n\nfunction localeData () {\n    return this._locale;\n}\n\nfunction startOf (units) {\n    units = normalizeUnits(units);\n    // the following switch intentionally omits break keywords\n    // to utilize falling through the cases.\n    switch (units) {\n        case 'year':\n            this.month(0);\n            /* falls through */\n        case 'quarter':\n        case 'month':\n            this.date(1);\n            /* falls through */\n        case 'week':\n        case 'isoWeek':\n        case 'day':\n        case 'date':\n            this.hours(0);\n            /* falls through */\n        case 'hour':\n            this.minutes(0);\n            /* falls through */\n        case 'minute':\n            this.seconds(0);\n            /* falls through */\n        case 'second':\n            this.milliseconds(0);\n    }\n\n    // weeks are a special case\n    if (units === 'week') {\n        this.weekday(0);\n    }\n    if (units === 'isoWeek') {\n        this.isoWeekday(1);\n    }\n\n    // quarters are also special\n    if (units === 'quarter') {\n        this.month(Math.floor(this.month() / 3) * 3);\n    }\n\n    return this;\n}\n\nfunction endOf (units) {\n    units = normalizeUnits(units);\n    if (units === undefined || units === 'millisecond') {\n        return this;\n    }\n\n    // 'date' is an alias for 'day', so it should be considered as such.\n    if (units === 'date') {\n        units = 'day';\n    }\n\n    return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');\n}\n\nfunction valueOf () {\n    return this._d.valueOf() - ((this._offset || 0) * 60000);\n}\n\nfunction unix () {\n    return Math.floor(this.valueOf() / 1000);\n}\n\nfunction toDate () {\n    return new Date(this.valueOf());\n}\n\nfunction toArray () {\n    var m = this;\n    return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];\n}\n\nfunction toObject () {\n    var m = this;\n    return {\n        years: m.year(),\n        months: m.month(),\n        date: m.date(),\n        hours: m.hours(),\n        minutes: m.minutes(),\n        seconds: m.seconds(),\n        milliseconds: m.milliseconds()\n    };\n}\n\nfunction toJSON () {\n    // new Date(NaN).toJSON() === null\n    return this.isValid() ? this.toISOString() : null;\n}\n\nfunction isValid$2 () {\n    return isValid(this);\n}\n\nfunction parsingFlags () {\n    return extend({}, getParsingFlags(this));\n}\n\nfunction invalidAt () {\n    return getParsingFlags(this).overflow;\n}\n\nfunction creationData() {\n    return {\n        input: this._i,\n        format: this._f,\n        locale: this._locale,\n        isUTC: this._isUTC,\n        strict: this._strict\n    };\n}\n\n// FORMATTING\n\naddFormatToken(0, ['gg', 2], 0, function () {\n    return this.weekYear() % 100;\n});\n\naddFormatToken(0, ['GG', 2], 0, function () {\n    return this.isoWeekYear() % 100;\n});\n\nfunction addWeekYearFormatToken (token, getter) {\n    addFormatToken(0, [token, token.length], 0, getter);\n}\n\naddWeekYearFormatToken('gggg',     'weekYear');\naddWeekYearFormatToken('ggggg',    'weekYear');\naddWeekYearFormatToken('GGGG',  'isoWeekYear');\naddWeekYearFormatToken('GGGGG', 'isoWeekYear');\n\n// ALIASES\n\naddUnitAlias('weekYear', 'gg');\naddUnitAlias('isoWeekYear', 'GG');\n\n// PRIORITY\n\naddUnitPriority('weekYear', 1);\naddUnitPriority('isoWeekYear', 1);\n\n\n// PARSING\n\naddRegexToken('G',      matchSigned);\naddRegexToken('g',      matchSigned);\naddRegexToken('GG',     match1to2, match2);\naddRegexToken('gg',     match1to2, match2);\naddRegexToken('GGGG',   match1to4, match4);\naddRegexToken('gggg',   match1to4, match4);\naddRegexToken('GGGGG',  match1to6, match6);\naddRegexToken('ggggg',  match1to6, match6);\n\naddWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {\n    week[token.substr(0, 2)] = toInt(input);\n});\n\naddWeekParseToken(['gg', 'GG'], function (input, week, config, token) {\n    week[token] = hooks.parseTwoDigitYear(input);\n});\n\n// MOMENTS\n\nfunction getSetWeekYear (input) {\n    return getSetWeekYearHelper.call(this,\n            input,\n            this.week(),\n            this.weekday(),\n            this.localeData()._week.dow,\n            this.localeData()._week.doy);\n}\n\nfunction getSetISOWeekYear (input) {\n    return getSetWeekYearHelper.call(this,\n            input, this.isoWeek(), this.isoWeekday(), 1, 4);\n}\n\nfunction getISOWeeksInYear () {\n    return weeksInYear(this.year(), 1, 4);\n}\n\nfunction getWeeksInYear () {\n    var weekInfo = this.localeData()._week;\n    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);\n}\n\nfunction getSetWeekYearHelper(input, week, weekday, dow, doy) {\n    var weeksTarget;\n    if (input == null) {\n        return weekOfYear(this, dow, doy).year;\n    } else {\n        weeksTarget = weeksInYear(input, dow, doy);\n        if (week > weeksTarget) {\n            week = weeksTarget;\n        }\n        return setWeekAll.call(this, input, week, weekday, dow, doy);\n    }\n}\n\nfunction setWeekAll(weekYear, week, weekday, dow, doy) {\n    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),\n        date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);\n\n    this.year(date.getUTCFullYear());\n    this.month(date.getUTCMonth());\n    this.date(date.getUTCDate());\n    return this;\n}\n\n// FORMATTING\n\naddFormatToken('Q', 0, 'Qo', 'quarter');\n\n// ALIASES\n\naddUnitAlias('quarter', 'Q');\n\n// PRIORITY\n\naddUnitPriority('quarter', 7);\n\n// PARSING\n\naddRegexToken('Q', match1);\naddParseToken('Q', function (input, array) {\n    array[MONTH] = (toInt(input) - 1) * 3;\n});\n\n// MOMENTS\n\nfunction getSetQuarter (input) {\n    return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);\n}\n\n// FORMATTING\n\naddFormatToken('D', ['DD', 2], 'Do', 'date');\n\n// ALIASES\n\naddUnitAlias('date', 'D');\n\n// PRIOROITY\naddUnitPriority('date', 9);\n\n// PARSING\n\naddRegexToken('D',  match1to2);\naddRegexToken('DD', match1to2, match2);\naddRegexToken('Do', function (isStrict, locale) {\n    // TODO: Remove \"ordinalParse\" fallback in next major release.\n    return isStrict ?\n      (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :\n      locale._dayOfMonthOrdinalParseLenient;\n});\n\naddParseToken(['D', 'DD'], DATE);\naddParseToken('Do', function (input, array) {\n    array[DATE] = toInt(input.match(match1to2)[0], 10);\n});\n\n// MOMENTS\n\nvar getSetDayOfMonth = makeGetSet('Date', true);\n\n// FORMATTING\n\naddFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');\n\n// ALIASES\n\naddUnitAlias('dayOfYear', 'DDD');\n\n// PRIORITY\naddUnitPriority('dayOfYear', 4);\n\n// PARSING\n\naddRegexToken('DDD',  match1to3);\naddRegexToken('DDDD', match3);\naddParseToken(['DDD', 'DDDD'], function (input, array, config) {\n    config._dayOfYear = toInt(input);\n});\n\n// HELPERS\n\n// MOMENTS\n\nfunction getSetDayOfYear (input) {\n    var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;\n    return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');\n}\n\n// FORMATTING\n\naddFormatToken('m', ['mm', 2], 0, 'minute');\n\n// ALIASES\n\naddUnitAlias('minute', 'm');\n\n// PRIORITY\n\naddUnitPriority('minute', 14);\n\n// PARSING\n\naddRegexToken('m',  match1to2);\naddRegexToken('mm', match1to2, match2);\naddParseToken(['m', 'mm'], MINUTE);\n\n// MOMENTS\n\nvar getSetMinute = makeGetSet('Minutes', false);\n\n// FORMATTING\n\naddFormatToken('s', ['ss', 2], 0, 'second');\n\n// ALIASES\n\naddUnitAlias('second', 's');\n\n// PRIORITY\n\naddUnitPriority('second', 15);\n\n// PARSING\n\naddRegexToken('s',  match1to2);\naddRegexToken('ss', match1to2, match2);\naddParseToken(['s', 'ss'], SECOND);\n\n// MOMENTS\n\nvar getSetSecond = makeGetSet('Seconds', false);\n\n// FORMATTING\n\naddFormatToken('S', 0, 0, function () {\n    return ~~(this.millisecond() / 100);\n});\n\naddFormatToken(0, ['SS', 2], 0, function () {\n    return ~~(this.millisecond() / 10);\n});\n\naddFormatToken(0, ['SSS', 3], 0, 'millisecond');\naddFormatToken(0, ['SSSS', 4], 0, function () {\n    return this.millisecond() * 10;\n});\naddFormatToken(0, ['SSSSS', 5], 0, function () {\n    return this.millisecond() * 100;\n});\naddFormatToken(0, ['SSSSSS', 6], 0, function () {\n    return this.millisecond() * 1000;\n});\naddFormatToken(0, ['SSSSSSS', 7], 0, function () {\n    return this.millisecond() * 10000;\n});\naddFormatToken(0, ['SSSSSSSS', 8], 0, function () {\n    return this.millisecond() * 100000;\n});\naddFormatToken(0, ['SSSSSSSSS', 9], 0, function () {\n    return this.millisecond() * 1000000;\n});\n\n\n// ALIASES\n\naddUnitAlias('millisecond', 'ms');\n\n// PRIORITY\n\naddUnitPriority('millisecond', 16);\n\n// PARSING\n\naddRegexToken('S',    match1to3, match1);\naddRegexToken('SS',   match1to3, match2);\naddRegexToken('SSS',  match1to3, match3);\n\nvar token;\nfor (token = 'SSSS'; token.length <= 9; token += 'S') {\n    addRegexToken(token, matchUnsigned);\n}\n\nfunction parseMs(input, array) {\n    array[MILLISECOND] = toInt(('0.' + input) * 1000);\n}\n\nfor (token = 'S'; token.length <= 9; token += 'S') {\n    addParseToken(token, parseMs);\n}\n// MOMENTS\n\nvar getSetMillisecond = makeGetSet('Milliseconds', false);\n\n// FORMATTING\n\naddFormatToken('z',  0, 0, 'zoneAbbr');\naddFormatToken('zz', 0, 0, 'zoneName');\n\n// MOMENTS\n\nfunction getZoneAbbr () {\n    return this._isUTC ? 'UTC' : '';\n}\n\nfunction getZoneName () {\n    return this._isUTC ? 'Coordinated Universal Time' : '';\n}\n\nvar proto = Moment.prototype;\n\nproto.add               = add;\nproto.calendar          = calendar$1;\nproto.clone             = clone;\nproto.diff              = diff;\nproto.endOf             = endOf;\nproto.format            = format;\nproto.from              = from;\nproto.fromNow           = fromNow;\nproto.to                = to;\nproto.toNow             = toNow;\nproto.get               = stringGet;\nproto.invalidAt         = invalidAt;\nproto.isAfter           = isAfter;\nproto.isBefore          = isBefore;\nproto.isBetween         = isBetween;\nproto.isSame            = isSame;\nproto.isSameOrAfter     = isSameOrAfter;\nproto.isSameOrBefore    = isSameOrBefore;\nproto.isValid           = isValid$2;\nproto.lang              = lang;\nproto.locale            = locale;\nproto.localeData        = localeData;\nproto.max               = prototypeMax;\nproto.min               = prototypeMin;\nproto.parsingFlags      = parsingFlags;\nproto.set               = stringSet;\nproto.startOf           = startOf;\nproto.subtract          = subtract;\nproto.toArray           = toArray;\nproto.toObject          = toObject;\nproto.toDate            = toDate;\nproto.toISOString       = toISOString;\nproto.inspect           = inspect;\nproto.toJSON            = toJSON;\nproto.toString          = toString;\nproto.unix              = unix;\nproto.valueOf           = valueOf;\nproto.creationData      = creationData;\n\n// Year\nproto.year       = getSetYear;\nproto.isLeapYear = getIsLeapYear;\n\n// Week Year\nproto.weekYear    = getSetWeekYear;\nproto.isoWeekYear = getSetISOWeekYear;\n\n// Quarter\nproto.quarter = proto.quarters = getSetQuarter;\n\n// Month\nproto.month       = getSetMonth;\nproto.daysInMonth = getDaysInMonth;\n\n// Week\nproto.week           = proto.weeks        = getSetWeek;\nproto.isoWeek        = proto.isoWeeks     = getSetISOWeek;\nproto.weeksInYear    = getWeeksInYear;\nproto.isoWeeksInYear = getISOWeeksInYear;\n\n// Day\nproto.date       = getSetDayOfMonth;\nproto.day        = proto.days             = getSetDayOfWeek;\nproto.weekday    = getSetLocaleDayOfWeek;\nproto.isoWeekday = getSetISODayOfWeek;\nproto.dayOfYear  = getSetDayOfYear;\n\n// Hour\nproto.hour = proto.hours = getSetHour;\n\n// Minute\nproto.minute = proto.minutes = getSetMinute;\n\n// Second\nproto.second = proto.seconds = getSetSecond;\n\n// Millisecond\nproto.millisecond = proto.milliseconds = getSetMillisecond;\n\n// Offset\nproto.utcOffset            = getSetOffset;\nproto.utc                  = setOffsetToUTC;\nproto.local                = setOffsetToLocal;\nproto.parseZone            = setOffsetToParsedOffset;\nproto.hasAlignedHourOffset = hasAlignedHourOffset;\nproto.isDST                = isDaylightSavingTime;\nproto.isLocal              = isLocal;\nproto.isUtcOffset          = isUtcOffset;\nproto.isUtc                = isUtc;\nproto.isUTC                = isUtc;\n\n// Timezone\nproto.zoneAbbr = getZoneAbbr;\nproto.zoneName = getZoneName;\n\n// Deprecations\nproto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);\nproto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);\nproto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);\nproto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);\nproto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);\n\nfunction createUnix (input) {\n    return createLocal(input * 1000);\n}\n\nfunction createInZone () {\n    return createLocal.apply(null, arguments).parseZone();\n}\n\nfunction preParsePostFormat (string) {\n    return string;\n}\n\nvar proto$1 = Locale.prototype;\n\nproto$1.calendar        = calendar;\nproto$1.longDateFormat  = longDateFormat;\nproto$1.invalidDate     = invalidDate;\nproto$1.ordinal         = ordinal;\nproto$1.preparse        = preParsePostFormat;\nproto$1.postformat      = preParsePostFormat;\nproto$1.relativeTime    = relativeTime;\nproto$1.pastFuture      = pastFuture;\nproto$1.set             = set;\n\n// Month\nproto$1.months            =        localeMonths;\nproto$1.monthsShort       =        localeMonthsShort;\nproto$1.monthsParse       =        localeMonthsParse;\nproto$1.monthsRegex       = monthsRegex;\nproto$1.monthsShortRegex  = monthsShortRegex;\n\n// Week\nproto$1.week = localeWeek;\nproto$1.firstDayOfYear = localeFirstDayOfYear;\nproto$1.firstDayOfWeek = localeFirstDayOfWeek;\n\n// Day of Week\nproto$1.weekdays       =        localeWeekdays;\nproto$1.weekdaysMin    =        localeWeekdaysMin;\nproto$1.weekdaysShort  =        localeWeekdaysShort;\nproto$1.weekdaysParse  =        localeWeekdaysParse;\n\nproto$1.weekdaysRegex       =        weekdaysRegex;\nproto$1.weekdaysShortRegex  =        weekdaysShortRegex;\nproto$1.weekdaysMinRegex    =        weekdaysMinRegex;\n\n// Hours\nproto$1.isPM = localeIsPM;\nproto$1.meridiem = localeMeridiem;\n\nfunction get$1 (format, index, field, setter) {\n    var locale = getLocale();\n    var utc = createUTC().set(setter, index);\n    return locale[field](utc, format);\n}\n\nfunction listMonthsImpl (format, index, field) {\n    if (isNumber(format)) {\n        index = format;\n        format = undefined;\n    }\n\n    format = format || '';\n\n    if (index != null) {\n        return get$1(format, index, field, 'month');\n    }\n\n    var i;\n    var out = [];\n    for (i = 0; i < 12; i++) {\n        out[i] = get$1(format, i, field, 'month');\n    }\n    return out;\n}\n\n// ()\n// (5)\n// (fmt, 5)\n// (fmt)\n// (true)\n// (true, 5)\n// (true, fmt, 5)\n// (true, fmt)\nfunction listWeekdaysImpl (localeSorted, format, index, field) {\n    if (typeof localeSorted === 'boolean') {\n        if (isNumber(format)) {\n            index = format;\n            format = undefined;\n        }\n\n        format = format || '';\n    } else {\n        format = localeSorted;\n        index = format;\n        localeSorted = false;\n\n        if (isNumber(format)) {\n            index = format;\n            format = undefined;\n        }\n\n        format = format || '';\n    }\n\n    var locale = getLocale(),\n        shift = localeSorted ? locale._week.dow : 0;\n\n    if (index != null) {\n        return get$1(format, (index + shift) % 7, field, 'day');\n    }\n\n    var i;\n    var out = [];\n    for (i = 0; i < 7; i++) {\n        out[i] = get$1(format, (i + shift) % 7, field, 'day');\n    }\n    return out;\n}\n\nfunction listMonths (format, index) {\n    return listMonthsImpl(format, index, 'months');\n}\n\nfunction listMonthsShort (format, index) {\n    return listMonthsImpl(format, index, 'monthsShort');\n}\n\nfunction listWeekdays (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdays');\n}\n\nfunction listWeekdaysShort (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');\n}\n\nfunction listWeekdaysMin (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');\n}\n\ngetSetGlobalLocale('en', {\n    dayOfMonthOrdinalParse: /\\d{1,2}(th|st|nd|rd)/,\n    ordinal : function (number) {\n        var b = number % 10,\n            output = (toInt(number % 100 / 10) === 1) ? 'th' :\n            (b === 1) ? 'st' :\n            (b === 2) ? 'nd' :\n            (b === 3) ? 'rd' : 'th';\n        return number + output;\n    }\n});\n\n// Side effect imports\nhooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);\nhooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);\n\nvar mathAbs = Math.abs;\n\nfunction abs () {\n    var data           = this._data;\n\n    this._milliseconds = mathAbs(this._milliseconds);\n    this._days         = mathAbs(this._days);\n    this._months       = mathAbs(this._months);\n\n    data.milliseconds  = mathAbs(data.milliseconds);\n    data.seconds       = mathAbs(data.seconds);\n    data.minutes       = mathAbs(data.minutes);\n    data.hours         = mathAbs(data.hours);\n    data.months        = mathAbs(data.months);\n    data.years         = mathAbs(data.years);\n\n    return this;\n}\n\nfunction addSubtract$1 (duration, input, value, direction) {\n    var other = createDuration(input, value);\n\n    duration._milliseconds += direction * other._milliseconds;\n    duration._days         += direction * other._days;\n    duration._months       += direction * other._months;\n\n    return duration._bubble();\n}\n\n// supports only 2.0-style add(1, 's') or add(duration)\nfunction add$1 (input, value) {\n    return addSubtract$1(this, input, value, 1);\n}\n\n// supports only 2.0-style subtract(1, 's') or subtract(duration)\nfunction subtract$1 (input, value) {\n    return addSubtract$1(this, input, value, -1);\n}\n\nfunction absCeil (number) {\n    if (number < 0) {\n        return Math.floor(number);\n    } else {\n        return Math.ceil(number);\n    }\n}\n\nfunction bubble () {\n    var milliseconds = this._milliseconds;\n    var days         = this._days;\n    var months       = this._months;\n    var data         = this._data;\n    var seconds, minutes, hours, years, monthsFromDays;\n\n    // if we have a mix of positive and negative values, bubble down first\n    // check: https://github.com/moment/moment/issues/2166\n    if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||\n            (milliseconds <= 0 && days <= 0 && months <= 0))) {\n        milliseconds += absCeil(monthsToDays(months) + days) * 864e5;\n        days = 0;\n        months = 0;\n    }\n\n    // The following code bubbles up values, see the tests for\n    // examples of what that means.\n    data.milliseconds = milliseconds % 1000;\n\n    seconds           = absFloor(milliseconds / 1000);\n    data.seconds      = seconds % 60;\n\n    minutes           = absFloor(seconds / 60);\n    data.minutes      = minutes % 60;\n\n    hours             = absFloor(minutes / 60);\n    data.hours        = hours % 24;\n\n    days += absFloor(hours / 24);\n\n    // convert days to months\n    monthsFromDays = absFloor(daysToMonths(days));\n    months += monthsFromDays;\n    days -= absCeil(monthsToDays(monthsFromDays));\n\n    // 12 months -> 1 year\n    years = absFloor(months / 12);\n    months %= 12;\n\n    data.days   = days;\n    data.months = months;\n    data.years  = years;\n\n    return this;\n}\n\nfunction daysToMonths (days) {\n    // 400 years have 146097 days (taking into account leap year rules)\n    // 400 years have 12 months === 4800\n    return days * 4800 / 146097;\n}\n\nfunction monthsToDays (months) {\n    // the reverse of daysToMonths\n    return months * 146097 / 4800;\n}\n\nfunction as (units) {\n    if (!this.isValid()) {\n        return NaN;\n    }\n    var days;\n    var months;\n    var milliseconds = this._milliseconds;\n\n    units = normalizeUnits(units);\n\n    if (units === 'month' || units === 'year') {\n        days   = this._days   + milliseconds / 864e5;\n        months = this._months + daysToMonths(days);\n        return units === 'month' ? months : months / 12;\n    } else {\n        // handle milliseconds separately because of floating point math errors (issue #1867)\n        days = this._days + Math.round(monthsToDays(this._months));\n        switch (units) {\n            case 'week'   : return days / 7     + milliseconds / 6048e5;\n            case 'day'    : return days         + milliseconds / 864e5;\n            case 'hour'   : return days * 24    + milliseconds / 36e5;\n            case 'minute' : return days * 1440  + milliseconds / 6e4;\n            case 'second' : return days * 86400 + milliseconds / 1000;\n            // Math.floor prevents floating point math errors here\n            case 'millisecond': return Math.floor(days * 864e5) + milliseconds;\n            default: throw new Error('Unknown unit ' + units);\n        }\n    }\n}\n\n// TODO: Use this.as('ms')?\nfunction valueOf$1 () {\n    if (!this.isValid()) {\n        return NaN;\n    }\n    return (\n        this._milliseconds +\n        this._days * 864e5 +\n        (this._months % 12) * 2592e6 +\n        toInt(this._months / 12) * 31536e6\n    );\n}\n\nfunction makeAs (alias) {\n    return function () {\n        return this.as(alias);\n    };\n}\n\nvar asMilliseconds = makeAs('ms');\nvar asSeconds      = makeAs('s');\nvar asMinutes      = makeAs('m');\nvar asHours        = makeAs('h');\nvar asDays         = makeAs('d');\nvar asWeeks        = makeAs('w');\nvar asMonths       = makeAs('M');\nvar asYears        = makeAs('y');\n\nfunction get$2 (units) {\n    units = normalizeUnits(units);\n    return this.isValid() ? this[units + 's']() : NaN;\n}\n\nfunction makeGetter(name) {\n    return function () {\n        return this.isValid() ? this._data[name] : NaN;\n    };\n}\n\nvar milliseconds = makeGetter('milliseconds');\nvar seconds      = makeGetter('seconds');\nvar minutes      = makeGetter('minutes');\nvar hours        = makeGetter('hours');\nvar days         = makeGetter('days');\nvar months       = makeGetter('months');\nvar years        = makeGetter('years');\n\nfunction weeks () {\n    return absFloor(this.days() / 7);\n}\n\nvar round = Math.round;\nvar thresholds = {\n    ss: 44,         // a few seconds to seconds\n    s : 45,         // seconds to minute\n    m : 45,         // minutes to hour\n    h : 22,         // hours to day\n    d : 26,         // days to month\n    M : 11          // months to year\n};\n\n// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize\nfunction substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {\n    return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);\n}\n\nfunction relativeTime$1 (posNegDuration, withoutSuffix, locale) {\n    var duration = createDuration(posNegDuration).abs();\n    var seconds  = round(duration.as('s'));\n    var minutes  = round(duration.as('m'));\n    var hours    = round(duration.as('h'));\n    var days     = round(duration.as('d'));\n    var months   = round(duration.as('M'));\n    var years    = round(duration.as('y'));\n\n    var a = seconds <= thresholds.ss && ['s', seconds]  ||\n            seconds < thresholds.s   && ['ss', seconds] ||\n            minutes <= 1             && ['m']           ||\n            minutes < thresholds.m   && ['mm', minutes] ||\n            hours   <= 1             && ['h']           ||\n            hours   < thresholds.h   && ['hh', hours]   ||\n            days    <= 1             && ['d']           ||\n            days    < thresholds.d   && ['dd', days]    ||\n            months  <= 1             && ['M']           ||\n            months  < thresholds.M   && ['MM', months]  ||\n            years   <= 1             && ['y']           || ['yy', years];\n\n    a[2] = withoutSuffix;\n    a[3] = +posNegDuration > 0;\n    a[4] = locale;\n    return substituteTimeAgo.apply(null, a);\n}\n\n// This function allows you to set the rounding function for relative time strings\nfunction getSetRelativeTimeRounding (roundingFunction) {\n    if (roundingFunction === undefined) {\n        return round;\n    }\n    if (typeof(roundingFunction) === 'function') {\n        round = roundingFunction;\n        return true;\n    }\n    return false;\n}\n\n// This function allows you to set a threshold for relative time strings\nfunction getSetRelativeTimeThreshold (threshold, limit) {\n    if (thresholds[threshold] === undefined) {\n        return false;\n    }\n    if (limit === undefined) {\n        return thresholds[threshold];\n    }\n    thresholds[threshold] = limit;\n    if (threshold === 's') {\n        thresholds.ss = limit - 1;\n    }\n    return true;\n}\n\nfunction humanize (withSuffix) {\n    if (!this.isValid()) {\n        return this.localeData().invalidDate();\n    }\n\n    var locale = this.localeData();\n    var output = relativeTime$1(this, !withSuffix, locale);\n\n    if (withSuffix) {\n        output = locale.pastFuture(+this, output);\n    }\n\n    return locale.postformat(output);\n}\n\nvar abs$1 = Math.abs;\n\nfunction toISOString$1() {\n    // for ISO strings we do not use the normal bubbling rules:\n    //  * milliseconds bubble up until they become hours\n    //  * days do not bubble at all\n    //  * months bubble up until they become years\n    // This is because there is no context-free conversion between hours and days\n    // (think of clock changes)\n    // and also not between days and months (28-31 days per month)\n    if (!this.isValid()) {\n        return this.localeData().invalidDate();\n    }\n\n    var seconds = abs$1(this._milliseconds) / 1000;\n    var days         = abs$1(this._days);\n    var months       = abs$1(this._months);\n    var minutes, hours, years;\n\n    // 3600 seconds -> 60 minutes -> 1 hour\n    minutes           = absFloor(seconds / 60);\n    hours             = absFloor(minutes / 60);\n    seconds %= 60;\n    minutes %= 60;\n\n    // 12 months -> 1 year\n    years  = absFloor(months / 12);\n    months %= 12;\n\n\n    // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js\n    var Y = years;\n    var M = months;\n    var D = days;\n    var h = hours;\n    var m = minutes;\n    var s = seconds;\n    var total = this.asSeconds();\n\n    if (!total) {\n        // this is the same as C#'s (Noda) and python (isodate)...\n        // but not other JS (goog.date)\n        return 'P0D';\n    }\n\n    return (total < 0 ? '-' : '') +\n        'P' +\n        (Y ? Y + 'Y' : '') +\n        (M ? M + 'M' : '') +\n        (D ? D + 'D' : '') +\n        ((h || m || s) ? 'T' : '') +\n        (h ? h + 'H' : '') +\n        (m ? m + 'M' : '') +\n        (s ? s + 'S' : '');\n}\n\nvar proto$2 = Duration.prototype;\n\nproto$2.isValid        = isValid$1;\nproto$2.abs            = abs;\nproto$2.add            = add$1;\nproto$2.subtract       = subtract$1;\nproto$2.as             = as;\nproto$2.asMilliseconds = asMilliseconds;\nproto$2.asSeconds      = asSeconds;\nproto$2.asMinutes      = asMinutes;\nproto$2.asHours        = asHours;\nproto$2.asDays         = asDays;\nproto$2.asWeeks        = asWeeks;\nproto$2.asMonths       = asMonths;\nproto$2.asYears        = asYears;\nproto$2.valueOf        = valueOf$1;\nproto$2._bubble        = bubble;\nproto$2.get            = get$2;\nproto$2.milliseconds   = milliseconds;\nproto$2.seconds        = seconds;\nproto$2.minutes        = minutes;\nproto$2.hours          = hours;\nproto$2.days           = days;\nproto$2.weeks          = weeks;\nproto$2.months         = months;\nproto$2.years          = years;\nproto$2.humanize       = humanize;\nproto$2.toISOString    = toISOString$1;\nproto$2.toString       = toISOString$1;\nproto$2.toJSON         = toISOString$1;\nproto$2.locale         = locale;\nproto$2.localeData     = localeData;\n\n// Deprecations\nproto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);\nproto$2.lang = lang;\n\n// Side effect imports\n\n// FORMATTING\n\naddFormatToken('X', 0, 0, 'unix');\naddFormatToken('x', 0, 0, 'valueOf');\n\n// PARSING\n\naddRegexToken('x', matchSigned);\naddRegexToken('X', matchTimestamp);\naddParseToken('X', function (input, array, config) {\n    config._d = new Date(parseFloat(input, 10) * 1000);\n});\naddParseToken('x', function (input, array, config) {\n    config._d = new Date(toInt(input));\n});\n\n// Side effect imports\n\n\nhooks.version = '2.18.1';\n\nsetHookCallback(createLocal);\n\nhooks.fn                    = proto;\nhooks.min                   = min;\nhooks.max                   = max;\nhooks.now                   = now;\nhooks.utc                   = createUTC;\nhooks.unix                  = createUnix;\nhooks.months                = listMonths;\nhooks.isDate                = isDate;\nhooks.locale                = getSetGlobalLocale;\nhooks.invalid               = createInvalid;\nhooks.duration              = createDuration;\nhooks.isMoment              = isMoment;\nhooks.weekdays              = listWeekdays;\nhooks.parseZone             = createInZone;\nhooks.localeData            = getLocale;\nhooks.isDuration            = isDuration;\nhooks.monthsShort           = listMonthsShort;\nhooks.weekdaysMin           = listWeekdaysMin;\nhooks.defineLocale          = defineLocale;\nhooks.updateLocale          = updateLocale;\nhooks.locales               = listLocales;\nhooks.weekdaysShort         = listWeekdaysShort;\nhooks.normalizeUnits        = normalizeUnits;\nhooks.relativeTimeRounding = getSetRelativeTimeRounding;\nhooks.relativeTimeThreshold = getSetRelativeTimeThreshold;\nhooks.calendarFormat        = getCalendarFormat;\nhooks.prototype             = proto;\n\nreturn hooks;\n\n})));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(142)(module)))\n\n/***/ }),\n\n/***/ 140:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction isObject(what) {\n    return typeof what === 'object' && what !== null;\n}\n\n// Yanked from https://git.io/vS8DV re-used under CC0\n// with some tiny modifications\nfunction isError(value) {\n  switch ({}.toString.call(value)) {\n    case '[object Error]': return true;\n    case '[object Exception]': return true;\n    case '[object DOMException]': return true;\n    default: return value instanceof Error;\n  }\n}\n\nfunction wrappedCallback(callback) {\n    function dataCallback(data, original) {\n      var normalizedData = callback(data) || data;\n      if (original) {\n          return original(normalizedData) || normalizedData;\n      }\n      return normalizedData;\n    }\n\n    return dataCallback;\n}\n\nmodule.exports = {\n    isObject: isObject,\n    isError: isError,\n    wrappedCallback: wrappedCallback\n};\n\n\n/***/ }),\n\n/***/ 141:\n/***/ (function(module, exports) {\n\n/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]';\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  // Safari 9 makes `arguments.length` enumerable in strict mode.\n  var result = (isArray(value) || isArguments(value))\n    ? baseTimes(value.length, String)\n    : [];\n\n  var length = result.length,\n      skipIndexes = !!length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\n/**\n * The base implementation of `_.forOwn` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\nfunction baseForOwn(object, iteratee) {\n  return object && baseFor(object, iteratee, keys);\n}\n\n/**\n * The base implementation of `_.invert` and `_.invertBy` which inverts\n * `object` with values transformed by `iteratee` and set by `setter`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform values.\n * @param {Object} accumulator The initial inverted object.\n * @returns {Function} Returns `accumulator`.\n */\nfunction baseInverter(object, setter, iteratee, accumulator) {\n  baseForOwn(object, function(value, key, object) {\n    setter(accumulator, iteratee(value), key, object);\n  });\n  return accumulator;\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\n/**\n * Creates a function like `_.invertBy`.\n *\n * @private\n * @param {Function} setter The function to set accumulator values.\n * @param {Function} toIteratee The function to resolve iteratees.\n * @returns {Function} Returns the new inverter function.\n */\nfunction createInverter(setter, toIteratee) {\n  return function(object, iteratee) {\n    return baseInverter(object, setter, toIteratee(iteratee), {});\n  };\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Creates an object composed of the inverted keys and values of `object`.\n * If `object` contains duplicate values, subsequent values overwrite\n * property assignments of previous values.\n *\n * @static\n * @memberOf _\n * @since 0.7.0\n * @category Object\n * @param {Object} object The object to invert.\n * @returns {Object} Returns the new inverted object.\n * @example\n *\n * var object = { 'a': 1, 'b': 2, 'c': 1 };\n *\n * _.invert(object);\n * // => { '1': 'c', '2': 'b' }\n */\nvar invert = createInverter(function(result, value, key) {\n  result[value] = key;\n}, constant(identity));\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nmodule.exports = invert;\n\n\n/***/ }),\n\n/***/ 142:\n/***/ (function(module, exports) {\n\nmodule.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\n/***/ 143:\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n * Root reference for iframes.\n */\n\nvar root;\nif (typeof window !== 'undefined') { // Browser window\n  root = window;\n} else if (typeof self !== 'undefined') { // Web Worker\n  root = self;\n} else { // Other environments\n  console.warn(\"Using browser-only version of superagent in non-browser environment\");\n  root = this;\n}\n\nvar Emitter = __webpack_require__(241);\nvar RequestBase = __webpack_require__(242);\nvar isObject = __webpack_require__(101);\nvar isFunction = __webpack_require__(243);\nvar ResponseBase = __webpack_require__(244);\nvar shouldRetry = __webpack_require__(246);\n\n/**\n * Noop.\n */\n\nfunction noop(){};\n\n/**\n * Expose `request`.\n */\n\nvar request = exports = module.exports = function(method, url) {\n  // callback\n  if ('function' == typeof url) {\n    return new exports.Request('GET', method).end(url);\n  }\n\n  // url first\n  if (1 == arguments.length) {\n    return new exports.Request('GET', method);\n  }\n\n  return new exports.Request(method, url);\n}\n\nexports.Request = Request;\n\n/**\n * Determine XHR.\n */\n\nrequest.getXHR = function () {\n  if (root.XMLHttpRequest\n      && (!root.location || 'file:' != root.location.protocol\n          || !root.ActiveXObject)) {\n    return new XMLHttpRequest;\n  } else {\n    try { return new ActiveXObject('Microsoft.XMLHTTP'); } catch(e) {}\n    try { return new ActiveXObject('Msxml2.XMLHTTP.6.0'); } catch(e) {}\n    try { return new ActiveXObject('Msxml2.XMLHTTP.3.0'); } catch(e) {}\n    try { return new ActiveXObject('Msxml2.XMLHTTP'); } catch(e) {}\n  }\n  throw Error(\"Browser-only verison of superagent could not find XHR\");\n};\n\n/**\n * Removes leading and trailing whitespace, added to support IE.\n *\n * @param {String} s\n * @return {String}\n * @api private\n */\n\nvar trim = ''.trim\n  ? function(s) { return s.trim(); }\n  : function(s) { return s.replace(/(^\\s*|\\s*$)/g, ''); };\n\n/**\n * Serialize the given `obj`.\n *\n * @param {Object} obj\n * @return {String}\n * @api private\n */\n\nfunction serialize(obj) {\n  if (!isObject(obj)) return obj;\n  var pairs = [];\n  for (var key in obj) {\n    pushEncodedKeyValuePair(pairs, key, obj[key]);\n  }\n  return pairs.join('&');\n}\n\n/**\n * Helps 'serialize' with serializing arrays.\n * Mutates the pairs array.\n *\n * @param {Array} pairs\n * @param {String} key\n * @param {Mixed} val\n */\n\nfunction pushEncodedKeyValuePair(pairs, key, val) {\n  if (val != null) {\n    if (Array.isArray(val)) {\n      val.forEach(function(v) {\n        pushEncodedKeyValuePair(pairs, key, v);\n      });\n    } else if (isObject(val)) {\n      for(var subkey in val) {\n        pushEncodedKeyValuePair(pairs, key + '[' + subkey + ']', val[subkey]);\n      }\n    } else {\n      pairs.push(encodeURIComponent(key)\n        + '=' + encodeURIComponent(val));\n    }\n  } else if (val === null) {\n    pairs.push(encodeURIComponent(key));\n  }\n}\n\n/**\n * Expose serialization method.\n */\n\n request.serializeObject = serialize;\n\n /**\n  * Parse the given x-www-form-urlencoded `str`.\n  *\n  * @param {String} str\n  * @return {Object}\n  * @api private\n  */\n\nfunction parseString(str) {\n  var obj = {};\n  var pairs = str.split('&');\n  var pair;\n  var pos;\n\n  for (var i = 0, len = pairs.length; i < len; ++i) {\n    pair = pairs[i];\n    pos = pair.indexOf('=');\n    if (pos == -1) {\n      obj[decodeURIComponent(pair)] = '';\n    } else {\n      obj[decodeURIComponent(pair.slice(0, pos))] =\n        decodeURIComponent(pair.slice(pos + 1));\n    }\n  }\n\n  return obj;\n}\n\n/**\n * Expose parser.\n */\n\nrequest.parseString = parseString;\n\n/**\n * Default MIME type map.\n *\n *     superagent.types.xml = 'application/xml';\n *\n */\n\nrequest.types = {\n  html: 'text/html',\n  json: 'application/json',\n  xml: 'application/xml',\n  urlencoded: 'application/x-www-form-urlencoded',\n  'form': 'application/x-www-form-urlencoded',\n  'form-data': 'application/x-www-form-urlencoded'\n};\n\n/**\n * Default serialization map.\n *\n *     superagent.serialize['application/xml'] = function(obj){\n *       return 'generated xml here';\n *     };\n *\n */\n\n request.serialize = {\n   'application/x-www-form-urlencoded': serialize,\n   'application/json': JSON.stringify\n };\n\n /**\n  * Default parsers.\n  *\n  *     superagent.parse['application/xml'] = function(str){\n  *       return { object parsed from str };\n  *     };\n  *\n  */\n\nrequest.parse = {\n  'application/x-www-form-urlencoded': parseString,\n  'application/json': JSON.parse\n};\n\n/**\n * Parse the given header `str` into\n * an object containing the mapped fields.\n *\n * @param {String} str\n * @return {Object}\n * @api private\n */\n\nfunction parseHeader(str) {\n  var lines = str.split(/\\r?\\n/);\n  var fields = {};\n  var index;\n  var line;\n  var field;\n  var val;\n\n  lines.pop(); // trailing CRLF\n\n  for (var i = 0, len = lines.length; i < len; ++i) {\n    line = lines[i];\n    index = line.indexOf(':');\n    field = line.slice(0, index).toLowerCase();\n    val = trim(line.slice(index + 1));\n    fields[field] = val;\n  }\n\n  return fields;\n}\n\n/**\n * Check if `mime` is json or has +json structured syntax suffix.\n *\n * @param {String} mime\n * @return {Boolean}\n * @api private\n */\n\nfunction isJSON(mime) {\n  return /[\\/+]json\\b/.test(mime);\n}\n\n/**\n * Initialize a new `Response` with the given `xhr`.\n *\n *  - set flags (.ok, .error, etc)\n *  - parse header\n *\n * Examples:\n *\n *  Aliasing `superagent` as `request` is nice:\n *\n *      request = superagent;\n *\n *  We can use the promise-like API, or pass callbacks:\n *\n *      request.get('/').end(function(res){});\n *      request.get('/', function(res){});\n *\n *  Sending data can be chained:\n *\n *      request\n *        .post('/user')\n *        .send({ name: 'tj' })\n *        .end(function(res){});\n *\n *  Or passed to `.send()`:\n *\n *      request\n *        .post('/user')\n *        .send({ name: 'tj' }, function(res){});\n *\n *  Or passed to `.post()`:\n *\n *      request\n *        .post('/user', { name: 'tj' })\n *        .end(function(res){});\n *\n * Or further reduced to a single call for simple cases:\n *\n *      request\n *        .post('/user', { name: 'tj' }, function(res){});\n *\n * @param {XMLHTTPRequest} xhr\n * @param {Object} options\n * @api private\n */\n\nfunction Response(req) {\n  this.req = req;\n  this.xhr = this.req.xhr;\n  // responseText is accessible only if responseType is '' or 'text' and on older browsers\n  this.text = ((this.req.method !='HEAD' && (this.xhr.responseType === '' || this.xhr.responseType === 'text')) || typeof this.xhr.responseType === 'undefined')\n     ? this.xhr.responseText\n     : null;\n  this.statusText = this.req.xhr.statusText;\n  var status = this.xhr.status;\n  // handle IE9 bug: http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request\n  if (status === 1223) {\n      status = 204;\n  }\n  this._setStatusProperties(status);\n  this.header = this.headers = parseHeader(this.xhr.getAllResponseHeaders());\n  // getAllResponseHeaders sometimes falsely returns \"\" for CORS requests, but\n  // getResponseHeader still works. so we get content-type even if getting\n  // other headers fails.\n  this.header['content-type'] = this.xhr.getResponseHeader('content-type');\n  this._setHeaderProperties(this.header);\n\n  if (null === this.text && req._responseType) {\n    this.body = this.xhr.response;\n  } else {\n    this.body = this.req.method != 'HEAD'\n      ? this._parseBody(this.text ? this.text : this.xhr.response)\n      : null;\n  }\n}\n\nResponseBase(Response.prototype);\n\n/**\n * Parse the given body `str`.\n *\n * Used for auto-parsing of bodies. Parsers\n * are defined on the `superagent.parse` object.\n *\n * @param {String} str\n * @return {Mixed}\n * @api private\n */\n\nResponse.prototype._parseBody = function(str){\n  var parse = request.parse[this.type];\n  if(this.req._parser) {\n    return this.req._parser(this, str);\n  }\n  if (!parse && isJSON(this.type)) {\n    parse = request.parse['application/json'];\n  }\n  return parse && str && (str.length || str instanceof Object)\n    ? parse(str)\n    : null;\n};\n\n/**\n * Return an `Error` representative of this response.\n *\n * @return {Error}\n * @api public\n */\n\nResponse.prototype.toError = function(){\n  var req = this.req;\n  var method = req.method;\n  var url = req.url;\n\n  var msg = 'cannot ' + method + ' ' + url + ' (' + this.status + ')';\n  var err = new Error(msg);\n  err.status = this.status;\n  err.method = method;\n  err.url = url;\n\n  return err;\n};\n\n/**\n * Expose `Response`.\n */\n\nrequest.Response = Response;\n\n/**\n * Initialize a new `Request` with the given `method` and `url`.\n *\n * @param {String} method\n * @param {String} url\n * @api public\n */\n\nfunction Request(method, url) {\n  var self = this;\n  this._query = this._query || [];\n  this.method = method;\n  this.url = url;\n  this.header = {}; // preserves header name case\n  this._header = {}; // coerces header names to lowercase\n  this.on('end', function(){\n    var err = null;\n    var res = null;\n\n    try {\n      res = new Response(self);\n    } catch(e) {\n      err = new Error('Parser is unable to parse the response');\n      err.parse = true;\n      err.original = e;\n      // issue #675: return the raw response if the response parsing fails\n      if (self.xhr) {\n        // ie9 doesn't have 'response' property\n        err.rawResponse = typeof self.xhr.responseType == 'undefined' ? self.xhr.responseText : self.xhr.response;\n        // issue #876: return the http status code if the response parsing fails\n        err.status = self.xhr.status ? self.xhr.status : null;\n        err.statusCode = err.status; // backwards-compat only\n      } else {\n        err.rawResponse = null;\n        err.status = null;\n      }\n\n      return self.callback(err);\n    }\n\n    self.emit('response', res);\n\n    var new_err;\n    try {\n      if (!self._isResponseOK(res)) {\n        new_err = new Error(res.statusText || 'Unsuccessful HTTP response');\n        new_err.original = err;\n        new_err.response = res;\n        new_err.status = res.status;\n      }\n    } catch(e) {\n      new_err = e; // #985 touching res may cause INVALID_STATE_ERR on old Android\n    }\n\n    // #1000 don't catch errors from the callback to avoid double calling it\n    if (new_err) {\n      self.callback(new_err, res);\n    } else {\n      self.callback(null, res);\n    }\n  });\n}\n\n/**\n * Mixin `Emitter` and `RequestBase`.\n */\n\nEmitter(Request.prototype);\nRequestBase(Request.prototype);\n\n/**\n * Set Content-Type to `type`, mapping values from `request.types`.\n *\n * Examples:\n *\n *      superagent.types.xml = 'application/xml';\n *\n *      request.post('/')\n *        .type('xml')\n *        .send(xmlstring)\n *        .end(callback);\n *\n *      request.post('/')\n *        .type('application/xml')\n *        .send(xmlstring)\n *        .end(callback);\n *\n * @param {String} type\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.type = function(type){\n  this.set('Content-Type', request.types[type] || type);\n  return this;\n};\n\n/**\n * Set Accept to `type`, mapping values from `request.types`.\n *\n * Examples:\n *\n *      superagent.types.json = 'application/json';\n *\n *      request.get('/agent')\n *        .accept('json')\n *        .end(callback);\n *\n *      request.get('/agent')\n *        .accept('application/json')\n *        .end(callback);\n *\n * @param {String} accept\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.accept = function(type){\n  this.set('Accept', request.types[type] || type);\n  return this;\n};\n\n/**\n * Set Authorization field value with `user` and `pass`.\n *\n * @param {String} user\n * @param {String} [pass] optional in case of using 'bearer' as type\n * @param {Object} options with 'type' property 'auto', 'basic' or 'bearer' (default 'basic')\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.auth = function(user, pass, options){\n  if (typeof pass === 'object' && pass !== null) { // pass is optional and can substitute for options\n    options = pass;\n  }\n  if (!options) {\n    options = {\n      type: 'function' === typeof btoa ? 'basic' : 'auto',\n    }\n  }\n\n  switch (options.type) {\n    case 'basic':\n      this.set('Authorization', 'Basic ' + btoa(user + ':' + pass));\n    break;\n\n    case 'auto':\n      this.username = user;\n      this.password = pass;\n    break;\n      \n    case 'bearer': // usage would be .auth(accessToken, { type: 'bearer' })\n      this.set('Authorization', 'Bearer ' + user);\n    break;  \n  }\n  return this;\n};\n\n/**\n * Add query-string `val`.\n *\n * Examples:\n *\n *   request.get('/shoes')\n *     .query('size=10')\n *     .query({ color: 'blue' })\n *\n * @param {Object|String} val\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.query = function(val){\n  if ('string' != typeof val) val = serialize(val);\n  if (val) this._query.push(val);\n  return this;\n};\n\n/**\n * Queue the given `file` as an attachment to the specified `field`,\n * with optional `options` (or filename).\n *\n * ``` js\n * request.post('/upload')\n *   .attach('content', new Blob(['<a id=\"a\"><b id=\"b\">hey!</b></a>'], { type: \"text/html\"}))\n *   .end(callback);\n * ```\n *\n * @param {String} field\n * @param {Blob|File} file\n * @param {String|Object} options\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.attach = function(field, file, options){\n  if (file) {\n    if (this._data) {\n      throw Error(\"superagent can't mix .send() and .attach()\");\n    }\n\n    this._getFormData().append(field, file, options || file.name);\n  }\n  return this;\n};\n\nRequest.prototype._getFormData = function(){\n  if (!this._formData) {\n    this._formData = new root.FormData();\n  }\n  return this._formData;\n};\n\n/**\n * Invoke the callback with `err` and `res`\n * and handle arity check.\n *\n * @param {Error} err\n * @param {Response} res\n * @api private\n */\n\nRequest.prototype.callback = function(err, res){\n  // console.log(this._retries, this._maxRetries)\n  if (this._maxRetries && this._retries++ < this._maxRetries && shouldRetry(err, res)) {\n    return this._retry();\n  }\n\n  var fn = this._callback;\n  this.clearTimeout();\n\n  if (err) {\n    if (this._maxRetries) err.retries = this._retries - 1;\n    this.emit('error', err);\n  }\n\n  fn(err, res);\n};\n\n/**\n * Invoke callback with x-domain error.\n *\n * @api private\n */\n\nRequest.prototype.crossDomainError = function(){\n  var err = new Error('Request has been terminated\\nPossible causes: the network is offline, Origin is not allowed by Access-Control-Allow-Origin, the page is being unloaded, etc.');\n  err.crossDomain = true;\n\n  err.status = this.status;\n  err.method = this.method;\n  err.url = this.url;\n\n  this.callback(err);\n};\n\n// This only warns, because the request is still likely to work\nRequest.prototype.buffer = Request.prototype.ca = Request.prototype.agent = function(){\n  console.warn(\"This is not supported in browser version of superagent\");\n  return this;\n};\n\n// This throws, because it can't send/receive data as expected\nRequest.prototype.pipe = Request.prototype.write = function(){\n  throw Error(\"Streaming is not supported in browser version of superagent\");\n};\n\n/**\n * Compose querystring to append to req.url\n *\n * @api private\n */\n\nRequest.prototype._appendQueryString = function(){\n  var query = this._query.join('&');\n  if (query) {\n    this.url += (this.url.indexOf('?') >= 0 ? '&' : '?') + query;\n  }\n\n  if (this._sort) {\n    var index = this.url.indexOf('?');\n    if (index >= 0) {\n      var queryArr = this.url.substring(index + 1).split('&');\n      if (isFunction(this._sort)) {\n        queryArr.sort(this._sort);\n      } else {\n        queryArr.sort();\n      }\n      this.url = this.url.substring(0, index) + '?' + queryArr.join('&');\n    }\n  }\n};\n\n/**\n * Check if `obj` is a host object,\n * we don't want to serialize these :)\n *\n * @param {Object} obj\n * @return {Boolean}\n * @api private\n */\nRequest.prototype._isHost = function _isHost(obj) {\n  // Native objects stringify to [object File], [object Blob], [object FormData], etc.\n  return obj && 'object' === typeof obj && !Array.isArray(obj) && Object.prototype.toString.call(obj) !== '[object Object]';\n}\n\n/**\n * Initiate request, invoking callback `fn(res)`\n * with an instanceof `Response`.\n *\n * @param {Function} fn\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.end = function(fn){\n  if (this._endCalled) {\n    console.warn(\"Warning: .end() was called twice. This is not supported in superagent\");\n  }\n  this._endCalled = true;\n\n  // store callback\n  this._callback = fn || noop;\n\n  // querystring\n  this._appendQueryString();\n\n  return this._end();\n};\n\nRequest.prototype._end = function() {\n  var self = this;\n  var xhr = this.xhr = request.getXHR();\n  var data = this._formData || this._data;\n\n  this._setTimeouts();\n\n  // state change\n  xhr.onreadystatechange = function(){\n    var readyState = xhr.readyState;\n    if (readyState >= 2 && self._responseTimeoutTimer) {\n      clearTimeout(self._responseTimeoutTimer);\n    }\n    if (4 != readyState) {\n      return;\n    }\n\n    // In IE9, reads to any property (e.g. status) off of an aborted XHR will\n    // result in the error \"Could not complete the operation due to error c00c023f\"\n    var status;\n    try { status = xhr.status } catch(e) { status = 0; }\n\n    if (!status) {\n      if (self.timedout || self._aborted) return;\n      return self.crossDomainError();\n    }\n    self.emit('end');\n  };\n\n  // progress\n  var handleProgress = function(direction, e) {\n    if (e.total > 0) {\n      e.percent = e.loaded / e.total * 100;\n    }\n    e.direction = direction;\n    self.emit('progress', e);\n  }\n  if (this.hasListeners('progress')) {\n    try {\n      xhr.onprogress = handleProgress.bind(null, 'download');\n      if (xhr.upload) {\n        xhr.upload.onprogress = handleProgress.bind(null, 'upload');\n      }\n    } catch(e) {\n      // Accessing xhr.upload fails in IE from a web worker, so just pretend it doesn't exist.\n      // Reported here:\n      // https://connect.microsoft.com/IE/feedback/details/837245/xmlhttprequest-upload-throws-invalid-argument-when-used-from-web-worker-context\n    }\n  }\n\n  // initiate request\n  try {\n    if (this.username && this.password) {\n      xhr.open(this.method, this.url, true, this.username, this.password);\n    } else {\n      xhr.open(this.method, this.url, true);\n    }\n  } catch (err) {\n    // see #1149\n    return this.callback(err);\n  }\n\n  // CORS\n  if (this._withCredentials) xhr.withCredentials = true;\n\n  // body\n  if (!this._formData && 'GET' != this.method && 'HEAD' != this.method && 'string' != typeof data && !this._isHost(data)) {\n    // serialize stuff\n    var contentType = this._header['content-type'];\n    var serialize = this._serializer || request.serialize[contentType ? contentType.split(';')[0] : ''];\n    if (!serialize && isJSON(contentType)) {\n      serialize = request.serialize['application/json'];\n    }\n    if (serialize) data = serialize(data);\n  }\n\n  // set header fields\n  for (var field in this.header) {\n    if (null == this.header[field]) continue;\n\n    if (this.header.hasOwnProperty(field))\n      xhr.setRequestHeader(field, this.header[field]);\n  }\n\n  if (this._responseType) {\n    xhr.responseType = this._responseType;\n  }\n\n  // send stuff\n  this.emit('request', this);\n\n  // IE11 xhr.send(undefined) sends 'undefined' string as POST payload (instead of nothing)\n  // We need null here if data is undefined\n  xhr.send(typeof data !== 'undefined' ? data : null);\n  return this;\n};\n\n/**\n * GET `url` with optional callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.get = function(url, data, fn){\n  var req = request('GET', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.query(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n/**\n * HEAD `url` with optional callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.head = function(url, data, fn){\n  var req = request('HEAD', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n/**\n * OPTIONS query to `url` with optional callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.options = function(url, data, fn){\n  var req = request('OPTIONS', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n/**\n * DELETE `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed} [data]\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nfunction del(url, data, fn){\n  var req = request('DELETE', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\nrequest['del'] = del;\nrequest['delete'] = del;\n\n/**\n * PATCH `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed} [data]\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.patch = function(url, data, fn){\n  var req = request('PATCH', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n/**\n * POST `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed} [data]\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.post = function(url, data, fn){\n  var req = request('POST', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n/**\n * PUT `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.put = function(url, data, fn){\n  var req = request('PUT', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n\n/***/ }),\n\n/***/ 144:\n/***/ (function(module, exports) {\n\nmodule.exports = function (prefix) {\n    return function (request) {\n        if (request.url[0] === '/') {\n            request.url = prefix + request.url;\n        }\n\n        return request;\n    };\n}\n\n/***/ }),\n\n/***/ 145:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar methods = __webpack_require__(247);\nvar extend = __webpack_require__(249);\n\nmodule.exports = function(_superagent) {\n  var superagent = extend({}, _superagent);\n\n  var uses = [];\n\n  superagent.use = function(fn) {\n    uses.push(fn);\n    return this;\n  };\n\n  if(methods.indexOf('del') === -1) {\n    methods = methods.slice(0);\n    methods.push('del');\n  }\n  methods.forEach(function(method) {\n    superagent[method] = function() {\n      var request = _superagent[method].apply(superagent, arguments);\n      uses.forEach(function(use) {\n        request = request.use(use);\n      })\n      return request;\n    };\n  });\n\n  return superagent;\n};\n\n\n/***/ }),\n\n/***/ 146:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* WEBPACK VAR INJECTION */(function(global) {/*!\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: \"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) { 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 (false) {\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 (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 () {\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 (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(\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    \"production\" !== '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 (false) {\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      \"production\" !== '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 (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)\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 (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 (\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 (false) {\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 (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(\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 (false) {\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 (false) {\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      \"production\" !== '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 (false) {\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      \"production\" !== '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                 false\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 (false) {\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 (false) {\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 (false) {\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 (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 = !!(\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 (false) {\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 (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) { 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 (false) {\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 =  false\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      \"production\" !== '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 (false) {\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    \"production\" !== '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 (false) {\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      \"production\" !== '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  \"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(\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 (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\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 (false) {\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  \"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(\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  \"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 (\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 (false) {\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 (false) {\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 (false) {\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 (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(\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    \"production\" !== '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 (false\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 && \"production\" !== '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      \"production\" !== '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      \"production\" !== '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 (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\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 (false) {\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 (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(\n        resolveConstructorOptions(vm.constructor),\n        options || {},\n        vm\n      );\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) { 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 (false\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 (false) {\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 (false) {\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 (false) {\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      \"production\" !== '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 (false) {\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 (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)) { 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 (false) {\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 (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)) { 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 (false\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 (false) {\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    false\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 (false) {\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 (false) {\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 (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 &&\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 (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(\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    \"production\" !== '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 (false) {\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 (false\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 (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__(\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 (false) {\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 (false\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 (false) {\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 (false) {\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 (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] === '') { 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 (false\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        \"production\" !== '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 (false) {\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 (false) {\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 (false) {\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 (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(\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 (false) {\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 (false) {\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 (false) {\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 (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(\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      false\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 (false\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 (false) {\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      \"production\" !== '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 (false\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 (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) { 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 (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(\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 (false) {\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 (false) {\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 (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 (\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    \"production\" !== '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 (false) {\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 (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__[\"default\"] = (Vue$3);\n\n/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(11)))\n\n/***/ }),\n\n/***/ 147:\n/***/ (function(module, exports, __webpack_require__) {\n\n(function(e,t){ true?module.exports=t():\"function\"==typeof define&&define.amd?define([],t):\"object\"==typeof exports?exports.VueTheMask=t():e.VueTheMask=t()})(this,function(){return function(e){function t(r){if(n[r])return n[r].exports;var a=n[r]={i:r,l:!1,exports:{}};return e[r].call(a.exports,a,a.exports,t),a.l=!0,a.exports}var n={};return t.m=e,t.c=n,t.i=function(e){return e},t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,\"a\",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p=\".\",t(t.s=10)}([function(e,t){e.exports={\"#\":{pattern:/\\d/},X:{pattern:/[0-9a-zA-Z]/},S:{pattern:/[a-zA-Z]/},A:{pattern:/[a-zA-Z]/,transform:function(e){return e.toLocaleUpperCase()}},a:{pattern:/[a-zA-Z]/,transform:function(e){return e.toLocaleLowerCase()}},\"!\":{escape:!0}}},function(e,t,n){\"use strict\";function r(e){var t=document.createEvent(\"Event\");return t.initEvent(e,!0,!0),t}var a=n(2),o=n(0),i=n.n(o);t.a=function(e,t){var o=t.value;if((Array.isArray(o)||\"string\"==typeof o)&&(o={mask:o,tokens:i.a}),\"INPUT\"!==e.tagName.toLocaleUpperCase()){var u=e.getElementsByTagName(\"input\");if(1!==u.length)throw new Error(\"v-mask directive requires 1 input, found \"+u.length);e=u[0]}e.oninput=function(t){if(t.isTrusted){var i=e.selectionEnd,u=e.value[i-1];for(e.value=n.i(a.a)(e.value,o.mask,!0,o.tokens);i<e.value.length&&e.value.charAt(i-1)!==u;)i++;e===document.activeElement&&e.setSelectionRange(i,i),e.dispatchEvent(r(\"input\"))}};var s=n.i(a.a)(e.value,o.mask,!0,o.tokens);s!==e.value&&(e.value=s,e.dispatchEvent(r(\"input\")))}},function(e,t,n){\"use strict\";var r=n(6),a=n(5);t.a=function(e,t){var o=!(arguments.length>2&&void 0!==arguments[2])||arguments[2],i=arguments[3];return Array.isArray(t)?n.i(a.a)(r.a,t,i)(e,t,o,i):n.i(r.a)(e,t,o,i)}},function(e,t,n){\"use strict\";function r(e){e.component(s.a.name,s.a),e.directive(\"mask\",i.a)}Object.defineProperty(t,\"__esModule\",{value:!0});var a=n(0),o=n.n(a),i=n(1),u=n(7),s=n.n(u);n.d(t,\"TheMask\",function(){return s.a}),n.d(t,\"mask\",function(){return i.a}),n.d(t,\"tokens\",function(){return o.a}),n.d(t,\"version\",function(){return c});var c=\"0.11.0-alpha.2\";t.default=r,\"undefined\"!=typeof window&&window.Vue&&window.Vue.use(r)},function(e,t,n){\"use strict\";Object.defineProperty(t,\"__esModule\",{value:!0});var r=n(1),a=n(0),o=n.n(a),i=n(2);t.default={name:\"TheMask\",props:{value:[String,Number],mask:{type:[String,Function,Array],required:!0},masked:{type:Boolean,default:!1},tokens:{type:Object,default:function(){return o.a}}},directives:{mask:r.a},data:function(){return{lastValue:null,display:this.value}},watch:{value:function(e){e!==this.lastValue&&(this.display=e)},masked:function(){this.refresh(this.display)}},computed:{config:function(){return{mask:this.mask,tokens:this.tokens,masked:this.masked}}},methods:{onInput:function(e){e.isTrusted||this.refresh(e.target.value)},refresh:function(e){this.display=e;var e=n.i(i.a)(e,this.mask,this.masked,this.tokens);e!==this.lastValue&&(this.lastValue=e,this.$emit(\"input\",e))}}}},function(e,t,n){\"use strict\";function r(e,t,n){return t=t.sort(function(e,t){return e.length-t.length}),function(r,a){for(var o=!(arguments.length>2&&void 0!==arguments[2])||arguments[2],i=0;i<t.length;){var u=t[i];i++;var s=t[i];if(!(s&&e(r,s,!0,n).length>u.length))return e(r,u,o,n)}return\"\"}}t.a=r},function(e,t,n){\"use strict\";function r(e,t){var n=!(arguments.length>2&&void 0!==arguments[2])||arguments[2],r=arguments[3];e=e||\"\",t=t||\"\";for(var a=0,o=0,i=\"\";a<t.length&&o<e.length;){var u=t[a],s=r[u],c=e[o];s&&!s.escape?(s.pattern.test(c)&&(i+=s.transform?s.transform(c):c,a++),o++):(s&&s.escape&&(a++,u=t[a]),n&&(i+=u),c===u&&o++,a++)}for(var f=\"\";a<t.length&&n;){var u=t[a];if(r[u]){f=\"\";break}f+=u,a++}return i+f}t.a=r},function(e,t,n){var r=n(8)(n(4),n(9),null,null);e.exports=r.exports},function(e,t){e.exports=function(e,t,n,r){var a,o=e=e||{},i=typeof e.default;\"object\"!==i&&\"function\"!==i||(a=e,o=e.default);var u=\"function\"==typeof o?o.options:o;if(t&&(u.render=t.render,u.staticRenderFns=t.staticRenderFns),n&&(u._scopeId=n),r){var s=u.computed||(u.computed={});Object.keys(r).forEach(function(e){var t=r[e];s[e]=function(){return t}})}return{esModule:a,exports:o,options:u}}},function(e,t){e.exports={render:function(){var e=this,t=e.$createElement;return(e._self._c||t)(\"input\",{directives:[{name:\"mask\",rawName:\"v-mask\",value:e.config,expression:\"config\"}],attrs:{type:\"text\"},domProps:{value:e.display},on:{input:e.onInput}})},staticRenderFns:[]}},function(e,t,n){e.exports=n(3)}])});\n\n/***/ }),\n\n/***/ 2:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"Store\", function() { return Store; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"mapState\", function() { return mapState; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"mapMutations\", function() { return mapMutations; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"mapGetters\", function() { return mapGetters; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"mapActions\", function() { return mapActions; });\n/**\n * vuex v2.3.0\n * (c) 2017 Evan You\n * @license MIT\n */\nvar applyMixin = function (Vue) {\n  var version = Number(Vue.version.split('.')[0]);\n\n  if (version >= 2) {\n    var usesInit = Vue.config._lifecycleHooks.indexOf('init') > -1;\n    Vue.mixin(usesInit ? { init: vuexInit } : { beforeCreate: vuexInit });\n  } else {\n    // override init and inject vuex init procedure\n    // for 1.x backwards compatibility.\n    var _init = Vue.prototype._init;\n    Vue.prototype._init = function (options) {\n      if ( options === void 0 ) options = {};\n\n      options.init = options.init\n        ? [vuexInit].concat(options.init)\n        : vuexInit;\n      _init.call(this, options);\n    };\n  }\n\n  /**\n   * Vuex init hook, injected into each instances init hooks list.\n   */\n\n  function vuexInit () {\n    var options = this.$options;\n    // store injection\n    if (options.store) {\n      this.$store = options.store;\n    } else if (options.parent && options.parent.$store) {\n      this.$store = options.parent.$store;\n    }\n  }\n};\n\nvar devtoolHook =\n  typeof window !== 'undefined' &&\n  window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\nfunction devtoolPlugin (store) {\n  if (!devtoolHook) { return }\n\n  store._devtoolHook = devtoolHook;\n\n  devtoolHook.emit('vuex:init', store);\n\n  devtoolHook.on('vuex:travel-to-state', function (targetState) {\n    store.replaceState(targetState);\n  });\n\n  store.subscribe(function (mutation, state) {\n    devtoolHook.emit('vuex:mutation', mutation, state);\n  });\n}\n\n/**\n * Get the first item that pass the test\n * by second argument function\n *\n * @param {Array} list\n * @param {Function} f\n * @return {*}\n */\n/**\n * Deep copy the given object considering circular structure.\n * This function caches all nested objects and its copies.\n * If it detects circular structure, use cached copy to avoid infinite loop.\n *\n * @param {*} obj\n * @param {Array<Object>} cache\n * @return {*}\n */\n\n\n/**\n * forEach for object\n */\nfunction forEachValue (obj, fn) {\n  Object.keys(obj).forEach(function (key) { return fn(obj[key], key); });\n}\n\nfunction isObject (obj) {\n  return obj !== null && typeof obj === 'object'\n}\n\nfunction isPromise (val) {\n  return val && typeof val.then === 'function'\n}\n\nfunction assert (condition, msg) {\n  if (!condition) { throw new Error((\"[vuex] \" + msg)) }\n}\n\nvar Module = function Module (rawModule, runtime) {\n  this.runtime = runtime;\n  this._children = Object.create(null);\n  this._rawModule = rawModule;\n  var rawState = rawModule.state;\n  this.state = (typeof rawState === 'function' ? rawState() : rawState) || {};\n};\n\nvar prototypeAccessors$1 = { namespaced: {} };\n\nprototypeAccessors$1.namespaced.get = function () {\n  return !!this._rawModule.namespaced\n};\n\nModule.prototype.addChild = function addChild (key, module) {\n  this._children[key] = module;\n};\n\nModule.prototype.removeChild = function removeChild (key) {\n  delete this._children[key];\n};\n\nModule.prototype.getChild = function getChild (key) {\n  return this._children[key]\n};\n\nModule.prototype.update = function update (rawModule) {\n  this._rawModule.namespaced = rawModule.namespaced;\n  if (rawModule.actions) {\n    this._rawModule.actions = rawModule.actions;\n  }\n  if (rawModule.mutations) {\n    this._rawModule.mutations = rawModule.mutations;\n  }\n  if (rawModule.getters) {\n    this._rawModule.getters = rawModule.getters;\n  }\n};\n\nModule.prototype.forEachChild = function forEachChild (fn) {\n  forEachValue(this._children, fn);\n};\n\nModule.prototype.forEachGetter = function forEachGetter (fn) {\n  if (this._rawModule.getters) {\n    forEachValue(this._rawModule.getters, fn);\n  }\n};\n\nModule.prototype.forEachAction = function forEachAction (fn) {\n  if (this._rawModule.actions) {\n    forEachValue(this._rawModule.actions, fn);\n  }\n};\n\nModule.prototype.forEachMutation = function forEachMutation (fn) {\n  if (this._rawModule.mutations) {\n    forEachValue(this._rawModule.mutations, fn);\n  }\n};\n\nObject.defineProperties( Module.prototype, prototypeAccessors$1 );\n\nvar ModuleCollection = function ModuleCollection (rawRootModule) {\n  var this$1 = this;\n\n  // register root module (Vuex.Store options)\n  this.root = new Module(rawRootModule, false);\n\n  // register all nested modules\n  if (rawRootModule.modules) {\n    forEachValue(rawRootModule.modules, function (rawModule, key) {\n      this$1.register([key], rawModule, false);\n    });\n  }\n};\n\nModuleCollection.prototype.get = function get (path) {\n  return path.reduce(function (module, key) {\n    return module.getChild(key)\n  }, this.root)\n};\n\nModuleCollection.prototype.getNamespace = function getNamespace (path) {\n  var module = this.root;\n  return path.reduce(function (namespace, key) {\n    module = module.getChild(key);\n    return namespace + (module.namespaced ? key + '/' : '')\n  }, '')\n};\n\nModuleCollection.prototype.update = function update$1 (rawRootModule) {\n  update(this.root, rawRootModule);\n};\n\nModuleCollection.prototype.register = function register (path, rawModule, runtime) {\n    var this$1 = this;\n    if ( runtime === void 0 ) runtime = true;\n\n  var parent = this.get(path.slice(0, -1));\n  var newModule = new Module(rawModule, runtime);\n  parent.addChild(path[path.length - 1], newModule);\n\n  // register nested modules\n  if (rawModule.modules) {\n    forEachValue(rawModule.modules, function (rawChildModule, key) {\n      this$1.register(path.concat(key), rawChildModule, runtime);\n    });\n  }\n};\n\nModuleCollection.prototype.unregister = function unregister (path) {\n  var parent = this.get(path.slice(0, -1));\n  var key = path[path.length - 1];\n  if (!parent.getChild(key).runtime) { return }\n\n  parent.removeChild(key);\n};\n\nfunction update (targetModule, newModule) {\n  // update target module\n  targetModule.update(newModule);\n\n  // update nested modules\n  if (newModule.modules) {\n    for (var key in newModule.modules) {\n      if (!targetModule.getChild(key)) {\n        console.warn(\n          \"[vuex] trying to add a new module '\" + key + \"' on hot reloading, \" +\n          'manual reload is needed'\n        );\n        return\n      }\n      update(targetModule.getChild(key), newModule.modules[key]);\n    }\n  }\n}\n\nvar Vue; // bind on install\n\nvar Store = function Store (options) {\n  var this$1 = this;\n  if ( options === void 0 ) options = {};\n\n  assert(Vue, \"must call Vue.use(Vuex) before creating a store instance.\");\n  assert(typeof Promise !== 'undefined', \"vuex requires a Promise polyfill in this browser.\");\n\n  var state = options.state; if ( state === void 0 ) state = {};\n  var plugins = options.plugins; if ( plugins === void 0 ) plugins = [];\n  var strict = options.strict; if ( strict === void 0 ) strict = false;\n\n  // store internal state\n  this._committing = false;\n  this._actions = Object.create(null);\n  this._mutations = Object.create(null);\n  this._wrappedGetters = Object.create(null);\n  this._modules = new ModuleCollection(options);\n  this._modulesNamespaceMap = Object.create(null);\n  this._subscribers = [];\n  this._watcherVM = new Vue();\n\n  // bind commit and dispatch to self\n  var store = this;\n  var ref = this;\n  var dispatch = ref.dispatch;\n  var commit = ref.commit;\n  this.dispatch = function boundDispatch (type, payload) {\n    return dispatch.call(store, type, payload)\n  };\n  this.commit = function boundCommit (type, payload, options) {\n    return commit.call(store, type, payload, options)\n  };\n\n  // strict mode\n  this.strict = strict;\n\n  // init root module.\n  // this also recursively registers all sub-modules\n  // and collects all module getters inside this._wrappedGetters\n  installModule(this, state, [], this._modules.root);\n\n  // initialize the store vm, which is responsible for the reactivity\n  // (also registers _wrappedGetters as computed properties)\n  resetStoreVM(this, state);\n\n  // apply plugins\n  plugins.concat(devtoolPlugin).forEach(function (plugin) { return plugin(this$1); });\n};\n\nvar prototypeAccessors = { state: {} };\n\nprototypeAccessors.state.get = function () {\n  return this._vm._data.$$state\n};\n\nprototypeAccessors.state.set = function (v) {\n  assert(false, \"Use store.replaceState() to explicit replace store state.\");\n};\n\nStore.prototype.commit = function commit (_type, _payload, _options) {\n    var this$1 = this;\n\n  // check object-style commit\n  var ref = unifyObjectStyle(_type, _payload, _options);\n    var type = ref.type;\n    var payload = ref.payload;\n    var options = ref.options;\n\n  var mutation = { type: type, payload: payload };\n  var entry = this._mutations[type];\n  if (!entry) {\n    console.error((\"[vuex] unknown mutation type: \" + type));\n    return\n  }\n  this._withCommit(function () {\n    entry.forEach(function commitIterator (handler) {\n      handler(payload);\n    });\n  });\n  this._subscribers.forEach(function (sub) { return sub(mutation, this$1.state); });\n\n  if (options && options.silent) {\n    console.warn(\n      \"[vuex] mutation type: \" + type + \". Silent option has been removed. \" +\n      'Use the filter functionality in the vue-devtools'\n    );\n  }\n};\n\nStore.prototype.dispatch = function dispatch (_type, _payload) {\n  // check object-style dispatch\n  var ref = unifyObjectStyle(_type, _payload);\n    var type = ref.type;\n    var payload = ref.payload;\n\n  var entry = this._actions[type];\n  if (!entry) {\n    console.error((\"[vuex] unknown action type: \" + type));\n    return\n  }\n  return entry.length > 1\n    ? Promise.all(entry.map(function (handler) { return handler(payload); }))\n    : entry[0](payload)\n};\n\nStore.prototype.subscribe = function subscribe (fn) {\n  var subs = this._subscribers;\n  if (subs.indexOf(fn) < 0) {\n    subs.push(fn);\n  }\n  return function () {\n    var i = subs.indexOf(fn);\n    if (i > -1) {\n      subs.splice(i, 1);\n    }\n  }\n};\n\nStore.prototype.watch = function watch (getter, cb, options) {\n    var this$1 = this;\n\n  assert(typeof getter === 'function', \"store.watch only accepts a function.\");\n  return this._watcherVM.$watch(function () { return getter(this$1.state, this$1.getters); }, cb, options)\n};\n\nStore.prototype.replaceState = function replaceState (state) {\n    var this$1 = this;\n\n  this._withCommit(function () {\n    this$1._vm._data.$$state = state;\n  });\n};\n\nStore.prototype.registerModule = function registerModule (path, rawModule) {\n  if (typeof path === 'string') { path = [path]; }\n  assert(Array.isArray(path), \"module path must be a string or an Array.\");\n  this._modules.register(path, rawModule);\n  installModule(this, this.state, path, this._modules.get(path));\n  // reset store to update getters...\n  resetStoreVM(this, this.state);\n};\n\nStore.prototype.unregisterModule = function unregisterModule (path) {\n    var this$1 = this;\n\n  if (typeof path === 'string') { path = [path]; }\n  assert(Array.isArray(path), \"module path must be a string or an Array.\");\n  this._modules.unregister(path);\n  this._withCommit(function () {\n    var parentState = getNestedState(this$1.state, path.slice(0, -1));\n    Vue.delete(parentState, path[path.length - 1]);\n  });\n  resetStore(this);\n};\n\nStore.prototype.hotUpdate = function hotUpdate (newOptions) {\n  this._modules.update(newOptions);\n  resetStore(this, true);\n};\n\nStore.prototype._withCommit = function _withCommit (fn) {\n  var committing = this._committing;\n  this._committing = true;\n  fn();\n  this._committing = committing;\n};\n\nObject.defineProperties( Store.prototype, prototypeAccessors );\n\nfunction resetStore (store, hot) {\n  store._actions = Object.create(null);\n  store._mutations = Object.create(null);\n  store._wrappedGetters = Object.create(null);\n  store._modulesNamespaceMap = Object.create(null);\n  var state = store.state;\n  // init all modules\n  installModule(store, state, [], store._modules.root, true);\n  // reset vm\n  resetStoreVM(store, state, hot);\n}\n\nfunction resetStoreVM (store, state, hot) {\n  var oldVm = store._vm;\n\n  // bind store public getters\n  store.getters = {};\n  var wrappedGetters = store._wrappedGetters;\n  var computed = {};\n  forEachValue(wrappedGetters, function (fn, key) {\n    // use computed to leverage its lazy-caching mechanism\n    computed[key] = function () { return fn(store); };\n    Object.defineProperty(store.getters, key, {\n      get: function () { return store._vm[key]; },\n      enumerable: true // for local getters\n    });\n  });\n\n  // use a Vue instance to store the state tree\n  // suppress warnings just in case the user has added\n  // some funky global mixins\n  var silent = Vue.config.silent;\n  Vue.config.silent = true;\n  store._vm = new Vue({\n    data: {\n      $$state: state\n    },\n    computed: computed\n  });\n  Vue.config.silent = silent;\n\n  // enable strict mode for new vm\n  if (store.strict) {\n    enableStrictMode(store);\n  }\n\n  if (oldVm) {\n    if (hot) {\n      // dispatch changes in all subscribed watchers\n      // to force getter re-evaluation for hot reloading.\n      store._withCommit(function () {\n        oldVm._data.$$state = null;\n      });\n    }\n    Vue.nextTick(function () { return oldVm.$destroy(); });\n  }\n}\n\nfunction installModule (store, rootState, path, module, hot) {\n  var isRoot = !path.length;\n  var namespace = store._modules.getNamespace(path);\n\n  // register in namespace map\n  if (module.namespaced) {\n    store._modulesNamespaceMap[namespace] = module;\n  }\n\n  // set state\n  if (!isRoot && !hot) {\n    var parentState = getNestedState(rootState, path.slice(0, -1));\n    var moduleName = path[path.length - 1];\n    store._withCommit(function () {\n      Vue.set(parentState, moduleName, module.state);\n    });\n  }\n\n  var local = module.context = makeLocalContext(store, namespace, path);\n\n  module.forEachMutation(function (mutation, key) {\n    var namespacedType = namespace + key;\n    registerMutation(store, namespacedType, mutation, local);\n  });\n\n  module.forEachAction(function (action, key) {\n    var namespacedType = namespace + key;\n    registerAction(store, namespacedType, action, local);\n  });\n\n  module.forEachGetter(function (getter, key) {\n    var namespacedType = namespace + key;\n    registerGetter(store, namespacedType, getter, local);\n  });\n\n  module.forEachChild(function (child, key) {\n    installModule(store, rootState, path.concat(key), child, hot);\n  });\n}\n\n/**\n * make localized dispatch, commit, getters and state\n * if there is no namespace, just use root ones\n */\nfunction makeLocalContext (store, namespace, path) {\n  var noNamespace = namespace === '';\n\n  var local = {\n    dispatch: noNamespace ? store.dispatch : function (_type, _payload, _options) {\n      var args = unifyObjectStyle(_type, _payload, _options);\n      var payload = args.payload;\n      var options = args.options;\n      var type = args.type;\n\n      if (!options || !options.root) {\n        type = namespace + type;\n        if (!store._actions[type]) {\n          console.error((\"[vuex] unknown local action type: \" + (args.type) + \", global type: \" + type));\n          return\n        }\n      }\n\n      return store.dispatch(type, payload)\n    },\n\n    commit: noNamespace ? store.commit : function (_type, _payload, _options) {\n      var args = unifyObjectStyle(_type, _payload, _options);\n      var payload = args.payload;\n      var options = args.options;\n      var type = args.type;\n\n      if (!options || !options.root) {\n        type = namespace + type;\n        if (!store._mutations[type]) {\n          console.error((\"[vuex] unknown local mutation type: \" + (args.type) + \", global type: \" + type));\n          return\n        }\n      }\n\n      store.commit(type, payload, options);\n    }\n  };\n\n  // getters and state object must be gotten lazily\n  // because they will be changed by vm update\n  Object.defineProperties(local, {\n    getters: {\n      get: noNamespace\n        ? function () { return store.getters; }\n        : function () { return makeLocalGetters(store, namespace); }\n    },\n    state: {\n      get: function () { return getNestedState(store.state, path); }\n    }\n  });\n\n  return local\n}\n\nfunction makeLocalGetters (store, namespace) {\n  var gettersProxy = {};\n\n  var splitPos = namespace.length;\n  Object.keys(store.getters).forEach(function (type) {\n    // skip if the target getter is not match this namespace\n    if (type.slice(0, splitPos) !== namespace) { return }\n\n    // extract local getter type\n    var localType = type.slice(splitPos);\n\n    // Add a port to the getters proxy.\n    // Define as getter property because\n    // we do not want to evaluate the getters in this time.\n    Object.defineProperty(gettersProxy, localType, {\n      get: function () { return store.getters[type]; },\n      enumerable: true\n    });\n  });\n\n  return gettersProxy\n}\n\nfunction registerMutation (store, type, handler, local) {\n  var entry = store._mutations[type] || (store._mutations[type] = []);\n  entry.push(function wrappedMutationHandler (payload) {\n    handler(local.state, payload);\n  });\n}\n\nfunction registerAction (store, type, handler, local) {\n  var entry = store._actions[type] || (store._actions[type] = []);\n  entry.push(function wrappedActionHandler (payload, cb) {\n    var res = handler({\n      dispatch: local.dispatch,\n      commit: local.commit,\n      getters: local.getters,\n      state: local.state,\n      rootGetters: store.getters,\n      rootState: store.state\n    }, payload, cb);\n    if (!isPromise(res)) {\n      res = Promise.resolve(res);\n    }\n    if (store._devtoolHook) {\n      return res.catch(function (err) {\n        store._devtoolHook.emit('vuex:error', err);\n        throw err\n      })\n    } else {\n      return res\n    }\n  });\n}\n\nfunction registerGetter (store, type, rawGetter, local) {\n  if (store._wrappedGetters[type]) {\n    console.error((\"[vuex] duplicate getter key: \" + type));\n    return\n  }\n  store._wrappedGetters[type] = function wrappedGetter (store) {\n    return rawGetter(\n      local.state, // local state\n      local.getters, // local getters\n      store.state, // root state\n      store.getters // root getters\n    )\n  };\n}\n\nfunction enableStrictMode (store) {\n  store._vm.$watch(function () { return this._data.$$state }, function () {\n    assert(store._committing, \"Do not mutate vuex store state outside mutation handlers.\");\n  }, { deep: true, sync: true });\n}\n\nfunction getNestedState (state, path) {\n  return path.length\n    ? path.reduce(function (state, key) { return state[key]; }, state)\n    : state\n}\n\nfunction unifyObjectStyle (type, payload, options) {\n  if (isObject(type) && type.type) {\n    options = payload;\n    payload = type;\n    type = type.type;\n  }\n\n  assert(typeof type === 'string', (\"Expects string as the type, but found \" + (typeof type) + \".\"));\n\n  return { type: type, payload: payload, options: options }\n}\n\nfunction install (_Vue) {\n  if (Vue) {\n    console.error(\n      '[vuex] already installed. Vue.use(Vuex) should be called only once.'\n    );\n    return\n  }\n  Vue = _Vue;\n  applyMixin(Vue);\n}\n\n// auto install in dist mode\nif (typeof window !== 'undefined' && window.Vue) {\n  install(window.Vue);\n}\n\nvar mapState = normalizeNamespace(function (namespace, states) {\n  var res = {};\n  normalizeMap(states).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    res[key] = function mappedState () {\n      var state = this.$store.state;\n      var getters = this.$store.getters;\n      if (namespace) {\n        var module = getModuleByNamespace(this.$store, 'mapState', namespace);\n        if (!module) {\n          return\n        }\n        state = module.context.state;\n        getters = module.context.getters;\n      }\n      return typeof val === 'function'\n        ? val.call(this, state, getters)\n        : state[val]\n    };\n    // mark vuex getter for devtools\n    res[key].vuex = true;\n  });\n  return res\n});\n\nvar mapMutations = normalizeNamespace(function (namespace, mutations) {\n  var res = {};\n  normalizeMap(mutations).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    val = namespace + val;\n    res[key] = function mappedMutation () {\n      var args = [], len = arguments.length;\n      while ( len-- ) args[ len ] = arguments[ len ];\n\n      if (namespace && !getModuleByNamespace(this.$store, 'mapMutations', namespace)) {\n        return\n      }\n      return this.$store.commit.apply(this.$store, [val].concat(args))\n    };\n  });\n  return res\n});\n\nvar mapGetters = normalizeNamespace(function (namespace, getters) {\n  var res = {};\n  normalizeMap(getters).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    val = namespace + val;\n    res[key] = function mappedGetter () {\n      if (namespace && !getModuleByNamespace(this.$store, 'mapGetters', namespace)) {\n        return\n      }\n      if (!(val in this.$store.getters)) {\n        console.error((\"[vuex] unknown getter: \" + val));\n        return\n      }\n      return this.$store.getters[val]\n    };\n    // mark vuex getter for devtools\n    res[key].vuex = true;\n  });\n  return res\n});\n\nvar mapActions = normalizeNamespace(function (namespace, actions) {\n  var res = {};\n  normalizeMap(actions).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    val = namespace + val;\n    res[key] = function mappedAction () {\n      var args = [], len = arguments.length;\n      while ( len-- ) args[ len ] = arguments[ len ];\n\n      if (namespace && !getModuleByNamespace(this.$store, 'mapActions', namespace)) {\n        return\n      }\n      return this.$store.dispatch.apply(this.$store, [val].concat(args))\n    };\n  });\n  return res\n});\n\nfunction normalizeMap (map) {\n  return Array.isArray(map)\n    ? map.map(function (key) { return ({ key: key, val: key }); })\n    : Object.keys(map).map(function (key) { return ({ key: key, val: map[key] }); })\n}\n\nfunction normalizeNamespace (fn) {\n  return function (namespace, map) {\n    if (typeof namespace !== 'string') {\n      map = namespace;\n      namespace = '';\n    } else if (namespace.charAt(namespace.length - 1) !== '/') {\n      namespace += '/';\n    }\n    return fn(namespace, map)\n  }\n}\n\nfunction getModuleByNamespace (store, helper, namespace) {\n  var module = store._modulesNamespaceMap[namespace];\n  if (!module) {\n    console.error((\"[vuex] module namespace not found in \" + helper + \"(): \" + namespace));\n  }\n  return module\n}\n\nvar index_esm = {\n  Store: Store,\n  install: install,\n  version: '2.3.0',\n  mapState: mapState,\n  mapMutations: mapMutations,\n  mapGetters: mapGetters,\n  mapActions: mapActions\n};\n\n/* harmony default export */ __webpack_exports__[\"default\"] = (index_esm);\n\n\n/***/ }),\n\n/***/ 229:\n/***/ (function(module, exports, __webpack_require__) {\n\n__webpack_require__(230);\n__webpack_require__(139);\n__webpack_require__(67);\n__webpack_require__(99);\n__webpack_require__(141);\n__webpack_require__(14);\n__webpack_require__(100);\n__webpack_require__(143);\n__webpack_require__(144);\n__webpack_require__(145);\n__webpack_require__(146);\n__webpack_require__(102);\n__webpack_require__(2);\nmodule.exports = __webpack_require__(147);\n\n\n/***/ }),\n\n/***/ 230:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n__webpack_require__(231);\n\n__webpack_require__(234);\n\n/***/ }),\n\n/***/ 231:\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\n\n/***/ }),\n\n/***/ 232:\n/***/ (function(module, exports) {\n\n/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\n// css base code, injected by the css-loader\nmodule.exports = function(useSourceMap) {\n\tvar list = [];\n\n\t// return the list of modules as css string\n\tlist.toString = function toString() {\n\t\treturn this.map(function (item) {\n\t\t\tvar content = cssWithMappingToString(item, useSourceMap);\n\t\t\tif(item[2]) {\n\t\t\t\treturn \"@media \" + item[2] + \"{\" + content + \"}\";\n\t\t\t} else {\n\t\t\t\treturn content;\n\t\t\t}\n\t\t}).join(\"\");\n\t};\n\n\t// import a list of modules into the list\n\tlist.i = function(modules, mediaQuery) {\n\t\tif(typeof modules === \"string\")\n\t\t\tmodules = [[null, modules, \"\"]];\n\t\tvar alreadyImportedModules = {};\n\t\tfor(var i = 0; i < this.length; i++) {\n\t\t\tvar id = this[i][0];\n\t\t\tif(typeof id === \"number\")\n\t\t\t\talreadyImportedModules[id] = true;\n\t\t}\n\t\tfor(i = 0; i < modules.length; i++) {\n\t\t\tvar item = modules[i];\n\t\t\t// skip already imported module\n\t\t\t// this implementation is not 100% perfect for weird media query combinations\n\t\t\t//  when a module is imported multiple times with different media queries.\n\t\t\t//  I hope this will never occur (Hey this way we have smaller bundles)\n\t\t\tif(typeof item[0] !== \"number\" || !alreadyImportedModules[item[0]]) {\n\t\t\t\tif(mediaQuery && !item[2]) {\n\t\t\t\t\titem[2] = mediaQuery;\n\t\t\t\t} else if(mediaQuery) {\n\t\t\t\t\titem[2] = \"(\" + item[2] + \") and (\" + mediaQuery + \")\";\n\t\t\t\t}\n\t\t\t\tlist.push(item);\n\t\t\t}\n\t\t}\n\t};\n\treturn list;\n};\n\nfunction cssWithMappingToString(item, useSourceMap) {\n\tvar content = item[1] || '';\n\tvar cssMapping = item[3];\n\tif (!cssMapping) {\n\t\treturn content;\n\t}\n\n\tif (useSourceMap && typeof btoa === 'function') {\n\t\tvar sourceMapping = toComment(cssMapping);\n\t\tvar sourceURLs = cssMapping.sources.map(function (source) {\n\t\t\treturn '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'\n\t\t});\n\n\t\treturn [content].concat(sourceURLs).concat([sourceMapping]).join('\\n');\n\t}\n\n\treturn [content].join('\\n');\n}\n\n// Adapted from convert-source-map (MIT)\nfunction toComment(sourceMap) {\n\t// eslint-disable-next-line no-undef\n\tvar base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));\n\tvar data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;\n\n\treturn '/*# ' + data + ' */';\n}\n\n\n/***/ }),\n\n/***/ 233:\n/***/ (function(module, exports) {\n\n\n/**\n * When source maps are enabled, `style-loader` uses a link element with a data-uri to\n * embed the css on the page. This breaks all relative urls because now they are relative to a\n * bundle instead of the current page.\n *\n * One solution is to only use full urls, but that may be impossible.\n *\n * Instead, this function \"fixes\" the relative urls to be absolute according to the current page location.\n *\n * A rudimentary test suite is located at `test/fixUrls.js` and can be run via the `npm test` command.\n *\n */\n\nmodule.exports = function (css) {\n  // get current location\n  var location = typeof window !== \"undefined\" && window.location;\n\n  if (!location) {\n    throw new Error(\"fixUrls requires window.location\");\n  }\n\n\t// blank or null?\n\tif (!css || typeof css !== \"string\") {\n\t  return css;\n  }\n\n  var baseUrl = location.protocol + \"//\" + location.host;\n  var currentDir = baseUrl + location.pathname.replace(/\\/[^\\/]*$/, \"/\");\n\n\t// convert each url(...)\n\t/*\n\tThis regular expression is just a way to recursively match brackets within\n\ta string.\n\n\t /url\\s*\\(  = Match on the word \"url\" with any whitespace after it and then a parens\n\t   (  = Start a capturing group\n\t     (?:  = Start a non-capturing group\n\t         [^)(]  = Match anything that isn't a parentheses\n\t         |  = OR\n\t         \\(  = Match a start parentheses\n\t             (?:  = Start another non-capturing groups\n\t                 [^)(]+  = Match anything that isn't a parentheses\n\t                 |  = OR\n\t                 \\(  = Match a start parentheses\n\t                     [^)(]*  = Match anything that isn't a parentheses\n\t                 \\)  = Match a end parentheses\n\t             )  = End Group\n              *\\) = Match anything and then a close parens\n          )  = Close non-capturing group\n          *  = Match anything\n       )  = Close capturing group\n\t \\)  = Match a close parens\n\n\t /gi  = Get all matches, not the first.  Be case insensitive.\n\t */\n\tvar fixedCss = css.replace(/url\\s*\\(((?:[^)(]|\\((?:[^)(]+|\\([^)(]*\\))*\\))*)\\)/gi, function(fullMatch, origUrl) {\n\t\t// strip quotes (if they exist)\n\t\tvar unquotedOrigUrl = origUrl\n\t\t\t.trim()\n\t\t\t.replace(/^\"(.*)\"$/, function(o, $1){ return $1; })\n\t\t\t.replace(/^'(.*)'$/, function(o, $1){ return $1; });\n\n\t\t// already a full url? no change\n\t\tif (/^(#|data:|http:\\/\\/|https:\\/\\/|file:\\/\\/\\/)/i.test(unquotedOrigUrl)) {\n\t\t  return fullMatch;\n\t\t}\n\n\t\t// convert the url to a full url\n\t\tvar newUrl;\n\n\t\tif (unquotedOrigUrl.indexOf(\"//\") === 0) {\n\t\t  \t//TODO: should we add protocol?\n\t\t\tnewUrl = unquotedOrigUrl;\n\t\t} else if (unquotedOrigUrl.indexOf(\"/\") === 0) {\n\t\t\t// path should be relative to the base url\n\t\t\tnewUrl = baseUrl + unquotedOrigUrl; // already starts with '/'\n\t\t} else {\n\t\t\t// path should be relative to current directory\n\t\t\tnewUrl = currentDir + unquotedOrigUrl.replace(/^\\.\\//, \"\"); // Strip leading './'\n\t\t}\n\n\t\t// send back the fixed url(...)\n\t\treturn \"url(\" + JSON.stringify(newUrl) + \")\";\n\t});\n\n\t// send back the fixed css\n\treturn fixedCss;\n};\n\n\n/***/ }),\n\n/***/ 234:\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__.p + \"src/styles/favicon.ico\";\n\n/***/ }),\n\n/***/ 235:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/*global XDomainRequest:false, __DEV__:false*/\n\n\nvar TraceKit = __webpack_require__(236);\nvar stringify = __webpack_require__(237);\nvar RavenConfigError = __webpack_require__(238);\nvar utils = __webpack_require__(140);\n\nvar isError = utils.isError,\n    isObject = utils.isObject;\n\nvar wrapConsoleMethod = __webpack_require__(239).wrapMethod;\n\nvar dsnKeys = 'source protocol user pass host port path'.split(' '),\n    dsnPattern = /^(?:(\\w+):)?\\/\\/(?:(\\w+)(:\\w+)?@)?([\\w\\.-]+)(?::(\\d+))?(\\/.*)/;\n\nfunction now() {\n    return +new Date();\n}\n\n// This is to be defensive in environments where window does not exist (see https://github.com/getsentry/raven-js/pull/785)\nvar _window = typeof window !== 'undefined' ? window\n            : typeof global !== 'undefined' ? global\n            : typeof self !== 'undefined' ? self\n            : {};\nvar _document = _window.document;\nvar _navigator = _window.navigator;\n\n\nfunction keepOriginalCallback(original, callback) {\n    return isFunction(callback) ?\n    function (data) { return callback(data, original) } :\n    callback;\n}\n\n// First, check for JSON support\n// If there is no JSON, we no-op the core features of Raven\n// since JSON is required to encode the payload\nfunction Raven() {\n    this._hasJSON = !!(typeof JSON === 'object' && JSON.stringify);\n    // Raven can run in contexts where there's no document (react-native)\n    this._hasDocument = !isUndefined(_document);\n    this._hasNavigator = !isUndefined(_navigator);\n    this._lastCapturedException = null;\n    this._lastData = null;\n    this._lastEventId = null;\n    this._globalServer = null;\n    this._globalKey = null;\n    this._globalProject = null;\n    this._globalContext = {};\n    this._globalOptions = {\n        logger: 'javascript',\n        ignoreErrors: [],\n        ignoreUrls: [],\n        whitelistUrls: [],\n        includePaths: [],\n        crossOrigin: 'anonymous',\n        collectWindowErrors: true,\n        maxMessageLength: 0,\n\n        // By default, truncates URL values to 250 chars\n        maxUrlLength: 250,\n        stackTraceLimit: 50,\n        autoBreadcrumbs: true,\n        instrument: true,\n        sampleRate: 1\n    };\n    this._ignoreOnError = 0;\n    this._isRavenInstalled = false;\n    this._originalErrorStackTraceLimit = Error.stackTraceLimit;\n    // capture references to window.console *and* all its methods first\n    // before the console plugin has a chance to monkey patch\n    this._originalConsole = _window.console || {};\n    this._originalConsoleMethods = {};\n    this._plugins = [];\n    this._startTime = now();\n    this._wrappedBuiltIns = [];\n    this._breadcrumbs = [];\n    this._lastCapturedEvent = null;\n    this._keypressTimeout;\n    this._location = _window.location;\n    this._lastHref = this._location && this._location.href;\n    this._resetBackoff();\n\n    for (var method in this._originalConsole) {  // eslint-disable-line guard-for-in\n      this._originalConsoleMethods[method] = this._originalConsole[method];\n    }\n}\n\n/*\n * The core Raven singleton\n *\n * @this {Raven}\n */\n\nRaven.prototype = {\n    // Hardcode version string so that raven source can be loaded directly via\n    // webpack (using a build step causes webpack #1617). Grunt verifies that\n    // this value matches package.json during build.\n    //   See: https://github.com/getsentry/raven-js/issues/465\n    VERSION: '3.17.0',\n\n    debug: false,\n\n    TraceKit: TraceKit, // alias to TraceKit\n\n    /*\n     * Configure Raven with a DSN and extra options\n     *\n     * @param {string} dsn The public Sentry DSN\n     * @param {object} options Optional set of of global options [optional]\n     * @return {Raven}\n     */\n    config: function(dsn, options) {\n        var self = this;\n\n        if (self._globalServer) {\n                this._logDebug('error', 'Error: Raven has already been configured');\n            return self;\n        }\n        if (!dsn) return self;\n\n        var globalOptions = self._globalOptions;\n\n        // merge in options\n        if (options) {\n            each(options, function(key, value){\n                // tags and extra are special and need to be put into context\n                if (key === 'tags' || key === 'extra' || key === 'user') {\n                    self._globalContext[key] = value;\n                } else {\n                    globalOptions[key] = value;\n                }\n            });\n        }\n\n        self.setDSN(dsn);\n\n        // \"Script error.\" is hard coded into browsers for errors that it can't read.\n        // this is the result of a script being pulled in from an external domain and CORS.\n        globalOptions.ignoreErrors.push(/^Script error\\.?$/);\n        globalOptions.ignoreErrors.push(/^Javascript error: Script error\\.? on line 0$/);\n\n        // join regexp rules into one big rule\n        globalOptions.ignoreErrors = joinRegExp(globalOptions.ignoreErrors);\n        globalOptions.ignoreUrls = globalOptions.ignoreUrls.length ? joinRegExp(globalOptions.ignoreUrls) : false;\n        globalOptions.whitelistUrls = globalOptions.whitelistUrls.length ? joinRegExp(globalOptions.whitelistUrls) : false;\n        globalOptions.includePaths = joinRegExp(globalOptions.includePaths);\n        globalOptions.maxBreadcrumbs = Math.max(0, Math.min(globalOptions.maxBreadcrumbs || 100, 100)); // default and hard limit is 100\n\n        var autoBreadcrumbDefaults = {\n            xhr: true,\n            console: true,\n            dom: true,\n            location: true\n        };\n\n        var autoBreadcrumbs = globalOptions.autoBreadcrumbs;\n        if ({}.toString.call(autoBreadcrumbs) === '[object Object]') {\n            autoBreadcrumbs = objectMerge(autoBreadcrumbDefaults, autoBreadcrumbs);\n        } else if (autoBreadcrumbs !== false) {\n            autoBreadcrumbs = autoBreadcrumbDefaults;\n        }\n        globalOptions.autoBreadcrumbs = autoBreadcrumbs;\n\n        var instrumentDefaults = {\n            tryCatch: true\n        };\n\n        var instrument = globalOptions.instrument;\n        if ({}.toString.call(instrument) === '[object Object]') {\n            instrument = objectMerge(instrumentDefaults, instrument);\n        } else if (instrument !== false) {\n            instrument = instrumentDefaults;\n        }\n        globalOptions.instrument = instrument;\n\n        TraceKit.collectWindowErrors = !!globalOptions.collectWindowErrors;\n\n        // return for chaining\n        return self;\n    },\n\n    /*\n     * Installs a global window.onerror error handler\n     * to capture and report uncaught exceptions.\n     * At this point, install() is required to be called due\n     * to the way TraceKit is set up.\n     *\n     * @return {Raven}\n     */\n    install: function() {\n        var self = this;\n        if (self.isSetup() && !self._isRavenInstalled) {\n            TraceKit.report.subscribe(function () {\n                self._handleOnErrorStackInfo.apply(self, arguments);\n            });\n            if (self._globalOptions.instrument && self._globalOptions.instrument.tryCatch) {\n              self._instrumentTryCatch();\n            }\n\n            if (self._globalOptions.autoBreadcrumbs)\n                self._instrumentBreadcrumbs();\n\n            // Install all of the plugins\n            self._drainPlugins();\n\n            self._isRavenInstalled = true;\n        }\n\n        Error.stackTraceLimit = self._globalOptions.stackTraceLimit;\n        return this;\n    },\n\n    /*\n     * Set the DSN (can be called multiple time unlike config)\n     *\n     * @param {string} dsn The public Sentry DSN\n     */\n    setDSN: function(dsn) {\n        var self = this,\n            uri = self._parseDSN(dsn),\n          lastSlash = uri.path.lastIndexOf('/'),\n          path = uri.path.substr(1, lastSlash);\n\n        self._dsn = dsn;\n        self._globalKey = uri.user;\n        self._globalSecret = uri.pass && uri.pass.substr(1);\n        self._globalProject = uri.path.substr(lastSlash + 1);\n\n        self._globalServer = self._getGlobalServer(uri);\n\n        self._globalEndpoint = self._globalServer +\n            '/' + path + 'api/' + self._globalProject + '/store/';\n\n        // Reset backoff state since we may be pointing at a\n        // new project/server\n        this._resetBackoff();\n    },\n\n    /*\n     * Wrap code within a context so Raven can capture errors\n     * reliably across domains that is executed immediately.\n     *\n     * @param {object} options A specific set of options for this context [optional]\n     * @param {function} func The callback to be immediately executed within the context\n     * @param {array} args An array of arguments to be called with the callback [optional]\n     */\n    context: function(options, func, args) {\n        if (isFunction(options)) {\n            args = func || [];\n            func = options;\n            options = undefined;\n        }\n\n        return this.wrap(options, func).apply(this, args);\n    },\n\n    /*\n     * Wrap code within a context and returns back a new function to be executed\n     *\n     * @param {object} options A specific set of options for this context [optional]\n     * @param {function} func The function to be wrapped in a new context\n     * @param {function} func A function to call before the try/catch wrapper [optional, private]\n     * @return {function} The newly wrapped functions with a context\n     */\n    wrap: function(options, func, _before) {\n        var self = this;\n        // 1 argument has been passed, and it's not a function\n        // so just return it\n        if (isUndefined(func) && !isFunction(options)) {\n            return options;\n        }\n\n        // options is optional\n        if (isFunction(options)) {\n            func = options;\n            options = undefined;\n        }\n\n        // At this point, we've passed along 2 arguments, and the second one\n        // is not a function either, so we'll just return the second argument.\n        if (!isFunction(func)) {\n            return func;\n        }\n\n        // We don't wanna wrap it twice!\n        try {\n            if (func.__raven__) {\n                return func;\n            }\n\n            // If this has already been wrapped in the past, return that\n            if (func.__raven_wrapper__ ){\n                return func.__raven_wrapper__ ;\n            }\n        } catch (e) {\n            // Just accessing custom props in some Selenium environments\n            // can cause a \"Permission denied\" exception (see raven-js#495).\n            // Bail on wrapping and return the function as-is (defers to window.onerror).\n            return func;\n        }\n\n        function wrapped() {\n            var args = [], i = arguments.length,\n                deep = !options || options && options.deep !== false;\n\n            if (_before && isFunction(_before)) {\n                _before.apply(this, arguments);\n            }\n\n            // Recursively wrap all of a function's arguments that are\n            // functions themselves.\n            while(i--) args[i] = deep ? self.wrap(options, arguments[i]) : arguments[i];\n\n            try {\n                // Attempt to invoke user-land function\n                // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n                //       means Raven caught an error invoking your application code. This is\n                //       expected behavior and NOT indicative of a bug with Raven.js.\n                return func.apply(this, args);\n            } catch(e) {\n                self._ignoreNextOnError();\n                self.captureException(e, options);\n                throw e;\n            }\n        }\n\n        // copy over properties of the old function\n        for (var property in func) {\n            if (hasKey(func, property)) {\n                wrapped[property] = func[property];\n            }\n        }\n        wrapped.prototype = func.prototype;\n\n        func.__raven_wrapper__ = wrapped;\n        // Signal that this function has been wrapped already\n        // for both debugging and to prevent it to being wrapped twice\n        wrapped.__raven__ = true;\n        wrapped.__inner__ = func;\n\n        return wrapped;\n    },\n\n    /*\n     * Uninstalls the global error handler.\n     *\n     * @return {Raven}\n     */\n    uninstall: function() {\n        TraceKit.report.uninstall();\n\n        this._restoreBuiltIns();\n\n        Error.stackTraceLimit = this._originalErrorStackTraceLimit;\n        this._isRavenInstalled = false;\n\n        return this;\n    },\n\n    /*\n     * Manually capture an exception and send it over to Sentry\n     *\n     * @param {error} ex An exception to be logged\n     * @param {object} options A specific set of options for this error [optional]\n     * @return {Raven}\n     */\n    captureException: function(ex, options) {\n        // If not an Error is passed through, recall as a message instead\n        if (!isError(ex)) {\n            return this.captureMessage(ex, objectMerge({\n                trimHeadFrames: 1,\n                stacktrace: true // if we fall back to captureMessage, default to attempting a new trace\n            }, options));\n        }\n\n        // Store the raw exception object for potential debugging and introspection\n        this._lastCapturedException = ex;\n\n        // TraceKit.report will re-raise any exception passed to it,\n        // which means you have to wrap it in try/catch. Instead, we\n        // can wrap it here and only re-raise if TraceKit.report\n        // raises an exception different from the one we asked to\n        // report on.\n        try {\n            var stack = TraceKit.computeStackTrace(ex);\n            this._handleStackInfo(stack, options);\n        } catch(ex1) {\n            if(ex !== ex1) {\n                throw ex1;\n            }\n        }\n\n        return this;\n    },\n\n    /*\n     * Manually send a message to Sentry\n     *\n     * @param {string} msg A plain message to be captured in Sentry\n     * @param {object} options A specific set of options for this message [optional]\n     * @return {Raven}\n     */\n    captureMessage: function(msg, options) {\n        // config() automagically converts ignoreErrors from a list to a RegExp so we need to test for an\n        // early call; we'll error on the side of logging anything called before configuration since it's\n        // probably something you should see:\n        if (!!this._globalOptions.ignoreErrors.test && this._globalOptions.ignoreErrors.test(msg)) {\n            return;\n        }\n\n        options = options || {};\n\n        var data = objectMerge({\n            message: msg + ''  // Make sure it's actually a string\n        }, options);\n\n        if (this._globalOptions.stacktrace || (options && options.stacktrace)) {\n            var ex;\n            // Generate a \"synthetic\" stack trace from this point.\n            // NOTE: If you are a Sentry user, and you are seeing this stack frame, it is NOT indicative\n            //       of a bug with Raven.js. Sentry generates synthetic traces either by configuration,\n            //       or if it catches a thrown object without a \"stack\" property.\n            try {\n                throw new Error(msg);\n            } catch (ex1) {\n                ex = ex1;\n            }\n\n            // null exception name so `Error` isn't prefixed to msg\n            ex.name = null;\n\n            options = objectMerge({\n                // fingerprint on msg, not stack trace (legacy behavior, could be\n                // revisited)\n                fingerprint: msg,\n                // since we know this is a synthetic trace, the top N-most frames\n                // MUST be from Raven.js, so mark them as in_app later by setting\n                // trimHeadFrames\n                trimHeadFrames: (options.trimHeadFrames || 0) + 1\n            }, options);\n\n            var stack = TraceKit.computeStackTrace(ex);\n            var frames = this._prepareFrames(stack, options);\n            data.stacktrace = {\n                // Sentry expects frames oldest to newest\n                frames: frames.reverse()\n            }\n        }\n\n        // Fire away!\n        this._send(data);\n\n        return this;\n    },\n\n    captureBreadcrumb: function (obj) {\n        var crumb = objectMerge({\n            timestamp: now() / 1000\n        }, obj);\n\n        if (isFunction(this._globalOptions.breadcrumbCallback)) {\n            var result = this._globalOptions.breadcrumbCallback(crumb);\n\n            if (isObject(result) && !isEmptyObject(result)) {\n                crumb = result;\n            } else if (result === false) {\n                return this;\n            }\n        }\n\n        this._breadcrumbs.push(crumb);\n        if (this._breadcrumbs.length > this._globalOptions.maxBreadcrumbs) {\n            this._breadcrumbs.shift();\n        }\n        return this;\n    },\n\n    addPlugin: function(plugin /*arg1, arg2, ... argN*/) {\n        var pluginArgs = [].slice.call(arguments, 1);\n\n        this._plugins.push([plugin, pluginArgs]);\n        if (this._isRavenInstalled) {\n            this._drainPlugins();\n        }\n\n        return this;\n    },\n\n    /*\n     * Set/clear a user to be sent along with the payload.\n     *\n     * @param {object} user An object representing user data [optional]\n     * @return {Raven}\n     */\n    setUserContext: function(user) {\n        // Intentionally do not merge here since that's an unexpected behavior.\n        this._globalContext.user = user;\n\n        return this;\n    },\n\n    /*\n     * Merge extra attributes to be sent along with the payload.\n     *\n     * @param {object} extra An object representing extra data [optional]\n     * @return {Raven}\n     */\n    setExtraContext: function(extra) {\n        this._mergeContext('extra', extra);\n\n        return this;\n    },\n\n    /*\n     * Merge tags to be sent along with the payload.\n     *\n     * @param {object} tags An object representing tags [optional]\n     * @return {Raven}\n     */\n    setTagsContext: function(tags) {\n        this._mergeContext('tags', tags);\n\n        return this;\n    },\n\n    /*\n     * Clear all of the context.\n     *\n     * @return {Raven}\n     */\n    clearContext: function() {\n        this._globalContext = {};\n\n        return this;\n    },\n\n    /*\n     * Get a copy of the current context. This cannot be mutated.\n     *\n     * @return {object} copy of context\n     */\n    getContext: function() {\n        // lol javascript\n        return JSON.parse(stringify(this._globalContext));\n    },\n\n\n    /*\n     * Set environment of application\n     *\n     * @param {string} environment Typically something like 'production'.\n     * @return {Raven}\n     */\n    setEnvironment: function(environment) {\n        this._globalOptions.environment = environment;\n\n        return this;\n    },\n\n    /*\n     * Set release version of application\n     *\n     * @param {string} release Typically something like a git SHA to identify version\n     * @return {Raven}\n     */\n    setRelease: function(release) {\n        this._globalOptions.release = release;\n\n        return this;\n    },\n\n    /*\n     * Set the dataCallback option\n     *\n     * @param {function} callback The callback to run which allows the\n     *                            data blob to be mutated before sending\n     * @return {Raven}\n     */\n    setDataCallback: function(callback) {\n        var original = this._globalOptions.dataCallback;\n        this._globalOptions.dataCallback =\n          keepOriginalCallback(original, callback);\n        return this;\n    },\n\n    /*\n     * Set the breadcrumbCallback option\n     *\n     * @param {function} callback The callback to run which allows filtering\n     *                            or mutating breadcrumbs\n     * @return {Raven}\n     */\n    setBreadcrumbCallback: function(callback) {\n        var original = this._globalOptions.breadcrumbCallback;\n        this._globalOptions.breadcrumbCallback =\n          keepOriginalCallback(original, callback);\n        return this;\n    },\n\n    /*\n     * Set the shouldSendCallback option\n     *\n     * @param {function} callback The callback to run which allows\n     *                            introspecting the blob before sending\n     * @return {Raven}\n     */\n    setShouldSendCallback: function(callback) {\n        var original = this._globalOptions.shouldSendCallback;\n        this._globalOptions.shouldSendCallback =\n          keepOriginalCallback(original, callback);\n        return this;\n    },\n\n    /**\n     * Override the default HTTP transport mechanism that transmits data\n     * to the Sentry server.\n     *\n     * @param {function} transport Function invoked instead of the default\n     *                             `makeRequest` handler.\n     *\n     * @return {Raven}\n     */\n    setTransport: function(transport) {\n        this._globalOptions.transport = transport;\n\n        return this;\n    },\n\n    /*\n     * Get the latest raw exception that was captured by Raven.\n     *\n     * @return {error}\n     */\n    lastException: function() {\n        return this._lastCapturedException;\n    },\n\n    /*\n     * Get the last event id\n     *\n     * @return {string}\n     */\n    lastEventId: function() {\n        return this._lastEventId;\n    },\n\n    /*\n     * Determine if Raven is setup and ready to go.\n     *\n     * @return {boolean}\n     */\n    isSetup: function() {\n        if (!this._hasJSON) return false;  // needs JSON support\n        if (!this._globalServer) {\n            if (!this.ravenNotConfiguredError) {\n              this.ravenNotConfiguredError = true;\n              this._logDebug('error', 'Error: Raven has not been configured.');\n            }\n            return false;\n        }\n        return true;\n    },\n\n    afterLoad: function () {\n        // TODO: remove window dependence?\n\n        // Attempt to initialize Raven on load\n        var RavenConfig = _window.RavenConfig;\n        if (RavenConfig) {\n            this.config(RavenConfig.dsn, RavenConfig.config).install();\n        }\n    },\n\n    showReportDialog: function (options) {\n        if (!_document) // doesn't work without a document (React native)\n            return;\n\n        options = options || {};\n\n        var lastEventId = options.eventId || this.lastEventId();\n        if (!lastEventId) {\n            throw new RavenConfigError('Missing eventId');\n        }\n\n        var dsn = options.dsn || this._dsn;\n        if (!dsn) {\n            throw new RavenConfigError('Missing DSN');\n        }\n\n        var encode = encodeURIComponent;\n        var qs = '';\n        qs += '?eventId=' + encode(lastEventId);\n        qs += '&dsn=' + encode(dsn);\n\n        var user = options.user || this._globalContext.user;\n        if (user) {\n            if (user.name)  qs += '&name=' + encode(user.name);\n            if (user.email) qs += '&email=' + encode(user.email);\n        }\n\n        var globalServer = this._getGlobalServer(this._parseDSN(dsn));\n\n        var script = _document.createElement('script');\n        script.async = true;\n        script.src = globalServer + '/api/embed/error-page/' + qs;\n        (_document.head || _document.body).appendChild(script);\n    },\n\n    /**** Private functions ****/\n    _ignoreNextOnError: function () {\n        var self = this;\n        this._ignoreOnError += 1;\n        setTimeout(function () {\n            // onerror should trigger before setTimeout\n            self._ignoreOnError -= 1;\n        });\n    },\n\n    _triggerEvent: function(eventType, options) {\n        // NOTE: `event` is a native browser thing, so let's avoid conflicting wiht it\n        var evt, key;\n\n        if (!this._hasDocument)\n            return;\n\n        options = options || {};\n\n        eventType = 'raven' + eventType.substr(0,1).toUpperCase() + eventType.substr(1);\n\n        if (_document.createEvent) {\n            evt = _document.createEvent('HTMLEvents');\n            evt.initEvent(eventType, true, true);\n        } else {\n            evt = _document.createEventObject();\n            evt.eventType = eventType;\n        }\n\n        for (key in options) if (hasKey(options, key)) {\n            evt[key] = options[key];\n        }\n\n        if (_document.createEvent) {\n            // IE9 if standards\n            _document.dispatchEvent(evt);\n        } else {\n            // IE8 regardless of Quirks or Standards\n            // IE9 if quirks\n            try {\n                _document.fireEvent('on' + evt.eventType.toLowerCase(), evt);\n            } catch(e) {\n                // Do nothing\n            }\n        }\n    },\n\n    /**\n     * Wraps addEventListener to capture UI breadcrumbs\n     * @param evtName the event name (e.g. \"click\")\n     * @returns {Function}\n     * @private\n     */\n    _breadcrumbEventHandler: function(evtName) {\n        var self = this;\n        return function (evt) {\n            // reset keypress timeout; e.g. triggering a 'click' after\n            // a 'keypress' will reset the keypress debounce so that a new\n            // set of keypresses can be recorded\n            self._keypressTimeout = null;\n\n            // It's possible this handler might trigger multiple times for the same\n            // event (e.g. event propagation through node ancestors). Ignore if we've\n            // already captured the event.\n            if (self._lastCapturedEvent === evt)\n                return;\n\n            self._lastCapturedEvent = evt;\n\n            // try/catch both:\n            // - accessing evt.target (see getsentry/raven-js#838, #768)\n            // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n            //   can throw an exception in some circumstances.\n            var target;\n            try {\n                target = htmlTreeAsString(evt.target);\n            } catch (e) {\n                target = '<unknown>';\n            }\n\n            self.captureBreadcrumb({\n                category: 'ui.' + evtName, // e.g. ui.click, ui.input\n                message: target\n            });\n        };\n    },\n\n    /**\n     * Wraps addEventListener to capture keypress UI events\n     * @returns {Function}\n     * @private\n     */\n    _keypressEventHandler: function() {\n        var self = this,\n            debounceDuration = 1000; // milliseconds\n\n        // TODO: if somehow user switches keypress target before\n        //       debounce timeout is triggered, we will only capture\n        //       a single breadcrumb from the FIRST target (acceptable?)\n        return function (evt) {\n            var target;\n            try {\n                target = evt.target;\n            } catch (e) {\n                // just accessing event properties can throw an exception in some rare circumstances\n                // see: https://github.com/getsentry/raven-js/issues/838\n                return;\n            }\n            var tagName = target && target.tagName;\n\n            // only consider keypress events on actual input elements\n            // this will disregard keypresses targeting body (e.g. tabbing\n            // through elements, hotkeys, etc)\n            if (!tagName || tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)\n                return;\n\n            // record first keypress in a series, but ignore subsequent\n            // keypresses until debounce clears\n            var timeout = self._keypressTimeout;\n            if (!timeout) {\n                self._breadcrumbEventHandler('input')(evt);\n            }\n            clearTimeout(timeout);\n            self._keypressTimeout = setTimeout(function () {\n                self._keypressTimeout = null;\n            }, debounceDuration);\n        };\n    },\n\n    /**\n     * Captures a breadcrumb of type \"navigation\", normalizing input URLs\n     * @param to the originating URL\n     * @param from the target URL\n     * @private\n     */\n    _captureUrlChange: function(from, to) {\n        var parsedLoc = parseUrl(this._location.href);\n        var parsedTo = parseUrl(to);\n        var parsedFrom = parseUrl(from);\n\n        // because onpopstate only tells you the \"new\" (to) value of location.href, and\n        // not the previous (from) value, we need to track the value of the current URL\n        // state ourselves\n        this._lastHref = to;\n\n        // Use only the path component of the URL if the URL matches the current\n        // document (almost all the time when using pushState)\n        if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host)\n            to = parsedTo.relative;\n        if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host)\n            from = parsedFrom.relative;\n\n        this.captureBreadcrumb({\n            category: 'navigation',\n            data: {\n                to: to,\n                from: from\n            }\n        });\n    },\n\n    /**\n     * Wrap timer functions and event targets to catch errors and provide\n     * better metadata.\n     */\n    _instrumentTryCatch: function() {\n        var self = this;\n\n        var wrappedBuiltIns = self._wrappedBuiltIns;\n\n        function wrapTimeFn(orig) {\n            return function (fn, t) { // preserve arity\n                // Make a copy of the arguments to prevent deoptimization\n                // https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments\n                var args = new Array(arguments.length);\n                for(var i = 0; i < args.length; ++i) {\n                    args[i] = arguments[i];\n                }\n                var originalCallback = args[0];\n                if (isFunction(originalCallback)) {\n                    args[0] = self.wrap(originalCallback);\n                }\n\n                // IE < 9 doesn't support .call/.apply on setInterval/setTimeout, but it\n                // also supports only two arguments and doesn't care what this is, so we\n                // can just call the original function directly.\n                if (orig.apply) {\n                    return orig.apply(this, args);\n                } else {\n                    return orig(args[0], args[1]);\n                }\n            };\n        }\n\n        var autoBreadcrumbs = this._globalOptions.autoBreadcrumbs;\n\n        function wrapEventTarget(global) {\n            var proto = _window[global] && _window[global].prototype;\n            if (proto && proto.hasOwnProperty && proto.hasOwnProperty('addEventListener')) {\n                fill(proto, 'addEventListener', function(orig) {\n                    return function (evtName, fn, capture, secure) { // preserve arity\n                        try {\n                            if (fn && fn.handleEvent) {\n                                fn.handleEvent = self.wrap(fn.handleEvent);\n                            }\n                        } catch (err) {\n                            // can sometimes get 'Permission denied to access property \"handle Event'\n                        }\n\n                        // More breadcrumb DOM capture ... done here and not in `_instrumentBreadcrumbs`\n                        // so that we don't have more than one wrapper function\n                        var before,\n                            clickHandler,\n                            keypressHandler;\n\n                        if (autoBreadcrumbs && autoBreadcrumbs.dom && (global === 'EventTarget' || global === 'Node')) {\n                            // NOTE: generating multiple handlers per addEventListener invocation, should\n                            //       revisit and verify we can just use one (almost certainly)\n                            clickHandler = self._breadcrumbEventHandler('click');\n                            keypressHandler = self._keypressEventHandler();\n                            before = function (evt) {\n                                // need to intercept every DOM event in `before` argument, in case that\n                                // same wrapped method is re-used for different events (e.g. mousemove THEN click)\n                                // see #724\n                                if (!evt) return;\n\n                                var eventType;\n                                try {\n                                    eventType = evt.type\n                                } catch (e) {\n                                    // just accessing event properties can throw an exception in some rare circumstances\n                                    // see: https://github.com/getsentry/raven-js/issues/838\n                                    return;\n                                }\n                                if (eventType === 'click')\n                                    return clickHandler(evt);\n                                else if (eventType === 'keypress')\n                                    return keypressHandler(evt);\n                            };\n                        }\n                        return orig.call(this, evtName, self.wrap(fn, undefined, before), capture, secure);\n                    };\n                }, wrappedBuiltIns);\n                fill(proto, 'removeEventListener', function (orig) {\n                    return function (evt, fn, capture, secure) {\n                        try {\n                            fn = fn && (fn.__raven_wrapper__ ? fn.__raven_wrapper__  : fn);\n                        } catch (e) {\n                            // ignore, accessing __raven_wrapper__ will throw in some Selenium environments\n                        }\n                        return orig.call(this, evt, fn, capture, secure);\n                    };\n                }, wrappedBuiltIns);\n            }\n        }\n\n        fill(_window, 'setTimeout', wrapTimeFn, wrappedBuiltIns);\n        fill(_window, 'setInterval', wrapTimeFn, wrappedBuiltIns);\n        if (_window.requestAnimationFrame) {\n            fill(_window, 'requestAnimationFrame', function (orig) {\n                return function (cb) {\n                    return orig(self.wrap(cb));\n                };\n            }, wrappedBuiltIns);\n        }\n\n        // event targets borrowed from bugsnag-js:\n        // https://github.com/bugsnag/bugsnag-js/blob/master/src/bugsnag.js#L666\n        var eventTargets = ['EventTarget', 'Window', 'Node', 'ApplicationCache', 'AudioTrackList', 'ChannelMergerNode', 'CryptoOperation', 'EventSource', 'FileReader', 'HTMLUnknownElement', 'IDBDatabase', 'IDBRequest', 'IDBTransaction', 'KeyOperation', 'MediaController', 'MessagePort', 'ModalWindow', 'Notification', 'SVGElementInstance', 'Screen', 'TextTrack', 'TextTrackCue', 'TextTrackList', 'WebSocket', 'WebSocketWorker', 'Worker', 'XMLHttpRequest', 'XMLHttpRequestEventTarget', 'XMLHttpRequestUpload'];\n        for (var i = 0; i < eventTargets.length; i++) {\n            wrapEventTarget(eventTargets[i]);\n        }\n    },\n\n\n    /**\n     * Instrument browser built-ins w/ breadcrumb capturing\n     *  - XMLHttpRequests\n     *  - DOM interactions (click/typing)\n     *  - window.location changes\n     *  - console\n     *\n     * Can be disabled or individually configured via the `autoBreadcrumbs` config option\n     */\n    _instrumentBreadcrumbs: function () {\n        var self = this;\n        var autoBreadcrumbs = this._globalOptions.autoBreadcrumbs;\n\n        var wrappedBuiltIns = self._wrappedBuiltIns;\n\n        function wrapProp(prop, xhr) {\n            if (prop in xhr && isFunction(xhr[prop])) {\n                fill(xhr, prop, function (orig) {\n                    return self.wrap(orig);\n                }); // intentionally don't track filled methods on XHR instances\n            }\n        }\n\n        if (autoBreadcrumbs.xhr && 'XMLHttpRequest' in _window) {\n            var xhrproto = XMLHttpRequest.prototype;\n            fill(xhrproto, 'open', function(origOpen) {\n                return function (method, url) { // preserve arity\n\n                    // if Sentry key appears in URL, don't capture\n                    if (isString(url) && url.indexOf(self._globalKey) === -1) {\n                        this.__raven_xhr = {\n                            method: method,\n                            url: url,\n                            status_code: null\n                        };\n                    }\n\n                    return origOpen.apply(this, arguments);\n                };\n            }, wrappedBuiltIns);\n\n            fill(xhrproto, 'send', function(origSend) {\n                return function (data) { // preserve arity\n                    var xhr = this;\n\n                    function onreadystatechangeHandler() {\n                        if (xhr.__raven_xhr && (xhr.readyState === 1 || xhr.readyState === 4)) {\n                            try {\n                                // touching statusCode in some platforms throws\n                                // an exception\n                                xhr.__raven_xhr.status_code = xhr.status;\n                            } catch (e) { /* do nothing */ }\n                            self.captureBreadcrumb({\n                                type: 'http',\n                                category: 'xhr',\n                                data: xhr.__raven_xhr\n                            });\n                        }\n                    }\n\n                    var props = ['onload', 'onerror', 'onprogress'];\n                    for (var j = 0; j < props.length; j++) {\n                        wrapProp(props[j], xhr);\n                    }\n\n                    if ('onreadystatechange' in xhr && isFunction(xhr.onreadystatechange)) {\n                        fill(xhr, 'onreadystatechange', function (orig) {\n                            return self.wrap(orig, undefined, onreadystatechangeHandler);\n                        } /* intentionally don't track this instrumentation */);\n                    } else {\n                        // if onreadystatechange wasn't actually set by the page on this xhr, we\n                        // are free to set our own and capture the breadcrumb\n                        xhr.onreadystatechange = onreadystatechangeHandler;\n                    }\n\n                    return origSend.apply(this, arguments);\n                };\n            }, wrappedBuiltIns);\n        }\n\n        if (autoBreadcrumbs.xhr && 'fetch' in _window) {\n            fill(_window, 'fetch', function(origFetch) {\n                return function (fn, t) { // preserve arity\n                    // Make a copy of the arguments to prevent deoptimization\n                    // https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments\n                    var args = new Array(arguments.length);\n                    for (var i = 0; i < args.length; ++i) {\n                        args[i] = arguments[i];\n                    }\n\n                    var fetchInput = args[0];\n                    var method = 'GET';\n                    var url;\n\n                    if (typeof fetchInput === 'string') {\n                        url = fetchInput;\n                    } else {\n                        url = fetchInput.url;\n                        if (fetchInput.method) {\n                            method = fetchInput.method;\n                        }\n                    }\n\n                    if (args[1] && args[1].method) {\n                        method = args[1].method;\n                    }\n\n                    var fetchData = {\n                        method: method,\n                        url: url,\n                        status_code: null\n                    };\n\n                    self.captureBreadcrumb({\n                        type: 'http',\n                        category: 'fetch',\n                        data: fetchData\n                    });\n\n                    return origFetch.apply(this, args).then(function (response) {\n                        fetchData.status_code = response.status;\n\n                        return response;\n                    });\n                };\n            }, wrappedBuiltIns);\n        }\n\n        // Capture breadcrumbs from any click that is unhandled / bubbled up all the way\n        // to the document. Do this before we instrument addEventListener.\n        if (autoBreadcrumbs.dom && this._hasDocument) {\n            if (_document.addEventListener) {\n                _document.addEventListener('click', self._breadcrumbEventHandler('click'), false);\n                _document.addEventListener('keypress', self._keypressEventHandler(), false);\n            }\n            else {\n                // IE8 Compatibility\n                _document.attachEvent('onclick', self._breadcrumbEventHandler('click'));\n                _document.attachEvent('onkeypress', self._keypressEventHandler());\n            }\n        }\n\n        // record navigation (URL) changes\n        // NOTE: in Chrome App environment, touching history.pushState, *even inside\n        //       a try/catch block*, will cause Chrome to output an error to console.error\n        // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n        var chrome = _window.chrome;\n        var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n        var hasPushState = !isChromePackagedApp && _window.history && history.pushState;\n        if (autoBreadcrumbs.location && hasPushState) {\n            // TODO: remove onpopstate handler on uninstall()\n            var oldOnPopState = _window.onpopstate;\n            _window.onpopstate = function () {\n                var currentHref = self._location.href;\n                self._captureUrlChange(self._lastHref, currentHref);\n\n                if (oldOnPopState) {\n                    return oldOnPopState.apply(this, arguments);\n                }\n            };\n\n            fill(history, 'pushState', function (origPushState) {\n                // note history.pushState.length is 0; intentionally not declaring\n                // params to preserve 0 arity\n                return function (/* state, title, url */) {\n                    var url = arguments.length > 2 ? arguments[2] : undefined;\n\n                    // url argument is optional\n                    if (url) {\n                        // coerce to string (this is what pushState does)\n                        self._captureUrlChange(self._lastHref, url + '');\n                    }\n\n                    return origPushState.apply(this, arguments);\n                };\n            }, wrappedBuiltIns);\n        }\n\n        if (autoBreadcrumbs.console && 'console' in _window && console.log) {\n            // console\n            var consoleMethodCallback = function (msg, data) {\n                self.captureBreadcrumb({\n                    message: msg,\n                    level: data.level,\n                    category: 'console'\n                });\n            };\n\n            each(['debug', 'info', 'warn', 'error', 'log'], function (_, level) {\n                wrapConsoleMethod(console, level, consoleMethodCallback);\n            });\n        }\n\n    },\n\n    _restoreBuiltIns: function () {\n        // restore any wrapped builtins\n        var builtin;\n        while (this._wrappedBuiltIns.length) {\n            builtin = this._wrappedBuiltIns.shift();\n\n            var obj = builtin[0],\n              name = builtin[1],\n              orig = builtin[2];\n\n            obj[name] = orig;\n        }\n    },\n\n    _drainPlugins: function() {\n        var self = this;\n\n        // FIX ME TODO\n        each(this._plugins, function(_, plugin) {\n            var installer = plugin[0];\n            var args = plugin[1];\n            installer.apply(self, [self].concat(args));\n        });\n    },\n\n    _parseDSN: function(str) {\n        var m = dsnPattern.exec(str),\n            dsn = {},\n            i = 7;\n\n        try {\n            while (i--) dsn[dsnKeys[i]] = m[i] || '';\n        } catch(e) {\n            throw new RavenConfigError('Invalid DSN: ' + str);\n        }\n\n        if (dsn.pass && !this._globalOptions.allowSecretKey) {\n            throw new RavenConfigError('Do not specify your secret key in the DSN. See: http://bit.ly/raven-secret-key');\n        }\n\n        return dsn;\n    },\n\n    _getGlobalServer: function(uri) {\n        // assemble the endpoint from the uri pieces\n        var globalServer = '//' + uri.host +\n            (uri.port ? ':' + uri.port : '');\n\n        if (uri.protocol) {\n            globalServer = uri.protocol + ':' + globalServer;\n        }\n        return globalServer;\n    },\n\n    _handleOnErrorStackInfo: function() {\n        // if we are intentionally ignoring errors via onerror, bail out\n        if (!this._ignoreOnError) {\n            this._handleStackInfo.apply(this, arguments);\n        }\n    },\n\n    _handleStackInfo: function(stackInfo, options) {\n        var frames = this._prepareFrames(stackInfo, options);\n\n        this._triggerEvent('handle', {\n            stackInfo: stackInfo,\n            options: options\n        });\n\n        this._processException(\n            stackInfo.name,\n            stackInfo.message,\n            stackInfo.url,\n            stackInfo.lineno,\n            frames,\n            options\n        );\n    },\n\n    _prepareFrames: function(stackInfo, options) {\n        var self = this;\n        var frames = [];\n        if (stackInfo.stack && stackInfo.stack.length) {\n            each(stackInfo.stack, function(i, stack) {\n                var frame = self._normalizeFrame(stack);\n                if (frame) {\n                    frames.push(frame);\n                }\n            });\n\n            // e.g. frames captured via captureMessage throw\n            if (options && options.trimHeadFrames) {\n                for (var j = 0; j < options.trimHeadFrames && j < frames.length; j++) {\n                    frames[j].in_app = false;\n                }\n            }\n        }\n        frames = frames.slice(0, this._globalOptions.stackTraceLimit);\n        return frames;\n    },\n\n\n    _normalizeFrame: function(frame) {\n        if (!frame.url) return;\n\n        // normalize the frames data\n        var normalized = {\n            filename:   frame.url,\n            lineno:     frame.line,\n            colno:      frame.column,\n            'function': frame.func || '?'\n        };\n\n        normalized.in_app = !( // determine if an exception came from outside of our app\n            // first we check the global includePaths list.\n            !!this._globalOptions.includePaths.test && !this._globalOptions.includePaths.test(normalized.filename) ||\n            // Now we check for fun, if the function name is Raven or TraceKit\n            /(Raven|TraceKit)\\./.test(normalized['function']) ||\n            // finally, we do a last ditch effort and check for raven.min.js\n            /raven\\.(min\\.)?js$/.test(normalized.filename)\n        );\n\n        return normalized;\n    },\n\n    _processException: function(type, message, fileurl, lineno, frames, options) {\n        var stacktrace;\n        if (!!this._globalOptions.ignoreErrors.test && this._globalOptions.ignoreErrors.test(message)) return;\n\n        message += '';\n\n        if (frames && frames.length) {\n            fileurl = frames[0].filename || fileurl;\n            // Sentry expects frames oldest to newest\n            // and JS sends them as newest to oldest\n            frames.reverse();\n            stacktrace = {frames: frames};\n        } else if (fileurl) {\n            stacktrace = {\n                frames: [{\n                    filename: fileurl,\n                    lineno: lineno,\n                    in_app: true\n                }]\n            };\n        }\n\n        if (!!this._globalOptions.ignoreUrls.test && this._globalOptions.ignoreUrls.test(fileurl)) return;\n        if (!!this._globalOptions.whitelistUrls.test && !this._globalOptions.whitelistUrls.test(fileurl)) return;\n\n        var data = objectMerge({\n            // sentry.interfaces.Exception\n            exception: {\n                values: [{\n                    type: type,\n                    value: message,\n                    stacktrace: stacktrace\n                }]\n            },\n            culprit: fileurl\n        }, options);\n\n        // Fire away!\n        this._send(data);\n    },\n\n    _trimPacket: function(data) {\n        // For now, we only want to truncate the two different messages\n        // but this could/should be expanded to just trim everything\n        var max = this._globalOptions.maxMessageLength;\n        if (data.message) {\n            data.message = truncate(data.message, max);\n        }\n        if (data.exception) {\n            var exception = data.exception.values[0];\n            exception.value = truncate(exception.value, max);\n        }\n\n        var request = data.request;\n        if (request) {\n            if (request.url) {\n                request.url = truncate(request.url, this._globalOptions.maxUrlLength);\n            }\n            if (request.Referer) {\n                request.Referer = truncate(request.Referer, this._globalOptions.maxUrlLength);\n            }\n        }\n\n        if (data.breadcrumbs && data.breadcrumbs.values)\n            this._trimBreadcrumbs(data.breadcrumbs);\n\n        return data;\n    },\n\n    /**\n     * Truncate breadcrumb values (right now just URLs)\n     */\n    _trimBreadcrumbs: function (breadcrumbs) {\n        // known breadcrumb properties with urls\n        // TODO: also consider arbitrary prop values that start with (https?)?://\n        var urlProps = ['to', 'from', 'url'],\n            urlProp,\n            crumb,\n            data;\n\n        for (var i = 0; i < breadcrumbs.values.length; ++i) {\n            crumb = breadcrumbs.values[i];\n            if (!crumb.hasOwnProperty('data') || !isObject(crumb.data) || objectFrozen(crumb.data))\n                continue;\n\n            data = objectMerge({}, crumb.data);\n            for (var j = 0; j < urlProps.length; ++j) {\n                urlProp = urlProps[j];\n                if (data.hasOwnProperty(urlProp)) {\n                    data[urlProp] = truncate(data[urlProp], this._globalOptions.maxUrlLength);\n                }\n            }\n            breadcrumbs.values[i].data = data;\n        }\n    },\n\n    _getHttpData: function() {\n        if (!this._hasNavigator && !this._hasDocument) return;\n        var httpData = {};\n\n        if (this._hasNavigator && _navigator.userAgent) {\n            httpData.headers = {\n              'User-Agent': navigator.userAgent\n            };\n        }\n\n        if (this._hasDocument) {\n            if (_document.location && _document.location.href) {\n                httpData.url = _document.location.href;\n            }\n            if (_document.referrer) {\n                if (!httpData.headers) httpData.headers = {};\n                httpData.headers.Referer = _document.referrer;\n            }\n        }\n\n        return httpData;\n    },\n\n    _resetBackoff: function() {\n        this._backoffDuration = 0;\n        this._backoffStart = null;\n    },\n\n    _shouldBackoff: function() {\n        return this._backoffDuration && now() - this._backoffStart < this._backoffDuration;\n    },\n\n    /**\n     * Returns true if the in-process data payload matches the signature\n     * of the previously-sent data\n     *\n     * NOTE: This has to be done at this level because TraceKit can generate\n     *       data from window.onerror WITHOUT an exception object (IE8, IE9,\n     *       other old browsers). This can take the form of an \"exception\"\n     *       data object with a single frame (derived from the onerror args).\n     */\n    _isRepeatData: function (current) {\n        var last = this._lastData;\n\n        if (!last ||\n            current.message !== last.message || // defined for captureMessage\n            current.culprit !== last.culprit)   // defined for captureException/onerror\n            return false;\n\n        // Stacktrace interface (i.e. from captureMessage)\n        if (current.stacktrace || last.stacktrace) {\n            return isSameStacktrace(current.stacktrace, last.stacktrace);\n        }\n        // Exception interface (i.e. from captureException/onerror)\n        else if (current.exception || last.exception) {\n            return isSameException(current.exception, last.exception);\n        }\n\n        return true;\n    },\n\n    _setBackoffState: function(request) {\n        // If we are already in a backoff state, don't change anything\n        if (this._shouldBackoff()) {\n            return;\n        }\n\n        var status = request.status;\n\n        // 400 - project_id doesn't exist or some other fatal\n        // 401 - invalid/revoked dsn\n        // 429 - too many requests\n        if (!(status === 400 || status === 401 || status === 429))\n            return;\n\n        var retry;\n        try {\n            // If Retry-After is not in Access-Control-Expose-Headers, most\n            // browsers will throw an exception trying to access it\n            retry = request.getResponseHeader('Retry-After');\n            retry = parseInt(retry, 10) * 1000; // Retry-After is returned in seconds\n        } catch (e) {\n            /* eslint no-empty:0 */\n        }\n\n\n        this._backoffDuration = retry\n            // If Sentry server returned a Retry-After value, use it\n            ? retry\n            // Otherwise, double the last backoff duration (starts at 1 sec)\n            : this._backoffDuration * 2 || 1000;\n\n        this._backoffStart = now();\n    },\n\n    _send: function(data) {\n        var globalOptions = this._globalOptions;\n\n        var baseData = {\n            project: this._globalProject,\n            logger: globalOptions.logger,\n            platform: 'javascript'\n        }, httpData = this._getHttpData();\n\n        if (httpData) {\n            baseData.request = httpData;\n        }\n\n        // HACK: delete `trimHeadFrames` to prevent from appearing in outbound payload\n        if (data.trimHeadFrames) delete data.trimHeadFrames;\n\n        data = objectMerge(baseData, data);\n\n        // Merge in the tags and extra separately since objectMerge doesn't handle a deep merge\n        data.tags = objectMerge(objectMerge({}, this._globalContext.tags), data.tags);\n        data.extra = objectMerge(objectMerge({}, this._globalContext.extra), data.extra);\n\n        // Send along our own collected metadata with extra\n        data.extra['session:duration'] = now() - this._startTime;\n\n        if (this._breadcrumbs && this._breadcrumbs.length > 0) {\n            // intentionally make shallow copy so that additions\n            // to breadcrumbs aren't accidentally sent in this request\n            data.breadcrumbs = {\n                values: [].slice.call(this._breadcrumbs, 0)\n            };\n        }\n\n        // If there are no tags/extra, strip the key from the payload alltogther.\n        if (isEmptyObject(data.tags)) delete data.tags;\n\n        if (this._globalContext.user) {\n            // sentry.interfaces.User\n            data.user = this._globalContext.user;\n        }\n\n        // Include the environment if it's defined in globalOptions\n        if (globalOptions.environment) data.environment = globalOptions.environment;\n\n        // Include the release if it's defined in globalOptions\n        if (globalOptions.release) data.release = globalOptions.release;\n\n        // Include server_name if it's defined in globalOptions\n        if (globalOptions.serverName) data.server_name = globalOptions.serverName;\n\n        if (isFunction(globalOptions.dataCallback)) {\n            data = globalOptions.dataCallback(data) || data;\n        }\n\n        // Why??????????\n        if (!data || isEmptyObject(data)) {\n            return;\n        }\n\n        // Check if the request should be filtered or not\n        if (isFunction(globalOptions.shouldSendCallback) && !globalOptions.shouldSendCallback(data)) {\n            return;\n        }\n\n        // Backoff state: Sentry server previously responded w/ an error (e.g. 429 - too many requests),\n        // so drop requests until \"cool-off\" period has elapsed.\n        if (this._shouldBackoff()) {\n            this._logDebug('warn', 'Raven dropped error due to backoff: ', data);\n            return;\n        }\n\n        if (typeof globalOptions.sampleRate === 'number') {\n            if (Math.random() < globalOptions.sampleRate) {\n                this._sendProcessedPayload(data);\n            }\n        } else {\n            this._sendProcessedPayload(data);\n        }\n    },\n\n    _getUuid: function () {\n      return uuid4();\n    },\n\n    _sendProcessedPayload: function(data, callback) {\n        var self = this;\n        var globalOptions = this._globalOptions;\n\n        if (!this.isSetup()) return;\n\n        // Send along an event_id if not explicitly passed.\n        // This event_id can be used to reference the error within Sentry itself.\n        // Set lastEventId after we know the error should actually be sent\n        this._lastEventId = data.event_id || (data.event_id = this._getUuid());\n\n        // Try and clean up the packet before sending by truncating long values\n        data = this._trimPacket(data);\n\n        // ideally duplicate error testing should occur *before* dataCallback/shouldSendCallback,\n        // but this would require copying an un-truncated copy of the data packet, which can be\n        // arbitrarily deep (extra_data) -- could be worthwhile? will revisit\n        if (!this._globalOptions.allowDuplicates && this._isRepeatData(data)) {\n            this._logDebug('warn', 'Raven dropped repeat event: ', data);\n            return;\n        }\n\n        // Store outbound payload after trim\n        this._lastData = data;\n\n        this._logDebug('debug', 'Raven about to send:', data);\n\n        var auth = {\n            sentry_version: '7',\n            sentry_client: 'raven-js/' + this.VERSION,\n            sentry_key: this._globalKey\n        };\n        if (this._globalSecret) {\n            auth.sentry_secret = this._globalSecret;\n        }\n\n        var exception = data.exception && data.exception.values[0];\n        this.captureBreadcrumb({\n            category: 'sentry',\n            message: exception\n                ? (exception.type ? exception.type + ': ' : '') + exception.value\n                : data.message,\n            event_id: data.event_id,\n            level: data.level || 'error' // presume error unless specified\n        });\n\n        var url = this._globalEndpoint;\n        (globalOptions.transport || this._makeRequest).call(this, {\n            url: url,\n            auth: auth,\n            data: data,\n            options: globalOptions,\n            onSuccess: function success() {\n                self._resetBackoff();\n\n                self._triggerEvent('success', {\n                    data: data,\n                    src: url\n                });\n                callback && callback();\n            },\n            onError: function failure(error) {\n                self._logDebug('error', 'Raven transport failed to send: ', error);\n\n                if (error.request) {\n                    self._setBackoffState(error.request);\n                }\n\n                self._triggerEvent('failure', {\n                    data: data,\n                    src: url\n                });\n                error = error || new Error('Raven send failed (no additional details provided)');\n                callback && callback(error);\n            }\n        });\n    },\n\n    _makeRequest: function(opts) {\n        var request = new XMLHttpRequest();\n\n        // if browser doesn't support CORS (e.g. IE7), we are out of luck\n        var hasCORS =\n            'withCredentials' in request ||\n            typeof XDomainRequest !== 'undefined';\n\n        if (!hasCORS) return;\n\n        var url = opts.url;\n\n        if ('withCredentials' in request) {\n            request.onreadystatechange = function () {\n                if (request.readyState !== 4) {\n                    return;\n                } else if (request.status === 200) {\n                    opts.onSuccess && opts.onSuccess();\n                } else if (opts.onError) {\n                    var err = new Error('Sentry error code: ' + request.status);\n                    err.request = request;\n                    opts.onError(err);\n                }\n            };\n        } else {\n            request = new XDomainRequest();\n            // xdomainrequest cannot go http -> https (or vice versa),\n            // so always use protocol relative\n            url = url.replace(/^https?:/, '');\n\n            // onreadystatechange not supported by XDomainRequest\n            if (opts.onSuccess) {\n                request.onload = opts.onSuccess;\n            }\n            if (opts.onError) {\n                request.onerror = function () {\n                    var err = new Error('Sentry error code: XDomainRequest');\n                    err.request = request;\n                    opts.onError(err);\n                }\n            }\n        }\n\n        // NOTE: auth is intentionally sent as part of query string (NOT as custom\n        //       HTTP header) so as to avoid preflight CORS requests\n        request.open('POST', url + '?' + urlencode(opts.auth));\n        request.send(stringify(opts.data));\n    },\n\n    _logDebug: function(level) {\n        if (this._originalConsoleMethods[level] && this.debug) {\n            // In IE<10 console methods do not have their own 'apply' method\n            Function.prototype.apply.call(\n                this._originalConsoleMethods[level],\n                this._originalConsole,\n                [].slice.call(arguments, 1)\n            );\n        }\n    },\n\n    _mergeContext: function(key, context) {\n        if (isUndefined(context)) {\n            delete this._globalContext[key];\n        } else {\n            this._globalContext[key] = objectMerge(this._globalContext[key] || {}, context);\n        }\n    }\n};\n\n/*------------------------------------------------\n * utils\n *\n * conditionally exported for test via Raven.utils\n =================================================\n */\nvar objectPrototype = Object.prototype;\n\nfunction isUndefined(what) {\n    return what === void 0;\n}\n\nfunction isFunction(what) {\n    return typeof what === 'function';\n}\n\nfunction isString(what) {\n    return objectPrototype.toString.call(what) === '[object String]';\n}\n\n\nfunction isEmptyObject(what) {\n    for (var _ in what) return false;  // eslint-disable-line guard-for-in, no-unused-vars\n    return true;\n}\n\nfunction each(obj, callback) {\n    var i, j;\n\n    if (isUndefined(obj.length)) {\n        for (i in obj) {\n            if (hasKey(obj, i)) {\n                callback.call(null, i, obj[i]);\n            }\n        }\n    } else {\n        j = obj.length;\n        if (j) {\n            for (i = 0; i < j; i++) {\n                callback.call(null, i, obj[i]);\n            }\n        }\n    }\n}\n\nfunction objectMerge(obj1, obj2) {\n    if (!obj2) {\n        return obj1;\n    }\n    each(obj2, function(key, value){\n        obj1[key] = value;\n    });\n    return obj1;\n}\n\n/**\n * This function is only used for react-native.\n * react-native freezes object that have already been sent over the\n * js bridge. We need this function in order to check if the object is frozen.\n * So it's ok that objectFrozen returns false if Object.isFrozen is not\n * supported because it's not relevant for other \"platforms\". See related issue:\n * https://github.com/getsentry/react-native-sentry/issues/57\n */\nfunction objectFrozen(obj) {\n    if (!Object.isFrozen) {\n        return false;\n    }\n    return Object.isFrozen(obj);\n}\n\nfunction truncate(str, max) {\n    return !max || str.length <= max ? str : str.substr(0, max) + '\\u2026';\n}\n\n/**\n * hasKey, a better form of hasOwnProperty\n * Example: hasKey(MainHostObject, property) === true/false\n *\n * @param {Object} host object to check property\n * @param {string} key to check\n */\nfunction hasKey(object, key) {\n    return objectPrototype.hasOwnProperty.call(object, key);\n}\n\nfunction joinRegExp(patterns) {\n    // Combine an array of regular expressions and strings into one large regexp\n    // Be mad.\n    var sources = [],\n        i = 0, len = patterns.length,\n        pattern;\n\n    for (; i < len; i++) {\n        pattern = patterns[i];\n        if (isString(pattern)) {\n            // If it's a string, we need to escape it\n            // Taken from: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\n            sources.push(pattern.replace(/([.*+?^=!:${}()|\\[\\]\\/\\\\])/g, '\\\\$1'));\n        } else if (pattern && pattern.source) {\n            // If it's a regexp already, we want to extract the source\n            sources.push(pattern.source);\n        }\n        // Intentionally skip other cases\n    }\n    return new RegExp(sources.join('|'), 'i');\n}\n\nfunction urlencode(o) {\n    var pairs = [];\n    each(o, function(key, value) {\n        pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));\n    });\n    return pairs.join('&');\n}\n\n// borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n// intentionally using regex and not <a/> href parsing trick because React Native and other\n// environments where DOM might not be available\nfunction parseUrl(url) {\n    var match = url.match(/^(([^:\\/?#]+):)?(\\/\\/([^\\/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n    if (!match) return {};\n\n    // coerce to undefined values to empty string so we don't get 'undefined'\n    var query = match[6] || '';\n    var fragment = match[8] || '';\n    return {\n        protocol: match[2],\n        host: match[4],\n        path: match[5],\n        relative: match[5] + query + fragment // everything minus origin\n    };\n}\nfunction uuid4() {\n    var crypto = _window.crypto || _window.msCrypto;\n\n    if (!isUndefined(crypto) && crypto.getRandomValues) {\n        // Use window.crypto API if available\n        var arr = new Uint16Array(8);\n        crypto.getRandomValues(arr);\n\n        // set 4 in byte 7\n        arr[3] = arr[3] & 0xFFF | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        arr[4] = arr[4] & 0x3FFF | 0x8000;\n\n        var pad = function(num) {\n            var v = num.toString(16);\n            while (v.length < 4) {\n                v = '0' + v;\n            }\n            return v;\n        };\n\n        return pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) +\n        pad(arr[5]) + pad(arr[6]) + pad(arr[7]);\n    } else {\n        // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n        return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\n            var r = Math.random()*16|0,\n                v = c === 'x' ? r : r&0x3|0x8;\n            return v.toString(16);\n        });\n    }\n}\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @param elem\n * @returns {string}\n */\nfunction htmlTreeAsString(elem) {\n    /* eslint no-extra-parens:0*/\n    var MAX_TRAVERSE_HEIGHT = 5,\n        MAX_OUTPUT_LEN = 80,\n        out = [],\n        height = 0,\n        len = 0,\n        separator = ' > ',\n        sepLength = separator.length,\n        nextStr;\n\n    while (elem && height++ < MAX_TRAVERSE_HEIGHT) {\n\n        nextStr = htmlElementAsString(elem);\n        // bail out if\n        // - nextStr is the 'html' element\n        // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n        //   (ignore this limit if we are on the first iteration)\n        if (nextStr === 'html' || height > 1 && len + (out.length * sepLength) + nextStr.length >= MAX_OUTPUT_LEN) {\n            break;\n        }\n\n        out.push(nextStr);\n\n        len += nextStr.length;\n        elem = elem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @param HTMLElement\n * @returns {string}\n */\nfunction htmlElementAsString(elem) {\n    var out = [],\n        className,\n        classes,\n        key,\n        attr,\n        i;\n\n    if (!elem || !elem.tagName) {\n        return '';\n    }\n\n    out.push(elem.tagName.toLowerCase());\n    if (elem.id) {\n        out.push('#' + elem.id);\n    }\n\n    className = elem.className;\n    if (className && isString(className)) {\n        classes = className.split(/\\s+/);\n        for (i = 0; i < classes.length; i++) {\n            out.push('.' + classes[i]);\n        }\n    }\n    var attrWhitelist = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < attrWhitelist.length; i++) {\n        key = attrWhitelist[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push('[' + key + '=\"' + attr + '\"]');\n        }\n    }\n    return out.join('');\n}\n\n/**\n * Returns true if either a OR b is truthy, but not both\n */\nfunction isOnlyOneTruthy(a, b) {\n    return !!(!!a ^ !!b);\n}\n\n/**\n * Returns true if the two input exception interfaces have the same content\n */\nfunction isSameException(ex1, ex2) {\n    if (isOnlyOneTruthy(ex1, ex2))\n        return false;\n\n    ex1 = ex1.values[0];\n    ex2 = ex2.values[0];\n\n    if (ex1.type !== ex2.type ||\n        ex1.value !== ex2.value)\n        return false;\n\n    return isSameStacktrace(ex1.stacktrace, ex2.stacktrace);\n}\n\n/**\n * Returns true if the two input stack trace interfaces have the same content\n */\nfunction isSameStacktrace(stack1, stack2) {\n    if (isOnlyOneTruthy(stack1, stack2))\n        return false;\n\n    var frames1 = stack1.frames;\n    var frames2 = stack2.frames;\n\n    // Exit early if frame count differs\n    if (frames1.length !== frames2.length)\n        return false;\n\n    // Iterate through every frame; bail out if anything differs\n    var a, b;\n    for (var i = 0; i < frames1.length; i++) {\n        a = frames1[i];\n        b = frames2[i];\n        if (a.filename !== b.filename ||\n            a.lineno !== b.lineno ||\n            a.colno !== b.colno ||\n            a['function'] !== b['function'])\n            return false;\n    }\n    return true;\n}\n\n/**\n * Polyfill a method\n * @param obj object e.g. `document`\n * @param name method name present on object e.g. `addEventListener`\n * @param replacement replacement function\n * @param track {optional} record instrumentation to an array\n */\nfunction fill(obj, name, replacement, track) {\n    var orig = obj[name];\n    obj[name] = replacement(orig);\n    if (track) {\n        track.push([obj, name, orig]);\n    }\n}\n\nif (typeof __DEV__ !== 'undefined' && __DEV__) {\n    Raven.utils = {\n        isUndefined: isUndefined,\n        isFunction: isFunction,\n        isString: isString,\n        isObject: isObject,\n        isEmptyObject: isEmptyObject,\n        isError: isError,\n        each: each,\n        objectMerge: objectMerge,\n        truncate: truncate,\n        hasKey: hasKey,\n        joinRegExp: joinRegExp,\n        urlencode: urlencode,\n        uuid4: uuid4,\n        htmlTreeAsString: htmlTreeAsString,\n        htmlElementAsString: htmlElementAsString,\n        parseUrl: parseUrl,\n        fill: fill\n    };\n};\n\n// Deprecations\nRaven.prototype.setUser = Raven.prototype.setUserContext;\nRaven.prototype.setReleaseContext = Raven.prototype.setRelease;\n\nmodule.exports = Raven;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(11)))\n\n/***/ }),\n\n/***/ 236:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {\n\nvar utils = __webpack_require__(140);\n\n/*\n TraceKit - Cross brower stack traces\n\n This was originally forked from github.com/occ/TraceKit, but has since been\n largely re-written and is now maintained as part of raven-js.  Tests for\n this are in test/vendor.\n\n MIT license\n*/\n\nvar TraceKit = {\n    collectWindowErrors: true,\n    debug: false\n};\n\n// This is to be defensive in environments where window does not exist (see https://github.com/getsentry/raven-js/pull/785)\nvar _window = typeof window !== 'undefined' ? window\n            : typeof global !== 'undefined' ? global\n            : typeof self !== 'undefined' ? self\n            : {};\n\n// global reference to slice\nvar _slice = [].slice;\nvar UNKNOWN_FUNCTION = '?';\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\nvar ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;\n\nfunction getLocationHref() {\n    if (typeof document === 'undefined' || typeof document.location === 'undefined')\n        return '';\n\n    return document.location.href;\n}\n\n\n/**\n * TraceKit.report: cross-browser processing of unhandled exceptions\n *\n * Syntax:\n *   TraceKit.report.subscribe(function(stackInfo) { ... })\n *   TraceKit.report.unsubscribe(function(stackInfo) { ... })\n *   TraceKit.report(exception)\n *   try { ...code... } catch(ex) { TraceKit.report(ex); }\n *\n * Supports:\n *   - Firefox: full stack trace with line numbers, plus column number\n *              on top frame; column number is not guaranteed\n *   - Opera:   full stack trace with line and column numbers\n *   - Chrome:  full stack trace with line and column numbers\n *   - Safari:  line and column number for the top frame only; some frames\n *              may be missing, and column number is not guaranteed\n *   - IE:      line and column number for the top frame only; some frames\n *              may be missing, and column number is not guaranteed\n *\n * In theory, TraceKit should work on all of the following versions:\n *   - IE5.5+ (only 8.0 tested)\n *   - Firefox 0.9+ (only 3.5+ tested)\n *   - Opera 7+ (only 10.50 tested; versions 9 and earlier may require\n *     Exceptions Have Stacktrace to be enabled in opera:config)\n *   - Safari 3+ (only 4+ tested)\n *   - Chrome 1+ (only 5+ tested)\n *   - Konqueror 3.5+ (untested)\n *\n * Requires TraceKit.computeStackTrace.\n *\n * Tries to catch all unhandled exceptions and report them to the\n * subscribed handlers. Please note that TraceKit.report will rethrow the\n * exception. This is REQUIRED in order to get a useful stack trace in IE.\n * If the exception does not reach the top of the browser, you will only\n * get a stack trace from the point where TraceKit.report was called.\n *\n * Handlers receive a stackInfo object as described in the\n * TraceKit.computeStackTrace docs.\n */\nTraceKit.report = (function reportModuleWrapper() {\n    var handlers = [],\n        lastArgs = null,\n        lastException = null,\n        lastExceptionStack = null;\n\n    /**\n     * Add a crash handler.\n     * @param {Function} handler\n     */\n    function subscribe(handler) {\n        installGlobalHandler();\n        handlers.push(handler);\n    }\n\n    /**\n     * Remove a crash handler.\n     * @param {Function} handler\n     */\n    function unsubscribe(handler) {\n        for (var i = handlers.length - 1; i >= 0; --i) {\n            if (handlers[i] === handler) {\n                handlers.splice(i, 1);\n            }\n        }\n    }\n\n    /**\n     * Remove all crash handlers.\n     */\n    function unsubscribeAll() {\n        uninstallGlobalHandler();\n        handlers = [];\n    }\n\n    /**\n     * Dispatch stack information to all handlers.\n     * @param {Object.<string, *>} stack\n     */\n    function notifyHandlers(stack, isWindowError) {\n        var exception = null;\n        if (isWindowError && !TraceKit.collectWindowErrors) {\n          return;\n        }\n        for (var i in handlers) {\n            if (handlers.hasOwnProperty(i)) {\n                try {\n                    handlers[i].apply(null, [stack].concat(_slice.call(arguments, 2)));\n                } catch (inner) {\n                    exception = inner;\n                }\n            }\n        }\n\n        if (exception) {\n            throw exception;\n        }\n    }\n\n    var _oldOnerrorHandler, _onErrorHandlerInstalled;\n\n    /**\n     * Ensures all global unhandled exceptions are recorded.\n     * Supported by Gecko and IE.\n     * @param {string} message Error message.\n     * @param {string} url URL of script that generated the exception.\n     * @param {(number|string)} lineNo The line number at which the error\n     * occurred.\n     * @param {?(number|string)} colNo The column number at which the error\n     * occurred.\n     * @param {?Error} ex The actual Error object.\n     */\n    function traceKitWindowOnError(message, url, lineNo, colNo, ex) {\n        var stack = null;\n\n        if (lastExceptionStack) {\n            TraceKit.computeStackTrace.augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);\n            processLastException();\n        } else if (ex && utils.isError(ex)) {\n            // non-string `ex` arg; attempt to extract stack trace\n\n            // New chrome and blink send along a real error object\n            // Let's just report that like a normal error.\n            // See: https://mikewest.org/2013/08/debugging-runtime-errors-with-window-onerror\n            stack = TraceKit.computeStackTrace(ex);\n            notifyHandlers(stack, true);\n        } else {\n            var location = {\n                'url': url,\n                'line': lineNo,\n                'column': colNo\n            };\n\n            var name = undefined;\n            var msg = message; // must be new var or will modify original `arguments`\n            var groups;\n            if ({}.toString.call(message) === '[object String]') {\n                var groups = message.match(ERROR_TYPES_RE);\n                if (groups) {\n                    name = groups[1];\n                    msg = groups[2];\n                }\n            }\n\n            location.func = UNKNOWN_FUNCTION;\n\n            stack = {\n                'name': name,\n                'message': msg,\n                'url': getLocationHref(),\n                'stack': [location]\n            };\n            notifyHandlers(stack, true);\n        }\n\n        if (_oldOnerrorHandler) {\n            return _oldOnerrorHandler.apply(this, arguments);\n        }\n\n        return false;\n    }\n\n    function installGlobalHandler ()\n    {\n        if (_onErrorHandlerInstalled) {\n            return;\n        }\n        _oldOnerrorHandler = _window.onerror;\n        _window.onerror = traceKitWindowOnError;\n        _onErrorHandlerInstalled = true;\n    }\n\n    function uninstallGlobalHandler ()\n    {\n        if (!_onErrorHandlerInstalled) {\n            return;\n        }\n        _window.onerror = _oldOnerrorHandler;\n        _onErrorHandlerInstalled = false;\n        _oldOnerrorHandler = undefined;\n    }\n\n    function processLastException() {\n        var _lastExceptionStack = lastExceptionStack,\n            _lastArgs = lastArgs;\n        lastArgs = null;\n        lastExceptionStack = null;\n        lastException = null;\n        notifyHandlers.apply(null, [_lastExceptionStack, false].concat(_lastArgs));\n    }\n\n    /**\n     * Reports an unhandled Error to TraceKit.\n     * @param {Error} ex\n     * @param {?boolean} rethrow If false, do not re-throw the exception.\n     * Only used for window.onerror to not cause an infinite loop of\n     * rethrowing.\n     */\n    function report(ex, rethrow) {\n        var args = _slice.call(arguments, 1);\n        if (lastExceptionStack) {\n            if (lastException === ex) {\n                return; // already caught by an inner catch block, ignore\n            } else {\n              processLastException();\n            }\n        }\n\n        var stack = TraceKit.computeStackTrace(ex);\n        lastExceptionStack = stack;\n        lastException = ex;\n        lastArgs = args;\n\n        // If the stack trace is incomplete, wait for 2 seconds for\n        // slow slow IE to see if onerror occurs or not before reporting\n        // this exception; otherwise, we will end up with an incomplete\n        // stack trace\n        setTimeout(function () {\n            if (lastException === ex) {\n                processLastException();\n            }\n        }, (stack.incomplete ? 2000 : 0));\n\n        if (rethrow !== false) {\n            throw ex; // re-throw to propagate to the top level (and cause window.onerror)\n        }\n    }\n\n    report.subscribe = subscribe;\n    report.unsubscribe = unsubscribe;\n    report.uninstall = unsubscribeAll;\n    return report;\n}());\n\n/**\n * TraceKit.computeStackTrace: cross-browser stack traces in JavaScript\n *\n * Syntax:\n *   s = TraceKit.computeStackTrace(exception) // consider using TraceKit.report instead (see below)\n * Returns:\n *   s.name              - exception name\n *   s.message           - exception message\n *   s.stack[i].url      - JavaScript or HTML file URL\n *   s.stack[i].func     - function name, or empty for anonymous functions (if guessing did not work)\n *   s.stack[i].args     - arguments passed to the function, if known\n *   s.stack[i].line     - line number, if known\n *   s.stack[i].column   - column number, if known\n *\n * Supports:\n *   - Firefox:  full stack trace with line numbers and unreliable column\n *               number on top frame\n *   - Opera 10: full stack trace with line and column numbers\n *   - Opera 9-: full stack trace with line numbers\n *   - Chrome:   full stack trace with line and column numbers\n *   - Safari:   line and column number for the topmost stacktrace element\n *               only\n *   - IE:       no line numbers whatsoever\n *\n * Tries to guess names of anonymous functions by looking for assignments\n * in the source code. In IE and Safari, we have to guess source file names\n * by searching for function bodies inside all page scripts. This will not\n * work for scripts that are loaded cross-domain.\n * Here be dragons: some function names may be guessed incorrectly, and\n * duplicate functions may be mismatched.\n *\n * TraceKit.computeStackTrace should only be used for tracing purposes.\n * Logging of unhandled exceptions should be done with TraceKit.report,\n * which builds on top of TraceKit.computeStackTrace and provides better\n * IE support by utilizing the window.onerror event to retrieve information\n * about the top of the stack.\n *\n * Note: In IE and Safari, no stack trace is recorded on the Error object,\n * so computeStackTrace instead walks its *own* chain of callers.\n * This means that:\n *  * in Safari, some methods may be missing from the stack trace;\n *  * in IE, the topmost function in the stack trace will always be the\n *    caller of computeStackTrace.\n *\n * This is okay for tracing (because you are likely to be calling\n * computeStackTrace from the function you want to be the topmost element\n * of the stack trace anyway), but not okay for logging unhandled\n * exceptions (because your catch block will likely be far away from the\n * inner function that actually caused the exception).\n *\n */\nTraceKit.computeStackTrace = (function computeStackTraceWrapper() {\n    // Contents of Exception in various browsers.\n    //\n    // SAFARI:\n    // ex.message = Can't find variable: qq\n    // ex.line = 59\n    // ex.sourceId = 580238192\n    // ex.sourceURL = http://...\n    // ex.expressionBeginOffset = 96\n    // ex.expressionCaretOffset = 98\n    // ex.expressionEndOffset = 98\n    // ex.name = ReferenceError\n    //\n    // FIREFOX:\n    // ex.message = qq is not defined\n    // ex.fileName = http://...\n    // ex.lineNumber = 59\n    // ex.columnNumber = 69\n    // ex.stack = ...stack trace... (see the example below)\n    // ex.name = ReferenceError\n    //\n    // CHROME:\n    // ex.message = qq is not defined\n    // ex.name = ReferenceError\n    // ex.type = not_defined\n    // ex.arguments = ['aa']\n    // ex.stack = ...stack trace...\n    //\n    // INTERNET EXPLORER:\n    // ex.message = ...\n    // ex.name = ReferenceError\n    //\n    // OPERA:\n    // ex.message = ...message... (see the example below)\n    // ex.name = ReferenceError\n    // ex.opera#sourceloc = 11  (pretty much useless, duplicates the info in ex.message)\n    // ex.stacktrace = n/a; see 'opera:config#UserPrefs|Exceptions Have Stacktrace'\n\n    /**\n     * Computes stack trace information from the stack property.\n     * Chrome and Gecko use this property.\n     * @param {Error} ex\n     * @return {?Object.<string, *>} Stack trace information.\n     */\n    function computeStackTraceFromStackProp(ex) {\n        if (typeof ex.stack === 'undefined' || !ex.stack) return;\n\n        var chrome = /^\\s*at (.*?) ?\\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i,\n            gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i,\n            winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i,\n\n            // Used to additionally parse URL/line/column from eval frames\n            geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i,\n            chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/,\n\n            lines = ex.stack.split('\\n'),\n            stack = [],\n            submatch,\n            parts,\n            element,\n            reference = /^(.*) is undefined$/.exec(ex.message);\n\n        for (var i = 0, j = lines.length; i < j; ++i) {\n            if ((parts = chrome.exec(lines[i]))) {\n                var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n                var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n                if (isEval && (submatch = chromeEval.exec(parts[2]))) {\n                    // throw out eval line/column and use top-most line/column number\n                    parts[2] = submatch[1]; // url\n                    parts[3] = submatch[2]; // line\n                    parts[4] = submatch[3]; // column\n                }\n                element = {\n                    'url': !isNative ? parts[2] : null,\n                    'func': parts[1] || UNKNOWN_FUNCTION,\n                    'args': isNative ? [parts[2]] : [],\n                    'line': parts[3] ? +parts[3] : null,\n                    'column': parts[4] ? +parts[4] : null\n                };\n            } else if ( parts = winjs.exec(lines[i]) ) {\n                element = {\n                    'url': parts[2],\n                    'func': parts[1] || UNKNOWN_FUNCTION,\n                    'args': [],\n                    'line': +parts[3],\n                    'column': parts[4] ? +parts[4] : null\n                };\n            } else if ((parts = gecko.exec(lines[i]))) {\n                var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n                if (isEval && (submatch = geckoEval.exec(parts[3]))) {\n                    // throw out eval line/column and use top-most line number\n                    parts[3] = submatch[1];\n                    parts[4] = submatch[2];\n                    parts[5] = null; // no column when eval\n                } else if (i === 0 && !parts[5] && typeof ex.columnNumber !== 'undefined') {\n                    // FireFox uses this awesome columnNumber property for its top frame\n                    // Also note, Firefox's column number is 0-based and everything else expects 1-based,\n                    // so adding 1\n                    // NOTE: this hack doesn't work if top-most frame is eval\n                    stack[0].column = ex.columnNumber + 1;\n                }\n                element = {\n                    'url': parts[3],\n                    'func': parts[1] || UNKNOWN_FUNCTION,\n                    'args': parts[2] ? parts[2].split(',') : [],\n                    'line': parts[4] ? +parts[4] : null,\n                    'column': parts[5] ? +parts[5] : null\n                };\n            } else {\n                continue;\n            }\n\n            if (!element.func && element.line) {\n                element.func = UNKNOWN_FUNCTION;\n            }\n\n            stack.push(element);\n        }\n\n        if (!stack.length) {\n            return null;\n        }\n\n        return {\n            'name': ex.name,\n            'message': ex.message,\n            'url': getLocationHref(),\n            'stack': stack\n        };\n    }\n\n    /**\n     * Adds information about the first frame to incomplete stack traces.\n     * Safari and IE require this to get complete data on the first frame.\n     * @param {Object.<string, *>} stackInfo Stack trace information from\n     * one of the compute* methods.\n     * @param {string} url The URL of the script that caused an error.\n     * @param {(number|string)} lineNo The line number of the script that\n     * caused an error.\n     * @param {string=} message The error generated by the browser, which\n     * hopefully contains the name of the object that caused the error.\n     * @return {boolean} Whether or not the stack information was\n     * augmented.\n     */\n    function augmentStackTraceWithInitialElement(stackInfo, url, lineNo, message) {\n        var initial = {\n            'url': url,\n            'line': lineNo\n        };\n\n        if (initial.url && initial.line) {\n            stackInfo.incomplete = false;\n\n            if (!initial.func) {\n                initial.func = UNKNOWN_FUNCTION;\n            }\n\n            if (stackInfo.stack.length > 0) {\n                if (stackInfo.stack[0].url === initial.url) {\n                    if (stackInfo.stack[0].line === initial.line) {\n                        return false; // already in stack trace\n                    } else if (!stackInfo.stack[0].line && stackInfo.stack[0].func === initial.func) {\n                        stackInfo.stack[0].line = initial.line;\n                        return false;\n                    }\n                }\n            }\n\n            stackInfo.stack.unshift(initial);\n            stackInfo.partial = true;\n            return true;\n        } else {\n            stackInfo.incomplete = true;\n        }\n\n        return false;\n    }\n\n    /**\n     * Computes stack trace information by walking the arguments.caller\n     * chain at the time the exception occurred. This will cause earlier\n     * frames to be missed but is the only way to get any stack trace in\n     * Safari and IE. The top frame is restored by\n     * {@link augmentStackTraceWithInitialElement}.\n     * @param {Error} ex\n     * @return {?Object.<string, *>} Stack trace information.\n     */\n    function computeStackTraceByWalkingCallerChain(ex, depth) {\n        var functionName = /function\\s+([_$a-zA-Z\\xA0-\\uFFFF][_$a-zA-Z0-9\\xA0-\\uFFFF]*)?\\s*\\(/i,\n            stack = [],\n            funcs = {},\n            recursion = false,\n            parts,\n            item,\n            source;\n\n        for (var curr = computeStackTraceByWalkingCallerChain.caller; curr && !recursion; curr = curr.caller) {\n            if (curr === computeStackTrace || curr === TraceKit.report) {\n                // console.log('skipping internal function');\n                continue;\n            }\n\n            item = {\n                'url': null,\n                'func': UNKNOWN_FUNCTION,\n                'line': null,\n                'column': null\n            };\n\n            if (curr.name) {\n                item.func = curr.name;\n            } else if ((parts = functionName.exec(curr.toString()))) {\n                item.func = parts[1];\n            }\n\n            if (typeof item.func === 'undefined') {\n              try {\n                item.func = parts.input.substring(0, parts.input.indexOf('{'));\n              } catch (e) { }\n            }\n\n            if (funcs['' + curr]) {\n                recursion = true;\n            }else{\n                funcs['' + curr] = true;\n            }\n\n            stack.push(item);\n        }\n\n        if (depth) {\n            // console.log('depth is ' + depth);\n            // console.log('stack is ' + stack.length);\n            stack.splice(0, depth);\n        }\n\n        var result = {\n            'name': ex.name,\n            'message': ex.message,\n            'url': getLocationHref(),\n            'stack': stack\n        };\n        augmentStackTraceWithInitialElement(result, ex.sourceURL || ex.fileName, ex.line || ex.lineNumber, ex.message || ex.description);\n        return result;\n    }\n\n    /**\n     * Computes a stack trace for an exception.\n     * @param {Error} ex\n     * @param {(string|number)=} depth\n     */\n    function computeStackTrace(ex, depth) {\n        var stack = null;\n        depth = (depth == null ? 0 : +depth);\n\n        try {\n            stack = computeStackTraceFromStackProp(ex);\n            if (stack) {\n                return stack;\n            }\n        } catch (e) {\n            if (TraceKit.debug) {\n                throw e;\n            }\n        }\n\n        try {\n            stack = computeStackTraceByWalkingCallerChain(ex, depth + 1);\n            if (stack) {\n                return stack;\n            }\n        } catch (e) {\n            if (TraceKit.debug) {\n                throw e;\n            }\n        }\n        return {\n            'name': ex.name,\n            'message': ex.message,\n            'url': getLocationHref()\n        };\n    }\n\n    computeStackTrace.augmentStackTraceWithInitialElement = augmentStackTraceWithInitialElement;\n    computeStackTrace.computeStackTraceFromStackProp = computeStackTraceFromStackProp;\n\n    return computeStackTrace;\n}());\n\nmodule.exports = TraceKit;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(11)))\n\n/***/ }),\n\n/***/ 237:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/*\n json-stringify-safe\n Like JSON.stringify, but doesn't throw on circular references.\n\n Originally forked from https://github.com/isaacs/json-stringify-safe\n version 5.0.1 on 3/8/2017 and modified for IE8 compatibility.\n Tests for this are in test/vendor.\n\n ISC license: https://github.com/isaacs/json-stringify-safe/blob/master/LICENSE\n*/\n\nexports = module.exports = stringify\nexports.getSerialize = serializer\n\nfunction indexOf(haystack, needle) {\n  for (var i = 0; i < haystack.length; ++i) {\n    if (haystack[i] === needle) return i;\n  }\n  return -1;\n}\n\nfunction stringify(obj, replacer, spaces, cycleReplacer) {\n  return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces)\n}\n\nfunction serializer(replacer, cycleReplacer) {\n  var stack = [], keys = []\n\n  if (cycleReplacer == null) cycleReplacer = function(key, value) {\n    if (stack[0] === value) return '[Circular ~]'\n    return '[Circular ~.' + keys.slice(0, indexOf(stack, value)).join('.') + ']'\n  }\n\n  return function(key, value) {\n    if (stack.length > 0) {\n      var thisPos = indexOf(stack, this);\n      ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)\n      ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)\n      if (~indexOf(stack, value)) value = cycleReplacer.call(this, key, value)\n    }\n    else stack.push(value)\n\n    return replacer == null ? value : replacer.call(this, key, value)\n  }\n}\n\n\n/***/ }),\n\n/***/ 238:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction RavenConfigError(message) {\n    this.name = 'RavenConfigError';\n    this.message = message;\n}\nRavenConfigError.prototype = new Error();\nRavenConfigError.prototype.constructor = RavenConfigError;\n\nmodule.exports = RavenConfigError;\n\n\n/***/ }),\n\n/***/ 239:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar wrapMethod = function(console, level, callback) {\n    var originalConsoleLevel = console[level];\n    var originalConsole = console;\n\n    if (!(level in console)) {\n        return;\n    }\n\n    var sentryLevel = level === 'warn'\n        ? 'warning'\n        : level;\n\n    console[level] = function () {\n        var args = [].slice.call(arguments);\n\n        var msg = '' + args.join(' ');\n        var data = {level: sentryLevel, logger: 'console', extra: {'arguments': args}};\n        callback && callback(msg, data);\n\n        // this fails for some browsers. :(\n        if (originalConsoleLevel) {\n            // IE9 doesn't allow calling apply on console functions directly\n            // See: https://stackoverflow.com/questions/5472938/does-ie9-support-console-log-and-is-it-a-real-function#answer-5473193\n            Function.prototype.apply.call(\n                originalConsoleLevel,\n                originalConsole,\n                args\n            );\n        }\n    };\n};\n\nmodule.exports = {\n    wrapMethod: wrapMethod\n};\n\n\n/***/ }),\n\n/***/ 240:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar map = {\n\t\"./ru\": 100,\n\t\"./ru.js\": 100\n};\nfunction webpackContext(req) {\n\treturn __webpack_require__(webpackContextResolve(req));\n};\nfunction webpackContextResolve(req) {\n\tvar id = map[req];\n\tif(!(id + 1)) // check for number or string\n\t\tthrow new Error(\"Cannot find module '\" + req + \"'.\");\n\treturn id;\n};\nwebpackContext.keys = function webpackContextKeys() {\n\treturn Object.keys(map);\n};\nwebpackContext.resolve = webpackContextResolve;\nmodule.exports = webpackContext;\nwebpackContext.id = 240;\n\n/***/ }),\n\n/***/ 241:\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/**\n * Expose `Emitter`.\n */\n\nif (true) {\n  module.exports = Emitter;\n}\n\n/**\n * Initialize a new `Emitter`.\n *\n * @api public\n */\n\nfunction Emitter(obj) {\n  if (obj) return mixin(obj);\n};\n\n/**\n * Mixin the emitter properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in Emitter.prototype) {\n    obj[key] = Emitter.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Listen on the given `event` with `fn`.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.on =\nEmitter.prototype.addEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\n    .push(fn);\n  return this;\n};\n\n/**\n * Adds an `event` listener that will be invoked a single\n * time then automatically removed.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.once = function(event, fn){\n  function on() {\n    this.off(event, on);\n    fn.apply(this, arguments);\n  }\n\n  on.fn = fn;\n  this.on(event, on);\n  return this;\n};\n\n/**\n * Remove the given callback for `event` or all\n * registered callbacks.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.off =\nEmitter.prototype.removeListener =\nEmitter.prototype.removeAllListeners =\nEmitter.prototype.removeEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n\n  // all\n  if (0 == arguments.length) {\n    this._callbacks = {};\n    return this;\n  }\n\n  // specific event\n  var callbacks = this._callbacks['$' + event];\n  if (!callbacks) return this;\n\n  // remove all handlers\n  if (1 == arguments.length) {\n    delete this._callbacks['$' + event];\n    return this;\n  }\n\n  // remove specific handler\n  var cb;\n  for (var i = 0; i < callbacks.length; i++) {\n    cb = callbacks[i];\n    if (cb === fn || cb.fn === fn) {\n      callbacks.splice(i, 1);\n      break;\n    }\n  }\n\n  // Remove event specific arrays for event types that no\n  // one is subscribed for to avoid memory leak.\n  if (callbacks.length === 0) {\n    delete this._callbacks['$' + event];\n  }\n\n  return this;\n};\n\n/**\n * Emit `event` with the given args.\n *\n * @param {String} event\n * @param {Mixed} ...\n * @return {Emitter}\n */\n\nEmitter.prototype.emit = function(event){\n  this._callbacks = this._callbacks || {};\n\n  var args = new Array(arguments.length - 1)\n    , callbacks = this._callbacks['$' + event];\n\n  for (var i = 1; i < arguments.length; i++) {\n    args[i - 1] = arguments[i];\n  }\n\n  if (callbacks) {\n    callbacks = callbacks.slice(0);\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\n      callbacks[i].apply(this, args);\n    }\n  }\n\n  return this;\n};\n\n/**\n * Return array of callbacks for `event`.\n *\n * @param {String} event\n * @return {Array}\n * @api public\n */\n\nEmitter.prototype.listeners = function(event){\n  this._callbacks = this._callbacks || {};\n  return this._callbacks['$' + event] || [];\n};\n\n/**\n * Check if this emitter has `event` handlers.\n *\n * @param {String} event\n * @return {Boolean}\n * @api public\n */\n\nEmitter.prototype.hasListeners = function(event){\n  return !! this.listeners(event).length;\n};\n\n\n/***/ }),\n\n/***/ 242:\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n * Module of mixed-in functions shared between node and client code\n */\nvar isObject = __webpack_require__(101);\n\n/**\n * Expose `RequestBase`.\n */\n\nmodule.exports = RequestBase;\n\n/**\n * Initialize a new `RequestBase`.\n *\n * @api public\n */\n\nfunction RequestBase(obj) {\n  if (obj) return mixin(obj);\n}\n\n/**\n * Mixin the prototype properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in RequestBase.prototype) {\n    obj[key] = RequestBase.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Clear previous timeout.\n *\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.clearTimeout = function _clearTimeout(){\n  clearTimeout(this._timer);\n  clearTimeout(this._responseTimeoutTimer);\n  delete this._timer;\n  delete this._responseTimeoutTimer;\n  return this;\n};\n\n/**\n * Override default response body parser\n *\n * This function will be called to convert incoming data into request.body\n *\n * @param {Function}\n * @api public\n */\n\nRequestBase.prototype.parse = function parse(fn){\n  this._parser = fn;\n  return this;\n};\n\n/**\n * Set format of binary response body.\n * In browser valid formats are 'blob' and 'arraybuffer',\n * which return Blob and ArrayBuffer, respectively.\n *\n * In Node all values result in Buffer.\n *\n * Examples:\n *\n *      req.get('/')\n *        .responseType('blob')\n *        .end(callback);\n *\n * @param {String} val\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.responseType = function(val){\n  this._responseType = val;\n  return this;\n};\n\n/**\n * Override default request body serializer\n *\n * This function will be called to convert data set via .send or .attach into payload to send\n *\n * @param {Function}\n * @api public\n */\n\nRequestBase.prototype.serialize = function serialize(fn){\n  this._serializer = fn;\n  return this;\n};\n\n/**\n * Set timeouts.\n *\n * - response timeout is time between sending request and receiving the first byte of the response. Includes DNS and connection time.\n * - deadline is the time from start of the request to receiving response body in full. If the deadline is too short large files may not load at all on slow connections.\n *\n * Value of 0 or false means no timeout.\n *\n * @param {Number|Object} ms or {response, read, deadline}\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.timeout = function timeout(options){\n  if (!options || 'object' !== typeof options) {\n    this._timeout = options;\n    this._responseTimeout = 0;\n    return this;\n  }\n\n  for(var option in options) {\n    switch(option) {\n      case 'deadline':\n        this._timeout = options.deadline;\n        break;\n      case 'response':\n        this._responseTimeout = options.response;\n        break;\n      default:\n        console.warn(\"Unknown timeout option\", option);\n    }\n  }\n  return this;\n};\n\n/**\n * Set number of retry attempts on error.\n *\n * Failed requests will be retried 'count' times if timeout or err.code >= 500.\n *\n * @param {Number} count\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.retry = function retry(count){\n  // Default to 1 if no count passed or true\n  if (arguments.length === 0 || count === true) count = 1;\n  if (count <= 0) count = 0;\n  this._maxRetries = count;\n  this._retries = 0;\n  return this;\n};\n\n/**\n * Retry request\n *\n * @return {Request} for chaining\n * @api private\n */\n\nRequestBase.prototype._retry = function() {\n  this.clearTimeout();\n\n  // node\n  if (this.req) {\n    this.req = null;\n    this.req = this.request();\n  }\n\n  this._aborted = false;\n  this.timedout = false;\n\n  return this._end();\n};\n\n/**\n * Promise support\n *\n * @param {Function} resolve\n * @param {Function} [reject]\n * @return {Request}\n */\n\nRequestBase.prototype.then = function then(resolve, reject) {\n  if (!this._fullfilledPromise) {\n    var self = this;\n    if (this._endCalled) {\n      console.warn(\"Warning: superagent request was sent twice, because both .end() and .then() were called. Never call .end() if you use promises\");\n    }\n    this._fullfilledPromise = new Promise(function(innerResolve, innerReject){\n      self.end(function(err, res){\n        if (err) innerReject(err); else innerResolve(res);\n      });\n    });\n  }\n  return this._fullfilledPromise.then(resolve, reject);\n}\n\nRequestBase.prototype.catch = function(cb) {\n  return this.then(undefined, cb);\n};\n\n/**\n * Allow for extension\n */\n\nRequestBase.prototype.use = function use(fn) {\n  fn(this);\n  return this;\n}\n\nRequestBase.prototype.ok = function(cb) {\n  if ('function' !== typeof cb) throw Error(\"Callback required\");\n  this._okCallback = cb;\n  return this;\n};\n\nRequestBase.prototype._isResponseOK = function(res) {\n  if (!res) {\n    return false;\n  }\n\n  if (this._okCallback) {\n    return this._okCallback(res);\n  }\n\n  return res.status >= 200 && res.status < 300;\n};\n\n\n/**\n * Get request header `field`.\n * Case-insensitive.\n *\n * @param {String} field\n * @return {String}\n * @api public\n */\n\nRequestBase.prototype.get = function(field){\n  return this._header[field.toLowerCase()];\n};\n\n/**\n * Get case-insensitive header `field` value.\n * This is a deprecated internal API. Use `.get(field)` instead.\n *\n * (getHeader is no longer used internally by the superagent code base)\n *\n * @param {String} field\n * @return {String}\n * @api private\n * @deprecated\n */\n\nRequestBase.prototype.getHeader = RequestBase.prototype.get;\n\n/**\n * Set header `field` to `val`, or multiple fields with one object.\n * Case-insensitive.\n *\n * Examples:\n *\n *      req.get('/')\n *        .set('Accept', 'application/json')\n *        .set('X-API-Key', 'foobar')\n *        .end(callback);\n *\n *      req.get('/')\n *        .set({ Accept: 'application/json', 'X-API-Key': 'foobar' })\n *        .end(callback);\n *\n * @param {String|Object} field\n * @param {String} val\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.set = function(field, val){\n  if (isObject(field)) {\n    for (var key in field) {\n      this.set(key, field[key]);\n    }\n    return this;\n  }\n  this._header[field.toLowerCase()] = val;\n  this.header[field] = val;\n  return this;\n};\n\n/**\n * Remove header `field`.\n * Case-insensitive.\n *\n * Example:\n *\n *      req.get('/')\n *        .unset('User-Agent')\n *        .end(callback);\n *\n * @param {String} field\n */\nRequestBase.prototype.unset = function(field){\n  delete this._header[field.toLowerCase()];\n  delete this.header[field];\n  return this;\n};\n\n/**\n * Write the field `name` and `val`, or multiple fields with one object\n * for \"multipart/form-data\" request bodies.\n *\n * ``` js\n * request.post('/upload')\n *   .field('foo', 'bar')\n *   .end(callback);\n *\n * request.post('/upload')\n *   .field({ foo: 'bar', baz: 'qux' })\n *   .end(callback);\n * ```\n *\n * @param {String|Object} name\n * @param {String|Blob|File|Buffer|fs.ReadStream} val\n * @return {Request} for chaining\n * @api public\n */\nRequestBase.prototype.field = function(name, val) {\n\n  // name should be either a string or an object.\n  if (null === name ||  undefined === name) {\n    throw new Error('.field(name, val) name can not be empty');\n  }\n\n  if (this._data) {\n    console.error(\".field() can't be used if .send() is used. Please use only .send() or only .field() & .attach()\");\n  }\n\n  if (isObject(name)) {\n    for (var key in name) {\n      this.field(key, name[key]);\n    }\n    return this;\n  }\n\n  if (Array.isArray(val)) {\n    for (var i in val) {\n      this.field(name, val[i]);\n    }\n    return this;\n  }\n\n  // val should be defined now\n  if (null === val || undefined === val) {\n    throw new Error('.field(name, val) val can not be empty');\n  }\n  if ('boolean' === typeof val) {\n    val = '' + val;\n  }\n  this._getFormData().append(name, val);\n  return this;\n};\n\n/**\n * Abort the request, and clear potential timeout.\n *\n * @return {Request}\n * @api public\n */\nRequestBase.prototype.abort = function(){\n  if (this._aborted) {\n    return this;\n  }\n  this._aborted = true;\n  this.xhr && this.xhr.abort(); // browser\n  this.req && this.req.abort(); // node\n  this.clearTimeout();\n  this.emit('abort');\n  return this;\n};\n\n/**\n * Enable transmission of cookies with x-domain requests.\n *\n * Note that for this to work the origin must not be\n * using \"Access-Control-Allow-Origin\" with a wildcard,\n * and also must set \"Access-Control-Allow-Credentials\"\n * to \"true\".\n *\n * @api public\n */\n\nRequestBase.prototype.withCredentials = function(on){\n  // This is browser-only functionality. Node side is no-op.\n  if(on==undefined) on = true;\n  this._withCredentials = on;\n  return this;\n};\n\n/**\n * Set the max redirects to `n`. Does noting in browser XHR implementation.\n *\n * @param {Number} n\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.redirects = function(n){\n  this._maxRedirects = n;\n  return this;\n};\n\n/**\n * Convert to a plain javascript object (not JSON string) of scalar properties.\n * Note as this method is designed to return a useful non-this value,\n * it cannot be chained.\n *\n * @return {Object} describing method, url, and data of this request\n * @api public\n */\n\nRequestBase.prototype.toJSON = function(){\n  return {\n    method: this.method,\n    url: this.url,\n    data: this._data,\n    headers: this._header\n  };\n};\n\n\n/**\n * Send `data` as the request body, defaulting the `.type()` to \"json\" when\n * an object is given.\n *\n * Examples:\n *\n *       // manual json\n *       request.post('/user')\n *         .type('json')\n *         .send('{\"name\":\"tj\"}')\n *         .end(callback)\n *\n *       // auto json\n *       request.post('/user')\n *         .send({ name: 'tj' })\n *         .end(callback)\n *\n *       // manual x-www-form-urlencoded\n *       request.post('/user')\n *         .type('form')\n *         .send('name=tj')\n *         .end(callback)\n *\n *       // auto x-www-form-urlencoded\n *       request.post('/user')\n *         .type('form')\n *         .send({ name: 'tj' })\n *         .end(callback)\n *\n *       // defaults to x-www-form-urlencoded\n *      request.post('/user')\n *        .send('name=tobi')\n *        .send('species=ferret')\n *        .end(callback)\n *\n * @param {String|Object} data\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.send = function(data){\n  var isObj = isObject(data);\n  var type = this._header['content-type'];\n\n  if (this._formData) {\n    console.error(\".send() can't be used if .attach() or .field() is used. Please use only .send() or only .field() & .attach()\");\n  }\n\n  if (isObj && !this._data) {\n    if (Array.isArray(data)) {\n      this._data = [];\n    } else if (!this._isHost(data)) {\n      this._data = {};\n    }\n  } else if (data && this._data && this._isHost(this._data)) {\n    throw Error(\"Can't merge these send calls\");\n  }\n\n  // merge\n  if (isObj && isObject(this._data)) {\n    for (var key in data) {\n      this._data[key] = data[key];\n    }\n  } else if ('string' == typeof data) {\n    // default to x-www-form-urlencoded\n    if (!type) this.type('form');\n    type = this._header['content-type'];\n    if ('application/x-www-form-urlencoded' == type) {\n      this._data = this._data\n        ? this._data + '&' + data\n        : data;\n    } else {\n      this._data = (this._data || '') + data;\n    }\n  } else {\n    this._data = data;\n  }\n\n  if (!isObj || this._isHost(data)) {\n    return this;\n  }\n\n  // default to json\n  if (!type) this.type('json');\n  return this;\n};\n\n\n/**\n * Sort `querystring` by the sort function\n *\n *\n * Examples:\n *\n *       // default order\n *       request.get('/user')\n *         .query('name=Nick')\n *         .query('search=Manny')\n *         .sortQuery()\n *         .end(callback)\n *\n *       // customized sort function\n *       request.get('/user')\n *         .query('name=Nick')\n *         .query('search=Manny')\n *         .sortQuery(function(a, b){\n *           return a.length - b.length;\n *         })\n *         .end(callback)\n *\n *\n * @param {Function} sort\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.sortQuery = function(sort) {\n  // _sort default to true but otherwise can be a function or boolean\n  this._sort = typeof sort === 'undefined' ? true : sort;\n  return this;\n};\n\n/**\n * Invoke callback with timeout error.\n *\n * @api private\n */\n\nRequestBase.prototype._timeoutError = function(reason, timeout, errno){\n  if (this._aborted) {\n    return;\n  }\n  var err = new Error(reason + timeout + 'ms exceeded');\n  err.timeout = timeout;\n  err.code = 'ECONNABORTED';\n  err.errno = errno;\n  this.timedout = true;\n  this.abort();\n  this.callback(err);\n};\n\nRequestBase.prototype._setTimeouts = function() {\n  var self = this;\n\n  // deadline\n  if (this._timeout && !this._timer) {\n    this._timer = setTimeout(function(){\n      self._timeoutError('Timeout of ', self._timeout, 'ETIME');\n    }, this._timeout);\n  }\n  // response timeout\n  if (this._responseTimeout && !this._responseTimeoutTimer) {\n    this._responseTimeoutTimer = setTimeout(function(){\n      self._timeoutError('Response timeout of ', self._responseTimeout, 'ETIMEDOUT');\n    }, this._responseTimeout);\n  }\n}\n\n\n/***/ }),\n\n/***/ 243:\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n * Check if `fn` is a function.\n *\n * @param {Function} fn\n * @return {Boolean}\n * @api private\n */\nvar isObject = __webpack_require__(101);\n\nfunction isFunction(fn) {\n  var tag = isObject(fn) ? Object.prototype.toString.call(fn) : '';\n  return tag === '[object Function]';\n}\n\nmodule.exports = isFunction;\n\n\n/***/ }),\n\n/***/ 244:\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/**\n * Module dependencies.\n */\n\nvar utils = __webpack_require__(245);\n\n/**\n * Expose `ResponseBase`.\n */\n\nmodule.exports = ResponseBase;\n\n/**\n * Initialize a new `ResponseBase`.\n *\n * @api public\n */\n\nfunction ResponseBase(obj) {\n  if (obj) return mixin(obj);\n}\n\n/**\n * Mixin the prototype properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in ResponseBase.prototype) {\n    obj[key] = ResponseBase.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Get case-insensitive `field` value.\n *\n * @param {String} field\n * @return {String}\n * @api public\n */\n\nResponseBase.prototype.get = function(field){\n    return this.header[field.toLowerCase()];\n};\n\n/**\n * Set header related properties:\n *\n *   - `.type` the content type without params\n *\n * A response of \"Content-Type: text/plain; charset=utf-8\"\n * will provide you with a `.type` of \"text/plain\".\n *\n * @param {Object} header\n * @api private\n */\n\nResponseBase.prototype._setHeaderProperties = function(header){\n    // TODO: moar!\n    // TODO: make this a util\n\n    // content-type\n    var ct = header['content-type'] || '';\n    this.type = utils.type(ct);\n\n    // params\n    var params = utils.params(ct);\n    for (var key in params) this[key] = params[key];\n\n    this.links = {};\n\n    // links\n    try {\n        if (header.link) {\n            this.links = utils.parseLinks(header.link);\n        }\n    } catch (err) {\n        // ignore\n    }\n};\n\n/**\n * Set flags such as `.ok` based on `status`.\n *\n * For example a 2xx response will give you a `.ok` of __true__\n * whereas 5xx will be __false__ and `.error` will be __true__. The\n * `.clientError` and `.serverError` are also available to be more\n * specific, and `.statusType` is the class of error ranging from 1..5\n * sometimes useful for mapping respond colors etc.\n *\n * \"sugar\" properties are also defined for common cases. Currently providing:\n *\n *   - .noContent\n *   - .badRequest\n *   - .unauthorized\n *   - .notAcceptable\n *   - .notFound\n *\n * @param {Number} status\n * @api private\n */\n\nResponseBase.prototype._setStatusProperties = function(status){\n    var type = status / 100 | 0;\n\n    // status / class\n    this.status = this.statusCode = status;\n    this.statusType = type;\n\n    // basics\n    this.info = 1 == type;\n    this.ok = 2 == type;\n    this.redirect = 3 == type;\n    this.clientError = 4 == type;\n    this.serverError = 5 == type;\n    this.error = (4 == type || 5 == type)\n        ? this.toError()\n        : false;\n\n    // sugar\n    this.accepted = 202 == status;\n    this.noContent = 204 == status;\n    this.badRequest = 400 == status;\n    this.unauthorized = 401 == status;\n    this.notAcceptable = 406 == status;\n    this.forbidden = 403 == status;\n    this.notFound = 404 == status;\n};\n\n\n/***/ }),\n\n/***/ 245:\n/***/ (function(module, exports) {\n\n\n/**\n * Return the mime type for the given `str`.\n *\n * @param {String} str\n * @return {String}\n * @api private\n */\n\nexports.type = function(str){\n  return str.split(/ *; */).shift();\n};\n\n/**\n * Return header field parameters.\n *\n * @param {String} str\n * @return {Object}\n * @api private\n */\n\nexports.params = function(str){\n  return str.split(/ *; */).reduce(function(obj, str){\n    var parts = str.split(/ *= */);\n    var key = parts.shift();\n    var val = parts.shift();\n\n    if (key && val) obj[key] = val;\n    return obj;\n  }, {});\n};\n\n/**\n * Parse Link header fields.\n *\n * @param {String} str\n * @return {Object}\n * @api private\n */\n\nexports.parseLinks = function(str){\n  return str.split(/ *, */).reduce(function(obj, str){\n    var parts = str.split(/ *; */);\n    var url = parts[0].slice(1, -1);\n    var rel = parts[1].split(/ *= */)[1].slice(1, -1);\n    obj[rel] = url;\n    return obj;\n  }, {});\n};\n\n/**\n * Strip content related fields from `header`.\n *\n * @param {Object} header\n * @return {Object} header\n * @api private\n */\n\nexports.cleanHeader = function(header, shouldStripCookie){\n  delete header['content-type'];\n  delete header['content-length'];\n  delete header['transfer-encoding'];\n  delete header['host'];\n  if (shouldStripCookie) {\n    delete header['cookie'];\n  }\n  return header;\n};\n\n/***/ }),\n\n/***/ 246:\n/***/ (function(module, exports) {\n\nvar ERROR_CODES = [\n  'ECONNRESET',\n  'ETIMEDOUT',\n  'EADDRINFO',\n  'ESOCKETTIMEDOUT'\n];\n\n/**\n * Determine if a request should be retried.\n * (Borrowed from segmentio/superagent-retry)\n *\n * @param {Error} err\n * @param {Response} [res]\n * @returns {Boolean}\n */\nmodule.exports = function shouldRetry(err, res) {\n  if (err && err.code && ~ERROR_CODES.indexOf(err.code)) return true;\n  if (res && res.status && res.status >= 500) return true;\n  // Superagent timeout\n  if (err && 'timeout' in err && err.code == 'ECONNABORTED') return true;\n  if (err && 'crossDomain' in err) return true;\n  return false;\n};\n\n\n/***/ }),\n\n/***/ 247:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/*!\n * methods\n * Copyright(c) 2013-2014 TJ Holowaychuk\n * Copyright(c) 2015-2016 Douglas Christopher Wilson\n * MIT Licensed\n */\n\n\n\n/**\n * Module dependencies.\n * @private\n */\n\nvar http = __webpack_require__(248);\n\n/**\n * Module exports.\n * @public\n */\n\nmodule.exports = getCurrentNodeMethods() || getBasicNodeMethods();\n\n/**\n * Get the current Node.js methods.\n * @private\n */\n\nfunction getCurrentNodeMethods() {\n  return http.METHODS && http.METHODS.map(function lowerCaseMethod(method) {\n    return method.toLowerCase();\n  });\n}\n\n/**\n * Get the \"basic\" Node.js methods, a snapshot from Node.js 0.10.\n * @private\n */\n\nfunction getBasicNodeMethods() {\n  return [\n    'get',\n    'post',\n    'put',\n    'head',\n    'delete',\n    'options',\n    'trace',\n    'copy',\n    'lock',\n    'mkcol',\n    'move',\n    'purge',\n    'propfind',\n    'proppatch',\n    'unlock',\n    'report',\n    'mkactivity',\n    'checkout',\n    'merge',\n    'm-search',\n    'notify',\n    'subscribe',\n    'unsubscribe',\n    'patch',\n    'search',\n    'connect'\n  ];\n}\n\n\n/***/ }),\n\n/***/ 248:\n/***/ (function(module, exports) {\n\n/* (ignored) */\n\n/***/ }),\n\n/***/ 249:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\n\n/***/ }),\n\n/***/ 67:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n * JavaScript Cookie v2.1.4\n * https://github.com/js-cookie/js-cookie\n *\n * Copyright 2006, 2015 Klaus Hartl & Fagner Brack\n * Released under the MIT license\n */\n;(function (factory) {\n\tvar registeredInModuleLoader = false;\n\tif (true) {\n\t\t!(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :\n\t\t\t\t__WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (true) {\n\t\tmodule.exports = factory();\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (!registeredInModuleLoader) {\n\t\tvar OldCookies = window.Cookies;\n\t\tvar api = window.Cookies = factory();\n\t\tapi.noConflict = function () {\n\t\t\twindow.Cookies = OldCookies;\n\t\t\treturn api;\n\t\t};\n\t}\n}(function () {\n\tfunction extend () {\n\t\tvar i = 0;\n\t\tvar result = {};\n\t\tfor (; i < arguments.length; i++) {\n\t\t\tvar attributes = arguments[ i ];\n\t\t\tfor (var key in attributes) {\n\t\t\t\tresult[key] = attributes[key];\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\n\tfunction init (converter) {\n\t\tfunction api (key, value, attributes) {\n\t\t\tvar result;\n\t\t\tif (typeof document === 'undefined') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Write\n\n\t\t\tif (arguments.length > 1) {\n\t\t\t\tattributes = extend({\n\t\t\t\t\tpath: '/'\n\t\t\t\t}, api.defaults, attributes);\n\n\t\t\t\tif (typeof attributes.expires === 'number') {\n\t\t\t\t\tvar expires = new Date();\n\t\t\t\t\texpires.setMilliseconds(expires.getMilliseconds() + attributes.expires * 864e+5);\n\t\t\t\t\tattributes.expires = expires;\n\t\t\t\t}\n\n\t\t\t\t// We're using \"expires\" because \"max-age\" is not supported by IE\n\t\t\t\tattributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';\n\n\t\t\t\ttry {\n\t\t\t\t\tresult = JSON.stringify(value);\n\t\t\t\t\tif (/^[\\{\\[]/.test(result)) {\n\t\t\t\t\t\tvalue = result;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\n\t\t\t\tif (!converter.write) {\n\t\t\t\t\tvalue = encodeURIComponent(String(value))\n\t\t\t\t\t\t.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);\n\t\t\t\t} else {\n\t\t\t\t\tvalue = converter.write(value, key);\n\t\t\t\t}\n\n\t\t\t\tkey = encodeURIComponent(String(key));\n\t\t\t\tkey = key.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent);\n\t\t\t\tkey = key.replace(/[\\(\\)]/g, escape);\n\n\t\t\t\tvar stringifiedAttributes = '';\n\n\t\t\t\tfor (var attributeName in attributes) {\n\t\t\t\t\tif (!attributes[attributeName]) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tstringifiedAttributes += '; ' + attributeName;\n\t\t\t\t\tif (attributes[attributeName] === true) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tstringifiedAttributes += '=' + attributes[attributeName];\n\t\t\t\t}\n\t\t\t\treturn (document.cookie = key + '=' + value + stringifiedAttributes);\n\t\t\t}\n\n\t\t\t// Read\n\n\t\t\tif (!key) {\n\t\t\t\tresult = {};\n\t\t\t}\n\n\t\t\t// To prevent the for loop in the first place assign an empty array\n\t\t\t// in case there are no cookies at all. Also prevents odd result when\n\t\t\t// calling \"get()\"\n\t\t\tvar cookies = document.cookie ? document.cookie.split('; ') : [];\n\t\t\tvar rdecode = /(%[0-9A-Z]{2})+/g;\n\t\t\tvar i = 0;\n\n\t\t\tfor (; i < cookies.length; i++) {\n\t\t\t\tvar parts = cookies[i].split('=');\n\t\t\t\tvar cookie = parts.slice(1).join('=');\n\n\t\t\t\tif (cookie.charAt(0) === '\"') {\n\t\t\t\t\tcookie = cookie.slice(1, -1);\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tvar name = parts[0].replace(rdecode, decodeURIComponent);\n\t\t\t\t\tcookie = converter.read ?\n\t\t\t\t\t\tconverter.read(cookie, name) : converter(cookie, name) ||\n\t\t\t\t\t\tcookie.replace(rdecode, decodeURIComponent);\n\n\t\t\t\t\tif (this.json) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tcookie = JSON.parse(cookie);\n\t\t\t\t\t\t} catch (e) {}\n\t\t\t\t\t}\n\n\t\t\t\t\tif (key === name) {\n\t\t\t\t\t\tresult = cookie;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (!key) {\n\t\t\t\t\t\tresult[name] = cookie;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\t\t\t}\n\n\t\t\treturn result;\n\t\t}\n\n\t\tapi.set = api;\n\t\tapi.get = function (key) {\n\t\t\treturn api.call(api, key);\n\t\t};\n\t\tapi.getJSON = function () {\n\t\t\treturn api.apply({\n\t\t\t\tjson: true\n\t\t\t}, [].slice.call(arguments));\n\t\t};\n\t\tapi.defaults = {};\n\n\t\tapi.remove = function (key, attributes) {\n\t\t\tapi(key, '', extend(attributes, {\n\t\t\t\texpires: -1\n\t\t\t}));\n\t\t};\n\n\t\tapi.withConverter = init;\n\n\t\treturn api;\n\t}\n\n\treturn init(function () {});\n}));\n\n\n/***/ }),\n\n/***/ 99:\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match words composed of alphanumeric characters. */\nvar reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n/** Used to match Latin Unicode letters (excluding mathematical operators). */\nvar reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n/** Used to compose unicode character classes. */\nvar rsAstralRange = '\\\\ud800-\\\\udfff',\n    rsComboMarksRange = '\\\\u0300-\\\\u036f\\\\ufe20-\\\\ufe23',\n    rsComboSymbolsRange = '\\\\u20d0-\\\\u20f0',\n    rsDingbatRange = '\\\\u2700-\\\\u27bf',\n    rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n    rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n    rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n    rsPunctuationRange = '\\\\u2000-\\\\u206f',\n    rsSpaceRange = ' \\\\t\\\\x0b\\\\f\\\\xa0\\\\ufeff\\\\n\\\\r\\\\u2028\\\\u2029\\\\u1680\\\\u180e\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200a\\\\u202f\\\\u205f\\\\u3000',\n    rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n    rsVarRange = '\\\\ufe0e\\\\ufe0f',\n    rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n/** Used to compose unicode capture groups. */\nvar rsApos = \"['\\u2019]\",\n    rsAstral = '[' + rsAstralRange + ']',\n    rsBreak = '[' + rsBreakRange + ']',\n    rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',\n    rsDigits = '\\\\d+',\n    rsDingbat = '[' + rsDingbatRange + ']',\n    rsLower = '[' + rsLowerRange + ']',\n    rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n    rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n    rsNonAstral = '[^' + rsAstralRange + ']',\n    rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n    rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n    rsUpper = '[' + rsUpperRange + ']',\n    rsZWJ = '\\\\u200d';\n\n/** Used to compose unicode regexes. */\nvar rsLowerMisc = '(?:' + rsLower + '|' + rsMisc + ')',\n    rsUpperMisc = '(?:' + rsUpper + '|' + rsMisc + ')',\n    rsOptLowerContr = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n    rsOptUpperContr = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n    reOptMod = rsModifier + '?',\n    rsOptVar = '[' + rsVarRange + ']?',\n    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n    rsSeq = rsOptVar + reOptMod + rsOptJoin,\n    rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,\n    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n/** Used to match apostrophes. */\nvar reApos = RegExp(rsApos, 'g');\n\n/**\n * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n */\nvar reComboMark = RegExp(rsCombo, 'g');\n\n/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\nvar reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n/** Used to match complex or compound words. */\nvar reUnicodeWord = RegExp([\n  rsUpper + '?' + rsLower + '+' + rsOptLowerContr + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n  rsUpperMisc + '+' + rsOptUpperContr + '(?=' + [rsBreak, rsUpper + rsLowerMisc, '$'].join('|') + ')',\n  rsUpper + '?' + rsLowerMisc + '+' + rsOptLowerContr,\n  rsUpper + '+' + rsOptUpperContr,\n  rsDigits,\n  rsEmoji\n].join('|'), 'g');\n\n/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\nvar reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');\n\n/** Used to detect strings that need a more robust regexp to match words. */\nvar reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;\n\n/** Used to map Latin Unicode letters to basic Latin letters. */\nvar deburredLetters = {\n  // Latin-1 Supplement block.\n  '\\xc0': 'A',  '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n  '\\xe0': 'a',  '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n  '\\xc7': 'C',  '\\xe7': 'c',\n  '\\xd0': 'D',  '\\xf0': 'd',\n  '\\xc8': 'E',  '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n  '\\xe8': 'e',  '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n  '\\xcc': 'I',  '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n  '\\xec': 'i',  '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n  '\\xd1': 'N',  '\\xf1': 'n',\n  '\\xd2': 'O',  '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n  '\\xf2': 'o',  '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n  '\\xd9': 'U',  '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n  '\\xf9': 'u',  '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n  '\\xdd': 'Y',  '\\xfd': 'y', '\\xff': 'y',\n  '\\xc6': 'Ae', '\\xe6': 'ae',\n  '\\xde': 'Th', '\\xfe': 'th',\n  '\\xdf': 'ss',\n  // Latin Extended-A block.\n  '\\u0100': 'A',  '\\u0102': 'A', '\\u0104': 'A',\n  '\\u0101': 'a',  '\\u0103': 'a', '\\u0105': 'a',\n  '\\u0106': 'C',  '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n  '\\u0107': 'c',  '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n  '\\u010e': 'D',  '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n  '\\u0112': 'E',  '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n  '\\u0113': 'e',  '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n  '\\u011c': 'G',  '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n  '\\u011d': 'g',  '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n  '\\u0124': 'H',  '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n  '\\u0128': 'I',  '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n  '\\u0129': 'i',  '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n  '\\u0134': 'J',  '\\u0135': 'j',\n  '\\u0136': 'K',  '\\u0137': 'k', '\\u0138': 'k',\n  '\\u0139': 'L',  '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n  '\\u013a': 'l',  '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n  '\\u0143': 'N',  '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n  '\\u0144': 'n',  '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n  '\\u014c': 'O',  '\\u014e': 'O', '\\u0150': 'O',\n  '\\u014d': 'o',  '\\u014f': 'o', '\\u0151': 'o',\n  '\\u0154': 'R',  '\\u0156': 'R', '\\u0158': 'R',\n  '\\u0155': 'r',  '\\u0157': 'r', '\\u0159': 'r',\n  '\\u015a': 'S',  '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n  '\\u015b': 's',  '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n  '\\u0162': 'T',  '\\u0164': 'T', '\\u0166': 'T',\n  '\\u0163': 't',  '\\u0165': 't', '\\u0167': 't',\n  '\\u0168': 'U',  '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n  '\\u0169': 'u',  '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n  '\\u0174': 'W',  '\\u0175': 'w',\n  '\\u0176': 'Y',  '\\u0177': 'y', '\\u0178': 'Y',\n  '\\u0179': 'Z',  '\\u017b': 'Z', '\\u017d': 'Z',\n  '\\u017a': 'z',  '\\u017c': 'z', '\\u017e': 'z',\n  '\\u0132': 'IJ', '\\u0133': 'ij',\n  '\\u0152': 'Oe', '\\u0153': 'oe',\n  '\\u0149': \"'n\", '\\u017f': 'ss'\n};\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/**\n * A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the first element of `array` as\n *  the initial value.\n * @returns {*} Returns the accumulated value.\n */\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  if (initAccum && length) {\n    accumulator = array[++index];\n  }\n  while (++index < length) {\n    accumulator = iteratee(accumulator, array[index], index, array);\n  }\n  return accumulator;\n}\n\n/**\n * Converts an ASCII `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction asciiToArray(string) {\n  return string.split('');\n}\n\n/**\n * Splits an ASCII `string` into an array of its words.\n *\n * @private\n * @param {string} The string to inspect.\n * @returns {Array} Returns the words of `string`.\n */\nfunction asciiWords(string) {\n  return string.match(reAsciiWord) || [];\n}\n\n/**\n * The base implementation of `_.propertyOf` without support for deep paths.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Function} Returns the new accessor function.\n */\nfunction basePropertyOf(object) {\n  return function(key) {\n    return object == null ? undefined : object[key];\n  };\n}\n\n/**\n * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n * letters to basic Latin letters.\n *\n * @private\n * @param {string} letter The matched letter to deburr.\n * @returns {string} Returns the deburred letter.\n */\nvar deburrLetter = basePropertyOf(deburredLetters);\n\n/**\n * Checks if `string` contains Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n */\nfunction hasUnicode(string) {\n  return reHasUnicode.test(string);\n}\n\n/**\n * Checks if `string` contains a word composed of Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a word is found, else `false`.\n */\nfunction hasUnicodeWord(string) {\n  return reHasUnicodeWord.test(string);\n}\n\n/**\n * Converts `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction stringToArray(string) {\n  return hasUnicode(string)\n    ? unicodeToArray(string)\n    : asciiToArray(string);\n}\n\n/**\n * Converts a Unicode `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction unicodeToArray(string) {\n  return string.match(reUnicode) || [];\n}\n\n/**\n * Splits a Unicode `string` into an array of its words.\n *\n * @private\n * @param {string} The string to inspect.\n * @returns {Array} Returns the words of `string`.\n */\nfunction unicodeWords(string) {\n  return string.match(reUnicodeWord) || [];\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n  var index = -1,\n      length = array.length;\n\n  if (start < 0) {\n    start = -start > length ? 0 : (length + start);\n  }\n  end = end > length ? length : end;\n  if (end < 0) {\n    end += length;\n  }\n  length = start > end ? 0 : ((end - start) >>> 0);\n  start >>>= 0;\n\n  var result = Array(length);\n  while (++index < length) {\n    result[index] = array[index + start];\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return symbolToString ? symbolToString.call(value) : '';\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\n/**\n * Casts `array` to a slice if it's needed.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {number} start The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the cast slice.\n */\nfunction castSlice(array, start, end) {\n  var length = array.length;\n  end = end === undefined ? length : end;\n  return (!start && end >= length) ? array : baseSlice(array, start, end);\n}\n\n/**\n * Creates a function like `_.lowerFirst`.\n *\n * @private\n * @param {string} methodName The name of the `String` case method to use.\n * @returns {Function} Returns the new case function.\n */\nfunction createCaseFirst(methodName) {\n  return function(string) {\n    string = toString(string);\n\n    var strSymbols = hasUnicode(string)\n      ? stringToArray(string)\n      : undefined;\n\n    var chr = strSymbols\n      ? strSymbols[0]\n      : string.charAt(0);\n\n    var trailing = strSymbols\n      ? castSlice(strSymbols, 1).join('')\n      : string.slice(1);\n\n    return chr[methodName]() + trailing;\n  };\n}\n\n/**\n * Creates a function like `_.camelCase`.\n *\n * @private\n * @param {Function} callback The function to combine each word.\n * @returns {Function} Returns the new compounder function.\n */\nfunction createCompounder(callback) {\n  return function(string) {\n    return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n  };\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n  return value == null ? '' : baseToString(value);\n}\n\n/**\n * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the camel cased string.\n * @example\n *\n * _.camelCase('Foo Bar');\n * // => 'fooBar'\n *\n * _.camelCase('--foo-bar--');\n * // => 'fooBar'\n *\n * _.camelCase('__FOO_BAR__');\n * // => 'fooBar'\n */\nvar camelCase = createCompounder(function(result, word, index) {\n  word = word.toLowerCase();\n  return result + (index ? capitalize(word) : word);\n});\n\n/**\n * Converts the first character of `string` to upper case and the remaining\n * to lower case.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to capitalize.\n * @returns {string} Returns the capitalized string.\n * @example\n *\n * _.capitalize('FRED');\n * // => 'Fred'\n */\nfunction capitalize(string) {\n  return upperFirst(toString(string).toLowerCase());\n}\n\n/**\n * Deburrs `string` by converting\n * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n * letters to basic Latin letters and removing\n * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to deburr.\n * @returns {string} Returns the deburred string.\n * @example\n *\n * _.deburr('déjà vu');\n * // => 'deja vu'\n */\nfunction deburr(string) {\n  string = toString(string);\n  return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n}\n\n/**\n * Converts the first character of `string` to upper case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.upperFirst('fred');\n * // => 'Fred'\n *\n * _.upperFirst('FRED');\n * // => 'FRED'\n */\nvar upperFirst = createCaseFirst('toUpperCase');\n\n/**\n * Splits `string` into an array of its words.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to inspect.\n * @param {RegExp|string} [pattern] The pattern to match words.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the words of `string`.\n * @example\n *\n * _.words('fred, barney, & pebbles');\n * // => ['fred', 'barney', 'pebbles']\n *\n * _.words('fred, barney, & pebbles', /[^, ]+/g);\n * // => ['fred', 'barney', '&', 'pebbles']\n */\nfunction words(string, pattern, guard) {\n  string = toString(string);\n  pattern = guard ? undefined : pattern;\n\n  if (pattern === undefined) {\n    return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n  }\n  return string.match(pattern) || [];\n}\n\nmodule.exports = camelCase;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(11)))\n\n/***/ })\n\n/******/ });\n\n\n// WEBPACK FOOTER //\n// src/vendors.3cf7aefbf5d07021599c.js"," \t// install a JSONP callback for chunk loading\n \tvar parentJsonpFunction = window[\"webpackJsonp\"];\n \twindow[\"webpackJsonp\"] = function webpackJsonpCallback(chunkIds, moreModules, executeModules) {\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, resolves = [], result;\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(installedChunks[chunkId]) {\n \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n \t\t\t}\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t\t}\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(chunkIds, moreModules, executeModules);\n \t\twhile(resolves.length) {\n \t\t\tresolves.shift()();\n \t\t}\n \t\tif(executeModules) {\n \t\t\tfor(i=0; i < executeModules.length; i++) {\n \t\t\t\tresult = __webpack_require__(__webpack_require__.s = executeModules[i]);\n \t\t\t}\n \t\t}\n \t\treturn result;\n \t};\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// objects to store loaded and loading chunks\n \tvar installedChunks = {\n \t\t1: 0\n \t};\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 \t// This file contains only the entry chunk.\n \t// The chunk loading function for additional chunks\n \t__webpack_require__.e = function requireEnsure(chunkId) {\n \t\tvar installedChunkData = installedChunks[chunkId];\n \t\tif(installedChunkData === 0) {\n \t\t\treturn new Promise(function(resolve) { resolve(); });\n \t\t}\n\n \t\t// a Promise means \"currently loading\".\n \t\tif(installedChunkData) {\n \t\t\treturn installedChunkData[2];\n \t\t}\n\n \t\t// setup Promise in chunk cache\n \t\tvar promise = new Promise(function(resolve, reject) {\n \t\t\tinstalledChunkData = installedChunks[chunkId] = [resolve, reject];\n \t\t});\n \t\tinstalledChunkData[2] = promise;\n\n \t\t// start chunk loading\n \t\tvar head = document.getElementsByTagName('head')[0];\n \t\tvar script = document.createElement('script');\n \t\tscript.type = 'text/javascript';\n \t\tscript.charset = 'utf-8';\n \t\tscript.async = true;\n \t\tscript.timeout = 120000;\n\n \t\tif (__webpack_require__.nc) {\n \t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n \t\t}\n \t\tscript.src = __webpack_require__.p + \"src/\" + chunkId + \".\" + \"3cf7aefbf5d07021599c\" + \".js\";\n \t\tvar timeout = setTimeout(onScriptComplete, 120000);\n \t\tscript.onerror = script.onload = onScriptComplete;\n \t\tfunction onScriptComplete() {\n \t\t\t// avoid mem leaks in IE.\n \t\t\tscript.onerror = script.onload = null;\n \t\t\tclearTimeout(timeout);\n \t\t\tvar chunk = installedChunks[chunkId];\n \t\t\tif(chunk !== 0) {\n \t\t\t\tif(chunk) {\n \t\t\t\t\tchunk[1](new Error('Loading chunk ' + chunkId + ' failed.'));\n \t\t\t\t}\n \t\t\t\tinstalledChunks[chunkId] = undefined;\n \t\t\t}\n \t\t};\n \t\thead.appendChild(script);\n\n \t\treturn promise;\n \t};\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 = \"/\";\n\n \t// on error function for async loading\n \t__webpack_require__.oe = function(err) { console.error(err); throw err; };\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 229);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 3cf7aefbf5d07021599c","//! moment.js locale configuration\n//! locale : Russian [ru]\n//! author : Viktorminator : https://github.com/Viktorminator\n//! Author : Menelion Elensúle : https://github.com/Oire\n//! author : Коренберг Марк : https://github.com/socketpair\n\n;(function (global, factory) {\n   typeof exports === 'object' && typeof module !== 'undefined'\n       && typeof require === 'function' ? factory(require('../moment')) :\n   typeof define === 'function' && define.amd ? define(['../moment'], factory) :\n   factory(global.moment)\n}(this, (function (moment) { 'use strict';\n\n\nfunction plural(word, num) {\n    var forms = word.split('_');\n    return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);\n}\nfunction relativeTimeWithPlural(number, withoutSuffix, key) {\n    var format = {\n        'mm': withoutSuffix ? 'минута_минуты_минут' : 'минуту_минуты_минут',\n        'hh': 'час_часа_часов',\n        'dd': 'день_дня_дней',\n        'MM': 'месяц_месяца_месяцев',\n        'yy': 'год_года_лет'\n    };\n    if (key === 'm') {\n        return withoutSuffix ? 'минута' : 'минуту';\n    }\n    else {\n        return number + ' ' + plural(format[key], +number);\n    }\n}\nvar monthsParse = [/^янв/i, /^фев/i, /^мар/i, /^апр/i, /^ма[йя]/i, /^июн/i, /^июл/i, /^авг/i, /^сен/i, /^окт/i, /^ноя/i, /^дек/i];\n\n// http://new.gramota.ru/spravka/rules/139-prop : § 103\n// Сокращения месяцев: http://new.gramota.ru/spravka/buro/search-answer?s=242637\n// CLDR data:          http://www.unicode.org/cldr/charts/28/summary/ru.html#1753\nvar ru = moment.defineLocale('ru', {\n    months : {\n        format: 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_'),\n        standalone: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_')\n    },\n    monthsShort : {\n        // по CLDR именно \"июл.\" и \"июн.\", но какой смысл менять букву на точку ?\n        format: 'янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.'.split('_'),\n        standalone: 'янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.'.split('_')\n    },\n    weekdays : {\n        standalone: 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split('_'),\n        format: 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split('_'),\n        isFormat: /\\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\\] ?dddd/\n    },\n    weekdaysShort : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),\n    weekdaysMin : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),\n    monthsParse : monthsParse,\n    longMonthsParse : monthsParse,\n    shortMonthsParse : monthsParse,\n\n    // полные названия с падежами, по три буквы, для некоторых, по 4 буквы, сокращения с точкой и без точки\n    monthsRegex: /^(январ[ья]|янв\\.?|феврал[ья]|февр?\\.?|марта?|мар\\.?|апрел[ья]|апр\\.?|ма[йя]|июн[ья]|июн\\.?|июл[ья]|июл\\.?|августа?|авг\\.?|сентябр[ья]|сент?\\.?|октябр[ья]|окт\\.?|ноябр[ья]|нояб?\\.?|декабр[ья]|дек\\.?)/i,\n\n    // копия предыдущего\n    monthsShortRegex: /^(январ[ья]|янв\\.?|феврал[ья]|февр?\\.?|марта?|мар\\.?|апрел[ья]|апр\\.?|ма[йя]|июн[ья]|июн\\.?|июл[ья]|июл\\.?|августа?|авг\\.?|сентябр[ья]|сент?\\.?|октябр[ья]|окт\\.?|ноябр[ья]|нояб?\\.?|декабр[ья]|дек\\.?)/i,\n\n    // полные названия с падежами\n    monthsStrictRegex: /^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,\n\n    // Выражение, которое соотвествует только сокращённым формам\n    monthsShortStrictRegex: /^(янв\\.|февр?\\.|мар[т.]|апр\\.|ма[яй]|июн[ья.]|июл[ья.]|авг\\.|сент?\\.|окт\\.|нояб?\\.|дек\\.)/i,\n    longDateFormat : {\n        LT : 'HH:mm',\n        LTS : 'HH:mm:ss',\n        L : 'DD.MM.YYYY',\n        LL : 'D MMMM YYYY г.',\n        LLL : 'D MMMM YYYY г., HH:mm',\n        LLLL : 'dddd, D MMMM YYYY г., HH:mm'\n    },\n    calendar : {\n        sameDay: '[Сегодня в] LT',\n        nextDay: '[Завтра в] LT',\n        lastDay: '[Вчера в] LT',\n        nextWeek: function (now) {\n            if (now.week() !== this.week()) {\n                switch (this.day()) {\n                    case 0:\n                        return '[В следующее] dddd [в] LT';\n                    case 1:\n                    case 2:\n                    case 4:\n                        return '[В следующий] dddd [в] LT';\n                    case 3:\n                    case 5:\n                    case 6:\n                        return '[В следующую] dddd [в] LT';\n                }\n            } else {\n                if (this.day() === 2) {\n                    return '[Во] dddd [в] LT';\n                } else {\n                    return '[В] dddd [в] LT';\n                }\n            }\n        },\n        lastWeek: function (now) {\n            if (now.week() !== this.week()) {\n                switch (this.day()) {\n                    case 0:\n                        return '[В прошлое] dddd [в] LT';\n                    case 1:\n                    case 2:\n                    case 4:\n                        return '[В прошлый] dddd [в] LT';\n                    case 3:\n                    case 5:\n                    case 6:\n                        return '[В прошлую] dddd [в] LT';\n                }\n            } else {\n                if (this.day() === 2) {\n                    return '[Во] dddd [в] LT';\n                } else {\n                    return '[В] dddd [в] LT';\n                }\n            }\n        },\n        sameElse: 'L'\n    },\n    relativeTime : {\n        future : 'через %s',\n        past : '%s назад',\n        s : 'несколько секунд',\n        m : relativeTimeWithPlural,\n        mm : relativeTimeWithPlural,\n        h : 'час',\n        hh : relativeTimeWithPlural,\n        d : 'день',\n        dd : relativeTimeWithPlural,\n        M : 'месяц',\n        MM : relativeTimeWithPlural,\n        y : 'год',\n        yy : relativeTimeWithPlural\n    },\n    meridiemParse: /ночи|утра|дня|вечера/i,\n    isPM : function (input) {\n        return /^(дня|вечера)$/.test(input);\n    },\n    meridiem : function (hour, minute, isLower) {\n        if (hour < 4) {\n            return 'ночи';\n        } else if (hour < 12) {\n            return 'утра';\n        } else if (hour < 17) {\n            return 'дня';\n        } else {\n            return 'вечера';\n        }\n    },\n    dayOfMonthOrdinalParse: /\\d{1,2}-(й|го|я)/,\n    ordinal: function (number, period) {\n        switch (period) {\n            case 'M':\n            case 'd':\n            case 'DDD':\n                return number + '-й';\n            case 'D':\n                return number + '-го';\n            case 'w':\n            case 'W':\n                return number + '-я';\n            default:\n                return number;\n        }\n    },\n    week : {\n        dow : 1, // Monday is the first day of the week.\n        doy : 7  // The week that contains Jan 1st is the first week of the year.\n    }\n});\n\nreturn ru;\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/moment/locale/ru.js\n// module id = 100\n// module chunks = 1","/**\n * Check if `obj` is an object.\n *\n * @param {Object} obj\n * @return {Boolean}\n * @api private\n */\n\nfunction isObject(obj) {\n  return null !== obj && 'object' === typeof obj;\n}\n\nmodule.exports = isObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/superagent/lib/is-object.js\n// module id = 101\n// module chunks = 1","/**\n  * vue-router v2.7.0\n  * (c) 2017 Evan You\n  * @license MIT\n  */\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n\ttypeof define === 'function' && define.amd ? define(factory) :\n\t(global.VueRouter = factory());\n}(this, (function () { 'use strict';\n\n/*  */\n\nfunction assert (condition, message) {\n  if (!condition) {\n    throw new Error((\"[vue-router] \" + message))\n  }\n}\n\nfunction warn (condition, message) {\n  if (\"development\" !== 'production' && !condition) {\n    typeof console !== 'undefined' && console.warn((\"[vue-router] \" + message));\n  }\n}\n\nfunction isError (err) {\n  return Object.prototype.toString.call(err).indexOf('Error') > -1\n}\n\nvar View = {\n  name: 'router-view',\n  functional: true,\n  props: {\n    name: {\n      type: String,\n      default: 'default'\n    }\n  },\n  render: function render (_, ref) {\n    var props = ref.props;\n    var children = ref.children;\n    var parent = ref.parent;\n    var data = ref.data;\n\n    data.routerView = true;\n\n    // directly use parent context's createElement() function\n    // so that components rendered by router-view can resolve named slots\n    var h = parent.$createElement;\n    var name = props.name;\n    var route = parent.$route;\n    var cache = parent._routerViewCache || (parent._routerViewCache = {});\n\n    // determine current view depth, also check to see if the tree\n    // has been toggled inactive but kept-alive.\n    var depth = 0;\n    var inactive = false;\n    while (parent && parent._routerRoot !== parent) {\n      if (parent.$vnode && parent.$vnode.data.routerView) {\n        depth++;\n      }\n      if (parent._inactive) {\n        inactive = true;\n      }\n      parent = parent.$parent;\n    }\n    data.routerViewDepth = depth;\n\n    // render previous view if the tree is inactive and kept-alive\n    if (inactive) {\n      return h(cache[name], data, children)\n    }\n\n    var matched = route.matched[depth];\n    // render empty node if no matched route\n    if (!matched) {\n      cache[name] = null;\n      return h()\n    }\n\n    var component = cache[name] = matched.components[name];\n\n    // attach instance registration hook\n    // this will be called in the instance's injected lifecycle hooks\n    data.registerRouteInstance = function (vm, val) {\n      // val could be undefined for unregistration\n      var current = matched.instances[name];\n      if (\n        (val && current !== vm) ||\n        (!val && current === vm)\n      ) {\n        matched.instances[name] = val;\n      }\n    }\n\n    // also regiseter instance in prepatch hook\n    // in case the same component instance is reused across different routes\n    ;(data.hook || (data.hook = {})).prepatch = function (_, vnode) {\n      matched.instances[name] = vnode.componentInstance;\n    };\n\n    // resolve props\n    data.props = resolveProps(route, matched.props && matched.props[name]);\n\n    return h(component, data, children)\n  }\n};\n\nfunction resolveProps (route, config) {\n  switch (typeof config) {\n    case 'undefined':\n      return\n    case 'object':\n      return config\n    case 'function':\n      return config(route)\n    case 'boolean':\n      return config ? route.params : undefined\n    default:\n      {\n        warn(\n          false,\n          \"props in \\\"\" + (route.path) + \"\\\" is a \" + (typeof config) + \", \" +\n          \"expecting an object, function or boolean.\"\n        );\n      }\n  }\n}\n\n/*  */\n\nvar encodeReserveRE = /[!'()*]/g;\nvar encodeReserveReplacer = function (c) { return '%' + c.charCodeAt(0).toString(16); };\nvar commaRE = /%2C/g;\n\n// fixed encodeURIComponent which is more conformant to RFC3986:\n// - escapes [!'()*]\n// - preserve commas\nvar encode = function (str) { return encodeURIComponent(str)\n  .replace(encodeReserveRE, encodeReserveReplacer)\n  .replace(commaRE, ','); };\n\nvar decode = decodeURIComponent;\n\nfunction resolveQuery (\n  query,\n  extraQuery,\n  _parseQuery\n) {\n  if ( extraQuery === void 0 ) extraQuery = {};\n\n  var parse = _parseQuery || parseQuery;\n  var parsedQuery;\n  try {\n    parsedQuery = parse(query || '');\n  } catch (e) {\n    \"development\" !== 'production' && warn(false, e.message);\n    parsedQuery = {};\n  }\n  for (var key in extraQuery) {\n    var val = extraQuery[key];\n    parsedQuery[key] = Array.isArray(val) ? val.slice() : val;\n  }\n  return parsedQuery\n}\n\nfunction parseQuery (query) {\n  var res = {};\n\n  query = query.trim().replace(/^(\\?|#|&)/, '');\n\n  if (!query) {\n    return res\n  }\n\n  query.split('&').forEach(function (param) {\n    var parts = param.replace(/\\+/g, ' ').split('=');\n    var key = decode(parts.shift());\n    var val = parts.length > 0\n      ? decode(parts.join('='))\n      : null;\n\n    if (res[key] === undefined) {\n      res[key] = val;\n    } else if (Array.isArray(res[key])) {\n      res[key].push(val);\n    } else {\n      res[key] = [res[key], val];\n    }\n  });\n\n  return res\n}\n\nfunction stringifyQuery (obj) {\n  var res = obj ? Object.keys(obj).map(function (key) {\n    var val = obj[key];\n\n    if (val === undefined) {\n      return ''\n    }\n\n    if (val === null) {\n      return encode(key)\n    }\n\n    if (Array.isArray(val)) {\n      var result = [];\n      val.forEach(function (val2) {\n        if (val2 === undefined) {\n          return\n        }\n        if (val2 === null) {\n          result.push(encode(key));\n        } else {\n          result.push(encode(key) + '=' + encode(val2));\n        }\n      });\n      return result.join('&')\n    }\n\n    return encode(key) + '=' + encode(val)\n  }).filter(function (x) { return x.length > 0; }).join('&') : null;\n  return res ? (\"?\" + res) : ''\n}\n\n/*  */\n\n\nvar trailingSlashRE = /\\/?$/;\n\nfunction createRoute (\n  record,\n  location,\n  redirectedFrom,\n  router\n) {\n  var stringifyQuery$$1 = router && router.options.stringifyQuery;\n  var route = {\n    name: location.name || (record && record.name),\n    meta: (record && record.meta) || {},\n    path: location.path || '/',\n    hash: location.hash || '',\n    query: location.query || {},\n    params: location.params || {},\n    fullPath: getFullPath(location, stringifyQuery$$1),\n    matched: record ? formatMatch(record) : []\n  };\n  if (redirectedFrom) {\n    route.redirectedFrom = getFullPath(redirectedFrom, stringifyQuery$$1);\n  }\n  return Object.freeze(route)\n}\n\n// the starting route that represents the initial state\nvar START = createRoute(null, {\n  path: '/'\n});\n\nfunction formatMatch (record) {\n  var res = [];\n  while (record) {\n    res.unshift(record);\n    record = record.parent;\n  }\n  return res\n}\n\nfunction getFullPath (\n  ref,\n  _stringifyQuery\n) {\n  var path = ref.path;\n  var query = ref.query; if ( query === void 0 ) query = {};\n  var hash = ref.hash; if ( hash === void 0 ) hash = '';\n\n  var stringify = _stringifyQuery || stringifyQuery;\n  return (path || '/') + stringify(query) + hash\n}\n\nfunction isSameRoute (a, b) {\n  if (b === START) {\n    return a === b\n  } else if (!b) {\n    return false\n  } else if (a.path && b.path) {\n    return (\n      a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') &&\n      a.hash === b.hash &&\n      isObjectEqual(a.query, b.query)\n    )\n  } else if (a.name && b.name) {\n    return (\n      a.name === b.name &&\n      a.hash === b.hash &&\n      isObjectEqual(a.query, b.query) &&\n      isObjectEqual(a.params, b.params)\n    )\n  } else {\n    return false\n  }\n}\n\nfunction isObjectEqual (a, b) {\n  if ( a === void 0 ) a = {};\n  if ( b === void 0 ) b = {};\n\n  var aKeys = Object.keys(a);\n  var bKeys = Object.keys(b);\n  if (aKeys.length !== bKeys.length) {\n    return false\n  }\n  return aKeys.every(function (key) {\n    var aVal = a[key];\n    var bVal = b[key];\n    // check nested equality\n    if (typeof aVal === 'object' && typeof bVal === 'object') {\n      return isObjectEqual(aVal, bVal)\n    }\n    return String(aVal) === String(bVal)\n  })\n}\n\nfunction isIncludedRoute (current, target) {\n  return (\n    current.path.replace(trailingSlashRE, '/').indexOf(\n      target.path.replace(trailingSlashRE, '/')\n    ) === 0 &&\n    (!target.hash || current.hash === target.hash) &&\n    queryIncludes(current.query, target.query)\n  )\n}\n\nfunction queryIncludes (current, target) {\n  for (var key in target) {\n    if (!(key in current)) {\n      return false\n    }\n  }\n  return true\n}\n\n/*  */\n\n// work around weird flow bug\nvar toTypes = [String, Object];\nvar eventTypes = [String, Array];\n\nvar Link = {\n  name: 'router-link',\n  props: {\n    to: {\n      type: toTypes,\n      required: true\n    },\n    tag: {\n      type: String,\n      default: 'a'\n    },\n    exact: Boolean,\n    append: Boolean,\n    replace: Boolean,\n    activeClass: String,\n    exactActiveClass: String,\n    event: {\n      type: eventTypes,\n      default: 'click'\n    }\n  },\n  render: function render (h) {\n    var this$1 = this;\n\n    var router = this.$router;\n    var current = this.$route;\n    var ref = router.resolve(this.to, current, this.append);\n    var location = ref.location;\n    var route = ref.route;\n    var href = ref.href;\n\n    var classes = {};\n    var globalActiveClass = router.options.linkActiveClass;\n    var globalExactActiveClass = router.options.linkExactActiveClass;\n    // Support global empty active class\n    var activeClassFallback = globalActiveClass == null\n            ? 'router-link-active'\n            : globalActiveClass;\n    var exactActiveClassFallback = globalExactActiveClass == null\n            ? 'router-link-exact-active'\n            : globalExactActiveClass;\n    var activeClass = this.activeClass == null\n            ? activeClassFallback\n            : this.activeClass;\n    var exactActiveClass = this.exactActiveClass == null\n            ? exactActiveClassFallback\n            : this.exactActiveClass;\n    var compareTarget = location.path\n      ? createRoute(null, location, null, router)\n      : route;\n\n    classes[exactActiveClass] = isSameRoute(current, compareTarget);\n    classes[activeClass] = this.exact\n      ? classes[exactActiveClass]\n      : isIncludedRoute(current, compareTarget);\n\n    var handler = function (e) {\n      if (guardEvent(e)) {\n        if (this$1.replace) {\n          router.replace(location);\n        } else {\n          router.push(location);\n        }\n      }\n    };\n\n    var on = { click: guardEvent };\n    if (Array.isArray(this.event)) {\n      this.event.forEach(function (e) { on[e] = handler; });\n    } else {\n      on[this.event] = handler;\n    }\n\n    var data = {\n      class: classes\n    };\n\n    if (this.tag === 'a') {\n      data.on = on;\n      data.attrs = { href: href };\n    } else {\n      // find the first <a> child and apply listener and href\n      var a = findAnchor(this.$slots.default);\n      if (a) {\n        // in case the <a> is a static node\n        a.isStatic = false;\n        var extend = _Vue.util.extend;\n        var aData = a.data = extend({}, a.data);\n        aData.on = on;\n        var aAttrs = a.data.attrs = extend({}, a.data.attrs);\n        aAttrs.href = href;\n      } else {\n        // doesn't have <a> child, apply listener to self\n        data.on = on;\n      }\n    }\n\n    return h(this.tag, data, this.$slots.default)\n  }\n};\n\nfunction guardEvent (e) {\n  // don't redirect with control keys\n  if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) { return }\n  // don't redirect when preventDefault called\n  if (e.defaultPrevented) { return }\n  // don't redirect on right click\n  if (e.button !== undefined && e.button !== 0) { return }\n  // don't redirect if `target=\"_blank\"`\n  if (e.currentTarget && e.currentTarget.getAttribute) {\n    var target = e.currentTarget.getAttribute('target');\n    if (/\\b_blank\\b/i.test(target)) { return }\n  }\n  // this may be a Weex event which doesn't have this method\n  if (e.preventDefault) {\n    e.preventDefault();\n  }\n  return true\n}\n\nfunction findAnchor (children) {\n  if (children) {\n    var child;\n    for (var i = 0; i < children.length; i++) {\n      child = children[i];\n      if (child.tag === 'a') {\n        return child\n      }\n      if (child.children && (child = findAnchor(child.children))) {\n        return child\n      }\n    }\n  }\n}\n\nvar _Vue;\n\nfunction install (Vue) {\n  if (install.installed) { return }\n  install.installed = true;\n\n  _Vue = Vue;\n\n  var isDef = function (v) { return v !== undefined; };\n\n  var registerInstance = function (vm, callVal) {\n    var i = vm.$options._parentVnode;\n    if (isDef(i) && isDef(i = i.data) && isDef(i = i.registerRouteInstance)) {\n      i(vm, callVal);\n    }\n  };\n\n  Vue.mixin({\n    beforeCreate: function beforeCreate () {\n      if (isDef(this.$options.router)) {\n        this._routerRoot = this;\n        this._router = this.$options.router;\n        this._router.init(this);\n        Vue.util.defineReactive(this, '_route', this._router.history.current);\n      } else {\n        this._routerRoot = (this.$parent && this.$parent._routerRoot) || this;\n      }\n      registerInstance(this, this);\n    },\n    destroyed: function destroyed () {\n      registerInstance(this);\n    }\n  });\n\n  Object.defineProperty(Vue.prototype, '$router', {\n    get: function get () { return this._routerRoot._router }\n  });\n\n  Object.defineProperty(Vue.prototype, '$route', {\n    get: function get () { return this._routerRoot._route }\n  });\n\n  Vue.component('router-view', View);\n  Vue.component('router-link', Link);\n\n  var strats = Vue.config.optionMergeStrategies;\n  // use the same hook merging strategy for route hooks\n  strats.beforeRouteEnter = strats.beforeRouteLeave = strats.beforeRouteUpdate = strats.created;\n}\n\n/*  */\n\nvar inBrowser = typeof window !== 'undefined';\n\n/*  */\n\nfunction resolvePath (\n  relative,\n  base,\n  append\n) {\n  var firstChar = relative.charAt(0);\n  if (firstChar === '/') {\n    return relative\n  }\n\n  if (firstChar === '?' || firstChar === '#') {\n    return base + relative\n  }\n\n  var stack = base.split('/');\n\n  // remove trailing segment if:\n  // - not appending\n  // - appending to trailing slash (last segment is empty)\n  if (!append || !stack[stack.length - 1]) {\n    stack.pop();\n  }\n\n  // resolve relative path\n  var segments = relative.replace(/^\\//, '').split('/');\n  for (var i = 0; i < segments.length; i++) {\n    var segment = segments[i];\n    if (segment === '..') {\n      stack.pop();\n    } else if (segment !== '.') {\n      stack.push(segment);\n    }\n  }\n\n  // ensure leading slash\n  if (stack[0] !== '') {\n    stack.unshift('');\n  }\n\n  return stack.join('/')\n}\n\nfunction parsePath (path) {\n  var hash = '';\n  var query = '';\n\n  var hashIndex = path.indexOf('#');\n  if (hashIndex >= 0) {\n    hash = path.slice(hashIndex);\n    path = path.slice(0, hashIndex);\n  }\n\n  var queryIndex = path.indexOf('?');\n  if (queryIndex >= 0) {\n    query = path.slice(queryIndex + 1);\n    path = path.slice(0, queryIndex);\n  }\n\n  return {\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\nfunction cleanPath (path) {\n  return path.replace(/\\/\\//g, '/')\n}\n\nvar index$1 = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\n/**\n * Expose `pathToRegexp`.\n */\nvar index = pathToRegexp;\nvar parse_1 = parse;\nvar compile_1 = compile;\nvar tokensToFunction_1 = tokensToFunction;\nvar tokensToRegExp_1 = tokensToRegExp;\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n  // \"/route(\\\\d+)\"  => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n  // \"/*\"            => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n  '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g');\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = [];\n  var key = 0;\n  var index = 0;\n  var path = '';\n  var defaultDelimiter = options && options.delimiter || '/';\n  var res;\n\n  while ((res = PATH_REGEXP.exec(str)) != null) {\n    var m = res[0];\n    var escaped = res[1];\n    var offset = res.index;\n    path += str.slice(index, offset);\n    index = offset + m.length;\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1];\n      continue\n    }\n\n    var next = str[index];\n    var prefix = res[2];\n    var name = res[3];\n    var capture = res[4];\n    var group = res[5];\n    var modifier = res[6];\n    var asterisk = res[7];\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path);\n      path = '';\n    }\n\n    var partial = prefix != null && next != null && next !== prefix;\n    var repeat = modifier === '+' || modifier === '*';\n    var optional = modifier === '?' || modifier === '*';\n    var delimiter = res[2] || defaultDelimiter;\n    var pattern = capture || group;\n\n    tokens.push({\n      name: name || key++,\n      prefix: prefix || '',\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      asterisk: !!asterisk,\n      pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n    });\n  }\n\n  // Match any characters still remaining.\n  if (index < str.length) {\n    path += str.substr(index);\n  }\n\n  // If the path exists, push it onto the end.\n  if (path) {\n    tokens.push(path);\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options))\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n  return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n  return encodeURI(str).replace(/[?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length);\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$');\n    }\n  }\n\n  return function (obj, opts) {\n    var path = '';\n    var data = obj || {};\n    var options = opts || {};\n    var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i];\n\n      if (typeof token === 'string') {\n        path += token;\n\n        continue\n      }\n\n      var value = data[token.name];\n      var segment;\n\n      if (value == null) {\n        if (token.optional) {\n          // Prepend partial segment prefixes.\n          if (token.partial) {\n            path += token.prefix;\n          }\n\n          continue\n        } else {\n          throw new TypeError('Expected \"' + token.name + '\" to be defined')\n        }\n      }\n\n      if (index$1(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) {\n            continue\n          } else {\n            throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n          }\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j]);\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment;\n        }\n\n        continue\n      }\n\n      segment = token.asterisk ? encodeAsterisk(value) : encode(value);\n\n      if (!matches[i].test(segment)) {\n        throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n      }\n\n      path += token.prefix + segment;\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param  {!RegExp} re\n * @param  {Array}   keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n  re.keys = keys;\n  return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {!Array}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g);\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        asterisk: false,\n        pattern: null\n      });\n    }\n  }\n\n  return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array}   keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = [];\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp(path[i], keys, options).source);\n  }\n\n  var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));\n\n  return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {!Array}  keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}          tokens\n * @param  {(Array|Object)=} keys\n * @param  {Object=}         options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  if (!index$1(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  var strict = options.strict;\n  var end = options.end !== false;\n  var route = '';\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i];\n\n    if (typeof token === 'string') {\n      route += escapeString(token);\n    } else {\n      var prefix = escapeString(token.prefix);\n      var capture = '(?:' + token.pattern + ')';\n\n      keys.push(token);\n\n      if (token.repeat) {\n        capture += '(?:' + prefix + capture + ')*';\n      }\n\n      if (token.optional) {\n        if (!token.partial) {\n          capture = '(?:' + prefix + '(' + capture + '))?';\n        } else {\n          capture = prefix + '(' + capture + ')?';\n        }\n      } else {\n        capture = prefix + '(' + capture + ')';\n      }\n\n      route += capture;\n    }\n  }\n\n  var delimiter = escapeString(options.delimiter || '/');\n  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;\n\n  // In non-strict mode we allow a slash at the end of match. If the path to\n  // match already ends with a slash, we remove it for consistency. The slash\n  // is valid at the end of a path match, not in the middle. This is important\n  // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n  if (!strict) {\n    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';\n  }\n\n  if (end) {\n    route += '$';\n  } else {\n    // In non-ending mode, we need the capturing groups to match as much as\n    // possible by using a positive lookahead to the end or next path segment.\n    route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';\n  }\n\n  return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {(Array|Object)=}       keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n  if (!index$1(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, /** @type {!Array} */ (keys))\n  }\n\n  if (index$1(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\n\nindex.parse = parse_1;\nindex.compile = compile_1;\nindex.tokensToFunction = tokensToFunction_1;\nindex.tokensToRegExp = tokensToRegExp_1;\n\n/*  */\n\nvar regexpCompileCache = Object.create(null);\n\nfunction fillParams (\n  path,\n  params,\n  routeMsg\n) {\n  try {\n    var filler =\n      regexpCompileCache[path] ||\n      (regexpCompileCache[path] = index.compile(path));\n    return filler(params || {}, { pretty: true })\n  } catch (e) {\n    {\n      warn(false, (\"missing param for \" + routeMsg + \": \" + (e.message)));\n    }\n    return ''\n  }\n}\n\n/*  */\n\nfunction createRouteMap (\n  routes,\n  oldPathList,\n  oldPathMap,\n  oldNameMap\n) {\n  // the path list is used to control path matching priority\n  var pathList = oldPathList || [];\n  var pathMap = oldPathMap || Object.create(null);\n  var nameMap = oldNameMap || Object.create(null);\n\n  routes.forEach(function (route) {\n    addRouteRecord(pathList, pathMap, nameMap, route);\n  });\n\n  // ensure wildcard routes are always at the end\n  for (var i = 0, l = pathList.length; i < l; i++) {\n    if (pathList[i] === '*') {\n      pathList.push(pathList.splice(i, 1)[0]);\n      l--;\n      i--;\n    }\n  }\n\n  return {\n    pathList: pathList,\n    pathMap: pathMap,\n    nameMap: nameMap\n  }\n}\n\nfunction addRouteRecord (\n  pathList,\n  pathMap,\n  nameMap,\n  route,\n  parent,\n  matchAs\n) {\n  var path = route.path;\n  var name = route.name;\n  {\n    assert(path != null, \"\\\"path\\\" is required in a route configuration.\");\n    assert(\n      typeof route.component !== 'string',\n      \"route config \\\"component\\\" for path: \" + (String(path || name)) + \" cannot be a \" +\n      \"string id. Use an actual component instead.\"\n    );\n  }\n\n  var normalizedPath = normalizePath(path, parent);\n  var pathToRegexpOptions = route.pathToRegexpOptions || {};\n\n  if (typeof route.caseSensitive === 'boolean') {\n    pathToRegexpOptions.sensitive = route.caseSensitive;\n  }\n\n  var record = {\n    path: normalizedPath,\n    regex: compileRouteRegex(normalizedPath, pathToRegexpOptions),\n    components: route.components || { default: route.component },\n    instances: {},\n    name: name,\n    parent: parent,\n    matchAs: matchAs,\n    redirect: route.redirect,\n    beforeEnter: route.beforeEnter,\n    meta: route.meta || {},\n    props: route.props == null\n      ? {}\n      : route.components\n        ? route.props\n        : { default: route.props }\n  };\n\n  if (route.children) {\n    // Warn if route is named, does not redirect and has a default child route.\n    // If users navigate to this route by name, the default child will\n    // not be rendered (GH Issue #629)\n    {\n      if (route.name && !route.redirect && route.children.some(function (child) { return /^\\/?$/.test(child.path); })) {\n        warn(\n          false,\n          \"Named Route '\" + (route.name) + \"' has a default child route. \" +\n          \"When navigating to this named route (:to=\\\"{name: '\" + (route.name) + \"'\\\"), \" +\n          \"the default child route will not be rendered. Remove the name from \" +\n          \"this route and use the name of the default child route for named \" +\n          \"links instead.\"\n        );\n      }\n    }\n    route.children.forEach(function (child) {\n      var childMatchAs = matchAs\n        ? cleanPath((matchAs + \"/\" + (child.path)))\n        : undefined;\n      addRouteRecord(pathList, pathMap, nameMap, child, record, childMatchAs);\n    });\n  }\n\n  if (route.alias !== undefined) {\n    var aliases = Array.isArray(route.alias)\n      ? route.alias\n      : [route.alias];\n\n    aliases.forEach(function (alias) {\n      var aliasRoute = {\n        path: alias,\n        children: route.children\n      };\n      addRouteRecord(\n        pathList,\n        pathMap,\n        nameMap,\n        aliasRoute,\n        parent,\n        record.path || '/' // matchAs\n      );\n    });\n  }\n\n  if (!pathMap[record.path]) {\n    pathList.push(record.path);\n    pathMap[record.path] = record;\n  }\n\n  if (name) {\n    if (!nameMap[name]) {\n      nameMap[name] = record;\n    } else if (\"development\" !== 'production' && !matchAs) {\n      warn(\n        false,\n        \"Duplicate named routes definition: \" +\n        \"{ name: \\\"\" + name + \"\\\", path: \\\"\" + (record.path) + \"\\\" }\"\n      );\n    }\n  }\n}\n\nfunction compileRouteRegex (path, pathToRegexpOptions) {\n  var regex = index(path, [], pathToRegexpOptions);\n  {\n    var keys = {};\n    regex.keys.forEach(function (key) {\n      warn(!keys[key.name], (\"Duplicate param keys in route with path: \\\"\" + path + \"\\\"\"));\n      keys[key.name] = true;\n    });\n  }\n  return regex\n}\n\nfunction normalizePath (path, parent) {\n  path = path.replace(/\\/$/, '');\n  if (path[0] === '/') { return path }\n  if (parent == null) { return path }\n  return cleanPath(((parent.path) + \"/\" + path))\n}\n\n/*  */\n\n\nfunction normalizeLocation (\n  raw,\n  current,\n  append,\n  router\n) {\n  var next = typeof raw === 'string' ? { path: raw } : raw;\n  // named target\n  if (next.name || next._normalized) {\n    return next\n  }\n\n  // relative params\n  if (!next.path && next.params && current) {\n    next = assign({}, next);\n    next._normalized = true;\n    var params = assign(assign({}, current.params), next.params);\n    if (current.name) {\n      next.name = current.name;\n      next.params = params;\n    } else if (current.matched.length) {\n      var rawPath = current.matched[current.matched.length - 1].path;\n      next.path = fillParams(rawPath, params, (\"path \" + (current.path)));\n    } else {\n      warn(false, \"relative params navigation requires a current route.\");\n    }\n    return next\n  }\n\n  var parsedPath = parsePath(next.path || '');\n  var basePath = (current && current.path) || '/';\n  var path = parsedPath.path\n    ? resolvePath(parsedPath.path, basePath, append || next.append)\n    : basePath;\n\n  var query = resolveQuery(\n    parsedPath.query,\n    next.query,\n    router && router.options.parseQuery\n  );\n\n  var hash = next.hash || parsedPath.hash;\n  if (hash && hash.charAt(0) !== '#') {\n    hash = \"#\" + hash;\n  }\n\n  return {\n    _normalized: true,\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\nfunction assign (a, b) {\n  for (var key in b) {\n    a[key] = b[key];\n  }\n  return a\n}\n\n/*  */\n\n\nfunction createMatcher (\n  routes,\n  router\n) {\n  var ref = createRouteMap(routes);\n  var pathList = ref.pathList;\n  var pathMap = ref.pathMap;\n  var nameMap = ref.nameMap;\n\n  function addRoutes (routes) {\n    createRouteMap(routes, pathList, pathMap, nameMap);\n  }\n\n  function match (\n    raw,\n    currentRoute,\n    redirectedFrom\n  ) {\n    var location = normalizeLocation(raw, currentRoute, false, router);\n    var name = location.name;\n\n    if (name) {\n      var record = nameMap[name];\n      {\n        warn(record, (\"Route with name '\" + name + \"' does not exist\"));\n      }\n      if (!record) { return _createRoute(null, location) }\n      var paramNames = record.regex.keys\n        .filter(function (key) { return !key.optional; })\n        .map(function (key) { return key.name; });\n\n      if (typeof location.params !== 'object') {\n        location.params = {};\n      }\n\n      if (currentRoute && typeof currentRoute.params === 'object') {\n        for (var key in currentRoute.params) {\n          if (!(key in location.params) && paramNames.indexOf(key) > -1) {\n            location.params[key] = currentRoute.params[key];\n          }\n        }\n      }\n\n      if (record) {\n        location.path = fillParams(record.path, location.params, (\"named route \\\"\" + name + \"\\\"\"));\n        return _createRoute(record, location, redirectedFrom)\n      }\n    } else if (location.path) {\n      location.params = {};\n      for (var i = 0; i < pathList.length; i++) {\n        var path = pathList[i];\n        var record$1 = pathMap[path];\n        if (matchRoute(record$1.regex, location.path, location.params)) {\n          return _createRoute(record$1, location, redirectedFrom)\n        }\n      }\n    }\n    // no match\n    return _createRoute(null, location)\n  }\n\n  function redirect (\n    record,\n    location\n  ) {\n    var originalRedirect = record.redirect;\n    var redirect = typeof originalRedirect === 'function'\n        ? originalRedirect(createRoute(record, location, null, router))\n        : originalRedirect;\n\n    if (typeof redirect === 'string') {\n      redirect = { path: redirect };\n    }\n\n    if (!redirect || typeof redirect !== 'object') {\n      {\n        warn(\n          false, (\"invalid redirect option: \" + (JSON.stringify(redirect)))\n        );\n      }\n      return _createRoute(null, location)\n    }\n\n    var re = redirect;\n    var name = re.name;\n    var path = re.path;\n    var query = location.query;\n    var hash = location.hash;\n    var params = location.params;\n    query = re.hasOwnProperty('query') ? re.query : query;\n    hash = re.hasOwnProperty('hash') ? re.hash : hash;\n    params = re.hasOwnProperty('params') ? re.params : params;\n\n    if (name) {\n      // resolved named direct\n      var targetRecord = nameMap[name];\n      {\n        assert(targetRecord, (\"redirect failed: named route \\\"\" + name + \"\\\" not found.\"));\n      }\n      return match({\n        _normalized: true,\n        name: name,\n        query: query,\n        hash: hash,\n        params: params\n      }, undefined, location)\n    } else if (path) {\n      // 1. resolve relative redirect\n      var rawPath = resolveRecordPath(path, record);\n      // 2. resolve params\n      var resolvedPath = fillParams(rawPath, params, (\"redirect route with path \\\"\" + rawPath + \"\\\"\"));\n      // 3. rematch with existing query and hash\n      return match({\n        _normalized: true,\n        path: resolvedPath,\n        query: query,\n        hash: hash\n      }, undefined, location)\n    } else {\n      {\n        warn(false, (\"invalid redirect option: \" + (JSON.stringify(redirect))));\n      }\n      return _createRoute(null, location)\n    }\n  }\n\n  function alias (\n    record,\n    location,\n    matchAs\n  ) {\n    var aliasedPath = fillParams(matchAs, location.params, (\"aliased route with path \\\"\" + matchAs + \"\\\"\"));\n    var aliasedMatch = match({\n      _normalized: true,\n      path: aliasedPath\n    });\n    if (aliasedMatch) {\n      var matched = aliasedMatch.matched;\n      var aliasedRecord = matched[matched.length - 1];\n      location.params = aliasedMatch.params;\n      return _createRoute(aliasedRecord, location)\n    }\n    return _createRoute(null, location)\n  }\n\n  function _createRoute (\n    record,\n    location,\n    redirectedFrom\n  ) {\n    if (record && record.redirect) {\n      return redirect(record, redirectedFrom || location)\n    }\n    if (record && record.matchAs) {\n      return alias(record, location, record.matchAs)\n    }\n    return createRoute(record, location, redirectedFrom, router)\n  }\n\n  return {\n    match: match,\n    addRoutes: addRoutes\n  }\n}\n\nfunction matchRoute (\n  regex,\n  path,\n  params\n) {\n  var m = path.match(regex);\n\n  if (!m) {\n    return false\n  } else if (!params) {\n    return true\n  }\n\n  for (var i = 1, len = m.length; i < len; ++i) {\n    var key = regex.keys[i - 1];\n    var val = typeof m[i] === 'string' ? decodeURIComponent(m[i]) : m[i];\n    if (key) {\n      params[key.name] = val;\n    }\n  }\n\n  return true\n}\n\nfunction resolveRecordPath (path, record) {\n  return resolvePath(path, record.parent ? record.parent.path : '/', true)\n}\n\n/*  */\n\n\nvar positionStore = Object.create(null);\n\nfunction setupScroll () {\n  window.addEventListener('popstate', function (e) {\n    saveScrollPosition();\n    if (e.state && e.state.key) {\n      setStateKey(e.state.key);\n    }\n  });\n}\n\nfunction handleScroll (\n  router,\n  to,\n  from,\n  isPop\n) {\n  if (!router.app) {\n    return\n  }\n\n  var behavior = router.options.scrollBehavior;\n  if (!behavior) {\n    return\n  }\n\n  {\n    assert(typeof behavior === 'function', \"scrollBehavior must be a function\");\n  }\n\n  // wait until re-render finishes before scrolling\n  router.app.$nextTick(function () {\n    var position = getScrollPosition();\n    var shouldScroll = behavior(to, from, isPop ? position : null);\n    if (!shouldScroll) {\n      return\n    }\n    var isObject = typeof shouldScroll === 'object';\n    if (isObject && typeof shouldScroll.selector === 'string') {\n      var el = document.querySelector(shouldScroll.selector);\n      if (el) {\n        var offset = shouldScroll.offset && typeof shouldScroll.offset === 'object' ? shouldScroll.offset : {};\n        offset = normalizeOffset(offset);\n        position = getElementPosition(el, offset);\n      } else if (isValidPosition(shouldScroll)) {\n        position = normalizePosition(shouldScroll);\n      }\n    } else if (isObject && isValidPosition(shouldScroll)) {\n      position = normalizePosition(shouldScroll);\n    }\n\n    if (position) {\n      window.scrollTo(position.x, position.y);\n    }\n  });\n}\n\nfunction saveScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    positionStore[key] = {\n      x: window.pageXOffset,\n      y: window.pageYOffset\n    };\n  }\n}\n\nfunction getScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    return positionStore[key]\n  }\n}\n\nfunction getElementPosition (el, offset) {\n  var docEl = document.documentElement;\n  var docRect = docEl.getBoundingClientRect();\n  var elRect = el.getBoundingClientRect();\n  return {\n    x: elRect.left - docRect.left - offset.x,\n    y: elRect.top - docRect.top - offset.y\n  }\n}\n\nfunction isValidPosition (obj) {\n  return isNumber(obj.x) || isNumber(obj.y)\n}\n\nfunction normalizePosition (obj) {\n  return {\n    x: isNumber(obj.x) ? obj.x : window.pageXOffset,\n    y: isNumber(obj.y) ? obj.y : window.pageYOffset\n  }\n}\n\nfunction normalizeOffset (obj) {\n  return {\n    x: isNumber(obj.x) ? obj.x : 0,\n    y: isNumber(obj.y) ? obj.y : 0\n  }\n}\n\nfunction isNumber (v) {\n  return typeof v === 'number'\n}\n\n/*  */\n\nvar supportsPushState = inBrowser && (function () {\n  var ua = window.navigator.userAgent;\n\n  if (\n    (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&\n    ua.indexOf('Mobile Safari') !== -1 &&\n    ua.indexOf('Chrome') === -1 &&\n    ua.indexOf('Windows Phone') === -1\n  ) {\n    return false\n  }\n\n  return window.history && 'pushState' in window.history\n})();\n\n// use User Timing api (if present) for more accurate key precision\nvar Time = inBrowser && window.performance && window.performance.now\n  ? window.performance\n  : Date;\n\nvar _key = genKey();\n\nfunction genKey () {\n  return Time.now().toFixed(3)\n}\n\nfunction getStateKey () {\n  return _key\n}\n\nfunction setStateKey (key) {\n  _key = key;\n}\n\nfunction pushState (url, replace) {\n  saveScrollPosition();\n  // try...catch the pushState call to get around Safari\n  // DOM Exception 18 where it limits to 100 pushState calls\n  var history = window.history;\n  try {\n    if (replace) {\n      history.replaceState({ key: _key }, '', url);\n    } else {\n      _key = genKey();\n      history.pushState({ key: _key }, '', url);\n    }\n  } catch (e) {\n    window.location[replace ? 'replace' : 'assign'](url);\n  }\n}\n\nfunction replaceState (url) {\n  pushState(url, true);\n}\n\n/*  */\n\nfunction runQueue (queue, fn, cb) {\n  var step = function (index) {\n    if (index >= queue.length) {\n      cb();\n    } else {\n      if (queue[index]) {\n        fn(queue[index], function () {\n          step(index + 1);\n        });\n      } else {\n        step(index + 1);\n      }\n    }\n  };\n  step(0);\n}\n\n/*  */\n\nfunction resolveAsyncComponents (matched) {\n  return function (to, from, next) {\n    var hasAsync = false;\n    var pending = 0;\n    var error = null;\n\n    flatMapComponents(matched, function (def, _, match, key) {\n      // if it's a function and doesn't have cid attached,\n      // assume it's an async component resolve function.\n      // we are not using Vue's default async resolving mechanism because\n      // we want to halt the navigation until the incoming component has been\n      // resolved.\n      if (typeof def === 'function' && def.cid === undefined) {\n        hasAsync = true;\n        pending++;\n\n        var resolve = once(function (resolvedDef) {\n          if (resolvedDef.__esModule && resolvedDef.default) {\n            resolvedDef = resolvedDef.default;\n          }\n          // save resolved on async factory in case it's used elsewhere\n          def.resolved = typeof resolvedDef === 'function'\n            ? resolvedDef\n            : _Vue.extend(resolvedDef);\n          match.components[key] = resolvedDef;\n          pending--;\n          if (pending <= 0) {\n            next();\n          }\n        });\n\n        var reject = once(function (reason) {\n          var msg = \"Failed to resolve async component \" + key + \": \" + reason;\n          \"development\" !== 'production' && warn(false, msg);\n          if (!error) {\n            error = isError(reason)\n              ? reason\n              : new Error(msg);\n            next(error);\n          }\n        });\n\n        var res;\n        try {\n          res = def(resolve, reject);\n        } catch (e) {\n          reject(e);\n        }\n        if (res) {\n          if (typeof res.then === 'function') {\n            res.then(resolve, reject);\n          } else {\n            // new syntax in Vue 2.3\n            var comp = res.component;\n            if (comp && typeof comp.then === 'function') {\n              comp.then(resolve, reject);\n            }\n          }\n        }\n      }\n    });\n\n    if (!hasAsync) { next(); }\n  }\n}\n\nfunction flatMapComponents (\n  matched,\n  fn\n) {\n  return flatten(matched.map(function (m) {\n    return Object.keys(m.components).map(function (key) { return fn(\n      m.components[key],\n      m.instances[key],\n      m, key\n    ); })\n  }))\n}\n\nfunction flatten (arr) {\n  return Array.prototype.concat.apply([], arr)\n}\n\n// in Webpack 2, require.ensure now also returns a Promise\n// so the resolve/reject functions may get called an extra time\n// if the user uses an arrow function shorthand that happens to\n// return that Promise.\nfunction once (fn) {\n  var called = false;\n  return function () {\n    var args = [], len = arguments.length;\n    while ( len-- ) args[ len ] = arguments[ len ];\n\n    if (called) { return }\n    called = true;\n    return fn.apply(this, args)\n  }\n}\n\n/*  */\n\nvar History = function History (router, base) {\n  this.router = router;\n  this.base = normalizeBase(base);\n  // start with a route object that stands for \"nowhere\"\n  this.current = START;\n  this.pending = null;\n  this.ready = false;\n  this.readyCbs = [];\n  this.readyErrorCbs = [];\n  this.errorCbs = [];\n};\n\nHistory.prototype.listen = function listen (cb) {\n  this.cb = cb;\n};\n\nHistory.prototype.onReady = function onReady (cb, errorCb) {\n  if (this.ready) {\n    cb();\n  } else {\n    this.readyCbs.push(cb);\n    if (errorCb) {\n      this.readyErrorCbs.push(errorCb);\n    }\n  }\n};\n\nHistory.prototype.onError = function onError (errorCb) {\n  this.errorCbs.push(errorCb);\n};\n\nHistory.prototype.transitionTo = function transitionTo (location, onComplete, onAbort) {\n    var this$1 = this;\n\n  var route = this.router.match(location, this.current);\n  this.confirmTransition(route, function () {\n    this$1.updateRoute(route);\n    onComplete && onComplete(route);\n    this$1.ensureURL();\n\n    // fire ready cbs once\n    if (!this$1.ready) {\n      this$1.ready = true;\n      this$1.readyCbs.forEach(function (cb) { cb(route); });\n    }\n  }, function (err) {\n    if (onAbort) {\n      onAbort(err);\n    }\n    if (err && !this$1.ready) {\n      this$1.ready = true;\n      this$1.readyErrorCbs.forEach(function (cb) { cb(err); });\n    }\n  });\n};\n\nHistory.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {\n    var this$1 = this;\n\n  var current = this.current;\n  var abort = function (err) {\n    if (isError(err)) {\n      if (this$1.errorCbs.length) {\n        this$1.errorCbs.forEach(function (cb) { cb(err); });\n      } else {\n        warn(false, 'uncaught error during route navigation:');\n        console.error(err);\n      }\n    }\n    onAbort && onAbort(err);\n  };\n  if (\n    isSameRoute(route, current) &&\n    // in the case the route map has been dynamically appended to\n    route.matched.length === current.matched.length\n  ) {\n    this.ensureURL();\n    return abort()\n  }\n\n  var ref = resolveQueue(this.current.matched, route.matched);\n    var updated = ref.updated;\n    var deactivated = ref.deactivated;\n    var activated = ref.activated;\n\n  var queue = [].concat(\n    // in-component leave guards\n    extractLeaveGuards(deactivated),\n    // global before hooks\n    this.router.beforeHooks,\n    // in-component update hooks\n    extractUpdateHooks(updated),\n    // in-config enter guards\n    activated.map(function (m) { return m.beforeEnter; }),\n    // async components\n    resolveAsyncComponents(activated)\n  );\n\n  this.pending = route;\n  var iterator = function (hook, next) {\n    if (this$1.pending !== route) {\n      return abort()\n    }\n    try {\n      hook(route, current, function (to) {\n        if (to === false || isError(to)) {\n          // next(false) -> abort navigation, ensure current URL\n          this$1.ensureURL(true);\n          abort(to);\n        } else if (\n          typeof to === 'string' ||\n          (typeof to === 'object' && (\n            typeof to.path === 'string' ||\n            typeof to.name === 'string'\n          ))\n        ) {\n          // next('/') or next({ path: '/' }) -> redirect\n          abort();\n          if (typeof to === 'object' && to.replace) {\n            this$1.replace(to);\n          } else {\n            this$1.push(to);\n          }\n        } else {\n          // confirm transition and pass on the value\n          next(to);\n        }\n      });\n    } catch (e) {\n      abort(e);\n    }\n  };\n\n  runQueue(queue, iterator, function () {\n    var postEnterCbs = [];\n    var isValid = function () { return this$1.current === route; };\n    // wait until async components are resolved before\n    // extracting in-component enter guards\n    var enterGuards = extractEnterGuards(activated, postEnterCbs, isValid);\n    var queue = enterGuards.concat(this$1.router.resolveHooks);\n    runQueue(queue, iterator, function () {\n      if (this$1.pending !== route) {\n        return abort()\n      }\n      this$1.pending = null;\n      onComplete(route);\n      if (this$1.router.app) {\n        this$1.router.app.$nextTick(function () {\n          postEnterCbs.forEach(function (cb) { cb(); });\n        });\n      }\n    });\n  });\n};\n\nHistory.prototype.updateRoute = function updateRoute (route) {\n  var prev = this.current;\n  this.current = route;\n  this.cb && this.cb(route);\n  this.router.afterHooks.forEach(function (hook) {\n    hook && hook(route, prev);\n  });\n};\n\nfunction normalizeBase (base) {\n  if (!base) {\n    if (inBrowser) {\n      // respect <base> tag\n      var baseEl = document.querySelector('base');\n      base = (baseEl && baseEl.getAttribute('href')) || '/';\n      // strip full URL origin\n      base = base.replace(/^https?:\\/\\/[^\\/]+/, '');\n    } else {\n      base = '/';\n    }\n  }\n  // make sure there's the starting slash\n  if (base.charAt(0) !== '/') {\n    base = '/' + base;\n  }\n  // remove trailing slash\n  return base.replace(/\\/$/, '')\n}\n\nfunction resolveQueue (\n  current,\n  next\n) {\n  var i;\n  var max = Math.max(current.length, next.length);\n  for (i = 0; i < max; i++) {\n    if (current[i] !== next[i]) {\n      break\n    }\n  }\n  return {\n    updated: next.slice(0, i),\n    activated: next.slice(i),\n    deactivated: current.slice(i)\n  }\n}\n\nfunction extractGuards (\n  records,\n  name,\n  bind,\n  reverse\n) {\n  var guards = flatMapComponents(records, function (def, instance, match, key) {\n    var guard = extractGuard(def, name);\n    if (guard) {\n      return Array.isArray(guard)\n        ? guard.map(function (guard) { return bind(guard, instance, match, key); })\n        : bind(guard, instance, match, key)\n    }\n  });\n  return flatten(reverse ? guards.reverse() : guards)\n}\n\nfunction extractGuard (\n  def,\n  key\n) {\n  if (typeof def !== 'function') {\n    // extend now so that global mixins are applied.\n    def = _Vue.extend(def);\n  }\n  return def.options[key]\n}\n\nfunction extractLeaveGuards (deactivated) {\n  return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)\n}\n\nfunction extractUpdateHooks (updated) {\n  return extractGuards(updated, 'beforeRouteUpdate', bindGuard)\n}\n\nfunction bindGuard (guard, instance) {\n  if (instance) {\n    return function boundRouteGuard () {\n      return guard.apply(instance, arguments)\n    }\n  }\n}\n\nfunction extractEnterGuards (\n  activated,\n  cbs,\n  isValid\n) {\n  return extractGuards(activated, 'beforeRouteEnter', function (guard, _, match, key) {\n    return bindEnterGuard(guard, match, key, cbs, isValid)\n  })\n}\n\nfunction bindEnterGuard (\n  guard,\n  match,\n  key,\n  cbs,\n  isValid\n) {\n  return function routeEnterGuard (to, from, next) {\n    return guard(to, from, function (cb) {\n      next(cb);\n      if (typeof cb === 'function') {\n        cbs.push(function () {\n          // #750\n          // if a router-view is wrapped with an out-in transition,\n          // the instance may not have been registered at this time.\n          // we will need to poll for registration until current route\n          // is no longer valid.\n          poll(cb, match.instances, key, isValid);\n        });\n      }\n    })\n  }\n}\n\nfunction poll (\n  cb, // somehow flow cannot infer this is a function\n  instances,\n  key,\n  isValid\n) {\n  if (instances[key]) {\n    cb(instances[key]);\n  } else if (isValid()) {\n    setTimeout(function () {\n      poll(cb, instances, key, isValid);\n    }, 16);\n  }\n}\n\n/*  */\n\n\nvar HTML5History = (function (History$$1) {\n  function HTML5History (router, base) {\n    var this$1 = this;\n\n    History$$1.call(this, router, base);\n\n    var expectScroll = router.options.scrollBehavior;\n\n    if (expectScroll) {\n      setupScroll();\n    }\n\n    window.addEventListener('popstate', function (e) {\n      var current = this$1.current;\n      this$1.transitionTo(getLocation(this$1.base), function (route) {\n        if (expectScroll) {\n          handleScroll(router, route, current, true);\n        }\n      });\n    });\n  }\n\n  if ( History$$1 ) HTML5History.__proto__ = History$$1;\n  HTML5History.prototype = Object.create( History$$1 && History$$1.prototype );\n  HTML5History.prototype.constructor = HTML5History;\n\n  HTML5History.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HTML5History.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(location, function (route) {\n      pushState(cleanPath(this$1.base + route.fullPath));\n      handleScroll(this$1.router, route, fromRoute, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(location, function (route) {\n      replaceState(cleanPath(this$1.base + route.fullPath));\n      handleScroll(this$1.router, route, fromRoute, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.ensureURL = function ensureURL (push) {\n    if (getLocation(this.base) !== this.current.fullPath) {\n      var current = cleanPath(this.base + this.current.fullPath);\n      push ? pushState(current) : replaceState(current);\n    }\n  };\n\n  HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getLocation(this.base)\n  };\n\n  return HTML5History;\n}(History));\n\nfunction getLocation (base) {\n  var path = window.location.pathname;\n  if (base && path.indexOf(base) === 0) {\n    path = path.slice(base.length);\n  }\n  return (path || '/') + window.location.search + window.location.hash\n}\n\n/*  */\n\n\nvar HashHistory = (function (History$$1) {\n  function HashHistory (router, base, fallback) {\n    History$$1.call(this, router, base);\n    // check history fallback deeplinking\n    if (fallback && checkFallback(this.base)) {\n      return\n    }\n    ensureSlash();\n  }\n\n  if ( History$$1 ) HashHistory.__proto__ = History$$1;\n  HashHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n  HashHistory.prototype.constructor = HashHistory;\n\n  // this is delayed until the app mounts\n  // to avoid the hashchange listener being fired too early\n  HashHistory.prototype.setupListeners = function setupListeners () {\n    var this$1 = this;\n\n    window.addEventListener('hashchange', function () {\n      if (!ensureSlash()) {\n        return\n      }\n      this$1.transitionTo(getHash(), function (route) {\n        replaceHash(route.fullPath);\n      });\n    });\n  };\n\n  HashHistory.prototype.push = function push (location, onComplete, onAbort) {\n    this.transitionTo(location, function (route) {\n      pushHash(route.fullPath);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    this.transitionTo(location, function (route) {\n      replaceHash(route.fullPath);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HashHistory.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HashHistory.prototype.ensureURL = function ensureURL (push) {\n    var current = this.current.fullPath;\n    if (getHash() !== current) {\n      push ? pushHash(current) : replaceHash(current);\n    }\n  };\n\n  HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getHash()\n  };\n\n  return HashHistory;\n}(History));\n\nfunction checkFallback (base) {\n  var location = getLocation(base);\n  if (!/^\\/#/.test(location)) {\n    window.location.replace(\n      cleanPath(base + '/#' + location)\n    );\n    return true\n  }\n}\n\nfunction ensureSlash () {\n  var path = getHash();\n  if (path.charAt(0) === '/') {\n    return true\n  }\n  replaceHash('/' + path);\n  return false\n}\n\nfunction getHash () {\n  // We can't use window.location.hash here because it's not\n  // consistent across browsers - Firefox will pre-decode it!\n  var href = window.location.href;\n  var index = href.indexOf('#');\n  return index === -1 ? '' : href.slice(index + 1)\n}\n\nfunction pushHash (path) {\n  window.location.hash = path;\n}\n\nfunction replaceHash (path) {\n  var href = window.location.href;\n  var i = href.indexOf('#');\n  var base = i >= 0 ? href.slice(0, i) : href;\n  window.location.replace((base + \"#\" + path));\n}\n\n/*  */\n\n\nvar AbstractHistory = (function (History$$1) {\n  function AbstractHistory (router, base) {\n    History$$1.call(this, router, base);\n    this.stack = [];\n    this.index = -1;\n  }\n\n  if ( History$$1 ) AbstractHistory.__proto__ = History$$1;\n  AbstractHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n  AbstractHistory.prototype.constructor = AbstractHistory;\n\n  AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      this$1.stack = this$1.stack.slice(0, this$1.index + 1).concat(route);\n      this$1.index++;\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      this$1.stack = this$1.stack.slice(0, this$1.index).concat(route);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  AbstractHistory.prototype.go = function go (n) {\n    var this$1 = this;\n\n    var targetIndex = this.index + n;\n    if (targetIndex < 0 || targetIndex >= this.stack.length) {\n      return\n    }\n    var route = this.stack[targetIndex];\n    this.confirmTransition(route, function () {\n      this$1.index = targetIndex;\n      this$1.updateRoute(route);\n    });\n  };\n\n  AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    var current = this.stack[this.stack.length - 1];\n    return current ? current.fullPath : '/'\n  };\n\n  AbstractHistory.prototype.ensureURL = function ensureURL () {\n    // noop\n  };\n\n  return AbstractHistory;\n}(History));\n\n/*  */\n\nvar VueRouter = function VueRouter (options) {\n  if ( options === void 0 ) options = {};\n\n  this.app = null;\n  this.apps = [];\n  this.options = options;\n  this.beforeHooks = [];\n  this.resolveHooks = [];\n  this.afterHooks = [];\n  this.matcher = createMatcher(options.routes || [], this);\n\n  var mode = options.mode || 'hash';\n  this.fallback = mode === 'history' && !supportsPushState && options.fallback !== false;\n  if (this.fallback) {\n    mode = 'hash';\n  }\n  if (!inBrowser) {\n    mode = 'abstract';\n  }\n  this.mode = mode;\n\n  switch (mode) {\n    case 'history':\n      this.history = new HTML5History(this, options.base);\n      break\n    case 'hash':\n      this.history = new HashHistory(this, options.base, this.fallback);\n      break\n    case 'abstract':\n      this.history = new AbstractHistory(this, options.base);\n      break\n    default:\n      {\n        assert(false, (\"invalid mode: \" + mode));\n      }\n  }\n};\n\nvar prototypeAccessors = { currentRoute: {} };\n\nVueRouter.prototype.match = function match (\n  raw,\n  current,\n  redirectedFrom\n) {\n  return this.matcher.match(raw, current, redirectedFrom)\n};\n\nprototypeAccessors.currentRoute.get = function () {\n  return this.history && this.history.current\n};\n\nVueRouter.prototype.init = function init (app /* Vue component instance */) {\n    var this$1 = this;\n\n  \"development\" !== 'production' && assert(\n    install.installed,\n    \"not installed. Make sure to call `Vue.use(VueRouter)` \" +\n    \"before creating root instance.\"\n  );\n\n  this.apps.push(app);\n\n  // main app already initialized.\n  if (this.app) {\n    return\n  }\n\n  this.app = app;\n\n  var history = this.history;\n\n  if (history instanceof HTML5History) {\n    history.transitionTo(history.getCurrentLocation());\n  } else if (history instanceof HashHistory) {\n    var setupHashListener = function () {\n      history.setupListeners();\n    };\n    history.transitionTo(\n      history.getCurrentLocation(),\n      setupHashListener,\n      setupHashListener\n    );\n  }\n\n  history.listen(function (route) {\n    this$1.apps.forEach(function (app) {\n      app._route = route;\n    });\n  });\n};\n\nVueRouter.prototype.beforeEach = function beforeEach (fn) {\n  return registerHook(this.beforeHooks, fn)\n};\n\nVueRouter.prototype.beforeResolve = function beforeResolve (fn) {\n  return registerHook(this.resolveHooks, fn)\n};\n\nVueRouter.prototype.afterEach = function afterEach (fn) {\n  return registerHook(this.afterHooks, fn)\n};\n\nVueRouter.prototype.onReady = function onReady (cb, errorCb) {\n  this.history.onReady(cb, errorCb);\n};\n\nVueRouter.prototype.onError = function onError (errorCb) {\n  this.history.onError(errorCb);\n};\n\nVueRouter.prototype.push = function push (location, onComplete, onAbort) {\n  this.history.push(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.replace = function replace (location, onComplete, onAbort) {\n  this.history.replace(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.go = function go (n) {\n  this.history.go(n);\n};\n\nVueRouter.prototype.back = function back () {\n  this.go(-1);\n};\n\nVueRouter.prototype.forward = function forward () {\n  this.go(1);\n};\n\nVueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {\n  var route = to\n    ? to.matched\n      ? to\n      : this.resolve(to).route\n    : this.currentRoute;\n  if (!route) {\n    return []\n  }\n  return [].concat.apply([], route.matched.map(function (m) {\n    return Object.keys(m.components).map(function (key) {\n      return m.components[key]\n    })\n  }))\n};\n\nVueRouter.prototype.resolve = function resolve (\n  to,\n  current,\n  append\n) {\n  var location = normalizeLocation(\n    to,\n    current || this.history.current,\n    append,\n    this\n  );\n  var route = this.match(location, current);\n  var fullPath = route.redirectedFrom || route.fullPath;\n  var base = this.history.base;\n  var href = createHref(base, fullPath, this.mode);\n  return {\n    location: location,\n    route: route,\n    href: href,\n    // for backwards compat\n    normalizedTo: location,\n    resolved: route\n  }\n};\n\nVueRouter.prototype.addRoutes = function addRoutes (routes) {\n  this.matcher.addRoutes(routes);\n  if (this.history.current !== START) {\n    this.history.transitionTo(this.history.getCurrentLocation());\n  }\n};\n\nObject.defineProperties( VueRouter.prototype, prototypeAccessors );\n\nfunction registerHook (list, fn) {\n  list.push(fn);\n  return function () {\n    var i = list.indexOf(fn);\n    if (i > -1) { list.splice(i, 1); }\n  }\n}\n\nfunction createHref (base, fullPath, mode) {\n  var path = mode === 'hash' ? '#' + fullPath : fullPath;\n  return base ? cleanPath(base + '/' + path) : path\n}\n\nVueRouter.install = install;\nVueRouter.version = '2.7.0';\n\nif (inBrowser && window.Vue) {\n  window.Vue.use(VueRouter);\n}\n\nreturn VueRouter;\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-router/dist/vue-router.js\n// module id = 102\n// module chunks = 1","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//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 11\n// module chunks = 1","/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\n\nvar stylesInDom = {};\n\nvar\tmemoize = function (fn) {\n\tvar memo;\n\n\treturn function () {\n\t\tif (typeof memo === \"undefined\") memo = fn.apply(this, arguments);\n\t\treturn memo;\n\t};\n};\n\nvar isOldIE = memoize(function () {\n\t// Test for IE <= 9 as proposed by Browserhacks\n\t// @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805\n\t// Tests for existence of standard globals is to allow style-loader\n\t// to operate correctly into non-standard environments\n\t// @see https://github.com/webpack-contrib/style-loader/issues/177\n\treturn window && document && document.all && !window.atob;\n});\n\nvar getElement = (function (fn) {\n\tvar memo = {};\n\n\treturn function(selector) {\n\t\tif (typeof memo[selector] === \"undefined\") {\n\t\t\tmemo[selector] = fn.call(this, selector);\n\t\t}\n\n\t\treturn memo[selector]\n\t};\n})(function (target) {\n\treturn document.querySelector(target)\n});\n\nvar singleton = null;\nvar\tsingletonCounter = 0;\nvar\tstylesInsertedAtTop = [];\n\nvar\tfixUrls = require(\"./urls\");\n\nmodule.exports = function(list, options) {\n\tif (typeof DEBUG !== \"undefined\" && DEBUG) {\n\t\tif (typeof document !== \"object\") throw new Error(\"The style-loader cannot be used in a non-browser environment\");\n\t}\n\n\toptions = options || {};\n\n\toptions.attrs = typeof options.attrs === \"object\" ? options.attrs : {};\n\n\t// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\n\t// tags it will allow on a page\n\tif (!options.singleton) options.singleton = isOldIE();\n\n\t// By default, add <style> tags to the <head> element\n\tif (!options.insertInto) options.insertInto = \"head\";\n\n\t// By default, add <style> tags to the bottom of the target\n\tif (!options.insertAt) options.insertAt = \"bottom\";\n\n\tvar styles = listToStyles(list, options);\n\n\taddStylesToDom(styles, options);\n\n\treturn function update (newList) {\n\t\tvar mayRemove = [];\n\n\t\tfor (var i = 0; i < styles.length; i++) {\n\t\t\tvar item = styles[i];\n\t\t\tvar domStyle = stylesInDom[item.id];\n\n\t\t\tdomStyle.refs--;\n\t\t\tmayRemove.push(domStyle);\n\t\t}\n\n\t\tif(newList) {\n\t\t\tvar newStyles = listToStyles(newList, options);\n\t\t\taddStylesToDom(newStyles, options);\n\t\t}\n\n\t\tfor (var i = 0; i < mayRemove.length; i++) {\n\t\t\tvar domStyle = mayRemove[i];\n\n\t\t\tif(domStyle.refs === 0) {\n\t\t\t\tfor (var j = 0; j < domStyle.parts.length; j++) domStyle.parts[j]();\n\n\t\t\t\tdelete stylesInDom[domStyle.id];\n\t\t\t}\n\t\t}\n\t};\n};\n\nfunction addStylesToDom (styles, options) {\n\tfor (var i = 0; i < styles.length; i++) {\n\t\tvar item = styles[i];\n\t\tvar domStyle = stylesInDom[item.id];\n\n\t\tif(domStyle) {\n\t\t\tdomStyle.refs++;\n\n\t\t\tfor(var j = 0; j < domStyle.parts.length; j++) {\n\t\t\t\tdomStyle.parts[j](item.parts[j]);\n\t\t\t}\n\n\t\t\tfor(; j < item.parts.length; j++) {\n\t\t\t\tdomStyle.parts.push(addStyle(item.parts[j], options));\n\t\t\t}\n\t\t} else {\n\t\t\tvar parts = [];\n\n\t\t\tfor(var j = 0; j < item.parts.length; j++) {\n\t\t\t\tparts.push(addStyle(item.parts[j], options));\n\t\t\t}\n\n\t\t\tstylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};\n\t\t}\n\t}\n}\n\nfunction listToStyles (list, options) {\n\tvar styles = [];\n\tvar newStyles = {};\n\n\tfor (var i = 0; i < list.length; i++) {\n\t\tvar item = list[i];\n\t\tvar id = options.base ? item[0] + options.base : item[0];\n\t\tvar css = item[1];\n\t\tvar media = item[2];\n\t\tvar sourceMap = item[3];\n\t\tvar part = {css: css, media: media, sourceMap: sourceMap};\n\n\t\tif(!newStyles[id]) styles.push(newStyles[id] = {id: id, parts: [part]});\n\t\telse newStyles[id].parts.push(part);\n\t}\n\n\treturn styles;\n}\n\nfunction insertStyleElement (options, style) {\n\tvar target = getElement(options.insertInto)\n\n\tif (!target) {\n\t\tthrow new Error(\"Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid.\");\n\t}\n\n\tvar lastStyleElementInsertedAtTop = stylesInsertedAtTop[stylesInsertedAtTop.length - 1];\n\n\tif (options.insertAt === \"top\") {\n\t\tif (!lastStyleElementInsertedAtTop) {\n\t\t\ttarget.insertBefore(style, target.firstChild);\n\t\t} else if (lastStyleElementInsertedAtTop.nextSibling) {\n\t\t\ttarget.insertBefore(style, lastStyleElementInsertedAtTop.nextSibling);\n\t\t} else {\n\t\t\ttarget.appendChild(style);\n\t\t}\n\t\tstylesInsertedAtTop.push(style);\n\t} else if (options.insertAt === \"bottom\") {\n\t\ttarget.appendChild(style);\n\t} else {\n\t\tthrow new Error(\"Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.\");\n\t}\n}\n\nfunction removeStyleElement (style) {\n\tif (style.parentNode === null) return false;\n\tstyle.parentNode.removeChild(style);\n\n\tvar idx = stylesInsertedAtTop.indexOf(style);\n\tif(idx >= 0) {\n\t\tstylesInsertedAtTop.splice(idx, 1);\n\t}\n}\n\nfunction createStyleElement (options) {\n\tvar style = document.createElement(\"style\");\n\n\toptions.attrs.type = \"text/css\";\n\n\taddAttrs(style, options.attrs);\n\tinsertStyleElement(options, style);\n\n\treturn style;\n}\n\nfunction createLinkElement (options) {\n\tvar link = document.createElement(\"link\");\n\n\toptions.attrs.type = \"text/css\";\n\toptions.attrs.rel = \"stylesheet\";\n\n\taddAttrs(link, options.attrs);\n\tinsertStyleElement(options, link);\n\n\treturn link;\n}\n\nfunction addAttrs (el, attrs) {\n\tObject.keys(attrs).forEach(function (key) {\n\t\tel.setAttribute(key, attrs[key]);\n\t});\n}\n\nfunction addStyle (obj, options) {\n\tvar style, update, remove, result;\n\n\t// If a transform function was defined, run it on the css\n\tif (options.transform && obj.css) {\n\t    result = options.transform(obj.css);\n\n\t    if (result) {\n\t    \t// If transform returns a value, use that instead of the original css.\n\t    \t// This allows running runtime transformations on the css.\n\t    \tobj.css = result;\n\t    } else {\n\t    \t// If the transform function returns a falsy value, don't add this css.\n\t    \t// This allows conditional loading of css\n\t    \treturn function() {\n\t    \t\t// noop\n\t    \t};\n\t    }\n\t}\n\n\tif (options.singleton) {\n\t\tvar styleIndex = singletonCounter++;\n\n\t\tstyle = singleton || (singleton = createStyleElement(options));\n\n\t\tupdate = applyToSingletonTag.bind(null, style, styleIndex, false);\n\t\tremove = applyToSingletonTag.bind(null, style, styleIndex, true);\n\n\t} else if (\n\t\tobj.sourceMap &&\n\t\ttypeof URL === \"function\" &&\n\t\ttypeof URL.createObjectURL === \"function\" &&\n\t\ttypeof URL.revokeObjectURL === \"function\" &&\n\t\ttypeof Blob === \"function\" &&\n\t\ttypeof btoa === \"function\"\n\t) {\n\t\tstyle = createLinkElement(options);\n\t\tupdate = updateLink.bind(null, style, options);\n\t\tremove = function () {\n\t\t\tremoveStyleElement(style);\n\n\t\t\tif(style.href) URL.revokeObjectURL(style.href);\n\t\t};\n\t} else {\n\t\tstyle = createStyleElement(options);\n\t\tupdate = applyToTag.bind(null, style);\n\t\tremove = function () {\n\t\t\tremoveStyleElement(style);\n\t\t};\n\t}\n\n\tupdate(obj);\n\n\treturn function updateStyle (newObj) {\n\t\tif (newObj) {\n\t\t\tif (\n\t\t\t\tnewObj.css === obj.css &&\n\t\t\t\tnewObj.media === obj.media &&\n\t\t\t\tnewObj.sourceMap === obj.sourceMap\n\t\t\t) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tupdate(obj = newObj);\n\t\t} else {\n\t\t\tremove();\n\t\t}\n\t};\n}\n\nvar replaceText = (function () {\n\tvar textStore = [];\n\n\treturn function (index, replacement) {\n\t\ttextStore[index] = replacement;\n\n\t\treturn textStore.filter(Boolean).join('\\n');\n\t};\n})();\n\nfunction applyToSingletonTag (style, index, remove, obj) {\n\tvar css = remove ? \"\" : obj.css;\n\n\tif (style.styleSheet) {\n\t\tstyle.styleSheet.cssText = replaceText(index, css);\n\t} else {\n\t\tvar cssNode = document.createTextNode(css);\n\t\tvar childNodes = style.childNodes;\n\n\t\tif (childNodes[index]) style.removeChild(childNodes[index]);\n\n\t\tif (childNodes.length) {\n\t\t\tstyle.insertBefore(cssNode, childNodes[index]);\n\t\t} else {\n\t\t\tstyle.appendChild(cssNode);\n\t\t}\n\t}\n}\n\nfunction applyToTag (style, obj) {\n\tvar css = obj.css;\n\tvar media = obj.media;\n\n\tif(media) {\n\t\tstyle.setAttribute(\"media\", media)\n\t}\n\n\tif(style.styleSheet) {\n\t\tstyle.styleSheet.cssText = css;\n\t} else {\n\t\twhile(style.firstChild) {\n\t\t\tstyle.removeChild(style.firstChild);\n\t\t}\n\n\t\tstyle.appendChild(document.createTextNode(css));\n\t}\n}\n\nfunction updateLink (link, options, obj) {\n\tvar css = obj.css;\n\tvar sourceMap = obj.sourceMap;\n\n\t/*\n\t\tIf convertToAbsoluteUrls isn't defined, but sourcemaps are enabled\n\t\tand there is no publicPath defined then lets turn convertToAbsoluteUrls\n\t\ton by default.  Otherwise default to the convertToAbsoluteUrls option\n\t\tdirectly\n\t*/\n\tvar autoFixUrls = options.convertToAbsoluteUrls === undefined && sourceMap;\n\n\tif (options.convertToAbsoluteUrls || autoFixUrls) {\n\t\tcss = fixUrls(css);\n\t}\n\n\tif (sourceMap) {\n\t\t// http://stackoverflow.com/a/26603875\n\t\tcss += \"\\n/*# sourceMappingURL=data:application/json;base64,\" + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + \" */\";\n\t}\n\n\tvar blob = new Blob([css], { type: \"text/css\" });\n\n\tvar oldSrc = link.href;\n\n\tlink.href = URL.createObjectURL(blob);\n\n\tif(oldSrc) URL.revokeObjectURL(oldSrc);\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/style-loader/lib/addStyles.js\n// module id = 1171\n// module chunks = 1","/**\n * Enforces a single instance of the Raven client, and the\n * main entry point for Raven. If you are a consumer of the\n * Raven library, you SHOULD load this file (vs raven.js).\n **/\n\n'use strict';\n\nvar RavenConstructor = require('./raven');\n\n// This is to be defensive in environments where window does not exist (see https://github.com/getsentry/raven-js/pull/785)\nvar _window = typeof window !== 'undefined' ? window\n            : typeof global !== 'undefined' ? global\n            : typeof self !== 'undefined' ? self\n            : {};\nvar _Raven = _window.Raven;\n\nvar Raven = new RavenConstructor();\n\n/*\n * Allow multiple versions of Raven to be installed.\n * Strip Raven from the global context and returns the instance.\n *\n * @return {Raven}\n */\nRaven.noConflict = function () {\n\t_window.Raven = _Raven;\n\treturn Raven;\n};\n\nRaven.afterLoad();\n\nmodule.exports = Raven;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/raven-js/src/singleton.js\n// module id = 139\n// module chunks = 1","//! moment.js\n//! version : 2.18.1\n//! authors : Tim Wood, Iskren Chernev, Moment.js contributors\n//! license : MIT\n//! momentjs.com\n\n;(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n    typeof define === 'function' && define.amd ? define(factory) :\n    global.moment = factory()\n}(this, (function () { 'use strict';\n\nvar hookCallback;\n\nfunction hooks () {\n    return hookCallback.apply(null, arguments);\n}\n\n// This is done to register the method called with moment()\n// without creating circular dependencies.\nfunction setHookCallback (callback) {\n    hookCallback = callback;\n}\n\nfunction isArray(input) {\n    return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';\n}\n\nfunction isObject(input) {\n    // IE8 will treat undefined and null as object if it wasn't for\n    // input != null\n    return input != null && Object.prototype.toString.call(input) === '[object Object]';\n}\n\nfunction isObjectEmpty(obj) {\n    var k;\n    for (k in obj) {\n        // even if its not own property I'd still call it non-empty\n        return false;\n    }\n    return true;\n}\n\nfunction isUndefined(input) {\n    return input === void 0;\n}\n\nfunction isNumber(input) {\n    return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';\n}\n\nfunction isDate(input) {\n    return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';\n}\n\nfunction map(arr, fn) {\n    var res = [], i;\n    for (i = 0; i < arr.length; ++i) {\n        res.push(fn(arr[i], i));\n    }\n    return res;\n}\n\nfunction hasOwnProp(a, b) {\n    return Object.prototype.hasOwnProperty.call(a, b);\n}\n\nfunction extend(a, b) {\n    for (var i in b) {\n        if (hasOwnProp(b, i)) {\n            a[i] = b[i];\n        }\n    }\n\n    if (hasOwnProp(b, 'toString')) {\n        a.toString = b.toString;\n    }\n\n    if (hasOwnProp(b, 'valueOf')) {\n        a.valueOf = b.valueOf;\n    }\n\n    return a;\n}\n\nfunction createUTC (input, format, locale, strict) {\n    return createLocalOrUTC(input, format, locale, strict, true).utc();\n}\n\nfunction defaultParsingFlags() {\n    // We need to deep clone this object.\n    return {\n        empty           : false,\n        unusedTokens    : [],\n        unusedInput     : [],\n        overflow        : -2,\n        charsLeftOver   : 0,\n        nullInput       : false,\n        invalidMonth    : null,\n        invalidFormat   : false,\n        userInvalidated : false,\n        iso             : false,\n        parsedDateParts : [],\n        meridiem        : null,\n        rfc2822         : false,\n        weekdayMismatch : false\n    };\n}\n\nfunction getParsingFlags(m) {\n    if (m._pf == null) {\n        m._pf = defaultParsingFlags();\n    }\n    return m._pf;\n}\n\nvar some;\nif (Array.prototype.some) {\n    some = Array.prototype.some;\n} else {\n    some = function (fun) {\n        var t = Object(this);\n        var len = t.length >>> 0;\n\n        for (var i = 0; i < len; i++) {\n            if (i in t && fun.call(this, t[i], i, t)) {\n                return true;\n            }\n        }\n\n        return false;\n    };\n}\n\nvar some$1 = some;\n\nfunction isValid(m) {\n    if (m._isValid == null) {\n        var flags = getParsingFlags(m);\n        var parsedParts = some$1.call(flags.parsedDateParts, function (i) {\n            return i != null;\n        });\n        var isNowValid = !isNaN(m._d.getTime()) &&\n            flags.overflow < 0 &&\n            !flags.empty &&\n            !flags.invalidMonth &&\n            !flags.invalidWeekday &&\n            !flags.nullInput &&\n            !flags.invalidFormat &&\n            !flags.userInvalidated &&\n            (!flags.meridiem || (flags.meridiem && parsedParts));\n\n        if (m._strict) {\n            isNowValid = isNowValid &&\n                flags.charsLeftOver === 0 &&\n                flags.unusedTokens.length === 0 &&\n                flags.bigHour === undefined;\n        }\n\n        if (Object.isFrozen == null || !Object.isFrozen(m)) {\n            m._isValid = isNowValid;\n        }\n        else {\n            return isNowValid;\n        }\n    }\n    return m._isValid;\n}\n\nfunction createInvalid (flags) {\n    var m = createUTC(NaN);\n    if (flags != null) {\n        extend(getParsingFlags(m), flags);\n    }\n    else {\n        getParsingFlags(m).userInvalidated = true;\n    }\n\n    return m;\n}\n\n// Plugins that add properties should also add the key here (null value),\n// so we can properly clone ourselves.\nvar momentProperties = hooks.momentProperties = [];\n\nfunction copyConfig(to, from) {\n    var i, prop, val;\n\n    if (!isUndefined(from._isAMomentObject)) {\n        to._isAMomentObject = from._isAMomentObject;\n    }\n    if (!isUndefined(from._i)) {\n        to._i = from._i;\n    }\n    if (!isUndefined(from._f)) {\n        to._f = from._f;\n    }\n    if (!isUndefined(from._l)) {\n        to._l = from._l;\n    }\n    if (!isUndefined(from._strict)) {\n        to._strict = from._strict;\n    }\n    if (!isUndefined(from._tzm)) {\n        to._tzm = from._tzm;\n    }\n    if (!isUndefined(from._isUTC)) {\n        to._isUTC = from._isUTC;\n    }\n    if (!isUndefined(from._offset)) {\n        to._offset = from._offset;\n    }\n    if (!isUndefined(from._pf)) {\n        to._pf = getParsingFlags(from);\n    }\n    if (!isUndefined(from._locale)) {\n        to._locale = from._locale;\n    }\n\n    if (momentProperties.length > 0) {\n        for (i = 0; i < momentProperties.length; i++) {\n            prop = momentProperties[i];\n            val = from[prop];\n            if (!isUndefined(val)) {\n                to[prop] = val;\n            }\n        }\n    }\n\n    return to;\n}\n\nvar updateInProgress = false;\n\n// Moment prototype object\nfunction Moment(config) {\n    copyConfig(this, config);\n    this._d = new Date(config._d != null ? config._d.getTime() : NaN);\n    if (!this.isValid()) {\n        this._d = new Date(NaN);\n    }\n    // Prevent infinite loop in case updateOffset creates new moment\n    // objects.\n    if (updateInProgress === false) {\n        updateInProgress = true;\n        hooks.updateOffset(this);\n        updateInProgress = false;\n    }\n}\n\nfunction isMoment (obj) {\n    return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);\n}\n\nfunction absFloor (number) {\n    if (number < 0) {\n        // -0 -> 0\n        return Math.ceil(number) || 0;\n    } else {\n        return Math.floor(number);\n    }\n}\n\nfunction toInt(argumentForCoercion) {\n    var coercedNumber = +argumentForCoercion,\n        value = 0;\n\n    if (coercedNumber !== 0 && isFinite(coercedNumber)) {\n        value = absFloor(coercedNumber);\n    }\n\n    return value;\n}\n\n// compare two arrays, return the number of differences\nfunction compareArrays(array1, array2, dontConvert) {\n    var len = Math.min(array1.length, array2.length),\n        lengthDiff = Math.abs(array1.length - array2.length),\n        diffs = 0,\n        i;\n    for (i = 0; i < len; i++) {\n        if ((dontConvert && array1[i] !== array2[i]) ||\n            (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {\n            diffs++;\n        }\n    }\n    return diffs + lengthDiff;\n}\n\nfunction warn(msg) {\n    if (hooks.suppressDeprecationWarnings === false &&\n            (typeof console !==  'undefined') && console.warn) {\n        console.warn('Deprecation warning: ' + msg);\n    }\n}\n\nfunction deprecate(msg, fn) {\n    var firstTime = true;\n\n    return extend(function () {\n        if (hooks.deprecationHandler != null) {\n            hooks.deprecationHandler(null, msg);\n        }\n        if (firstTime) {\n            var args = [];\n            var arg;\n            for (var i = 0; i < arguments.length; i++) {\n                arg = '';\n                if (typeof arguments[i] === 'object') {\n                    arg += '\\n[' + i + '] ';\n                    for (var key in arguments[0]) {\n                        arg += key + ': ' + arguments[0][key] + ', ';\n                    }\n                    arg = arg.slice(0, -2); // Remove trailing comma and space\n                } else {\n                    arg = arguments[i];\n                }\n                args.push(arg);\n            }\n            warn(msg + '\\nArguments: ' + Array.prototype.slice.call(args).join('') + '\\n' + (new Error()).stack);\n            firstTime = false;\n        }\n        return fn.apply(this, arguments);\n    }, fn);\n}\n\nvar deprecations = {};\n\nfunction deprecateSimple(name, msg) {\n    if (hooks.deprecationHandler != null) {\n        hooks.deprecationHandler(name, msg);\n    }\n    if (!deprecations[name]) {\n        warn(msg);\n        deprecations[name] = true;\n    }\n}\n\nhooks.suppressDeprecationWarnings = false;\nhooks.deprecationHandler = null;\n\nfunction isFunction(input) {\n    return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';\n}\n\nfunction set (config) {\n    var prop, i;\n    for (i in config) {\n        prop = config[i];\n        if (isFunction(prop)) {\n            this[i] = prop;\n        } else {\n            this['_' + i] = prop;\n        }\n    }\n    this._config = config;\n    // Lenient ordinal parsing accepts just a number in addition to\n    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.\n    // TODO: Remove \"ordinalParse\" fallback in next major release.\n    this._dayOfMonthOrdinalParseLenient = new RegExp(\n        (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +\n            '|' + (/\\d{1,2}/).source);\n}\n\nfunction mergeConfigs(parentConfig, childConfig) {\n    var res = extend({}, parentConfig), prop;\n    for (prop in childConfig) {\n        if (hasOwnProp(childConfig, prop)) {\n            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {\n                res[prop] = {};\n                extend(res[prop], parentConfig[prop]);\n                extend(res[prop], childConfig[prop]);\n            } else if (childConfig[prop] != null) {\n                res[prop] = childConfig[prop];\n            } else {\n                delete res[prop];\n            }\n        }\n    }\n    for (prop in parentConfig) {\n        if (hasOwnProp(parentConfig, prop) &&\n                !hasOwnProp(childConfig, prop) &&\n                isObject(parentConfig[prop])) {\n            // make sure changes to properties don't modify parent config\n            res[prop] = extend({}, res[prop]);\n        }\n    }\n    return res;\n}\n\nfunction Locale(config) {\n    if (config != null) {\n        this.set(config);\n    }\n}\n\nvar keys;\n\nif (Object.keys) {\n    keys = Object.keys;\n} else {\n    keys = function (obj) {\n        var i, res = [];\n        for (i in obj) {\n            if (hasOwnProp(obj, i)) {\n                res.push(i);\n            }\n        }\n        return res;\n    };\n}\n\nvar keys$1 = keys;\n\nvar defaultCalendar = {\n    sameDay : '[Today at] LT',\n    nextDay : '[Tomorrow at] LT',\n    nextWeek : 'dddd [at] LT',\n    lastDay : '[Yesterday at] LT',\n    lastWeek : '[Last] dddd [at] LT',\n    sameElse : 'L'\n};\n\nfunction calendar (key, mom, now) {\n    var output = this._calendar[key] || this._calendar['sameElse'];\n    return isFunction(output) ? output.call(mom, now) : output;\n}\n\nvar defaultLongDateFormat = {\n    LTS  : 'h:mm:ss A',\n    LT   : 'h:mm A',\n    L    : 'MM/DD/YYYY',\n    LL   : 'MMMM D, YYYY',\n    LLL  : 'MMMM D, YYYY h:mm A',\n    LLLL : 'dddd, MMMM D, YYYY h:mm A'\n};\n\nfunction longDateFormat (key) {\n    var format = this._longDateFormat[key],\n        formatUpper = this._longDateFormat[key.toUpperCase()];\n\n    if (format || !formatUpper) {\n        return format;\n    }\n\n    this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {\n        return val.slice(1);\n    });\n\n    return this._longDateFormat[key];\n}\n\nvar defaultInvalidDate = 'Invalid date';\n\nfunction invalidDate () {\n    return this._invalidDate;\n}\n\nvar defaultOrdinal = '%d';\nvar defaultDayOfMonthOrdinalParse = /\\d{1,2}/;\n\nfunction ordinal (number) {\n    return this._ordinal.replace('%d', number);\n}\n\nvar defaultRelativeTime = {\n    future : 'in %s',\n    past   : '%s ago',\n    s  : 'a few seconds',\n    ss : '%d seconds',\n    m  : 'a minute',\n    mm : '%d minutes',\n    h  : 'an hour',\n    hh : '%d hours',\n    d  : 'a day',\n    dd : '%d days',\n    M  : 'a month',\n    MM : '%d months',\n    y  : 'a year',\n    yy : '%d years'\n};\n\nfunction relativeTime (number, withoutSuffix, string, isFuture) {\n    var output = this._relativeTime[string];\n    return (isFunction(output)) ?\n        output(number, withoutSuffix, string, isFuture) :\n        output.replace(/%d/i, number);\n}\n\nfunction pastFuture (diff, output) {\n    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];\n    return isFunction(format) ? format(output) : format.replace(/%s/i, output);\n}\n\nvar aliases = {};\n\nfunction addUnitAlias (unit, shorthand) {\n    var lowerCase = unit.toLowerCase();\n    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;\n}\n\nfunction normalizeUnits(units) {\n    return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;\n}\n\nfunction normalizeObjectUnits(inputObject) {\n    var normalizedInput = {},\n        normalizedProp,\n        prop;\n\n    for (prop in inputObject) {\n        if (hasOwnProp(inputObject, prop)) {\n            normalizedProp = normalizeUnits(prop);\n            if (normalizedProp) {\n                normalizedInput[normalizedProp] = inputObject[prop];\n            }\n        }\n    }\n\n    return normalizedInput;\n}\n\nvar priorities = {};\n\nfunction addUnitPriority(unit, priority) {\n    priorities[unit] = priority;\n}\n\nfunction getPrioritizedUnits(unitsObj) {\n    var units = [];\n    for (var u in unitsObj) {\n        units.push({unit: u, priority: priorities[u]});\n    }\n    units.sort(function (a, b) {\n        return a.priority - b.priority;\n    });\n    return units;\n}\n\nfunction makeGetSet (unit, keepTime) {\n    return function (value) {\n        if (value != null) {\n            set$1(this, unit, value);\n            hooks.updateOffset(this, keepTime);\n            return this;\n        } else {\n            return get(this, unit);\n        }\n    };\n}\n\nfunction get (mom, unit) {\n    return mom.isValid() ?\n        mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;\n}\n\nfunction set$1 (mom, unit, value) {\n    if (mom.isValid()) {\n        mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);\n    }\n}\n\n// MOMENTS\n\nfunction stringGet (units) {\n    units = normalizeUnits(units);\n    if (isFunction(this[units])) {\n        return this[units]();\n    }\n    return this;\n}\n\n\nfunction stringSet (units, value) {\n    if (typeof units === 'object') {\n        units = normalizeObjectUnits(units);\n        var prioritized = getPrioritizedUnits(units);\n        for (var i = 0; i < prioritized.length; i++) {\n            this[prioritized[i].unit](units[prioritized[i].unit]);\n        }\n    } else {\n        units = normalizeUnits(units);\n        if (isFunction(this[units])) {\n            return this[units](value);\n        }\n    }\n    return this;\n}\n\nfunction zeroFill(number, targetLength, forceSign) {\n    var absNumber = '' + Math.abs(number),\n        zerosToFill = targetLength - absNumber.length,\n        sign = number >= 0;\n    return (sign ? (forceSign ? '+' : '') : '-') +\n        Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;\n}\n\nvar formattingTokens = /(\\[[^\\[]*\\])|(\\\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;\n\nvar localFormattingTokens = /(\\[[^\\[]*\\])|(\\\\)?(LTS|LT|LL?L?L?|l{1,4})/g;\n\nvar formatFunctions = {};\n\nvar formatTokenFunctions = {};\n\n// token:    'M'\n// padded:   ['MM', 2]\n// ordinal:  'Mo'\n// callback: function () { this.month() + 1 }\nfunction addFormatToken (token, padded, ordinal, callback) {\n    var func = callback;\n    if (typeof callback === 'string') {\n        func = function () {\n            return this[callback]();\n        };\n    }\n    if (token) {\n        formatTokenFunctions[token] = func;\n    }\n    if (padded) {\n        formatTokenFunctions[padded[0]] = function () {\n            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);\n        };\n    }\n    if (ordinal) {\n        formatTokenFunctions[ordinal] = function () {\n            return this.localeData().ordinal(func.apply(this, arguments), token);\n        };\n    }\n}\n\nfunction removeFormattingTokens(input) {\n    if (input.match(/\\[[\\s\\S]/)) {\n        return input.replace(/^\\[|\\]$/g, '');\n    }\n    return input.replace(/\\\\/g, '');\n}\n\nfunction makeFormatFunction(format) {\n    var array = format.match(formattingTokens), i, length;\n\n    for (i = 0, length = array.length; i < length; i++) {\n        if (formatTokenFunctions[array[i]]) {\n            array[i] = formatTokenFunctions[array[i]];\n        } else {\n            array[i] = removeFormattingTokens(array[i]);\n        }\n    }\n\n    return function (mom) {\n        var output = '', i;\n        for (i = 0; i < length; i++) {\n            output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];\n        }\n        return output;\n    };\n}\n\n// format date using native date object\nfunction formatMoment(m, format) {\n    if (!m.isValid()) {\n        return m.localeData().invalidDate();\n    }\n\n    format = expandFormat(format, m.localeData());\n    formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);\n\n    return formatFunctions[format](m);\n}\n\nfunction expandFormat(format, locale) {\n    var i = 5;\n\n    function replaceLongDateFormatTokens(input) {\n        return locale.longDateFormat(input) || input;\n    }\n\n    localFormattingTokens.lastIndex = 0;\n    while (i >= 0 && localFormattingTokens.test(format)) {\n        format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);\n        localFormattingTokens.lastIndex = 0;\n        i -= 1;\n    }\n\n    return format;\n}\n\nvar match1         = /\\d/;            //       0 - 9\nvar match2         = /\\d\\d/;          //      00 - 99\nvar match3         = /\\d{3}/;         //     000 - 999\nvar match4         = /\\d{4}/;         //    0000 - 9999\nvar match6         = /[+-]?\\d{6}/;    // -999999 - 999999\nvar match1to2      = /\\d\\d?/;         //       0 - 99\nvar match3to4      = /\\d\\d\\d\\d?/;     //     999 - 9999\nvar match5to6      = /\\d\\d\\d\\d\\d\\d?/; //   99999 - 999999\nvar match1to3      = /\\d{1,3}/;       //       0 - 999\nvar match1to4      = /\\d{1,4}/;       //       0 - 9999\nvar match1to6      = /[+-]?\\d{1,6}/;  // -999999 - 999999\n\nvar matchUnsigned  = /\\d+/;           //       0 - inf\nvar matchSigned    = /[+-]?\\d+/;      //    -inf - inf\n\nvar matchOffset    = /Z|[+-]\\d\\d:?\\d\\d/gi; // +00:00 -00:00 +0000 -0000 or Z\nvar matchShortOffset = /Z|[+-]\\d\\d(?::?\\d\\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z\n\nvar matchTimestamp = /[+-]?\\d+(\\.\\d{1,3})?/; // 123456789 123456789.123\n\n// any word (or two) characters or numbers including two/three word month in arabic.\n// includes scottish gaelic two word and hyphenated months\nvar matchWord = /[0-9]*['a-z\\u00A0-\\u05FF\\u0700-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]+|[\\u0600-\\u06FF\\/]+(\\s*?[\\u0600-\\u06FF]+){1,2}/i;\n\n\nvar regexes = {};\n\nfunction addRegexToken (token, regex, strictRegex) {\n    regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {\n        return (isStrict && strictRegex) ? strictRegex : regex;\n    };\n}\n\nfunction getParseRegexForToken (token, config) {\n    if (!hasOwnProp(regexes, token)) {\n        return new RegExp(unescapeFormat(token));\n    }\n\n    return regexes[token](config._strict, config._locale);\n}\n\n// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript\nfunction unescapeFormat(s) {\n    return regexEscape(s.replace('\\\\', '').replace(/\\\\(\\[)|\\\\(\\])|\\[([^\\]\\[]*)\\]|\\\\(.)/g, function (matched, p1, p2, p3, p4) {\n        return p1 || p2 || p3 || p4;\n    }));\n}\n\nfunction regexEscape(s) {\n    return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n}\n\nvar tokens = {};\n\nfunction addParseToken (token, callback) {\n    var i, func = callback;\n    if (typeof token === 'string') {\n        token = [token];\n    }\n    if (isNumber(callback)) {\n        func = function (input, array) {\n            array[callback] = toInt(input);\n        };\n    }\n    for (i = 0; i < token.length; i++) {\n        tokens[token[i]] = func;\n    }\n}\n\nfunction addWeekParseToken (token, callback) {\n    addParseToken(token, function (input, array, config, token) {\n        config._w = config._w || {};\n        callback(input, config._w, config, token);\n    });\n}\n\nfunction addTimeToArrayFromToken(token, input, config) {\n    if (input != null && hasOwnProp(tokens, token)) {\n        tokens[token](input, config._a, config, token);\n    }\n}\n\nvar YEAR = 0;\nvar MONTH = 1;\nvar DATE = 2;\nvar HOUR = 3;\nvar MINUTE = 4;\nvar SECOND = 5;\nvar MILLISECOND = 6;\nvar WEEK = 7;\nvar WEEKDAY = 8;\n\nvar indexOf;\n\nif (Array.prototype.indexOf) {\n    indexOf = Array.prototype.indexOf;\n} else {\n    indexOf = function (o) {\n        // I know\n        var i;\n        for (i = 0; i < this.length; ++i) {\n            if (this[i] === o) {\n                return i;\n            }\n        }\n        return -1;\n    };\n}\n\nvar indexOf$1 = indexOf;\n\nfunction daysInMonth(year, month) {\n    return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();\n}\n\n// FORMATTING\n\naddFormatToken('M', ['MM', 2], 'Mo', function () {\n    return this.month() + 1;\n});\n\naddFormatToken('MMM', 0, 0, function (format) {\n    return this.localeData().monthsShort(this, format);\n});\n\naddFormatToken('MMMM', 0, 0, function (format) {\n    return this.localeData().months(this, format);\n});\n\n// ALIASES\n\naddUnitAlias('month', 'M');\n\n// PRIORITY\n\naddUnitPriority('month', 8);\n\n// PARSING\n\naddRegexToken('M',    match1to2);\naddRegexToken('MM',   match1to2, match2);\naddRegexToken('MMM',  function (isStrict, locale) {\n    return locale.monthsShortRegex(isStrict);\n});\naddRegexToken('MMMM', function (isStrict, locale) {\n    return locale.monthsRegex(isStrict);\n});\n\naddParseToken(['M', 'MM'], function (input, array) {\n    array[MONTH] = toInt(input) - 1;\n});\n\naddParseToken(['MMM', 'MMMM'], function (input, array, config, token) {\n    var month = config._locale.monthsParse(input, token, config._strict);\n    // if we didn't find a month name, mark the date as invalid.\n    if (month != null) {\n        array[MONTH] = month;\n    } else {\n        getParsingFlags(config).invalidMonth = input;\n    }\n});\n\n// LOCALES\n\nvar MONTHS_IN_FORMAT = /D[oD]?(\\[[^\\[\\]]*\\]|\\s)+MMMM?/;\nvar defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');\nfunction localeMonths (m, format) {\n    if (!m) {\n        return isArray(this._months) ? this._months :\n            this._months['standalone'];\n    }\n    return isArray(this._months) ? this._months[m.month()] :\n        this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];\n}\n\nvar defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');\nfunction localeMonthsShort (m, format) {\n    if (!m) {\n        return isArray(this._monthsShort) ? this._monthsShort :\n            this._monthsShort['standalone'];\n    }\n    return isArray(this._monthsShort) ? this._monthsShort[m.month()] :\n        this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];\n}\n\nfunction handleStrictParse(monthName, format, strict) {\n    var i, ii, mom, llc = monthName.toLocaleLowerCase();\n    if (!this._monthsParse) {\n        // this is not used\n        this._monthsParse = [];\n        this._longMonthsParse = [];\n        this._shortMonthsParse = [];\n        for (i = 0; i < 12; ++i) {\n            mom = createUTC([2000, i]);\n            this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();\n            this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();\n        }\n    }\n\n    if (strict) {\n        if (format === 'MMM') {\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    } else {\n        if (format === 'MMM') {\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    }\n}\n\nfunction localeMonthsParse (monthName, format, strict) {\n    var i, mom, regex;\n\n    if (this._monthsParseExact) {\n        return handleStrictParse.call(this, monthName, format, strict);\n    }\n\n    if (!this._monthsParse) {\n        this._monthsParse = [];\n        this._longMonthsParse = [];\n        this._shortMonthsParse = [];\n    }\n\n    // TODO: add sorting\n    // Sorting makes sure if one month (or abbr) is a prefix of another\n    // see sorting in computeMonthsParse\n    for (i = 0; i < 12; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, i]);\n        if (strict && !this._longMonthsParse[i]) {\n            this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');\n            this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');\n        }\n        if (!strict && !this._monthsParse[i]) {\n            regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');\n            this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');\n        }\n        // test the regex\n        if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {\n            return i;\n        } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {\n            return i;\n        } else if (!strict && this._monthsParse[i].test(monthName)) {\n            return i;\n        }\n    }\n}\n\n// MOMENTS\n\nfunction setMonth (mom, value) {\n    var dayOfMonth;\n\n    if (!mom.isValid()) {\n        // No op\n        return mom;\n    }\n\n    if (typeof value === 'string') {\n        if (/^\\d+$/.test(value)) {\n            value = toInt(value);\n        } else {\n            value = mom.localeData().monthsParse(value);\n            // TODO: Another silent failure?\n            if (!isNumber(value)) {\n                return mom;\n            }\n        }\n    }\n\n    dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));\n    mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);\n    return mom;\n}\n\nfunction getSetMonth (value) {\n    if (value != null) {\n        setMonth(this, value);\n        hooks.updateOffset(this, true);\n        return this;\n    } else {\n        return get(this, 'Month');\n    }\n}\n\nfunction getDaysInMonth () {\n    return daysInMonth(this.year(), this.month());\n}\n\nvar defaultMonthsShortRegex = matchWord;\nfunction monthsShortRegex (isStrict) {\n    if (this._monthsParseExact) {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            computeMonthsParse.call(this);\n        }\n        if (isStrict) {\n            return this._monthsShortStrictRegex;\n        } else {\n            return this._monthsShortRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_monthsShortRegex')) {\n            this._monthsShortRegex = defaultMonthsShortRegex;\n        }\n        return this._monthsShortStrictRegex && isStrict ?\n            this._monthsShortStrictRegex : this._monthsShortRegex;\n    }\n}\n\nvar defaultMonthsRegex = matchWord;\nfunction monthsRegex (isStrict) {\n    if (this._monthsParseExact) {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            computeMonthsParse.call(this);\n        }\n        if (isStrict) {\n            return this._monthsStrictRegex;\n        } else {\n            return this._monthsRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            this._monthsRegex = defaultMonthsRegex;\n        }\n        return this._monthsStrictRegex && isStrict ?\n            this._monthsStrictRegex : this._monthsRegex;\n    }\n}\n\nfunction computeMonthsParse () {\n    function cmpLenRev(a, b) {\n        return b.length - a.length;\n    }\n\n    var shortPieces = [], longPieces = [], mixedPieces = [],\n        i, mom;\n    for (i = 0; i < 12; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, i]);\n        shortPieces.push(this.monthsShort(mom, ''));\n        longPieces.push(this.months(mom, ''));\n        mixedPieces.push(this.months(mom, ''));\n        mixedPieces.push(this.monthsShort(mom, ''));\n    }\n    // Sorting makes sure if one month (or abbr) is a prefix of another it\n    // will match the longer piece.\n    shortPieces.sort(cmpLenRev);\n    longPieces.sort(cmpLenRev);\n    mixedPieces.sort(cmpLenRev);\n    for (i = 0; i < 12; i++) {\n        shortPieces[i] = regexEscape(shortPieces[i]);\n        longPieces[i] = regexEscape(longPieces[i]);\n    }\n    for (i = 0; i < 24; i++) {\n        mixedPieces[i] = regexEscape(mixedPieces[i]);\n    }\n\n    this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._monthsShortRegex = this._monthsRegex;\n    this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n    this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n}\n\n// FORMATTING\n\naddFormatToken('Y', 0, 0, function () {\n    var y = this.year();\n    return y <= 9999 ? '' + y : '+' + y;\n});\n\naddFormatToken(0, ['YY', 2], 0, function () {\n    return this.year() % 100;\n});\n\naddFormatToken(0, ['YYYY',   4],       0, 'year');\naddFormatToken(0, ['YYYYY',  5],       0, 'year');\naddFormatToken(0, ['YYYYYY', 6, true], 0, 'year');\n\n// ALIASES\n\naddUnitAlias('year', 'y');\n\n// PRIORITIES\n\naddUnitPriority('year', 1);\n\n// PARSING\n\naddRegexToken('Y',      matchSigned);\naddRegexToken('YY',     match1to2, match2);\naddRegexToken('YYYY',   match1to4, match4);\naddRegexToken('YYYYY',  match1to6, match6);\naddRegexToken('YYYYYY', match1to6, match6);\n\naddParseToken(['YYYYY', 'YYYYYY'], YEAR);\naddParseToken('YYYY', function (input, array) {\n    array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);\n});\naddParseToken('YY', function (input, array) {\n    array[YEAR] = hooks.parseTwoDigitYear(input);\n});\naddParseToken('Y', function (input, array) {\n    array[YEAR] = parseInt(input, 10);\n});\n\n// HELPERS\n\nfunction daysInYear(year) {\n    return isLeapYear(year) ? 366 : 365;\n}\n\nfunction isLeapYear(year) {\n    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n}\n\n// HOOKS\n\nhooks.parseTwoDigitYear = function (input) {\n    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);\n};\n\n// MOMENTS\n\nvar getSetYear = makeGetSet('FullYear', true);\n\nfunction getIsLeapYear () {\n    return isLeapYear(this.year());\n}\n\nfunction createDate (y, m, d, h, M, s, ms) {\n    // can't just apply() to create a date:\n    // https://stackoverflow.com/q/181348\n    var date = new Date(y, m, d, h, M, s, ms);\n\n    // the date constructor remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {\n        date.setFullYear(y);\n    }\n    return date;\n}\n\nfunction createUTCDate (y) {\n    var date = new Date(Date.UTC.apply(null, arguments));\n\n    // the Date.UTC function remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {\n        date.setUTCFullYear(y);\n    }\n    return date;\n}\n\n// start-of-first-week - start-of-year\nfunction firstWeekOffset(year, dow, doy) {\n    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)\n        fwd = 7 + dow - doy,\n        // first-week day local weekday -- which local weekday is fwd\n        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;\n\n    return -fwdlw + fwd - 1;\n}\n\n// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday\nfunction dayOfYearFromWeeks(year, week, weekday, dow, doy) {\n    var localWeekday = (7 + weekday - dow) % 7,\n        weekOffset = firstWeekOffset(year, dow, doy),\n        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,\n        resYear, resDayOfYear;\n\n    if (dayOfYear <= 0) {\n        resYear = year - 1;\n        resDayOfYear = daysInYear(resYear) + dayOfYear;\n    } else if (dayOfYear > daysInYear(year)) {\n        resYear = year + 1;\n        resDayOfYear = dayOfYear - daysInYear(year);\n    } else {\n        resYear = year;\n        resDayOfYear = dayOfYear;\n    }\n\n    return {\n        year: resYear,\n        dayOfYear: resDayOfYear\n    };\n}\n\nfunction weekOfYear(mom, dow, doy) {\n    var weekOffset = firstWeekOffset(mom.year(), dow, doy),\n        week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,\n        resWeek, resYear;\n\n    if (week < 1) {\n        resYear = mom.year() - 1;\n        resWeek = week + weeksInYear(resYear, dow, doy);\n    } else if (week > weeksInYear(mom.year(), dow, doy)) {\n        resWeek = week - weeksInYear(mom.year(), dow, doy);\n        resYear = mom.year() + 1;\n    } else {\n        resYear = mom.year();\n        resWeek = week;\n    }\n\n    return {\n        week: resWeek,\n        year: resYear\n    };\n}\n\nfunction weeksInYear(year, dow, doy) {\n    var weekOffset = firstWeekOffset(year, dow, doy),\n        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);\n    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;\n}\n\n// FORMATTING\n\naddFormatToken('w', ['ww', 2], 'wo', 'week');\naddFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');\n\n// ALIASES\n\naddUnitAlias('week', 'w');\naddUnitAlias('isoWeek', 'W');\n\n// PRIORITIES\n\naddUnitPriority('week', 5);\naddUnitPriority('isoWeek', 5);\n\n// PARSING\n\naddRegexToken('w',  match1to2);\naddRegexToken('ww', match1to2, match2);\naddRegexToken('W',  match1to2);\naddRegexToken('WW', match1to2, match2);\n\naddWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {\n    week[token.substr(0, 1)] = toInt(input);\n});\n\n// HELPERS\n\n// LOCALES\n\nfunction localeWeek (mom) {\n    return weekOfYear(mom, this._week.dow, this._week.doy).week;\n}\n\nvar defaultLocaleWeek = {\n    dow : 0, // Sunday is the first day of the week.\n    doy : 6  // The week that contains Jan 1st is the first week of the year.\n};\n\nfunction localeFirstDayOfWeek () {\n    return this._week.dow;\n}\n\nfunction localeFirstDayOfYear () {\n    return this._week.doy;\n}\n\n// MOMENTS\n\nfunction getSetWeek (input) {\n    var week = this.localeData().week(this);\n    return input == null ? week : this.add((input - week) * 7, 'd');\n}\n\nfunction getSetISOWeek (input) {\n    var week = weekOfYear(this, 1, 4).week;\n    return input == null ? week : this.add((input - week) * 7, 'd');\n}\n\n// FORMATTING\n\naddFormatToken('d', 0, 'do', 'day');\n\naddFormatToken('dd', 0, 0, function (format) {\n    return this.localeData().weekdaysMin(this, format);\n});\n\naddFormatToken('ddd', 0, 0, function (format) {\n    return this.localeData().weekdaysShort(this, format);\n});\n\naddFormatToken('dddd', 0, 0, function (format) {\n    return this.localeData().weekdays(this, format);\n});\n\naddFormatToken('e', 0, 0, 'weekday');\naddFormatToken('E', 0, 0, 'isoWeekday');\n\n// ALIASES\n\naddUnitAlias('day', 'd');\naddUnitAlias('weekday', 'e');\naddUnitAlias('isoWeekday', 'E');\n\n// PRIORITY\naddUnitPriority('day', 11);\naddUnitPriority('weekday', 11);\naddUnitPriority('isoWeekday', 11);\n\n// PARSING\n\naddRegexToken('d',    match1to2);\naddRegexToken('e',    match1to2);\naddRegexToken('E',    match1to2);\naddRegexToken('dd',   function (isStrict, locale) {\n    return locale.weekdaysMinRegex(isStrict);\n});\naddRegexToken('ddd',   function (isStrict, locale) {\n    return locale.weekdaysShortRegex(isStrict);\n});\naddRegexToken('dddd',   function (isStrict, locale) {\n    return locale.weekdaysRegex(isStrict);\n});\n\naddWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {\n    var weekday = config._locale.weekdaysParse(input, token, config._strict);\n    // if we didn't get a weekday name, mark the date as invalid\n    if (weekday != null) {\n        week.d = weekday;\n    } else {\n        getParsingFlags(config).invalidWeekday = input;\n    }\n});\n\naddWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {\n    week[token] = toInt(input);\n});\n\n// HELPERS\n\nfunction parseWeekday(input, locale) {\n    if (typeof input !== 'string') {\n        return input;\n    }\n\n    if (!isNaN(input)) {\n        return parseInt(input, 10);\n    }\n\n    input = locale.weekdaysParse(input);\n    if (typeof input === 'number') {\n        return input;\n    }\n\n    return null;\n}\n\nfunction parseIsoWeekday(input, locale) {\n    if (typeof input === 'string') {\n        return locale.weekdaysParse(input) % 7 || 7;\n    }\n    return isNaN(input) ? null : input;\n}\n\n// LOCALES\n\nvar defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');\nfunction localeWeekdays (m, format) {\n    if (!m) {\n        return isArray(this._weekdays) ? this._weekdays :\n            this._weekdays['standalone'];\n    }\n    return isArray(this._weekdays) ? this._weekdays[m.day()] :\n        this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];\n}\n\nvar defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');\nfunction localeWeekdaysShort (m) {\n    return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;\n}\n\nvar defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');\nfunction localeWeekdaysMin (m) {\n    return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;\n}\n\nfunction handleStrictParse$1(weekdayName, format, strict) {\n    var i, ii, mom, llc = weekdayName.toLocaleLowerCase();\n    if (!this._weekdaysParse) {\n        this._weekdaysParse = [];\n        this._shortWeekdaysParse = [];\n        this._minWeekdaysParse = [];\n\n        for (i = 0; i < 7; ++i) {\n            mom = createUTC([2000, 1]).day(i);\n            this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();\n            this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();\n            this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();\n        }\n    }\n\n    if (strict) {\n        if (format === 'dddd') {\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else if (format === 'ddd') {\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    } else {\n        if (format === 'dddd') {\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else if (format === 'ddd') {\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    }\n}\n\nfunction localeWeekdaysParse (weekdayName, format, strict) {\n    var i, mom, regex;\n\n    if (this._weekdaysParseExact) {\n        return handleStrictParse$1.call(this, weekdayName, format, strict);\n    }\n\n    if (!this._weekdaysParse) {\n        this._weekdaysParse = [];\n        this._minWeekdaysParse = [];\n        this._shortWeekdaysParse = [];\n        this._fullWeekdaysParse = [];\n    }\n\n    for (i = 0; i < 7; i++) {\n        // make the regex if we don't have it already\n\n        mom = createUTC([2000, 1]).day(i);\n        if (strict && !this._fullWeekdaysParse[i]) {\n            this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 'i');\n            this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 'i');\n            this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 'i');\n        }\n        if (!this._weekdaysParse[i]) {\n            regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');\n            this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');\n        }\n        // test the regex\n        if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {\n            return i;\n        }\n    }\n}\n\n// MOMENTS\n\nfunction getSetDayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();\n    if (input != null) {\n        input = parseWeekday(input, this.localeData());\n        return this.add(input - day, 'd');\n    } else {\n        return day;\n    }\n}\n\nfunction getSetLocaleDayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;\n    return input == null ? weekday : this.add(input - weekday, 'd');\n}\n\nfunction getSetISODayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n\n    // behaves the same as moment#day except\n    // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)\n    // as a setter, sunday should belong to the previous week.\n\n    if (input != null) {\n        var weekday = parseIsoWeekday(input, this.localeData());\n        return this.day(this.day() % 7 ? weekday : weekday - 7);\n    } else {\n        return this.day() || 7;\n    }\n}\n\nvar defaultWeekdaysRegex = matchWord;\nfunction weekdaysRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysStrictRegex;\n        } else {\n            return this._weekdaysRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            this._weekdaysRegex = defaultWeekdaysRegex;\n        }\n        return this._weekdaysStrictRegex && isStrict ?\n            this._weekdaysStrictRegex : this._weekdaysRegex;\n    }\n}\n\nvar defaultWeekdaysShortRegex = matchWord;\nfunction weekdaysShortRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysShortStrictRegex;\n        } else {\n            return this._weekdaysShortRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysShortRegex')) {\n            this._weekdaysShortRegex = defaultWeekdaysShortRegex;\n        }\n        return this._weekdaysShortStrictRegex && isStrict ?\n            this._weekdaysShortStrictRegex : this._weekdaysShortRegex;\n    }\n}\n\nvar defaultWeekdaysMinRegex = matchWord;\nfunction weekdaysMinRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysMinStrictRegex;\n        } else {\n            return this._weekdaysMinRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysMinRegex')) {\n            this._weekdaysMinRegex = defaultWeekdaysMinRegex;\n        }\n        return this._weekdaysMinStrictRegex && isStrict ?\n            this._weekdaysMinStrictRegex : this._weekdaysMinRegex;\n    }\n}\n\n\nfunction computeWeekdaysParse () {\n    function cmpLenRev(a, b) {\n        return b.length - a.length;\n    }\n\n    var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],\n        i, mom, minp, shortp, longp;\n    for (i = 0; i < 7; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, 1]).day(i);\n        minp = this.weekdaysMin(mom, '');\n        shortp = this.weekdaysShort(mom, '');\n        longp = this.weekdays(mom, '');\n        minPieces.push(minp);\n        shortPieces.push(shortp);\n        longPieces.push(longp);\n        mixedPieces.push(minp);\n        mixedPieces.push(shortp);\n        mixedPieces.push(longp);\n    }\n    // Sorting makes sure if one weekday (or abbr) is a prefix of another it\n    // will match the longer piece.\n    minPieces.sort(cmpLenRev);\n    shortPieces.sort(cmpLenRev);\n    longPieces.sort(cmpLenRev);\n    mixedPieces.sort(cmpLenRev);\n    for (i = 0; i < 7; i++) {\n        shortPieces[i] = regexEscape(shortPieces[i]);\n        longPieces[i] = regexEscape(longPieces[i]);\n        mixedPieces[i] = regexEscape(mixedPieces[i]);\n    }\n\n    this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._weekdaysShortRegex = this._weekdaysRegex;\n    this._weekdaysMinRegex = this._weekdaysRegex;\n\n    this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n    this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n    this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');\n}\n\n// FORMATTING\n\nfunction hFormat() {\n    return this.hours() % 12 || 12;\n}\n\nfunction kFormat() {\n    return this.hours() || 24;\n}\n\naddFormatToken('H', ['HH', 2], 0, 'hour');\naddFormatToken('h', ['hh', 2], 0, hFormat);\naddFormatToken('k', ['kk', 2], 0, kFormat);\n\naddFormatToken('hmm', 0, 0, function () {\n    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);\n});\n\naddFormatToken('hmmss', 0, 0, function () {\n    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +\n        zeroFill(this.seconds(), 2);\n});\n\naddFormatToken('Hmm', 0, 0, function () {\n    return '' + this.hours() + zeroFill(this.minutes(), 2);\n});\n\naddFormatToken('Hmmss', 0, 0, function () {\n    return '' + this.hours() + zeroFill(this.minutes(), 2) +\n        zeroFill(this.seconds(), 2);\n});\n\nfunction meridiem (token, lowercase) {\n    addFormatToken(token, 0, 0, function () {\n        return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);\n    });\n}\n\nmeridiem('a', true);\nmeridiem('A', false);\n\n// ALIASES\n\naddUnitAlias('hour', 'h');\n\n// PRIORITY\naddUnitPriority('hour', 13);\n\n// PARSING\n\nfunction matchMeridiem (isStrict, locale) {\n    return locale._meridiemParse;\n}\n\naddRegexToken('a',  matchMeridiem);\naddRegexToken('A',  matchMeridiem);\naddRegexToken('H',  match1to2);\naddRegexToken('h',  match1to2);\naddRegexToken('k',  match1to2);\naddRegexToken('HH', match1to2, match2);\naddRegexToken('hh', match1to2, match2);\naddRegexToken('kk', match1to2, match2);\n\naddRegexToken('hmm', match3to4);\naddRegexToken('hmmss', match5to6);\naddRegexToken('Hmm', match3to4);\naddRegexToken('Hmmss', match5to6);\n\naddParseToken(['H', 'HH'], HOUR);\naddParseToken(['k', 'kk'], function (input, array, config) {\n    var kInput = toInt(input);\n    array[HOUR] = kInput === 24 ? 0 : kInput;\n});\naddParseToken(['a', 'A'], function (input, array, config) {\n    config._isPm = config._locale.isPM(input);\n    config._meridiem = input;\n});\naddParseToken(['h', 'hh'], function (input, array, config) {\n    array[HOUR] = toInt(input);\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('hmm', function (input, array, config) {\n    var pos = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos));\n    array[MINUTE] = toInt(input.substr(pos));\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('hmmss', function (input, array, config) {\n    var pos1 = input.length - 4;\n    var pos2 = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos1));\n    array[MINUTE] = toInt(input.substr(pos1, 2));\n    array[SECOND] = toInt(input.substr(pos2));\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('Hmm', function (input, array, config) {\n    var pos = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos));\n    array[MINUTE] = toInt(input.substr(pos));\n});\naddParseToken('Hmmss', function (input, array, config) {\n    var pos1 = input.length - 4;\n    var pos2 = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos1));\n    array[MINUTE] = toInt(input.substr(pos1, 2));\n    array[SECOND] = toInt(input.substr(pos2));\n});\n\n// LOCALES\n\nfunction localeIsPM (input) {\n    // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays\n    // Using charAt should be more compatible.\n    return ((input + '').toLowerCase().charAt(0) === 'p');\n}\n\nvar defaultLocaleMeridiemParse = /[ap]\\.?m?\\.?/i;\nfunction localeMeridiem (hours, minutes, isLower) {\n    if (hours > 11) {\n        return isLower ? 'pm' : 'PM';\n    } else {\n        return isLower ? 'am' : 'AM';\n    }\n}\n\n\n// MOMENTS\n\n// Setting the hour should keep the time, because the user explicitly\n// specified which hour he wants. So trying to maintain the same hour (in\n// a new timezone) makes sense. Adding/subtracting hours does not follow\n// this rule.\nvar getSetHour = makeGetSet('Hours', true);\n\n// months\n// week\n// weekdays\n// meridiem\nvar baseConfig = {\n    calendar: defaultCalendar,\n    longDateFormat: defaultLongDateFormat,\n    invalidDate: defaultInvalidDate,\n    ordinal: defaultOrdinal,\n    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,\n    relativeTime: defaultRelativeTime,\n\n    months: defaultLocaleMonths,\n    monthsShort: defaultLocaleMonthsShort,\n\n    week: defaultLocaleWeek,\n\n    weekdays: defaultLocaleWeekdays,\n    weekdaysMin: defaultLocaleWeekdaysMin,\n    weekdaysShort: defaultLocaleWeekdaysShort,\n\n    meridiemParse: defaultLocaleMeridiemParse\n};\n\n// internal storage for locale config files\nvar locales = {};\nvar localeFamilies = {};\nvar globalLocale;\n\nfunction normalizeLocale(key) {\n    return key ? key.toLowerCase().replace('_', '-') : key;\n}\n\n// pick the locale from the array\n// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each\n// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root\nfunction chooseLocale(names) {\n    var i = 0, j, next, locale, split;\n\n    while (i < names.length) {\n        split = normalizeLocale(names[i]).split('-');\n        j = split.length;\n        next = normalizeLocale(names[i + 1]);\n        next = next ? next.split('-') : null;\n        while (j > 0) {\n            locale = loadLocale(split.slice(0, j).join('-'));\n            if (locale) {\n                return locale;\n            }\n            if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {\n                //the next array item is better than a shallower substring of this one\n                break;\n            }\n            j--;\n        }\n        i++;\n    }\n    return null;\n}\n\nfunction loadLocale(name) {\n    var oldLocale = null;\n    // TODO: Find a better way to register and load all the locales in Node\n    if (!locales[name] && (typeof module !== 'undefined') &&\n            module && module.exports) {\n        try {\n            oldLocale = globalLocale._abbr;\n            require('./locale/' + name);\n            // because defineLocale currently also sets the global locale, we\n            // want to undo that for lazy loaded locales\n            getSetGlobalLocale(oldLocale);\n        } catch (e) { }\n    }\n    return locales[name];\n}\n\n// This function will load locale and then set the global locale.  If\n// no arguments are passed in, it will simply return the current global\n// locale key.\nfunction getSetGlobalLocale (key, values) {\n    var data;\n    if (key) {\n        if (isUndefined(values)) {\n            data = getLocale(key);\n        }\n        else {\n            data = defineLocale(key, values);\n        }\n\n        if (data) {\n            // moment.duration._locale = moment._locale = data;\n            globalLocale = data;\n        }\n    }\n\n    return globalLocale._abbr;\n}\n\nfunction defineLocale (name, config) {\n    if (config !== null) {\n        var parentConfig = baseConfig;\n        config.abbr = name;\n        if (locales[name] != null) {\n            deprecateSimple('defineLocaleOverride',\n                    'use moment.updateLocale(localeName, config) to change ' +\n                    'an existing locale. moment.defineLocale(localeName, ' +\n                    'config) should only be used for creating a new locale ' +\n                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');\n            parentConfig = locales[name]._config;\n        } else if (config.parentLocale != null) {\n            if (locales[config.parentLocale] != null) {\n                parentConfig = locales[config.parentLocale]._config;\n            } else {\n                if (!localeFamilies[config.parentLocale]) {\n                    localeFamilies[config.parentLocale] = [];\n                }\n                localeFamilies[config.parentLocale].push({\n                    name: name,\n                    config: config\n                });\n                return null;\n            }\n        }\n        locales[name] = new Locale(mergeConfigs(parentConfig, config));\n\n        if (localeFamilies[name]) {\n            localeFamilies[name].forEach(function (x) {\n                defineLocale(x.name, x.config);\n            });\n        }\n\n        // backwards compat for now: also set the locale\n        // make sure we set the locale AFTER all child locales have been\n        // created, so we won't end up with the child locale set.\n        getSetGlobalLocale(name);\n\n\n        return locales[name];\n    } else {\n        // useful for testing\n        delete locales[name];\n        return null;\n    }\n}\n\nfunction updateLocale(name, config) {\n    if (config != null) {\n        var locale, parentConfig = baseConfig;\n        // MERGE\n        if (locales[name] != null) {\n            parentConfig = locales[name]._config;\n        }\n        config = mergeConfigs(parentConfig, config);\n        locale = new Locale(config);\n        locale.parentLocale = locales[name];\n        locales[name] = locale;\n\n        // backwards compat for now: also set the locale\n        getSetGlobalLocale(name);\n    } else {\n        // pass null for config to unupdate, useful for tests\n        if (locales[name] != null) {\n            if (locales[name].parentLocale != null) {\n                locales[name] = locales[name].parentLocale;\n            } else if (locales[name] != null) {\n                delete locales[name];\n            }\n        }\n    }\n    return locales[name];\n}\n\n// returns locale data\nfunction getLocale (key) {\n    var locale;\n\n    if (key && key._locale && key._locale._abbr) {\n        key = key._locale._abbr;\n    }\n\n    if (!key) {\n        return globalLocale;\n    }\n\n    if (!isArray(key)) {\n        //short-circuit everything else\n        locale = loadLocale(key);\n        if (locale) {\n            return locale;\n        }\n        key = [key];\n    }\n\n    return chooseLocale(key);\n}\n\nfunction listLocales() {\n    return keys$1(locales);\n}\n\nfunction checkOverflow (m) {\n    var overflow;\n    var a = m._a;\n\n    if (a && getParsingFlags(m).overflow === -2) {\n        overflow =\n            a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :\n            a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :\n            a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :\n            a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :\n            a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :\n            a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :\n            -1;\n\n        if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {\n            overflow = DATE;\n        }\n        if (getParsingFlags(m)._overflowWeeks && overflow === -1) {\n            overflow = WEEK;\n        }\n        if (getParsingFlags(m)._overflowWeekday && overflow === -1) {\n            overflow = WEEKDAY;\n        }\n\n        getParsingFlags(m).overflow = overflow;\n    }\n\n    return m;\n}\n\n// iso 8601 regex\n// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)\nvar extendedIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})-(?:\\d\\d-\\d\\d|W\\d\\d-\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?::\\d\\d(?::\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\nvar basicIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})(?:\\d\\d\\d\\d|W\\d\\d\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?:\\d\\d(?:\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\n\nvar tzRegex = /Z|[+-]\\d\\d(?::?\\d\\d)?/;\n\nvar isoDates = [\n    ['YYYYYY-MM-DD', /[+-]\\d{6}-\\d\\d-\\d\\d/],\n    ['YYYY-MM-DD', /\\d{4}-\\d\\d-\\d\\d/],\n    ['GGGG-[W]WW-E', /\\d{4}-W\\d\\d-\\d/],\n    ['GGGG-[W]WW', /\\d{4}-W\\d\\d/, false],\n    ['YYYY-DDD', /\\d{4}-\\d{3}/],\n    ['YYYY-MM', /\\d{4}-\\d\\d/, false],\n    ['YYYYYYMMDD', /[+-]\\d{10}/],\n    ['YYYYMMDD', /\\d{8}/],\n    // YYYYMM is NOT allowed by the standard\n    ['GGGG[W]WWE', /\\d{4}W\\d{3}/],\n    ['GGGG[W]WW', /\\d{4}W\\d{2}/, false],\n    ['YYYYDDD', /\\d{7}/]\n];\n\n// iso time formats and regexes\nvar isoTimes = [\n    ['HH:mm:ss.SSSS', /\\d\\d:\\d\\d:\\d\\d\\.\\d+/],\n    ['HH:mm:ss,SSSS', /\\d\\d:\\d\\d:\\d\\d,\\d+/],\n    ['HH:mm:ss', /\\d\\d:\\d\\d:\\d\\d/],\n    ['HH:mm', /\\d\\d:\\d\\d/],\n    ['HHmmss.SSSS', /\\d\\d\\d\\d\\d\\d\\.\\d+/],\n    ['HHmmss,SSSS', /\\d\\d\\d\\d\\d\\d,\\d+/],\n    ['HHmmss', /\\d\\d\\d\\d\\d\\d/],\n    ['HHmm', /\\d\\d\\d\\d/],\n    ['HH', /\\d\\d/]\n];\n\nvar aspNetJsonRegex = /^\\/?Date\\((\\-?\\d+)/i;\n\n// date from iso format\nfunction configFromISO(config) {\n    var i, l,\n        string = config._i,\n        match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),\n        allowTime, dateFormat, timeFormat, tzFormat;\n\n    if (match) {\n        getParsingFlags(config).iso = true;\n\n        for (i = 0, l = isoDates.length; i < l; i++) {\n            if (isoDates[i][1].exec(match[1])) {\n                dateFormat = isoDates[i][0];\n                allowTime = isoDates[i][2] !== false;\n                break;\n            }\n        }\n        if (dateFormat == null) {\n            config._isValid = false;\n            return;\n        }\n        if (match[3]) {\n            for (i = 0, l = isoTimes.length; i < l; i++) {\n                if (isoTimes[i][1].exec(match[3])) {\n                    // match[2] should be 'T' or space\n                    timeFormat = (match[2] || ' ') + isoTimes[i][0];\n                    break;\n                }\n            }\n            if (timeFormat == null) {\n                config._isValid = false;\n                return;\n            }\n        }\n        if (!allowTime && timeFormat != null) {\n            config._isValid = false;\n            return;\n        }\n        if (match[4]) {\n            if (tzRegex.exec(match[4])) {\n                tzFormat = 'Z';\n            } else {\n                config._isValid = false;\n                return;\n            }\n        }\n        config._f = dateFormat + (timeFormat || '') + (tzFormat || '');\n        configFromStringAndFormat(config);\n    } else {\n        config._isValid = false;\n    }\n}\n\n// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3\nvar basicRfcRegex = /^((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\\s)?(\\d?\\d\\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\s(?:\\d\\d)?\\d\\d\\s)(\\d\\d:\\d\\d)(\\:\\d\\d)?(\\s(?:UT|GMT|[ECMP][SD]T|[A-IK-Za-ik-z]|[+-]\\d{4}))$/;\n\n// date and time from ref 2822 format\nfunction configFromRFC2822(config) {\n    var string, match, dayFormat,\n        dateFormat, timeFormat, tzFormat;\n    var timezones = {\n        ' GMT': ' +0000',\n        ' EDT': ' -0400',\n        ' EST': ' -0500',\n        ' CDT': ' -0500',\n        ' CST': ' -0600',\n        ' MDT': ' -0600',\n        ' MST': ' -0700',\n        ' PDT': ' -0700',\n        ' PST': ' -0800'\n    };\n    var military = 'YXWVUTSRQPONZABCDEFGHIKLM';\n    var timezone, timezoneIndex;\n\n    string = config._i\n        .replace(/\\([^\\)]*\\)|[\\n\\t]/g, ' ') // Remove comments and folding whitespace\n        .replace(/(\\s\\s+)/g, ' ') // Replace multiple-spaces with a single space\n        .replace(/^\\s|\\s$/g, ''); // Remove leading and trailing spaces\n    match = basicRfcRegex.exec(string);\n\n    if (match) {\n        dayFormat = match[1] ? 'ddd' + ((match[1].length === 5) ? ', ' : ' ') : '';\n        dateFormat = 'D MMM ' + ((match[2].length > 10) ? 'YYYY ' : 'YY ');\n        timeFormat = 'HH:mm' + (match[4] ? ':ss' : '');\n\n        // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.\n        if (match[1]) { // day of week given\n            var momentDate = new Date(match[2]);\n            var momentDay = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'][momentDate.getDay()];\n\n            if (match[1].substr(0,3) !== momentDay) {\n                getParsingFlags(config).weekdayMismatch = true;\n                config._isValid = false;\n                return;\n            }\n        }\n\n        switch (match[5].length) {\n            case 2: // military\n                if (timezoneIndex === 0) {\n                    timezone = ' +0000';\n                } else {\n                    timezoneIndex = military.indexOf(match[5][1].toUpperCase()) - 12;\n                    timezone = ((timezoneIndex < 0) ? ' -' : ' +') +\n                        (('' + timezoneIndex).replace(/^-?/, '0')).match(/..$/)[0] + '00';\n                }\n                break;\n            case 4: // Zone\n                timezone = timezones[match[5]];\n                break;\n            default: // UT or +/-9999\n                timezone = timezones[' GMT'];\n        }\n        match[5] = timezone;\n        config._i = match.splice(1).join('');\n        tzFormat = ' ZZ';\n        config._f = dayFormat + dateFormat + timeFormat + tzFormat;\n        configFromStringAndFormat(config);\n        getParsingFlags(config).rfc2822 = true;\n    } else {\n        config._isValid = false;\n    }\n}\n\n// date from iso format or fallback\nfunction configFromString(config) {\n    var matched = aspNetJsonRegex.exec(config._i);\n\n    if (matched !== null) {\n        config._d = new Date(+matched[1]);\n        return;\n    }\n\n    configFromISO(config);\n    if (config._isValid === false) {\n        delete config._isValid;\n    } else {\n        return;\n    }\n\n    configFromRFC2822(config);\n    if (config._isValid === false) {\n        delete config._isValid;\n    } else {\n        return;\n    }\n\n    // Final attempt, use Input Fallback\n    hooks.createFromInputFallback(config);\n}\n\nhooks.createFromInputFallback = deprecate(\n    'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +\n    'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +\n    'discouraged and will be removed in an upcoming major release. Please refer to ' +\n    'http://momentjs.com/guides/#/warnings/js-date/ for more info.',\n    function (config) {\n        config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));\n    }\n);\n\n// Pick the first defined of two or three arguments.\nfunction defaults(a, b, c) {\n    if (a != null) {\n        return a;\n    }\n    if (b != null) {\n        return b;\n    }\n    return c;\n}\n\nfunction currentDateArray(config) {\n    // hooks is actually the exported moment object\n    var nowValue = new Date(hooks.now());\n    if (config._useUTC) {\n        return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];\n    }\n    return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];\n}\n\n// convert an array to a date.\n// the array should mirror the parameters below\n// note: all values past the year are optional and will default to the lowest possible value.\n// [year, month, day , hour, minute, second, millisecond]\nfunction configFromArray (config) {\n    var i, date, input = [], currentDate, yearToUse;\n\n    if (config._d) {\n        return;\n    }\n\n    currentDate = currentDateArray(config);\n\n    //compute day of the year from weeks and weekdays\n    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {\n        dayOfYearFromWeekInfo(config);\n    }\n\n    //if the day of the year is set, figure out what it is\n    if (config._dayOfYear != null) {\n        yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);\n\n        if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {\n            getParsingFlags(config)._overflowDayOfYear = true;\n        }\n\n        date = createUTCDate(yearToUse, 0, config._dayOfYear);\n        config._a[MONTH] = date.getUTCMonth();\n        config._a[DATE] = date.getUTCDate();\n    }\n\n    // Default to current date.\n    // * if no year, month, day of month are given, default to today\n    // * if day of month is given, default month and year\n    // * if month is given, default only year\n    // * if year is given, don't default anything\n    for (i = 0; i < 3 && config._a[i] == null; ++i) {\n        config._a[i] = input[i] = currentDate[i];\n    }\n\n    // Zero out whatever was not defaulted, including time\n    for (; i < 7; i++) {\n        config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];\n    }\n\n    // Check for 24:00:00.000\n    if (config._a[HOUR] === 24 &&\n            config._a[MINUTE] === 0 &&\n            config._a[SECOND] === 0 &&\n            config._a[MILLISECOND] === 0) {\n        config._nextDay = true;\n        config._a[HOUR] = 0;\n    }\n\n    config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);\n    // Apply timezone offset from input. The actual utcOffset can be changed\n    // with parseZone.\n    if (config._tzm != null) {\n        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n    }\n\n    if (config._nextDay) {\n        config._a[HOUR] = 24;\n    }\n}\n\nfunction dayOfYearFromWeekInfo(config) {\n    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;\n\n    w = config._w;\n    if (w.GG != null || w.W != null || w.E != null) {\n        dow = 1;\n        doy = 4;\n\n        // TODO: We need to take the current isoWeekYear, but that depends on\n        // how we interpret now (local, utc, fixed offset). So create\n        // a now version of current config (take local/utc/offset flags, and\n        // create now).\n        weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);\n        week = defaults(w.W, 1);\n        weekday = defaults(w.E, 1);\n        if (weekday < 1 || weekday > 7) {\n            weekdayOverflow = true;\n        }\n    } else {\n        dow = config._locale._week.dow;\n        doy = config._locale._week.doy;\n\n        var curWeek = weekOfYear(createLocal(), dow, doy);\n\n        weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);\n\n        // Default to current week.\n        week = defaults(w.w, curWeek.week);\n\n        if (w.d != null) {\n            // weekday -- low day numbers are considered next week\n            weekday = w.d;\n            if (weekday < 0 || weekday > 6) {\n                weekdayOverflow = true;\n            }\n        } else if (w.e != null) {\n            // local weekday -- counting starts from begining of week\n            weekday = w.e + dow;\n            if (w.e < 0 || w.e > 6) {\n                weekdayOverflow = true;\n            }\n        } else {\n            // default to begining of week\n            weekday = dow;\n        }\n    }\n    if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {\n        getParsingFlags(config)._overflowWeeks = true;\n    } else if (weekdayOverflow != null) {\n        getParsingFlags(config)._overflowWeekday = true;\n    } else {\n        temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);\n        config._a[YEAR] = temp.year;\n        config._dayOfYear = temp.dayOfYear;\n    }\n}\n\n// constant that refers to the ISO standard\nhooks.ISO_8601 = function () {};\n\n// constant that refers to the RFC 2822 form\nhooks.RFC_2822 = function () {};\n\n// date from string and format string\nfunction configFromStringAndFormat(config) {\n    // TODO: Move this to another part of the creation flow to prevent circular deps\n    if (config._f === hooks.ISO_8601) {\n        configFromISO(config);\n        return;\n    }\n    if (config._f === hooks.RFC_2822) {\n        configFromRFC2822(config);\n        return;\n    }\n    config._a = [];\n    getParsingFlags(config).empty = true;\n\n    // This array is used to make a Date, either with `new Date` or `Date.UTC`\n    var string = '' + config._i,\n        i, parsedInput, tokens, token, skipped,\n        stringLength = string.length,\n        totalParsedInputLength = 0;\n\n    tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];\n\n    for (i = 0; i < tokens.length; i++) {\n        token = tokens[i];\n        parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];\n        // console.log('token', token, 'parsedInput', parsedInput,\n        //         'regex', getParseRegexForToken(token, config));\n        if (parsedInput) {\n            skipped = string.substr(0, string.indexOf(parsedInput));\n            if (skipped.length > 0) {\n                getParsingFlags(config).unusedInput.push(skipped);\n            }\n            string = string.slice(string.indexOf(parsedInput) + parsedInput.length);\n            totalParsedInputLength += parsedInput.length;\n        }\n        // don't parse if it's not a known token\n        if (formatTokenFunctions[token]) {\n            if (parsedInput) {\n                getParsingFlags(config).empty = false;\n            }\n            else {\n                getParsingFlags(config).unusedTokens.push(token);\n            }\n            addTimeToArrayFromToken(token, parsedInput, config);\n        }\n        else if (config._strict && !parsedInput) {\n            getParsingFlags(config).unusedTokens.push(token);\n        }\n    }\n\n    // add remaining unparsed input length to the string\n    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;\n    if (string.length > 0) {\n        getParsingFlags(config).unusedInput.push(string);\n    }\n\n    // clear _12h flag if hour is <= 12\n    if (config._a[HOUR] <= 12 &&\n        getParsingFlags(config).bigHour === true &&\n        config._a[HOUR] > 0) {\n        getParsingFlags(config).bigHour = undefined;\n    }\n\n    getParsingFlags(config).parsedDateParts = config._a.slice(0);\n    getParsingFlags(config).meridiem = config._meridiem;\n    // handle meridiem\n    config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);\n\n    configFromArray(config);\n    checkOverflow(config);\n}\n\n\nfunction meridiemFixWrap (locale, hour, meridiem) {\n    var isPm;\n\n    if (meridiem == null) {\n        // nothing to do\n        return hour;\n    }\n    if (locale.meridiemHour != null) {\n        return locale.meridiemHour(hour, meridiem);\n    } else if (locale.isPM != null) {\n        // Fallback\n        isPm = locale.isPM(meridiem);\n        if (isPm && hour < 12) {\n            hour += 12;\n        }\n        if (!isPm && hour === 12) {\n            hour = 0;\n        }\n        return hour;\n    } else {\n        // this is not supposed to happen\n        return hour;\n    }\n}\n\n// date from string and array of format strings\nfunction configFromStringAndArray(config) {\n    var tempConfig,\n        bestMoment,\n\n        scoreToBeat,\n        i,\n        currentScore;\n\n    if (config._f.length === 0) {\n        getParsingFlags(config).invalidFormat = true;\n        config._d = new Date(NaN);\n        return;\n    }\n\n    for (i = 0; i < config._f.length; i++) {\n        currentScore = 0;\n        tempConfig = copyConfig({}, config);\n        if (config._useUTC != null) {\n            tempConfig._useUTC = config._useUTC;\n        }\n        tempConfig._f = config._f[i];\n        configFromStringAndFormat(tempConfig);\n\n        if (!isValid(tempConfig)) {\n            continue;\n        }\n\n        // if there is any input that was not parsed add a penalty for that format\n        currentScore += getParsingFlags(tempConfig).charsLeftOver;\n\n        //or tokens\n        currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;\n\n        getParsingFlags(tempConfig).score = currentScore;\n\n        if (scoreToBeat == null || currentScore < scoreToBeat) {\n            scoreToBeat = currentScore;\n            bestMoment = tempConfig;\n        }\n    }\n\n    extend(config, bestMoment || tempConfig);\n}\n\nfunction configFromObject(config) {\n    if (config._d) {\n        return;\n    }\n\n    var i = normalizeObjectUnits(config._i);\n    config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {\n        return obj && parseInt(obj, 10);\n    });\n\n    configFromArray(config);\n}\n\nfunction createFromConfig (config) {\n    var res = new Moment(checkOverflow(prepareConfig(config)));\n    if (res._nextDay) {\n        // Adding is smart enough around DST\n        res.add(1, 'd');\n        res._nextDay = undefined;\n    }\n\n    return res;\n}\n\nfunction prepareConfig (config) {\n    var input = config._i,\n        format = config._f;\n\n    config._locale = config._locale || getLocale(config._l);\n\n    if (input === null || (format === undefined && input === '')) {\n        return createInvalid({nullInput: true});\n    }\n\n    if (typeof input === 'string') {\n        config._i = input = config._locale.preparse(input);\n    }\n\n    if (isMoment(input)) {\n        return new Moment(checkOverflow(input));\n    } else if (isDate(input)) {\n        config._d = input;\n    } else if (isArray(format)) {\n        configFromStringAndArray(config);\n    } else if (format) {\n        configFromStringAndFormat(config);\n    }  else {\n        configFromInput(config);\n    }\n\n    if (!isValid(config)) {\n        config._d = null;\n    }\n\n    return config;\n}\n\nfunction configFromInput(config) {\n    var input = config._i;\n    if (isUndefined(input)) {\n        config._d = new Date(hooks.now());\n    } else if (isDate(input)) {\n        config._d = new Date(input.valueOf());\n    } else if (typeof input === 'string') {\n        configFromString(config);\n    } else if (isArray(input)) {\n        config._a = map(input.slice(0), function (obj) {\n            return parseInt(obj, 10);\n        });\n        configFromArray(config);\n    } else if (isObject(input)) {\n        configFromObject(config);\n    } else if (isNumber(input)) {\n        // from milliseconds\n        config._d = new Date(input);\n    } else {\n        hooks.createFromInputFallback(config);\n    }\n}\n\nfunction createLocalOrUTC (input, format, locale, strict, isUTC) {\n    var c = {};\n\n    if (locale === true || locale === false) {\n        strict = locale;\n        locale = undefined;\n    }\n\n    if ((isObject(input) && isObjectEmpty(input)) ||\n            (isArray(input) && input.length === 0)) {\n        input = undefined;\n    }\n    // object construction must be done this way.\n    // https://github.com/moment/moment/issues/1423\n    c._isAMomentObject = true;\n    c._useUTC = c._isUTC = isUTC;\n    c._l = locale;\n    c._i = input;\n    c._f = format;\n    c._strict = strict;\n\n    return createFromConfig(c);\n}\n\nfunction createLocal (input, format, locale, strict) {\n    return createLocalOrUTC(input, format, locale, strict, false);\n}\n\nvar prototypeMin = deprecate(\n    'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',\n    function () {\n        var other = createLocal.apply(null, arguments);\n        if (this.isValid() && other.isValid()) {\n            return other < this ? this : other;\n        } else {\n            return createInvalid();\n        }\n    }\n);\n\nvar prototypeMax = deprecate(\n    'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',\n    function () {\n        var other = createLocal.apply(null, arguments);\n        if (this.isValid() && other.isValid()) {\n            return other > this ? this : other;\n        } else {\n            return createInvalid();\n        }\n    }\n);\n\n// Pick a moment m from moments so that m[fn](other) is true for all\n// other. This relies on the function fn to be transitive.\n//\n// moments should either be an array of moment objects or an array, whose\n// first element is an array of moment objects.\nfunction pickBy(fn, moments) {\n    var res, i;\n    if (moments.length === 1 && isArray(moments[0])) {\n        moments = moments[0];\n    }\n    if (!moments.length) {\n        return createLocal();\n    }\n    res = moments[0];\n    for (i = 1; i < moments.length; ++i) {\n        if (!moments[i].isValid() || moments[i][fn](res)) {\n            res = moments[i];\n        }\n    }\n    return res;\n}\n\n// TODO: Use [].sort instead?\nfunction min () {\n    var args = [].slice.call(arguments, 0);\n\n    return pickBy('isBefore', args);\n}\n\nfunction max () {\n    var args = [].slice.call(arguments, 0);\n\n    return pickBy('isAfter', args);\n}\n\nvar now = function () {\n    return Date.now ? Date.now() : +(new Date());\n};\n\nvar ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];\n\nfunction isDurationValid(m) {\n    for (var key in m) {\n        if (!(ordering.indexOf(key) !== -1 && (m[key] == null || !isNaN(m[key])))) {\n            return false;\n        }\n    }\n\n    var unitHasDecimal = false;\n    for (var i = 0; i < ordering.length; ++i) {\n        if (m[ordering[i]]) {\n            if (unitHasDecimal) {\n                return false; // only allow non-integers for smallest unit\n            }\n            if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {\n                unitHasDecimal = true;\n            }\n        }\n    }\n\n    return true;\n}\n\nfunction isValid$1() {\n    return this._isValid;\n}\n\nfunction createInvalid$1() {\n    return createDuration(NaN);\n}\n\nfunction Duration (duration) {\n    var normalizedInput = normalizeObjectUnits(duration),\n        years = normalizedInput.year || 0,\n        quarters = normalizedInput.quarter || 0,\n        months = normalizedInput.month || 0,\n        weeks = normalizedInput.week || 0,\n        days = normalizedInput.day || 0,\n        hours = normalizedInput.hour || 0,\n        minutes = normalizedInput.minute || 0,\n        seconds = normalizedInput.second || 0,\n        milliseconds = normalizedInput.millisecond || 0;\n\n    this._isValid = isDurationValid(normalizedInput);\n\n    // representation for dateAddRemove\n    this._milliseconds = +milliseconds +\n        seconds * 1e3 + // 1000\n        minutes * 6e4 + // 1000 * 60\n        hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978\n    // Because of dateAddRemove treats 24 hours as different from a\n    // day when working around DST, we need to store them separately\n    this._days = +days +\n        weeks * 7;\n    // It is impossible translate months into days without knowing\n    // which months you are are talking about, so we have to store\n    // it separately.\n    this._months = +months +\n        quarters * 3 +\n        years * 12;\n\n    this._data = {};\n\n    this._locale = getLocale();\n\n    this._bubble();\n}\n\nfunction isDuration (obj) {\n    return obj instanceof Duration;\n}\n\nfunction absRound (number) {\n    if (number < 0) {\n        return Math.round(-1 * number) * -1;\n    } else {\n        return Math.round(number);\n    }\n}\n\n// FORMATTING\n\nfunction offset (token, separator) {\n    addFormatToken(token, 0, 0, function () {\n        var offset = this.utcOffset();\n        var sign = '+';\n        if (offset < 0) {\n            offset = -offset;\n            sign = '-';\n        }\n        return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);\n    });\n}\n\noffset('Z', ':');\noffset('ZZ', '');\n\n// PARSING\n\naddRegexToken('Z',  matchShortOffset);\naddRegexToken('ZZ', matchShortOffset);\naddParseToken(['Z', 'ZZ'], function (input, array, config) {\n    config._useUTC = true;\n    config._tzm = offsetFromString(matchShortOffset, input);\n});\n\n// HELPERS\n\n// timezone chunker\n// '+10:00' > ['10',  '00']\n// '-1530'  > ['-15', '30']\nvar chunkOffset = /([\\+\\-]|\\d\\d)/gi;\n\nfunction offsetFromString(matcher, string) {\n    var matches = (string || '').match(matcher);\n\n    if (matches === null) {\n        return null;\n    }\n\n    var chunk   = matches[matches.length - 1] || [];\n    var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];\n    var minutes = +(parts[1] * 60) + toInt(parts[2]);\n\n    return minutes === 0 ?\n      0 :\n      parts[0] === '+' ? minutes : -minutes;\n}\n\n// Return a moment from input, that is local/utc/zone equivalent to model.\nfunction cloneWithOffset(input, model) {\n    var res, diff;\n    if (model._isUTC) {\n        res = model.clone();\n        diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();\n        // Use low-level api, because this fn is low-level api.\n        res._d.setTime(res._d.valueOf() + diff);\n        hooks.updateOffset(res, false);\n        return res;\n    } else {\n        return createLocal(input).local();\n    }\n}\n\nfunction getDateOffset (m) {\n    // On Firefox.24 Date#getTimezoneOffset returns a floating point.\n    // https://github.com/moment/moment/pull/1871\n    return -Math.round(m._d.getTimezoneOffset() / 15) * 15;\n}\n\n// HOOKS\n\n// This function will be called whenever a moment is mutated.\n// It is intended to keep the offset in sync with the timezone.\nhooks.updateOffset = function () {};\n\n// MOMENTS\n\n// keepLocalTime = true means only change the timezone, without\n// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->\n// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset\n// +0200, so we adjust the time as needed, to be valid.\n//\n// Keeping the time actually adds/subtracts (one hour)\n// from the actual represented time. That is why we call updateOffset\n// a second time. In case it wants us to change the offset again\n// _changeInProgress == true case, then we have to adjust, because\n// there is no such time in the given timezone.\nfunction getSetOffset (input, keepLocalTime, keepMinutes) {\n    var offset = this._offset || 0,\n        localAdjust;\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    if (input != null) {\n        if (typeof input === 'string') {\n            input = offsetFromString(matchShortOffset, input);\n            if (input === null) {\n                return this;\n            }\n        } else if (Math.abs(input) < 16 && !keepMinutes) {\n            input = input * 60;\n        }\n        if (!this._isUTC && keepLocalTime) {\n            localAdjust = getDateOffset(this);\n        }\n        this._offset = input;\n        this._isUTC = true;\n        if (localAdjust != null) {\n            this.add(localAdjust, 'm');\n        }\n        if (offset !== input) {\n            if (!keepLocalTime || this._changeInProgress) {\n                addSubtract(this, createDuration(input - offset, 'm'), 1, false);\n            } else if (!this._changeInProgress) {\n                this._changeInProgress = true;\n                hooks.updateOffset(this, true);\n                this._changeInProgress = null;\n            }\n        }\n        return this;\n    } else {\n        return this._isUTC ? offset : getDateOffset(this);\n    }\n}\n\nfunction getSetZone (input, keepLocalTime) {\n    if (input != null) {\n        if (typeof input !== 'string') {\n            input = -input;\n        }\n\n        this.utcOffset(input, keepLocalTime);\n\n        return this;\n    } else {\n        return -this.utcOffset();\n    }\n}\n\nfunction setOffsetToUTC (keepLocalTime) {\n    return this.utcOffset(0, keepLocalTime);\n}\n\nfunction setOffsetToLocal (keepLocalTime) {\n    if (this._isUTC) {\n        this.utcOffset(0, keepLocalTime);\n        this._isUTC = false;\n\n        if (keepLocalTime) {\n            this.subtract(getDateOffset(this), 'm');\n        }\n    }\n    return this;\n}\n\nfunction setOffsetToParsedOffset () {\n    if (this._tzm != null) {\n        this.utcOffset(this._tzm, false, true);\n    } else if (typeof this._i === 'string') {\n        var tZone = offsetFromString(matchOffset, this._i);\n        if (tZone != null) {\n            this.utcOffset(tZone);\n        }\n        else {\n            this.utcOffset(0, true);\n        }\n    }\n    return this;\n}\n\nfunction hasAlignedHourOffset (input) {\n    if (!this.isValid()) {\n        return false;\n    }\n    input = input ? createLocal(input).utcOffset() : 0;\n\n    return (this.utcOffset() - input) % 60 === 0;\n}\n\nfunction isDaylightSavingTime () {\n    return (\n        this.utcOffset() > this.clone().month(0).utcOffset() ||\n        this.utcOffset() > this.clone().month(5).utcOffset()\n    );\n}\n\nfunction isDaylightSavingTimeShifted () {\n    if (!isUndefined(this._isDSTShifted)) {\n        return this._isDSTShifted;\n    }\n\n    var c = {};\n\n    copyConfig(c, this);\n    c = prepareConfig(c);\n\n    if (c._a) {\n        var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);\n        this._isDSTShifted = this.isValid() &&\n            compareArrays(c._a, other.toArray()) > 0;\n    } else {\n        this._isDSTShifted = false;\n    }\n\n    return this._isDSTShifted;\n}\n\nfunction isLocal () {\n    return this.isValid() ? !this._isUTC : false;\n}\n\nfunction isUtcOffset () {\n    return this.isValid() ? this._isUTC : false;\n}\n\nfunction isUtc () {\n    return this.isValid() ? this._isUTC && this._offset === 0 : false;\n}\n\n// ASP.NET json date format regex\nvar aspNetRegex = /^(\\-)?(?:(\\d*)[. ])?(\\d+)\\:(\\d+)(?:\\:(\\d+)(\\.\\d*)?)?$/;\n\n// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html\n// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere\n// and further modified to allow for strings containing both week and day\nvar isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;\n\nfunction createDuration (input, key) {\n    var duration = input,\n        // matching against regexp is expensive, do it on demand\n        match = null,\n        sign,\n        ret,\n        diffRes;\n\n    if (isDuration(input)) {\n        duration = {\n            ms : input._milliseconds,\n            d  : input._days,\n            M  : input._months\n        };\n    } else if (isNumber(input)) {\n        duration = {};\n        if (key) {\n            duration[key] = input;\n        } else {\n            duration.milliseconds = input;\n        }\n    } else if (!!(match = aspNetRegex.exec(input))) {\n        sign = (match[1] === '-') ? -1 : 1;\n        duration = {\n            y  : 0,\n            d  : toInt(match[DATE])                         * sign,\n            h  : toInt(match[HOUR])                         * sign,\n            m  : toInt(match[MINUTE])                       * sign,\n            s  : toInt(match[SECOND])                       * sign,\n            ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match\n        };\n    } else if (!!(match = isoRegex.exec(input))) {\n        sign = (match[1] === '-') ? -1 : 1;\n        duration = {\n            y : parseIso(match[2], sign),\n            M : parseIso(match[3], sign),\n            w : parseIso(match[4], sign),\n            d : parseIso(match[5], sign),\n            h : parseIso(match[6], sign),\n            m : parseIso(match[7], sign),\n            s : parseIso(match[8], sign)\n        };\n    } else if (duration == null) {// checks for null or undefined\n        duration = {};\n    } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {\n        diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));\n\n        duration = {};\n        duration.ms = diffRes.milliseconds;\n        duration.M = diffRes.months;\n    }\n\n    ret = new Duration(duration);\n\n    if (isDuration(input) && hasOwnProp(input, '_locale')) {\n        ret._locale = input._locale;\n    }\n\n    return ret;\n}\n\ncreateDuration.fn = Duration.prototype;\ncreateDuration.invalid = createInvalid$1;\n\nfunction parseIso (inp, sign) {\n    // We'd normally use ~~inp for this, but unfortunately it also\n    // converts floats to ints.\n    // inp may be undefined, so careful calling replace on it.\n    var res = inp && parseFloat(inp.replace(',', '.'));\n    // apply sign while we're at it\n    return (isNaN(res) ? 0 : res) * sign;\n}\n\nfunction positiveMomentsDifference(base, other) {\n    var res = {milliseconds: 0, months: 0};\n\n    res.months = other.month() - base.month() +\n        (other.year() - base.year()) * 12;\n    if (base.clone().add(res.months, 'M').isAfter(other)) {\n        --res.months;\n    }\n\n    res.milliseconds = +other - +(base.clone().add(res.months, 'M'));\n\n    return res;\n}\n\nfunction momentsDifference(base, other) {\n    var res;\n    if (!(base.isValid() && other.isValid())) {\n        return {milliseconds: 0, months: 0};\n    }\n\n    other = cloneWithOffset(other, base);\n    if (base.isBefore(other)) {\n        res = positiveMomentsDifference(base, other);\n    } else {\n        res = positiveMomentsDifference(other, base);\n        res.milliseconds = -res.milliseconds;\n        res.months = -res.months;\n    }\n\n    return res;\n}\n\n// TODO: remove 'name' arg after deprecation is removed\nfunction createAdder(direction, name) {\n    return function (val, period) {\n        var dur, tmp;\n        //invert the arguments, but complain about it\n        if (period !== null && !isNaN(+period)) {\n            deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +\n            'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');\n            tmp = val; val = period; period = tmp;\n        }\n\n        val = typeof val === 'string' ? +val : val;\n        dur = createDuration(val, period);\n        addSubtract(this, dur, direction);\n        return this;\n    };\n}\n\nfunction addSubtract (mom, duration, isAdding, updateOffset) {\n    var milliseconds = duration._milliseconds,\n        days = absRound(duration._days),\n        months = absRound(duration._months);\n\n    if (!mom.isValid()) {\n        // No op\n        return;\n    }\n\n    updateOffset = updateOffset == null ? true : updateOffset;\n\n    if (milliseconds) {\n        mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);\n    }\n    if (days) {\n        set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);\n    }\n    if (months) {\n        setMonth(mom, get(mom, 'Month') + months * isAdding);\n    }\n    if (updateOffset) {\n        hooks.updateOffset(mom, days || months);\n    }\n}\n\nvar add      = createAdder(1, 'add');\nvar subtract = createAdder(-1, 'subtract');\n\nfunction getCalendarFormat(myMoment, now) {\n    var diff = myMoment.diff(now, 'days', true);\n    return diff < -6 ? 'sameElse' :\n            diff < -1 ? 'lastWeek' :\n            diff < 0 ? 'lastDay' :\n            diff < 1 ? 'sameDay' :\n            diff < 2 ? 'nextDay' :\n            diff < 7 ? 'nextWeek' : 'sameElse';\n}\n\nfunction calendar$1 (time, formats) {\n    // We want to compare the start of today, vs this.\n    // Getting start-of-today depends on whether we're local/utc/offset or not.\n    var now = time || createLocal(),\n        sod = cloneWithOffset(now, this).startOf('day'),\n        format = hooks.calendarFormat(this, sod) || 'sameElse';\n\n    var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);\n\n    return this.format(output || this.localeData().calendar(format, this, createLocal(now)));\n}\n\nfunction clone () {\n    return new Moment(this);\n}\n\nfunction isAfter (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input);\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() > localInput.valueOf();\n    } else {\n        return localInput.valueOf() < this.clone().startOf(units).valueOf();\n    }\n}\n\nfunction isBefore (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input);\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() < localInput.valueOf();\n    } else {\n        return this.clone().endOf(units).valueOf() < localInput.valueOf();\n    }\n}\n\nfunction isBetween (from, to, units, inclusivity) {\n    inclusivity = inclusivity || '()';\n    return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&\n        (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));\n}\n\nfunction isSame (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input),\n        inputMs;\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(units || 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() === localInput.valueOf();\n    } else {\n        inputMs = localInput.valueOf();\n        return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();\n    }\n}\n\nfunction isSameOrAfter (input, units) {\n    return this.isSame(input, units) || this.isAfter(input,units);\n}\n\nfunction isSameOrBefore (input, units) {\n    return this.isSame(input, units) || this.isBefore(input,units);\n}\n\nfunction diff (input, units, asFloat) {\n    var that,\n        zoneDelta,\n        delta, output;\n\n    if (!this.isValid()) {\n        return NaN;\n    }\n\n    that = cloneWithOffset(input, this);\n\n    if (!that.isValid()) {\n        return NaN;\n    }\n\n    zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;\n\n    units = normalizeUnits(units);\n\n    if (units === 'year' || units === 'month' || units === 'quarter') {\n        output = monthDiff(this, that);\n        if (units === 'quarter') {\n            output = output / 3;\n        } else if (units === 'year') {\n            output = output / 12;\n        }\n    } else {\n        delta = this - that;\n        output = units === 'second' ? delta / 1e3 : // 1000\n            units === 'minute' ? delta / 6e4 : // 1000 * 60\n            units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60\n            units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst\n            units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst\n            delta;\n    }\n    return asFloat ? output : absFloor(output);\n}\n\nfunction monthDiff (a, b) {\n    // difference in months\n    var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),\n        // b is in (anchor - 1 month, anchor + 1 month)\n        anchor = a.clone().add(wholeMonthDiff, 'months'),\n        anchor2, adjust;\n\n    if (b - anchor < 0) {\n        anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');\n        // linear across the month\n        adjust = (b - anchor) / (anchor - anchor2);\n    } else {\n        anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');\n        // linear across the month\n        adjust = (b - anchor) / (anchor2 - anchor);\n    }\n\n    //check for negative zero, return zero if negative zero\n    return -(wholeMonthDiff + adjust) || 0;\n}\n\nhooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';\nhooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';\n\nfunction toString () {\n    return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');\n}\n\nfunction toISOString() {\n    if (!this.isValid()) {\n        return null;\n    }\n    var m = this.clone().utc();\n    if (m.year() < 0 || m.year() > 9999) {\n        return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n    }\n    if (isFunction(Date.prototype.toISOString)) {\n        // native implementation is ~50x faster, use it when we can\n        return this.toDate().toISOString();\n    }\n    return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n}\n\n/**\n * Return a human readable representation of a moment that can\n * also be evaluated to get a new moment which is the same\n *\n * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects\n */\nfunction inspect () {\n    if (!this.isValid()) {\n        return 'moment.invalid(/* ' + this._i + ' */)';\n    }\n    var func = 'moment';\n    var zone = '';\n    if (!this.isLocal()) {\n        func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';\n        zone = 'Z';\n    }\n    var prefix = '[' + func + '(\"]';\n    var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';\n    var datetime = '-MM-DD[T]HH:mm:ss.SSS';\n    var suffix = zone + '[\")]';\n\n    return this.format(prefix + year + datetime + suffix);\n}\n\nfunction format (inputString) {\n    if (!inputString) {\n        inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;\n    }\n    var output = formatMoment(this, inputString);\n    return this.localeData().postformat(output);\n}\n\nfunction from (time, withoutSuffix) {\n    if (this.isValid() &&\n            ((isMoment(time) && time.isValid()) ||\n             createLocal(time).isValid())) {\n        return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);\n    } else {\n        return this.localeData().invalidDate();\n    }\n}\n\nfunction fromNow (withoutSuffix) {\n    return this.from(createLocal(), withoutSuffix);\n}\n\nfunction to (time, withoutSuffix) {\n    if (this.isValid() &&\n            ((isMoment(time) && time.isValid()) ||\n             createLocal(time).isValid())) {\n        return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);\n    } else {\n        return this.localeData().invalidDate();\n    }\n}\n\nfunction toNow (withoutSuffix) {\n    return this.to(createLocal(), withoutSuffix);\n}\n\n// If passed a locale key, it will set the locale for this\n// instance.  Otherwise, it will return the locale configuration\n// variables for this instance.\nfunction locale (key) {\n    var newLocaleData;\n\n    if (key === undefined) {\n        return this._locale._abbr;\n    } else {\n        newLocaleData = getLocale(key);\n        if (newLocaleData != null) {\n            this._locale = newLocaleData;\n        }\n        return this;\n    }\n}\n\nvar lang = deprecate(\n    'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',\n    function (key) {\n        if (key === undefined) {\n            return this.localeData();\n        } else {\n            return this.locale(key);\n        }\n    }\n);\n\nfunction localeData () {\n    return this._locale;\n}\n\nfunction startOf (units) {\n    units = normalizeUnits(units);\n    // the following switch intentionally omits break keywords\n    // to utilize falling through the cases.\n    switch (units) {\n        case 'year':\n            this.month(0);\n            /* falls through */\n        case 'quarter':\n        case 'month':\n            this.date(1);\n            /* falls through */\n        case 'week':\n        case 'isoWeek':\n        case 'day':\n        case 'date':\n            this.hours(0);\n            /* falls through */\n        case 'hour':\n            this.minutes(0);\n            /* falls through */\n        case 'minute':\n            this.seconds(0);\n            /* falls through */\n        case 'second':\n            this.milliseconds(0);\n    }\n\n    // weeks are a special case\n    if (units === 'week') {\n        this.weekday(0);\n    }\n    if (units === 'isoWeek') {\n        this.isoWeekday(1);\n    }\n\n    // quarters are also special\n    if (units === 'quarter') {\n        this.month(Math.floor(this.month() / 3) * 3);\n    }\n\n    return this;\n}\n\nfunction endOf (units) {\n    units = normalizeUnits(units);\n    if (units === undefined || units === 'millisecond') {\n        return this;\n    }\n\n    // 'date' is an alias for 'day', so it should be considered as such.\n    if (units === 'date') {\n        units = 'day';\n    }\n\n    return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');\n}\n\nfunction valueOf () {\n    return this._d.valueOf() - ((this._offset || 0) * 60000);\n}\n\nfunction unix () {\n    return Math.floor(this.valueOf() / 1000);\n}\n\nfunction toDate () {\n    return new Date(this.valueOf());\n}\n\nfunction toArray () {\n    var m = this;\n    return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];\n}\n\nfunction toObject () {\n    var m = this;\n    return {\n        years: m.year(),\n        months: m.month(),\n        date: m.date(),\n        hours: m.hours(),\n        minutes: m.minutes(),\n        seconds: m.seconds(),\n        milliseconds: m.milliseconds()\n    };\n}\n\nfunction toJSON () {\n    // new Date(NaN).toJSON() === null\n    return this.isValid() ? this.toISOString() : null;\n}\n\nfunction isValid$2 () {\n    return isValid(this);\n}\n\nfunction parsingFlags () {\n    return extend({}, getParsingFlags(this));\n}\n\nfunction invalidAt () {\n    return getParsingFlags(this).overflow;\n}\n\nfunction creationData() {\n    return {\n        input: this._i,\n        format: this._f,\n        locale: this._locale,\n        isUTC: this._isUTC,\n        strict: this._strict\n    };\n}\n\n// FORMATTING\n\naddFormatToken(0, ['gg', 2], 0, function () {\n    return this.weekYear() % 100;\n});\n\naddFormatToken(0, ['GG', 2], 0, function () {\n    return this.isoWeekYear() % 100;\n});\n\nfunction addWeekYearFormatToken (token, getter) {\n    addFormatToken(0, [token, token.length], 0, getter);\n}\n\naddWeekYearFormatToken('gggg',     'weekYear');\naddWeekYearFormatToken('ggggg',    'weekYear');\naddWeekYearFormatToken('GGGG',  'isoWeekYear');\naddWeekYearFormatToken('GGGGG', 'isoWeekYear');\n\n// ALIASES\n\naddUnitAlias('weekYear', 'gg');\naddUnitAlias('isoWeekYear', 'GG');\n\n// PRIORITY\n\naddUnitPriority('weekYear', 1);\naddUnitPriority('isoWeekYear', 1);\n\n\n// PARSING\n\naddRegexToken('G',      matchSigned);\naddRegexToken('g',      matchSigned);\naddRegexToken('GG',     match1to2, match2);\naddRegexToken('gg',     match1to2, match2);\naddRegexToken('GGGG',   match1to4, match4);\naddRegexToken('gggg',   match1to4, match4);\naddRegexToken('GGGGG',  match1to6, match6);\naddRegexToken('ggggg',  match1to6, match6);\n\naddWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {\n    week[token.substr(0, 2)] = toInt(input);\n});\n\naddWeekParseToken(['gg', 'GG'], function (input, week, config, token) {\n    week[token] = hooks.parseTwoDigitYear(input);\n});\n\n// MOMENTS\n\nfunction getSetWeekYear (input) {\n    return getSetWeekYearHelper.call(this,\n            input,\n            this.week(),\n            this.weekday(),\n            this.localeData()._week.dow,\n            this.localeData()._week.doy);\n}\n\nfunction getSetISOWeekYear (input) {\n    return getSetWeekYearHelper.call(this,\n            input, this.isoWeek(), this.isoWeekday(), 1, 4);\n}\n\nfunction getISOWeeksInYear () {\n    return weeksInYear(this.year(), 1, 4);\n}\n\nfunction getWeeksInYear () {\n    var weekInfo = this.localeData()._week;\n    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);\n}\n\nfunction getSetWeekYearHelper(input, week, weekday, dow, doy) {\n    var weeksTarget;\n    if (input == null) {\n        return weekOfYear(this, dow, doy).year;\n    } else {\n        weeksTarget = weeksInYear(input, dow, doy);\n        if (week > weeksTarget) {\n            week = weeksTarget;\n        }\n        return setWeekAll.call(this, input, week, weekday, dow, doy);\n    }\n}\n\nfunction setWeekAll(weekYear, week, weekday, dow, doy) {\n    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),\n        date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);\n\n    this.year(date.getUTCFullYear());\n    this.month(date.getUTCMonth());\n    this.date(date.getUTCDate());\n    return this;\n}\n\n// FORMATTING\n\naddFormatToken('Q', 0, 'Qo', 'quarter');\n\n// ALIASES\n\naddUnitAlias('quarter', 'Q');\n\n// PRIORITY\n\naddUnitPriority('quarter', 7);\n\n// PARSING\n\naddRegexToken('Q', match1);\naddParseToken('Q', function (input, array) {\n    array[MONTH] = (toInt(input) - 1) * 3;\n});\n\n// MOMENTS\n\nfunction getSetQuarter (input) {\n    return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);\n}\n\n// FORMATTING\n\naddFormatToken('D', ['DD', 2], 'Do', 'date');\n\n// ALIASES\n\naddUnitAlias('date', 'D');\n\n// PRIOROITY\naddUnitPriority('date', 9);\n\n// PARSING\n\naddRegexToken('D',  match1to2);\naddRegexToken('DD', match1to2, match2);\naddRegexToken('Do', function (isStrict, locale) {\n    // TODO: Remove \"ordinalParse\" fallback in next major release.\n    return isStrict ?\n      (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :\n      locale._dayOfMonthOrdinalParseLenient;\n});\n\naddParseToken(['D', 'DD'], DATE);\naddParseToken('Do', function (input, array) {\n    array[DATE] = toInt(input.match(match1to2)[0], 10);\n});\n\n// MOMENTS\n\nvar getSetDayOfMonth = makeGetSet('Date', true);\n\n// FORMATTING\n\naddFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');\n\n// ALIASES\n\naddUnitAlias('dayOfYear', 'DDD');\n\n// PRIORITY\naddUnitPriority('dayOfYear', 4);\n\n// PARSING\n\naddRegexToken('DDD',  match1to3);\naddRegexToken('DDDD', match3);\naddParseToken(['DDD', 'DDDD'], function (input, array, config) {\n    config._dayOfYear = toInt(input);\n});\n\n// HELPERS\n\n// MOMENTS\n\nfunction getSetDayOfYear (input) {\n    var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;\n    return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');\n}\n\n// FORMATTING\n\naddFormatToken('m', ['mm', 2], 0, 'minute');\n\n// ALIASES\n\naddUnitAlias('minute', 'm');\n\n// PRIORITY\n\naddUnitPriority('minute', 14);\n\n// PARSING\n\naddRegexToken('m',  match1to2);\naddRegexToken('mm', match1to2, match2);\naddParseToken(['m', 'mm'], MINUTE);\n\n// MOMENTS\n\nvar getSetMinute = makeGetSet('Minutes', false);\n\n// FORMATTING\n\naddFormatToken('s', ['ss', 2], 0, 'second');\n\n// ALIASES\n\naddUnitAlias('second', 's');\n\n// PRIORITY\n\naddUnitPriority('second', 15);\n\n// PARSING\n\naddRegexToken('s',  match1to2);\naddRegexToken('ss', match1to2, match2);\naddParseToken(['s', 'ss'], SECOND);\n\n// MOMENTS\n\nvar getSetSecond = makeGetSet('Seconds', false);\n\n// FORMATTING\n\naddFormatToken('S', 0, 0, function () {\n    return ~~(this.millisecond() / 100);\n});\n\naddFormatToken(0, ['SS', 2], 0, function () {\n    return ~~(this.millisecond() / 10);\n});\n\naddFormatToken(0, ['SSS', 3], 0, 'millisecond');\naddFormatToken(0, ['SSSS', 4], 0, function () {\n    return this.millisecond() * 10;\n});\naddFormatToken(0, ['SSSSS', 5], 0, function () {\n    return this.millisecond() * 100;\n});\naddFormatToken(0, ['SSSSSS', 6], 0, function () {\n    return this.millisecond() * 1000;\n});\naddFormatToken(0, ['SSSSSSS', 7], 0, function () {\n    return this.millisecond() * 10000;\n});\naddFormatToken(0, ['SSSSSSSS', 8], 0, function () {\n    return this.millisecond() * 100000;\n});\naddFormatToken(0, ['SSSSSSSSS', 9], 0, function () {\n    return this.millisecond() * 1000000;\n});\n\n\n// ALIASES\n\naddUnitAlias('millisecond', 'ms');\n\n// PRIORITY\n\naddUnitPriority('millisecond', 16);\n\n// PARSING\n\naddRegexToken('S',    match1to3, match1);\naddRegexToken('SS',   match1to3, match2);\naddRegexToken('SSS',  match1to3, match3);\n\nvar token;\nfor (token = 'SSSS'; token.length <= 9; token += 'S') {\n    addRegexToken(token, matchUnsigned);\n}\n\nfunction parseMs(input, array) {\n    array[MILLISECOND] = toInt(('0.' + input) * 1000);\n}\n\nfor (token = 'S'; token.length <= 9; token += 'S') {\n    addParseToken(token, parseMs);\n}\n// MOMENTS\n\nvar getSetMillisecond = makeGetSet('Milliseconds', false);\n\n// FORMATTING\n\naddFormatToken('z',  0, 0, 'zoneAbbr');\naddFormatToken('zz', 0, 0, 'zoneName');\n\n// MOMENTS\n\nfunction getZoneAbbr () {\n    return this._isUTC ? 'UTC' : '';\n}\n\nfunction getZoneName () {\n    return this._isUTC ? 'Coordinated Universal Time' : '';\n}\n\nvar proto = Moment.prototype;\n\nproto.add               = add;\nproto.calendar          = calendar$1;\nproto.clone             = clone;\nproto.diff              = diff;\nproto.endOf             = endOf;\nproto.format            = format;\nproto.from              = from;\nproto.fromNow           = fromNow;\nproto.to                = to;\nproto.toNow             = toNow;\nproto.get               = stringGet;\nproto.invalidAt         = invalidAt;\nproto.isAfter           = isAfter;\nproto.isBefore          = isBefore;\nproto.isBetween         = isBetween;\nproto.isSame            = isSame;\nproto.isSameOrAfter     = isSameOrAfter;\nproto.isSameOrBefore    = isSameOrBefore;\nproto.isValid           = isValid$2;\nproto.lang              = lang;\nproto.locale            = locale;\nproto.localeData        = localeData;\nproto.max               = prototypeMax;\nproto.min               = prototypeMin;\nproto.parsingFlags      = parsingFlags;\nproto.set               = stringSet;\nproto.startOf           = startOf;\nproto.subtract          = subtract;\nproto.toArray           = toArray;\nproto.toObject          = toObject;\nproto.toDate            = toDate;\nproto.toISOString       = toISOString;\nproto.inspect           = inspect;\nproto.toJSON            = toJSON;\nproto.toString          = toString;\nproto.unix              = unix;\nproto.valueOf           = valueOf;\nproto.creationData      = creationData;\n\n// Year\nproto.year       = getSetYear;\nproto.isLeapYear = getIsLeapYear;\n\n// Week Year\nproto.weekYear    = getSetWeekYear;\nproto.isoWeekYear = getSetISOWeekYear;\n\n// Quarter\nproto.quarter = proto.quarters = getSetQuarter;\n\n// Month\nproto.month       = getSetMonth;\nproto.daysInMonth = getDaysInMonth;\n\n// Week\nproto.week           = proto.weeks        = getSetWeek;\nproto.isoWeek        = proto.isoWeeks     = getSetISOWeek;\nproto.weeksInYear    = getWeeksInYear;\nproto.isoWeeksInYear = getISOWeeksInYear;\n\n// Day\nproto.date       = getSetDayOfMonth;\nproto.day        = proto.days             = getSetDayOfWeek;\nproto.weekday    = getSetLocaleDayOfWeek;\nproto.isoWeekday = getSetISODayOfWeek;\nproto.dayOfYear  = getSetDayOfYear;\n\n// Hour\nproto.hour = proto.hours = getSetHour;\n\n// Minute\nproto.minute = proto.minutes = getSetMinute;\n\n// Second\nproto.second = proto.seconds = getSetSecond;\n\n// Millisecond\nproto.millisecond = proto.milliseconds = getSetMillisecond;\n\n// Offset\nproto.utcOffset            = getSetOffset;\nproto.utc                  = setOffsetToUTC;\nproto.local                = setOffsetToLocal;\nproto.parseZone            = setOffsetToParsedOffset;\nproto.hasAlignedHourOffset = hasAlignedHourOffset;\nproto.isDST                = isDaylightSavingTime;\nproto.isLocal              = isLocal;\nproto.isUtcOffset          = isUtcOffset;\nproto.isUtc                = isUtc;\nproto.isUTC                = isUtc;\n\n// Timezone\nproto.zoneAbbr = getZoneAbbr;\nproto.zoneName = getZoneName;\n\n// Deprecations\nproto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);\nproto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);\nproto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);\nproto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);\nproto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);\n\nfunction createUnix (input) {\n    return createLocal(input * 1000);\n}\n\nfunction createInZone () {\n    return createLocal.apply(null, arguments).parseZone();\n}\n\nfunction preParsePostFormat (string) {\n    return string;\n}\n\nvar proto$1 = Locale.prototype;\n\nproto$1.calendar        = calendar;\nproto$1.longDateFormat  = longDateFormat;\nproto$1.invalidDate     = invalidDate;\nproto$1.ordinal         = ordinal;\nproto$1.preparse        = preParsePostFormat;\nproto$1.postformat      = preParsePostFormat;\nproto$1.relativeTime    = relativeTime;\nproto$1.pastFuture      = pastFuture;\nproto$1.set             = set;\n\n// Month\nproto$1.months            =        localeMonths;\nproto$1.monthsShort       =        localeMonthsShort;\nproto$1.monthsParse       =        localeMonthsParse;\nproto$1.monthsRegex       = monthsRegex;\nproto$1.monthsShortRegex  = monthsShortRegex;\n\n// Week\nproto$1.week = localeWeek;\nproto$1.firstDayOfYear = localeFirstDayOfYear;\nproto$1.firstDayOfWeek = localeFirstDayOfWeek;\n\n// Day of Week\nproto$1.weekdays       =        localeWeekdays;\nproto$1.weekdaysMin    =        localeWeekdaysMin;\nproto$1.weekdaysShort  =        localeWeekdaysShort;\nproto$1.weekdaysParse  =        localeWeekdaysParse;\n\nproto$1.weekdaysRegex       =        weekdaysRegex;\nproto$1.weekdaysShortRegex  =        weekdaysShortRegex;\nproto$1.weekdaysMinRegex    =        weekdaysMinRegex;\n\n// Hours\nproto$1.isPM = localeIsPM;\nproto$1.meridiem = localeMeridiem;\n\nfunction get$1 (format, index, field, setter) {\n    var locale = getLocale();\n    var utc = createUTC().set(setter, index);\n    return locale[field](utc, format);\n}\n\nfunction listMonthsImpl (format, index, field) {\n    if (isNumber(format)) {\n        index = format;\n        format = undefined;\n    }\n\n    format = format || '';\n\n    if (index != null) {\n        return get$1(format, index, field, 'month');\n    }\n\n    var i;\n    var out = [];\n    for (i = 0; i < 12; i++) {\n        out[i] = get$1(format, i, field, 'month');\n    }\n    return out;\n}\n\n// ()\n// (5)\n// (fmt, 5)\n// (fmt)\n// (true)\n// (true, 5)\n// (true, fmt, 5)\n// (true, fmt)\nfunction listWeekdaysImpl (localeSorted, format, index, field) {\n    if (typeof localeSorted === 'boolean') {\n        if (isNumber(format)) {\n            index = format;\n            format = undefined;\n        }\n\n        format = format || '';\n    } else {\n        format = localeSorted;\n        index = format;\n        localeSorted = false;\n\n        if (isNumber(format)) {\n            index = format;\n            format = undefined;\n        }\n\n        format = format || '';\n    }\n\n    var locale = getLocale(),\n        shift = localeSorted ? locale._week.dow : 0;\n\n    if (index != null) {\n        return get$1(format, (index + shift) % 7, field, 'day');\n    }\n\n    var i;\n    var out = [];\n    for (i = 0; i < 7; i++) {\n        out[i] = get$1(format, (i + shift) % 7, field, 'day');\n    }\n    return out;\n}\n\nfunction listMonths (format, index) {\n    return listMonthsImpl(format, index, 'months');\n}\n\nfunction listMonthsShort (format, index) {\n    return listMonthsImpl(format, index, 'monthsShort');\n}\n\nfunction listWeekdays (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdays');\n}\n\nfunction listWeekdaysShort (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');\n}\n\nfunction listWeekdaysMin (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');\n}\n\ngetSetGlobalLocale('en', {\n    dayOfMonthOrdinalParse: /\\d{1,2}(th|st|nd|rd)/,\n    ordinal : function (number) {\n        var b = number % 10,\n            output = (toInt(number % 100 / 10) === 1) ? 'th' :\n            (b === 1) ? 'st' :\n            (b === 2) ? 'nd' :\n            (b === 3) ? 'rd' : 'th';\n        return number + output;\n    }\n});\n\n// Side effect imports\nhooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);\nhooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);\n\nvar mathAbs = Math.abs;\n\nfunction abs () {\n    var data           = this._data;\n\n    this._milliseconds = mathAbs(this._milliseconds);\n    this._days         = mathAbs(this._days);\n    this._months       = mathAbs(this._months);\n\n    data.milliseconds  = mathAbs(data.milliseconds);\n    data.seconds       = mathAbs(data.seconds);\n    data.minutes       = mathAbs(data.minutes);\n    data.hours         = mathAbs(data.hours);\n    data.months        = mathAbs(data.months);\n    data.years         = mathAbs(data.years);\n\n    return this;\n}\n\nfunction addSubtract$1 (duration, input, value, direction) {\n    var other = createDuration(input, value);\n\n    duration._milliseconds += direction * other._milliseconds;\n    duration._days         += direction * other._days;\n    duration._months       += direction * other._months;\n\n    return duration._bubble();\n}\n\n// supports only 2.0-style add(1, 's') or add(duration)\nfunction add$1 (input, value) {\n    return addSubtract$1(this, input, value, 1);\n}\n\n// supports only 2.0-style subtract(1, 's') or subtract(duration)\nfunction subtract$1 (input, value) {\n    return addSubtract$1(this, input, value, -1);\n}\n\nfunction absCeil (number) {\n    if (number < 0) {\n        return Math.floor(number);\n    } else {\n        return Math.ceil(number);\n    }\n}\n\nfunction bubble () {\n    var milliseconds = this._milliseconds;\n    var days         = this._days;\n    var months       = this._months;\n    var data         = this._data;\n    var seconds, minutes, hours, years, monthsFromDays;\n\n    // if we have a mix of positive and negative values, bubble down first\n    // check: https://github.com/moment/moment/issues/2166\n    if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||\n            (milliseconds <= 0 && days <= 0 && months <= 0))) {\n        milliseconds += absCeil(monthsToDays(months) + days) * 864e5;\n        days = 0;\n        months = 0;\n    }\n\n    // The following code bubbles up values, see the tests for\n    // examples of what that means.\n    data.milliseconds = milliseconds % 1000;\n\n    seconds           = absFloor(milliseconds / 1000);\n    data.seconds      = seconds % 60;\n\n    minutes           = absFloor(seconds / 60);\n    data.minutes      = minutes % 60;\n\n    hours             = absFloor(minutes / 60);\n    data.hours        = hours % 24;\n\n    days += absFloor(hours / 24);\n\n    // convert days to months\n    monthsFromDays = absFloor(daysToMonths(days));\n    months += monthsFromDays;\n    days -= absCeil(monthsToDays(monthsFromDays));\n\n    // 12 months -> 1 year\n    years = absFloor(months / 12);\n    months %= 12;\n\n    data.days   = days;\n    data.months = months;\n    data.years  = years;\n\n    return this;\n}\n\nfunction daysToMonths (days) {\n    // 400 years have 146097 days (taking into account leap year rules)\n    // 400 years have 12 months === 4800\n    return days * 4800 / 146097;\n}\n\nfunction monthsToDays (months) {\n    // the reverse of daysToMonths\n    return months * 146097 / 4800;\n}\n\nfunction as (units) {\n    if (!this.isValid()) {\n        return NaN;\n    }\n    var days;\n    var months;\n    var milliseconds = this._milliseconds;\n\n    units = normalizeUnits(units);\n\n    if (units === 'month' || units === 'year') {\n        days   = this._days   + milliseconds / 864e5;\n        months = this._months + daysToMonths(days);\n        return units === 'month' ? months : months / 12;\n    } else {\n        // handle milliseconds separately because of floating point math errors (issue #1867)\n        days = this._days + Math.round(monthsToDays(this._months));\n        switch (units) {\n            case 'week'   : return days / 7     + milliseconds / 6048e5;\n            case 'day'    : return days         + milliseconds / 864e5;\n            case 'hour'   : return days * 24    + milliseconds / 36e5;\n            case 'minute' : return days * 1440  + milliseconds / 6e4;\n            case 'second' : return days * 86400 + milliseconds / 1000;\n            // Math.floor prevents floating point math errors here\n            case 'millisecond': return Math.floor(days * 864e5) + milliseconds;\n            default: throw new Error('Unknown unit ' + units);\n        }\n    }\n}\n\n// TODO: Use this.as('ms')?\nfunction valueOf$1 () {\n    if (!this.isValid()) {\n        return NaN;\n    }\n    return (\n        this._milliseconds +\n        this._days * 864e5 +\n        (this._months % 12) * 2592e6 +\n        toInt(this._months / 12) * 31536e6\n    );\n}\n\nfunction makeAs (alias) {\n    return function () {\n        return this.as(alias);\n    };\n}\n\nvar asMilliseconds = makeAs('ms');\nvar asSeconds      = makeAs('s');\nvar asMinutes      = makeAs('m');\nvar asHours        = makeAs('h');\nvar asDays         = makeAs('d');\nvar asWeeks        = makeAs('w');\nvar asMonths       = makeAs('M');\nvar asYears        = makeAs('y');\n\nfunction get$2 (units) {\n    units = normalizeUnits(units);\n    return this.isValid() ? this[units + 's']() : NaN;\n}\n\nfunction makeGetter(name) {\n    return function () {\n        return this.isValid() ? this._data[name] : NaN;\n    };\n}\n\nvar milliseconds = makeGetter('milliseconds');\nvar seconds      = makeGetter('seconds');\nvar minutes      = makeGetter('minutes');\nvar hours        = makeGetter('hours');\nvar days         = makeGetter('days');\nvar months       = makeGetter('months');\nvar years        = makeGetter('years');\n\nfunction weeks () {\n    return absFloor(this.days() / 7);\n}\n\nvar round = Math.round;\nvar thresholds = {\n    ss: 44,         // a few seconds to seconds\n    s : 45,         // seconds to minute\n    m : 45,         // minutes to hour\n    h : 22,         // hours to day\n    d : 26,         // days to month\n    M : 11          // months to year\n};\n\n// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize\nfunction substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {\n    return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);\n}\n\nfunction relativeTime$1 (posNegDuration, withoutSuffix, locale) {\n    var duration = createDuration(posNegDuration).abs();\n    var seconds  = round(duration.as('s'));\n    var minutes  = round(duration.as('m'));\n    var hours    = round(duration.as('h'));\n    var days     = round(duration.as('d'));\n    var months   = round(duration.as('M'));\n    var years    = round(duration.as('y'));\n\n    var a = seconds <= thresholds.ss && ['s', seconds]  ||\n            seconds < thresholds.s   && ['ss', seconds] ||\n            minutes <= 1             && ['m']           ||\n            minutes < thresholds.m   && ['mm', minutes] ||\n            hours   <= 1             && ['h']           ||\n            hours   < thresholds.h   && ['hh', hours]   ||\n            days    <= 1             && ['d']           ||\n            days    < thresholds.d   && ['dd', days]    ||\n            months  <= 1             && ['M']           ||\n            months  < thresholds.M   && ['MM', months]  ||\n            years   <= 1             && ['y']           || ['yy', years];\n\n    a[2] = withoutSuffix;\n    a[3] = +posNegDuration > 0;\n    a[4] = locale;\n    return substituteTimeAgo.apply(null, a);\n}\n\n// This function allows you to set the rounding function for relative time strings\nfunction getSetRelativeTimeRounding (roundingFunction) {\n    if (roundingFunction === undefined) {\n        return round;\n    }\n    if (typeof(roundingFunction) === 'function') {\n        round = roundingFunction;\n        return true;\n    }\n    return false;\n}\n\n// This function allows you to set a threshold for relative time strings\nfunction getSetRelativeTimeThreshold (threshold, limit) {\n    if (thresholds[threshold] === undefined) {\n        return false;\n    }\n    if (limit === undefined) {\n        return thresholds[threshold];\n    }\n    thresholds[threshold] = limit;\n    if (threshold === 's') {\n        thresholds.ss = limit - 1;\n    }\n    return true;\n}\n\nfunction humanize (withSuffix) {\n    if (!this.isValid()) {\n        return this.localeData().invalidDate();\n    }\n\n    var locale = this.localeData();\n    var output = relativeTime$1(this, !withSuffix, locale);\n\n    if (withSuffix) {\n        output = locale.pastFuture(+this, output);\n    }\n\n    return locale.postformat(output);\n}\n\nvar abs$1 = Math.abs;\n\nfunction toISOString$1() {\n    // for ISO strings we do not use the normal bubbling rules:\n    //  * milliseconds bubble up until they become hours\n    //  * days do not bubble at all\n    //  * months bubble up until they become years\n    // This is because there is no context-free conversion between hours and days\n    // (think of clock changes)\n    // and also not between days and months (28-31 days per month)\n    if (!this.isValid()) {\n        return this.localeData().invalidDate();\n    }\n\n    var seconds = abs$1(this._milliseconds) / 1000;\n    var days         = abs$1(this._days);\n    var months       = abs$1(this._months);\n    var minutes, hours, years;\n\n    // 3600 seconds -> 60 minutes -> 1 hour\n    minutes           = absFloor(seconds / 60);\n    hours             = absFloor(minutes / 60);\n    seconds %= 60;\n    minutes %= 60;\n\n    // 12 months -> 1 year\n    years  = absFloor(months / 12);\n    months %= 12;\n\n\n    // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js\n    var Y = years;\n    var M = months;\n    var D = days;\n    var h = hours;\n    var m = minutes;\n    var s = seconds;\n    var total = this.asSeconds();\n\n    if (!total) {\n        // this is the same as C#'s (Noda) and python (isodate)...\n        // but not other JS (goog.date)\n        return 'P0D';\n    }\n\n    return (total < 0 ? '-' : '') +\n        'P' +\n        (Y ? Y + 'Y' : '') +\n        (M ? M + 'M' : '') +\n        (D ? D + 'D' : '') +\n        ((h || m || s) ? 'T' : '') +\n        (h ? h + 'H' : '') +\n        (m ? m + 'M' : '') +\n        (s ? s + 'S' : '');\n}\n\nvar proto$2 = Duration.prototype;\n\nproto$2.isValid        = isValid$1;\nproto$2.abs            = abs;\nproto$2.add            = add$1;\nproto$2.subtract       = subtract$1;\nproto$2.as             = as;\nproto$2.asMilliseconds = asMilliseconds;\nproto$2.asSeconds      = asSeconds;\nproto$2.asMinutes      = asMinutes;\nproto$2.asHours        = asHours;\nproto$2.asDays         = asDays;\nproto$2.asWeeks        = asWeeks;\nproto$2.asMonths       = asMonths;\nproto$2.asYears        = asYears;\nproto$2.valueOf        = valueOf$1;\nproto$2._bubble        = bubble;\nproto$2.get            = get$2;\nproto$2.milliseconds   = milliseconds;\nproto$2.seconds        = seconds;\nproto$2.minutes        = minutes;\nproto$2.hours          = hours;\nproto$2.days           = days;\nproto$2.weeks          = weeks;\nproto$2.months         = months;\nproto$2.years          = years;\nproto$2.humanize       = humanize;\nproto$2.toISOString    = toISOString$1;\nproto$2.toString       = toISOString$1;\nproto$2.toJSON         = toISOString$1;\nproto$2.locale         = locale;\nproto$2.localeData     = localeData;\n\n// Deprecations\nproto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);\nproto$2.lang = lang;\n\n// Side effect imports\n\n// FORMATTING\n\naddFormatToken('X', 0, 0, 'unix');\naddFormatToken('x', 0, 0, 'valueOf');\n\n// PARSING\n\naddRegexToken('x', matchSigned);\naddRegexToken('X', matchTimestamp);\naddParseToken('X', function (input, array, config) {\n    config._d = new Date(parseFloat(input, 10) * 1000);\n});\naddParseToken('x', function (input, array, config) {\n    config._d = new Date(toInt(input));\n});\n\n// Side effect imports\n\n\nhooks.version = '2.18.1';\n\nsetHookCallback(createLocal);\n\nhooks.fn                    = proto;\nhooks.min                   = min;\nhooks.max                   = max;\nhooks.now                   = now;\nhooks.utc                   = createUTC;\nhooks.unix                  = createUnix;\nhooks.months                = listMonths;\nhooks.isDate                = isDate;\nhooks.locale                = getSetGlobalLocale;\nhooks.invalid               = createInvalid;\nhooks.duration              = createDuration;\nhooks.isMoment              = isMoment;\nhooks.weekdays              = listWeekdays;\nhooks.parseZone             = createInZone;\nhooks.localeData            = getLocale;\nhooks.isDuration            = isDuration;\nhooks.monthsShort           = listMonthsShort;\nhooks.weekdaysMin           = listWeekdaysMin;\nhooks.defineLocale          = defineLocale;\nhooks.updateLocale          = updateLocale;\nhooks.locales               = listLocales;\nhooks.weekdaysShort         = listWeekdaysShort;\nhooks.normalizeUnits        = normalizeUnits;\nhooks.relativeTimeRounding = getSetRelativeTimeRounding;\nhooks.relativeTimeThreshold = getSetRelativeTimeThreshold;\nhooks.calendarFormat        = getCalendarFormat;\nhooks.prototype             = proto;\n\nreturn hooks;\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/moment/moment.js\n// module id = 14\n// module chunks = 1","'use strict';\n\nfunction isObject(what) {\n    return typeof what === 'object' && what !== null;\n}\n\n// Yanked from https://git.io/vS8DV re-used under CC0\n// with some tiny modifications\nfunction isError(value) {\n  switch ({}.toString.call(value)) {\n    case '[object Error]': return true;\n    case '[object Exception]': return true;\n    case '[object DOMException]': return true;\n    default: return value instanceof Error;\n  }\n}\n\nfunction wrappedCallback(callback) {\n    function dataCallback(data, original) {\n      var normalizedData = callback(data) || data;\n      if (original) {\n          return original(normalizedData) || normalizedData;\n      }\n      return normalizedData;\n    }\n\n    return dataCallback;\n}\n\nmodule.exports = {\n    isObject: isObject,\n    isError: isError,\n    wrappedCallback: wrappedCallback\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/raven-js/src/utils.js\n// module id = 140\n// module chunks = 1","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]';\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  // Safari 9 makes `arguments.length` enumerable in strict mode.\n  var result = (isArray(value) || isArguments(value))\n    ? baseTimes(value.length, String)\n    : [];\n\n  var length = result.length,\n      skipIndexes = !!length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\n/**\n * The base implementation of `_.forOwn` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\nfunction baseForOwn(object, iteratee) {\n  return object && baseFor(object, iteratee, keys);\n}\n\n/**\n * The base implementation of `_.invert` and `_.invertBy` which inverts\n * `object` with values transformed by `iteratee` and set by `setter`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform values.\n * @param {Object} accumulator The initial inverted object.\n * @returns {Function} Returns `accumulator`.\n */\nfunction baseInverter(object, setter, iteratee, accumulator) {\n  baseForOwn(object, function(value, key, object) {\n    setter(accumulator, iteratee(value), key, object);\n  });\n  return accumulator;\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\n/**\n * Creates a function like `_.invertBy`.\n *\n * @private\n * @param {Function} setter The function to set accumulator values.\n * @param {Function} toIteratee The function to resolve iteratees.\n * @returns {Function} Returns the new inverter function.\n */\nfunction createInverter(setter, toIteratee) {\n  return function(object, iteratee) {\n    return baseInverter(object, setter, toIteratee(iteratee), {});\n  };\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Creates an object composed of the inverted keys and values of `object`.\n * If `object` contains duplicate values, subsequent values overwrite\n * property assignments of previous values.\n *\n * @static\n * @memberOf _\n * @since 0.7.0\n * @category Object\n * @param {Object} object The object to invert.\n * @returns {Object} Returns the new inverted object.\n * @example\n *\n * var object = { 'a': 1, 'b': 2, 'c': 1 };\n *\n * _.invert(object);\n * // => { '1': 'c', '2': 'b' }\n */\nvar invert = createInverter(function(result, value, key) {\n  result[value] = key;\n}, constant(identity));\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nmodule.exports = invert;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash.invert/index.js\n// module id = 141\n// module chunks = 1","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//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/module.js\n// module id = 142\n// module chunks = 1","/**\n * Root reference for iframes.\n */\n\nvar root;\nif (typeof window !== 'undefined') { // Browser window\n  root = window;\n} else if (typeof self !== 'undefined') { // Web Worker\n  root = self;\n} else { // Other environments\n  console.warn(\"Using browser-only version of superagent in non-browser environment\");\n  root = this;\n}\n\nvar Emitter = require('component-emitter');\nvar RequestBase = require('./request-base');\nvar isObject = require('./is-object');\nvar isFunction = require('./is-function');\nvar ResponseBase = require('./response-base');\nvar shouldRetry = require('./should-retry');\n\n/**\n * Noop.\n */\n\nfunction noop(){};\n\n/**\n * Expose `request`.\n */\n\nvar request = exports = module.exports = function(method, url) {\n  // callback\n  if ('function' == typeof url) {\n    return new exports.Request('GET', method).end(url);\n  }\n\n  // url first\n  if (1 == arguments.length) {\n    return new exports.Request('GET', method);\n  }\n\n  return new exports.Request(method, url);\n}\n\nexports.Request = Request;\n\n/**\n * Determine XHR.\n */\n\nrequest.getXHR = function () {\n  if (root.XMLHttpRequest\n      && (!root.location || 'file:' != root.location.protocol\n          || !root.ActiveXObject)) {\n    return new XMLHttpRequest;\n  } else {\n    try { return new ActiveXObject('Microsoft.XMLHTTP'); } catch(e) {}\n    try { return new ActiveXObject('Msxml2.XMLHTTP.6.0'); } catch(e) {}\n    try { return new ActiveXObject('Msxml2.XMLHTTP.3.0'); } catch(e) {}\n    try { return new ActiveXObject('Msxml2.XMLHTTP'); } catch(e) {}\n  }\n  throw Error(\"Browser-only verison of superagent could not find XHR\");\n};\n\n/**\n * Removes leading and trailing whitespace, added to support IE.\n *\n * @param {String} s\n * @return {String}\n * @api private\n */\n\nvar trim = ''.trim\n  ? function(s) { return s.trim(); }\n  : function(s) { return s.replace(/(^\\s*|\\s*$)/g, ''); };\n\n/**\n * Serialize the given `obj`.\n *\n * @param {Object} obj\n * @return {String}\n * @api private\n */\n\nfunction serialize(obj) {\n  if (!isObject(obj)) return obj;\n  var pairs = [];\n  for (var key in obj) {\n    pushEncodedKeyValuePair(pairs, key, obj[key]);\n  }\n  return pairs.join('&');\n}\n\n/**\n * Helps 'serialize' with serializing arrays.\n * Mutates the pairs array.\n *\n * @param {Array} pairs\n * @param {String} key\n * @param {Mixed} val\n */\n\nfunction pushEncodedKeyValuePair(pairs, key, val) {\n  if (val != null) {\n    if (Array.isArray(val)) {\n      val.forEach(function(v) {\n        pushEncodedKeyValuePair(pairs, key, v);\n      });\n    } else if (isObject(val)) {\n      for(var subkey in val) {\n        pushEncodedKeyValuePair(pairs, key + '[' + subkey + ']', val[subkey]);\n      }\n    } else {\n      pairs.push(encodeURIComponent(key)\n        + '=' + encodeURIComponent(val));\n    }\n  } else if (val === null) {\n    pairs.push(encodeURIComponent(key));\n  }\n}\n\n/**\n * Expose serialization method.\n */\n\n request.serializeObject = serialize;\n\n /**\n  * Parse the given x-www-form-urlencoded `str`.\n  *\n  * @param {String} str\n  * @return {Object}\n  * @api private\n  */\n\nfunction parseString(str) {\n  var obj = {};\n  var pairs = str.split('&');\n  var pair;\n  var pos;\n\n  for (var i = 0, len = pairs.length; i < len; ++i) {\n    pair = pairs[i];\n    pos = pair.indexOf('=');\n    if (pos == -1) {\n      obj[decodeURIComponent(pair)] = '';\n    } else {\n      obj[decodeURIComponent(pair.slice(0, pos))] =\n        decodeURIComponent(pair.slice(pos + 1));\n    }\n  }\n\n  return obj;\n}\n\n/**\n * Expose parser.\n */\n\nrequest.parseString = parseString;\n\n/**\n * Default MIME type map.\n *\n *     superagent.types.xml = 'application/xml';\n *\n */\n\nrequest.types = {\n  html: 'text/html',\n  json: 'application/json',\n  xml: 'application/xml',\n  urlencoded: 'application/x-www-form-urlencoded',\n  'form': 'application/x-www-form-urlencoded',\n  'form-data': 'application/x-www-form-urlencoded'\n};\n\n/**\n * Default serialization map.\n *\n *     superagent.serialize['application/xml'] = function(obj){\n *       return 'generated xml here';\n *     };\n *\n */\n\n request.serialize = {\n   'application/x-www-form-urlencoded': serialize,\n   'application/json': JSON.stringify\n };\n\n /**\n  * Default parsers.\n  *\n  *     superagent.parse['application/xml'] = function(str){\n  *       return { object parsed from str };\n  *     };\n  *\n  */\n\nrequest.parse = {\n  'application/x-www-form-urlencoded': parseString,\n  'application/json': JSON.parse\n};\n\n/**\n * Parse the given header `str` into\n * an object containing the mapped fields.\n *\n * @param {String} str\n * @return {Object}\n * @api private\n */\n\nfunction parseHeader(str) {\n  var lines = str.split(/\\r?\\n/);\n  var fields = {};\n  var index;\n  var line;\n  var field;\n  var val;\n\n  lines.pop(); // trailing CRLF\n\n  for (var i = 0, len = lines.length; i < len; ++i) {\n    line = lines[i];\n    index = line.indexOf(':');\n    field = line.slice(0, index).toLowerCase();\n    val = trim(line.slice(index + 1));\n    fields[field] = val;\n  }\n\n  return fields;\n}\n\n/**\n * Check if `mime` is json or has +json structured syntax suffix.\n *\n * @param {String} mime\n * @return {Boolean}\n * @api private\n */\n\nfunction isJSON(mime) {\n  return /[\\/+]json\\b/.test(mime);\n}\n\n/**\n * Initialize a new `Response` with the given `xhr`.\n *\n *  - set flags (.ok, .error, etc)\n *  - parse header\n *\n * Examples:\n *\n *  Aliasing `superagent` as `request` is nice:\n *\n *      request = superagent;\n *\n *  We can use the promise-like API, or pass callbacks:\n *\n *      request.get('/').end(function(res){});\n *      request.get('/', function(res){});\n *\n *  Sending data can be chained:\n *\n *      request\n *        .post('/user')\n *        .send({ name: 'tj' })\n *        .end(function(res){});\n *\n *  Or passed to `.send()`:\n *\n *      request\n *        .post('/user')\n *        .send({ name: 'tj' }, function(res){});\n *\n *  Or passed to `.post()`:\n *\n *      request\n *        .post('/user', { name: 'tj' })\n *        .end(function(res){});\n *\n * Or further reduced to a single call for simple cases:\n *\n *      request\n *        .post('/user', { name: 'tj' }, function(res){});\n *\n * @param {XMLHTTPRequest} xhr\n * @param {Object} options\n * @api private\n */\n\nfunction Response(req) {\n  this.req = req;\n  this.xhr = this.req.xhr;\n  // responseText is accessible only if responseType is '' or 'text' and on older browsers\n  this.text = ((this.req.method !='HEAD' && (this.xhr.responseType === '' || this.xhr.responseType === 'text')) || typeof this.xhr.responseType === 'undefined')\n     ? this.xhr.responseText\n     : null;\n  this.statusText = this.req.xhr.statusText;\n  var status = this.xhr.status;\n  // handle IE9 bug: http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request\n  if (status === 1223) {\n      status = 204;\n  }\n  this._setStatusProperties(status);\n  this.header = this.headers = parseHeader(this.xhr.getAllResponseHeaders());\n  // getAllResponseHeaders sometimes falsely returns \"\" for CORS requests, but\n  // getResponseHeader still works. so we get content-type even if getting\n  // other headers fails.\n  this.header['content-type'] = this.xhr.getResponseHeader('content-type');\n  this._setHeaderProperties(this.header);\n\n  if (null === this.text && req._responseType) {\n    this.body = this.xhr.response;\n  } else {\n    this.body = this.req.method != 'HEAD'\n      ? this._parseBody(this.text ? this.text : this.xhr.response)\n      : null;\n  }\n}\n\nResponseBase(Response.prototype);\n\n/**\n * Parse the given body `str`.\n *\n * Used for auto-parsing of bodies. Parsers\n * are defined on the `superagent.parse` object.\n *\n * @param {String} str\n * @return {Mixed}\n * @api private\n */\n\nResponse.prototype._parseBody = function(str){\n  var parse = request.parse[this.type];\n  if(this.req._parser) {\n    return this.req._parser(this, str);\n  }\n  if (!parse && isJSON(this.type)) {\n    parse = request.parse['application/json'];\n  }\n  return parse && str && (str.length || str instanceof Object)\n    ? parse(str)\n    : null;\n};\n\n/**\n * Return an `Error` representative of this response.\n *\n * @return {Error}\n * @api public\n */\n\nResponse.prototype.toError = function(){\n  var req = this.req;\n  var method = req.method;\n  var url = req.url;\n\n  var msg = 'cannot ' + method + ' ' + url + ' (' + this.status + ')';\n  var err = new Error(msg);\n  err.status = this.status;\n  err.method = method;\n  err.url = url;\n\n  return err;\n};\n\n/**\n * Expose `Response`.\n */\n\nrequest.Response = Response;\n\n/**\n * Initialize a new `Request` with the given `method` and `url`.\n *\n * @param {String} method\n * @param {String} url\n * @api public\n */\n\nfunction Request(method, url) {\n  var self = this;\n  this._query = this._query || [];\n  this.method = method;\n  this.url = url;\n  this.header = {}; // preserves header name case\n  this._header = {}; // coerces header names to lowercase\n  this.on('end', function(){\n    var err = null;\n    var res = null;\n\n    try {\n      res = new Response(self);\n    } catch(e) {\n      err = new Error('Parser is unable to parse the response');\n      err.parse = true;\n      err.original = e;\n      // issue #675: return the raw response if the response parsing fails\n      if (self.xhr) {\n        // ie9 doesn't have 'response' property\n        err.rawResponse = typeof self.xhr.responseType == 'undefined' ? self.xhr.responseText : self.xhr.response;\n        // issue #876: return the http status code if the response parsing fails\n        err.status = self.xhr.status ? self.xhr.status : null;\n        err.statusCode = err.status; // backwards-compat only\n      } else {\n        err.rawResponse = null;\n        err.status = null;\n      }\n\n      return self.callback(err);\n    }\n\n    self.emit('response', res);\n\n    var new_err;\n    try {\n      if (!self._isResponseOK(res)) {\n        new_err = new Error(res.statusText || 'Unsuccessful HTTP response');\n        new_err.original = err;\n        new_err.response = res;\n        new_err.status = res.status;\n      }\n    } catch(e) {\n      new_err = e; // #985 touching res may cause INVALID_STATE_ERR on old Android\n    }\n\n    // #1000 don't catch errors from the callback to avoid double calling it\n    if (new_err) {\n      self.callback(new_err, res);\n    } else {\n      self.callback(null, res);\n    }\n  });\n}\n\n/**\n * Mixin `Emitter` and `RequestBase`.\n */\n\nEmitter(Request.prototype);\nRequestBase(Request.prototype);\n\n/**\n * Set Content-Type to `type`, mapping values from `request.types`.\n *\n * Examples:\n *\n *      superagent.types.xml = 'application/xml';\n *\n *      request.post('/')\n *        .type('xml')\n *        .send(xmlstring)\n *        .end(callback);\n *\n *      request.post('/')\n *        .type('application/xml')\n *        .send(xmlstring)\n *        .end(callback);\n *\n * @param {String} type\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.type = function(type){\n  this.set('Content-Type', request.types[type] || type);\n  return this;\n};\n\n/**\n * Set Accept to `type`, mapping values from `request.types`.\n *\n * Examples:\n *\n *      superagent.types.json = 'application/json';\n *\n *      request.get('/agent')\n *        .accept('json')\n *        .end(callback);\n *\n *      request.get('/agent')\n *        .accept('application/json')\n *        .end(callback);\n *\n * @param {String} accept\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.accept = function(type){\n  this.set('Accept', request.types[type] || type);\n  return this;\n};\n\n/**\n * Set Authorization field value with `user` and `pass`.\n *\n * @param {String} user\n * @param {String} [pass] optional in case of using 'bearer' as type\n * @param {Object} options with 'type' property 'auto', 'basic' or 'bearer' (default 'basic')\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.auth = function(user, pass, options){\n  if (typeof pass === 'object' && pass !== null) { // pass is optional and can substitute for options\n    options = pass;\n  }\n  if (!options) {\n    options = {\n      type: 'function' === typeof btoa ? 'basic' : 'auto',\n    }\n  }\n\n  switch (options.type) {\n    case 'basic':\n      this.set('Authorization', 'Basic ' + btoa(user + ':' + pass));\n    break;\n\n    case 'auto':\n      this.username = user;\n      this.password = pass;\n    break;\n      \n    case 'bearer': // usage would be .auth(accessToken, { type: 'bearer' })\n      this.set('Authorization', 'Bearer ' + user);\n    break;  \n  }\n  return this;\n};\n\n/**\n * Add query-string `val`.\n *\n * Examples:\n *\n *   request.get('/shoes')\n *     .query('size=10')\n *     .query({ color: 'blue' })\n *\n * @param {Object|String} val\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.query = function(val){\n  if ('string' != typeof val) val = serialize(val);\n  if (val) this._query.push(val);\n  return this;\n};\n\n/**\n * Queue the given `file` as an attachment to the specified `field`,\n * with optional `options` (or filename).\n *\n * ``` js\n * request.post('/upload')\n *   .attach('content', new Blob(['<a id=\"a\"><b id=\"b\">hey!</b></a>'], { type: \"text/html\"}))\n *   .end(callback);\n * ```\n *\n * @param {String} field\n * @param {Blob|File} file\n * @param {String|Object} options\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.attach = function(field, file, options){\n  if (file) {\n    if (this._data) {\n      throw Error(\"superagent can't mix .send() and .attach()\");\n    }\n\n    this._getFormData().append(field, file, options || file.name);\n  }\n  return this;\n};\n\nRequest.prototype._getFormData = function(){\n  if (!this._formData) {\n    this._formData = new root.FormData();\n  }\n  return this._formData;\n};\n\n/**\n * Invoke the callback with `err` and `res`\n * and handle arity check.\n *\n * @param {Error} err\n * @param {Response} res\n * @api private\n */\n\nRequest.prototype.callback = function(err, res){\n  // console.log(this._retries, this._maxRetries)\n  if (this._maxRetries && this._retries++ < this._maxRetries && shouldRetry(err, res)) {\n    return this._retry();\n  }\n\n  var fn = this._callback;\n  this.clearTimeout();\n\n  if (err) {\n    if (this._maxRetries) err.retries = this._retries - 1;\n    this.emit('error', err);\n  }\n\n  fn(err, res);\n};\n\n/**\n * Invoke callback with x-domain error.\n *\n * @api private\n */\n\nRequest.prototype.crossDomainError = function(){\n  var err = new Error('Request has been terminated\\nPossible causes: the network is offline, Origin is not allowed by Access-Control-Allow-Origin, the page is being unloaded, etc.');\n  err.crossDomain = true;\n\n  err.status = this.status;\n  err.method = this.method;\n  err.url = this.url;\n\n  this.callback(err);\n};\n\n// This only warns, because the request is still likely to work\nRequest.prototype.buffer = Request.prototype.ca = Request.prototype.agent = function(){\n  console.warn(\"This is not supported in browser version of superagent\");\n  return this;\n};\n\n// This throws, because it can't send/receive data as expected\nRequest.prototype.pipe = Request.prototype.write = function(){\n  throw Error(\"Streaming is not supported in browser version of superagent\");\n};\n\n/**\n * Compose querystring to append to req.url\n *\n * @api private\n */\n\nRequest.prototype._appendQueryString = function(){\n  var query = this._query.join('&');\n  if (query) {\n    this.url += (this.url.indexOf('?') >= 0 ? '&' : '?') + query;\n  }\n\n  if (this._sort) {\n    var index = this.url.indexOf('?');\n    if (index >= 0) {\n      var queryArr = this.url.substring(index + 1).split('&');\n      if (isFunction(this._sort)) {\n        queryArr.sort(this._sort);\n      } else {\n        queryArr.sort();\n      }\n      this.url = this.url.substring(0, index) + '?' + queryArr.join('&');\n    }\n  }\n};\n\n/**\n * Check if `obj` is a host object,\n * we don't want to serialize these :)\n *\n * @param {Object} obj\n * @return {Boolean}\n * @api private\n */\nRequest.prototype._isHost = function _isHost(obj) {\n  // Native objects stringify to [object File], [object Blob], [object FormData], etc.\n  return obj && 'object' === typeof obj && !Array.isArray(obj) && Object.prototype.toString.call(obj) !== '[object Object]';\n}\n\n/**\n * Initiate request, invoking callback `fn(res)`\n * with an instanceof `Response`.\n *\n * @param {Function} fn\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.end = function(fn){\n  if (this._endCalled) {\n    console.warn(\"Warning: .end() was called twice. This is not supported in superagent\");\n  }\n  this._endCalled = true;\n\n  // store callback\n  this._callback = fn || noop;\n\n  // querystring\n  this._appendQueryString();\n\n  return this._end();\n};\n\nRequest.prototype._end = function() {\n  var self = this;\n  var xhr = this.xhr = request.getXHR();\n  var data = this._formData || this._data;\n\n  this._setTimeouts();\n\n  // state change\n  xhr.onreadystatechange = function(){\n    var readyState = xhr.readyState;\n    if (readyState >= 2 && self._responseTimeoutTimer) {\n      clearTimeout(self._responseTimeoutTimer);\n    }\n    if (4 != readyState) {\n      return;\n    }\n\n    // In IE9, reads to any property (e.g. status) off of an aborted XHR will\n    // result in the error \"Could not complete the operation due to error c00c023f\"\n    var status;\n    try { status = xhr.status } catch(e) { status = 0; }\n\n    if (!status) {\n      if (self.timedout || self._aborted) return;\n      return self.crossDomainError();\n    }\n    self.emit('end');\n  };\n\n  // progress\n  var handleProgress = function(direction, e) {\n    if (e.total > 0) {\n      e.percent = e.loaded / e.total * 100;\n    }\n    e.direction = direction;\n    self.emit('progress', e);\n  }\n  if (this.hasListeners('progress')) {\n    try {\n      xhr.onprogress = handleProgress.bind(null, 'download');\n      if (xhr.upload) {\n        xhr.upload.onprogress = handleProgress.bind(null, 'upload');\n      }\n    } catch(e) {\n      // Accessing xhr.upload fails in IE from a web worker, so just pretend it doesn't exist.\n      // Reported here:\n      // https://connect.microsoft.com/IE/feedback/details/837245/xmlhttprequest-upload-throws-invalid-argument-when-used-from-web-worker-context\n    }\n  }\n\n  // initiate request\n  try {\n    if (this.username && this.password) {\n      xhr.open(this.method, this.url, true, this.username, this.password);\n    } else {\n      xhr.open(this.method, this.url, true);\n    }\n  } catch (err) {\n    // see #1149\n    return this.callback(err);\n  }\n\n  // CORS\n  if (this._withCredentials) xhr.withCredentials = true;\n\n  // body\n  if (!this._formData && 'GET' != this.method && 'HEAD' != this.method && 'string' != typeof data && !this._isHost(data)) {\n    // serialize stuff\n    var contentType = this._header['content-type'];\n    var serialize = this._serializer || request.serialize[contentType ? contentType.split(';')[0] : ''];\n    if (!serialize && isJSON(contentType)) {\n      serialize = request.serialize['application/json'];\n    }\n    if (serialize) data = serialize(data);\n  }\n\n  // set header fields\n  for (var field in this.header) {\n    if (null == this.header[field]) continue;\n\n    if (this.header.hasOwnProperty(field))\n      xhr.setRequestHeader(field, this.header[field]);\n  }\n\n  if (this._responseType) {\n    xhr.responseType = this._responseType;\n  }\n\n  // send stuff\n  this.emit('request', this);\n\n  // IE11 xhr.send(undefined) sends 'undefined' string as POST payload (instead of nothing)\n  // We need null here if data is undefined\n  xhr.send(typeof data !== 'undefined' ? data : null);\n  return this;\n};\n\n/**\n * GET `url` with optional callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.get = function(url, data, fn){\n  var req = request('GET', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.query(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n/**\n * HEAD `url` with optional callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.head = function(url, data, fn){\n  var req = request('HEAD', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n/**\n * OPTIONS query to `url` with optional callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.options = function(url, data, fn){\n  var req = request('OPTIONS', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n/**\n * DELETE `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed} [data]\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nfunction del(url, data, fn){\n  var req = request('DELETE', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\nrequest['del'] = del;\nrequest['delete'] = del;\n\n/**\n * PATCH `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed} [data]\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.patch = function(url, data, fn){\n  var req = request('PATCH', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n/**\n * POST `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed} [data]\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.post = function(url, data, fn){\n  var req = request('POST', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n/**\n * PUT `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.put = function(url, data, fn){\n  var req = request('PUT', url);\n  if ('function' == typeof data) fn = data, data = null;\n  if (data) req.send(data);\n  if (fn) req.end(fn);\n  return req;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/superagent/lib/client.js\n// module id = 143\n// module chunks = 1","module.exports = function (prefix) {\n    return function (request) {\n        if (request.url[0] === '/') {\n            request.url = prefix + request.url;\n        }\n\n        return request;\n    };\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/superagent-prefix/index.js\n// module id = 144\n// module chunks = 1","var methods = require('methods');\nvar extend = require('extend');\n\nmodule.exports = function(_superagent) {\n  var superagent = extend({}, _superagent);\n\n  var uses = [];\n\n  superagent.use = function(fn) {\n    uses.push(fn);\n    return this;\n  };\n\n  if(methods.indexOf('del') === -1) {\n    methods = methods.slice(0);\n    methods.push('del');\n  }\n  methods.forEach(function(method) {\n    superagent[method] = function() {\n      var request = _superagent[method].apply(superagent, arguments);\n      uses.forEach(function(use) {\n        request = request.use(use);\n      })\n      return request;\n    };\n  });\n\n  return superagent;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/superagent-use/index.js\n// module id = 145\n// module chunks = 1","/*!\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//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue/dist/vue.esm.js\n// module id = 146\n// module chunks = 1","(function(e,t){\"object\"==typeof exports&&\"object\"==typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define([],t):\"object\"==typeof exports?exports.VueTheMask=t():e.VueTheMask=t()})(this,function(){return function(e){function t(r){if(n[r])return n[r].exports;var a=n[r]={i:r,l:!1,exports:{}};return e[r].call(a.exports,a,a.exports,t),a.l=!0,a.exports}var n={};return t.m=e,t.c=n,t.i=function(e){return e},t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,\"a\",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p=\".\",t(t.s=10)}([function(e,t){e.exports={\"#\":{pattern:/\\d/},X:{pattern:/[0-9a-zA-Z]/},S:{pattern:/[a-zA-Z]/},A:{pattern:/[a-zA-Z]/,transform:function(e){return e.toLocaleUpperCase()}},a:{pattern:/[a-zA-Z]/,transform:function(e){return e.toLocaleLowerCase()}},\"!\":{escape:!0}}},function(e,t,n){\"use strict\";function r(e){var t=document.createEvent(\"Event\");return t.initEvent(e,!0,!0),t}var a=n(2),o=n(0),i=n.n(o);t.a=function(e,t){var o=t.value;if((Array.isArray(o)||\"string\"==typeof o)&&(o={mask:o,tokens:i.a}),\"INPUT\"!==e.tagName.toLocaleUpperCase()){var u=e.getElementsByTagName(\"input\");if(1!==u.length)throw new Error(\"v-mask directive requires 1 input, found \"+u.length);e=u[0]}e.oninput=function(t){if(t.isTrusted){var i=e.selectionEnd,u=e.value[i-1];for(e.value=n.i(a.a)(e.value,o.mask,!0,o.tokens);i<e.value.length&&e.value.charAt(i-1)!==u;)i++;e===document.activeElement&&e.setSelectionRange(i,i),e.dispatchEvent(r(\"input\"))}};var s=n.i(a.a)(e.value,o.mask,!0,o.tokens);s!==e.value&&(e.value=s,e.dispatchEvent(r(\"input\")))}},function(e,t,n){\"use strict\";var r=n(6),a=n(5);t.a=function(e,t){var o=!(arguments.length>2&&void 0!==arguments[2])||arguments[2],i=arguments[3];return Array.isArray(t)?n.i(a.a)(r.a,t,i)(e,t,o,i):n.i(r.a)(e,t,o,i)}},function(e,t,n){\"use strict\";function r(e){e.component(s.a.name,s.a),e.directive(\"mask\",i.a)}Object.defineProperty(t,\"__esModule\",{value:!0});var a=n(0),o=n.n(a),i=n(1),u=n(7),s=n.n(u);n.d(t,\"TheMask\",function(){return s.a}),n.d(t,\"mask\",function(){return i.a}),n.d(t,\"tokens\",function(){return o.a}),n.d(t,\"version\",function(){return c});var c=\"0.11.0-alpha.2\";t.default=r,\"undefined\"!=typeof window&&window.Vue&&window.Vue.use(r)},function(e,t,n){\"use strict\";Object.defineProperty(t,\"__esModule\",{value:!0});var r=n(1),a=n(0),o=n.n(a),i=n(2);t.default={name:\"TheMask\",props:{value:[String,Number],mask:{type:[String,Function,Array],required:!0},masked:{type:Boolean,default:!1},tokens:{type:Object,default:function(){return o.a}}},directives:{mask:r.a},data:function(){return{lastValue:null,display:this.value}},watch:{value:function(e){e!==this.lastValue&&(this.display=e)},masked:function(){this.refresh(this.display)}},computed:{config:function(){return{mask:this.mask,tokens:this.tokens,masked:this.masked}}},methods:{onInput:function(e){e.isTrusted||this.refresh(e.target.value)},refresh:function(e){this.display=e;var e=n.i(i.a)(e,this.mask,this.masked,this.tokens);e!==this.lastValue&&(this.lastValue=e,this.$emit(\"input\",e))}}}},function(e,t,n){\"use strict\";function r(e,t,n){return t=t.sort(function(e,t){return e.length-t.length}),function(r,a){for(var o=!(arguments.length>2&&void 0!==arguments[2])||arguments[2],i=0;i<t.length;){var u=t[i];i++;var s=t[i];if(!(s&&e(r,s,!0,n).length>u.length))return e(r,u,o,n)}return\"\"}}t.a=r},function(e,t,n){\"use strict\";function r(e,t){var n=!(arguments.length>2&&void 0!==arguments[2])||arguments[2],r=arguments[3];e=e||\"\",t=t||\"\";for(var a=0,o=0,i=\"\";a<t.length&&o<e.length;){var u=t[a],s=r[u],c=e[o];s&&!s.escape?(s.pattern.test(c)&&(i+=s.transform?s.transform(c):c,a++),o++):(s&&s.escape&&(a++,u=t[a]),n&&(i+=u),c===u&&o++,a++)}for(var f=\"\";a<t.length&&n;){var u=t[a];if(r[u]){f=\"\";break}f+=u,a++}return i+f}t.a=r},function(e,t,n){var r=n(8)(n(4),n(9),null,null);e.exports=r.exports},function(e,t){e.exports=function(e,t,n,r){var a,o=e=e||{},i=typeof e.default;\"object\"!==i&&\"function\"!==i||(a=e,o=e.default);var u=\"function\"==typeof o?o.options:o;if(t&&(u.render=t.render,u.staticRenderFns=t.staticRenderFns),n&&(u._scopeId=n),r){var s=u.computed||(u.computed={});Object.keys(r).forEach(function(e){var t=r[e];s[e]=function(){return t}})}return{esModule:a,exports:o,options:u}}},function(e,t){e.exports={render:function(){var e=this,t=e.$createElement;return(e._self._c||t)(\"input\",{directives:[{name:\"mask\",rawName:\"v-mask\",value:e.config,expression:\"config\"}],attrs:{type:\"text\"},domProps:{value:e.display},on:{input:e.onInput}})},staticRenderFns:[]}},function(e,t,n){e.exports=n(3)}])});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-the-mask/dist/vue-the-mask.js\n// module id = 147\n// module chunks = 1","/**\n * vuex v2.3.0\n * (c) 2017 Evan You\n * @license MIT\n */\nvar applyMixin = function (Vue) {\n  var version = Number(Vue.version.split('.')[0]);\n\n  if (version >= 2) {\n    var usesInit = Vue.config._lifecycleHooks.indexOf('init') > -1;\n    Vue.mixin(usesInit ? { init: vuexInit } : { beforeCreate: vuexInit });\n  } else {\n    // override init and inject vuex init procedure\n    // for 1.x backwards compatibility.\n    var _init = Vue.prototype._init;\n    Vue.prototype._init = function (options) {\n      if ( options === void 0 ) options = {};\n\n      options.init = options.init\n        ? [vuexInit].concat(options.init)\n        : vuexInit;\n      _init.call(this, options);\n    };\n  }\n\n  /**\n   * Vuex init hook, injected into each instances init hooks list.\n   */\n\n  function vuexInit () {\n    var options = this.$options;\n    // store injection\n    if (options.store) {\n      this.$store = options.store;\n    } else if (options.parent && options.parent.$store) {\n      this.$store = options.parent.$store;\n    }\n  }\n};\n\nvar devtoolHook =\n  typeof window !== 'undefined' &&\n  window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\nfunction devtoolPlugin (store) {\n  if (!devtoolHook) { return }\n\n  store._devtoolHook = devtoolHook;\n\n  devtoolHook.emit('vuex:init', store);\n\n  devtoolHook.on('vuex:travel-to-state', function (targetState) {\n    store.replaceState(targetState);\n  });\n\n  store.subscribe(function (mutation, state) {\n    devtoolHook.emit('vuex:mutation', mutation, state);\n  });\n}\n\n/**\n * Get the first item that pass the test\n * by second argument function\n *\n * @param {Array} list\n * @param {Function} f\n * @return {*}\n */\n/**\n * Deep copy the given object considering circular structure.\n * This function caches all nested objects and its copies.\n * If it detects circular structure, use cached copy to avoid infinite loop.\n *\n * @param {*} obj\n * @param {Array<Object>} cache\n * @return {*}\n */\n\n\n/**\n * forEach for object\n */\nfunction forEachValue (obj, fn) {\n  Object.keys(obj).forEach(function (key) { return fn(obj[key], key); });\n}\n\nfunction isObject (obj) {\n  return obj !== null && typeof obj === 'object'\n}\n\nfunction isPromise (val) {\n  return val && typeof val.then === 'function'\n}\n\nfunction assert (condition, msg) {\n  if (!condition) { throw new Error((\"[vuex] \" + msg)) }\n}\n\nvar Module = function Module (rawModule, runtime) {\n  this.runtime = runtime;\n  this._children = Object.create(null);\n  this._rawModule = rawModule;\n  var rawState = rawModule.state;\n  this.state = (typeof rawState === 'function' ? rawState() : rawState) || {};\n};\n\nvar prototypeAccessors$1 = { namespaced: {} };\n\nprototypeAccessors$1.namespaced.get = function () {\n  return !!this._rawModule.namespaced\n};\n\nModule.prototype.addChild = function addChild (key, module) {\n  this._children[key] = module;\n};\n\nModule.prototype.removeChild = function removeChild (key) {\n  delete this._children[key];\n};\n\nModule.prototype.getChild = function getChild (key) {\n  return this._children[key]\n};\n\nModule.prototype.update = function update (rawModule) {\n  this._rawModule.namespaced = rawModule.namespaced;\n  if (rawModule.actions) {\n    this._rawModule.actions = rawModule.actions;\n  }\n  if (rawModule.mutations) {\n    this._rawModule.mutations = rawModule.mutations;\n  }\n  if (rawModule.getters) {\n    this._rawModule.getters = rawModule.getters;\n  }\n};\n\nModule.prototype.forEachChild = function forEachChild (fn) {\n  forEachValue(this._children, fn);\n};\n\nModule.prototype.forEachGetter = function forEachGetter (fn) {\n  if (this._rawModule.getters) {\n    forEachValue(this._rawModule.getters, fn);\n  }\n};\n\nModule.prototype.forEachAction = function forEachAction (fn) {\n  if (this._rawModule.actions) {\n    forEachValue(this._rawModule.actions, fn);\n  }\n};\n\nModule.prototype.forEachMutation = function forEachMutation (fn) {\n  if (this._rawModule.mutations) {\n    forEachValue(this._rawModule.mutations, fn);\n  }\n};\n\nObject.defineProperties( Module.prototype, prototypeAccessors$1 );\n\nvar ModuleCollection = function ModuleCollection (rawRootModule) {\n  var this$1 = this;\n\n  // register root module (Vuex.Store options)\n  this.root = new Module(rawRootModule, false);\n\n  // register all nested modules\n  if (rawRootModule.modules) {\n    forEachValue(rawRootModule.modules, function (rawModule, key) {\n      this$1.register([key], rawModule, false);\n    });\n  }\n};\n\nModuleCollection.prototype.get = function get (path) {\n  return path.reduce(function (module, key) {\n    return module.getChild(key)\n  }, this.root)\n};\n\nModuleCollection.prototype.getNamespace = function getNamespace (path) {\n  var module = this.root;\n  return path.reduce(function (namespace, key) {\n    module = module.getChild(key);\n    return namespace + (module.namespaced ? key + '/' : '')\n  }, '')\n};\n\nModuleCollection.prototype.update = function update$1 (rawRootModule) {\n  update(this.root, rawRootModule);\n};\n\nModuleCollection.prototype.register = function register (path, rawModule, runtime) {\n    var this$1 = this;\n    if ( runtime === void 0 ) runtime = true;\n\n  var parent = this.get(path.slice(0, -1));\n  var newModule = new Module(rawModule, runtime);\n  parent.addChild(path[path.length - 1], newModule);\n\n  // register nested modules\n  if (rawModule.modules) {\n    forEachValue(rawModule.modules, function (rawChildModule, key) {\n      this$1.register(path.concat(key), rawChildModule, runtime);\n    });\n  }\n};\n\nModuleCollection.prototype.unregister = function unregister (path) {\n  var parent = this.get(path.slice(0, -1));\n  var key = path[path.length - 1];\n  if (!parent.getChild(key).runtime) { return }\n\n  parent.removeChild(key);\n};\n\nfunction update (targetModule, newModule) {\n  // update target module\n  targetModule.update(newModule);\n\n  // update nested modules\n  if (newModule.modules) {\n    for (var key in newModule.modules) {\n      if (!targetModule.getChild(key)) {\n        console.warn(\n          \"[vuex] trying to add a new module '\" + key + \"' on hot reloading, \" +\n          'manual reload is needed'\n        );\n        return\n      }\n      update(targetModule.getChild(key), newModule.modules[key]);\n    }\n  }\n}\n\nvar Vue; // bind on install\n\nvar Store = function Store (options) {\n  var this$1 = this;\n  if ( options === void 0 ) options = {};\n\n  assert(Vue, \"must call Vue.use(Vuex) before creating a store instance.\");\n  assert(typeof Promise !== 'undefined', \"vuex requires a Promise polyfill in this browser.\");\n\n  var state = options.state; if ( state === void 0 ) state = {};\n  var plugins = options.plugins; if ( plugins === void 0 ) plugins = [];\n  var strict = options.strict; if ( strict === void 0 ) strict = false;\n\n  // store internal state\n  this._committing = false;\n  this._actions = Object.create(null);\n  this._mutations = Object.create(null);\n  this._wrappedGetters = Object.create(null);\n  this._modules = new ModuleCollection(options);\n  this._modulesNamespaceMap = Object.create(null);\n  this._subscribers = [];\n  this._watcherVM = new Vue();\n\n  // bind commit and dispatch to self\n  var store = this;\n  var ref = this;\n  var dispatch = ref.dispatch;\n  var commit = ref.commit;\n  this.dispatch = function boundDispatch (type, payload) {\n    return dispatch.call(store, type, payload)\n  };\n  this.commit = function boundCommit (type, payload, options) {\n    return commit.call(store, type, payload, options)\n  };\n\n  // strict mode\n  this.strict = strict;\n\n  // init root module.\n  // this also recursively registers all sub-modules\n  // and collects all module getters inside this._wrappedGetters\n  installModule(this, state, [], this._modules.root);\n\n  // initialize the store vm, which is responsible for the reactivity\n  // (also registers _wrappedGetters as computed properties)\n  resetStoreVM(this, state);\n\n  // apply plugins\n  plugins.concat(devtoolPlugin).forEach(function (plugin) { return plugin(this$1); });\n};\n\nvar prototypeAccessors = { state: {} };\n\nprototypeAccessors.state.get = function () {\n  return this._vm._data.$$state\n};\n\nprototypeAccessors.state.set = function (v) {\n  assert(false, \"Use store.replaceState() to explicit replace store state.\");\n};\n\nStore.prototype.commit = function commit (_type, _payload, _options) {\n    var this$1 = this;\n\n  // check object-style commit\n  var ref = unifyObjectStyle(_type, _payload, _options);\n    var type = ref.type;\n    var payload = ref.payload;\n    var options = ref.options;\n\n  var mutation = { type: type, payload: payload };\n  var entry = this._mutations[type];\n  if (!entry) {\n    console.error((\"[vuex] unknown mutation type: \" + type));\n    return\n  }\n  this._withCommit(function () {\n    entry.forEach(function commitIterator (handler) {\n      handler(payload);\n    });\n  });\n  this._subscribers.forEach(function (sub) { return sub(mutation, this$1.state); });\n\n  if (options && options.silent) {\n    console.warn(\n      \"[vuex] mutation type: \" + type + \". Silent option has been removed. \" +\n      'Use the filter functionality in the vue-devtools'\n    );\n  }\n};\n\nStore.prototype.dispatch = function dispatch (_type, _payload) {\n  // check object-style dispatch\n  var ref = unifyObjectStyle(_type, _payload);\n    var type = ref.type;\n    var payload = ref.payload;\n\n  var entry = this._actions[type];\n  if (!entry) {\n    console.error((\"[vuex] unknown action type: \" + type));\n    return\n  }\n  return entry.length > 1\n    ? Promise.all(entry.map(function (handler) { return handler(payload); }))\n    : entry[0](payload)\n};\n\nStore.prototype.subscribe = function subscribe (fn) {\n  var subs = this._subscribers;\n  if (subs.indexOf(fn) < 0) {\n    subs.push(fn);\n  }\n  return function () {\n    var i = subs.indexOf(fn);\n    if (i > -1) {\n      subs.splice(i, 1);\n    }\n  }\n};\n\nStore.prototype.watch = function watch (getter, cb, options) {\n    var this$1 = this;\n\n  assert(typeof getter === 'function', \"store.watch only accepts a function.\");\n  return this._watcherVM.$watch(function () { return getter(this$1.state, this$1.getters); }, cb, options)\n};\n\nStore.prototype.replaceState = function replaceState (state) {\n    var this$1 = this;\n\n  this._withCommit(function () {\n    this$1._vm._data.$$state = state;\n  });\n};\n\nStore.prototype.registerModule = function registerModule (path, rawModule) {\n  if (typeof path === 'string') { path = [path]; }\n  assert(Array.isArray(path), \"module path must be a string or an Array.\");\n  this._modules.register(path, rawModule);\n  installModule(this, this.state, path, this._modules.get(path));\n  // reset store to update getters...\n  resetStoreVM(this, this.state);\n};\n\nStore.prototype.unregisterModule = function unregisterModule (path) {\n    var this$1 = this;\n\n  if (typeof path === 'string') { path = [path]; }\n  assert(Array.isArray(path), \"module path must be a string or an Array.\");\n  this._modules.unregister(path);\n  this._withCommit(function () {\n    var parentState = getNestedState(this$1.state, path.slice(0, -1));\n    Vue.delete(parentState, path[path.length - 1]);\n  });\n  resetStore(this);\n};\n\nStore.prototype.hotUpdate = function hotUpdate (newOptions) {\n  this._modules.update(newOptions);\n  resetStore(this, true);\n};\n\nStore.prototype._withCommit = function _withCommit (fn) {\n  var committing = this._committing;\n  this._committing = true;\n  fn();\n  this._committing = committing;\n};\n\nObject.defineProperties( Store.prototype, prototypeAccessors );\n\nfunction resetStore (store, hot) {\n  store._actions = Object.create(null);\n  store._mutations = Object.create(null);\n  store._wrappedGetters = Object.create(null);\n  store._modulesNamespaceMap = Object.create(null);\n  var state = store.state;\n  // init all modules\n  installModule(store, state, [], store._modules.root, true);\n  // reset vm\n  resetStoreVM(store, state, hot);\n}\n\nfunction resetStoreVM (store, state, hot) {\n  var oldVm = store._vm;\n\n  // bind store public getters\n  store.getters = {};\n  var wrappedGetters = store._wrappedGetters;\n  var computed = {};\n  forEachValue(wrappedGetters, function (fn, key) {\n    // use computed to leverage its lazy-caching mechanism\n    computed[key] = function () { return fn(store); };\n    Object.defineProperty(store.getters, key, {\n      get: function () { return store._vm[key]; },\n      enumerable: true // for local getters\n    });\n  });\n\n  // use a Vue instance to store the state tree\n  // suppress warnings just in case the user has added\n  // some funky global mixins\n  var silent = Vue.config.silent;\n  Vue.config.silent = true;\n  store._vm = new Vue({\n    data: {\n      $$state: state\n    },\n    computed: computed\n  });\n  Vue.config.silent = silent;\n\n  // enable strict mode for new vm\n  if (store.strict) {\n    enableStrictMode(store);\n  }\n\n  if (oldVm) {\n    if (hot) {\n      // dispatch changes in all subscribed watchers\n      // to force getter re-evaluation for hot reloading.\n      store._withCommit(function () {\n        oldVm._data.$$state = null;\n      });\n    }\n    Vue.nextTick(function () { return oldVm.$destroy(); });\n  }\n}\n\nfunction installModule (store, rootState, path, module, hot) {\n  var isRoot = !path.length;\n  var namespace = store._modules.getNamespace(path);\n\n  // register in namespace map\n  if (module.namespaced) {\n    store._modulesNamespaceMap[namespace] = module;\n  }\n\n  // set state\n  if (!isRoot && !hot) {\n    var parentState = getNestedState(rootState, path.slice(0, -1));\n    var moduleName = path[path.length - 1];\n    store._withCommit(function () {\n      Vue.set(parentState, moduleName, module.state);\n    });\n  }\n\n  var local = module.context = makeLocalContext(store, namespace, path);\n\n  module.forEachMutation(function (mutation, key) {\n    var namespacedType = namespace + key;\n    registerMutation(store, namespacedType, mutation, local);\n  });\n\n  module.forEachAction(function (action, key) {\n    var namespacedType = namespace + key;\n    registerAction(store, namespacedType, action, local);\n  });\n\n  module.forEachGetter(function (getter, key) {\n    var namespacedType = namespace + key;\n    registerGetter(store, namespacedType, getter, local);\n  });\n\n  module.forEachChild(function (child, key) {\n    installModule(store, rootState, path.concat(key), child, hot);\n  });\n}\n\n/**\n * make localized dispatch, commit, getters and state\n * if there is no namespace, just use root ones\n */\nfunction makeLocalContext (store, namespace, path) {\n  var noNamespace = namespace === '';\n\n  var local = {\n    dispatch: noNamespace ? store.dispatch : function (_type, _payload, _options) {\n      var args = unifyObjectStyle(_type, _payload, _options);\n      var payload = args.payload;\n      var options = args.options;\n      var type = args.type;\n\n      if (!options || !options.root) {\n        type = namespace + type;\n        if (!store._actions[type]) {\n          console.error((\"[vuex] unknown local action type: \" + (args.type) + \", global type: \" + type));\n          return\n        }\n      }\n\n      return store.dispatch(type, payload)\n    },\n\n    commit: noNamespace ? store.commit : function (_type, _payload, _options) {\n      var args = unifyObjectStyle(_type, _payload, _options);\n      var payload = args.payload;\n      var options = args.options;\n      var type = args.type;\n\n      if (!options || !options.root) {\n        type = namespace + type;\n        if (!store._mutations[type]) {\n          console.error((\"[vuex] unknown local mutation type: \" + (args.type) + \", global type: \" + type));\n          return\n        }\n      }\n\n      store.commit(type, payload, options);\n    }\n  };\n\n  // getters and state object must be gotten lazily\n  // because they will be changed by vm update\n  Object.defineProperties(local, {\n    getters: {\n      get: noNamespace\n        ? function () { return store.getters; }\n        : function () { return makeLocalGetters(store, namespace); }\n    },\n    state: {\n      get: function () { return getNestedState(store.state, path); }\n    }\n  });\n\n  return local\n}\n\nfunction makeLocalGetters (store, namespace) {\n  var gettersProxy = {};\n\n  var splitPos = namespace.length;\n  Object.keys(store.getters).forEach(function (type) {\n    // skip if the target getter is not match this namespace\n    if (type.slice(0, splitPos) !== namespace) { return }\n\n    // extract local getter type\n    var localType = type.slice(splitPos);\n\n    // Add a port to the getters proxy.\n    // Define as getter property because\n    // we do not want to evaluate the getters in this time.\n    Object.defineProperty(gettersProxy, localType, {\n      get: function () { return store.getters[type]; },\n      enumerable: true\n    });\n  });\n\n  return gettersProxy\n}\n\nfunction registerMutation (store, type, handler, local) {\n  var entry = store._mutations[type] || (store._mutations[type] = []);\n  entry.push(function wrappedMutationHandler (payload) {\n    handler(local.state, payload);\n  });\n}\n\nfunction registerAction (store, type, handler, local) {\n  var entry = store._actions[type] || (store._actions[type] = []);\n  entry.push(function wrappedActionHandler (payload, cb) {\n    var res = handler({\n      dispatch: local.dispatch,\n      commit: local.commit,\n      getters: local.getters,\n      state: local.state,\n      rootGetters: store.getters,\n      rootState: store.state\n    }, payload, cb);\n    if (!isPromise(res)) {\n      res = Promise.resolve(res);\n    }\n    if (store._devtoolHook) {\n      return res.catch(function (err) {\n        store._devtoolHook.emit('vuex:error', err);\n        throw err\n      })\n    } else {\n      return res\n    }\n  });\n}\n\nfunction registerGetter (store, type, rawGetter, local) {\n  if (store._wrappedGetters[type]) {\n    console.error((\"[vuex] duplicate getter key: \" + type));\n    return\n  }\n  store._wrappedGetters[type] = function wrappedGetter (store) {\n    return rawGetter(\n      local.state, // local state\n      local.getters, // local getters\n      store.state, // root state\n      store.getters // root getters\n    )\n  };\n}\n\nfunction enableStrictMode (store) {\n  store._vm.$watch(function () { return this._data.$$state }, function () {\n    assert(store._committing, \"Do not mutate vuex store state outside mutation handlers.\");\n  }, { deep: true, sync: true });\n}\n\nfunction getNestedState (state, path) {\n  return path.length\n    ? path.reduce(function (state, key) { return state[key]; }, state)\n    : state\n}\n\nfunction unifyObjectStyle (type, payload, options) {\n  if (isObject(type) && type.type) {\n    options = payload;\n    payload = type;\n    type = type.type;\n  }\n\n  assert(typeof type === 'string', (\"Expects string as the type, but found \" + (typeof type) + \".\"));\n\n  return { type: type, payload: payload, options: options }\n}\n\nfunction install (_Vue) {\n  if (Vue) {\n    console.error(\n      '[vuex] already installed. Vue.use(Vuex) should be called only once.'\n    );\n    return\n  }\n  Vue = _Vue;\n  applyMixin(Vue);\n}\n\n// auto install in dist mode\nif (typeof window !== 'undefined' && window.Vue) {\n  install(window.Vue);\n}\n\nvar mapState = normalizeNamespace(function (namespace, states) {\n  var res = {};\n  normalizeMap(states).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    res[key] = function mappedState () {\n      var state = this.$store.state;\n      var getters = this.$store.getters;\n      if (namespace) {\n        var module = getModuleByNamespace(this.$store, 'mapState', namespace);\n        if (!module) {\n          return\n        }\n        state = module.context.state;\n        getters = module.context.getters;\n      }\n      return typeof val === 'function'\n        ? val.call(this, state, getters)\n        : state[val]\n    };\n    // mark vuex getter for devtools\n    res[key].vuex = true;\n  });\n  return res\n});\n\nvar mapMutations = normalizeNamespace(function (namespace, mutations) {\n  var res = {};\n  normalizeMap(mutations).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    val = namespace + val;\n    res[key] = function mappedMutation () {\n      var args = [], len = arguments.length;\n      while ( len-- ) args[ len ] = arguments[ len ];\n\n      if (namespace && !getModuleByNamespace(this.$store, 'mapMutations', namespace)) {\n        return\n      }\n      return this.$store.commit.apply(this.$store, [val].concat(args))\n    };\n  });\n  return res\n});\n\nvar mapGetters = normalizeNamespace(function (namespace, getters) {\n  var res = {};\n  normalizeMap(getters).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    val = namespace + val;\n    res[key] = function mappedGetter () {\n      if (namespace && !getModuleByNamespace(this.$store, 'mapGetters', namespace)) {\n        return\n      }\n      if (!(val in this.$store.getters)) {\n        console.error((\"[vuex] unknown getter: \" + val));\n        return\n      }\n      return this.$store.getters[val]\n    };\n    // mark vuex getter for devtools\n    res[key].vuex = true;\n  });\n  return res\n});\n\nvar mapActions = normalizeNamespace(function (namespace, actions) {\n  var res = {};\n  normalizeMap(actions).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    val = namespace + val;\n    res[key] = function mappedAction () {\n      var args = [], len = arguments.length;\n      while ( len-- ) args[ len ] = arguments[ len ];\n\n      if (namespace && !getModuleByNamespace(this.$store, 'mapActions', namespace)) {\n        return\n      }\n      return this.$store.dispatch.apply(this.$store, [val].concat(args))\n    };\n  });\n  return res\n});\n\nfunction normalizeMap (map) {\n  return Array.isArray(map)\n    ? map.map(function (key) { return ({ key: key, val: key }); })\n    : Object.keys(map).map(function (key) { return ({ key: key, val: map[key] }); })\n}\n\nfunction normalizeNamespace (fn) {\n  return function (namespace, map) {\n    if (typeof namespace !== 'string') {\n      map = namespace;\n      namespace = '';\n    } else if (namespace.charAt(namespace.length - 1) !== '/') {\n      namespace += '/';\n    }\n    return fn(namespace, map)\n  }\n}\n\nfunction getModuleByNamespace (store, helper, namespace) {\n  var module = store._modulesNamespaceMap[namespace];\n  if (!module) {\n    console.error((\"[vuex] module namespace not found in \" + helper + \"(): \" + namespace));\n  }\n  return module\n}\n\nvar index_esm = {\n  Store: Store,\n  install: install,\n  version: '2.3.0',\n  mapState: mapState,\n  mapMutations: mapMutations,\n  mapGetters: mapGetters,\n  mapActions: mapActions\n};\n\nexport { Store, mapState, mapMutations, mapGetters, mapActions };export default index_esm;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vuex/dist/vuex.esm.js\n// module id = 2\n// module chunks = 1","import './styles.scss';\nimport './styles/favicon.ico';\n\n\n// WEBPACK FOOTER //\n// ./src/styles.js","/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\n// css base code, injected by the css-loader\nmodule.exports = function(useSourceMap) {\n\tvar list = [];\n\n\t// return the list of modules as css string\n\tlist.toString = function toString() {\n\t\treturn this.map(function (item) {\n\t\t\tvar content = cssWithMappingToString(item, useSourceMap);\n\t\t\tif(item[2]) {\n\t\t\t\treturn \"@media \" + item[2] + \"{\" + content + \"}\";\n\t\t\t} else {\n\t\t\t\treturn content;\n\t\t\t}\n\t\t}).join(\"\");\n\t};\n\n\t// import a list of modules into the list\n\tlist.i = function(modules, mediaQuery) {\n\t\tif(typeof modules === \"string\")\n\t\t\tmodules = [[null, modules, \"\"]];\n\t\tvar alreadyImportedModules = {};\n\t\tfor(var i = 0; i < this.length; i++) {\n\t\t\tvar id = this[i][0];\n\t\t\tif(typeof id === \"number\")\n\t\t\t\talreadyImportedModules[id] = true;\n\t\t}\n\t\tfor(i = 0; i < modules.length; i++) {\n\t\t\tvar item = modules[i];\n\t\t\t// skip already imported module\n\t\t\t// this implementation is not 100% perfect for weird media query combinations\n\t\t\t//  when a module is imported multiple times with different media queries.\n\t\t\t//  I hope this will never occur (Hey this way we have smaller bundles)\n\t\t\tif(typeof item[0] !== \"number\" || !alreadyImportedModules[item[0]]) {\n\t\t\t\tif(mediaQuery && !item[2]) {\n\t\t\t\t\titem[2] = mediaQuery;\n\t\t\t\t} else if(mediaQuery) {\n\t\t\t\t\titem[2] = \"(\" + item[2] + \") and (\" + mediaQuery + \")\";\n\t\t\t\t}\n\t\t\t\tlist.push(item);\n\t\t\t}\n\t\t}\n\t};\n\treturn list;\n};\n\nfunction cssWithMappingToString(item, useSourceMap) {\n\tvar content = item[1] || '';\n\tvar cssMapping = item[3];\n\tif (!cssMapping) {\n\t\treturn content;\n\t}\n\n\tif (useSourceMap && typeof btoa === 'function') {\n\t\tvar sourceMapping = toComment(cssMapping);\n\t\tvar sourceURLs = cssMapping.sources.map(function (source) {\n\t\t\treturn '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'\n\t\t});\n\n\t\treturn [content].concat(sourceURLs).concat([sourceMapping]).join('\\n');\n\t}\n\n\treturn [content].join('\\n');\n}\n\n// Adapted from convert-source-map (MIT)\nfunction toComment(sourceMap) {\n\t// eslint-disable-next-line no-undef\n\tvar base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));\n\tvar data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;\n\n\treturn '/*# ' + data + ' */';\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/css-loader/lib/css-base.js\n// module id = 232\n// module chunks = 1","\n/**\n * When source maps are enabled, `style-loader` uses a link element with a data-uri to\n * embed the css on the page. This breaks all relative urls because now they are relative to a\n * bundle instead of the current page.\n *\n * One solution is to only use full urls, but that may be impossible.\n *\n * Instead, this function \"fixes\" the relative urls to be absolute according to the current page location.\n *\n * A rudimentary test suite is located at `test/fixUrls.js` and can be run via the `npm test` command.\n *\n */\n\nmodule.exports = function (css) {\n  // get current location\n  var location = typeof window !== \"undefined\" && window.location;\n\n  if (!location) {\n    throw new Error(\"fixUrls requires window.location\");\n  }\n\n\t// blank or null?\n\tif (!css || typeof css !== \"string\") {\n\t  return css;\n  }\n\n  var baseUrl = location.protocol + \"//\" + location.host;\n  var currentDir = baseUrl + location.pathname.replace(/\\/[^\\/]*$/, \"/\");\n\n\t// convert each url(...)\n\t/*\n\tThis regular expression is just a way to recursively match brackets within\n\ta string.\n\n\t /url\\s*\\(  = Match on the word \"url\" with any whitespace after it and then a parens\n\t   (  = Start a capturing group\n\t     (?:  = Start a non-capturing group\n\t         [^)(]  = Match anything that isn't a parentheses\n\t         |  = OR\n\t         \\(  = Match a start parentheses\n\t             (?:  = Start another non-capturing groups\n\t                 [^)(]+  = Match anything that isn't a parentheses\n\t                 |  = OR\n\t                 \\(  = Match a start parentheses\n\t                     [^)(]*  = Match anything that isn't a parentheses\n\t                 \\)  = Match a end parentheses\n\t             )  = End Group\n              *\\) = Match anything and then a close parens\n          )  = Close non-capturing group\n          *  = Match anything\n       )  = Close capturing group\n\t \\)  = Match a close parens\n\n\t /gi  = Get all matches, not the first.  Be case insensitive.\n\t */\n\tvar fixedCss = css.replace(/url\\s*\\(((?:[^)(]|\\((?:[^)(]+|\\([^)(]*\\))*\\))*)\\)/gi, function(fullMatch, origUrl) {\n\t\t// strip quotes (if they exist)\n\t\tvar unquotedOrigUrl = origUrl\n\t\t\t.trim()\n\t\t\t.replace(/^\"(.*)\"$/, function(o, $1){ return $1; })\n\t\t\t.replace(/^'(.*)'$/, function(o, $1){ return $1; });\n\n\t\t// already a full url? no change\n\t\tif (/^(#|data:|http:\\/\\/|https:\\/\\/|file:\\/\\/\\/)/i.test(unquotedOrigUrl)) {\n\t\t  return fullMatch;\n\t\t}\n\n\t\t// convert the url to a full url\n\t\tvar newUrl;\n\n\t\tif (unquotedOrigUrl.indexOf(\"//\") === 0) {\n\t\t  \t//TODO: should we add protocol?\n\t\t\tnewUrl = unquotedOrigUrl;\n\t\t} else if (unquotedOrigUrl.indexOf(\"/\") === 0) {\n\t\t\t// path should be relative to the base url\n\t\t\tnewUrl = baseUrl + unquotedOrigUrl; // already starts with '/'\n\t\t} else {\n\t\t\t// path should be relative to current directory\n\t\t\tnewUrl = currentDir + unquotedOrigUrl.replace(/^\\.\\//, \"\"); // Strip leading './'\n\t\t}\n\n\t\t// send back the fixed url(...)\n\t\treturn \"url(\" + JSON.stringify(newUrl) + \")\";\n\t});\n\n\t// send back the fixed css\n\treturn fixedCss;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/style-loader/lib/urls.js\n// module id = 233\n// module chunks = 1","module.exports = __webpack_public_path__ + \"src/styles/favicon.ico\";\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/styles/favicon.ico\n// module id = 234\n// module chunks = 1","/*global XDomainRequest:false, __DEV__:false*/\n'use strict';\n\nvar TraceKit = require('../vendor/TraceKit/tracekit');\nvar stringify = require('../vendor/json-stringify-safe/stringify');\nvar RavenConfigError = require('./configError');\nvar utils = require('./utils');\n\nvar isError = utils.isError,\n    isObject = utils.isObject;\n\nvar wrapConsoleMethod = require('./console').wrapMethod;\n\nvar dsnKeys = 'source protocol user pass host port path'.split(' '),\n    dsnPattern = /^(?:(\\w+):)?\\/\\/(?:(\\w+)(:\\w+)?@)?([\\w\\.-]+)(?::(\\d+))?(\\/.*)/;\n\nfunction now() {\n    return +new Date();\n}\n\n// This is to be defensive in environments where window does not exist (see https://github.com/getsentry/raven-js/pull/785)\nvar _window = typeof window !== 'undefined' ? window\n            : typeof global !== 'undefined' ? global\n            : typeof self !== 'undefined' ? self\n            : {};\nvar _document = _window.document;\nvar _navigator = _window.navigator;\n\n\nfunction keepOriginalCallback(original, callback) {\n    return isFunction(callback) ?\n    function (data) { return callback(data, original) } :\n    callback;\n}\n\n// First, check for JSON support\n// If there is no JSON, we no-op the core features of Raven\n// since JSON is required to encode the payload\nfunction Raven() {\n    this._hasJSON = !!(typeof JSON === 'object' && JSON.stringify);\n    // Raven can run in contexts where there's no document (react-native)\n    this._hasDocument = !isUndefined(_document);\n    this._hasNavigator = !isUndefined(_navigator);\n    this._lastCapturedException = null;\n    this._lastData = null;\n    this._lastEventId = null;\n    this._globalServer = null;\n    this._globalKey = null;\n    this._globalProject = null;\n    this._globalContext = {};\n    this._globalOptions = {\n        logger: 'javascript',\n        ignoreErrors: [],\n        ignoreUrls: [],\n        whitelistUrls: [],\n        includePaths: [],\n        crossOrigin: 'anonymous',\n        collectWindowErrors: true,\n        maxMessageLength: 0,\n\n        // By default, truncates URL values to 250 chars\n        maxUrlLength: 250,\n        stackTraceLimit: 50,\n        autoBreadcrumbs: true,\n        instrument: true,\n        sampleRate: 1\n    };\n    this._ignoreOnError = 0;\n    this._isRavenInstalled = false;\n    this._originalErrorStackTraceLimit = Error.stackTraceLimit;\n    // capture references to window.console *and* all its methods first\n    // before the console plugin has a chance to monkey patch\n    this._originalConsole = _window.console || {};\n    this._originalConsoleMethods = {};\n    this._plugins = [];\n    this._startTime = now();\n    this._wrappedBuiltIns = [];\n    this._breadcrumbs = [];\n    this._lastCapturedEvent = null;\n    this._keypressTimeout;\n    this._location = _window.location;\n    this._lastHref = this._location && this._location.href;\n    this._resetBackoff();\n\n    for (var method in this._originalConsole) {  // eslint-disable-line guard-for-in\n      this._originalConsoleMethods[method] = this._originalConsole[method];\n    }\n}\n\n/*\n * The core Raven singleton\n *\n * @this {Raven}\n */\n\nRaven.prototype = {\n    // Hardcode version string so that raven source can be loaded directly via\n    // webpack (using a build step causes webpack #1617). Grunt verifies that\n    // this value matches package.json during build.\n    //   See: https://github.com/getsentry/raven-js/issues/465\n    VERSION: '3.17.0',\n\n    debug: false,\n\n    TraceKit: TraceKit, // alias to TraceKit\n\n    /*\n     * Configure Raven with a DSN and extra options\n     *\n     * @param {string} dsn The public Sentry DSN\n     * @param {object} options Optional set of of global options [optional]\n     * @return {Raven}\n     */\n    config: function(dsn, options) {\n        var self = this;\n\n        if (self._globalServer) {\n                this._logDebug('error', 'Error: Raven has already been configured');\n            return self;\n        }\n        if (!dsn) return self;\n\n        var globalOptions = self._globalOptions;\n\n        // merge in options\n        if (options) {\n            each(options, function(key, value){\n                // tags and extra are special and need to be put into context\n                if (key === 'tags' || key === 'extra' || key === 'user') {\n                    self._globalContext[key] = value;\n                } else {\n                    globalOptions[key] = value;\n                }\n            });\n        }\n\n        self.setDSN(dsn);\n\n        // \"Script error.\" is hard coded into browsers for errors that it can't read.\n        // this is the result of a script being pulled in from an external domain and CORS.\n        globalOptions.ignoreErrors.push(/^Script error\\.?$/);\n        globalOptions.ignoreErrors.push(/^Javascript error: Script error\\.? on line 0$/);\n\n        // join regexp rules into one big rule\n        globalOptions.ignoreErrors = joinRegExp(globalOptions.ignoreErrors);\n        globalOptions.ignoreUrls = globalOptions.ignoreUrls.length ? joinRegExp(globalOptions.ignoreUrls) : false;\n        globalOptions.whitelistUrls = globalOptions.whitelistUrls.length ? joinRegExp(globalOptions.whitelistUrls) : false;\n        globalOptions.includePaths = joinRegExp(globalOptions.includePaths);\n        globalOptions.maxBreadcrumbs = Math.max(0, Math.min(globalOptions.maxBreadcrumbs || 100, 100)); // default and hard limit is 100\n\n        var autoBreadcrumbDefaults = {\n            xhr: true,\n            console: true,\n            dom: true,\n            location: true\n        };\n\n        var autoBreadcrumbs = globalOptions.autoBreadcrumbs;\n        if ({}.toString.call(autoBreadcrumbs) === '[object Object]') {\n            autoBreadcrumbs = objectMerge(autoBreadcrumbDefaults, autoBreadcrumbs);\n        } else if (autoBreadcrumbs !== false) {\n            autoBreadcrumbs = autoBreadcrumbDefaults;\n        }\n        globalOptions.autoBreadcrumbs = autoBreadcrumbs;\n\n        var instrumentDefaults = {\n            tryCatch: true\n        };\n\n        var instrument = globalOptions.instrument;\n        if ({}.toString.call(instrument) === '[object Object]') {\n            instrument = objectMerge(instrumentDefaults, instrument);\n        } else if (instrument !== false) {\n            instrument = instrumentDefaults;\n        }\n        globalOptions.instrument = instrument;\n\n        TraceKit.collectWindowErrors = !!globalOptions.collectWindowErrors;\n\n        // return for chaining\n        return self;\n    },\n\n    /*\n     * Installs a global window.onerror error handler\n     * to capture and report uncaught exceptions.\n     * At this point, install() is required to be called due\n     * to the way TraceKit is set up.\n     *\n     * @return {Raven}\n     */\n    install: function() {\n        var self = this;\n        if (self.isSetup() && !self._isRavenInstalled) {\n            TraceKit.report.subscribe(function () {\n                self._handleOnErrorStackInfo.apply(self, arguments);\n            });\n            if (self._globalOptions.instrument && self._globalOptions.instrument.tryCatch) {\n              self._instrumentTryCatch();\n            }\n\n            if (self._globalOptions.autoBreadcrumbs)\n                self._instrumentBreadcrumbs();\n\n            // Install all of the plugins\n            self._drainPlugins();\n\n            self._isRavenInstalled = true;\n        }\n\n        Error.stackTraceLimit = self._globalOptions.stackTraceLimit;\n        return this;\n    },\n\n    /*\n     * Set the DSN (can be called multiple time unlike config)\n     *\n     * @param {string} dsn The public Sentry DSN\n     */\n    setDSN: function(dsn) {\n        var self = this,\n            uri = self._parseDSN(dsn),\n          lastSlash = uri.path.lastIndexOf('/'),\n          path = uri.path.substr(1, lastSlash);\n\n        self._dsn = dsn;\n        self._globalKey = uri.user;\n        self._globalSecret = uri.pass && uri.pass.substr(1);\n        self._globalProject = uri.path.substr(lastSlash + 1);\n\n        self._globalServer = self._getGlobalServer(uri);\n\n        self._globalEndpoint = self._globalServer +\n            '/' + path + 'api/' + self._globalProject + '/store/';\n\n        // Reset backoff state since we may be pointing at a\n        // new project/server\n        this._resetBackoff();\n    },\n\n    /*\n     * Wrap code within a context so Raven can capture errors\n     * reliably across domains that is executed immediately.\n     *\n     * @param {object} options A specific set of options for this context [optional]\n     * @param {function} func The callback to be immediately executed within the context\n     * @param {array} args An array of arguments to be called with the callback [optional]\n     */\n    context: function(options, func, args) {\n        if (isFunction(options)) {\n            args = func || [];\n            func = options;\n            options = undefined;\n        }\n\n        return this.wrap(options, func).apply(this, args);\n    },\n\n    /*\n     * Wrap code within a context and returns back a new function to be executed\n     *\n     * @param {object} options A specific set of options for this context [optional]\n     * @param {function} func The function to be wrapped in a new context\n     * @param {function} func A function to call before the try/catch wrapper [optional, private]\n     * @return {function} The newly wrapped functions with a context\n     */\n    wrap: function(options, func, _before) {\n        var self = this;\n        // 1 argument has been passed, and it's not a function\n        // so just return it\n        if (isUndefined(func) && !isFunction(options)) {\n            return options;\n        }\n\n        // options is optional\n        if (isFunction(options)) {\n            func = options;\n            options = undefined;\n        }\n\n        // At this point, we've passed along 2 arguments, and the second one\n        // is not a function either, so we'll just return the second argument.\n        if (!isFunction(func)) {\n            return func;\n        }\n\n        // We don't wanna wrap it twice!\n        try {\n            if (func.__raven__) {\n                return func;\n            }\n\n            // If this has already been wrapped in the past, return that\n            if (func.__raven_wrapper__ ){\n                return func.__raven_wrapper__ ;\n            }\n        } catch (e) {\n            // Just accessing custom props in some Selenium environments\n            // can cause a \"Permission denied\" exception (see raven-js#495).\n            // Bail on wrapping and return the function as-is (defers to window.onerror).\n            return func;\n        }\n\n        function wrapped() {\n            var args = [], i = arguments.length,\n                deep = !options || options && options.deep !== false;\n\n            if (_before && isFunction(_before)) {\n                _before.apply(this, arguments);\n            }\n\n            // Recursively wrap all of a function's arguments that are\n            // functions themselves.\n            while(i--) args[i] = deep ? self.wrap(options, arguments[i]) : arguments[i];\n\n            try {\n                // Attempt to invoke user-land function\n                // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n                //       means Raven caught an error invoking your application code. This is\n                //       expected behavior and NOT indicative of a bug with Raven.js.\n                return func.apply(this, args);\n            } catch(e) {\n                self._ignoreNextOnError();\n                self.captureException(e, options);\n                throw e;\n            }\n        }\n\n        // copy over properties of the old function\n        for (var property in func) {\n            if (hasKey(func, property)) {\n                wrapped[property] = func[property];\n            }\n        }\n        wrapped.prototype = func.prototype;\n\n        func.__raven_wrapper__ = wrapped;\n        // Signal that this function has been wrapped already\n        // for both debugging and to prevent it to being wrapped twice\n        wrapped.__raven__ = true;\n        wrapped.__inner__ = func;\n\n        return wrapped;\n    },\n\n    /*\n     * Uninstalls the global error handler.\n     *\n     * @return {Raven}\n     */\n    uninstall: function() {\n        TraceKit.report.uninstall();\n\n        this._restoreBuiltIns();\n\n        Error.stackTraceLimit = this._originalErrorStackTraceLimit;\n        this._isRavenInstalled = false;\n\n        return this;\n    },\n\n    /*\n     * Manually capture an exception and send it over to Sentry\n     *\n     * @param {error} ex An exception to be logged\n     * @param {object} options A specific set of options for this error [optional]\n     * @return {Raven}\n     */\n    captureException: function(ex, options) {\n        // If not an Error is passed through, recall as a message instead\n        if (!isError(ex)) {\n            return this.captureMessage(ex, objectMerge({\n                trimHeadFrames: 1,\n                stacktrace: true // if we fall back to captureMessage, default to attempting a new trace\n            }, options));\n        }\n\n        // Store the raw exception object for potential debugging and introspection\n        this._lastCapturedException = ex;\n\n        // TraceKit.report will re-raise any exception passed to it,\n        // which means you have to wrap it in try/catch. Instead, we\n        // can wrap it here and only re-raise if TraceKit.report\n        // raises an exception different from the one we asked to\n        // report on.\n        try {\n            var stack = TraceKit.computeStackTrace(ex);\n            this._handleStackInfo(stack, options);\n        } catch(ex1) {\n            if(ex !== ex1) {\n                throw ex1;\n            }\n        }\n\n        return this;\n    },\n\n    /*\n     * Manually send a message to Sentry\n     *\n     * @param {string} msg A plain message to be captured in Sentry\n     * @param {object} options A specific set of options for this message [optional]\n     * @return {Raven}\n     */\n    captureMessage: function(msg, options) {\n        // config() automagically converts ignoreErrors from a list to a RegExp so we need to test for an\n        // early call; we'll error on the side of logging anything called before configuration since it's\n        // probably something you should see:\n        if (!!this._globalOptions.ignoreErrors.test && this._globalOptions.ignoreErrors.test(msg)) {\n            return;\n        }\n\n        options = options || {};\n\n        var data = objectMerge({\n            message: msg + ''  // Make sure it's actually a string\n        }, options);\n\n        if (this._globalOptions.stacktrace || (options && options.stacktrace)) {\n            var ex;\n            // Generate a \"synthetic\" stack trace from this point.\n            // NOTE: If you are a Sentry user, and you are seeing this stack frame, it is NOT indicative\n            //       of a bug with Raven.js. Sentry generates synthetic traces either by configuration,\n            //       or if it catches a thrown object without a \"stack\" property.\n            try {\n                throw new Error(msg);\n            } catch (ex1) {\n                ex = ex1;\n            }\n\n            // null exception name so `Error` isn't prefixed to msg\n            ex.name = null;\n\n            options = objectMerge({\n                // fingerprint on msg, not stack trace (legacy behavior, could be\n                // revisited)\n                fingerprint: msg,\n                // since we know this is a synthetic trace, the top N-most frames\n                // MUST be from Raven.js, so mark them as in_app later by setting\n                // trimHeadFrames\n                trimHeadFrames: (options.trimHeadFrames || 0) + 1\n            }, options);\n\n            var stack = TraceKit.computeStackTrace(ex);\n            var frames = this._prepareFrames(stack, options);\n            data.stacktrace = {\n                // Sentry expects frames oldest to newest\n                frames: frames.reverse()\n            }\n        }\n\n        // Fire away!\n        this._send(data);\n\n        return this;\n    },\n\n    captureBreadcrumb: function (obj) {\n        var crumb = objectMerge({\n            timestamp: now() / 1000\n        }, obj);\n\n        if (isFunction(this._globalOptions.breadcrumbCallback)) {\n            var result = this._globalOptions.breadcrumbCallback(crumb);\n\n            if (isObject(result) && !isEmptyObject(result)) {\n                crumb = result;\n            } else if (result === false) {\n                return this;\n            }\n        }\n\n        this._breadcrumbs.push(crumb);\n        if (this._breadcrumbs.length > this._globalOptions.maxBreadcrumbs) {\n            this._breadcrumbs.shift();\n        }\n        return this;\n    },\n\n    addPlugin: function(plugin /*arg1, arg2, ... argN*/) {\n        var pluginArgs = [].slice.call(arguments, 1);\n\n        this._plugins.push([plugin, pluginArgs]);\n        if (this._isRavenInstalled) {\n            this._drainPlugins();\n        }\n\n        return this;\n    },\n\n    /*\n     * Set/clear a user to be sent along with the payload.\n     *\n     * @param {object} user An object representing user data [optional]\n     * @return {Raven}\n     */\n    setUserContext: function(user) {\n        // Intentionally do not merge here since that's an unexpected behavior.\n        this._globalContext.user = user;\n\n        return this;\n    },\n\n    /*\n     * Merge extra attributes to be sent along with the payload.\n     *\n     * @param {object} extra An object representing extra data [optional]\n     * @return {Raven}\n     */\n    setExtraContext: function(extra) {\n        this._mergeContext('extra', extra);\n\n        return this;\n    },\n\n    /*\n     * Merge tags to be sent along with the payload.\n     *\n     * @param {object} tags An object representing tags [optional]\n     * @return {Raven}\n     */\n    setTagsContext: function(tags) {\n        this._mergeContext('tags', tags);\n\n        return this;\n    },\n\n    /*\n     * Clear all of the context.\n     *\n     * @return {Raven}\n     */\n    clearContext: function() {\n        this._globalContext = {};\n\n        return this;\n    },\n\n    /*\n     * Get a copy of the current context. This cannot be mutated.\n     *\n     * @return {object} copy of context\n     */\n    getContext: function() {\n        // lol javascript\n        return JSON.parse(stringify(this._globalContext));\n    },\n\n\n    /*\n     * Set environment of application\n     *\n     * @param {string} environment Typically something like 'production'.\n     * @return {Raven}\n     */\n    setEnvironment: function(environment) {\n        this._globalOptions.environment = environment;\n\n        return this;\n    },\n\n    /*\n     * Set release version of application\n     *\n     * @param {string} release Typically something like a git SHA to identify version\n     * @return {Raven}\n     */\n    setRelease: function(release) {\n        this._globalOptions.release = release;\n\n        return this;\n    },\n\n    /*\n     * Set the dataCallback option\n     *\n     * @param {function} callback The callback to run which allows the\n     *                            data blob to be mutated before sending\n     * @return {Raven}\n     */\n    setDataCallback: function(callback) {\n        var original = this._globalOptions.dataCallback;\n        this._globalOptions.dataCallback =\n          keepOriginalCallback(original, callback);\n        return this;\n    },\n\n    /*\n     * Set the breadcrumbCallback option\n     *\n     * @param {function} callback The callback to run which allows filtering\n     *                            or mutating breadcrumbs\n     * @return {Raven}\n     */\n    setBreadcrumbCallback: function(callback) {\n        var original = this._globalOptions.breadcrumbCallback;\n        this._globalOptions.breadcrumbCallback =\n          keepOriginalCallback(original, callback);\n        return this;\n    },\n\n    /*\n     * Set the shouldSendCallback option\n     *\n     * @param {function} callback The callback to run which allows\n     *                            introspecting the blob before sending\n     * @return {Raven}\n     */\n    setShouldSendCallback: function(callback) {\n        var original = this._globalOptions.shouldSendCallback;\n        this._globalOptions.shouldSendCallback =\n          keepOriginalCallback(original, callback);\n        return this;\n    },\n\n    /**\n     * Override the default HTTP transport mechanism that transmits data\n     * to the Sentry server.\n     *\n     * @param {function} transport Function invoked instead of the default\n     *                             `makeRequest` handler.\n     *\n     * @return {Raven}\n     */\n    setTransport: function(transport) {\n        this._globalOptions.transport = transport;\n\n        return this;\n    },\n\n    /*\n     * Get the latest raw exception that was captured by Raven.\n     *\n     * @return {error}\n     */\n    lastException: function() {\n        return this._lastCapturedException;\n    },\n\n    /*\n     * Get the last event id\n     *\n     * @return {string}\n     */\n    lastEventId: function() {\n        return this._lastEventId;\n    },\n\n    /*\n     * Determine if Raven is setup and ready to go.\n     *\n     * @return {boolean}\n     */\n    isSetup: function() {\n        if (!this._hasJSON) return false;  // needs JSON support\n        if (!this._globalServer) {\n            if (!this.ravenNotConfiguredError) {\n              this.ravenNotConfiguredError = true;\n              this._logDebug('error', 'Error: Raven has not been configured.');\n            }\n            return false;\n        }\n        return true;\n    },\n\n    afterLoad: function () {\n        // TODO: remove window dependence?\n\n        // Attempt to initialize Raven on load\n        var RavenConfig = _window.RavenConfig;\n        if (RavenConfig) {\n            this.config(RavenConfig.dsn, RavenConfig.config).install();\n        }\n    },\n\n    showReportDialog: function (options) {\n        if (!_document) // doesn't work without a document (React native)\n            return;\n\n        options = options || {};\n\n        var lastEventId = options.eventId || this.lastEventId();\n        if (!lastEventId) {\n            throw new RavenConfigError('Missing eventId');\n        }\n\n        var dsn = options.dsn || this._dsn;\n        if (!dsn) {\n            throw new RavenConfigError('Missing DSN');\n        }\n\n        var encode = encodeURIComponent;\n        var qs = '';\n        qs += '?eventId=' + encode(lastEventId);\n        qs += '&dsn=' + encode(dsn);\n\n        var user = options.user || this._globalContext.user;\n        if (user) {\n            if (user.name)  qs += '&name=' + encode(user.name);\n            if (user.email) qs += '&email=' + encode(user.email);\n        }\n\n        var globalServer = this._getGlobalServer(this._parseDSN(dsn));\n\n        var script = _document.createElement('script');\n        script.async = true;\n        script.src = globalServer + '/api/embed/error-page/' + qs;\n        (_document.head || _document.body).appendChild(script);\n    },\n\n    /**** Private functions ****/\n    _ignoreNextOnError: function () {\n        var self = this;\n        this._ignoreOnError += 1;\n        setTimeout(function () {\n            // onerror should trigger before setTimeout\n            self._ignoreOnError -= 1;\n        });\n    },\n\n    _triggerEvent: function(eventType, options) {\n        // NOTE: `event` is a native browser thing, so let's avoid conflicting wiht it\n        var evt, key;\n\n        if (!this._hasDocument)\n            return;\n\n        options = options || {};\n\n        eventType = 'raven' + eventType.substr(0,1).toUpperCase() + eventType.substr(1);\n\n        if (_document.createEvent) {\n            evt = _document.createEvent('HTMLEvents');\n            evt.initEvent(eventType, true, true);\n        } else {\n            evt = _document.createEventObject();\n            evt.eventType = eventType;\n        }\n\n        for (key in options) if (hasKey(options, key)) {\n            evt[key] = options[key];\n        }\n\n        if (_document.createEvent) {\n            // IE9 if standards\n            _document.dispatchEvent(evt);\n        } else {\n            // IE8 regardless of Quirks or Standards\n            // IE9 if quirks\n            try {\n                _document.fireEvent('on' + evt.eventType.toLowerCase(), evt);\n            } catch(e) {\n                // Do nothing\n            }\n        }\n    },\n\n    /**\n     * Wraps addEventListener to capture UI breadcrumbs\n     * @param evtName the event name (e.g. \"click\")\n     * @returns {Function}\n     * @private\n     */\n    _breadcrumbEventHandler: function(evtName) {\n        var self = this;\n        return function (evt) {\n            // reset keypress timeout; e.g. triggering a 'click' after\n            // a 'keypress' will reset the keypress debounce so that a new\n            // set of keypresses can be recorded\n            self._keypressTimeout = null;\n\n            // It's possible this handler might trigger multiple times for the same\n            // event (e.g. event propagation through node ancestors). Ignore if we've\n            // already captured the event.\n            if (self._lastCapturedEvent === evt)\n                return;\n\n            self._lastCapturedEvent = evt;\n\n            // try/catch both:\n            // - accessing evt.target (see getsentry/raven-js#838, #768)\n            // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n            //   can throw an exception in some circumstances.\n            var target;\n            try {\n                target = htmlTreeAsString(evt.target);\n            } catch (e) {\n                target = '<unknown>';\n            }\n\n            self.captureBreadcrumb({\n                category: 'ui.' + evtName, // e.g. ui.click, ui.input\n                message: target\n            });\n        };\n    },\n\n    /**\n     * Wraps addEventListener to capture keypress UI events\n     * @returns {Function}\n     * @private\n     */\n    _keypressEventHandler: function() {\n        var self = this,\n            debounceDuration = 1000; // milliseconds\n\n        // TODO: if somehow user switches keypress target before\n        //       debounce timeout is triggered, we will only capture\n        //       a single breadcrumb from the FIRST target (acceptable?)\n        return function (evt) {\n            var target;\n            try {\n                target = evt.target;\n            } catch (e) {\n                // just accessing event properties can throw an exception in some rare circumstances\n                // see: https://github.com/getsentry/raven-js/issues/838\n                return;\n            }\n            var tagName = target && target.tagName;\n\n            // only consider keypress events on actual input elements\n            // this will disregard keypresses targeting body (e.g. tabbing\n            // through elements, hotkeys, etc)\n            if (!tagName || tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)\n                return;\n\n            // record first keypress in a series, but ignore subsequent\n            // keypresses until debounce clears\n            var timeout = self._keypressTimeout;\n            if (!timeout) {\n                self._breadcrumbEventHandler('input')(evt);\n            }\n            clearTimeout(timeout);\n            self._keypressTimeout = setTimeout(function () {\n                self._keypressTimeout = null;\n            }, debounceDuration);\n        };\n    },\n\n    /**\n     * Captures a breadcrumb of type \"navigation\", normalizing input URLs\n     * @param to the originating URL\n     * @param from the target URL\n     * @private\n     */\n    _captureUrlChange: function(from, to) {\n        var parsedLoc = parseUrl(this._location.href);\n        var parsedTo = parseUrl(to);\n        var parsedFrom = parseUrl(from);\n\n        // because onpopstate only tells you the \"new\" (to) value of location.href, and\n        // not the previous (from) value, we need to track the value of the current URL\n        // state ourselves\n        this._lastHref = to;\n\n        // Use only the path component of the URL if the URL matches the current\n        // document (almost all the time when using pushState)\n        if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host)\n            to = parsedTo.relative;\n        if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host)\n            from = parsedFrom.relative;\n\n        this.captureBreadcrumb({\n            category: 'navigation',\n            data: {\n                to: to,\n                from: from\n            }\n        });\n    },\n\n    /**\n     * Wrap timer functions and event targets to catch errors and provide\n     * better metadata.\n     */\n    _instrumentTryCatch: function() {\n        var self = this;\n\n        var wrappedBuiltIns = self._wrappedBuiltIns;\n\n        function wrapTimeFn(orig) {\n            return function (fn, t) { // preserve arity\n                // Make a copy of the arguments to prevent deoptimization\n                // https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments\n                var args = new Array(arguments.length);\n                for(var i = 0; i < args.length; ++i) {\n                    args[i] = arguments[i];\n                }\n                var originalCallback = args[0];\n                if (isFunction(originalCallback)) {\n                    args[0] = self.wrap(originalCallback);\n                }\n\n                // IE < 9 doesn't support .call/.apply on setInterval/setTimeout, but it\n                // also supports only two arguments and doesn't care what this is, so we\n                // can just call the original function directly.\n                if (orig.apply) {\n                    return orig.apply(this, args);\n                } else {\n                    return orig(args[0], args[1]);\n                }\n            };\n        }\n\n        var autoBreadcrumbs = this._globalOptions.autoBreadcrumbs;\n\n        function wrapEventTarget(global) {\n            var proto = _window[global] && _window[global].prototype;\n            if (proto && proto.hasOwnProperty && proto.hasOwnProperty('addEventListener')) {\n                fill(proto, 'addEventListener', function(orig) {\n                    return function (evtName, fn, capture, secure) { // preserve arity\n                        try {\n                            if (fn && fn.handleEvent) {\n                                fn.handleEvent = self.wrap(fn.handleEvent);\n                            }\n                        } catch (err) {\n                            // can sometimes get 'Permission denied to access property \"handle Event'\n                        }\n\n                        // More breadcrumb DOM capture ... done here and not in `_instrumentBreadcrumbs`\n                        // so that we don't have more than one wrapper function\n                        var before,\n                            clickHandler,\n                            keypressHandler;\n\n                        if (autoBreadcrumbs && autoBreadcrumbs.dom && (global === 'EventTarget' || global === 'Node')) {\n                            // NOTE: generating multiple handlers per addEventListener invocation, should\n                            //       revisit and verify we can just use one (almost certainly)\n                            clickHandler = self._breadcrumbEventHandler('click');\n                            keypressHandler = self._keypressEventHandler();\n                            before = function (evt) {\n                                // need to intercept every DOM event in `before` argument, in case that\n                                // same wrapped method is re-used for different events (e.g. mousemove THEN click)\n                                // see #724\n                                if (!evt) return;\n\n                                var eventType;\n                                try {\n                                    eventType = evt.type\n                                } catch (e) {\n                                    // just accessing event properties can throw an exception in some rare circumstances\n                                    // see: https://github.com/getsentry/raven-js/issues/838\n                                    return;\n                                }\n                                if (eventType === 'click')\n                                    return clickHandler(evt);\n                                else if (eventType === 'keypress')\n                                    return keypressHandler(evt);\n                            };\n                        }\n                        return orig.call(this, evtName, self.wrap(fn, undefined, before), capture, secure);\n                    };\n                }, wrappedBuiltIns);\n                fill(proto, 'removeEventListener', function (orig) {\n                    return function (evt, fn, capture, secure) {\n                        try {\n                            fn = fn && (fn.__raven_wrapper__ ? fn.__raven_wrapper__  : fn);\n                        } catch (e) {\n                            // ignore, accessing __raven_wrapper__ will throw in some Selenium environments\n                        }\n                        return orig.call(this, evt, fn, capture, secure);\n                    };\n                }, wrappedBuiltIns);\n            }\n        }\n\n        fill(_window, 'setTimeout', wrapTimeFn, wrappedBuiltIns);\n        fill(_window, 'setInterval', wrapTimeFn, wrappedBuiltIns);\n        if (_window.requestAnimationFrame) {\n            fill(_window, 'requestAnimationFrame', function (orig) {\n                return function (cb) {\n                    return orig(self.wrap(cb));\n                };\n            }, wrappedBuiltIns);\n        }\n\n        // event targets borrowed from bugsnag-js:\n        // https://github.com/bugsnag/bugsnag-js/blob/master/src/bugsnag.js#L666\n        var eventTargets = ['EventTarget', 'Window', 'Node', 'ApplicationCache', 'AudioTrackList', 'ChannelMergerNode', 'CryptoOperation', 'EventSource', 'FileReader', 'HTMLUnknownElement', 'IDBDatabase', 'IDBRequest', 'IDBTransaction', 'KeyOperation', 'MediaController', 'MessagePort', 'ModalWindow', 'Notification', 'SVGElementInstance', 'Screen', 'TextTrack', 'TextTrackCue', 'TextTrackList', 'WebSocket', 'WebSocketWorker', 'Worker', 'XMLHttpRequest', 'XMLHttpRequestEventTarget', 'XMLHttpRequestUpload'];\n        for (var i = 0; i < eventTargets.length; i++) {\n            wrapEventTarget(eventTargets[i]);\n        }\n    },\n\n\n    /**\n     * Instrument browser built-ins w/ breadcrumb capturing\n     *  - XMLHttpRequests\n     *  - DOM interactions (click/typing)\n     *  - window.location changes\n     *  - console\n     *\n     * Can be disabled or individually configured via the `autoBreadcrumbs` config option\n     */\n    _instrumentBreadcrumbs: function () {\n        var self = this;\n        var autoBreadcrumbs = this._globalOptions.autoBreadcrumbs;\n\n        var wrappedBuiltIns = self._wrappedBuiltIns;\n\n        function wrapProp(prop, xhr) {\n            if (prop in xhr && isFunction(xhr[prop])) {\n                fill(xhr, prop, function (orig) {\n                    return self.wrap(orig);\n                }); // intentionally don't track filled methods on XHR instances\n            }\n        }\n\n        if (autoBreadcrumbs.xhr && 'XMLHttpRequest' in _window) {\n            var xhrproto = XMLHttpRequest.prototype;\n            fill(xhrproto, 'open', function(origOpen) {\n                return function (method, url) { // preserve arity\n\n                    // if Sentry key appears in URL, don't capture\n                    if (isString(url) && url.indexOf(self._globalKey) === -1) {\n                        this.__raven_xhr = {\n                            method: method,\n                            url: url,\n                            status_code: null\n                        };\n                    }\n\n                    return origOpen.apply(this, arguments);\n                };\n            }, wrappedBuiltIns);\n\n            fill(xhrproto, 'send', function(origSend) {\n                return function (data) { // preserve arity\n                    var xhr = this;\n\n                    function onreadystatechangeHandler() {\n                        if (xhr.__raven_xhr && (xhr.readyState === 1 || xhr.readyState === 4)) {\n                            try {\n                                // touching statusCode in some platforms throws\n                                // an exception\n                                xhr.__raven_xhr.status_code = xhr.status;\n                            } catch (e) { /* do nothing */ }\n                            self.captureBreadcrumb({\n                                type: 'http',\n                                category: 'xhr',\n                                data: xhr.__raven_xhr\n                            });\n                        }\n                    }\n\n                    var props = ['onload', 'onerror', 'onprogress'];\n                    for (var j = 0; j < props.length; j++) {\n                        wrapProp(props[j], xhr);\n                    }\n\n                    if ('onreadystatechange' in xhr && isFunction(xhr.onreadystatechange)) {\n                        fill(xhr, 'onreadystatechange', function (orig) {\n                            return self.wrap(orig, undefined, onreadystatechangeHandler);\n                        } /* intentionally don't track this instrumentation */);\n                    } else {\n                        // if onreadystatechange wasn't actually set by the page on this xhr, we\n                        // are free to set our own and capture the breadcrumb\n                        xhr.onreadystatechange = onreadystatechangeHandler;\n                    }\n\n                    return origSend.apply(this, arguments);\n                };\n            }, wrappedBuiltIns);\n        }\n\n        if (autoBreadcrumbs.xhr && 'fetch' in _window) {\n            fill(_window, 'fetch', function(origFetch) {\n                return function (fn, t) { // preserve arity\n                    // Make a copy of the arguments to prevent deoptimization\n                    // https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments\n                    var args = new Array(arguments.length);\n                    for (var i = 0; i < args.length; ++i) {\n                        args[i] = arguments[i];\n                    }\n\n                    var fetchInput = args[0];\n                    var method = 'GET';\n                    var url;\n\n                    if (typeof fetchInput === 'string') {\n                        url = fetchInput;\n                    } else {\n                        url = fetchInput.url;\n                        if (fetchInput.method) {\n                            method = fetchInput.method;\n                        }\n                    }\n\n                    if (args[1] && args[1].method) {\n                        method = args[1].method;\n                    }\n\n                    var fetchData = {\n                        method: method,\n                        url: url,\n                        status_code: null\n                    };\n\n                    self.captureBreadcrumb({\n                        type: 'http',\n                        category: 'fetch',\n                        data: fetchData\n                    });\n\n                    return origFetch.apply(this, args).then(function (response) {\n                        fetchData.status_code = response.status;\n\n                        return response;\n                    });\n                };\n            }, wrappedBuiltIns);\n        }\n\n        // Capture breadcrumbs from any click that is unhandled / bubbled up all the way\n        // to the document. Do this before we instrument addEventListener.\n        if (autoBreadcrumbs.dom && this._hasDocument) {\n            if (_document.addEventListener) {\n                _document.addEventListener('click', self._breadcrumbEventHandler('click'), false);\n                _document.addEventListener('keypress', self._keypressEventHandler(), false);\n            }\n            else {\n                // IE8 Compatibility\n                _document.attachEvent('onclick', self._breadcrumbEventHandler('click'));\n                _document.attachEvent('onkeypress', self._keypressEventHandler());\n            }\n        }\n\n        // record navigation (URL) changes\n        // NOTE: in Chrome App environment, touching history.pushState, *even inside\n        //       a try/catch block*, will cause Chrome to output an error to console.error\n        // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n        var chrome = _window.chrome;\n        var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n        var hasPushState = !isChromePackagedApp && _window.history && history.pushState;\n        if (autoBreadcrumbs.location && hasPushState) {\n            // TODO: remove onpopstate handler on uninstall()\n            var oldOnPopState = _window.onpopstate;\n            _window.onpopstate = function () {\n                var currentHref = self._location.href;\n                self._captureUrlChange(self._lastHref, currentHref);\n\n                if (oldOnPopState) {\n                    return oldOnPopState.apply(this, arguments);\n                }\n            };\n\n            fill(history, 'pushState', function (origPushState) {\n                // note history.pushState.length is 0; intentionally not declaring\n                // params to preserve 0 arity\n                return function (/* state, title, url */) {\n                    var url = arguments.length > 2 ? arguments[2] : undefined;\n\n                    // url argument is optional\n                    if (url) {\n                        // coerce to string (this is what pushState does)\n                        self._captureUrlChange(self._lastHref, url + '');\n                    }\n\n                    return origPushState.apply(this, arguments);\n                };\n            }, wrappedBuiltIns);\n        }\n\n        if (autoBreadcrumbs.console && 'console' in _window && console.log) {\n            // console\n            var consoleMethodCallback = function (msg, data) {\n                self.captureBreadcrumb({\n                    message: msg,\n                    level: data.level,\n                    category: 'console'\n                });\n            };\n\n            each(['debug', 'info', 'warn', 'error', 'log'], function (_, level) {\n                wrapConsoleMethod(console, level, consoleMethodCallback);\n            });\n        }\n\n    },\n\n    _restoreBuiltIns: function () {\n        // restore any wrapped builtins\n        var builtin;\n        while (this._wrappedBuiltIns.length) {\n            builtin = this._wrappedBuiltIns.shift();\n\n            var obj = builtin[0],\n              name = builtin[1],\n              orig = builtin[2];\n\n            obj[name] = orig;\n        }\n    },\n\n    _drainPlugins: function() {\n        var self = this;\n\n        // FIX ME TODO\n        each(this._plugins, function(_, plugin) {\n            var installer = plugin[0];\n            var args = plugin[1];\n            installer.apply(self, [self].concat(args));\n        });\n    },\n\n    _parseDSN: function(str) {\n        var m = dsnPattern.exec(str),\n            dsn = {},\n            i = 7;\n\n        try {\n            while (i--) dsn[dsnKeys[i]] = m[i] || '';\n        } catch(e) {\n            throw new RavenConfigError('Invalid DSN: ' + str);\n        }\n\n        if (dsn.pass && !this._globalOptions.allowSecretKey) {\n            throw new RavenConfigError('Do not specify your secret key in the DSN. See: http://bit.ly/raven-secret-key');\n        }\n\n        return dsn;\n    },\n\n    _getGlobalServer: function(uri) {\n        // assemble the endpoint from the uri pieces\n        var globalServer = '//' + uri.host +\n            (uri.port ? ':' + uri.port : '');\n\n        if (uri.protocol) {\n            globalServer = uri.protocol + ':' + globalServer;\n        }\n        return globalServer;\n    },\n\n    _handleOnErrorStackInfo: function() {\n        // if we are intentionally ignoring errors via onerror, bail out\n        if (!this._ignoreOnError) {\n            this._handleStackInfo.apply(this, arguments);\n        }\n    },\n\n    _handleStackInfo: function(stackInfo, options) {\n        var frames = this._prepareFrames(stackInfo, options);\n\n        this._triggerEvent('handle', {\n            stackInfo: stackInfo,\n            options: options\n        });\n\n        this._processException(\n            stackInfo.name,\n            stackInfo.message,\n            stackInfo.url,\n            stackInfo.lineno,\n            frames,\n            options\n        );\n    },\n\n    _prepareFrames: function(stackInfo, options) {\n        var self = this;\n        var frames = [];\n        if (stackInfo.stack && stackInfo.stack.length) {\n            each(stackInfo.stack, function(i, stack) {\n                var frame = self._normalizeFrame(stack);\n                if (frame) {\n                    frames.push(frame);\n                }\n            });\n\n            // e.g. frames captured via captureMessage throw\n            if (options && options.trimHeadFrames) {\n                for (var j = 0; j < options.trimHeadFrames && j < frames.length; j++) {\n                    frames[j].in_app = false;\n                }\n            }\n        }\n        frames = frames.slice(0, this._globalOptions.stackTraceLimit);\n        return frames;\n    },\n\n\n    _normalizeFrame: function(frame) {\n        if (!frame.url) return;\n\n        // normalize the frames data\n        var normalized = {\n            filename:   frame.url,\n            lineno:     frame.line,\n            colno:      frame.column,\n            'function': frame.func || '?'\n        };\n\n        normalized.in_app = !( // determine if an exception came from outside of our app\n            // first we check the global includePaths list.\n            !!this._globalOptions.includePaths.test && !this._globalOptions.includePaths.test(normalized.filename) ||\n            // Now we check for fun, if the function name is Raven or TraceKit\n            /(Raven|TraceKit)\\./.test(normalized['function']) ||\n            // finally, we do a last ditch effort and check for raven.min.js\n            /raven\\.(min\\.)?js$/.test(normalized.filename)\n        );\n\n        return normalized;\n    },\n\n    _processException: function(type, message, fileurl, lineno, frames, options) {\n        var stacktrace;\n        if (!!this._globalOptions.ignoreErrors.test && this._globalOptions.ignoreErrors.test(message)) return;\n\n        message += '';\n\n        if (frames && frames.length) {\n            fileurl = frames[0].filename || fileurl;\n            // Sentry expects frames oldest to newest\n            // and JS sends them as newest to oldest\n            frames.reverse();\n            stacktrace = {frames: frames};\n        } else if (fileurl) {\n            stacktrace = {\n                frames: [{\n                    filename: fileurl,\n                    lineno: lineno,\n                    in_app: true\n                }]\n            };\n        }\n\n        if (!!this._globalOptions.ignoreUrls.test && this._globalOptions.ignoreUrls.test(fileurl)) return;\n        if (!!this._globalOptions.whitelistUrls.test && !this._globalOptions.whitelistUrls.test(fileurl)) return;\n\n        var data = objectMerge({\n            // sentry.interfaces.Exception\n            exception: {\n                values: [{\n                    type: type,\n                    value: message,\n                    stacktrace: stacktrace\n                }]\n            },\n            culprit: fileurl\n        }, options);\n\n        // Fire away!\n        this._send(data);\n    },\n\n    _trimPacket: function(data) {\n        // For now, we only want to truncate the two different messages\n        // but this could/should be expanded to just trim everything\n        var max = this._globalOptions.maxMessageLength;\n        if (data.message) {\n            data.message = truncate(data.message, max);\n        }\n        if (data.exception) {\n            var exception = data.exception.values[0];\n            exception.value = truncate(exception.value, max);\n        }\n\n        var request = data.request;\n        if (request) {\n            if (request.url) {\n                request.url = truncate(request.url, this._globalOptions.maxUrlLength);\n            }\n            if (request.Referer) {\n                request.Referer = truncate(request.Referer, this._globalOptions.maxUrlLength);\n            }\n        }\n\n        if (data.breadcrumbs && data.breadcrumbs.values)\n            this._trimBreadcrumbs(data.breadcrumbs);\n\n        return data;\n    },\n\n    /**\n     * Truncate breadcrumb values (right now just URLs)\n     */\n    _trimBreadcrumbs: function (breadcrumbs) {\n        // known breadcrumb properties with urls\n        // TODO: also consider arbitrary prop values that start with (https?)?://\n        var urlProps = ['to', 'from', 'url'],\n            urlProp,\n            crumb,\n            data;\n\n        for (var i = 0; i < breadcrumbs.values.length; ++i) {\n            crumb = breadcrumbs.values[i];\n            if (!crumb.hasOwnProperty('data') || !isObject(crumb.data) || objectFrozen(crumb.data))\n                continue;\n\n            data = objectMerge({}, crumb.data);\n            for (var j = 0; j < urlProps.length; ++j) {\n                urlProp = urlProps[j];\n                if (data.hasOwnProperty(urlProp)) {\n                    data[urlProp] = truncate(data[urlProp], this._globalOptions.maxUrlLength);\n                }\n            }\n            breadcrumbs.values[i].data = data;\n        }\n    },\n\n    _getHttpData: function() {\n        if (!this._hasNavigator && !this._hasDocument) return;\n        var httpData = {};\n\n        if (this._hasNavigator && _navigator.userAgent) {\n            httpData.headers = {\n              'User-Agent': navigator.userAgent\n            };\n        }\n\n        if (this._hasDocument) {\n            if (_document.location && _document.location.href) {\n                httpData.url = _document.location.href;\n            }\n            if (_document.referrer) {\n                if (!httpData.headers) httpData.headers = {};\n                httpData.headers.Referer = _document.referrer;\n            }\n        }\n\n        return httpData;\n    },\n\n    _resetBackoff: function() {\n        this._backoffDuration = 0;\n        this._backoffStart = null;\n    },\n\n    _shouldBackoff: function() {\n        return this._backoffDuration && now() - this._backoffStart < this._backoffDuration;\n    },\n\n    /**\n     * Returns true if the in-process data payload matches the signature\n     * of the previously-sent data\n     *\n     * NOTE: This has to be done at this level because TraceKit can generate\n     *       data from window.onerror WITHOUT an exception object (IE8, IE9,\n     *       other old browsers). This can take the form of an \"exception\"\n     *       data object with a single frame (derived from the onerror args).\n     */\n    _isRepeatData: function (current) {\n        var last = this._lastData;\n\n        if (!last ||\n            current.message !== last.message || // defined for captureMessage\n            current.culprit !== last.culprit)   // defined for captureException/onerror\n            return false;\n\n        // Stacktrace interface (i.e. from captureMessage)\n        if (current.stacktrace || last.stacktrace) {\n            return isSameStacktrace(current.stacktrace, last.stacktrace);\n        }\n        // Exception interface (i.e. from captureException/onerror)\n        else if (current.exception || last.exception) {\n            return isSameException(current.exception, last.exception);\n        }\n\n        return true;\n    },\n\n    _setBackoffState: function(request) {\n        // If we are already in a backoff state, don't change anything\n        if (this._shouldBackoff()) {\n            return;\n        }\n\n        var status = request.status;\n\n        // 400 - project_id doesn't exist or some other fatal\n        // 401 - invalid/revoked dsn\n        // 429 - too many requests\n        if (!(status === 400 || status === 401 || status === 429))\n            return;\n\n        var retry;\n        try {\n            // If Retry-After is not in Access-Control-Expose-Headers, most\n            // browsers will throw an exception trying to access it\n            retry = request.getResponseHeader('Retry-After');\n            retry = parseInt(retry, 10) * 1000; // Retry-After is returned in seconds\n        } catch (e) {\n            /* eslint no-empty:0 */\n        }\n\n\n        this._backoffDuration = retry\n            // If Sentry server returned a Retry-After value, use it\n            ? retry\n            // Otherwise, double the last backoff duration (starts at 1 sec)\n            : this._backoffDuration * 2 || 1000;\n\n        this._backoffStart = now();\n    },\n\n    _send: function(data) {\n        var globalOptions = this._globalOptions;\n\n        var baseData = {\n            project: this._globalProject,\n            logger: globalOptions.logger,\n            platform: 'javascript'\n        }, httpData = this._getHttpData();\n\n        if (httpData) {\n            baseData.request = httpData;\n        }\n\n        // HACK: delete `trimHeadFrames` to prevent from appearing in outbound payload\n        if (data.trimHeadFrames) delete data.trimHeadFrames;\n\n        data = objectMerge(baseData, data);\n\n        // Merge in the tags and extra separately since objectMerge doesn't handle a deep merge\n        data.tags = objectMerge(objectMerge({}, this._globalContext.tags), data.tags);\n        data.extra = objectMerge(objectMerge({}, this._globalContext.extra), data.extra);\n\n        // Send along our own collected metadata with extra\n        data.extra['session:duration'] = now() - this._startTime;\n\n        if (this._breadcrumbs && this._breadcrumbs.length > 0) {\n            // intentionally make shallow copy so that additions\n            // to breadcrumbs aren't accidentally sent in this request\n            data.breadcrumbs = {\n                values: [].slice.call(this._breadcrumbs, 0)\n            };\n        }\n\n        // If there are no tags/extra, strip the key from the payload alltogther.\n        if (isEmptyObject(data.tags)) delete data.tags;\n\n        if (this._globalContext.user) {\n            // sentry.interfaces.User\n            data.user = this._globalContext.user;\n        }\n\n        // Include the environment if it's defined in globalOptions\n        if (globalOptions.environment) data.environment = globalOptions.environment;\n\n        // Include the release if it's defined in globalOptions\n        if (globalOptions.release) data.release = globalOptions.release;\n\n        // Include server_name if it's defined in globalOptions\n        if (globalOptions.serverName) data.server_name = globalOptions.serverName;\n\n        if (isFunction(globalOptions.dataCallback)) {\n            data = globalOptions.dataCallback(data) || data;\n        }\n\n        // Why??????????\n        if (!data || isEmptyObject(data)) {\n            return;\n        }\n\n        // Check if the request should be filtered or not\n        if (isFunction(globalOptions.shouldSendCallback) && !globalOptions.shouldSendCallback(data)) {\n            return;\n        }\n\n        // Backoff state: Sentry server previously responded w/ an error (e.g. 429 - too many requests),\n        // so drop requests until \"cool-off\" period has elapsed.\n        if (this._shouldBackoff()) {\n            this._logDebug('warn', 'Raven dropped error due to backoff: ', data);\n            return;\n        }\n\n        if (typeof globalOptions.sampleRate === 'number') {\n            if (Math.random() < globalOptions.sampleRate) {\n                this._sendProcessedPayload(data);\n            }\n        } else {\n            this._sendProcessedPayload(data);\n        }\n    },\n\n    _getUuid: function () {\n      return uuid4();\n    },\n\n    _sendProcessedPayload: function(data, callback) {\n        var self = this;\n        var globalOptions = this._globalOptions;\n\n        if (!this.isSetup()) return;\n\n        // Send along an event_id if not explicitly passed.\n        // This event_id can be used to reference the error within Sentry itself.\n        // Set lastEventId after we know the error should actually be sent\n        this._lastEventId = data.event_id || (data.event_id = this._getUuid());\n\n        // Try and clean up the packet before sending by truncating long values\n        data = this._trimPacket(data);\n\n        // ideally duplicate error testing should occur *before* dataCallback/shouldSendCallback,\n        // but this would require copying an un-truncated copy of the data packet, which can be\n        // arbitrarily deep (extra_data) -- could be worthwhile? will revisit\n        if (!this._globalOptions.allowDuplicates && this._isRepeatData(data)) {\n            this._logDebug('warn', 'Raven dropped repeat event: ', data);\n            return;\n        }\n\n        // Store outbound payload after trim\n        this._lastData = data;\n\n        this._logDebug('debug', 'Raven about to send:', data);\n\n        var auth = {\n            sentry_version: '7',\n            sentry_client: 'raven-js/' + this.VERSION,\n            sentry_key: this._globalKey\n        };\n        if (this._globalSecret) {\n            auth.sentry_secret = this._globalSecret;\n        }\n\n        var exception = data.exception && data.exception.values[0];\n        this.captureBreadcrumb({\n            category: 'sentry',\n            message: exception\n                ? (exception.type ? exception.type + ': ' : '') + exception.value\n                : data.message,\n            event_id: data.event_id,\n            level: data.level || 'error' // presume error unless specified\n        });\n\n        var url = this._globalEndpoint;\n        (globalOptions.transport || this._makeRequest).call(this, {\n            url: url,\n            auth: auth,\n            data: data,\n            options: globalOptions,\n            onSuccess: function success() {\n                self._resetBackoff();\n\n                self._triggerEvent('success', {\n                    data: data,\n                    src: url\n                });\n                callback && callback();\n            },\n            onError: function failure(error) {\n                self._logDebug('error', 'Raven transport failed to send: ', error);\n\n                if (error.request) {\n                    self._setBackoffState(error.request);\n                }\n\n                self._triggerEvent('failure', {\n                    data: data,\n                    src: url\n                });\n                error = error || new Error('Raven send failed (no additional details provided)');\n                callback && callback(error);\n            }\n        });\n    },\n\n    _makeRequest: function(opts) {\n        var request = new XMLHttpRequest();\n\n        // if browser doesn't support CORS (e.g. IE7), we are out of luck\n        var hasCORS =\n            'withCredentials' in request ||\n            typeof XDomainRequest !== 'undefined';\n\n        if (!hasCORS) return;\n\n        var url = opts.url;\n\n        if ('withCredentials' in request) {\n            request.onreadystatechange = function () {\n                if (request.readyState !== 4) {\n                    return;\n                } else if (request.status === 200) {\n                    opts.onSuccess && opts.onSuccess();\n                } else if (opts.onError) {\n                    var err = new Error('Sentry error code: ' + request.status);\n                    err.request = request;\n                    opts.onError(err);\n                }\n            };\n        } else {\n            request = new XDomainRequest();\n            // xdomainrequest cannot go http -> https (or vice versa),\n            // so always use protocol relative\n            url = url.replace(/^https?:/, '');\n\n            // onreadystatechange not supported by XDomainRequest\n            if (opts.onSuccess) {\n                request.onload = opts.onSuccess;\n            }\n            if (opts.onError) {\n                request.onerror = function () {\n                    var err = new Error('Sentry error code: XDomainRequest');\n                    err.request = request;\n                    opts.onError(err);\n                }\n            }\n        }\n\n        // NOTE: auth is intentionally sent as part of query string (NOT as custom\n        //       HTTP header) so as to avoid preflight CORS requests\n        request.open('POST', url + '?' + urlencode(opts.auth));\n        request.send(stringify(opts.data));\n    },\n\n    _logDebug: function(level) {\n        if (this._originalConsoleMethods[level] && this.debug) {\n            // In IE<10 console methods do not have their own 'apply' method\n            Function.prototype.apply.call(\n                this._originalConsoleMethods[level],\n                this._originalConsole,\n                [].slice.call(arguments, 1)\n            );\n        }\n    },\n\n    _mergeContext: function(key, context) {\n        if (isUndefined(context)) {\n            delete this._globalContext[key];\n        } else {\n            this._globalContext[key] = objectMerge(this._globalContext[key] || {}, context);\n        }\n    }\n};\n\n/*------------------------------------------------\n * utils\n *\n * conditionally exported for test via Raven.utils\n =================================================\n */\nvar objectPrototype = Object.prototype;\n\nfunction isUndefined(what) {\n    return what === void 0;\n}\n\nfunction isFunction(what) {\n    return typeof what === 'function';\n}\n\nfunction isString(what) {\n    return objectPrototype.toString.call(what) === '[object String]';\n}\n\n\nfunction isEmptyObject(what) {\n    for (var _ in what) return false;  // eslint-disable-line guard-for-in, no-unused-vars\n    return true;\n}\n\nfunction each(obj, callback) {\n    var i, j;\n\n    if (isUndefined(obj.length)) {\n        for (i in obj) {\n            if (hasKey(obj, i)) {\n                callback.call(null, i, obj[i]);\n            }\n        }\n    } else {\n        j = obj.length;\n        if (j) {\n            for (i = 0; i < j; i++) {\n                callback.call(null, i, obj[i]);\n            }\n        }\n    }\n}\n\nfunction objectMerge(obj1, obj2) {\n    if (!obj2) {\n        return obj1;\n    }\n    each(obj2, function(key, value){\n        obj1[key] = value;\n    });\n    return obj1;\n}\n\n/**\n * This function is only used for react-native.\n * react-native freezes object that have already been sent over the\n * js bridge. We need this function in order to check if the object is frozen.\n * So it's ok that objectFrozen returns false if Object.isFrozen is not\n * supported because it's not relevant for other \"platforms\". See related issue:\n * https://github.com/getsentry/react-native-sentry/issues/57\n */\nfunction objectFrozen(obj) {\n    if (!Object.isFrozen) {\n        return false;\n    }\n    return Object.isFrozen(obj);\n}\n\nfunction truncate(str, max) {\n    return !max || str.length <= max ? str : str.substr(0, max) + '\\u2026';\n}\n\n/**\n * hasKey, a better form of hasOwnProperty\n * Example: hasKey(MainHostObject, property) === true/false\n *\n * @param {Object} host object to check property\n * @param {string} key to check\n */\nfunction hasKey(object, key) {\n    return objectPrototype.hasOwnProperty.call(object, key);\n}\n\nfunction joinRegExp(patterns) {\n    // Combine an array of regular expressions and strings into one large regexp\n    // Be mad.\n    var sources = [],\n        i = 0, len = patterns.length,\n        pattern;\n\n    for (; i < len; i++) {\n        pattern = patterns[i];\n        if (isString(pattern)) {\n            // If it's a string, we need to escape it\n            // Taken from: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\n            sources.push(pattern.replace(/([.*+?^=!:${}()|\\[\\]\\/\\\\])/g, '\\\\$1'));\n        } else if (pattern && pattern.source) {\n            // If it's a regexp already, we want to extract the source\n            sources.push(pattern.source);\n        }\n        // Intentionally skip other cases\n    }\n    return new RegExp(sources.join('|'), 'i');\n}\n\nfunction urlencode(o) {\n    var pairs = [];\n    each(o, function(key, value) {\n        pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));\n    });\n    return pairs.join('&');\n}\n\n// borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n// intentionally using regex and not <a/> href parsing trick because React Native and other\n// environments where DOM might not be available\nfunction parseUrl(url) {\n    var match = url.match(/^(([^:\\/?#]+):)?(\\/\\/([^\\/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n    if (!match) return {};\n\n    // coerce to undefined values to empty string so we don't get 'undefined'\n    var query = match[6] || '';\n    var fragment = match[8] || '';\n    return {\n        protocol: match[2],\n        host: match[4],\n        path: match[5],\n        relative: match[5] + query + fragment // everything minus origin\n    };\n}\nfunction uuid4() {\n    var crypto = _window.crypto || _window.msCrypto;\n\n    if (!isUndefined(crypto) && crypto.getRandomValues) {\n        // Use window.crypto API if available\n        var arr = new Uint16Array(8);\n        crypto.getRandomValues(arr);\n\n        // set 4 in byte 7\n        arr[3] = arr[3] & 0xFFF | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        arr[4] = arr[4] & 0x3FFF | 0x8000;\n\n        var pad = function(num) {\n            var v = num.toString(16);\n            while (v.length < 4) {\n                v = '0' + v;\n            }\n            return v;\n        };\n\n        return pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) +\n        pad(arr[5]) + pad(arr[6]) + pad(arr[7]);\n    } else {\n        // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n        return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\n            var r = Math.random()*16|0,\n                v = c === 'x' ? r : r&0x3|0x8;\n            return v.toString(16);\n        });\n    }\n}\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @param elem\n * @returns {string}\n */\nfunction htmlTreeAsString(elem) {\n    /* eslint no-extra-parens:0*/\n    var MAX_TRAVERSE_HEIGHT = 5,\n        MAX_OUTPUT_LEN = 80,\n        out = [],\n        height = 0,\n        len = 0,\n        separator = ' > ',\n        sepLength = separator.length,\n        nextStr;\n\n    while (elem && height++ < MAX_TRAVERSE_HEIGHT) {\n\n        nextStr = htmlElementAsString(elem);\n        // bail out if\n        // - nextStr is the 'html' element\n        // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n        //   (ignore this limit if we are on the first iteration)\n        if (nextStr === 'html' || height > 1 && len + (out.length * sepLength) + nextStr.length >= MAX_OUTPUT_LEN) {\n            break;\n        }\n\n        out.push(nextStr);\n\n        len += nextStr.length;\n        elem = elem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @param HTMLElement\n * @returns {string}\n */\nfunction htmlElementAsString(elem) {\n    var out = [],\n        className,\n        classes,\n        key,\n        attr,\n        i;\n\n    if (!elem || !elem.tagName) {\n        return '';\n    }\n\n    out.push(elem.tagName.toLowerCase());\n    if (elem.id) {\n        out.push('#' + elem.id);\n    }\n\n    className = elem.className;\n    if (className && isString(className)) {\n        classes = className.split(/\\s+/);\n        for (i = 0; i < classes.length; i++) {\n            out.push('.' + classes[i]);\n        }\n    }\n    var attrWhitelist = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < attrWhitelist.length; i++) {\n        key = attrWhitelist[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push('[' + key + '=\"' + attr + '\"]');\n        }\n    }\n    return out.join('');\n}\n\n/**\n * Returns true if either a OR b is truthy, but not both\n */\nfunction isOnlyOneTruthy(a, b) {\n    return !!(!!a ^ !!b);\n}\n\n/**\n * Returns true if the two input exception interfaces have the same content\n */\nfunction isSameException(ex1, ex2) {\n    if (isOnlyOneTruthy(ex1, ex2))\n        return false;\n\n    ex1 = ex1.values[0];\n    ex2 = ex2.values[0];\n\n    if (ex1.type !== ex2.type ||\n        ex1.value !== ex2.value)\n        return false;\n\n    return isSameStacktrace(ex1.stacktrace, ex2.stacktrace);\n}\n\n/**\n * Returns true if the two input stack trace interfaces have the same content\n */\nfunction isSameStacktrace(stack1, stack2) {\n    if (isOnlyOneTruthy(stack1, stack2))\n        return false;\n\n    var frames1 = stack1.frames;\n    var frames2 = stack2.frames;\n\n    // Exit early if frame count differs\n    if (frames1.length !== frames2.length)\n        return false;\n\n    // Iterate through every frame; bail out if anything differs\n    var a, b;\n    for (var i = 0; i < frames1.length; i++) {\n        a = frames1[i];\n        b = frames2[i];\n        if (a.filename !== b.filename ||\n            a.lineno !== b.lineno ||\n            a.colno !== b.colno ||\n            a['function'] !== b['function'])\n            return false;\n    }\n    return true;\n}\n\n/**\n * Polyfill a method\n * @param obj object e.g. `document`\n * @param name method name present on object e.g. `addEventListener`\n * @param replacement replacement function\n * @param track {optional} record instrumentation to an array\n */\nfunction fill(obj, name, replacement, track) {\n    var orig = obj[name];\n    obj[name] = replacement(orig);\n    if (track) {\n        track.push([obj, name, orig]);\n    }\n}\n\nif (typeof __DEV__ !== 'undefined' && __DEV__) {\n    Raven.utils = {\n        isUndefined: isUndefined,\n        isFunction: isFunction,\n        isString: isString,\n        isObject: isObject,\n        isEmptyObject: isEmptyObject,\n        isError: isError,\n        each: each,\n        objectMerge: objectMerge,\n        truncate: truncate,\n        hasKey: hasKey,\n        joinRegExp: joinRegExp,\n        urlencode: urlencode,\n        uuid4: uuid4,\n        htmlTreeAsString: htmlTreeAsString,\n        htmlElementAsString: htmlElementAsString,\n        parseUrl: parseUrl,\n        fill: fill\n    };\n};\n\n// Deprecations\nRaven.prototype.setUser = Raven.prototype.setUserContext;\nRaven.prototype.setReleaseContext = Raven.prototype.setRelease;\n\nmodule.exports = Raven;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/raven-js/src/raven.js\n// module id = 235\n// module chunks = 1","'use strict';\n\nvar utils = require('../../src/utils');\n\n/*\n TraceKit - Cross brower stack traces\n\n This was originally forked from github.com/occ/TraceKit, but has since been\n largely re-written and is now maintained as part of raven-js.  Tests for\n this are in test/vendor.\n\n MIT license\n*/\n\nvar TraceKit = {\n    collectWindowErrors: true,\n    debug: false\n};\n\n// This is to be defensive in environments where window does not exist (see https://github.com/getsentry/raven-js/pull/785)\nvar _window = typeof window !== 'undefined' ? window\n            : typeof global !== 'undefined' ? global\n            : typeof self !== 'undefined' ? self\n            : {};\n\n// global reference to slice\nvar _slice = [].slice;\nvar UNKNOWN_FUNCTION = '?';\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\nvar ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;\n\nfunction getLocationHref() {\n    if (typeof document === 'undefined' || typeof document.location === 'undefined')\n        return '';\n\n    return document.location.href;\n}\n\n\n/**\n * TraceKit.report: cross-browser processing of unhandled exceptions\n *\n * Syntax:\n *   TraceKit.report.subscribe(function(stackInfo) { ... })\n *   TraceKit.report.unsubscribe(function(stackInfo) { ... })\n *   TraceKit.report(exception)\n *   try { ...code... } catch(ex) { TraceKit.report(ex); }\n *\n * Supports:\n *   - Firefox: full stack trace with line numbers, plus column number\n *              on top frame; column number is not guaranteed\n *   - Opera:   full stack trace with line and column numbers\n *   - Chrome:  full stack trace with line and column numbers\n *   - Safari:  line and column number for the top frame only; some frames\n *              may be missing, and column number is not guaranteed\n *   - IE:      line and column number for the top frame only; some frames\n *              may be missing, and column number is not guaranteed\n *\n * In theory, TraceKit should work on all of the following versions:\n *   - IE5.5+ (only 8.0 tested)\n *   - Firefox 0.9+ (only 3.5+ tested)\n *   - Opera 7+ (only 10.50 tested; versions 9 and earlier may require\n *     Exceptions Have Stacktrace to be enabled in opera:config)\n *   - Safari 3+ (only 4+ tested)\n *   - Chrome 1+ (only 5+ tested)\n *   - Konqueror 3.5+ (untested)\n *\n * Requires TraceKit.computeStackTrace.\n *\n * Tries to catch all unhandled exceptions and report them to the\n * subscribed handlers. Please note that TraceKit.report will rethrow the\n * exception. This is REQUIRED in order to get a useful stack trace in IE.\n * If the exception does not reach the top of the browser, you will only\n * get a stack trace from the point where TraceKit.report was called.\n *\n * Handlers receive a stackInfo object as described in the\n * TraceKit.computeStackTrace docs.\n */\nTraceKit.report = (function reportModuleWrapper() {\n    var handlers = [],\n        lastArgs = null,\n        lastException = null,\n        lastExceptionStack = null;\n\n    /**\n     * Add a crash handler.\n     * @param {Function} handler\n     */\n    function subscribe(handler) {\n        installGlobalHandler();\n        handlers.push(handler);\n    }\n\n    /**\n     * Remove a crash handler.\n     * @param {Function} handler\n     */\n    function unsubscribe(handler) {\n        for (var i = handlers.length - 1; i >= 0; --i) {\n            if (handlers[i] === handler) {\n                handlers.splice(i, 1);\n            }\n        }\n    }\n\n    /**\n     * Remove all crash handlers.\n     */\n    function unsubscribeAll() {\n        uninstallGlobalHandler();\n        handlers = [];\n    }\n\n    /**\n     * Dispatch stack information to all handlers.\n     * @param {Object.<string, *>} stack\n     */\n    function notifyHandlers(stack, isWindowError) {\n        var exception = null;\n        if (isWindowError && !TraceKit.collectWindowErrors) {\n          return;\n        }\n        for (var i in handlers) {\n            if (handlers.hasOwnProperty(i)) {\n                try {\n                    handlers[i].apply(null, [stack].concat(_slice.call(arguments, 2)));\n                } catch (inner) {\n                    exception = inner;\n                }\n            }\n        }\n\n        if (exception) {\n            throw exception;\n        }\n    }\n\n    var _oldOnerrorHandler, _onErrorHandlerInstalled;\n\n    /**\n     * Ensures all global unhandled exceptions are recorded.\n     * Supported by Gecko and IE.\n     * @param {string} message Error message.\n     * @param {string} url URL of script that generated the exception.\n     * @param {(number|string)} lineNo The line number at which the error\n     * occurred.\n     * @param {?(number|string)} colNo The column number at which the error\n     * occurred.\n     * @param {?Error} ex The actual Error object.\n     */\n    function traceKitWindowOnError(message, url, lineNo, colNo, ex) {\n        var stack = null;\n\n        if (lastExceptionStack) {\n            TraceKit.computeStackTrace.augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);\n            processLastException();\n        } else if (ex && utils.isError(ex)) {\n            // non-string `ex` arg; attempt to extract stack trace\n\n            // New chrome and blink send along a real error object\n            // Let's just report that like a normal error.\n            // See: https://mikewest.org/2013/08/debugging-runtime-errors-with-window-onerror\n            stack = TraceKit.computeStackTrace(ex);\n            notifyHandlers(stack, true);\n        } else {\n            var location = {\n                'url': url,\n                'line': lineNo,\n                'column': colNo\n            };\n\n            var name = undefined;\n            var msg = message; // must be new var or will modify original `arguments`\n            var groups;\n            if ({}.toString.call(message) === '[object String]') {\n                var groups = message.match(ERROR_TYPES_RE);\n                if (groups) {\n                    name = groups[1];\n                    msg = groups[2];\n                }\n            }\n\n            location.func = UNKNOWN_FUNCTION;\n\n            stack = {\n                'name': name,\n                'message': msg,\n                'url': getLocationHref(),\n                'stack': [location]\n            };\n            notifyHandlers(stack, true);\n        }\n\n        if (_oldOnerrorHandler) {\n            return _oldOnerrorHandler.apply(this, arguments);\n        }\n\n        return false;\n    }\n\n    function installGlobalHandler ()\n    {\n        if (_onErrorHandlerInstalled) {\n            return;\n        }\n        _oldOnerrorHandler = _window.onerror;\n        _window.onerror = traceKitWindowOnError;\n        _onErrorHandlerInstalled = true;\n    }\n\n    function uninstallGlobalHandler ()\n    {\n        if (!_onErrorHandlerInstalled) {\n            return;\n        }\n        _window.onerror = _oldOnerrorHandler;\n        _onErrorHandlerInstalled = false;\n        _oldOnerrorHandler = undefined;\n    }\n\n    function processLastException() {\n        var _lastExceptionStack = lastExceptionStack,\n            _lastArgs = lastArgs;\n        lastArgs = null;\n        lastExceptionStack = null;\n        lastException = null;\n        notifyHandlers.apply(null, [_lastExceptionStack, false].concat(_lastArgs));\n    }\n\n    /**\n     * Reports an unhandled Error to TraceKit.\n     * @param {Error} ex\n     * @param {?boolean} rethrow If false, do not re-throw the exception.\n     * Only used for window.onerror to not cause an infinite loop of\n     * rethrowing.\n     */\n    function report(ex, rethrow) {\n        var args = _slice.call(arguments, 1);\n        if (lastExceptionStack) {\n            if (lastException === ex) {\n                return; // already caught by an inner catch block, ignore\n            } else {\n              processLastException();\n            }\n        }\n\n        var stack = TraceKit.computeStackTrace(ex);\n        lastExceptionStack = stack;\n        lastException = ex;\n        lastArgs = args;\n\n        // If the stack trace is incomplete, wait for 2 seconds for\n        // slow slow IE to see if onerror occurs or not before reporting\n        // this exception; otherwise, we will end up with an incomplete\n        // stack trace\n        setTimeout(function () {\n            if (lastException === ex) {\n                processLastException();\n            }\n        }, (stack.incomplete ? 2000 : 0));\n\n        if (rethrow !== false) {\n            throw ex; // re-throw to propagate to the top level (and cause window.onerror)\n        }\n    }\n\n    report.subscribe = subscribe;\n    report.unsubscribe = unsubscribe;\n    report.uninstall = unsubscribeAll;\n    return report;\n}());\n\n/**\n * TraceKit.computeStackTrace: cross-browser stack traces in JavaScript\n *\n * Syntax:\n *   s = TraceKit.computeStackTrace(exception) // consider using TraceKit.report instead (see below)\n * Returns:\n *   s.name              - exception name\n *   s.message           - exception message\n *   s.stack[i].url      - JavaScript or HTML file URL\n *   s.stack[i].func     - function name, or empty for anonymous functions (if guessing did not work)\n *   s.stack[i].args     - arguments passed to the function, if known\n *   s.stack[i].line     - line number, if known\n *   s.stack[i].column   - column number, if known\n *\n * Supports:\n *   - Firefox:  full stack trace with line numbers and unreliable column\n *               number on top frame\n *   - Opera 10: full stack trace with line and column numbers\n *   - Opera 9-: full stack trace with line numbers\n *   - Chrome:   full stack trace with line and column numbers\n *   - Safari:   line and column number for the topmost stacktrace element\n *               only\n *   - IE:       no line numbers whatsoever\n *\n * Tries to guess names of anonymous functions by looking for assignments\n * in the source code. In IE and Safari, we have to guess source file names\n * by searching for function bodies inside all page scripts. This will not\n * work for scripts that are loaded cross-domain.\n * Here be dragons: some function names may be guessed incorrectly, and\n * duplicate functions may be mismatched.\n *\n * TraceKit.computeStackTrace should only be used for tracing purposes.\n * Logging of unhandled exceptions should be done with TraceKit.report,\n * which builds on top of TraceKit.computeStackTrace and provides better\n * IE support by utilizing the window.onerror event to retrieve information\n * about the top of the stack.\n *\n * Note: In IE and Safari, no stack trace is recorded on the Error object,\n * so computeStackTrace instead walks its *own* chain of callers.\n * This means that:\n *  * in Safari, some methods may be missing from the stack trace;\n *  * in IE, the topmost function in the stack trace will always be the\n *    caller of computeStackTrace.\n *\n * This is okay for tracing (because you are likely to be calling\n * computeStackTrace from the function you want to be the topmost element\n * of the stack trace anyway), but not okay for logging unhandled\n * exceptions (because your catch block will likely be far away from the\n * inner function that actually caused the exception).\n *\n */\nTraceKit.computeStackTrace = (function computeStackTraceWrapper() {\n    // Contents of Exception in various browsers.\n    //\n    // SAFARI:\n    // ex.message = Can't find variable: qq\n    // ex.line = 59\n    // ex.sourceId = 580238192\n    // ex.sourceURL = http://...\n    // ex.expressionBeginOffset = 96\n    // ex.expressionCaretOffset = 98\n    // ex.expressionEndOffset = 98\n    // ex.name = ReferenceError\n    //\n    // FIREFOX:\n    // ex.message = qq is not defined\n    // ex.fileName = http://...\n    // ex.lineNumber = 59\n    // ex.columnNumber = 69\n    // ex.stack = ...stack trace... (see the example below)\n    // ex.name = ReferenceError\n    //\n    // CHROME:\n    // ex.message = qq is not defined\n    // ex.name = ReferenceError\n    // ex.type = not_defined\n    // ex.arguments = ['aa']\n    // ex.stack = ...stack trace...\n    //\n    // INTERNET EXPLORER:\n    // ex.message = ...\n    // ex.name = ReferenceError\n    //\n    // OPERA:\n    // ex.message = ...message... (see the example below)\n    // ex.name = ReferenceError\n    // ex.opera#sourceloc = 11  (pretty much useless, duplicates the info in ex.message)\n    // ex.stacktrace = n/a; see 'opera:config#UserPrefs|Exceptions Have Stacktrace'\n\n    /**\n     * Computes stack trace information from the stack property.\n     * Chrome and Gecko use this property.\n     * @param {Error} ex\n     * @return {?Object.<string, *>} Stack trace information.\n     */\n    function computeStackTraceFromStackProp(ex) {\n        if (typeof ex.stack === 'undefined' || !ex.stack) return;\n\n        var chrome = /^\\s*at (.*?) ?\\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i,\n            gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i,\n            winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i,\n\n            // Used to additionally parse URL/line/column from eval frames\n            geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i,\n            chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/,\n\n            lines = ex.stack.split('\\n'),\n            stack = [],\n            submatch,\n            parts,\n            element,\n            reference = /^(.*) is undefined$/.exec(ex.message);\n\n        for (var i = 0, j = lines.length; i < j; ++i) {\n            if ((parts = chrome.exec(lines[i]))) {\n                var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n                var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n                if (isEval && (submatch = chromeEval.exec(parts[2]))) {\n                    // throw out eval line/column and use top-most line/column number\n                    parts[2] = submatch[1]; // url\n                    parts[3] = submatch[2]; // line\n                    parts[4] = submatch[3]; // column\n                }\n                element = {\n                    'url': !isNative ? parts[2] : null,\n                    'func': parts[1] || UNKNOWN_FUNCTION,\n                    'args': isNative ? [parts[2]] : [],\n                    'line': parts[3] ? +parts[3] : null,\n                    'column': parts[4] ? +parts[4] : null\n                };\n            } else if ( parts = winjs.exec(lines[i]) ) {\n                element = {\n                    'url': parts[2],\n                    'func': parts[1] || UNKNOWN_FUNCTION,\n                    'args': [],\n                    'line': +parts[3],\n                    'column': parts[4] ? +parts[4] : null\n                };\n            } else if ((parts = gecko.exec(lines[i]))) {\n                var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n                if (isEval && (submatch = geckoEval.exec(parts[3]))) {\n                    // throw out eval line/column and use top-most line number\n                    parts[3] = submatch[1];\n                    parts[4] = submatch[2];\n                    parts[5] = null; // no column when eval\n                } else if (i === 0 && !parts[5] && typeof ex.columnNumber !== 'undefined') {\n                    // FireFox uses this awesome columnNumber property for its top frame\n                    // Also note, Firefox's column number is 0-based and everything else expects 1-based,\n                    // so adding 1\n                    // NOTE: this hack doesn't work if top-most frame is eval\n                    stack[0].column = ex.columnNumber + 1;\n                }\n                element = {\n                    'url': parts[3],\n                    'func': parts[1] || UNKNOWN_FUNCTION,\n                    'args': parts[2] ? parts[2].split(',') : [],\n                    'line': parts[4] ? +parts[4] : null,\n                    'column': parts[5] ? +parts[5] : null\n                };\n            } else {\n                continue;\n            }\n\n            if (!element.func && element.line) {\n                element.func = UNKNOWN_FUNCTION;\n            }\n\n            stack.push(element);\n        }\n\n        if (!stack.length) {\n            return null;\n        }\n\n        return {\n            'name': ex.name,\n            'message': ex.message,\n            'url': getLocationHref(),\n            'stack': stack\n        };\n    }\n\n    /**\n     * Adds information about the first frame to incomplete stack traces.\n     * Safari and IE require this to get complete data on the first frame.\n     * @param {Object.<string, *>} stackInfo Stack trace information from\n     * one of the compute* methods.\n     * @param {string} url The URL of the script that caused an error.\n     * @param {(number|string)} lineNo The line number of the script that\n     * caused an error.\n     * @param {string=} message The error generated by the browser, which\n     * hopefully contains the name of the object that caused the error.\n     * @return {boolean} Whether or not the stack information was\n     * augmented.\n     */\n    function augmentStackTraceWithInitialElement(stackInfo, url, lineNo, message) {\n        var initial = {\n            'url': url,\n            'line': lineNo\n        };\n\n        if (initial.url && initial.line) {\n            stackInfo.incomplete = false;\n\n            if (!initial.func) {\n                initial.func = UNKNOWN_FUNCTION;\n            }\n\n            if (stackInfo.stack.length > 0) {\n                if (stackInfo.stack[0].url === initial.url) {\n                    if (stackInfo.stack[0].line === initial.line) {\n                        return false; // already in stack trace\n                    } else if (!stackInfo.stack[0].line && stackInfo.stack[0].func === initial.func) {\n                        stackInfo.stack[0].line = initial.line;\n                        return false;\n                    }\n                }\n            }\n\n            stackInfo.stack.unshift(initial);\n            stackInfo.partial = true;\n            return true;\n        } else {\n            stackInfo.incomplete = true;\n        }\n\n        return false;\n    }\n\n    /**\n     * Computes stack trace information by walking the arguments.caller\n     * chain at the time the exception occurred. This will cause earlier\n     * frames to be missed but is the only way to get any stack trace in\n     * Safari and IE. The top frame is restored by\n     * {@link augmentStackTraceWithInitialElement}.\n     * @param {Error} ex\n     * @return {?Object.<string, *>} Stack trace information.\n     */\n    function computeStackTraceByWalkingCallerChain(ex, depth) {\n        var functionName = /function\\s+([_$a-zA-Z\\xA0-\\uFFFF][_$a-zA-Z0-9\\xA0-\\uFFFF]*)?\\s*\\(/i,\n            stack = [],\n            funcs = {},\n            recursion = false,\n            parts,\n            item,\n            source;\n\n        for (var curr = computeStackTraceByWalkingCallerChain.caller; curr && !recursion; curr = curr.caller) {\n            if (curr === computeStackTrace || curr === TraceKit.report) {\n                // console.log('skipping internal function');\n                continue;\n            }\n\n            item = {\n                'url': null,\n                'func': UNKNOWN_FUNCTION,\n                'line': null,\n                'column': null\n            };\n\n            if (curr.name) {\n                item.func = curr.name;\n            } else if ((parts = functionName.exec(curr.toString()))) {\n                item.func = parts[1];\n            }\n\n            if (typeof item.func === 'undefined') {\n              try {\n                item.func = parts.input.substring(0, parts.input.indexOf('{'));\n              } catch (e) { }\n            }\n\n            if (funcs['' + curr]) {\n                recursion = true;\n            }else{\n                funcs['' + curr] = true;\n            }\n\n            stack.push(item);\n        }\n\n        if (depth) {\n            // console.log('depth is ' + depth);\n            // console.log('stack is ' + stack.length);\n            stack.splice(0, depth);\n        }\n\n        var result = {\n            'name': ex.name,\n            'message': ex.message,\n            'url': getLocationHref(),\n            'stack': stack\n        };\n        augmentStackTraceWithInitialElement(result, ex.sourceURL || ex.fileName, ex.line || ex.lineNumber, ex.message || ex.description);\n        return result;\n    }\n\n    /**\n     * Computes a stack trace for an exception.\n     * @param {Error} ex\n     * @param {(string|number)=} depth\n     */\n    function computeStackTrace(ex, depth) {\n        var stack = null;\n        depth = (depth == null ? 0 : +depth);\n\n        try {\n            stack = computeStackTraceFromStackProp(ex);\n            if (stack) {\n                return stack;\n            }\n        } catch (e) {\n            if (TraceKit.debug) {\n                throw e;\n            }\n        }\n\n        try {\n            stack = computeStackTraceByWalkingCallerChain(ex, depth + 1);\n            if (stack) {\n                return stack;\n            }\n        } catch (e) {\n            if (TraceKit.debug) {\n                throw e;\n            }\n        }\n        return {\n            'name': ex.name,\n            'message': ex.message,\n            'url': getLocationHref()\n        };\n    }\n\n    computeStackTrace.augmentStackTraceWithInitialElement = augmentStackTraceWithInitialElement;\n    computeStackTrace.computeStackTraceFromStackProp = computeStackTraceFromStackProp;\n\n    return computeStackTrace;\n}());\n\nmodule.exports = TraceKit;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/raven-js/vendor/TraceKit/tracekit.js\n// module id = 236\n// module chunks = 1","'use strict';\n\n/*\n json-stringify-safe\n Like JSON.stringify, but doesn't throw on circular references.\n\n Originally forked from https://github.com/isaacs/json-stringify-safe\n version 5.0.1 on 3/8/2017 and modified for IE8 compatibility.\n Tests for this are in test/vendor.\n\n ISC license: https://github.com/isaacs/json-stringify-safe/blob/master/LICENSE\n*/\n\nexports = module.exports = stringify\nexports.getSerialize = serializer\n\nfunction indexOf(haystack, needle) {\n  for (var i = 0; i < haystack.length; ++i) {\n    if (haystack[i] === needle) return i;\n  }\n  return -1;\n}\n\nfunction stringify(obj, replacer, spaces, cycleReplacer) {\n  return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces)\n}\n\nfunction serializer(replacer, cycleReplacer) {\n  var stack = [], keys = []\n\n  if (cycleReplacer == null) cycleReplacer = function(key, value) {\n    if (stack[0] === value) return '[Circular ~]'\n    return '[Circular ~.' + keys.slice(0, indexOf(stack, value)).join('.') + ']'\n  }\n\n  return function(key, value) {\n    if (stack.length > 0) {\n      var thisPos = indexOf(stack, this);\n      ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)\n      ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)\n      if (~indexOf(stack, value)) value = cycleReplacer.call(this, key, value)\n    }\n    else stack.push(value)\n\n    return replacer == null ? value : replacer.call(this, key, value)\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/raven-js/vendor/json-stringify-safe/stringify.js\n// module id = 237\n// module chunks = 1","'use strict';\n\nfunction RavenConfigError(message) {\n    this.name = 'RavenConfigError';\n    this.message = message;\n}\nRavenConfigError.prototype = new Error();\nRavenConfigError.prototype.constructor = RavenConfigError;\n\nmodule.exports = RavenConfigError;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/raven-js/src/configError.js\n// module id = 238\n// module chunks = 1","'use strict';\n\nvar wrapMethod = function(console, level, callback) {\n    var originalConsoleLevel = console[level];\n    var originalConsole = console;\n\n    if (!(level in console)) {\n        return;\n    }\n\n    var sentryLevel = level === 'warn'\n        ? 'warning'\n        : level;\n\n    console[level] = function () {\n        var args = [].slice.call(arguments);\n\n        var msg = '' + args.join(' ');\n        var data = {level: sentryLevel, logger: 'console', extra: {'arguments': args}};\n        callback && callback(msg, data);\n\n        // this fails for some browsers. :(\n        if (originalConsoleLevel) {\n            // IE9 doesn't allow calling apply on console functions directly\n            // See: https://stackoverflow.com/questions/5472938/does-ie9-support-console-log-and-is-it-a-real-function#answer-5473193\n            Function.prototype.apply.call(\n                originalConsoleLevel,\n                originalConsole,\n                args\n            );\n        }\n    };\n};\n\nmodule.exports = {\n    wrapMethod: wrapMethod\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/raven-js/src/console.js\n// module id = 239\n// module chunks = 1","var map = {\n\t\"./ru\": 100,\n\t\"./ru.js\": 100\n};\nfunction webpackContext(req) {\n\treturn __webpack_require__(webpackContextResolve(req));\n};\nfunction webpackContextResolve(req) {\n\tvar id = map[req];\n\tif(!(id + 1)) // check for number or string\n\t\tthrow new Error(\"Cannot find module '\" + req + \"'.\");\n\treturn id;\n};\nwebpackContext.keys = function webpackContextKeys() {\n\treturn Object.keys(map);\n};\nwebpackContext.resolve = webpackContextResolve;\nmodule.exports = webpackContext;\nwebpackContext.id = 240;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/moment/locale ru\n// module id = 240\n// module chunks = 1","\n/**\n * Expose `Emitter`.\n */\n\nif (typeof module !== 'undefined') {\n  module.exports = Emitter;\n}\n\n/**\n * Initialize a new `Emitter`.\n *\n * @api public\n */\n\nfunction Emitter(obj) {\n  if (obj) return mixin(obj);\n};\n\n/**\n * Mixin the emitter properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in Emitter.prototype) {\n    obj[key] = Emitter.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Listen on the given `event` with `fn`.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.on =\nEmitter.prototype.addEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\n    .push(fn);\n  return this;\n};\n\n/**\n * Adds an `event` listener that will be invoked a single\n * time then automatically removed.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.once = function(event, fn){\n  function on() {\n    this.off(event, on);\n    fn.apply(this, arguments);\n  }\n\n  on.fn = fn;\n  this.on(event, on);\n  return this;\n};\n\n/**\n * Remove the given callback for `event` or all\n * registered callbacks.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.off =\nEmitter.prototype.removeListener =\nEmitter.prototype.removeAllListeners =\nEmitter.prototype.removeEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n\n  // all\n  if (0 == arguments.length) {\n    this._callbacks = {};\n    return this;\n  }\n\n  // specific event\n  var callbacks = this._callbacks['$' + event];\n  if (!callbacks) return this;\n\n  // remove all handlers\n  if (1 == arguments.length) {\n    delete this._callbacks['$' + event];\n    return this;\n  }\n\n  // remove specific handler\n  var cb;\n  for (var i = 0; i < callbacks.length; i++) {\n    cb = callbacks[i];\n    if (cb === fn || cb.fn === fn) {\n      callbacks.splice(i, 1);\n      break;\n    }\n  }\n\n  // Remove event specific arrays for event types that no\n  // one is subscribed for to avoid memory leak.\n  if (callbacks.length === 0) {\n    delete this._callbacks['$' + event];\n  }\n\n  return this;\n};\n\n/**\n * Emit `event` with the given args.\n *\n * @param {String} event\n * @param {Mixed} ...\n * @return {Emitter}\n */\n\nEmitter.prototype.emit = function(event){\n  this._callbacks = this._callbacks || {};\n\n  var args = new Array(arguments.length - 1)\n    , callbacks = this._callbacks['$' + event];\n\n  for (var i = 1; i < arguments.length; i++) {\n    args[i - 1] = arguments[i];\n  }\n\n  if (callbacks) {\n    callbacks = callbacks.slice(0);\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\n      callbacks[i].apply(this, args);\n    }\n  }\n\n  return this;\n};\n\n/**\n * Return array of callbacks for `event`.\n *\n * @param {String} event\n * @return {Array}\n * @api public\n */\n\nEmitter.prototype.listeners = function(event){\n  this._callbacks = this._callbacks || {};\n  return this._callbacks['$' + event] || [];\n};\n\n/**\n * Check if this emitter has `event` handlers.\n *\n * @param {String} event\n * @return {Boolean}\n * @api public\n */\n\nEmitter.prototype.hasListeners = function(event){\n  return !! this.listeners(event).length;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/component-emitter/index.js\n// module id = 241\n// module chunks = 1","/**\n * Module of mixed-in functions shared between node and client code\n */\nvar isObject = require('./is-object');\n\n/**\n * Expose `RequestBase`.\n */\n\nmodule.exports = RequestBase;\n\n/**\n * Initialize a new `RequestBase`.\n *\n * @api public\n */\n\nfunction RequestBase(obj) {\n  if (obj) return mixin(obj);\n}\n\n/**\n * Mixin the prototype properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in RequestBase.prototype) {\n    obj[key] = RequestBase.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Clear previous timeout.\n *\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.clearTimeout = function _clearTimeout(){\n  clearTimeout(this._timer);\n  clearTimeout(this._responseTimeoutTimer);\n  delete this._timer;\n  delete this._responseTimeoutTimer;\n  return this;\n};\n\n/**\n * Override default response body parser\n *\n * This function will be called to convert incoming data into request.body\n *\n * @param {Function}\n * @api public\n */\n\nRequestBase.prototype.parse = function parse(fn){\n  this._parser = fn;\n  return this;\n};\n\n/**\n * Set format of binary response body.\n * In browser valid formats are 'blob' and 'arraybuffer',\n * which return Blob and ArrayBuffer, respectively.\n *\n * In Node all values result in Buffer.\n *\n * Examples:\n *\n *      req.get('/')\n *        .responseType('blob')\n *        .end(callback);\n *\n * @param {String} val\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.responseType = function(val){\n  this._responseType = val;\n  return this;\n};\n\n/**\n * Override default request body serializer\n *\n * This function will be called to convert data set via .send or .attach into payload to send\n *\n * @param {Function}\n * @api public\n */\n\nRequestBase.prototype.serialize = function serialize(fn){\n  this._serializer = fn;\n  return this;\n};\n\n/**\n * Set timeouts.\n *\n * - response timeout is time between sending request and receiving the first byte of the response. Includes DNS and connection time.\n * - deadline is the time from start of the request to receiving response body in full. If the deadline is too short large files may not load at all on slow connections.\n *\n * Value of 0 or false means no timeout.\n *\n * @param {Number|Object} ms or {response, read, deadline}\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.timeout = function timeout(options){\n  if (!options || 'object' !== typeof options) {\n    this._timeout = options;\n    this._responseTimeout = 0;\n    return this;\n  }\n\n  for(var option in options) {\n    switch(option) {\n      case 'deadline':\n        this._timeout = options.deadline;\n        break;\n      case 'response':\n        this._responseTimeout = options.response;\n        break;\n      default:\n        console.warn(\"Unknown timeout option\", option);\n    }\n  }\n  return this;\n};\n\n/**\n * Set number of retry attempts on error.\n *\n * Failed requests will be retried 'count' times if timeout or err.code >= 500.\n *\n * @param {Number} count\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.retry = function retry(count){\n  // Default to 1 if no count passed or true\n  if (arguments.length === 0 || count === true) count = 1;\n  if (count <= 0) count = 0;\n  this._maxRetries = count;\n  this._retries = 0;\n  return this;\n};\n\n/**\n * Retry request\n *\n * @return {Request} for chaining\n * @api private\n */\n\nRequestBase.prototype._retry = function() {\n  this.clearTimeout();\n\n  // node\n  if (this.req) {\n    this.req = null;\n    this.req = this.request();\n  }\n\n  this._aborted = false;\n  this.timedout = false;\n\n  return this._end();\n};\n\n/**\n * Promise support\n *\n * @param {Function} resolve\n * @param {Function} [reject]\n * @return {Request}\n */\n\nRequestBase.prototype.then = function then(resolve, reject) {\n  if (!this._fullfilledPromise) {\n    var self = this;\n    if (this._endCalled) {\n      console.warn(\"Warning: superagent request was sent twice, because both .end() and .then() were called. Never call .end() if you use promises\");\n    }\n    this._fullfilledPromise = new Promise(function(innerResolve, innerReject){\n      self.end(function(err, res){\n        if (err) innerReject(err); else innerResolve(res);\n      });\n    });\n  }\n  return this._fullfilledPromise.then(resolve, reject);\n}\n\nRequestBase.prototype.catch = function(cb) {\n  return this.then(undefined, cb);\n};\n\n/**\n * Allow for extension\n */\n\nRequestBase.prototype.use = function use(fn) {\n  fn(this);\n  return this;\n}\n\nRequestBase.prototype.ok = function(cb) {\n  if ('function' !== typeof cb) throw Error(\"Callback required\");\n  this._okCallback = cb;\n  return this;\n};\n\nRequestBase.prototype._isResponseOK = function(res) {\n  if (!res) {\n    return false;\n  }\n\n  if (this._okCallback) {\n    return this._okCallback(res);\n  }\n\n  return res.status >= 200 && res.status < 300;\n};\n\n\n/**\n * Get request header `field`.\n * Case-insensitive.\n *\n * @param {String} field\n * @return {String}\n * @api public\n */\n\nRequestBase.prototype.get = function(field){\n  return this._header[field.toLowerCase()];\n};\n\n/**\n * Get case-insensitive header `field` value.\n * This is a deprecated internal API. Use `.get(field)` instead.\n *\n * (getHeader is no longer used internally by the superagent code base)\n *\n * @param {String} field\n * @return {String}\n * @api private\n * @deprecated\n */\n\nRequestBase.prototype.getHeader = RequestBase.prototype.get;\n\n/**\n * Set header `field` to `val`, or multiple fields with one object.\n * Case-insensitive.\n *\n * Examples:\n *\n *      req.get('/')\n *        .set('Accept', 'application/json')\n *        .set('X-API-Key', 'foobar')\n *        .end(callback);\n *\n *      req.get('/')\n *        .set({ Accept: 'application/json', 'X-API-Key': 'foobar' })\n *        .end(callback);\n *\n * @param {String|Object} field\n * @param {String} val\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.set = function(field, val){\n  if (isObject(field)) {\n    for (var key in field) {\n      this.set(key, field[key]);\n    }\n    return this;\n  }\n  this._header[field.toLowerCase()] = val;\n  this.header[field] = val;\n  return this;\n};\n\n/**\n * Remove header `field`.\n * Case-insensitive.\n *\n * Example:\n *\n *      req.get('/')\n *        .unset('User-Agent')\n *        .end(callback);\n *\n * @param {String} field\n */\nRequestBase.prototype.unset = function(field){\n  delete this._header[field.toLowerCase()];\n  delete this.header[field];\n  return this;\n};\n\n/**\n * Write the field `name` and `val`, or multiple fields with one object\n * for \"multipart/form-data\" request bodies.\n *\n * ``` js\n * request.post('/upload')\n *   .field('foo', 'bar')\n *   .end(callback);\n *\n * request.post('/upload')\n *   .field({ foo: 'bar', baz: 'qux' })\n *   .end(callback);\n * ```\n *\n * @param {String|Object} name\n * @param {String|Blob|File|Buffer|fs.ReadStream} val\n * @return {Request} for chaining\n * @api public\n */\nRequestBase.prototype.field = function(name, val) {\n\n  // name should be either a string or an object.\n  if (null === name ||  undefined === name) {\n    throw new Error('.field(name, val) name can not be empty');\n  }\n\n  if (this._data) {\n    console.error(\".field() can't be used if .send() is used. Please use only .send() or only .field() & .attach()\");\n  }\n\n  if (isObject(name)) {\n    for (var key in name) {\n      this.field(key, name[key]);\n    }\n    return this;\n  }\n\n  if (Array.isArray(val)) {\n    for (var i in val) {\n      this.field(name, val[i]);\n    }\n    return this;\n  }\n\n  // val should be defined now\n  if (null === val || undefined === val) {\n    throw new Error('.field(name, val) val can not be empty');\n  }\n  if ('boolean' === typeof val) {\n    val = '' + val;\n  }\n  this._getFormData().append(name, val);\n  return this;\n};\n\n/**\n * Abort the request, and clear potential timeout.\n *\n * @return {Request}\n * @api public\n */\nRequestBase.prototype.abort = function(){\n  if (this._aborted) {\n    return this;\n  }\n  this._aborted = true;\n  this.xhr && this.xhr.abort(); // browser\n  this.req && this.req.abort(); // node\n  this.clearTimeout();\n  this.emit('abort');\n  return this;\n};\n\n/**\n * Enable transmission of cookies with x-domain requests.\n *\n * Note that for this to work the origin must not be\n * using \"Access-Control-Allow-Origin\" with a wildcard,\n * and also must set \"Access-Control-Allow-Credentials\"\n * to \"true\".\n *\n * @api public\n */\n\nRequestBase.prototype.withCredentials = function(on){\n  // This is browser-only functionality. Node side is no-op.\n  if(on==undefined) on = true;\n  this._withCredentials = on;\n  return this;\n};\n\n/**\n * Set the max redirects to `n`. Does noting in browser XHR implementation.\n *\n * @param {Number} n\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.redirects = function(n){\n  this._maxRedirects = n;\n  return this;\n};\n\n/**\n * Convert to a plain javascript object (not JSON string) of scalar properties.\n * Note as this method is designed to return a useful non-this value,\n * it cannot be chained.\n *\n * @return {Object} describing method, url, and data of this request\n * @api public\n */\n\nRequestBase.prototype.toJSON = function(){\n  return {\n    method: this.method,\n    url: this.url,\n    data: this._data,\n    headers: this._header\n  };\n};\n\n\n/**\n * Send `data` as the request body, defaulting the `.type()` to \"json\" when\n * an object is given.\n *\n * Examples:\n *\n *       // manual json\n *       request.post('/user')\n *         .type('json')\n *         .send('{\"name\":\"tj\"}')\n *         .end(callback)\n *\n *       // auto json\n *       request.post('/user')\n *         .send({ name: 'tj' })\n *         .end(callback)\n *\n *       // manual x-www-form-urlencoded\n *       request.post('/user')\n *         .type('form')\n *         .send('name=tj')\n *         .end(callback)\n *\n *       // auto x-www-form-urlencoded\n *       request.post('/user')\n *         .type('form')\n *         .send({ name: 'tj' })\n *         .end(callback)\n *\n *       // defaults to x-www-form-urlencoded\n *      request.post('/user')\n *        .send('name=tobi')\n *        .send('species=ferret')\n *        .end(callback)\n *\n * @param {String|Object} data\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.send = function(data){\n  var isObj = isObject(data);\n  var type = this._header['content-type'];\n\n  if (this._formData) {\n    console.error(\".send() can't be used if .attach() or .field() is used. Please use only .send() or only .field() & .attach()\");\n  }\n\n  if (isObj && !this._data) {\n    if (Array.isArray(data)) {\n      this._data = [];\n    } else if (!this._isHost(data)) {\n      this._data = {};\n    }\n  } else if (data && this._data && this._isHost(this._data)) {\n    throw Error(\"Can't merge these send calls\");\n  }\n\n  // merge\n  if (isObj && isObject(this._data)) {\n    for (var key in data) {\n      this._data[key] = data[key];\n    }\n  } else if ('string' == typeof data) {\n    // default to x-www-form-urlencoded\n    if (!type) this.type('form');\n    type = this._header['content-type'];\n    if ('application/x-www-form-urlencoded' == type) {\n      this._data = this._data\n        ? this._data + '&' + data\n        : data;\n    } else {\n      this._data = (this._data || '') + data;\n    }\n  } else {\n    this._data = data;\n  }\n\n  if (!isObj || this._isHost(data)) {\n    return this;\n  }\n\n  // default to json\n  if (!type) this.type('json');\n  return this;\n};\n\n\n/**\n * Sort `querystring` by the sort function\n *\n *\n * Examples:\n *\n *       // default order\n *       request.get('/user')\n *         .query('name=Nick')\n *         .query('search=Manny')\n *         .sortQuery()\n *         .end(callback)\n *\n *       // customized sort function\n *       request.get('/user')\n *         .query('name=Nick')\n *         .query('search=Manny')\n *         .sortQuery(function(a, b){\n *           return a.length - b.length;\n *         })\n *         .end(callback)\n *\n *\n * @param {Function} sort\n * @return {Request} for chaining\n * @api public\n */\n\nRequestBase.prototype.sortQuery = function(sort) {\n  // _sort default to true but otherwise can be a function or boolean\n  this._sort = typeof sort === 'undefined' ? true : sort;\n  return this;\n};\n\n/**\n * Invoke callback with timeout error.\n *\n * @api private\n */\n\nRequestBase.prototype._timeoutError = function(reason, timeout, errno){\n  if (this._aborted) {\n    return;\n  }\n  var err = new Error(reason + timeout + 'ms exceeded');\n  err.timeout = timeout;\n  err.code = 'ECONNABORTED';\n  err.errno = errno;\n  this.timedout = true;\n  this.abort();\n  this.callback(err);\n};\n\nRequestBase.prototype._setTimeouts = function() {\n  var self = this;\n\n  // deadline\n  if (this._timeout && !this._timer) {\n    this._timer = setTimeout(function(){\n      self._timeoutError('Timeout of ', self._timeout, 'ETIME');\n    }, this._timeout);\n  }\n  // response timeout\n  if (this._responseTimeout && !this._responseTimeoutTimer) {\n    this._responseTimeoutTimer = setTimeout(function(){\n      self._timeoutError('Response timeout of ', self._responseTimeout, 'ETIMEDOUT');\n    }, this._responseTimeout);\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/superagent/lib/request-base.js\n// module id = 242\n// module chunks = 1","/**\n * Check if `fn` is a function.\n *\n * @param {Function} fn\n * @return {Boolean}\n * @api private\n */\nvar isObject = require('./is-object');\n\nfunction isFunction(fn) {\n  var tag = isObject(fn) ? Object.prototype.toString.call(fn) : '';\n  return tag === '[object Function]';\n}\n\nmodule.exports = isFunction;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/superagent/lib/is-function.js\n// module id = 243\n// module chunks = 1","\n/**\n * Module dependencies.\n */\n\nvar utils = require('./utils');\n\n/**\n * Expose `ResponseBase`.\n */\n\nmodule.exports = ResponseBase;\n\n/**\n * Initialize a new `ResponseBase`.\n *\n * @api public\n */\n\nfunction ResponseBase(obj) {\n  if (obj) return mixin(obj);\n}\n\n/**\n * Mixin the prototype properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in ResponseBase.prototype) {\n    obj[key] = ResponseBase.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Get case-insensitive `field` value.\n *\n * @param {String} field\n * @return {String}\n * @api public\n */\n\nResponseBase.prototype.get = function(field){\n    return this.header[field.toLowerCase()];\n};\n\n/**\n * Set header related properties:\n *\n *   - `.type` the content type without params\n *\n * A response of \"Content-Type: text/plain; charset=utf-8\"\n * will provide you with a `.type` of \"text/plain\".\n *\n * @param {Object} header\n * @api private\n */\n\nResponseBase.prototype._setHeaderProperties = function(header){\n    // TODO: moar!\n    // TODO: make this a util\n\n    // content-type\n    var ct = header['content-type'] || '';\n    this.type = utils.type(ct);\n\n    // params\n    var params = utils.params(ct);\n    for (var key in params) this[key] = params[key];\n\n    this.links = {};\n\n    // links\n    try {\n        if (header.link) {\n            this.links = utils.parseLinks(header.link);\n        }\n    } catch (err) {\n        // ignore\n    }\n};\n\n/**\n * Set flags such as `.ok` based on `status`.\n *\n * For example a 2xx response will give you a `.ok` of __true__\n * whereas 5xx will be __false__ and `.error` will be __true__. The\n * `.clientError` and `.serverError` are also available to be more\n * specific, and `.statusType` is the class of error ranging from 1..5\n * sometimes useful for mapping respond colors etc.\n *\n * \"sugar\" properties are also defined for common cases. Currently providing:\n *\n *   - .noContent\n *   - .badRequest\n *   - .unauthorized\n *   - .notAcceptable\n *   - .notFound\n *\n * @param {Number} status\n * @api private\n */\n\nResponseBase.prototype._setStatusProperties = function(status){\n    var type = status / 100 | 0;\n\n    // status / class\n    this.status = this.statusCode = status;\n    this.statusType = type;\n\n    // basics\n    this.info = 1 == type;\n    this.ok = 2 == type;\n    this.redirect = 3 == type;\n    this.clientError = 4 == type;\n    this.serverError = 5 == type;\n    this.error = (4 == type || 5 == type)\n        ? this.toError()\n        : false;\n\n    // sugar\n    this.accepted = 202 == status;\n    this.noContent = 204 == status;\n    this.badRequest = 400 == status;\n    this.unauthorized = 401 == status;\n    this.notAcceptable = 406 == status;\n    this.forbidden = 403 == status;\n    this.notFound = 404 == status;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/superagent/lib/response-base.js\n// module id = 244\n// module chunks = 1","\n/**\n * Return the mime type for the given `str`.\n *\n * @param {String} str\n * @return {String}\n * @api private\n */\n\nexports.type = function(str){\n  return str.split(/ *; */).shift();\n};\n\n/**\n * Return header field parameters.\n *\n * @param {String} str\n * @return {Object}\n * @api private\n */\n\nexports.params = function(str){\n  return str.split(/ *; */).reduce(function(obj, str){\n    var parts = str.split(/ *= */);\n    var key = parts.shift();\n    var val = parts.shift();\n\n    if (key && val) obj[key] = val;\n    return obj;\n  }, {});\n};\n\n/**\n * Parse Link header fields.\n *\n * @param {String} str\n * @return {Object}\n * @api private\n */\n\nexports.parseLinks = function(str){\n  return str.split(/ *, */).reduce(function(obj, str){\n    var parts = str.split(/ *; */);\n    var url = parts[0].slice(1, -1);\n    var rel = parts[1].split(/ *= */)[1].slice(1, -1);\n    obj[rel] = url;\n    return obj;\n  }, {});\n};\n\n/**\n * Strip content related fields from `header`.\n *\n * @param {Object} header\n * @return {Object} header\n * @api private\n */\n\nexports.cleanHeader = function(header, shouldStripCookie){\n  delete header['content-type'];\n  delete header['content-length'];\n  delete header['transfer-encoding'];\n  delete header['host'];\n  if (shouldStripCookie) {\n    delete header['cookie'];\n  }\n  return header;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/superagent/lib/utils.js\n// module id = 245\n// module chunks = 1","var ERROR_CODES = [\n  'ECONNRESET',\n  'ETIMEDOUT',\n  'EADDRINFO',\n  'ESOCKETTIMEDOUT'\n];\n\n/**\n * Determine if a request should be retried.\n * (Borrowed from segmentio/superagent-retry)\n *\n * @param {Error} err\n * @param {Response} [res]\n * @returns {Boolean}\n */\nmodule.exports = function shouldRetry(err, res) {\n  if (err && err.code && ~ERROR_CODES.indexOf(err.code)) return true;\n  if (res && res.status && res.status >= 500) return true;\n  // Superagent timeout\n  if (err && 'timeout' in err && err.code == 'ECONNABORTED') return true;\n  if (err && 'crossDomain' in err) return true;\n  return false;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/superagent/lib/should-retry.js\n// module id = 246\n// module chunks = 1","/*!\n * methods\n * Copyright(c) 2013-2014 TJ Holowaychuk\n * Copyright(c) 2015-2016 Douglas Christopher Wilson\n * MIT Licensed\n */\n\n'use strict';\n\n/**\n * Module dependencies.\n * @private\n */\n\nvar http = require('http');\n\n/**\n * Module exports.\n * @public\n */\n\nmodule.exports = getCurrentNodeMethods() || getBasicNodeMethods();\n\n/**\n * Get the current Node.js methods.\n * @private\n */\n\nfunction getCurrentNodeMethods() {\n  return http.METHODS && http.METHODS.map(function lowerCaseMethod(method) {\n    return method.toLowerCase();\n  });\n}\n\n/**\n * Get the \"basic\" Node.js methods, a snapshot from Node.js 0.10.\n * @private\n */\n\nfunction getBasicNodeMethods() {\n  return [\n    'get',\n    'post',\n    'put',\n    'head',\n    'delete',\n    'options',\n    'trace',\n    'copy',\n    'lock',\n    'mkcol',\n    'move',\n    'purge',\n    'propfind',\n    'proppatch',\n    'unlock',\n    'report',\n    'mkactivity',\n    'checkout',\n    'merge',\n    'm-search',\n    'notify',\n    'subscribe',\n    'unsubscribe',\n    'patch',\n    'search',\n    'connect'\n  ];\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/methods/index.js\n// module id = 247\n// module chunks = 1","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/extend/index.js\n// module id = 249\n// module chunks = 1","/*!\n * JavaScript Cookie v2.1.4\n * https://github.com/js-cookie/js-cookie\n *\n * Copyright 2006, 2015 Klaus Hartl & Fagner Brack\n * Released under the MIT license\n */\n;(function (factory) {\n\tvar registeredInModuleLoader = false;\n\tif (typeof define === 'function' && define.amd) {\n\t\tdefine(factory);\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (typeof exports === 'object') {\n\t\tmodule.exports = factory();\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (!registeredInModuleLoader) {\n\t\tvar OldCookies = window.Cookies;\n\t\tvar api = window.Cookies = factory();\n\t\tapi.noConflict = function () {\n\t\t\twindow.Cookies = OldCookies;\n\t\t\treturn api;\n\t\t};\n\t}\n}(function () {\n\tfunction extend () {\n\t\tvar i = 0;\n\t\tvar result = {};\n\t\tfor (; i < arguments.length; i++) {\n\t\t\tvar attributes = arguments[ i ];\n\t\t\tfor (var key in attributes) {\n\t\t\t\tresult[key] = attributes[key];\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\n\tfunction init (converter) {\n\t\tfunction api (key, value, attributes) {\n\t\t\tvar result;\n\t\t\tif (typeof document === 'undefined') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Write\n\n\t\t\tif (arguments.length > 1) {\n\t\t\t\tattributes = extend({\n\t\t\t\t\tpath: '/'\n\t\t\t\t}, api.defaults, attributes);\n\n\t\t\t\tif (typeof attributes.expires === 'number') {\n\t\t\t\t\tvar expires = new Date();\n\t\t\t\t\texpires.setMilliseconds(expires.getMilliseconds() + attributes.expires * 864e+5);\n\t\t\t\t\tattributes.expires = expires;\n\t\t\t\t}\n\n\t\t\t\t// We're using \"expires\" because \"max-age\" is not supported by IE\n\t\t\t\tattributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';\n\n\t\t\t\ttry {\n\t\t\t\t\tresult = JSON.stringify(value);\n\t\t\t\t\tif (/^[\\{\\[]/.test(result)) {\n\t\t\t\t\t\tvalue = result;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\n\t\t\t\tif (!converter.write) {\n\t\t\t\t\tvalue = encodeURIComponent(String(value))\n\t\t\t\t\t\t.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);\n\t\t\t\t} else {\n\t\t\t\t\tvalue = converter.write(value, key);\n\t\t\t\t}\n\n\t\t\t\tkey = encodeURIComponent(String(key));\n\t\t\t\tkey = key.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent);\n\t\t\t\tkey = key.replace(/[\\(\\)]/g, escape);\n\n\t\t\t\tvar stringifiedAttributes = '';\n\n\t\t\t\tfor (var attributeName in attributes) {\n\t\t\t\t\tif (!attributes[attributeName]) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tstringifiedAttributes += '; ' + attributeName;\n\t\t\t\t\tif (attributes[attributeName] === true) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tstringifiedAttributes += '=' + attributes[attributeName];\n\t\t\t\t}\n\t\t\t\treturn (document.cookie = key + '=' + value + stringifiedAttributes);\n\t\t\t}\n\n\t\t\t// Read\n\n\t\t\tif (!key) {\n\t\t\t\tresult = {};\n\t\t\t}\n\n\t\t\t// To prevent the for loop in the first place assign an empty array\n\t\t\t// in case there are no cookies at all. Also prevents odd result when\n\t\t\t// calling \"get()\"\n\t\t\tvar cookies = document.cookie ? document.cookie.split('; ') : [];\n\t\t\tvar rdecode = /(%[0-9A-Z]{2})+/g;\n\t\t\tvar i = 0;\n\n\t\t\tfor (; i < cookies.length; i++) {\n\t\t\t\tvar parts = cookies[i].split('=');\n\t\t\t\tvar cookie = parts.slice(1).join('=');\n\n\t\t\t\tif (cookie.charAt(0) === '\"') {\n\t\t\t\t\tcookie = cookie.slice(1, -1);\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tvar name = parts[0].replace(rdecode, decodeURIComponent);\n\t\t\t\t\tcookie = converter.read ?\n\t\t\t\t\t\tconverter.read(cookie, name) : converter(cookie, name) ||\n\t\t\t\t\t\tcookie.replace(rdecode, decodeURIComponent);\n\n\t\t\t\t\tif (this.json) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tcookie = JSON.parse(cookie);\n\t\t\t\t\t\t} catch (e) {}\n\t\t\t\t\t}\n\n\t\t\t\t\tif (key === name) {\n\t\t\t\t\t\tresult = cookie;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (!key) {\n\t\t\t\t\t\tresult[name] = cookie;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\t\t\t}\n\n\t\t\treturn result;\n\t\t}\n\n\t\tapi.set = api;\n\t\tapi.get = function (key) {\n\t\t\treturn api.call(api, key);\n\t\t};\n\t\tapi.getJSON = function () {\n\t\t\treturn api.apply({\n\t\t\t\tjson: true\n\t\t\t}, [].slice.call(arguments));\n\t\t};\n\t\tapi.defaults = {};\n\n\t\tapi.remove = function (key, attributes) {\n\t\t\tapi(key, '', extend(attributes, {\n\t\t\t\texpires: -1\n\t\t\t}));\n\t\t};\n\n\t\tapi.withConverter = init;\n\n\t\treturn api;\n\t}\n\n\treturn init(function () {});\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/js-cookie/src/js.cookie.js\n// module id = 67\n// module chunks = 1","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match words composed of alphanumeric characters. */\nvar reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n/** Used to match Latin Unicode letters (excluding mathematical operators). */\nvar reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n/** Used to compose unicode character classes. */\nvar rsAstralRange = '\\\\ud800-\\\\udfff',\n    rsComboMarksRange = '\\\\u0300-\\\\u036f\\\\ufe20-\\\\ufe23',\n    rsComboSymbolsRange = '\\\\u20d0-\\\\u20f0',\n    rsDingbatRange = '\\\\u2700-\\\\u27bf',\n    rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n    rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n    rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n    rsPunctuationRange = '\\\\u2000-\\\\u206f',\n    rsSpaceRange = ' \\\\t\\\\x0b\\\\f\\\\xa0\\\\ufeff\\\\n\\\\r\\\\u2028\\\\u2029\\\\u1680\\\\u180e\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200a\\\\u202f\\\\u205f\\\\u3000',\n    rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n    rsVarRange = '\\\\ufe0e\\\\ufe0f',\n    rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n/** Used to compose unicode capture groups. */\nvar rsApos = \"['\\u2019]\",\n    rsAstral = '[' + rsAstralRange + ']',\n    rsBreak = '[' + rsBreakRange + ']',\n    rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',\n    rsDigits = '\\\\d+',\n    rsDingbat = '[' + rsDingbatRange + ']',\n    rsLower = '[' + rsLowerRange + ']',\n    rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n    rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n    rsNonAstral = '[^' + rsAstralRange + ']',\n    rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n    rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n    rsUpper = '[' + rsUpperRange + ']',\n    rsZWJ = '\\\\u200d';\n\n/** Used to compose unicode regexes. */\nvar rsLowerMisc = '(?:' + rsLower + '|' + rsMisc + ')',\n    rsUpperMisc = '(?:' + rsUpper + '|' + rsMisc + ')',\n    rsOptLowerContr = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n    rsOptUpperContr = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n    reOptMod = rsModifier + '?',\n    rsOptVar = '[' + rsVarRange + ']?',\n    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n    rsSeq = rsOptVar + reOptMod + rsOptJoin,\n    rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,\n    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n/** Used to match apostrophes. */\nvar reApos = RegExp(rsApos, 'g');\n\n/**\n * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n */\nvar reComboMark = RegExp(rsCombo, 'g');\n\n/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\nvar reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n/** Used to match complex or compound words. */\nvar reUnicodeWord = RegExp([\n  rsUpper + '?' + rsLower + '+' + rsOptLowerContr + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n  rsUpperMisc + '+' + rsOptUpperContr + '(?=' + [rsBreak, rsUpper + rsLowerMisc, '$'].join('|') + ')',\n  rsUpper + '?' + rsLowerMisc + '+' + rsOptLowerContr,\n  rsUpper + '+' + rsOptUpperContr,\n  rsDigits,\n  rsEmoji\n].join('|'), 'g');\n\n/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\nvar reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');\n\n/** Used to detect strings that need a more robust regexp to match words. */\nvar reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;\n\n/** Used to map Latin Unicode letters to basic Latin letters. */\nvar deburredLetters = {\n  // Latin-1 Supplement block.\n  '\\xc0': 'A',  '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n  '\\xe0': 'a',  '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n  '\\xc7': 'C',  '\\xe7': 'c',\n  '\\xd0': 'D',  '\\xf0': 'd',\n  '\\xc8': 'E',  '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n  '\\xe8': 'e',  '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n  '\\xcc': 'I',  '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n  '\\xec': 'i',  '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n  '\\xd1': 'N',  '\\xf1': 'n',\n  '\\xd2': 'O',  '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n  '\\xf2': 'o',  '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n  '\\xd9': 'U',  '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n  '\\xf9': 'u',  '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n  '\\xdd': 'Y',  '\\xfd': 'y', '\\xff': 'y',\n  '\\xc6': 'Ae', '\\xe6': 'ae',\n  '\\xde': 'Th', '\\xfe': 'th',\n  '\\xdf': 'ss',\n  // Latin Extended-A block.\n  '\\u0100': 'A',  '\\u0102': 'A', '\\u0104': 'A',\n  '\\u0101': 'a',  '\\u0103': 'a', '\\u0105': 'a',\n  '\\u0106': 'C',  '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n  '\\u0107': 'c',  '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n  '\\u010e': 'D',  '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n  '\\u0112': 'E',  '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n  '\\u0113': 'e',  '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n  '\\u011c': 'G',  '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n  '\\u011d': 'g',  '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n  '\\u0124': 'H',  '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n  '\\u0128': 'I',  '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n  '\\u0129': 'i',  '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n  '\\u0134': 'J',  '\\u0135': 'j',\n  '\\u0136': 'K',  '\\u0137': 'k', '\\u0138': 'k',\n  '\\u0139': 'L',  '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n  '\\u013a': 'l',  '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n  '\\u0143': 'N',  '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n  '\\u0144': 'n',  '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n  '\\u014c': 'O',  '\\u014e': 'O', '\\u0150': 'O',\n  '\\u014d': 'o',  '\\u014f': 'o', '\\u0151': 'o',\n  '\\u0154': 'R',  '\\u0156': 'R', '\\u0158': 'R',\n  '\\u0155': 'r',  '\\u0157': 'r', '\\u0159': 'r',\n  '\\u015a': 'S',  '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n  '\\u015b': 's',  '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n  '\\u0162': 'T',  '\\u0164': 'T', '\\u0166': 'T',\n  '\\u0163': 't',  '\\u0165': 't', '\\u0167': 't',\n  '\\u0168': 'U',  '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n  '\\u0169': 'u',  '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n  '\\u0174': 'W',  '\\u0175': 'w',\n  '\\u0176': 'Y',  '\\u0177': 'y', '\\u0178': 'Y',\n  '\\u0179': 'Z',  '\\u017b': 'Z', '\\u017d': 'Z',\n  '\\u017a': 'z',  '\\u017c': 'z', '\\u017e': 'z',\n  '\\u0132': 'IJ', '\\u0133': 'ij',\n  '\\u0152': 'Oe', '\\u0153': 'oe',\n  '\\u0149': \"'n\", '\\u017f': 'ss'\n};\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/**\n * A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the first element of `array` as\n *  the initial value.\n * @returns {*} Returns the accumulated value.\n */\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  if (initAccum && length) {\n    accumulator = array[++index];\n  }\n  while (++index < length) {\n    accumulator = iteratee(accumulator, array[index], index, array);\n  }\n  return accumulator;\n}\n\n/**\n * Converts an ASCII `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction asciiToArray(string) {\n  return string.split('');\n}\n\n/**\n * Splits an ASCII `string` into an array of its words.\n *\n * @private\n * @param {string} The string to inspect.\n * @returns {Array} Returns the words of `string`.\n */\nfunction asciiWords(string) {\n  return string.match(reAsciiWord) || [];\n}\n\n/**\n * The base implementation of `_.propertyOf` without support for deep paths.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Function} Returns the new accessor function.\n */\nfunction basePropertyOf(object) {\n  return function(key) {\n    return object == null ? undefined : object[key];\n  };\n}\n\n/**\n * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n * letters to basic Latin letters.\n *\n * @private\n * @param {string} letter The matched letter to deburr.\n * @returns {string} Returns the deburred letter.\n */\nvar deburrLetter = basePropertyOf(deburredLetters);\n\n/**\n * Checks if `string` contains Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n */\nfunction hasUnicode(string) {\n  return reHasUnicode.test(string);\n}\n\n/**\n * Checks if `string` contains a word composed of Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a word is found, else `false`.\n */\nfunction hasUnicodeWord(string) {\n  return reHasUnicodeWord.test(string);\n}\n\n/**\n * Converts `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction stringToArray(string) {\n  return hasUnicode(string)\n    ? unicodeToArray(string)\n    : asciiToArray(string);\n}\n\n/**\n * Converts a Unicode `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction unicodeToArray(string) {\n  return string.match(reUnicode) || [];\n}\n\n/**\n * Splits a Unicode `string` into an array of its words.\n *\n * @private\n * @param {string} The string to inspect.\n * @returns {Array} Returns the words of `string`.\n */\nfunction unicodeWords(string) {\n  return string.match(reUnicodeWord) || [];\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n  var index = -1,\n      length = array.length;\n\n  if (start < 0) {\n    start = -start > length ? 0 : (length + start);\n  }\n  end = end > length ? length : end;\n  if (end < 0) {\n    end += length;\n  }\n  length = start > end ? 0 : ((end - start) >>> 0);\n  start >>>= 0;\n\n  var result = Array(length);\n  while (++index < length) {\n    result[index] = array[index + start];\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return symbolToString ? symbolToString.call(value) : '';\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\n/**\n * Casts `array` to a slice if it's needed.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {number} start The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the cast slice.\n */\nfunction castSlice(array, start, end) {\n  var length = array.length;\n  end = end === undefined ? length : end;\n  return (!start && end >= length) ? array : baseSlice(array, start, end);\n}\n\n/**\n * Creates a function like `_.lowerFirst`.\n *\n * @private\n * @param {string} methodName The name of the `String` case method to use.\n * @returns {Function} Returns the new case function.\n */\nfunction createCaseFirst(methodName) {\n  return function(string) {\n    string = toString(string);\n\n    var strSymbols = hasUnicode(string)\n      ? stringToArray(string)\n      : undefined;\n\n    var chr = strSymbols\n      ? strSymbols[0]\n      : string.charAt(0);\n\n    var trailing = strSymbols\n      ? castSlice(strSymbols, 1).join('')\n      : string.slice(1);\n\n    return chr[methodName]() + trailing;\n  };\n}\n\n/**\n * Creates a function like `_.camelCase`.\n *\n * @private\n * @param {Function} callback The function to combine each word.\n * @returns {Function} Returns the new compounder function.\n */\nfunction createCompounder(callback) {\n  return function(string) {\n    return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n  };\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n  return value == null ? '' : baseToString(value);\n}\n\n/**\n * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the camel cased string.\n * @example\n *\n * _.camelCase('Foo Bar');\n * // => 'fooBar'\n *\n * _.camelCase('--foo-bar--');\n * // => 'fooBar'\n *\n * _.camelCase('__FOO_BAR__');\n * // => 'fooBar'\n */\nvar camelCase = createCompounder(function(result, word, index) {\n  word = word.toLowerCase();\n  return result + (index ? capitalize(word) : word);\n});\n\n/**\n * Converts the first character of `string` to upper case and the remaining\n * to lower case.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to capitalize.\n * @returns {string} Returns the capitalized string.\n * @example\n *\n * _.capitalize('FRED');\n * // => 'Fred'\n */\nfunction capitalize(string) {\n  return upperFirst(toString(string).toLowerCase());\n}\n\n/**\n * Deburrs `string` by converting\n * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n * letters to basic Latin letters and removing\n * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to deburr.\n * @returns {string} Returns the deburred string.\n * @example\n *\n * _.deburr('déjà vu');\n * // => 'deja vu'\n */\nfunction deburr(string) {\n  string = toString(string);\n  return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n}\n\n/**\n * Converts the first character of `string` to upper case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.upperFirst('fred');\n * // => 'Fred'\n *\n * _.upperFirst('FRED');\n * // => 'FRED'\n */\nvar upperFirst = createCaseFirst('toUpperCase');\n\n/**\n * Splits `string` into an array of its words.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to inspect.\n * @param {RegExp|string} [pattern] The pattern to match words.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the words of `string`.\n * @example\n *\n * _.words('fred, barney, & pebbles');\n * // => ['fred', 'barney', 'pebbles']\n *\n * _.words('fred, barney, & pebbles', /[^, ]+/g);\n * // => ['fred', 'barney', '&', 'pebbles']\n */\nfunction words(string, pattern, guard) {\n  string = toString(string);\n  pattern = guard ? undefined : pattern;\n\n  if (pattern === undefined) {\n    return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n  }\n  return string.match(pattern) || [];\n}\n\nmodule.exports = camelCase;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash.camelcase/index.js\n// module id = 99\n// module chunks = 1"],"sourceRoot":""}