{"version":3,"sources":["vue.js"],"names":["global","factory","exports","module","define","amd","Vue","this","set","obj","key","val","hasOwn","_isVue","_data","ob","__ob__","convert","dep","notify","vms","i","length","vm","_proxy","_digest","del","_unproxy","hasOwnProperty","call","isLiteral","exp","literalValueRE","test","isReserved","str","c","charCodeAt","_toString","value","toString","toNumber","parsed","Number","isNaN","toBoolean","stripQuotes","a","b","slice","camelize","replace","camelizeRE","toUpper","_","toUpperCase","hyphenate","hyphenateRE","toLowerCase","classify","classifyRE","bind","fn","ctx","l","arguments","apply","toArray","list","start","ret","Array","extend","to","from","keys","Object","isObject","isPlainObject","OBJECT_STRING","def","enumerable","defineProperty","writable","configurable","_debounce","func","wait","timeout","args","context","timestamp","result","later","last","Date","now","setTimeout","indexOf","arr","cancellable","cb","cancelled","cancel","looseEqual","JSON","stringify","isNative","Ctor","Cache","limit","size","head","tail","undefined","_keymap","create","peek","index","next","eof","len","eatSpace","spaceChr","isStringStart","chr","doubleChr","singleChr","isExpStart","expStartChr","isExpEnd","expChrPair","parseString","stringQuote","escapeChr","parseSpecialExp","inExp","startChr","parseExpression","pipeChr","state","startState","filterArgState","filterState","filterNameState","parseFilterList","filters","push","parseFilter","filter","name","trim","parseFilterArguments","arg","processFilterArg","reservedArgRE","dynamic","stripped","parseDirective","s","hit","cache$1","get","dir","expression","put","escapeRegex","regexEscapeRE","compileRegex","open","config","delimiters","close","unsafeOpen","unsafeDelimiters","unsafeClose","tagRE","RegExp","htmlRE","cache","parseText","text","match","html","first","oneTime","tokens","lastIndex","exec","tag","tokensToExp","map","token","formatToken","join","single","$eval","inlineFilters","filterRE","appendWithTransition","el","target","applyTransition","appendChild","beforeWithTransition","before","removeWithTransition","remove","direction","op","transition","__v_trans","hooks","transitionEndEvent","_isCompiled","$parent","action","query","document","querySelector","inDoc","node","doc","ownerDocument","documentElement","parent","parentNode","nodeType","contains","getAttr","_attr","getAttribute","removeAttribute","getBindAttr","hasBindAttr","hasAttribute","insertBefore","after","nextSibling","removeChild","prepend","firstChild","replaceChild","on","event","useCapture","addEventListener","off","removeEventListener","getClass","classname","className","baseVal","setClass","cls","isIE9","namespaceURI","setAttribute","addClass","classList","add","cur","removeClass","tar","extractContent","asFragment","child","rawContent","isTemplate","isFragment","content","hasChildNodes","trimNode","createDocumentFragment","createElement","isTrimmable","lastChild","data","tagName","createAnchor","persist","anchor","debug","createComment","createTextNode","__v_anchor","findRef","hasAttributes","attrs","attributes","refRE","mapNodeRange","end","removeNodeRange","frag","onRemoved","removed","done","nodes","getOuterHTML","outerHTML","container","cloneNode","innerHTML","checkComponentAttr","options","hasAttrs","commonTagRE","reservedTagRE","getIsBinding","resolveAsset","id","is","mergeData","toVal","fromVal","mergeAssets","parentVal","childVal","res","guardArrayAssets","guardComponents","components","ids","guardProps","props","isArray","type","assets","asset","mergeOptions","mergeField","strat","strats","defaultStrat","mixins","mixin","mixinOptions","prototype","warnMissing","camelizedId","charAt","Dep","uid$1","subs","withoutConversion","shouldConvert","Observer","augment","hasProto","protoAugment","copyAugment","arrayMethods","arrayKeys","observeArray","walk","src","__proto__","observe","isExtensible","addVm","defineReactive","property","getOwnPropertyDescriptor","getter","setter","childOb","depend","e","newVal","initMixin","_init","$el","$root","$children","$refs","$els","_watchers","_directives","_uid","uid","_events","_eventsCount","_isFragment","_fragment","_fragmentStart","_fragmentEnd","_isDestroyed","_isReady","_isAttached","_isBeingDestroyed","_vForRemoving","_unlinkFn","_context","_scope","_frag","children","$options","constructor","_updateRef","_callHook","_initState","_initEvents","$mount","getPathCharType","ch","code","formatSubPath","path","trimmed","parse","maybeUnescapeQuote","nextChar","mode","IN_SINGLE_QUOTE","IN_DOUBLE_QUOTE","newChar","actions","APPEND","typeMap","BEFORE_PATH","subPathDepth","PUSH","INC_SUB_PATH_DEPTH","PUSH_SUB_PATH","IN_SUB_PATH","pathStateMachine","ERROR","AFTER_PATH","raw","parsePath","pathCache","getPath","parseExpression$1","setPath","original","$set","noop","save","isString","saved","newlineRE","rewrite","allowedKeywordsRE","restoreRE","restore","compileGetter","improperKeywordsRE","body","saveRE","wsRE","identRE","makeGetterFn","Function","compileSetter","scope","needSet","expressionCache","isSimplePath","pathTestRE","literalValueRE$1","resetBatcherState","queue","userQueue","has","circular","waiting","flushBatcherQueue","_again","runBatcherQueue","devtools","emit","watcher","run","pushWatcher","q","user","nextTick","Watcher","expOrFn","isFn","uid$2","active","dirty","lazy","deps","newDeps","depIds","_Set","newDepIds","prevError","twoWay","queued","shallow","traverse","seen","seenObjects","clear","isA","isO","depId","isRealTemplate","stringToFragment","templateString","cacheKey","templateCache","tagMatch","tagRE$1","entityMatch","entityRE","commentMatch","commentRE","wrap","efault","depth","prefix","suffix","nodeToFragment","textContent","clonedNode","querySelectorAll","cloned","hasBrokenTemplate","tempClone","hasTextareaCloneBug","parseTemplate","template","shouldClone","idSelectorCache","getElementById","Fragment","linker","host","parentFrag","childFrags","inserted","unlink","childNodes","singleBefore","singleRemove","multiBefore","multiRemove","__v_frag","withTransition","method","callHook","attach","shouldCallRemove","self","beforeRemove","detach","destroy","FragmentFactory","cid","cacheId","linkerCache","compile","findPrevFrag","previousSibling","forId","range","n","Math","floor","getTrackByKey","trackByKey","findVmFromFrag","__vue__","getValue","multi","init","selected","_value","indexOf$1","keyFilter","handler","codes","charCode","parseInt","keyCodes","concat","keyCode","stopFilter","stopPropagation","preventFilter","preventDefault","selfFilter","currentTarget","normalize","prop","propCache","camel","upper","testEl","prefixed","prefixes","style","kebab","camelPrefixes","normalize$1","_key","k","split","callActivateHooks","called","total","compileProps","propOptions","attr","propsData","names","empty","identRE$1","propBindingModes","ONE_WAY","TWO_WAY","ONE_TIME","optimizedLiteral","parentPath","makePropsLinkFn","_props","inlineProps","initProp","$get","_bindDir","propDef","Boolean","processPropValue","rawValue","isSimple","getPropDefaultValue","coerceProp","coerced","assertProp","updateProp","required","valid","expectedTypes","assertedType","assertType","expectedType","validator","coerce","String","pushJob","job","queue$1","flush","f","offsetHeight","Transition","enterClass","leaveClass","pendingCssEvent","pendingCssCb","pendingJsCb","justEntered","entered","left","typeCache","forEach","m","isHidden","rect","getBoundingClientRect","width","height","offsetWidth","getClientRects","partial","nodeLinkFn","_asComponent","compileNode","childLinkFn","terminal","isScript","compileNodeList","dirs","linkAndCapture","makeUnlinkFn","originalDirCount","sortDirectives","_bind","j","groupedMap","priorities","priority","descriptor","DEFAULT_PRIORITY","array","sort","group","contextDirs","destroying","teardownDirs","_teardown","compileAndLinkProps","propsLinkFn","propDirs","compileRoot","contextOptions","contextLinkFn","replacerLinkFn","containerAttrs","_containerAttrs","replacerAttrs","_replacerAttrs","compileDirectives","selfDirs","compileTextNode","compileElement","skip","linkFn","checkTerminalDirectives","checkElementDirectives","checkComponent","_skip","removeText","wholeText","processTextToken","makeTextNodeLinkFn","setTokenType","directives","fragClone","nodeList","linkFns","makeChildLinkFn","childrenLinkFn","makeTerminalNodeLinkFn","component","ref","internalDirectives","modifiers","literal","componentLinkFn","prev","previousElementSibling","matched","dirName","rawName","termDef","modifierRE","dirAttrRE","DEFAULT_TERMINAL_PRIORITY","parseModifiers","pushDir","interpTokens","hasOneTimeToken","hasOneTime","interp","dirDef","transitionRE","bindRE","onRE","makeNodeLinkFn","transclude","extractAttrs","_content","transcludeTemplate","replacer","mergeAttrs","specialCharRE","resolveSlots","contents","_slotContents","extractFragment","stateMixin","makeComputedGetter","owner","evaluate","newData","_setData","_initProps","_initMeta","_initMethods","_initData","_initComputed","_propsUnlinkFn","dataFn","oldData","removeVm","update","computed","userDef","methods","metas","_meta","eventsMixin","registerComponentEvents","eventRE","_fromParent","$on","registerCallbacks","hash","handlers","register","onAttached","callAttach","onDetached","callDetach","events","watch","_initDOMHooks","hook","$emit","noop$1","Directive","_locked","_bound","_listeners","_host","lifecycleMixin","_ref","refs","_compile","_initElement","rootLinker","contentLinkFn","ctor","_linkerCachable","rootUnlinkFn","contentUnlinkFn","_destroy","deferCleanup","_cleanup","destroyReady","pendingRemoval","cleanupIfPossible","$remove","$destroy","teardown","$off","miscMixin","_applyFilters","oldValue","write","offset","read","_resolveComponent","resolved","requested","pendingCallbacks","cbs","reason","dataAPI","clean","asStatement","$arguments","$delete","$watch","deep","sync","immediate","filterRE$1","$interpolate","$log","console","log","domAPI","insert","op1","op2","targetIsDetached","shouldCallHook","append","beforeWithCb","removeWithCb","$nextTick","$appendTo","$prependTo","$before","$after","inDocument","realCb","eventsAPI","modifyListenerCount","count","hookRE","$once","splice","isSource","shouldPropagate","hasParentCbs","some","$broadcast","source","$dispatch","lifecycleAPI","ready","$compile","limitBy","filterBy","search","delimiter","convertArray","item","$value","$key","orderBy","baseCompare","sortKeyIndex","sortKey","sortKeys","order","comparator","firstArg","installGlobalAPI","createClass","elementDirectives","transitions","partials","util","compiler","parsers","directive","extendOptions","Super","isFirstExtend","_Ctor","Sub","_assetTypes","use","plugin","installed","unshift","install","definition","inBrowser","window","__VUE_DEVTOOLS_GLOBAL_HOOK__","UA","navigator","userAgent","isIE","isAndroid","isIOS","transitionProp","animationProp","animationEndEvent","isWebkitTrans","ontransitionend","onwebkittransitionend","isWebkitAnim","onanimationend","onwebkitanimationend","nextTickHandler","pending","copies","callbacks","timerFunc","Promise","p","resolve","then","MutationObserver","counter","observer","textNode","characterData","Set","entry","shift","newer","older","returnEntry","91","123","40","freeze","defineProperties","silent","async","warnExpressionErrors","_delimitersChanged","_propBindingModes","_maxUpdateCount","warn","optionMergeStrategies","instanceData","defaultData","created","attached","detached","beforeCompile","compiled","beforeDestroy","destroyed","activate","addSub","sub","removeSub","addDep","arrayProto","getOwnPropertyNames","items","debounce","IN_PATH","BEFORE_IDENT","IN_IDENT","ws","ident","[",".","0","number","'","\"","]","else","allowedKeywords","improperKeywords","beforeGet","preProcess","postProcess","afterGet","forContext","$forContext","alias","_withLock","$index","tmp","current","text$1","legend","tr","col","td","th","option","optgroup","thead","tbody","colgroup","caption","tfoot","g","defs","symbol","image","circle","ellipse","line","polygon","polyline","t","placeholder","swap","_watcher","ON","MODEL","BIND","TRANSITION","EL","COMPONENT","PARTIAL","IF","FOR","SLOT","uid$3","vFor","params","inMatch","itMatch","iterator","isOption","diff","updateRef","updateModel","primitive","convertedFromObject","fromObject","trackBy","oldFrags","frags","getCachedFrag","reused","fresh","removalIndex","totalRemoved","deleteCachedFrag","w","targetPrev","prevEl","currentPrev","insertionIndex","staggerCb","staggerAnchor","move","parentScope","cacheFrag","model","__v_model","forceUpdate","staggerAmount","getStagger","trans","stagger","_preProcess","_postProcess","unbind","vIf","invalid","nextElementSibling","elseEl","elseFrag","elseFactory","show","toggle","display","text$2","isRange","composing","listener","focused","rawListener","hasjQuery","jQuery","afterBind","radio","checked","select","_this","multiple","initValue","selectedIndex","checkbox","getBooleanValue","_trueValue","_falseValue","checkFilters","hasRead","hasWrite","_unbind","esc","tab","enter","space","delete","up","right","down","on$1","acceptStatement","iframeBind","contentWindow","capture","stop","prevent","reset","importantRE","cssText","handleObject","reduce","handleSingle","isImportant","setProperty","xlinkNS","xlinkRE","disallowedInterpAttrRE","attrWithPropsRE","enumeratedAttrRE","modelProps","true-value","false-value","bind$1","attrValue","modelProp","setAttributeNS","cloak","for","if","vClass","cleanup","prevKeys","keepAlive","inlineTemplate","pendingComponentCb","Component","pendingRemovals","pendingRemovalCb","setComponent","invalidatePending","resolveComponent","mountComponent","unbuild","childVM","ComponentName","activateHooks","cached","getCached","newComponent","build","waitingFor","extraOptions","_isRouterView","defer","_inactive","transitionMode","bindingModes","childKey","parentKey","parentWatcher","childWatcher","TYPE_TRANSITION","TYPE_ANIMATION","transDurationProp","animDurationProp","raf","requestAnimationFrame","waitForTransitionStart","p$1","cancelPending","callHookWithCb","enterCancelled","enterNextTick","enterDone","getCssTransitionType","setupCssCb","leave","leaveCancelled","leaveDone","leaveNextTick","hasPending","hidden","css","inlineStyles","computedStyles","getComputedStyle","transDuration","animDuration","onEnd","transition$1","oldId","class","_setupParams","_checkStatement","_update","oldVal","mappedKey","_setupParamWatcher","unwatch","paramWatchers","_paramUnwatchFns","$event","listeners","unwatchFns","slot","fallback","elseBlock","digitsRE","json","indent","capitalize","uppercase","lowercase","currency","_currency","decimals","parseFloat","isFinite","stringified","abs","toFixed","_int","_float","sign","pluralize","delay","version"],"mappings":"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","file":"vue.min.js","sourcesContent":["/*!\n * Vue.js v1.0.28\n * (c) 2016 Evan You\n * Released under the MIT License.\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.Vue = factory());\n}(this, (function () { 'use strict';\n\nfunction set(obj, key, val) {\n  if (hasOwn(obj, key)) {\n    obj[key] = val;\n    return;\n  }\n  if (obj._isVue) {\n    set(obj._data, key, val);\n    return;\n  }\n  var ob = obj.__ob__;\n  if (!ob) {\n    obj[key] = val;\n    return;\n  }\n  ob.convert(key, val);\n  ob.dep.notify();\n  if (ob.vms) {\n    var i = ob.vms.length;\n    while (i--) {\n      var vm = ob.vms[i];\n      vm._proxy(key);\n      vm._digest();\n    }\n  }\n  return val;\n}\n\n/**\n * Delete a property and trigger change if necessary.\n *\n * @param {Object} obj\n * @param {String} key\n */\n\nfunction del(obj, key) {\n  if (!hasOwn(obj, key)) {\n    return;\n  }\n  delete obj[key];\n  var ob = obj.__ob__;\n  if (!ob) {\n    if (obj._isVue) {\n      delete obj._data[key];\n      obj._digest();\n    }\n    return;\n  }\n  ob.dep.notify();\n  if (ob.vms) {\n    var i = ob.vms.length;\n    while (i--) {\n      var vm = ob.vms[i];\n      vm._unproxy(key);\n      vm._digest();\n    }\n  }\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n/**\n * Check whether the object has the property.\n *\n * @param {Object} obj\n * @param {String} key\n * @return {Boolean}\n */\n\nfunction hasOwn(obj, key) {\n  return hasOwnProperty.call(obj, key);\n}\n\n/**\n * Check if an expression is a literal value.\n *\n * @param {String} exp\n * @return {Boolean}\n */\n\nvar literalValueRE = /^\\s?(true|false|-?[\\d\\.]+|'[^']*'|\"[^\"]*\")\\s?$/;\n\nfunction isLiteral(exp) {\n  return literalValueRE.test(exp);\n}\n\n/**\n * Check if a string starts with $ or _\n *\n * @param {String} str\n * @return {Boolean}\n */\n\nfunction isReserved(str) {\n  var c = (str + '').charCodeAt(0);\n  return c === 0x24 || c === 0x5F;\n}\n\n/**\n * Guard text output, make sure undefined outputs\n * empty string\n *\n * @param {*} value\n * @return {String}\n */\n\nfunction _toString(value) {\n  return value == null ? '' : value.toString();\n}\n\n/**\n * Check and convert possible numeric strings to numbers\n * before setting back to data\n *\n * @param {*} value\n * @return {*|Number}\n */\n\nfunction toNumber(value) {\n  if (typeof value !== 'string') {\n    return value;\n  } else {\n    var parsed = Number(value);\n    return isNaN(parsed) ? value : parsed;\n  }\n}\n\n/**\n * Convert string boolean literals into real booleans.\n *\n * @param {*} value\n * @return {*|Boolean}\n */\n\nfunction toBoolean(value) {\n  return value === 'true' ? true : value === 'false' ? false : value;\n}\n\n/**\n * Strip quotes from a string\n *\n * @param {String} str\n * @return {String | false}\n */\n\nfunction stripQuotes(str) {\n  var a = str.charCodeAt(0);\n  var b = str.charCodeAt(str.length - 1);\n  return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;\n}\n\n/**\n * Camelize a hyphen-delimited string.\n *\n * @param {String} str\n * @return {String}\n */\n\nvar camelizeRE = /-(\\w)/g;\n\nfunction camelize(str) {\n  return str.replace(camelizeRE, toUpper);\n}\n\nfunction toUpper(_, c) {\n  return c ? c.toUpperCase() : '';\n}\n\n/**\n * Hyphenate a camelCase string.\n *\n * @param {String} str\n * @return {String}\n */\n\nvar hyphenateRE = /([^-])([A-Z])/g;\n\nfunction hyphenate(str) {\n  return str.replace(hyphenateRE, '$1-$2').replace(hyphenateRE, '$1-$2').toLowerCase();\n}\n\n/**\n * Converts hyphen/underscore/slash delimitered names into\n * camelized classNames.\n *\n * e.g. my-component => MyComponent\n *      some_else    => SomeElse\n *      some/comp    => SomeComp\n *\n * @param {String} str\n * @return {String}\n */\n\nvar classifyRE = /(?:^|[-_\\/])(\\w)/g;\n\nfunction classify(str) {\n  return str.replace(classifyRE, toUpper);\n}\n\n/**\n * Simple bind, faster than native\n *\n * @param {Function} fn\n * @param {Object} ctx\n * @return {Function}\n */\n\nfunction bind(fn, ctx) {\n  return function (a) {\n    var l = arguments.length;\n    return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx);\n  };\n}\n\n/**\n * Convert an Array-like object to a real Array.\n *\n * @param {Array-like} list\n * @param {Number} [start] - start index\n * @return {Array}\n */\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 *\n * @param {Object} to\n * @param {Object} from\n */\n\nfunction extend(to, from) {\n  var keys = Object.keys(from);\n  var i = keys.length;\n  while (i--) {\n    to[keys[i]] = from[keys[i]];\n  }\n  return to;\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 *\n * @param {*} obj\n * @return {Boolean}\n */\n\nfunction isObject(obj) {\n  return obj !== null && typeof obj === 'object';\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n *\n * @param {*} obj\n * @return {Boolean}\n */\n\nvar toString = Object.prototype.toString;\nvar OBJECT_STRING = '[object Object]';\n\nfunction isPlainObject(obj) {\n  return toString.call(obj) === OBJECT_STRING;\n}\n\n/**\n * Array type check.\n *\n * @param {*} obj\n * @return {Boolean}\n */\n\nvar isArray = Array.isArray;\n\n/**\n * Define a property.\n *\n * @param {Object} obj\n * @param {String} key\n * @param {*} val\n * @param {Boolean} [enumerable]\n */\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 * Debounce a function so it only gets called after the\n * input stops arriving after the given wait period.\n *\n * @param {Function} func\n * @param {Number} wait\n * @return {Function} - the debounced function\n */\n\nfunction _debounce(func, wait) {\n  var timeout, args, context, timestamp, result;\n  var later = function later() {\n    var last = Date.now() - timestamp;\n    if (last < wait && last >= 0) {\n      timeout = setTimeout(later, wait - last);\n    } else {\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    }\n  };\n  return function () {\n    context = this;\n    args = arguments;\n    timestamp = Date.now();\n    if (!timeout) {\n      timeout = setTimeout(later, wait);\n    }\n    return result;\n  };\n}\n\n/**\n * Manual indexOf because it's slightly faster than\n * native.\n *\n * @param {Array} arr\n * @param {*} obj\n */\n\nfunction indexOf(arr, obj) {\n  var i = arr.length;\n  while (i--) {\n    if (arr[i] === obj) return i;\n  }\n  return -1;\n}\n\n/**\n * Make a cancellable version of an async callback.\n *\n * @param {Function} fn\n * @return {Function}\n */\n\nfunction cancellable(fn) {\n  var cb = function cb() {\n    if (!cb.cancelled) {\n      return fn.apply(this, arguments);\n    }\n  };\n  cb.cancel = function () {\n    cb.cancelled = true;\n  };\n  return cb;\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 *\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n */\n\nfunction looseEqual(a, b) {\n  /* eslint-disable eqeqeq */\n  return a == b || (isObject(a) && isObject(b) ? JSON.stringify(a) === JSON.stringify(b) : false);\n  /* eslint-enable eqeqeq */\n}\n\nvar hasProto = ('__proto__' in {});\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined' && Object.prototype.toString.call(window) !== '[object Object]';\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n// UA sniffing for working around browser-specific quirks\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && UA.indexOf('trident') > 0;\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isAndroid = UA && UA.indexOf('android') > 0;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\n\nvar transitionProp = undefined;\nvar transitionEndEvent = undefined;\nvar animationProp = undefined;\nvar animationEndEvent = undefined;\n\n// Transition property/event sniffing\nif (inBrowser && !isIE9) {\n  var isWebkitTrans = window.ontransitionend === undefined && window.onwebkittransitionend !== undefined;\n  var isWebkitAnim = window.onanimationend === undefined && window.onwebkitanimationend !== undefined;\n  transitionProp = isWebkitTrans ? 'WebkitTransition' : 'transition';\n  transitionEndEvent = isWebkitTrans ? 'webkitTransitionEnd' : 'transitionend';\n  animationProp = isWebkitAnim ? 'WebkitAnimation' : 'animation';\n  animationEndEvent = isWebkitAnim ? 'webkitAnimationEnd' : 'animationend';\n}\n\n/* istanbul ignore next */\nfunction isNative(Ctor) {\n  return (/native code/.test(Ctor.toString())\n  );\n}\n\n/**\n * Defer a task to execute it asynchronously. Ideally this\n * should be executed as a microtask, so we leverage\n * MutationObserver if it's available, and fallback to\n * setTimeout(0).\n *\n * @param {Function} cb\n * @param {Object} ctx\n */\n\nvar nextTick = (function () {\n  var callbacks = [];\n  var pending = false;\n  var timerFunc = undefined;\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 noop = function noop() {};\n    timerFunc = function () {\n      p.then(nextTickHandler);\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    // use MutationObserver where native Promise is not available,\n    // e.g. 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 = setTimeout;\n  }\n\n  return function (cb, ctx) {\n    var func = ctx ? function () {\n      cb.call(ctx);\n    } : cb;\n    callbacks.push(func);\n    if (pending) return;\n    pending = true;\n    timerFunc(nextTickHandler, 0);\n  };\n})();\n\nvar _Set = undefined;\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    this.set = Object.create(null);\n  };\n  _Set.prototype.has = function (key) {\n    return this.set[key] !== undefined;\n  };\n  _Set.prototype.add = function (key) {\n    this.set[key] = 1;\n  };\n  _Set.prototype.clear = function () {\n    this.set = Object.create(null);\n  };\n}\n\nfunction Cache(limit) {\n  this.size = 0;\n  this.limit = limit;\n  this.head = this.tail = undefined;\n  this._keymap = Object.create(null);\n}\n\nvar p = Cache.prototype;\n\n/**\n * Put <value> into the cache associated with <key>.\n * Returns the entry which was removed to make room for\n * the new entry. Otherwise undefined is returned.\n * (i.e. if there was enough room already).\n *\n * @param {String} key\n * @param {*} value\n * @return {Entry|undefined}\n */\n\np.put = function (key, value) {\n  var removed;\n\n  var entry = this.get(key, true);\n  if (!entry) {\n    if (this.size === this.limit) {\n      removed = this.shift();\n    }\n    entry = {\n      key: key\n    };\n    this._keymap[key] = entry;\n    if (this.tail) {\n      this.tail.newer = entry;\n      entry.older = this.tail;\n    } else {\n      this.head = entry;\n    }\n    this.tail = entry;\n    this.size++;\n  }\n  entry.value = value;\n\n  return removed;\n};\n\n/**\n * Purge the least recently used (oldest) entry from the\n * cache. Returns the removed entry or undefined if the\n * cache was empty.\n */\n\np.shift = function () {\n  var entry = this.head;\n  if (entry) {\n    this.head = this.head.newer;\n    this.head.older = undefined;\n    entry.newer = entry.older = undefined;\n    this._keymap[entry.key] = undefined;\n    this.size--;\n  }\n  return entry;\n};\n\n/**\n * Get and register recent use of <key>. Returns the value\n * associated with <key> or undefined if not in cache.\n *\n * @param {String} key\n * @param {Boolean} returnEntry\n * @return {Entry|*}\n */\n\np.get = function (key, returnEntry) {\n  var entry = this._keymap[key];\n  if (entry === undefined) return;\n  if (entry === this.tail) {\n    return returnEntry ? entry : entry.value;\n  }\n  // HEAD--------------TAIL\n  //   <.older   .newer>\n  //  <--- add direction --\n  //   A  B  C  <D>  E\n  if (entry.newer) {\n    if (entry === this.head) {\n      this.head = entry.newer;\n    }\n    entry.newer.older = entry.older; // C <-- E.\n  }\n  if (entry.older) {\n    entry.older.newer = entry.newer; // C. --> E\n  }\n  entry.newer = undefined; // D --x\n  entry.older = this.tail; // D. --> E\n  if (this.tail) {\n    this.tail.newer = entry; // E. <-- D\n  }\n  this.tail = entry;\n  return returnEntry ? entry : entry.value;\n};\n\nvar cache$1 = new Cache(1000);\nvar reservedArgRE = /^in$|^-?\\d+/;\n\n/**\n * Parser state\n */\n\nvar str;\nvar dir;\nvar len;\nvar index;\nvar chr;\nvar state;\nvar startState = 0;\nvar filterState = 1;\nvar filterNameState = 2;\nvar filterArgState = 3;\n\nvar doubleChr = 0x22;\nvar singleChr = 0x27;\nvar pipeChr = 0x7C;\nvar escapeChr = 0x5C;\nvar spaceChr = 0x20;\n\nvar expStartChr = { 0x5B: 1, 0x7B: 1, 0x28: 1 };\nvar expChrPair = { 0x5B: 0x5D, 0x7B: 0x7D, 0x28: 0x29 };\n\nfunction peek() {\n  return str.charCodeAt(index + 1);\n}\n\nfunction next() {\n  return str.charCodeAt(++index);\n}\n\nfunction eof() {\n  return index >= len;\n}\n\nfunction eatSpace() {\n  while (peek() === spaceChr) {\n    next();\n  }\n}\n\nfunction isStringStart(chr) {\n  return chr === doubleChr || chr === singleChr;\n}\n\nfunction isExpStart(chr) {\n  return expStartChr[chr];\n}\n\nfunction isExpEnd(start, chr) {\n  return expChrPair[start] === chr;\n}\n\nfunction parseString() {\n  var stringQuote = next();\n  var chr;\n  while (!eof()) {\n    chr = next();\n    // escape char\n    if (chr === escapeChr) {\n      next();\n    } else if (chr === stringQuote) {\n      break;\n    }\n  }\n}\n\nfunction parseSpecialExp(chr) {\n  var inExp = 0;\n  var startChr = chr;\n\n  while (!eof()) {\n    chr = peek();\n    if (isStringStart(chr)) {\n      parseString();\n      continue;\n    }\n\n    if (startChr === chr) {\n      inExp++;\n    }\n    if (isExpEnd(startChr, chr)) {\n      inExp--;\n    }\n\n    next();\n\n    if (inExp === 0) {\n      break;\n    }\n  }\n}\n\n/**\n * syntax:\n * expression | filterName  [arg  arg [| filterName arg arg]]\n */\n\nfunction parseExpression() {\n  var start = index;\n  while (!eof()) {\n    chr = peek();\n    if (isStringStart(chr)) {\n      parseString();\n    } else if (isExpStart(chr)) {\n      parseSpecialExp(chr);\n    } else if (chr === pipeChr) {\n      next();\n      chr = peek();\n      if (chr === pipeChr) {\n        next();\n      } else {\n        if (state === startState || state === filterArgState) {\n          state = filterState;\n        }\n        break;\n      }\n    } else if (chr === spaceChr && (state === filterNameState || state === filterArgState)) {\n      eatSpace();\n      break;\n    } else {\n      if (state === filterState) {\n        state = filterNameState;\n      }\n      next();\n    }\n  }\n\n  return str.slice(start + 1, index) || null;\n}\n\nfunction parseFilterList() {\n  var filters = [];\n  while (!eof()) {\n    filters.push(parseFilter());\n  }\n  return filters;\n}\n\nfunction parseFilter() {\n  var filter = {};\n  var args;\n\n  state = filterState;\n  filter.name = parseExpression().trim();\n\n  state = filterArgState;\n  args = parseFilterArguments();\n\n  if (args.length) {\n    filter.args = args;\n  }\n  return filter;\n}\n\nfunction parseFilterArguments() {\n  var args = [];\n  while (!eof() && state !== filterState) {\n    var arg = parseExpression();\n    if (!arg) {\n      break;\n    }\n    args.push(processFilterArg(arg));\n  }\n\n  return args;\n}\n\n/**\n * Check if an argument is dynamic and strip quotes.\n *\n * @param {String} arg\n * @return {Object}\n */\n\nfunction processFilterArg(arg) {\n  if (reservedArgRE.test(arg)) {\n    return {\n      value: toNumber(arg),\n      dynamic: false\n    };\n  } else {\n    var stripped = stripQuotes(arg);\n    var dynamic = stripped === arg;\n    return {\n      value: dynamic ? arg : stripped,\n      dynamic: dynamic\n    };\n  }\n}\n\n/**\n * Parse a directive value and extract the expression\n * and its filters into a descriptor.\n *\n * Example:\n *\n * \"a + 1 | uppercase\" will yield:\n * {\n *   expression: 'a + 1',\n *   filters: [\n *     { name: 'uppercase', args: null }\n *   ]\n * }\n *\n * @param {String} s\n * @return {Object}\n */\n\nfunction parseDirective(s) {\n  var hit = cache$1.get(s);\n  if (hit) {\n    return hit;\n  }\n\n  // reset parser state\n  str = s;\n  dir = {};\n  len = str.length;\n  index = -1;\n  chr = '';\n  state = startState;\n\n  var filters;\n\n  if (str.indexOf('|') < 0) {\n    dir.expression = str.trim();\n  } else {\n    dir.expression = parseExpression().trim();\n    filters = parseFilterList();\n    if (filters.length) {\n      dir.filters = filters;\n    }\n  }\n\n  cache$1.put(s, dir);\n  return dir;\n}\n\nvar directive = Object.freeze({\n  parseDirective: parseDirective\n});\n\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\nvar cache = undefined;\nvar tagRE = undefined;\nvar htmlRE = undefined;\n/**\n * Escape a string so it can be used in a RegExp\n * constructor.\n *\n * @param {String} str\n */\n\nfunction escapeRegex(str) {\n  return str.replace(regexEscapeRE, '\\\\$&');\n}\n\nfunction compileRegex() {\n  var open = escapeRegex(config.delimiters[0]);\n  var close = escapeRegex(config.delimiters[1]);\n  var unsafeOpen = escapeRegex(config.unsafeDelimiters[0]);\n  var unsafeClose = escapeRegex(config.unsafeDelimiters[1]);\n  tagRE = new RegExp(unsafeOpen + '((?:.|\\\\n)+?)' + unsafeClose + '|' + open + '((?:.|\\\\n)+?)' + close, 'g');\n  htmlRE = new RegExp('^' + unsafeOpen + '((?:.|\\\\n)+?)' + unsafeClose + '$');\n  // reset cache\n  cache = new Cache(1000);\n}\n\n/**\n * Parse a template text string into an array of tokens.\n *\n * @param {String} text\n * @return {Array<Object> | null}\n *               - {String} type\n *               - {String} value\n *               - {Boolean} [html]\n *               - {Boolean} [oneTime]\n */\n\nfunction parseText(text) {\n  if (!cache) {\n    compileRegex();\n  }\n  var hit = cache.get(text);\n  if (hit) {\n    return hit;\n  }\n  if (!tagRE.test(text)) {\n    return null;\n  }\n  var tokens = [];\n  var lastIndex = tagRE.lastIndex = 0;\n  var match, index, html, value, first, oneTime;\n  /* eslint-disable no-cond-assign */\n  while (match = tagRE.exec(text)) {\n    /* eslint-enable no-cond-assign */\n    index = match.index;\n    // push text token\n    if (index > lastIndex) {\n      tokens.push({\n        value: text.slice(lastIndex, index)\n      });\n    }\n    // tag token\n    html = htmlRE.test(match[0]);\n    value = html ? match[1] : match[2];\n    first = value.charCodeAt(0);\n    oneTime = first === 42; // *\n    value = oneTime ? value.slice(1) : value;\n    tokens.push({\n      tag: true,\n      value: value.trim(),\n      html: html,\n      oneTime: oneTime\n    });\n    lastIndex = index + match[0].length;\n  }\n  if (lastIndex < text.length) {\n    tokens.push({\n      value: text.slice(lastIndex)\n    });\n  }\n  cache.put(text, tokens);\n  return tokens;\n}\n\n/**\n * Format a list of tokens into an expression.\n * e.g. tokens parsed from 'a {{b}} c' can be serialized\n * into one single expression as '\"a \" + b + \" c\"'.\n *\n * @param {Array} tokens\n * @param {Vue} [vm]\n * @return {String}\n */\n\nfunction tokensToExp(tokens, vm) {\n  if (tokens.length > 1) {\n    return tokens.map(function (token) {\n      return formatToken(token, vm);\n    }).join('+');\n  } else {\n    return formatToken(tokens[0], vm, true);\n  }\n}\n\n/**\n * Format a single token.\n *\n * @param {Object} token\n * @param {Vue} [vm]\n * @param {Boolean} [single]\n * @return {String}\n */\n\nfunction formatToken(token, vm, single) {\n  return token.tag ? token.oneTime && vm ? '\"' + vm.$eval(token.value) + '\"' : inlineFilters(token.value, single) : '\"' + token.value + '\"';\n}\n\n/**\n * For an attribute with multiple interpolation tags,\n * e.g. attr=\"some-{{thing | filter}}\", in order to combine\n * the whole thing into a single watchable expression, we\n * have to inline those filters. This function does exactly\n * that. This is a bit hacky but it avoids heavy changes\n * to directive parser and watcher mechanism.\n *\n * @param {String} exp\n * @param {Boolean} single\n * @return {String}\n */\n\nvar filterRE = /[^|]\\|[^|]/;\nfunction inlineFilters(exp, single) {\n  if (!filterRE.test(exp)) {\n    return single ? exp : '(' + exp + ')';\n  } else {\n    var dir = parseDirective(exp);\n    if (!dir.filters) {\n      return '(' + exp + ')';\n    } else {\n      return 'this._applyFilters(' + dir.expression + // value\n      ',null,' + // oldValue (null for read)\n      JSON.stringify(dir.filters) + // filter descriptors\n      ',false)'; // write?\n    }\n  }\n}\n\nvar text = Object.freeze({\n  compileRegex: compileRegex,\n  parseText: parseText,\n  tokensToExp: tokensToExp\n});\n\nvar delimiters = ['{{', '}}'];\nvar unsafeDelimiters = ['{{{', '}}}'];\n\nvar config = Object.defineProperties({\n\n  /**\n   * Whether to print debug messages.\n   * Also enables stack trace for warnings.\n   *\n   * @type {Boolean}\n   */\n\n  debug: false,\n\n  /**\n   * Whether to suppress warnings.\n   *\n   * @type {Boolean}\n   */\n\n  silent: false,\n\n  /**\n   * Whether to use async rendering.\n   */\n\n  async: true,\n\n  /**\n   * Whether to warn against errors caught when evaluating\n   * expressions.\n   */\n\n  warnExpressionErrors: true,\n\n  /**\n   * Whether to allow devtools inspection.\n   * Disabled by default in production builds.\n   */\n\n  devtools: 'production' !== 'production',\n\n  /**\n   * Internal flag to indicate the delimiters have been\n   * changed.\n   *\n   * @type {Boolean}\n   */\n\n  _delimitersChanged: true,\n\n  /**\n   * List of asset types that a component can own.\n   *\n   * @type {Array}\n   */\n\n  _assetTypes: ['component', 'directive', 'elementDirective', 'filter', 'transition', 'partial'],\n\n  /**\n   * prop binding modes\n   */\n\n  _propBindingModes: {\n    ONE_WAY: 0,\n    TWO_WAY: 1,\n    ONE_TIME: 2\n  },\n\n  /**\n   * Max circular updates allowed in a batcher flush cycle.\n   */\n\n  _maxUpdateCount: 100\n\n}, {\n  delimiters: { /**\n                 * Interpolation delimiters. Changing these would trigger\n                 * the text parser to re-compile the regular expressions.\n                 *\n                 * @type {Array<String>}\n                 */\n\n    get: function get() {\n      return delimiters;\n    },\n    set: function set(val) {\n      delimiters = val;\n      compileRegex();\n    },\n    configurable: true,\n    enumerable: true\n  },\n  unsafeDelimiters: {\n    get: function get() {\n      return unsafeDelimiters;\n    },\n    set: function set(val) {\n      unsafeDelimiters = val;\n      compileRegex();\n    },\n    configurable: true,\n    enumerable: true\n  }\n});\n\nvar warn = undefined;\n\n/**\n * Append with transition.\n *\n * @param {Element} el\n * @param {Element} target\n * @param {Vue} vm\n * @param {Function} [cb]\n */\n\nfunction appendWithTransition(el, target, vm, cb) {\n  applyTransition(el, 1, function () {\n    target.appendChild(el);\n  }, vm, cb);\n}\n\n/**\n * InsertBefore with transition.\n *\n * @param {Element} el\n * @param {Element} target\n * @param {Vue} vm\n * @param {Function} [cb]\n */\n\nfunction beforeWithTransition(el, target, vm, cb) {\n  applyTransition(el, 1, function () {\n    before(el, target);\n  }, vm, cb);\n}\n\n/**\n * Remove with transition.\n *\n * @param {Element} el\n * @param {Vue} vm\n * @param {Function} [cb]\n */\n\nfunction removeWithTransition(el, vm, cb) {\n  applyTransition(el, -1, function () {\n    remove(el);\n  }, vm, cb);\n}\n\n/**\n * Apply transitions with an operation callback.\n *\n * @param {Element} el\n * @param {Number} direction\n *                  1: enter\n *                 -1: leave\n * @param {Function} op - the actual DOM operation\n * @param {Vue} vm\n * @param {Function} [cb]\n */\n\nfunction applyTransition(el, direction, op, vm, cb) {\n  var transition = el.__v_trans;\n  if (!transition ||\n  // skip if there are no js hooks and CSS transition is\n  // not supported\n  !transition.hooks && !transitionEndEvent ||\n  // skip transitions for initial compile\n  !vm._isCompiled ||\n  // if the vm is being manipulated by a parent directive\n  // during the parent's compilation phase, skip the\n  // animation.\n  vm.$parent && !vm.$parent._isCompiled) {\n    op();\n    if (cb) cb();\n    return;\n  }\n  var action = direction > 0 ? 'enter' : 'leave';\n  transition[action](op, cb);\n}\n\nvar transition = Object.freeze({\n  appendWithTransition: appendWithTransition,\n  beforeWithTransition: beforeWithTransition,\n  removeWithTransition: removeWithTransition,\n  applyTransition: applyTransition\n});\n\n/**\n * Query an element selector if it's not an element already.\n *\n * @param {String|Element} el\n * @return {Element}\n */\n\nfunction query(el) {\n  if (typeof el === 'string') {\n    var selector = el;\n    el = document.querySelector(el);\n    if (!el) {\n      'production' !== 'production' && warn('Cannot find element: ' + selector);\n    }\n  }\n  return el;\n}\n\n/**\n * Check if a node is in the document.\n * Note: document.documentElement.contains should work here\n * but always returns false for comment nodes in phantomjs,\n * making unit tests difficult. This is fixed by doing the\n * contains() check on the node's parentNode instead of\n * the node itself.\n *\n * @param {Node} node\n * @return {Boolean}\n */\n\nfunction inDoc(node) {\n  if (!node) return false;\n  var doc = node.ownerDocument.documentElement;\n  var parent = node.parentNode;\n  return doc === node || doc === parent || !!(parent && parent.nodeType === 1 && doc.contains(parent));\n}\n\n/**\n * Get and remove an attribute from a node.\n *\n * @param {Node} node\n * @param {String} _attr\n */\n\nfunction getAttr(node, _attr) {\n  var val = node.getAttribute(_attr);\n  if (val !== null) {\n    node.removeAttribute(_attr);\n  }\n  return val;\n}\n\n/**\n * Get an attribute with colon or v-bind: prefix.\n *\n * @param {Node} node\n * @param {String} name\n * @return {String|null}\n */\n\nfunction getBindAttr(node, name) {\n  var val = getAttr(node, ':' + name);\n  if (val === null) {\n    val = getAttr(node, 'v-bind:' + name);\n  }\n  return val;\n}\n\n/**\n * Check the presence of a bind attribute.\n *\n * @param {Node} node\n * @param {String} name\n * @return {Boolean}\n */\n\nfunction hasBindAttr(node, name) {\n  return node.hasAttribute(name) || node.hasAttribute(':' + name) || node.hasAttribute('v-bind:' + name);\n}\n\n/**\n * Insert el before target\n *\n * @param {Element} el\n * @param {Element} target\n */\n\nfunction before(el, target) {\n  target.parentNode.insertBefore(el, target);\n}\n\n/**\n * Insert el after target\n *\n * @param {Element} el\n * @param {Element} target\n */\n\nfunction after(el, target) {\n  if (target.nextSibling) {\n    before(el, target.nextSibling);\n  } else {\n    target.parentNode.appendChild(el);\n  }\n}\n\n/**\n * Remove el from DOM\n *\n * @param {Element} el\n */\n\nfunction remove(el) {\n  el.parentNode.removeChild(el);\n}\n\n/**\n * Prepend el to target\n *\n * @param {Element} el\n * @param {Element} target\n */\n\nfunction prepend(el, target) {\n  if (target.firstChild) {\n    before(el, target.firstChild);\n  } else {\n    target.appendChild(el);\n  }\n}\n\n/**\n * Replace target with el\n *\n * @param {Element} target\n * @param {Element} el\n */\n\nfunction replace(target, el) {\n  var parent = target.parentNode;\n  if (parent) {\n    parent.replaceChild(el, target);\n  }\n}\n\n/**\n * Add event listener shorthand.\n *\n * @param {Element} el\n * @param {String} event\n * @param {Function} cb\n * @param {Boolean} [useCapture]\n */\n\nfunction on(el, event, cb, useCapture) {\n  el.addEventListener(event, cb, useCapture);\n}\n\n/**\n * Remove event listener shorthand.\n *\n * @param {Element} el\n * @param {String} event\n * @param {Function} cb\n */\n\nfunction off(el, event, cb) {\n  el.removeEventListener(event, cb);\n}\n\n/**\n * For IE9 compat: when both class and :class are present\n * getAttribute('class') returns wrong value...\n *\n * @param {Element} el\n * @return {String}\n */\n\nfunction getClass(el) {\n  var classname = el.className;\n  if (typeof classname === 'object') {\n    classname = classname.baseVal || '';\n  }\n  return classname;\n}\n\n/**\n * In IE9, setAttribute('class') will result in empty class\n * if the element also has the :class attribute; However in\n * PhantomJS, setting `className` does not work on SVG elements...\n * So we have to do a conditional check here.\n *\n * @param {Element} el\n * @param {String} cls\n */\n\nfunction setClass(el, cls) {\n  /* istanbul ignore if */\n  if (isIE9 && !/svg$/.test(el.namespaceURI)) {\n    el.className = cls;\n  } else {\n    el.setAttribute('class', cls);\n  }\n}\n\n/**\n * Add class with compatibility for IE & SVG\n *\n * @param {Element} el\n * @param {String} cls\n */\n\nfunction addClass(el, cls) {\n  if (el.classList) {\n    el.classList.add(cls);\n  } else {\n    var cur = ' ' + getClass(el) + ' ';\n    if (cur.indexOf(' ' + cls + ' ') < 0) {\n      setClass(el, (cur + cls).trim());\n    }\n  }\n}\n\n/**\n * Remove class with compatibility for IE & SVG\n *\n * @param {Element} el\n * @param {String} cls\n */\n\nfunction removeClass(el, cls) {\n  if (el.classList) {\n    el.classList.remove(cls);\n  } else {\n    var cur = ' ' + getClass(el) + ' ';\n    var tar = ' ' + cls + ' ';\n    while (cur.indexOf(tar) >= 0) {\n      cur = cur.replace(tar, ' ');\n    }\n    setClass(el, cur.trim());\n  }\n  if (!el.className) {\n    el.removeAttribute('class');\n  }\n}\n\n/**\n * Extract raw content inside an element into a temporary\n * container div\n *\n * @param {Element} el\n * @param {Boolean} asFragment\n * @return {Element|DocumentFragment}\n */\n\nfunction extractContent(el, asFragment) {\n  var child;\n  var rawContent;\n  /* istanbul ignore if */\n  if (isTemplate(el) && isFragment(el.content)) {\n    el = el.content;\n  }\n  if (el.hasChildNodes()) {\n    trimNode(el);\n    rawContent = asFragment ? document.createDocumentFragment() : document.createElement('div');\n    /* eslint-disable no-cond-assign */\n    while (child = el.firstChild) {\n      /* eslint-enable no-cond-assign */\n      rawContent.appendChild(child);\n    }\n  }\n  return rawContent;\n}\n\n/**\n * Trim possible empty head/tail text and comment\n * nodes inside a parent.\n *\n * @param {Node} node\n */\n\nfunction trimNode(node) {\n  var child;\n  /* eslint-disable no-sequences */\n  while ((child = node.firstChild, isTrimmable(child))) {\n    node.removeChild(child);\n  }\n  while ((child = node.lastChild, isTrimmable(child))) {\n    node.removeChild(child);\n  }\n  /* eslint-enable no-sequences */\n}\n\nfunction isTrimmable(node) {\n  return node && (node.nodeType === 3 && !node.data.trim() || node.nodeType === 8);\n}\n\n/**\n * Check if an element is a template tag.\n * Note if the template appears inside an SVG its tagName\n * will be in lowercase.\n *\n * @param {Element} el\n */\n\nfunction isTemplate(el) {\n  return el.tagName && el.tagName.toLowerCase() === 'template';\n}\n\n/**\n * Create an \"anchor\" for performing dom insertion/removals.\n * This is used in a number of scenarios:\n * - fragment instance\n * - v-html\n * - v-if\n * - v-for\n * - component\n *\n * @param {String} content\n * @param {Boolean} persist - IE trashes empty textNodes on\n *                            cloneNode(true), so in certain\n *                            cases the anchor needs to be\n *                            non-empty to be persisted in\n *                            templates.\n * @return {Comment|Text}\n */\n\nfunction createAnchor(content, persist) {\n  var anchor = config.debug ? document.createComment(content) : document.createTextNode(persist ? ' ' : '');\n  anchor.__v_anchor = true;\n  return anchor;\n}\n\n/**\n * Find a component ref attribute that starts with $.\n *\n * @param {Element} node\n * @return {String|undefined}\n */\n\nvar refRE = /^v-ref:/;\n\nfunction findRef(node) {\n  if (node.hasAttributes()) {\n    var attrs = node.attributes;\n    for (var i = 0, l = attrs.length; i < l; i++) {\n      var name = attrs[i].name;\n      if (refRE.test(name)) {\n        return camelize(name.replace(refRE, ''));\n      }\n    }\n  }\n}\n\n/**\n * Map a function to a range of nodes .\n *\n * @param {Node} node\n * @param {Node} end\n * @param {Function} op\n */\n\nfunction mapNodeRange(node, end, op) {\n  var next;\n  while (node !== end) {\n    next = node.nextSibling;\n    op(node);\n    node = next;\n  }\n  op(end);\n}\n\n/**\n * Remove a range of nodes with transition, store\n * the nodes in a fragment with correct ordering,\n * and call callback when done.\n *\n * @param {Node} start\n * @param {Node} end\n * @param {Vue} vm\n * @param {DocumentFragment} frag\n * @param {Function} cb\n */\n\nfunction removeNodeRange(start, end, vm, frag, cb) {\n  var done = false;\n  var removed = 0;\n  var nodes = [];\n  mapNodeRange(start, end, function (node) {\n    if (node === end) done = true;\n    nodes.push(node);\n    removeWithTransition(node, vm, onRemoved);\n  });\n  function onRemoved() {\n    removed++;\n    if (done && removed >= nodes.length) {\n      for (var i = 0; i < nodes.length; i++) {\n        frag.appendChild(nodes[i]);\n      }\n      cb && cb();\n    }\n  }\n}\n\n/**\n * Check if a node is a DocumentFragment.\n *\n * @param {Node} node\n * @return {Boolean}\n */\n\nfunction isFragment(node) {\n  return node && node.nodeType === 11;\n}\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n *\n * @param {Element} el\n * @return {String}\n */\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\nvar commonTagRE = /^(div|p|span|img|a|b|i|br|ul|ol|li|h1|h2|h3|h4|h5|h6|code|pre|table|th|td|tr|form|label|input|select|option|nav|article|section|header|footer)$/i;\nvar reservedTagRE = /^(slot|partial|component)$/i;\n\n/**\n * Check if an element is a component, if yes return its\n * component id.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Object|undefined}\n */\n\nfunction checkComponentAttr(el, options) {\n  var tag = el.tagName.toLowerCase();\n  var hasAttrs = el.hasAttributes();\n  if (!commonTagRE.test(tag) && !reservedTagRE.test(tag)) {\n    if (resolveAsset(options, 'components', tag)) {\n      return { id: tag };\n    } else {\n      var is = hasAttrs && getIsBinding(el, options);\n      if (is) {\n        return is;\n      } else if ('production' !== 'production') {}\n    }\n  } else if (hasAttrs) {\n    return getIsBinding(el, options);\n  }\n}\n\n/**\n * Get \"is\" binding from an element.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Object|undefined}\n */\n\nfunction getIsBinding(el, options) {\n  // dynamic syntax\n  var exp = el.getAttribute('is');\n  if (exp != null) {\n    if (resolveAsset(options, 'components', exp)) {\n      el.removeAttribute('is');\n      return { id: exp };\n    }\n  } else {\n    exp = getBindAttr(el, 'is');\n    if (exp != null) {\n      return { id: exp, dynamic: true };\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 *\n * All strategy functions follow the same signature:\n *\n * @param {*} parentVal\n * @param {*} childVal\n * @param {Vue} [vm]\n */\n\nvar strats = config.optionMergeStrategies = Object.create(null);\n\n/**\n * Helper that recursively merges two data objects together.\n */\n\nfunction mergeData(to, from) {\n  var key, toVal, fromVal;\n  for (key in from) {\n    toVal = to[key];\n    fromVal = from[key];\n    if (!hasOwn(to, key)) {\n      set(to, key, fromVal);\n    } else if (isObject(toVal) && isObject(fromVal)) {\n      mergeData(toVal, fromVal);\n    }\n  }\n  return to;\n}\n\n/**\n * Data\n */\n\nstrats.data = function (parentVal, childVal, vm) {\n  if (!vm) {\n    // in a Vue.extend merge, both should be functions\n    if (!childVal) {\n      return parentVal;\n    }\n    if (typeof childVal !== 'function') {\n      'production' !== 'production' && warn('The \"data\" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm);\n      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(childVal.call(this), parentVal.call(this));\n    };\n  } else if (parentVal || childVal) {\n    return function mergedInstanceDataFn() {\n      // instance merge\n      var instanceData = typeof childVal === 'function' ? childVal.call(vm) : childVal;\n      var defaultData = typeof parentVal === 'function' ? parentVal.call(vm) : undefined;\n      if (instanceData) {\n        return mergeData(instanceData, defaultData);\n      } else {\n        return defaultData;\n      }\n    };\n  }\n};\n\n/**\n * El\n */\n\nstrats.el = function (parentVal, childVal, vm) {\n  if (!vm && childVal && typeof childVal !== 'function') {\n    'production' !== 'production' && warn('The \"el\" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm);\n    return;\n  }\n  var ret = childVal || parentVal;\n  // invoke the element factory if this is instance merge\n  return vm && typeof ret === 'function' ? ret.call(vm) : ret;\n};\n\n/**\n * Hooks and param attributes are merged as arrays.\n */\n\nstrats.init = strats.created = strats.ready = strats.attached = strats.detached = strats.beforeCompile = strats.compiled = strats.beforeDestroy = strats.destroyed = strats.activate = function (parentVal, childVal) {\n  return childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal;\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 */\n\nfunction mergeAssets(parentVal, childVal) {\n  var res = Object.create(parentVal || null);\n  return childVal ? extend(res, guardArrayAssets(childVal)) : res;\n}\n\nconfig._assetTypes.forEach(function (type) {\n  strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Events & Watchers.\n *\n * Events & watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\n\nstrats.watch = strats.events = function (parentVal, childVal) {\n  if (!childVal) return parentVal;\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 && !isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key] = parent ? parent.concat(child) : [child];\n  }\n  return ret;\n};\n\n/**\n * Other object hashes.\n */\n\nstrats.props = strats.methods = strats.computed = function (parentVal, childVal) {\n  if (!childVal) return parentVal;\n  if (!parentVal) return childVal;\n  var ret = Object.create(null);\n  extend(ret, parentVal);\n  extend(ret, childVal);\n  return ret;\n};\n\n/**\n * Default strategy.\n */\n\nvar defaultStrat = function defaultStrat(parentVal, childVal) {\n  return childVal === undefined ? parentVal : childVal;\n};\n\n/**\n * Make sure component options get converted to actual\n * constructors.\n *\n * @param {Object} options\n */\n\nfunction guardComponents(options) {\n  if (options.components) {\n    var components = options.components = guardArrayAssets(options.components);\n    var ids = Object.keys(components);\n    var def;\n    if ('production' !== 'production') {}\n    for (var i = 0, l = ids.length; i < l; i++) {\n      var key = ids[i];\n      if (commonTagRE.test(key) || reservedTagRE.test(key)) {\n        'production' !== 'production' && warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + key);\n        continue;\n      }\n      // record a all lowercase <-> kebab-case mapping for\n      // possible custom element case error warning\n      if ('production' !== 'production') {}\n      def = components[key];\n      if (isPlainObject(def)) {\n        components[key] = Vue.extend(def);\n      }\n    }\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n *\n * @param {Object} options\n */\n\nfunction guardProps(options) {\n  var props = options.props;\n  var i, val;\n  if (isArray(props)) {\n    options.props = {};\n    i = props.length;\n    while (i--) {\n      val = props[i];\n      if (typeof val === 'string') {\n        options.props[val] = null;\n      } else if (val.name) {\n        options.props[val.name] = val;\n      }\n    }\n  } else if (isPlainObject(props)) {\n    var keys = Object.keys(props);\n    i = keys.length;\n    while (i--) {\n      val = props[keys[i]];\n      if (typeof val === 'function') {\n        props[keys[i]] = { type: val };\n      }\n    }\n  }\n}\n\n/**\n * Guard an Array-format assets option and converted it\n * into the key-value Object format.\n *\n * @param {Object|Array} assets\n * @return {Object}\n */\n\nfunction guardArrayAssets(assets) {\n  if (isArray(assets)) {\n    var res = {};\n    var i = assets.length;\n    var asset;\n    while (i--) {\n      asset = assets[i];\n      var id = typeof asset === 'function' ? asset.options && asset.options.name || asset.id : asset.name || asset.id;\n      if (!id) {\n        'production' !== 'production' && warn('Array-syntax assets must provide a \"name\" or \"id\" field.');\n      } else {\n        res[id] = asset;\n      }\n    }\n    return res;\n  }\n  return assets;\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n *\n * @param {Object} parent\n * @param {Object} child\n * @param {Vue} [vm] - if vm is present, indicates this is\n *                     an instantiation merge.\n */\n\nfunction mergeOptions(parent, child, vm) {\n  guardComponents(child);\n  guardProps(child);\n  if ('production' !== 'production') {}\n  var options = {};\n  var key;\n  if (child['extends']) {\n    parent = typeof child['extends'] === 'function' ? mergeOptions(parent, child['extends'].options, vm) : mergeOptions(parent, child['extends'], vm);\n  }\n  if (child.mixins) {\n    for (var i = 0, l = child.mixins.length; i < l; i++) {\n      var mixin = child.mixins[i];\n      var mixinOptions = mixin.prototype instanceof Vue ? mixin.options : mixin;\n      parent = mergeOptions(parent, mixinOptions, vm);\n    }\n  }\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 *\n * @param {Object} options\n * @param {String} type\n * @param {String} id\n * @param {Boolean} warnMissing\n * @return {Object|Function}\n */\n\nfunction resolveAsset(options, type, id, warnMissing) {\n  /* istanbul ignore if */\n  if (typeof id !== 'string') {\n    return;\n  }\n  var assets = options[type];\n  var camelizedId;\n  var res = assets[id] ||\n  // camelCase ID\n  assets[camelizedId = camelize(id)] ||\n  // Pascal Case ID\n  assets[camelizedId.charAt(0).toUpperCase() + camelizedId.slice(1)];\n  if ('production' !== 'production' && warnMissing && !res) {}\n  return res;\n}\n\nvar uid$1 = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n *\n * @constructor\n */\nfunction Dep() {\n  this.id = uid$1++;\n  this.subs = [];\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;\n\n/**\n * Add a directive subscriber.\n *\n * @param {Directive} sub\n */\n\nDep.prototype.addSub = function (sub) {\n  this.subs.push(sub);\n};\n\n/**\n * Remove a directive subscriber.\n *\n * @param {Directive} sub\n */\n\nDep.prototype.removeSub = function (sub) {\n  this.subs.$remove(sub);\n};\n\n/**\n * Add self as a dependency to the target watcher.\n */\n\nDep.prototype.depend = function () {\n  Dep.target.addDep(this);\n};\n\n/**\n * Notify all subscribers of a new value.\n */\n\nDep.prototype.notify = function () {\n  // stablize the subscriber list first\n  var subs = toArray(this.subs);\n  for (var i = 0, l = subs.length; i < l; i++) {\n    subs[i].update();\n  }\n};\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto)\n\n/**\n * Intercept mutating methods and emit events\n */\n\n;['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'].forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  def(arrayMethods, method, function mutator() {\n    // avoid leaking arguments:\n    // http://jsperf.com/closure-with-arguments\n    var i = arguments.length;\n    var args = new Array(i);\n    while (i--) {\n      args[i] = arguments[i];\n    }\n    var result = original.apply(this, args);\n    var ob = this.__ob__;\n    var inserted;\n    switch (method) {\n      case 'push':\n        inserted = args;\n        break;\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 * Swap the element at the given index with a new value\n * and emits corresponding event.\n *\n * @param {Number} index\n * @param {*} val\n * @return {*} - replaced element\n */\n\ndef(arrayProto, '$set', function $set(index, val) {\n  if (index >= this.length) {\n    this.length = Number(index) + 1;\n  }\n  return this.splice(index, 1, val)[0];\n});\n\n/**\n * Convenience method to remove the element at given index or target element reference.\n *\n * @param {*} item\n */\n\ndef(arrayProto, '$remove', function $remove(item) {\n  /* istanbul ignore if */\n  if (!this.length) return;\n  var index = indexOf(this, item);\n  if (index > -1) {\n    return this.splice(index, 1);\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 in certain cases, e.g.\n * v-for scope alias and props, we don't want to force conversion\n * because the value may be a nested value under a frozen data structure.\n *\n * So whenever we want to set a reactive property without forcing\n * conversion on the new value, we wrap that call inside this function.\n */\n\nvar shouldConvert = true;\n\nfunction withoutConversion(fn) {\n  shouldConvert = false;\n  fn();\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 *\n * @param {Array|Object} value\n * @constructor\n */\n\nfunction Observer(value) {\n  this.value = value;\n  this.dep = new Dep();\n  def(value, '__ob__', this);\n  if (isArray(value)) {\n    var augment = hasProto ? protoAugment : copyAugment;\n    augment(value, arrayMethods, arrayKeys);\n    this.observeArray(value);\n  } else {\n    this.walk(value);\n  }\n}\n\n// Instance methods\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 *\n * @param {Object} obj\n */\n\nObserver.prototype.walk = function (obj) {\n  var keys = Object.keys(obj);\n  for (var i = 0, l = keys.length; i < l; i++) {\n    this.convert(keys[i], obj[keys[i]]);\n  }\n};\n\n/**\n * Observe a list of Array items.\n *\n * @param {Array} items\n */\n\nObserver.prototype.observeArray = function (items) {\n  for (var i = 0, l = items.length; i < l; i++) {\n    observe(items[i]);\n  }\n};\n\n/**\n * Convert a property into getter/setter so we can emit\n * the events when the property is accessed/changed.\n *\n * @param {String} key\n * @param {*} val\n */\n\nObserver.prototype.convert = function (key, val) {\n  defineReactive(this.value, key, val);\n};\n\n/**\n * Add an owner vm, so that when $set/$delete mutations\n * happen we can notify owner vms to proxy the keys and\n * digest the watchers. This is only called when the object\n * is observed as an instance's root $data.\n *\n * @param {Vue} vm\n */\n\nObserver.prototype.addVm = function (vm) {\n  (this.vms || (this.vms = [])).push(vm);\n};\n\n/**\n * Remove an owner vm. This is called when the object is\n * swapped out as an instance's $data object.\n *\n * @param {Vue} vm\n */\n\nObserver.prototype.removeVm = function (vm) {\n  this.vms.$remove(vm);\n};\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n *\n * @param {Object|Array} target\n * @param {Object} src\n */\n\nfunction protoAugment(target, src) {\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 * @param {Object|Array} target\n * @param {Object} proto\n */\n\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 *\n * @param {*} value\n * @param {Vue} [vm]\n * @return {Observer|undefined}\n * @static\n */\n\nfunction observe(value, vm) {\n  if (!value || typeof value !== 'object') {\n    return;\n  }\n  var ob;\n  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if (shouldConvert && (isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value._isVue) {\n    ob = new Observer(value);\n  }\n  if (ob && vm) {\n    ob.addVm(vm);\n  }\n  return ob;\n}\n\n/**\n * Define a reactive property on an Object.\n *\n * @param {Object} obj\n * @param {String} key\n * @param {*} val\n */\n\nfunction defineReactive(obj, key, val) {\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 = 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 (isArray(value)) {\n          for (var e, i = 0, l = value.length; i < l; i++) {\n            e = value[i];\n            e && e.__ob__ && e.__ob__.dep.depend();\n          }\n        }\n      }\n      return value;\n    },\n    set: function reactiveSetter(newVal) {\n      var value = getter ? getter.call(obj) : val;\n      if (newVal === value) {\n        return;\n      }\n      if (setter) {\n        setter.call(obj, newVal);\n      } else {\n        val = newVal;\n      }\n      childOb = observe(newVal);\n      dep.notify();\n    }\n  });\n}\n\n\n\nvar util = Object.freeze({\n\tdefineReactive: defineReactive,\n\tset: set,\n\tdel: del,\n\thasOwn: hasOwn,\n\tisLiteral: isLiteral,\n\tisReserved: isReserved,\n\t_toString: _toString,\n\ttoNumber: toNumber,\n\ttoBoolean: toBoolean,\n\tstripQuotes: stripQuotes,\n\tcamelize: camelize,\n\thyphenate: hyphenate,\n\tclassify: classify,\n\tbind: bind,\n\ttoArray: toArray,\n\textend: extend,\n\tisObject: isObject,\n\tisPlainObject: isPlainObject,\n\tdef: def,\n\tdebounce: _debounce,\n\tindexOf: indexOf,\n\tcancellable: cancellable,\n\tlooseEqual: looseEqual,\n\tisArray: isArray,\n\thasProto: hasProto,\n\tinBrowser: inBrowser,\n\tdevtools: devtools,\n\tisIE: isIE,\n\tisIE9: isIE9,\n\tisAndroid: isAndroid,\n\tisIOS: isIOS,\n\tget transitionProp () { return transitionProp; },\n\tget transitionEndEvent () { return transitionEndEvent; },\n\tget animationProp () { return animationProp; },\n\tget animationEndEvent () { return animationEndEvent; },\n\tnextTick: nextTick,\n\tget _Set () { return _Set; },\n\tquery: query,\n\tinDoc: inDoc,\n\tgetAttr: getAttr,\n\tgetBindAttr: getBindAttr,\n\thasBindAttr: hasBindAttr,\n\tbefore: before,\n\tafter: after,\n\tremove: remove,\n\tprepend: prepend,\n\treplace: replace,\n\ton: on,\n\toff: off,\n\tsetClass: setClass,\n\taddClass: addClass,\n\tremoveClass: removeClass,\n\textractContent: extractContent,\n\ttrimNode: trimNode,\n\tisTemplate: isTemplate,\n\tcreateAnchor: createAnchor,\n\tfindRef: findRef,\n\tmapNodeRange: mapNodeRange,\n\tremoveNodeRange: removeNodeRange,\n\tisFragment: isFragment,\n\tgetOuterHTML: getOuterHTML,\n\tmergeOptions: mergeOptions,\n\tresolveAsset: resolveAsset,\n\tcheckComponentAttr: checkComponentAttr,\n\tcommonTagRE: commonTagRE,\n\treservedTagRE: reservedTagRE,\n\twarn: warn\n});\n\nvar uid = 0;\n\nfunction initMixin (Vue) {\n  /**\n   * The main init sequence. This is called for every\n   * instance, including ones that are created from extended\n   * constructors.\n   *\n   * @param {Object} options - this options object should be\n   *                           the result of merging class\n   *                           options and the options passed\n   *                           in to the constructor.\n   */\n\n  Vue.prototype._init = function (options) {\n    options = options || {};\n\n    this.$el = null;\n    this.$parent = options.parent;\n    this.$root = this.$parent ? this.$parent.$root : this;\n    this.$children = [];\n    this.$refs = {}; // child vm references\n    this.$els = {}; // element references\n    this._watchers = []; // all watchers as an array\n    this._directives = []; // all directives\n\n    // a uid\n    this._uid = uid++;\n\n    // a flag to avoid this being observed\n    this._isVue = true;\n\n    // events bookkeeping\n    this._events = {}; // registered callbacks\n    this._eventsCount = {}; // for $broadcast optimization\n\n    // fragment instance properties\n    this._isFragment = false;\n    this._fragment = // @type {DocumentFragment}\n    this._fragmentStart = // @type {Text|Comment}\n    this._fragmentEnd = null; // @type {Text|Comment}\n\n    // lifecycle state\n    this._isCompiled = this._isDestroyed = this._isReady = this._isAttached = this._isBeingDestroyed = this._vForRemoving = false;\n    this._unlinkFn = null;\n\n    // context:\n    // if this is a transcluded component, context\n    // will be the common parent vm of this instance\n    // and its host.\n    this._context = options._context || this.$parent;\n\n    // scope:\n    // if this is inside an inline v-for, the scope\n    // will be the intermediate scope created for this\n    // repeat fragment. this is used for linking props\n    // and container directives.\n    this._scope = options._scope;\n\n    // fragment:\n    // if this instance is compiled inside a Fragment, it\n    // needs to register itself as a child of that fragment\n    // for attach/detach to work properly.\n    this._frag = options._frag;\n    if (this._frag) {\n      this._frag.children.push(this);\n    }\n\n    // push self into parent / transclusion host\n    if (this.$parent) {\n      this.$parent.$children.push(this);\n    }\n\n    // merge options.\n    options = this.$options = mergeOptions(this.constructor.options, options, this);\n\n    // set ref\n    this._updateRef();\n\n    // initialize data as empty object.\n    // it will be filled up in _initData().\n    this._data = {};\n\n    // call init hook\n    this._callHook('init');\n\n    // initialize data observation and scope inheritance.\n    this._initState();\n\n    // setup event system and option events.\n    this._initEvents();\n\n    // call created hook\n    this._callHook('created');\n\n    // if `el` option is passed, start compilation.\n    if (options.el) {\n      this.$mount(options.el);\n    }\n  };\n}\n\nvar pathCache = new Cache(1000);\n\n// actions\nvar APPEND = 0;\nvar PUSH = 1;\nvar INC_SUB_PATH_DEPTH = 2;\nvar PUSH_SUB_PATH = 3;\n\n// states\nvar BEFORE_PATH = 0;\nvar IN_PATH = 1;\nvar BEFORE_IDENT = 2;\nvar IN_IDENT = 3;\nvar IN_SUB_PATH = 4;\nvar IN_SINGLE_QUOTE = 5;\nvar IN_DOUBLE_QUOTE = 6;\nvar AFTER_PATH = 7;\nvar ERROR = 8;\n\nvar pathStateMachine = [];\n\npathStateMachine[BEFORE_PATH] = {\n  'ws': [BEFORE_PATH],\n  'ident': [IN_IDENT, APPEND],\n  '[': [IN_SUB_PATH],\n  'eof': [AFTER_PATH]\n};\n\npathStateMachine[IN_PATH] = {\n  'ws': [IN_PATH],\n  '.': [BEFORE_IDENT],\n  '[': [IN_SUB_PATH],\n  'eof': [AFTER_PATH]\n};\n\npathStateMachine[BEFORE_IDENT] = {\n  'ws': [BEFORE_IDENT],\n  'ident': [IN_IDENT, APPEND]\n};\n\npathStateMachine[IN_IDENT] = {\n  'ident': [IN_IDENT, APPEND],\n  '0': [IN_IDENT, APPEND],\n  'number': [IN_IDENT, APPEND],\n  'ws': [IN_PATH, PUSH],\n  '.': [BEFORE_IDENT, PUSH],\n  '[': [IN_SUB_PATH, PUSH],\n  'eof': [AFTER_PATH, PUSH]\n};\n\npathStateMachine[IN_SUB_PATH] = {\n  \"'\": [IN_SINGLE_QUOTE, APPEND],\n  '\"': [IN_DOUBLE_QUOTE, APPEND],\n  '[': [IN_SUB_PATH, INC_SUB_PATH_DEPTH],\n  ']': [IN_PATH, PUSH_SUB_PATH],\n  'eof': ERROR,\n  'else': [IN_SUB_PATH, APPEND]\n};\n\npathStateMachine[IN_SINGLE_QUOTE] = {\n  \"'\": [IN_SUB_PATH, APPEND],\n  'eof': ERROR,\n  'else': [IN_SINGLE_QUOTE, APPEND]\n};\n\npathStateMachine[IN_DOUBLE_QUOTE] = {\n  '\"': [IN_SUB_PATH, APPEND],\n  'eof': ERROR,\n  'else': [IN_DOUBLE_QUOTE, APPEND]\n};\n\n/**\n * Determine the type of a character in a keypath.\n *\n * @param {Char} ch\n * @return {String} type\n */\n\nfunction getPathCharType(ch) {\n  if (ch === undefined) {\n    return 'eof';\n  }\n\n  var code = ch.charCodeAt(0);\n\n  switch (code) {\n    case 0x5B: // [\n    case 0x5D: // ]\n    case 0x2E: // .\n    case 0x22: // \"\n    case 0x27: // '\n    case 0x30:\n      // 0\n      return ch;\n\n    case 0x5F: // _\n    case 0x24:\n      // $\n      return 'ident';\n\n    case 0x20: // Space\n    case 0x09: // Tab\n    case 0x0A: // Newline\n    case 0x0D: // Return\n    case 0xA0: // No-break space\n    case 0xFEFF: // Byte Order Mark\n    case 0x2028: // Line Separator\n    case 0x2029:\n      // Paragraph Separator\n      return 'ws';\n  }\n\n  // a-z, A-Z\n  if (code >= 0x61 && code <= 0x7A || code >= 0x41 && code <= 0x5A) {\n    return 'ident';\n  }\n\n  // 1-9\n  if (code >= 0x31 && code <= 0x39) {\n    return 'number';\n  }\n\n  return 'else';\n}\n\n/**\n * Format a subPath, return its plain form if it is\n * a literal string or number. Otherwise prepend the\n * dynamic indicator (*).\n *\n * @param {String} path\n * @return {String}\n */\n\nfunction formatSubPath(path) {\n  var trimmed = path.trim();\n  // invalid leading 0\n  if (path.charAt(0) === '0' && isNaN(path)) {\n    return false;\n  }\n  return isLiteral(trimmed) ? stripQuotes(trimmed) : '*' + trimmed;\n}\n\n/**\n * Parse a string path into an array of segments\n *\n * @param {String} path\n * @return {Array|undefined}\n */\n\nfunction parse(path) {\n  var keys = [];\n  var index = -1;\n  var mode = BEFORE_PATH;\n  var subPathDepth = 0;\n  var c, newChar, key, type, transition, action, typeMap;\n\n  var actions = [];\n\n  actions[PUSH] = function () {\n    if (key !== undefined) {\n      keys.push(key);\n      key = undefined;\n    }\n  };\n\n  actions[APPEND] = function () {\n    if (key === undefined) {\n      key = newChar;\n    } else {\n      key += newChar;\n    }\n  };\n\n  actions[INC_SUB_PATH_DEPTH] = function () {\n    actions[APPEND]();\n    subPathDepth++;\n  };\n\n  actions[PUSH_SUB_PATH] = function () {\n    if (subPathDepth > 0) {\n      subPathDepth--;\n      mode = IN_SUB_PATH;\n      actions[APPEND]();\n    } else {\n      subPathDepth = 0;\n      key = formatSubPath(key);\n      if (key === false) {\n        return false;\n      } else {\n        actions[PUSH]();\n      }\n    }\n  };\n\n  function maybeUnescapeQuote() {\n    var nextChar = path[index + 1];\n    if (mode === IN_SINGLE_QUOTE && nextChar === \"'\" || mode === IN_DOUBLE_QUOTE && nextChar === '\"') {\n      index++;\n      newChar = '\\\\' + nextChar;\n      actions[APPEND]();\n      return true;\n    }\n  }\n\n  while (mode != null) {\n    index++;\n    c = path[index];\n\n    if (c === '\\\\' && maybeUnescapeQuote()) {\n      continue;\n    }\n\n    type = getPathCharType(c);\n    typeMap = pathStateMachine[mode];\n    transition = typeMap[type] || typeMap['else'] || ERROR;\n\n    if (transition === ERROR) {\n      return; // parse error\n    }\n\n    mode = transition[0];\n    action = actions[transition[1]];\n    if (action) {\n      newChar = transition[2];\n      newChar = newChar === undefined ? c : newChar;\n      if (action() === false) {\n        return;\n      }\n    }\n\n    if (mode === AFTER_PATH) {\n      keys.raw = path;\n      return keys;\n    }\n  }\n}\n\n/**\n * External parse that check for a cache hit first\n *\n * @param {String} path\n * @return {Array|undefined}\n */\n\nfunction parsePath(path) {\n  var hit = pathCache.get(path);\n  if (!hit) {\n    hit = parse(path);\n    if (hit) {\n      pathCache.put(path, hit);\n    }\n  }\n  return hit;\n}\n\n/**\n * Get from an object from a path string\n *\n * @param {Object} obj\n * @param {String} path\n */\n\nfunction getPath(obj, path) {\n  return parseExpression$1(path).get(obj);\n}\n\n/**\n * Set on an object from a path\n *\n * @param {Object} obj\n * @param {String | Array} path\n * @param {*} val\n */\n\nfunction setPath(obj, path, val) {\n  var original = obj;\n  if (typeof path === 'string') {\n    path = parse(path);\n  }\n  if (!path || !isObject(obj)) {\n    return false;\n  }\n  var last, key;\n  for (var i = 0, l = path.length; i < l; i++) {\n    last = obj;\n    key = path[i];\n    if (key.charAt(0) === '*') {\n      key = parseExpression$1(key.slice(1)).get.call(original, original);\n    }\n    if (i < l - 1) {\n      obj = obj[key];\n      if (!isObject(obj)) {\n        obj = {};\n        if ('production' !== 'production' && last._isVue) {}\n        set(last, key, obj);\n      }\n    } else {\n      if (isArray(obj)) {\n        obj.$set(key, val);\n      } else if (key in obj) {\n        obj[key] = val;\n      } else {\n        if ('production' !== 'production' && obj._isVue) {}\n        set(obj, key, val);\n      }\n    }\n  }\n  return true;\n}\n\nvar path = Object.freeze({\n  parsePath: parsePath,\n  getPath: getPath,\n  setPath: setPath\n});\n\nvar expressionCache = new Cache(1000);\n\nvar allowedKeywords = 'Math,Date,this,true,false,null,undefined,Infinity,NaN,' + 'isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,' + 'encodeURIComponent,parseInt,parseFloat';\nvar allowedKeywordsRE = new RegExp('^(' + allowedKeywords.replace(/,/g, '\\\\b|') + '\\\\b)');\n\n// keywords that don't make sense inside expressions\nvar improperKeywords = 'break,case,class,catch,const,continue,debugger,default,' + 'delete,do,else,export,extends,finally,for,function,if,' + 'import,in,instanceof,let,return,super,switch,throw,try,' + 'var,while,with,yield,enum,await,implements,package,' + 'protected,static,interface,private,public';\nvar improperKeywordsRE = new RegExp('^(' + improperKeywords.replace(/,/g, '\\\\b|') + '\\\\b)');\n\nvar wsRE = /\\s/g;\nvar newlineRE = /\\n/g;\nvar saveRE = /[\\{,]\\s*[\\w\\$_]+\\s*:|('(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\\"']|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`)|new |typeof |void /g;\nvar restoreRE = /\"(\\d+)\"/g;\nvar pathTestRE = /^[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?'\\]|\\[\".*?\"\\]|\\[\\d+\\]|\\[[A-Za-z_$][\\w$]*\\])*$/;\nvar identRE = /[^\\w$\\.](?:[A-Za-z_$][\\w$]*)/g;\nvar literalValueRE$1 = /^(?:true|false|null|undefined|Infinity|NaN)$/;\n\nfunction noop() {}\n\n/**\n * Save / Rewrite / Restore\n *\n * When rewriting paths found in an expression, it is\n * possible for the same letter sequences to be found in\n * strings and Object literal property keys. Therefore we\n * remove and store these parts in a temporary array, and\n * restore them after the path rewrite.\n */\n\nvar saved = [];\n\n/**\n * Save replacer\n *\n * The save regex can match two possible cases:\n * 1. An opening object literal\n * 2. A string\n * If matched as a plain string, we need to escape its\n * newlines, since the string needs to be preserved when\n * generating the function body.\n *\n * @param {String} str\n * @param {String} isString - str if matched as a string\n * @return {String} - placeholder with index\n */\n\nfunction save(str, isString) {\n  var i = saved.length;\n  saved[i] = isString ? str.replace(newlineRE, '\\\\n') : str;\n  return '\"' + i + '\"';\n}\n\n/**\n * Path rewrite replacer\n *\n * @param {String} raw\n * @return {String}\n */\n\nfunction rewrite(raw) {\n  var c = raw.charAt(0);\n  var path = raw.slice(1);\n  if (allowedKeywordsRE.test(path)) {\n    return raw;\n  } else {\n    path = path.indexOf('\"') > -1 ? path.replace(restoreRE, restore) : path;\n    return c + 'scope.' + path;\n  }\n}\n\n/**\n * Restore replacer\n *\n * @param {String} str\n * @param {String} i - matched save index\n * @return {String}\n */\n\nfunction restore(str, i) {\n  return saved[i];\n}\n\n/**\n * Rewrite an expression, prefixing all path accessors with\n * `scope.` and generate getter/setter functions.\n *\n * @param {String} exp\n * @return {Function}\n */\n\nfunction compileGetter(exp) {\n  if (improperKeywordsRE.test(exp)) {\n    'production' !== 'production' && warn('Avoid using reserved keywords in expression: ' + exp);\n  }\n  // reset state\n  saved.length = 0;\n  // save strings and object literal keys\n  var body = exp.replace(saveRE, save).replace(wsRE, '');\n  // rewrite all paths\n  // pad 1 space here because the regex matches 1 extra char\n  body = (' ' + body).replace(identRE, rewrite).replace(restoreRE, restore);\n  return makeGetterFn(body);\n}\n\n/**\n * Build a getter function. Requires eval.\n *\n * We isolate the try/catch so it doesn't affect the\n * optimization of the parse function when it is not called.\n *\n * @param {String} body\n * @return {Function|undefined}\n */\n\nfunction makeGetterFn(body) {\n  try {\n    /* eslint-disable no-new-func */\n    return new Function('scope', 'return ' + body + ';');\n    /* eslint-enable no-new-func */\n  } catch (e) {\n    if ('production' !== 'production') {}\n    return noop;\n  }\n}\n\n/**\n * Compile a setter function for the expression.\n *\n * @param {String} exp\n * @return {Function|undefined}\n */\n\nfunction compileSetter(exp) {\n  var path = parsePath(exp);\n  if (path) {\n    return function (scope, val) {\n      setPath(scope, path, val);\n    };\n  } else {\n    'production' !== 'production' && warn('Invalid setter expression: ' + exp);\n  }\n}\n\n/**\n * Parse an expression into re-written getter/setters.\n *\n * @param {String} exp\n * @param {Boolean} needSet\n * @return {Function}\n */\n\nfunction parseExpression$1(exp, needSet) {\n  exp = exp.trim();\n  // try cache\n  var hit = expressionCache.get(exp);\n  if (hit) {\n    if (needSet && !hit.set) {\n      hit.set = compileSetter(hit.exp);\n    }\n    return hit;\n  }\n  var res = { exp: exp };\n  res.get = isSimplePath(exp) && exp.indexOf('[') < 0\n  // optimized super simple getter\n  ? makeGetterFn('scope.' + exp)\n  // dynamic getter\n  : compileGetter(exp);\n  if (needSet) {\n    res.set = compileSetter(exp);\n  }\n  expressionCache.put(exp, res);\n  return res;\n}\n\n/**\n * Check if an expression is a simple path.\n *\n * @param {String} exp\n * @return {Boolean}\n */\n\nfunction isSimplePath(exp) {\n  return pathTestRE.test(exp) &&\n  // don't treat literal values as paths\n  !literalValueRE$1.test(exp) &&\n  // Math constants e.g. Math.PI, Math.E etc.\n  exp.slice(0, 5) !== 'Math.';\n}\n\nvar expression = Object.freeze({\n  parseExpression: parseExpression$1,\n  isSimplePath: isSimplePath\n});\n\n// we have two separate queues: one for directive updates\n// and one for user watcher registered via $watch().\n// we want to guarantee directive updates to be called\n// before user watchers so that when user watchers are\n// triggered, the DOM would have already been in updated\n// state.\n\nvar queue = [];\nvar userQueue = [];\nvar has = {};\nvar circular = {};\nvar waiting = false;\n\n/**\n * Reset the batcher's state.\n */\n\nfunction resetBatcherState() {\n  queue.length = 0;\n  userQueue.length = 0;\n  has = {};\n  circular = {};\n  waiting = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\n\nfunction flushBatcherQueue() {\n  var _again = true;\n\n  _function: while (_again) {\n    _again = false;\n\n    runBatcherQueue(queue);\n    runBatcherQueue(userQueue);\n    // user watchers triggered more watchers,\n    // keep flushing until it depletes\n    if (queue.length) {\n      _again = true;\n      continue _function;\n    }\n    // dev tool hook\n    /* istanbul ignore if */\n    if (devtools && config.devtools) {\n      devtools.emit('flush');\n    }\n    resetBatcherState();\n  }\n}\n\n/**\n * Run the watchers in a single queue.\n *\n * @param {Array} queue\n */\n\nfunction runBatcherQueue(queue) {\n  // do not cache length because more watchers might be pushed\n  // as we run existing watchers\n  for (var i = 0; i < queue.length; i++) {\n    var watcher = queue[i];\n    var id = watcher.id;\n    has[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if ('production' !== 'production' && has[id] != null) {}\n  }\n  queue.length = 0;\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 *\n * @param {Watcher} watcher\n *   properties:\n *   - {Number} id\n *   - {Function} run\n */\n\nfunction pushWatcher(watcher) {\n  var id = watcher.id;\n  if (has[id] == null) {\n    // push watcher into appropriate queue\n    var q = watcher.user ? userQueue : queue;\n    has[id] = q.length;\n    q.push(watcher);\n    // queue the flush\n    if (!waiting) {\n      waiting = true;\n      nextTick(flushBatcherQueue);\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 *\n * @param {Vue} vm\n * @param {String|Function} expOrFn\n * @param {Function} cb\n * @param {Object} options\n *                 - {Array} filters\n *                 - {Boolean} twoWay\n *                 - {Boolean} deep\n *                 - {Boolean} user\n *                 - {Boolean} sync\n *                 - {Boolean} lazy\n *                 - {Function} [preProcess]\n *                 - {Function} [postProcess]\n * @constructor\n */\nfunction Watcher(vm, expOrFn, cb, options) {\n  // mix in options\n  if (options) {\n    extend(this, options);\n  }\n  var isFn = typeof expOrFn === 'function';\n  this.vm = vm;\n  vm._watchers.push(this);\n  this.expression = expOrFn;\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.prevError = null; // for async error stacks\n  // parse expression for getter/setter\n  if (isFn) {\n    this.getter = expOrFn;\n    this.setter = undefined;\n  } else {\n    var res = parseExpression$1(expOrFn, this.twoWay);\n    this.getter = res.get;\n    this.setter = res.set;\n  }\n  this.value = this.lazy ? undefined : this.get();\n  // state for avoiding false triggers for deep and Array\n  // watchers during vm._digest()\n  this.queued = this.shallow = false;\n}\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\n\nWatcher.prototype.get = function () {\n  this.beforeGet();\n  var scope = this.scope || this.vm;\n  var value;\n  try {\n    value = this.getter.call(scope, scope);\n  } catch (e) {\n    if ('production' !== 'production' && config.warnExpressionErrors) {}\n  }\n  // \"touch\" every property so they are all tracked as\n  // dependencies for deep watching\n  if (this.deep) {\n    traverse(value);\n  }\n  if (this.preProcess) {\n    value = this.preProcess(value);\n  }\n  if (this.filters) {\n    value = scope._applyFilters(value, null, this.filters, false);\n  }\n  if (this.postProcess) {\n    value = this.postProcess(value);\n  }\n  this.afterGet();\n  return value;\n};\n\n/**\n * Set the corresponding value with the setter.\n *\n * @param {*} value\n */\n\nWatcher.prototype.set = function (value) {\n  var scope = this.scope || this.vm;\n  if (this.filters) {\n    value = scope._applyFilters(value, this.value, this.filters, true);\n  }\n  try {\n    this.setter.call(scope, scope, value);\n  } catch (e) {\n    if ('production' !== 'production' && config.warnExpressionErrors) {}\n  }\n  // two-way sync for v-for alias\n  var forContext = scope.$forContext;\n  if (forContext && forContext.alias === this.expression) {\n    if (forContext.filters) {\n      'production' !== 'production' && warn('It seems you are using two-way binding on ' + 'a v-for alias (' + this.expression + '), and the ' + 'v-for has filters. This will not work properly. ' + 'Either remove the filters or use an array of ' + 'objects and bind to object properties instead.', this.vm);\n      return;\n    }\n    forContext._withLock(function () {\n      if (scope.$key) {\n        // original is an object\n        forContext.rawValue[scope.$key] = value;\n      } else {\n        forContext.rawValue.$set(scope.$index, value);\n      }\n    });\n  }\n};\n\n/**\n * Prepare for dependency collection.\n */\n\nWatcher.prototype.beforeGet = function () {\n  Dep.target = this;\n};\n\n/**\n * Add a dependency to this directive.\n *\n * @param {Dep} dep\n */\n\nWatcher.prototype.addDep = function (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 */\n\nWatcher.prototype.afterGet = function () {\n  Dep.target = null;\n  var i = this.deps.length;\n  while (i--) {\n    var dep = this.deps[i];\n    if (!this.newDepIds.has(dep.id)) {\n      dep.removeSub(this);\n    }\n  }\n  var tmp = this.depIds;\n  this.depIds = this.newDepIds;\n  this.newDepIds = tmp;\n  this.newDepIds.clear();\n  tmp = this.deps;\n  this.deps = this.newDeps;\n  this.newDeps = tmp;\n  this.newDeps.length = 0;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n *\n * @param {Boolean} shallow\n */\n\nWatcher.prototype.update = function (shallow) {\n  if (this.lazy) {\n    this.dirty = true;\n  } else if (this.sync || !config.async) {\n    this.run();\n  } else {\n    // if queued, only overwrite shallow with non-shallow,\n    // but not the other way around.\n    this.shallow = this.queued ? shallow ? this.shallow : false : !!shallow;\n    this.queued = true;\n    // record before-push error stack in debug mode\n    /* istanbul ignore if */\n    if ('production' !== 'production' && config.debug) {}\n    pushWatcher(this);\n  }\n};\n\n/**\n * Batcher job interface.\n * Will be called by the batcher.\n */\n\nWatcher.prototype.run = function () {\n  if (this.active) {\n    var value = this.get();\n    if (value !== this.value ||\n    // Deep watchers and watchers on Object/Arrays should fire even\n    // when the value is the same, because the value may\n    // have mutated; but only do so if this is a\n    // non-shallow update (caused by a vm digest).\n    (isObject(value) || this.deep) && !this.shallow) {\n      // set new value\n      var oldValue = this.value;\n      this.value = value;\n      // in debug + async mode, when a watcher callbacks\n      // throws, we also throw the saved before-push error\n      // so the full cross-tick stack trace is available.\n      var prevError = this.prevError;\n      /* istanbul ignore if */\n      if ('production' !== 'production' && config.debug && prevError) {} else {\n        this.cb.call(this.vm, value, oldValue);\n      }\n    }\n    this.queued = this.shallow = false;\n  }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\n\nWatcher.prototype.evaluate = function () {\n  // avoid overwriting another watcher that is being\n  // collected.\n  var current = Dep.target;\n  this.value = this.get();\n  this.dirty = false;\n  Dep.target = current;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\n\nWatcher.prototype.depend = function () {\n  var i = this.deps.length;\n  while (i--) {\n    this.deps[i].depend();\n  }\n};\n\n/**\n * Remove self from all dependencies' subcriber list.\n */\n\nWatcher.prototype.teardown = function () {\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 or is performing a v-for\n    // re-render (the watcher list is then filtered by v-for).\n    if (!this.vm._isBeingDestroyed && !this.vm._vForRemoving) {\n      this.vm._watchers.$remove(this);\n    }\n    var i = this.deps.length;\n    while (i--) {\n      this.deps[i].removeSub(this);\n    }\n    this.active = false;\n    this.vm = this.cb = this.value = null;\n  }\n};\n\n/**\n * Recrusively 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 *\n * @param {*} val\n */\n\nvar seenObjects = new _Set();\nfunction traverse(val, seen) {\n  var i = undefined,\n      keys = undefined;\n  if (!seen) {\n    seen = seenObjects;\n    seen.clear();\n  }\n  var isA = isArray(val);\n  var isO = isObject(val);\n  if ((isA || isO) && Object.isExtensible(val)) {\n    if (val.__ob__) {\n      var depId = val.__ob__.dep.id;\n      if (seen.has(depId)) {\n        return;\n      } else {\n        seen.add(depId);\n      }\n    }\n    if (isA) {\n      i = val.length;\n      while (i--) traverse(val[i], seen);\n    } else if (isO) {\n      keys = Object.keys(val);\n      i = keys.length;\n      while (i--) traverse(val[keys[i]], seen);\n    }\n  }\n}\n\nvar text$1 = {\n\n  bind: function bind() {\n    this.attr = this.el.nodeType === 3 ? 'data' : 'textContent';\n  },\n\n  update: function update(value) {\n    this.el[this.attr] = _toString(value);\n  }\n};\n\nvar templateCache = new Cache(1000);\nvar idSelectorCache = new Cache(1000);\n\nvar map = {\n  efault: [0, '', ''],\n  legend: [1, '<fieldset>', '</fieldset>'],\n  tr: [2, '<table><tbody>', '</tbody></table>'],\n  col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>']\n};\n\nmap.td = map.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];\n\nmap.option = map.optgroup = [1, '<select multiple=\"multiple\">', '</select>'];\n\nmap.thead = map.tbody = map.colgroup = map.caption = map.tfoot = [1, '<table>', '</table>'];\n\nmap.g = map.defs = map.symbol = map.use = map.image = map.text = map.circle = map.ellipse = map.line = map.path = map.polygon = map.polyline = map.rect = [1, '<svg ' + 'xmlns=\"http://www.w3.org/2000/svg\" ' + 'xmlns:xlink=\"http://www.w3.org/1999/xlink\" ' + 'xmlns:ev=\"http://www.w3.org/2001/xml-events\"' + 'version=\"1.1\">', '</svg>'];\n\n/**\n * Check if a node is a supported template node with a\n * DocumentFragment content.\n *\n * @param {Node} node\n * @return {Boolean}\n */\n\nfunction isRealTemplate(node) {\n  return isTemplate(node) && isFragment(node.content);\n}\n\nvar tagRE$1 = /<([\\w:-]+)/;\nvar entityRE = /&#?\\w+?;/;\nvar commentRE = /<!--/;\n\n/**\n * Convert a string template to a DocumentFragment.\n * Determines correct wrapping by tag types. Wrapping\n * strategy found in jQuery & component/domify.\n *\n * @param {String} templateString\n * @param {Boolean} raw\n * @return {DocumentFragment}\n */\n\nfunction stringToFragment(templateString, raw) {\n  // try a cache hit first\n  var cacheKey = raw ? templateString : templateString.trim();\n  var hit = templateCache.get(cacheKey);\n  if (hit) {\n    return hit;\n  }\n\n  var frag = document.createDocumentFragment();\n  var tagMatch = templateString.match(tagRE$1);\n  var entityMatch = entityRE.test(templateString);\n  var commentMatch = commentRE.test(templateString);\n\n  if (!tagMatch && !entityMatch && !commentMatch) {\n    // text only, return a single text node.\n    frag.appendChild(document.createTextNode(templateString));\n  } else {\n    var tag = tagMatch && tagMatch[1];\n    var wrap = map[tag] || map.efault;\n    var depth = wrap[0];\n    var prefix = wrap[1];\n    var suffix = wrap[2];\n    var node = document.createElement('div');\n\n    node.innerHTML = prefix + templateString + suffix;\n    while (depth--) {\n      node = node.lastChild;\n    }\n\n    var child;\n    /* eslint-disable no-cond-assign */\n    while (child = node.firstChild) {\n      /* eslint-enable no-cond-assign */\n      frag.appendChild(child);\n    }\n  }\n  if (!raw) {\n    trimNode(frag);\n  }\n  templateCache.put(cacheKey, frag);\n  return frag;\n}\n\n/**\n * Convert a template node to a DocumentFragment.\n *\n * @param {Node} node\n * @return {DocumentFragment}\n */\n\nfunction nodeToFragment(node) {\n  // if its a template tag and the browser supports it,\n  // its content is already a document fragment. However, iOS Safari has\n  // bug when using directly cloned template content with touch\n  // events and can cause crashes when the nodes are removed from DOM, so we\n  // have to treat template elements as string templates. (#2805)\n  /* istanbul ignore if */\n  if (isRealTemplate(node)) {\n    return stringToFragment(node.innerHTML);\n  }\n  // script template\n  if (node.tagName === 'SCRIPT') {\n    return stringToFragment(node.textContent);\n  }\n  // normal node, clone it to avoid mutating the original\n  var clonedNode = cloneNode(node);\n  var frag = document.createDocumentFragment();\n  var child;\n  /* eslint-disable no-cond-assign */\n  while (child = clonedNode.firstChild) {\n    /* eslint-enable no-cond-assign */\n    frag.appendChild(child);\n  }\n  trimNode(frag);\n  return frag;\n}\n\n// Test for the presence of the Safari template cloning bug\n// https://bugs.webkit.org/showug.cgi?id=137755\nvar hasBrokenTemplate = (function () {\n  /* istanbul ignore else */\n  if (inBrowser) {\n    var a = document.createElement('div');\n    a.innerHTML = '<template>1</template>';\n    return !a.cloneNode(true).firstChild.innerHTML;\n  } else {\n    return false;\n  }\n})();\n\n// Test for IE10/11 textarea placeholder clone bug\nvar hasTextareaCloneBug = (function () {\n  /* istanbul ignore else */\n  if (inBrowser) {\n    var t = document.createElement('textarea');\n    t.placeholder = 't';\n    return t.cloneNode(true).value === 't';\n  } else {\n    return false;\n  }\n})();\n\n/**\n * 1. Deal with Safari cloning nested <template> bug by\n *    manually cloning all template instances.\n * 2. Deal with IE10/11 textarea placeholder bug by setting\n *    the correct value after cloning.\n *\n * @param {Element|DocumentFragment} node\n * @return {Element|DocumentFragment}\n */\n\nfunction cloneNode(node) {\n  /* istanbul ignore if */\n  if (!node.querySelectorAll) {\n    return node.cloneNode();\n  }\n  var res = node.cloneNode(true);\n  var i, original, cloned;\n  /* istanbul ignore if */\n  if (hasBrokenTemplate) {\n    var tempClone = res;\n    if (isRealTemplate(node)) {\n      node = node.content;\n      tempClone = res.content;\n    }\n    original = node.querySelectorAll('template');\n    if (original.length) {\n      cloned = tempClone.querySelectorAll('template');\n      i = cloned.length;\n      while (i--) {\n        cloned[i].parentNode.replaceChild(cloneNode(original[i]), cloned[i]);\n      }\n    }\n  }\n  /* istanbul ignore if */\n  if (hasTextareaCloneBug) {\n    if (node.tagName === 'TEXTAREA') {\n      res.value = node.value;\n    } else {\n      original = node.querySelectorAll('textarea');\n      if (original.length) {\n        cloned = res.querySelectorAll('textarea');\n        i = cloned.length;\n        while (i--) {\n          cloned[i].value = original[i].value;\n        }\n      }\n    }\n  }\n  return res;\n}\n\n/**\n * Process the template option and normalizes it into a\n * a DocumentFragment that can be used as a partial or a\n * instance template.\n *\n * @param {*} template\n *        Possible values include:\n *        - DocumentFragment object\n *        - Node object of type Template\n *        - id selector: '#some-template-id'\n *        - template string: '<div><span>{{msg}}</span></div>'\n * @param {Boolean} shouldClone\n * @param {Boolean} raw\n *        inline HTML interpolation. Do not check for id\n *        selector and keep whitespace in the string.\n * @return {DocumentFragment|undefined}\n */\n\nfunction parseTemplate(template, shouldClone, raw) {\n  var node, frag;\n\n  // if the template is already a document fragment,\n  // do nothing\n  if (isFragment(template)) {\n    trimNode(template);\n    return shouldClone ? cloneNode(template) : template;\n  }\n\n  if (typeof template === 'string') {\n    // id selector\n    if (!raw && template.charAt(0) === '#') {\n      // id selector can be cached too\n      frag = idSelectorCache.get(template);\n      if (!frag) {\n        node = document.getElementById(template.slice(1));\n        if (node) {\n          frag = nodeToFragment(node);\n          // save selector to cache\n          idSelectorCache.put(template, frag);\n        }\n      }\n    } else {\n      // normal string template\n      frag = stringToFragment(template, raw);\n    }\n  } else if (template.nodeType) {\n    // a direct node\n    frag = nodeToFragment(template);\n  }\n\n  return frag && shouldClone ? cloneNode(frag) : frag;\n}\n\nvar template = Object.freeze({\n  cloneNode: cloneNode,\n  parseTemplate: parseTemplate\n});\n\nvar html = {\n\n  bind: function bind() {\n    // a comment node means this is a binding for\n    // {{{ inline unescaped html }}}\n    if (this.el.nodeType === 8) {\n      // hold nodes\n      this.nodes = [];\n      // replace the placeholder with proper anchor\n      this.anchor = createAnchor('v-html');\n      replace(this.el, this.anchor);\n    }\n  },\n\n  update: function update(value) {\n    value = _toString(value);\n    if (this.nodes) {\n      this.swap(value);\n    } else {\n      this.el.innerHTML = value;\n    }\n  },\n\n  swap: function swap(value) {\n    // remove old nodes\n    var i = this.nodes.length;\n    while (i--) {\n      remove(this.nodes[i]);\n    }\n    // convert new value to a fragment\n    // do not attempt to retrieve from id selector\n    var frag = parseTemplate(value, true, true);\n    // save a reference to these nodes so we can remove later\n    this.nodes = toArray(frag.childNodes);\n    before(frag, this.anchor);\n  }\n};\n\n/**\n * Abstraction for a partially-compiled fragment.\n * Can optionally compile content with a child scope.\n *\n * @param {Function} linker\n * @param {Vue} vm\n * @param {DocumentFragment} frag\n * @param {Vue} [host]\n * @param {Object} [scope]\n * @param {Fragment} [parentFrag]\n */\nfunction Fragment(linker, vm, frag, host, scope, parentFrag) {\n  this.children = [];\n  this.childFrags = [];\n  this.vm = vm;\n  this.scope = scope;\n  this.inserted = false;\n  this.parentFrag = parentFrag;\n  if (parentFrag) {\n    parentFrag.childFrags.push(this);\n  }\n  this.unlink = linker(vm, frag, host, scope, this);\n  var single = this.single = frag.childNodes.length === 1 &&\n  // do not go single mode if the only node is an anchor\n  !frag.childNodes[0].__v_anchor;\n  if (single) {\n    this.node = frag.childNodes[0];\n    this.before = singleBefore;\n    this.remove = singleRemove;\n  } else {\n    this.node = createAnchor('fragment-start');\n    this.end = createAnchor('fragment-end');\n    this.frag = frag;\n    prepend(this.node, frag);\n    frag.appendChild(this.end);\n    this.before = multiBefore;\n    this.remove = multiRemove;\n  }\n  this.node.__v_frag = this;\n}\n\n/**\n * Call attach/detach for all components contained within\n * this fragment. Also do so recursively for all child\n * fragments.\n *\n * @param {Function} hook\n */\n\nFragment.prototype.callHook = function (hook) {\n  var i, l;\n  for (i = 0, l = this.childFrags.length; i < l; i++) {\n    this.childFrags[i].callHook(hook);\n  }\n  for (i = 0, l = this.children.length; i < l; i++) {\n    hook(this.children[i]);\n  }\n};\n\n/**\n * Insert fragment before target, single node version\n *\n * @param {Node} target\n * @param {Boolean} withTransition\n */\n\nfunction singleBefore(target, withTransition) {\n  this.inserted = true;\n  var method = withTransition !== false ? beforeWithTransition : before;\n  method(this.node, target, this.vm);\n  if (inDoc(this.node)) {\n    this.callHook(attach);\n  }\n}\n\n/**\n * Remove fragment, single node version\n */\n\nfunction singleRemove() {\n  this.inserted = false;\n  var shouldCallRemove = inDoc(this.node);\n  var self = this;\n  this.beforeRemove();\n  removeWithTransition(this.node, this.vm, function () {\n    if (shouldCallRemove) {\n      self.callHook(detach);\n    }\n    self.destroy();\n  });\n}\n\n/**\n * Insert fragment before target, multi-nodes version\n *\n * @param {Node} target\n * @param {Boolean} withTransition\n */\n\nfunction multiBefore(target, withTransition) {\n  this.inserted = true;\n  var vm = this.vm;\n  var method = withTransition !== false ? beforeWithTransition : before;\n  mapNodeRange(this.node, this.end, function (node) {\n    method(node, target, vm);\n  });\n  if (inDoc(this.node)) {\n    this.callHook(attach);\n  }\n}\n\n/**\n * Remove fragment, multi-nodes version\n */\n\nfunction multiRemove() {\n  this.inserted = false;\n  var self = this;\n  var shouldCallRemove = inDoc(this.node);\n  this.beforeRemove();\n  removeNodeRange(this.node, this.end, this.vm, this.frag, function () {\n    if (shouldCallRemove) {\n      self.callHook(detach);\n    }\n    self.destroy();\n  });\n}\n\n/**\n * Prepare the fragment for removal.\n */\n\nFragment.prototype.beforeRemove = function () {\n  var i, l;\n  for (i = 0, l = this.childFrags.length; i < l; i++) {\n    // call the same method recursively on child\n    // fragments, depth-first\n    this.childFrags[i].beforeRemove(false);\n  }\n  for (i = 0, l = this.children.length; i < l; i++) {\n    // Call destroy for all contained instances,\n    // with remove:false and defer:true.\n    // Defer is necessary because we need to\n    // keep the children to call detach hooks\n    // on them.\n    this.children[i].$destroy(false, true);\n  }\n  var dirs = this.unlink.dirs;\n  for (i = 0, l = dirs.length; i < l; i++) {\n    // disable the watchers on all the directives\n    // so that the rendered content stays the same\n    // during removal.\n    dirs[i]._watcher && dirs[i]._watcher.teardown();\n  }\n};\n\n/**\n * Destroy the fragment.\n */\n\nFragment.prototype.destroy = function () {\n  if (this.parentFrag) {\n    this.parentFrag.childFrags.$remove(this);\n  }\n  this.node.__v_frag = null;\n  this.unlink();\n};\n\n/**\n * Call attach hook for a Vue instance.\n *\n * @param {Vue} child\n */\n\nfunction attach(child) {\n  if (!child._isAttached && inDoc(child.$el)) {\n    child._callHook('attached');\n  }\n}\n\n/**\n * Call detach hook for a Vue instance.\n *\n * @param {Vue} child\n */\n\nfunction detach(child) {\n  if (child._isAttached && !inDoc(child.$el)) {\n    child._callHook('detached');\n  }\n}\n\nvar linkerCache = new Cache(5000);\n\n/**\n * A factory that can be used to create instances of a\n * fragment. Caches the compiled linker if possible.\n *\n * @param {Vue} vm\n * @param {Element|String} el\n */\nfunction FragmentFactory(vm, el) {\n  this.vm = vm;\n  var template;\n  var isString = typeof el === 'string';\n  if (isString || isTemplate(el) && !el.hasAttribute('v-if')) {\n    template = parseTemplate(el, true);\n  } else {\n    template = document.createDocumentFragment();\n    template.appendChild(el);\n  }\n  this.template = template;\n  // linker can be cached, but only for components\n  var linker;\n  var cid = vm.constructor.cid;\n  if (cid > 0) {\n    var cacheId = cid + (isString ? el : getOuterHTML(el));\n    linker = linkerCache.get(cacheId);\n    if (!linker) {\n      linker = compile(template, vm.$options, true);\n      linkerCache.put(cacheId, linker);\n    }\n  } else {\n    linker = compile(template, vm.$options, true);\n  }\n  this.linker = linker;\n}\n\n/**\n * Create a fragment instance with given host and scope.\n *\n * @param {Vue} host\n * @param {Object} scope\n * @param {Fragment} parentFrag\n */\n\nFragmentFactory.prototype.create = function (host, scope, parentFrag) {\n  var frag = cloneNode(this.template);\n  return new Fragment(this.linker, this.vm, frag, host, scope, parentFrag);\n};\n\nvar ON = 700;\nvar MODEL = 800;\nvar BIND = 850;\nvar TRANSITION = 1100;\nvar EL = 1500;\nvar COMPONENT = 1500;\nvar PARTIAL = 1750;\nvar IF = 2100;\nvar FOR = 2200;\nvar SLOT = 2300;\n\nvar uid$3 = 0;\n\nvar vFor = {\n\n  priority: FOR,\n  terminal: true,\n\n  params: ['track-by', 'stagger', 'enter-stagger', 'leave-stagger'],\n\n  bind: function bind() {\n    if ('production' !== 'production' && this.el.hasAttribute('v-if')) {}\n\n    // support \"item in/of items\" syntax\n    var inMatch = this.expression.match(/(.*) (?:in|of) (.*)/);\n    if (inMatch) {\n      var itMatch = inMatch[1].match(/\\((.*),(.*)\\)/);\n      if (itMatch) {\n        this.iterator = itMatch[1].trim();\n        this.alias = itMatch[2].trim();\n      } else {\n        this.alias = inMatch[1].trim();\n      }\n      this.expression = inMatch[2];\n    }\n\n    if (!this.alias) {\n      'production' !== 'production' && warn('Invalid v-for expression \"' + this.descriptor.raw + '\": ' + 'alias is required.', this.vm);\n      return;\n    }\n\n    // uid as a cache identifier\n    this.id = '__v-for__' + ++uid$3;\n\n    // check if this is an option list,\n    // so that we know if we need to update the <select>'s\n    // v-model when the option list has changed.\n    // because v-model has a lower priority than v-for,\n    // the v-model is not bound here yet, so we have to\n    // retrive it in the actual updateModel() function.\n    var tag = this.el.tagName;\n    this.isOption = (tag === 'OPTION' || tag === 'OPTGROUP') && this.el.parentNode.tagName === 'SELECT';\n\n    // setup anchor nodes\n    this.start = createAnchor('v-for-start');\n    this.end = createAnchor('v-for-end');\n    replace(this.el, this.end);\n    before(this.start, this.end);\n\n    // cache\n    this.cache = Object.create(null);\n\n    // fragment factory\n    this.factory = new FragmentFactory(this.vm, this.el);\n  },\n\n  update: function update(data) {\n    this.diff(data);\n    this.updateRef();\n    this.updateModel();\n  },\n\n  /**\n   * Diff, based on new data and old data, determine the\n   * minimum amount of DOM manipulations needed to make the\n   * DOM reflect the new data Array.\n   *\n   * The algorithm diffs the new data Array by storing a\n   * hidden reference to an owner vm instance on previously\n   * seen data. This allows us to achieve O(n) which is\n   * better than a levenshtein distance based algorithm,\n   * which is O(m * n).\n   *\n   * @param {Array} data\n   */\n\n  diff: function diff(data) {\n    // check if the Array was converted from an Object\n    var item = data[0];\n    var convertedFromObject = this.fromObject = isObject(item) && hasOwn(item, '$key') && hasOwn(item, '$value');\n\n    var trackByKey = this.params.trackBy;\n    var oldFrags = this.frags;\n    var frags = this.frags = new Array(data.length);\n    var alias = this.alias;\n    var iterator = this.iterator;\n    var start = this.start;\n    var end = this.end;\n    var inDocument = inDoc(start);\n    var init = !oldFrags;\n    var i, l, frag, key, value, primitive;\n\n    // First pass, go through the new Array and fill up\n    // the new frags array. If a piece of data has a cached\n    // instance for it, we reuse it. Otherwise build a new\n    // instance.\n    for (i = 0, l = data.length; i < l; i++) {\n      item = data[i];\n      key = convertedFromObject ? item.$key : null;\n      value = convertedFromObject ? item.$value : item;\n      primitive = !isObject(value);\n      frag = !init && this.getCachedFrag(value, i, key);\n      if (frag) {\n        // reusable fragment\n        frag.reused = true;\n        // update $index\n        frag.scope.$index = i;\n        // update $key\n        if (key) {\n          frag.scope.$key = key;\n        }\n        // update iterator\n        if (iterator) {\n          frag.scope[iterator] = key !== null ? key : i;\n        }\n        // update data for track-by, object repeat &\n        // primitive values.\n        if (trackByKey || convertedFromObject || primitive) {\n          withoutConversion(function () {\n            frag.scope[alias] = value;\n          });\n        }\n      } else {\n        // new instance\n        frag = this.create(value, alias, i, key);\n        frag.fresh = !init;\n      }\n      frags[i] = frag;\n      if (init) {\n        frag.before(end);\n      }\n    }\n\n    // we're done for the initial render.\n    if (init) {\n      return;\n    }\n\n    // Second pass, go through the old fragments and\n    // destroy those who are not reused (and remove them\n    // from cache)\n    var removalIndex = 0;\n    var totalRemoved = oldFrags.length - frags.length;\n    // when removing a large number of fragments, watcher removal\n    // turns out to be a perf bottleneck, so we batch the watcher\n    // removals into a single filter call!\n    this.vm._vForRemoving = true;\n    for (i = 0, l = oldFrags.length; i < l; i++) {\n      frag = oldFrags[i];\n      if (!frag.reused) {\n        this.deleteCachedFrag(frag);\n        this.remove(frag, removalIndex++, totalRemoved, inDocument);\n      }\n    }\n    this.vm._vForRemoving = false;\n    if (removalIndex) {\n      this.vm._watchers = this.vm._watchers.filter(function (w) {\n        return w.active;\n      });\n    }\n\n    // Final pass, move/insert new fragments into the\n    // right place.\n    var targetPrev, prevEl, currentPrev;\n    var insertionIndex = 0;\n    for (i = 0, l = frags.length; i < l; i++) {\n      frag = frags[i];\n      // this is the frag that we should be after\n      targetPrev = frags[i - 1];\n      prevEl = targetPrev ? targetPrev.staggerCb ? targetPrev.staggerAnchor : targetPrev.end || targetPrev.node : start;\n      if (frag.reused && !frag.staggerCb) {\n        currentPrev = findPrevFrag(frag, start, this.id);\n        if (currentPrev !== targetPrev && (!currentPrev ||\n        // optimization for moving a single item.\n        // thanks to suggestions by @livoras in #1807\n        findPrevFrag(currentPrev, start, this.id) !== targetPrev)) {\n          this.move(frag, prevEl);\n        }\n      } else {\n        // new instance, or still in stagger.\n        // insert with updated stagger index.\n        this.insert(frag, insertionIndex++, prevEl, inDocument);\n      }\n      frag.reused = frag.fresh = false;\n    }\n  },\n\n  /**\n   * Create a new fragment instance.\n   *\n   * @param {*} value\n   * @param {String} alias\n   * @param {Number} index\n   * @param {String} [key]\n   * @return {Fragment}\n   */\n\n  create: function create(value, alias, index, key) {\n    var host = this._host;\n    // create iteration scope\n    var parentScope = this._scope || this.vm;\n    var scope = Object.create(parentScope);\n    // ref holder for the scope\n    scope.$refs = Object.create(parentScope.$refs);\n    scope.$els = Object.create(parentScope.$els);\n    // make sure point $parent to parent scope\n    scope.$parent = parentScope;\n    // for two-way binding on alias\n    scope.$forContext = this;\n    // define scope properties\n    // important: define the scope alias without forced conversion\n    // so that frozen data structures remain non-reactive.\n    withoutConversion(function () {\n      defineReactive(scope, alias, value);\n    });\n    defineReactive(scope, '$index', index);\n    if (key) {\n      defineReactive(scope, '$key', key);\n    } else if (scope.$key) {\n      // avoid accidental fallback\n      def(scope, '$key', null);\n    }\n    if (this.iterator) {\n      defineReactive(scope, this.iterator, key !== null ? key : index);\n    }\n    var frag = this.factory.create(host, scope, this._frag);\n    frag.forId = this.id;\n    this.cacheFrag(value, frag, index, key);\n    return frag;\n  },\n\n  /**\n   * Update the v-ref on owner vm.\n   */\n\n  updateRef: function updateRef() {\n    var ref = this.descriptor.ref;\n    if (!ref) return;\n    var hash = (this._scope || this.vm).$refs;\n    var refs;\n    if (!this.fromObject) {\n      refs = this.frags.map(findVmFromFrag);\n    } else {\n      refs = {};\n      this.frags.forEach(function (frag) {\n        refs[frag.scope.$key] = findVmFromFrag(frag);\n      });\n    }\n    hash[ref] = refs;\n  },\n\n  /**\n   * For option lists, update the containing v-model on\n   * parent <select>.\n   */\n\n  updateModel: function updateModel() {\n    if (this.isOption) {\n      var parent = this.start.parentNode;\n      var model = parent && parent.__v_model;\n      if (model) {\n        model.forceUpdate();\n      }\n    }\n  },\n\n  /**\n   * Insert a fragment. Handles staggering.\n   *\n   * @param {Fragment} frag\n   * @param {Number} index\n   * @param {Node} prevEl\n   * @param {Boolean} inDocument\n   */\n\n  insert: function insert(frag, index, prevEl, inDocument) {\n    if (frag.staggerCb) {\n      frag.staggerCb.cancel();\n      frag.staggerCb = null;\n    }\n    var staggerAmount = this.getStagger(frag, index, null, 'enter');\n    if (inDocument && staggerAmount) {\n      // create an anchor and insert it synchronously,\n      // so that we can resolve the correct order without\n      // worrying about some elements not inserted yet\n      var anchor = frag.staggerAnchor;\n      if (!anchor) {\n        anchor = frag.staggerAnchor = createAnchor('stagger-anchor');\n        anchor.__v_frag = frag;\n      }\n      after(anchor, prevEl);\n      var op = frag.staggerCb = cancellable(function () {\n        frag.staggerCb = null;\n        frag.before(anchor);\n        remove(anchor);\n      });\n      setTimeout(op, staggerAmount);\n    } else {\n      var target = prevEl.nextSibling;\n      /* istanbul ignore if */\n      if (!target) {\n        // reset end anchor position in case the position was messed up\n        // by an external drag-n-drop library.\n        after(this.end, prevEl);\n        target = this.end;\n      }\n      frag.before(target);\n    }\n  },\n\n  /**\n   * Remove a fragment. Handles staggering.\n   *\n   * @param {Fragment} frag\n   * @param {Number} index\n   * @param {Number} total\n   * @param {Boolean} inDocument\n   */\n\n  remove: function remove(frag, index, total, inDocument) {\n    if (frag.staggerCb) {\n      frag.staggerCb.cancel();\n      frag.staggerCb = null;\n      // it's not possible for the same frag to be removed\n      // twice, so if we have a pending stagger callback,\n      // it means this frag is queued for enter but removed\n      // before its transition started. Since it is already\n      // destroyed, we can just leave it in detached state.\n      return;\n    }\n    var staggerAmount = this.getStagger(frag, index, total, 'leave');\n    if (inDocument && staggerAmount) {\n      var op = frag.staggerCb = cancellable(function () {\n        frag.staggerCb = null;\n        frag.remove();\n      });\n      setTimeout(op, staggerAmount);\n    } else {\n      frag.remove();\n    }\n  },\n\n  /**\n   * Move a fragment to a new position.\n   * Force no transition.\n   *\n   * @param {Fragment} frag\n   * @param {Node} prevEl\n   */\n\n  move: function move(frag, prevEl) {\n    // fix a common issue with Sortable:\n    // if prevEl doesn't have nextSibling, this means it's\n    // been dragged after the end anchor. Just re-position\n    // the end anchor to the end of the container.\n    /* istanbul ignore if */\n    if (!prevEl.nextSibling) {\n      this.end.parentNode.appendChild(this.end);\n    }\n    frag.before(prevEl.nextSibling, false);\n  },\n\n  /**\n   * Cache a fragment using track-by or the object key.\n   *\n   * @param {*} value\n   * @param {Fragment} frag\n   * @param {Number} index\n   * @param {String} [key]\n   */\n\n  cacheFrag: function cacheFrag(value, frag, index, key) {\n    var trackByKey = this.params.trackBy;\n    var cache = this.cache;\n    var primitive = !isObject(value);\n    var id;\n    if (key || trackByKey || primitive) {\n      id = getTrackByKey(index, key, value, trackByKey);\n      if (!cache[id]) {\n        cache[id] = frag;\n      } else if (trackByKey !== '$index') {\n        'production' !== 'production' && this.warnDuplicate(value);\n      }\n    } else {\n      id = this.id;\n      if (hasOwn(value, id)) {\n        if (value[id] === null) {\n          value[id] = frag;\n        } else {\n          'production' !== 'production' && this.warnDuplicate(value);\n        }\n      } else if (Object.isExtensible(value)) {\n        def(value, id, frag);\n      } else if ('production' !== 'production') {}\n    }\n    frag.raw = value;\n  },\n\n  /**\n   * Get a cached fragment from the value/index/key\n   *\n   * @param {*} value\n   * @param {Number} index\n   * @param {String} key\n   * @return {Fragment}\n   */\n\n  getCachedFrag: function getCachedFrag(value, index, key) {\n    var trackByKey = this.params.trackBy;\n    var primitive = !isObject(value);\n    var frag;\n    if (key || trackByKey || primitive) {\n      var id = getTrackByKey(index, key, value, trackByKey);\n      frag = this.cache[id];\n    } else {\n      frag = value[this.id];\n    }\n    if (frag && (frag.reused || frag.fresh)) {\n      'production' !== 'production' && this.warnDuplicate(value);\n    }\n    return frag;\n  },\n\n  /**\n   * Delete a fragment from cache.\n   *\n   * @param {Fragment} frag\n   */\n\n  deleteCachedFrag: function deleteCachedFrag(frag) {\n    var value = frag.raw;\n    var trackByKey = this.params.trackBy;\n    var scope = frag.scope;\n    var index = scope.$index;\n    // fix #948: avoid accidentally fall through to\n    // a parent repeater which happens to have $key.\n    var key = hasOwn(scope, '$key') && scope.$key;\n    var primitive = !isObject(value);\n    if (trackByKey || key || primitive) {\n      var id = getTrackByKey(index, key, value, trackByKey);\n      this.cache[id] = null;\n    } else {\n      value[this.id] = null;\n      frag.raw = null;\n    }\n  },\n\n  /**\n   * Get the stagger amount for an insertion/removal.\n   *\n   * @param {Fragment} frag\n   * @param {Number} index\n   * @param {Number} total\n   * @param {String} type\n   */\n\n  getStagger: function getStagger(frag, index, total, type) {\n    type = type + 'Stagger';\n    var trans = frag.node.__v_trans;\n    var hooks = trans && trans.hooks;\n    var hook = hooks && (hooks[type] || hooks.stagger);\n    return hook ? hook.call(frag, index, total) : index * parseInt(this.params[type] || this.params.stagger, 10);\n  },\n\n  /**\n   * Pre-process the value before piping it through the\n   * filters. This is passed to and called by the watcher.\n   */\n\n  _preProcess: function _preProcess(value) {\n    // regardless of type, store the un-filtered raw value.\n    this.rawValue = value;\n    return value;\n  },\n\n  /**\n   * Post-process the value after it has been piped through\n   * the filters. This is passed to and called by the watcher.\n   *\n   * It is necessary for this to be called during the\n   * watcher's dependency collection phase because we want\n   * the v-for to update when the source Object is mutated.\n   */\n\n  _postProcess: function _postProcess(value) {\n    if (isArray(value)) {\n      return value;\n    } else if (isPlainObject(value)) {\n      // convert plain object to array.\n      var keys = Object.keys(value);\n      var i = keys.length;\n      var res = new Array(i);\n      var key;\n      while (i--) {\n        key = keys[i];\n        res[i] = {\n          $key: key,\n          $value: value[key]\n        };\n      }\n      return res;\n    } else {\n      if (typeof value === 'number' && !isNaN(value)) {\n        value = range(value);\n      }\n      return value || [];\n    }\n  },\n\n  unbind: function unbind() {\n    if (this.descriptor.ref) {\n      (this._scope || this.vm).$refs[this.descriptor.ref] = null;\n    }\n    if (this.frags) {\n      var i = this.frags.length;\n      var frag;\n      while (i--) {\n        frag = this.frags[i];\n        this.deleteCachedFrag(frag);\n        frag.destroy();\n      }\n    }\n  }\n};\n\n/**\n * Helper to find the previous element that is a fragment\n * anchor. This is necessary because a destroyed frag's\n * element could still be lingering in the DOM before its\n * leaving transition finishes, but its inserted flag\n * should have been set to false so we can skip them.\n *\n * If this is a block repeat, we want to make sure we only\n * return frag that is bound to this v-for. (see #929)\n *\n * @param {Fragment} frag\n * @param {Comment|Text} anchor\n * @param {String} id\n * @return {Fragment}\n */\n\nfunction findPrevFrag(frag, anchor, id) {\n  var el = frag.node.previousSibling;\n  /* istanbul ignore if */\n  if (!el) return;\n  frag = el.__v_frag;\n  while ((!frag || frag.forId !== id || !frag.inserted) && el !== anchor) {\n    el = el.previousSibling;\n    /* istanbul ignore if */\n    if (!el) return;\n    frag = el.__v_frag;\n  }\n  return frag;\n}\n\n/**\n * Create a range array from given number.\n *\n * @param {Number} n\n * @return {Array}\n */\n\nfunction range(n) {\n  var i = -1;\n  var ret = new Array(Math.floor(n));\n  while (++i < n) {\n    ret[i] = i;\n  }\n  return ret;\n}\n\n/**\n * Get the track by key for an item.\n *\n * @param {Number} index\n * @param {String} key\n * @param {*} value\n * @param {String} [trackByKey]\n */\n\nfunction getTrackByKey(index, key, value, trackByKey) {\n  return trackByKey ? trackByKey === '$index' ? index : trackByKey.charAt(0).match(/\\w/) ? getPath(value, trackByKey) : value[trackByKey] : key || value;\n}\n\n/**\n * Find a vm from a fragment.\n *\n * @param {Fragment} frag\n * @return {Vue|undefined}\n */\n\nfunction findVmFromFrag(frag) {\n  var node = frag.node;\n  // handle multi-node frag\n  if (frag.end) {\n    while (!node.__vue__ && node !== frag.end && node.nextSibling) {\n      node = node.nextSibling;\n    }\n  }\n  return node.__vue__;\n}\n\nvar vIf = {\n\n  priority: IF,\n  terminal: true,\n\n  bind: function bind() {\n    var el = this.el;\n    if (!el.__vue__) {\n      // check else block\n      var next = el.nextElementSibling;\n      if (next && getAttr(next, 'v-else') !== null) {\n        remove(next);\n        this.elseEl = next;\n      }\n      // check main block\n      this.anchor = createAnchor('v-if');\n      replace(el, this.anchor);\n    } else {\n      'production' !== 'production' && warn('v-if=\"' + this.expression + '\" cannot be ' + 'used on an instance root element.', this.vm);\n      this.invalid = true;\n    }\n  },\n\n  update: function update(value) {\n    if (this.invalid) return;\n    if (value) {\n      if (!this.frag) {\n        this.insert();\n      }\n    } else {\n      this.remove();\n    }\n  },\n\n  insert: function insert() {\n    if (this.elseFrag) {\n      this.elseFrag.remove();\n      this.elseFrag = null;\n    }\n    // lazy init factory\n    if (!this.factory) {\n      this.factory = new FragmentFactory(this.vm, this.el);\n    }\n    this.frag = this.factory.create(this._host, this._scope, this._frag);\n    this.frag.before(this.anchor);\n  },\n\n  remove: function remove() {\n    if (this.frag) {\n      this.frag.remove();\n      this.frag = null;\n    }\n    if (this.elseEl && !this.elseFrag) {\n      if (!this.elseFactory) {\n        this.elseFactory = new FragmentFactory(this.elseEl._context || this.vm, this.elseEl);\n      }\n      this.elseFrag = this.elseFactory.create(this._host, this._scope, this._frag);\n      this.elseFrag.before(this.anchor);\n    }\n  },\n\n  unbind: function unbind() {\n    if (this.frag) {\n      this.frag.destroy();\n    }\n    if (this.elseFrag) {\n      this.elseFrag.destroy();\n    }\n  }\n};\n\nvar show = {\n\n  bind: function bind() {\n    // check else block\n    var next = this.el.nextElementSibling;\n    if (next && getAttr(next, 'v-else') !== null) {\n      this.elseEl = next;\n    }\n  },\n\n  update: function update(value) {\n    this.apply(this.el, value);\n    if (this.elseEl) {\n      this.apply(this.elseEl, !value);\n    }\n  },\n\n  apply: function apply(el, value) {\n    if (inDoc(el)) {\n      applyTransition(el, value ? 1 : -1, toggle, this.vm);\n    } else {\n      toggle();\n    }\n    function toggle() {\n      el.style.display = value ? '' : 'none';\n    }\n  }\n};\n\nvar text$2 = {\n\n  bind: function bind() {\n    var self = this;\n    var el = this.el;\n    var isRange = el.type === 'range';\n    var lazy = this.params.lazy;\n    var number = this.params.number;\n    var debounce = this.params.debounce;\n\n    // handle composition events.\n    //   http://blog.evanyou.me/2014/01/03/composition-event/\n    // skip this for Android because it handles composition\n    // events quite differently. Android doesn't trigger\n    // composition events for language input methods e.g.\n    // Chinese, but instead triggers them for spelling\n    // suggestions... (see Discussion/#162)\n    var composing = false;\n    if (!isAndroid && !isRange) {\n      this.on('compositionstart', function () {\n        composing = true;\n      });\n      this.on('compositionend', function () {\n        composing = false;\n        // in IE11 the \"compositionend\" event fires AFTER\n        // the \"input\" event, so the input handler is blocked\n        // at the end... have to call it here.\n        //\n        // #1327: in lazy mode this is unecessary.\n        if (!lazy) {\n          self.listener();\n        }\n      });\n    }\n\n    // prevent messing with the input when user is typing,\n    // and force update on blur.\n    this.focused = false;\n    if (!isRange && !lazy) {\n      this.on('focus', function () {\n        self.focused = true;\n      });\n      this.on('blur', function () {\n        self.focused = false;\n        // do not sync value after fragment removal (#2017)\n        if (!self._frag || self._frag.inserted) {\n          self.rawListener();\n        }\n      });\n    }\n\n    // Now attach the main listener\n    this.listener = this.rawListener = function () {\n      if (composing || !self._bound) {\n        return;\n      }\n      var val = number || isRange ? toNumber(el.value) : el.value;\n      self.set(val);\n      // force update on next tick to avoid lock & same value\n      // also only update when user is not typing\n      nextTick(function () {\n        if (self._bound && !self.focused) {\n          self.update(self._watcher.value);\n        }\n      });\n    };\n\n    // apply debounce\n    if (debounce) {\n      this.listener = _debounce(this.listener, debounce);\n    }\n\n    // Support jQuery events, since jQuery.trigger() doesn't\n    // trigger native events in some cases and some plugins\n    // rely on $.trigger()\n    //\n    // We want to make sure if a listener is attached using\n    // jQuery, it is also removed with jQuery, that's why\n    // we do the check for each directive instance and\n    // store that check result on itself. This also allows\n    // easier test coverage control by unsetting the global\n    // jQuery variable in tests.\n    this.hasjQuery = typeof jQuery === 'function';\n    if (this.hasjQuery) {\n      var method = jQuery.fn.on ? 'on' : 'bind';\n      jQuery(el)[method]('change', this.rawListener);\n      if (!lazy) {\n        jQuery(el)[method]('input', this.listener);\n      }\n    } else {\n      this.on('change', this.rawListener);\n      if (!lazy) {\n        this.on('input', this.listener);\n      }\n    }\n\n    // IE9 doesn't fire input event on backspace/del/cut\n    if (!lazy && isIE9) {\n      this.on('cut', function () {\n        nextTick(self.listener);\n      });\n      this.on('keyup', function (e) {\n        if (e.keyCode === 46 || e.keyCode === 8) {\n          self.listener();\n        }\n      });\n    }\n\n    // set initial value if present\n    if (el.hasAttribute('value') || el.tagName === 'TEXTAREA' && el.value.trim()) {\n      this.afterBind = this.listener;\n    }\n  },\n\n  update: function update(value) {\n    // #3029 only update when the value changes. This prevent\n    // browsers from overwriting values like selectionStart\n    value = _toString(value);\n    if (value !== this.el.value) this.el.value = value;\n  },\n\n  unbind: function unbind() {\n    var el = this.el;\n    if (this.hasjQuery) {\n      var method = jQuery.fn.off ? 'off' : 'unbind';\n      jQuery(el)[method]('change', this.listener);\n      jQuery(el)[method]('input', this.listener);\n    }\n  }\n};\n\nvar radio = {\n\n  bind: function bind() {\n    var self = this;\n    var el = this.el;\n\n    this.getValue = function () {\n      // value overwrite via v-bind:value\n      if (el.hasOwnProperty('_value')) {\n        return el._value;\n      }\n      var val = el.value;\n      if (self.params.number) {\n        val = toNumber(val);\n      }\n      return val;\n    };\n\n    this.listener = function () {\n      self.set(self.getValue());\n    };\n    this.on('change', this.listener);\n\n    if (el.hasAttribute('checked')) {\n      this.afterBind = this.listener;\n    }\n  },\n\n  update: function update(value) {\n    this.el.checked = looseEqual(value, this.getValue());\n  }\n};\n\nvar select = {\n\n  bind: function bind() {\n    var _this = this;\n\n    var self = this;\n    var el = this.el;\n\n    // method to force update DOM using latest value.\n    this.forceUpdate = function () {\n      if (self._watcher) {\n        self.update(self._watcher.get());\n      }\n    };\n\n    // check if this is a multiple select\n    var multiple = this.multiple = el.hasAttribute('multiple');\n\n    // attach listener\n    this.listener = function () {\n      var value = getValue(el, multiple);\n      value = self.params.number ? isArray(value) ? value.map(toNumber) : toNumber(value) : value;\n      self.set(value);\n    };\n    this.on('change', this.listener);\n\n    // if has initial value, set afterBind\n    var initValue = getValue(el, multiple, true);\n    if (multiple && initValue.length || !multiple && initValue !== null) {\n      this.afterBind = this.listener;\n    }\n\n    // All major browsers except Firefox resets\n    // selectedIndex with value -1 to 0 when the element\n    // is appended to a new parent, therefore we have to\n    // force a DOM update whenever that happens...\n    this.vm.$on('hook:attached', function () {\n      nextTick(_this.forceUpdate);\n    });\n    if (!inDoc(el)) {\n      nextTick(this.forceUpdate);\n    }\n  },\n\n  update: function update(value) {\n    var el = this.el;\n    el.selectedIndex = -1;\n    var multi = this.multiple && isArray(value);\n    var options = el.options;\n    var i = options.length;\n    var op, val;\n    while (i--) {\n      op = options[i];\n      val = op.hasOwnProperty('_value') ? op._value : op.value;\n      /* eslint-disable eqeqeq */\n      op.selected = multi ? indexOf$1(value, val) > -1 : looseEqual(value, val);\n      /* eslint-enable eqeqeq */\n    }\n  },\n\n  unbind: function unbind() {\n    /* istanbul ignore next */\n    this.vm.$off('hook:attached', this.forceUpdate);\n  }\n};\n\n/**\n * Get select value\n *\n * @param {SelectElement} el\n * @param {Boolean} multi\n * @param {Boolean} init\n * @return {Array|*}\n */\n\nfunction getValue(el, multi, init) {\n  var res = multi ? [] : null;\n  var op, val, selected;\n  for (var i = 0, l = el.options.length; i < l; i++) {\n    op = el.options[i];\n    selected = init ? op.hasAttribute('selected') : op.selected;\n    if (selected) {\n      val = op.hasOwnProperty('_value') ? op._value : op.value;\n      if (multi) {\n        res.push(val);\n      } else {\n        return val;\n      }\n    }\n  }\n  return res;\n}\n\n/**\n * Native Array.indexOf uses strict equal, but in this\n * case we need to match string/numbers with custom equal.\n *\n * @param {Array} arr\n * @param {*} val\n */\n\nfunction indexOf$1(arr, val) {\n  var i = arr.length;\n  while (i--) {\n    if (looseEqual(arr[i], val)) {\n      return i;\n    }\n  }\n  return -1;\n}\n\nvar checkbox = {\n\n  bind: function bind() {\n    var self = this;\n    var el = this.el;\n\n    this.getValue = function () {\n      return el.hasOwnProperty('_value') ? el._value : self.params.number ? toNumber(el.value) : el.value;\n    };\n\n    function getBooleanValue() {\n      var val = el.checked;\n      if (val && el.hasOwnProperty('_trueValue')) {\n        return el._trueValue;\n      }\n      if (!val && el.hasOwnProperty('_falseValue')) {\n        return el._falseValue;\n      }\n      return val;\n    }\n\n    this.listener = function () {\n      var model = self._watcher.get();\n      if (isArray(model)) {\n        var val = self.getValue();\n        var i = indexOf(model, val);\n        if (el.checked) {\n          if (i < 0) {\n            self.set(model.concat(val));\n          }\n        } else if (i > -1) {\n          self.set(model.slice(0, i).concat(model.slice(i + 1)));\n        }\n      } else {\n        self.set(getBooleanValue());\n      }\n    };\n\n    this.on('change', this.listener);\n    if (el.hasAttribute('checked')) {\n      this.afterBind = this.listener;\n    }\n  },\n\n  update: function update(value) {\n    var el = this.el;\n    if (isArray(value)) {\n      el.checked = indexOf(value, this.getValue()) > -1;\n    } else {\n      if (el.hasOwnProperty('_trueValue')) {\n        el.checked = looseEqual(value, el._trueValue);\n      } else {\n        el.checked = !!value;\n      }\n    }\n  }\n};\n\nvar handlers = {\n  text: text$2,\n  radio: radio,\n  select: select,\n  checkbox: checkbox\n};\n\nvar model = {\n\n  priority: MODEL,\n  twoWay: true,\n  handlers: handlers,\n  params: ['lazy', 'number', 'debounce'],\n\n  /**\n   * Possible elements:\n   *   <select>\n   *   <textarea>\n   *   <input type=\"*\">\n   *     - text\n   *     - checkbox\n   *     - radio\n   *     - number\n   */\n\n  bind: function bind() {\n    // friendly warning...\n    this.checkFilters();\n    if (this.hasRead && !this.hasWrite) {\n      'production' !== 'production' && warn('It seems you are using a read-only filter with ' + 'v-model=\"' + this.descriptor.raw + '\". ' + 'You might want to use a two-way filter to ensure correct behavior.', this.vm);\n    }\n    var el = this.el;\n    var tag = el.tagName;\n    var handler;\n    if (tag === 'INPUT') {\n      handler = handlers[el.type] || handlers.text;\n    } else if (tag === 'SELECT') {\n      handler = handlers.select;\n    } else if (tag === 'TEXTAREA') {\n      handler = handlers.text;\n    } else {\n      'production' !== 'production' && warn('v-model does not support element type: ' + tag, this.vm);\n      return;\n    }\n    el.__v_model = this;\n    handler.bind.call(this);\n    this.update = handler.update;\n    this._unbind = handler.unbind;\n  },\n\n  /**\n   * Check read/write filter stats.\n   */\n\n  checkFilters: function checkFilters() {\n    var filters = this.filters;\n    if (!filters) return;\n    var i = filters.length;\n    while (i--) {\n      var filter = resolveAsset(this.vm.$options, 'filters', filters[i].name);\n      if (typeof filter === 'function' || filter.read) {\n        this.hasRead = true;\n      }\n      if (filter.write) {\n        this.hasWrite = true;\n      }\n    }\n  },\n\n  unbind: function unbind() {\n    this.el.__v_model = null;\n    this._unbind && this._unbind();\n  }\n};\n\n// keyCode aliases\nvar keyCodes = {\n  esc: 27,\n  tab: 9,\n  enter: 13,\n  space: 32,\n  'delete': [8, 46],\n  up: 38,\n  left: 37,\n  right: 39,\n  down: 40\n};\n\nfunction keyFilter(handler, keys) {\n  var codes = keys.map(function (key) {\n    var charCode = key.charCodeAt(0);\n    if (charCode > 47 && charCode < 58) {\n      return parseInt(key, 10);\n    }\n    if (key.length === 1) {\n      charCode = key.toUpperCase().charCodeAt(0);\n      if (charCode > 64 && charCode < 91) {\n        return charCode;\n      }\n    }\n    return keyCodes[key];\n  });\n  codes = [].concat.apply([], codes);\n  return function keyHandler(e) {\n    if (codes.indexOf(e.keyCode) > -1) {\n      return handler.call(this, e);\n    }\n  };\n}\n\nfunction stopFilter(handler) {\n  return function stopHandler(e) {\n    e.stopPropagation();\n    return handler.call(this, e);\n  };\n}\n\nfunction preventFilter(handler) {\n  return function preventHandler(e) {\n    e.preventDefault();\n    return handler.call(this, e);\n  };\n}\n\nfunction selfFilter(handler) {\n  return function selfHandler(e) {\n    if (e.target === e.currentTarget) {\n      return handler.call(this, e);\n    }\n  };\n}\n\nvar on$1 = {\n\n  priority: ON,\n  acceptStatement: true,\n  keyCodes: keyCodes,\n\n  bind: function bind() {\n    // deal with iframes\n    if (this.el.tagName === 'IFRAME' && this.arg !== 'load') {\n      var self = this;\n      this.iframeBind = function () {\n        on(self.el.contentWindow, self.arg, self.handler, self.modifiers.capture);\n      };\n      this.on('load', this.iframeBind);\n    }\n  },\n\n  update: function update(handler) {\n    // stub a noop for v-on with no value,\n    // e.g. @mousedown.prevent\n    if (!this.descriptor.raw) {\n      handler = function () {};\n    }\n\n    if (typeof handler !== 'function') {\n      'production' !== 'production' && warn('v-on:' + this.arg + '=\"' + this.expression + '\" expects a function value, ' + 'got ' + handler, this.vm);\n      return;\n    }\n\n    // apply modifiers\n    if (this.modifiers.stop) {\n      handler = stopFilter(handler);\n    }\n    if (this.modifiers.prevent) {\n      handler = preventFilter(handler);\n    }\n    if (this.modifiers.self) {\n      handler = selfFilter(handler);\n    }\n    // key filter\n    var keys = Object.keys(this.modifiers).filter(function (key) {\n      return key !== 'stop' && key !== 'prevent' && key !== 'self' && key !== 'capture';\n    });\n    if (keys.length) {\n      handler = keyFilter(handler, keys);\n    }\n\n    this.reset();\n    this.handler = handler;\n\n    if (this.iframeBind) {\n      this.iframeBind();\n    } else {\n      on(this.el, this.arg, this.handler, this.modifiers.capture);\n    }\n  },\n\n  reset: function reset() {\n    var el = this.iframeBind ? this.el.contentWindow : this.el;\n    if (this.handler) {\n      off(el, this.arg, this.handler);\n    }\n  },\n\n  unbind: function unbind() {\n    this.reset();\n  }\n};\n\nvar prefixes = ['-webkit-', '-moz-', '-ms-'];\nvar camelPrefixes = ['Webkit', 'Moz', 'ms'];\nvar importantRE = /!important;?$/;\nvar propCache = Object.create(null);\n\nvar testEl = null;\n\nvar style = {\n\n  deep: true,\n\n  update: function update(value) {\n    if (typeof value === 'string') {\n      this.el.style.cssText = value;\n    } else if (isArray(value)) {\n      this.handleObject(value.reduce(extend, {}));\n    } else {\n      this.handleObject(value || {});\n    }\n  },\n\n  handleObject: function handleObject(value) {\n    // cache object styles so that only changed props\n    // are actually updated.\n    var cache = this.cache || (this.cache = {});\n    var name, val;\n    for (name in cache) {\n      if (!(name in value)) {\n        this.handleSingle(name, null);\n        delete cache[name];\n      }\n    }\n    for (name in value) {\n      val = value[name];\n      if (val !== cache[name]) {\n        cache[name] = val;\n        this.handleSingle(name, val);\n      }\n    }\n  },\n\n  handleSingle: function handleSingle(prop, value) {\n    prop = normalize(prop);\n    if (!prop) return; // unsupported prop\n    // cast possible numbers/booleans into strings\n    if (value != null) value += '';\n    if (value) {\n      var isImportant = importantRE.test(value) ? 'important' : '';\n      if (isImportant) {\n        /* istanbul ignore if */\n        if ('production' !== 'production') {}\n        value = value.replace(importantRE, '').trim();\n        this.el.style.setProperty(prop.kebab, value, isImportant);\n      } else {\n        this.el.style[prop.camel] = value;\n      }\n    } else {\n      this.el.style[prop.camel] = '';\n    }\n  }\n\n};\n\n/**\n * Normalize a CSS property name.\n * - cache result\n * - auto prefix\n * - camelCase -> dash-case\n *\n * @param {String} prop\n * @return {String}\n */\n\nfunction normalize(prop) {\n  if (propCache[prop]) {\n    return propCache[prop];\n  }\n  var res = prefix(prop);\n  propCache[prop] = propCache[res] = res;\n  return res;\n}\n\n/**\n * Auto detect the appropriate prefix for a CSS property.\n * https://gist.github.com/paulirish/523692\n *\n * @param {String} prop\n * @return {String}\n */\n\nfunction prefix(prop) {\n  prop = hyphenate(prop);\n  var camel = camelize(prop);\n  var upper = camel.charAt(0).toUpperCase() + camel.slice(1);\n  if (!testEl) {\n    testEl = document.createElement('div');\n  }\n  var i = prefixes.length;\n  var prefixed;\n  if (camel !== 'filter' && camel in testEl.style) {\n    return {\n      kebab: prop,\n      camel: camel\n    };\n  }\n  while (i--) {\n    prefixed = camelPrefixes[i] + upper;\n    if (prefixed in testEl.style) {\n      return {\n        kebab: prefixes[i] + prop,\n        camel: prefixed\n      };\n    }\n  }\n}\n\n// xlink\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\nvar xlinkRE = /^xlink:/;\n\n// check for attributes that prohibit interpolations\nvar disallowedInterpAttrRE = /^v-|^:|^@|^(?:is|transition|transition-mode|debounce|track-by|stagger|enter-stagger|leave-stagger)$/;\n// these attributes should also set their corresponding properties\n// because they only affect the initial state of the element\nvar attrWithPropsRE = /^(?:value|checked|selected|muted)$/;\n// these attributes expect enumrated values of \"true\" or \"false\"\n// but are not boolean attributes\nvar enumeratedAttrRE = /^(?:draggable|contenteditable|spellcheck)$/;\n\n// these attributes should set a hidden property for\n// binding v-model to object values\nvar modelProps = {\n  value: '_value',\n  'true-value': '_trueValue',\n  'false-value': '_falseValue'\n};\n\nvar bind$1 = {\n\n  priority: BIND,\n\n  bind: function bind() {\n    var attr = this.arg;\n    var tag = this.el.tagName;\n    // should be deep watch on object mode\n    if (!attr) {\n      this.deep = true;\n    }\n    // handle interpolation bindings\n    var descriptor = this.descriptor;\n    var tokens = descriptor.interp;\n    if (tokens) {\n      // handle interpolations with one-time tokens\n      if (descriptor.hasOneTime) {\n        this.expression = tokensToExp(tokens, this._scope || this.vm);\n      }\n\n      // only allow binding on native attributes\n      if (disallowedInterpAttrRE.test(attr) || attr === 'name' && (tag === 'PARTIAL' || tag === 'SLOT')) {\n        'production' !== 'production' && warn(attr + '=\"' + descriptor.raw + '\": ' + 'attribute interpolation is not allowed in Vue.js ' + 'directives and special attributes.', this.vm);\n        this.el.removeAttribute(attr);\n        this.invalid = true;\n      }\n\n      /* istanbul ignore if */\n      if ('production' !== 'production') {}\n    }\n  },\n\n  update: function update(value) {\n    if (this.invalid) {\n      return;\n    }\n    var attr = this.arg;\n    if (this.arg) {\n      this.handleSingle(attr, value);\n    } else {\n      this.handleObject(value || {});\n    }\n  },\n\n  // share object handler with v-bind:class\n  handleObject: style.handleObject,\n\n  handleSingle: function handleSingle(attr, value) {\n    var el = this.el;\n    var interp = this.descriptor.interp;\n    if (this.modifiers.camel) {\n      attr = camelize(attr);\n    }\n    if (!interp && attrWithPropsRE.test(attr) && attr in el) {\n      var attrValue = attr === 'value' ? value == null // IE9 will set input.value to \"null\" for null...\n      ? '' : value : value;\n\n      if (el[attr] !== attrValue) {\n        el[attr] = attrValue;\n      }\n    }\n    // set model props\n    var modelProp = modelProps[attr];\n    if (!interp && modelProp) {\n      el[modelProp] = value;\n      // update v-model if present\n      var model = el.__v_model;\n      if (model) {\n        model.listener();\n      }\n    }\n    // do not set value attribute for textarea\n    if (attr === 'value' && el.tagName === 'TEXTAREA') {\n      el.removeAttribute(attr);\n      return;\n    }\n    // update attribute\n    if (enumeratedAttrRE.test(attr)) {\n      el.setAttribute(attr, value ? 'true' : 'false');\n    } else if (value != null && value !== false) {\n      if (attr === 'class') {\n        // handle edge case #1960:\n        // class interpolation should not overwrite Vue transition class\n        if (el.__v_trans) {\n          value += ' ' + el.__v_trans.id + '-transition';\n        }\n        setClass(el, value);\n      } else if (xlinkRE.test(attr)) {\n        el.setAttributeNS(xlinkNS, attr, value === true ? '' : value);\n      } else {\n        el.setAttribute(attr, value === true ? '' : value);\n      }\n    } else {\n      el.removeAttribute(attr);\n    }\n  }\n};\n\nvar el = {\n\n  priority: EL,\n\n  bind: function bind() {\n    /* istanbul ignore if */\n    if (!this.arg) {\n      return;\n    }\n    var id = this.id = camelize(this.arg);\n    var refs = (this._scope || this.vm).$els;\n    if (hasOwn(refs, id)) {\n      refs[id] = this.el;\n    } else {\n      defineReactive(refs, id, this.el);\n    }\n  },\n\n  unbind: function unbind() {\n    var refs = (this._scope || this.vm).$els;\n    if (refs[this.id] === this.el) {\n      refs[this.id] = null;\n    }\n  }\n};\n\nvar ref = {\n  bind: function bind() {\n    'production' !== 'production' && warn('v-ref:' + this.arg + ' must be used on a child ' + 'component. Found on <' + this.el.tagName.toLowerCase() + '>.', this.vm);\n  }\n};\n\nvar cloak = {\n  bind: function bind() {\n    var el = this.el;\n    this.vm.$once('pre-hook:compiled', function () {\n      el.removeAttribute('v-cloak');\n    });\n  }\n};\n\n// logic control\n// two-way binding\n// event handling\n// attributes\n// ref & el\n// cloak\n// must export plain object\nvar directives = {\n  text: text$1,\n  html: html,\n  'for': vFor,\n  'if': vIf,\n  show: show,\n  model: model,\n  on: on$1,\n  bind: bind$1,\n  el: el,\n  ref: ref,\n  cloak: cloak\n};\n\nvar vClass = {\n\n  deep: true,\n\n  update: function update(value) {\n    if (!value) {\n      this.cleanup();\n    } else if (typeof value === 'string') {\n      this.setClass(value.trim().split(/\\s+/));\n    } else {\n      this.setClass(normalize$1(value));\n    }\n  },\n\n  setClass: function setClass(value) {\n    this.cleanup(value);\n    for (var i = 0, l = value.length; i < l; i++) {\n      var val = value[i];\n      if (val) {\n        apply(this.el, val, addClass);\n      }\n    }\n    this.prevKeys = value;\n  },\n\n  cleanup: function cleanup(value) {\n    var prevKeys = this.prevKeys;\n    if (!prevKeys) return;\n    var i = prevKeys.length;\n    while (i--) {\n      var key = prevKeys[i];\n      if (!value || value.indexOf(key) < 0) {\n        apply(this.el, key, removeClass);\n      }\n    }\n  }\n};\n\n/**\n * Normalize objects and arrays (potentially containing objects)\n * into array of strings.\n *\n * @param {Object|Array<String|Object>} value\n * @return {Array<String>}\n */\n\nfunction normalize$1(value) {\n  var res = [];\n  if (isArray(value)) {\n    for (var i = 0, l = value.length; i < l; i++) {\n      var _key = value[i];\n      if (_key) {\n        if (typeof _key === 'string') {\n          res.push(_key);\n        } else {\n          for (var k in _key) {\n            if (_key[k]) res.push(k);\n          }\n        }\n      }\n    }\n  } else if (isObject(value)) {\n    for (var key in value) {\n      if (value[key]) res.push(key);\n    }\n  }\n  return res;\n}\n\n/**\n * Add or remove a class/classes on an element\n *\n * @param {Element} el\n * @param {String} key The class name. This may or may not\n *                     contain a space character, in such a\n *                     case we'll deal with multiple class\n *                     names at once.\n * @param {Function} fn\n */\n\nfunction apply(el, key, fn) {\n  key = key.trim();\n  if (key.indexOf(' ') === -1) {\n    fn(el, key);\n    return;\n  }\n  // The key contains one or more space characters.\n  // Since a class name doesn't accept such characters, we\n  // treat it as multiple classes.\n  var keys = key.split(/\\s+/);\n  for (var i = 0, l = keys.length; i < l; i++) {\n    fn(el, keys[i]);\n  }\n}\n\nvar component = {\n\n  priority: COMPONENT,\n\n  params: ['keep-alive', 'transition-mode', 'inline-template'],\n\n  /**\n   * Setup. Two possible usages:\n   *\n   * - static:\n   *   <comp> or <div v-component=\"comp\">\n   *\n   * - dynamic:\n   *   <component :is=\"view\">\n   */\n\n  bind: function bind() {\n    if (!this.el.__vue__) {\n      // keep-alive cache\n      this.keepAlive = this.params.keepAlive;\n      if (this.keepAlive) {\n        this.cache = {};\n      }\n      // check inline-template\n      if (this.params.inlineTemplate) {\n        // extract inline template as a DocumentFragment\n        this.inlineTemplate = extractContent(this.el, true);\n      }\n      // component resolution related state\n      this.pendingComponentCb = this.Component = null;\n      // transition related state\n      this.pendingRemovals = 0;\n      this.pendingRemovalCb = null;\n      // create a ref anchor\n      this.anchor = createAnchor('v-component');\n      replace(this.el, this.anchor);\n      // remove is attribute.\n      // this is removed during compilation, but because compilation is\n      // cached, when the component is used elsewhere this attribute\n      // will remain at link time.\n      this.el.removeAttribute('is');\n      this.el.removeAttribute(':is');\n      // remove ref, same as above\n      if (this.descriptor.ref) {\n        this.el.removeAttribute('v-ref:' + hyphenate(this.descriptor.ref));\n      }\n      // if static, build right now.\n      if (this.literal) {\n        this.setComponent(this.expression);\n      }\n    } else {\n      'production' !== 'production' && warn('cannot mount component \"' + this.expression + '\" ' + 'on already mounted element: ' + this.el);\n    }\n  },\n\n  /**\n   * Public update, called by the watcher in the dynamic\n   * literal scenario, e.g. <component :is=\"view\">\n   */\n\n  update: function update(value) {\n    if (!this.literal) {\n      this.setComponent(value);\n    }\n  },\n\n  /**\n   * Switch dynamic components. May resolve the component\n   * asynchronously, and perform transition based on\n   * specified transition mode. Accepts a few additional\n   * arguments specifically for vue-router.\n   *\n   * The callback is called when the full transition is\n   * finished.\n   *\n   * @param {String} value\n   * @param {Function} [cb]\n   */\n\n  setComponent: function setComponent(value, cb) {\n    this.invalidatePending();\n    if (!value) {\n      // just remove current\n      this.unbuild(true);\n      this.remove(this.childVM, cb);\n      this.childVM = null;\n    } else {\n      var self = this;\n      this.resolveComponent(value, function () {\n        self.mountComponent(cb);\n      });\n    }\n  },\n\n  /**\n   * Resolve the component constructor to use when creating\n   * the child vm.\n   *\n   * @param {String|Function} value\n   * @param {Function} cb\n   */\n\n  resolveComponent: function resolveComponent(value, cb) {\n    var self = this;\n    this.pendingComponentCb = cancellable(function (Component) {\n      self.ComponentName = Component.options.name || (typeof value === 'string' ? value : null);\n      self.Component = Component;\n      cb();\n    });\n    this.vm._resolveComponent(value, this.pendingComponentCb);\n  },\n\n  /**\n   * Create a new instance using the current constructor and\n   * replace the existing instance. This method doesn't care\n   * whether the new component and the old one are actually\n   * the same.\n   *\n   * @param {Function} [cb]\n   */\n\n  mountComponent: function mountComponent(cb) {\n    // actual mount\n    this.unbuild(true);\n    var self = this;\n    var activateHooks = this.Component.options.activate;\n    var cached = this.getCached();\n    var newComponent = this.build();\n    if (activateHooks && !cached) {\n      this.waitingFor = newComponent;\n      callActivateHooks(activateHooks, newComponent, function () {\n        if (self.waitingFor !== newComponent) {\n          return;\n        }\n        self.waitingFor = null;\n        self.transition(newComponent, cb);\n      });\n    } else {\n      // update ref for kept-alive component\n      if (cached) {\n        newComponent._updateRef();\n      }\n      this.transition(newComponent, cb);\n    }\n  },\n\n  /**\n   * When the component changes or unbinds before an async\n   * constructor is resolved, we need to invalidate its\n   * pending callback.\n   */\n\n  invalidatePending: function invalidatePending() {\n    if (this.pendingComponentCb) {\n      this.pendingComponentCb.cancel();\n      this.pendingComponentCb = null;\n    }\n  },\n\n  /**\n   * Instantiate/insert a new child vm.\n   * If keep alive and has cached instance, insert that\n   * instance; otherwise build a new one and cache it.\n   *\n   * @param {Object} [extraOptions]\n   * @return {Vue} - the created instance\n   */\n\n  build: function build(extraOptions) {\n    var cached = this.getCached();\n    if (cached) {\n      return cached;\n    }\n    if (this.Component) {\n      // default options\n      var options = {\n        name: this.ComponentName,\n        el: cloneNode(this.el),\n        template: this.inlineTemplate,\n        // make sure to add the child with correct parent\n        // if this is a transcluded component, its parent\n        // should be the transclusion host.\n        parent: this._host || this.vm,\n        // if no inline-template, then the compiled\n        // linker can be cached for better performance.\n        _linkerCachable: !this.inlineTemplate,\n        _ref: this.descriptor.ref,\n        _asComponent: true,\n        _isRouterView: this._isRouterView,\n        // if this is a transcluded component, context\n        // will be the common parent vm of this instance\n        // and its host.\n        _context: this.vm,\n        // if this is inside an inline v-for, the scope\n        // will be the intermediate scope created for this\n        // repeat fragment. this is used for linking props\n        // and container directives.\n        _scope: this._scope,\n        // pass in the owner fragment of this component.\n        // this is necessary so that the fragment can keep\n        // track of its contained components in order to\n        // call attach/detach hooks for them.\n        _frag: this._frag\n      };\n      // extra options\n      // in 1.0.0 this is used by vue-router only\n      /* istanbul ignore if */\n      if (extraOptions) {\n        extend(options, extraOptions);\n      }\n      var child = new this.Component(options);\n      if (this.keepAlive) {\n        this.cache[this.Component.cid] = child;\n      }\n      /* istanbul ignore if */\n      if ('production' !== 'production' && this.el.hasAttribute('transition') && child._isFragment) {}\n      return child;\n    }\n  },\n\n  /**\n   * Try to get a cached instance of the current component.\n   *\n   * @return {Vue|undefined}\n   */\n\n  getCached: function getCached() {\n    return this.keepAlive && this.cache[this.Component.cid];\n  },\n\n  /**\n   * Teardown the current child, but defers cleanup so\n   * that we can separate the destroy and removal steps.\n   *\n   * @param {Boolean} defer\n   */\n\n  unbuild: function unbuild(defer) {\n    if (this.waitingFor) {\n      if (!this.keepAlive) {\n        this.waitingFor.$destroy();\n      }\n      this.waitingFor = null;\n    }\n    var child = this.childVM;\n    if (!child || this.keepAlive) {\n      if (child) {\n        // remove ref\n        child._inactive = true;\n        child._updateRef(true);\n      }\n      return;\n    }\n    // the sole purpose of `deferCleanup` is so that we can\n    // \"deactivate\" the vm right now and perform DOM removal\n    // later.\n    child.$destroy(false, defer);\n  },\n\n  /**\n   * Remove current destroyed child and manually do\n   * the cleanup after removal.\n   *\n   * @param {Function} cb\n   */\n\n  remove: function remove(child, cb) {\n    var keepAlive = this.keepAlive;\n    if (child) {\n      // we may have a component switch when a previous\n      // component is still being transitioned out.\n      // we want to trigger only one lastest insertion cb\n      // when the existing transition finishes. (#1119)\n      this.pendingRemovals++;\n      this.pendingRemovalCb = cb;\n      var self = this;\n      child.$remove(function () {\n        self.pendingRemovals--;\n        if (!keepAlive) child._cleanup();\n        if (!self.pendingRemovals && self.pendingRemovalCb) {\n          self.pendingRemovalCb();\n          self.pendingRemovalCb = null;\n        }\n      });\n    } else if (cb) {\n      cb();\n    }\n  },\n\n  /**\n   * Actually swap the components, depending on the\n   * transition mode. Defaults to simultaneous.\n   *\n   * @param {Vue} target\n   * @param {Function} [cb]\n   */\n\n  transition: function transition(target, cb) {\n    var self = this;\n    var current = this.childVM;\n    // for devtool inspection\n    if (current) current._inactive = true;\n    target._inactive = false;\n    this.childVM = target;\n    switch (self.params.transitionMode) {\n      case 'in-out':\n        target.$before(self.anchor, function () {\n          self.remove(current, cb);\n        });\n        break;\n      case 'out-in':\n        self.remove(current, function () {\n          target.$before(self.anchor, cb);\n        });\n        break;\n      default:\n        self.remove(current);\n        target.$before(self.anchor, cb);\n    }\n  },\n\n  /**\n   * Unbind.\n   */\n\n  unbind: function unbind() {\n    this.invalidatePending();\n    // Do not defer cleanup when unbinding\n    this.unbuild();\n    // destroy all keep-alive cached instances\n    if (this.cache) {\n      for (var key in this.cache) {\n        this.cache[key].$destroy();\n      }\n      this.cache = null;\n    }\n  }\n};\n\n/**\n * Call activate hooks in order (asynchronous)\n *\n * @param {Array} hooks\n * @param {Vue} vm\n * @param {Function} cb\n */\n\nfunction callActivateHooks(hooks, vm, cb) {\n  var total = hooks.length;\n  var called = 0;\n  hooks[0].call(vm, next);\n  function next() {\n    if (++called >= total) {\n      cb();\n    } else {\n      hooks[called].call(vm, next);\n    }\n  }\n}\n\nvar propBindingModes = config._propBindingModes;\nvar empty = {};\n\n// regexes\nvar identRE$1 = /^[$_a-zA-Z]+[\\w$]*$/;\nvar settablePathRE = /^[A-Za-z_$][\\w$]*(\\.[A-Za-z_$][\\w$]*|\\[[^\\[\\]]+\\])*$/;\n\n/**\n * Compile props on a root element and return\n * a props link function.\n *\n * @param {Element|DocumentFragment} el\n * @param {Array} propOptions\n * @param {Vue} vm\n * @return {Function} propsLinkFn\n */\n\nfunction compileProps(el, propOptions, vm) {\n  var props = [];\n  var propsData = vm.$options.propsData;\n  var names = Object.keys(propOptions);\n  var i = names.length;\n  var options, name, attr, value, path, parsed, prop;\n  while (i--) {\n    name = names[i];\n    options = propOptions[name] || empty;\n\n    if ('production' !== 'production' && name === '$data') {}\n\n    // props could contain dashes, which will be\n    // interpreted as minus calculations by the parser\n    // so we need to camelize the path here\n    path = camelize(name);\n    if (!identRE$1.test(path)) {\n      'production' !== 'production' && warn('Invalid prop key: \"' + name + '\". Prop keys ' + 'must be valid identifiers.', vm);\n      continue;\n    }\n\n    prop = {\n      name: name,\n      path: path,\n      options: options,\n      mode: propBindingModes.ONE_WAY,\n      raw: null\n    };\n\n    attr = hyphenate(name);\n    // first check dynamic version\n    if ((value = getBindAttr(el, attr)) === null) {\n      if ((value = getBindAttr(el, attr + '.sync')) !== null) {\n        prop.mode = propBindingModes.TWO_WAY;\n      } else if ((value = getBindAttr(el, attr + '.once')) !== null) {\n        prop.mode = propBindingModes.ONE_TIME;\n      }\n    }\n    if (value !== null) {\n      // has dynamic binding!\n      prop.raw = value;\n      parsed = parseDirective(value);\n      value = parsed.expression;\n      prop.filters = parsed.filters;\n      // check binding type\n      if (isLiteral(value) && !parsed.filters) {\n        // for expressions containing literal numbers and\n        // booleans, there's no need to setup a prop binding,\n        // so we can optimize them as a one-time set.\n        prop.optimizedLiteral = true;\n      } else {\n        prop.dynamic = true;\n        // check non-settable path for two-way bindings\n        if ('production' !== 'production' && prop.mode === propBindingModes.TWO_WAY && !settablePathRE.test(value)) {}\n      }\n      prop.parentPath = value;\n\n      // warn required two-way\n      if ('production' !== 'production' && options.twoWay && prop.mode !== propBindingModes.TWO_WAY) {}\n    } else if ((value = getAttr(el, attr)) !== null) {\n      // has literal binding!\n      prop.raw = value;\n    } else if (propsData && (value = propsData[name] || propsData[path]) !== null) {\n      // has propsData\n      prop.raw = value;\n    } else if ('production' !== 'production') {}\n    // push prop\n    props.push(prop);\n  }\n  return makePropsLinkFn(props);\n}\n\n/**\n * Build a function that applies props to a vm.\n *\n * @param {Array} props\n * @return {Function} propsLinkFn\n */\n\nfunction makePropsLinkFn(props) {\n  return function propsLinkFn(vm, scope) {\n    // store resolved props info\n    vm._props = {};\n    var inlineProps = vm.$options.propsData;\n    var i = props.length;\n    var prop, path, options, value, raw;\n    while (i--) {\n      prop = props[i];\n      raw = prop.raw;\n      path = prop.path;\n      options = prop.options;\n      vm._props[path] = prop;\n      if (inlineProps && hasOwn(inlineProps, path)) {\n        initProp(vm, prop, inlineProps[path]);\n      }if (raw === null) {\n        // initialize absent prop\n        initProp(vm, prop, undefined);\n      } else if (prop.dynamic) {\n        // dynamic prop\n        if (prop.mode === propBindingModes.ONE_TIME) {\n          // one time binding\n          value = (scope || vm._context || vm).$get(prop.parentPath);\n          initProp(vm, prop, value);\n        } else {\n          if (vm._context) {\n            // dynamic binding\n            vm._bindDir({\n              name: 'prop',\n              def: propDef,\n              prop: prop\n            }, null, null, scope); // el, host, scope\n          } else {\n              // root instance\n              initProp(vm, prop, vm.$get(prop.parentPath));\n            }\n        }\n      } else if (prop.optimizedLiteral) {\n        // optimized literal, cast it and just set once\n        var stripped = stripQuotes(raw);\n        value = stripped === raw ? toBoolean(toNumber(raw)) : stripped;\n        initProp(vm, prop, value);\n      } else {\n        // string literal, but we need to cater for\n        // Boolean props with no value, or with same\n        // literal value (e.g. disabled=\"disabled\")\n        // see https://github.com/vuejs/vue-loader/issues/182\n        value = options.type === Boolean && (raw === '' || raw === hyphenate(prop.name)) ? true : raw;\n        initProp(vm, prop, value);\n      }\n    }\n  };\n}\n\n/**\n * Process a prop with a rawValue, applying necessary coersions,\n * default values & assertions and call the given callback with\n * processed value.\n *\n * @param {Vue} vm\n * @param {Object} prop\n * @param {*} rawValue\n * @param {Function} fn\n */\n\nfunction processPropValue(vm, prop, rawValue, fn) {\n  var isSimple = prop.dynamic && isSimplePath(prop.parentPath);\n  var value = rawValue;\n  if (value === undefined) {\n    value = getPropDefaultValue(vm, prop);\n  }\n  value = coerceProp(prop, value, vm);\n  var coerced = value !== rawValue;\n  if (!assertProp(prop, value, vm)) {\n    value = undefined;\n  }\n  if (isSimple && !coerced) {\n    withoutConversion(function () {\n      fn(value);\n    });\n  } else {\n    fn(value);\n  }\n}\n\n/**\n * Set a prop's initial value on a vm and its data object.\n *\n * @param {Vue} vm\n * @param {Object} prop\n * @param {*} value\n */\n\nfunction initProp(vm, prop, value) {\n  processPropValue(vm, prop, value, function (value) {\n    defineReactive(vm, prop.path, value);\n  });\n}\n\n/**\n * Update a prop's value on a vm.\n *\n * @param {Vue} vm\n * @param {Object} prop\n * @param {*} value\n */\n\nfunction updateProp(vm, prop, value) {\n  processPropValue(vm, prop, value, function (value) {\n    vm[prop.path] = value;\n  });\n}\n\n/**\n * Get the default value of a prop.\n *\n * @param {Vue} vm\n * @param {Object} prop\n * @return {*}\n */\n\nfunction getPropDefaultValue(vm, prop) {\n  // no default, return undefined\n  var options = prop.options;\n  if (!hasOwn(options, 'default')) {\n    // absent boolean value defaults to false\n    return options.type === Boolean ? false : undefined;\n  }\n  var def = options['default'];\n  // warn against non-factory defaults for Object & Array\n  if (isObject(def)) {\n    'production' !== 'production' && warn('Invalid default value for prop \"' + prop.name + '\": ' + 'Props with type Object/Array must use a factory function ' + 'to return the default value.', vm);\n  }\n  // call factory function for non-Function types\n  return typeof def === 'function' && options.type !== Function ? def.call(vm) : def;\n}\n\n/**\n * Assert whether a prop is valid.\n *\n * @param {Object} prop\n * @param {*} value\n * @param {Vue} vm\n */\n\nfunction assertProp(prop, value, vm) {\n  if (!prop.options.required && ( // non-required\n  prop.raw === null || // abscent\n  value == null) // null or undefined\n  ) {\n      return true;\n    }\n  var options = prop.options;\n  var type = options.type;\n  var valid = !type;\n  var expectedTypes = [];\n  if (type) {\n    if (!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    if ('production' !== 'production') {}\n    return false;\n  }\n  var validator = options.validator;\n  if (validator) {\n    if (!validator(value)) {\n      'production' !== 'production' && warn('Invalid prop: custom validator check failed for prop \"' + prop.name + '\".', vm);\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Force parsing value with coerce option.\n *\n * @param {*} value\n * @param {Object} options\n * @return {*}\n */\n\nfunction coerceProp(prop, value, vm) {\n  var coerce = prop.options.coerce;\n  if (!coerce) {\n    return value;\n  }\n  if (typeof coerce === 'function') {\n    return coerce(value);\n  } else {\n    'production' !== 'production' && warn('Invalid coerce for prop \"' + prop.name + '\": expected function, got ' + typeof coerce + '.', vm);\n    return value;\n  }\n}\n\n/**\n * Assert the type of a value\n *\n * @param {*} value\n * @param {Function} type\n * @return {Object}\n */\n\nfunction assertType(value, type) {\n  var valid;\n  var expectedType;\n  if (type === String) {\n    expectedType = 'string';\n    valid = typeof value === expectedType;\n  } else if (type === Number) {\n    expectedType = 'number';\n    valid = typeof value === expectedType;\n  } else if (type === Boolean) {\n    expectedType = 'boolean';\n    valid = typeof value === expectedType;\n  } else if (type === Function) {\n    expectedType = 'function';\n    valid = typeof value === expectedType;\n  } else if (type === Object) {\n    expectedType = 'object';\n    valid = isPlainObject(value);\n  } else if (type === Array) {\n    expectedType = 'array';\n    valid = isArray(value);\n  } else {\n    valid = value instanceof type;\n  }\n  return {\n    valid: valid,\n    expectedType: expectedType\n  };\n}\n\nvar bindingModes = config._propBindingModes;\n\nvar propDef = {\n\n  bind: function bind() {\n    var child = this.vm;\n    var parent = child._context;\n    // passed in from compiler directly\n    var prop = this.descriptor.prop;\n    var childKey = prop.path;\n    var parentKey = prop.parentPath;\n    var twoWay = prop.mode === bindingModes.TWO_WAY;\n\n    var parentWatcher = this.parentWatcher = new Watcher(parent, parentKey, function (val) {\n      updateProp(child, prop, val);\n    }, {\n      twoWay: twoWay,\n      filters: prop.filters,\n      // important: props need to be observed on the\n      // v-for scope if present\n      scope: this._scope\n    });\n\n    // set the child initial value.\n    initProp(child, prop, parentWatcher.value);\n\n    // setup two-way binding\n    if (twoWay) {\n      // important: defer the child watcher creation until\n      // the created hook (after data observation)\n      var self = this;\n      child.$once('pre-hook:created', function () {\n        self.childWatcher = new Watcher(child, childKey, function (val) {\n          parentWatcher.set(val);\n        }, {\n          // ensure sync upward before parent sync down.\n          // this is necessary in cases e.g. the child\n          // mutates a prop array, then replaces it. (#1683)\n          sync: true\n        });\n      });\n    }\n  },\n\n  unbind: function unbind() {\n    this.parentWatcher.teardown();\n    if (this.childWatcher) {\n      this.childWatcher.teardown();\n    }\n  }\n};\n\nvar queue$1 = [];\nvar queued = false;\n\n/**\n * Push a job into the queue.\n *\n * @param {Function} job\n */\n\nfunction pushJob(job) {\n  queue$1.push(job);\n  if (!queued) {\n    queued = true;\n    nextTick(flush);\n  }\n}\n\n/**\n * Flush the queue, and do one forced reflow before\n * triggering transitions.\n */\n\nfunction flush() {\n  // Force layout\n  var f = document.documentElement.offsetHeight;\n  for (var i = 0; i < queue$1.length; i++) {\n    queue$1[i]();\n  }\n  queue$1 = [];\n  queued = false;\n  // dummy return, so js linters don't complain about\n  // unused variable f\n  return f;\n}\n\nvar TYPE_TRANSITION = 'transition';\nvar TYPE_ANIMATION = 'animation';\nvar transDurationProp = transitionProp + 'Duration';\nvar animDurationProp = animationProp + 'Duration';\n\n/**\n * If a just-entered element is applied the\n * leave class while its enter transition hasn't started yet,\n * and the transitioned property has the same value for both\n * enter/leave, then the leave transition will be skipped and\n * the transitionend event never fires. This function ensures\n * its callback to be called after a transition has started\n * by waiting for double raf.\n *\n * It falls back to setTimeout on devices that support CSS\n * transitions but not raf (e.g. Android 4.2 browser) - since\n * these environments are usually slow, we are giving it a\n * relatively large timeout.\n */\n\nvar raf = inBrowser && window.requestAnimationFrame;\nvar waitForTransitionStart = raf\n/* istanbul ignore next */\n? function (fn) {\n  raf(function () {\n    raf(fn);\n  });\n} : function (fn) {\n  setTimeout(fn, 50);\n};\n\n/**\n * A Transition object that encapsulates the state and logic\n * of the transition.\n *\n * @param {Element} el\n * @param {String} id\n * @param {Object} hooks\n * @param {Vue} vm\n */\nfunction Transition(el, id, hooks, vm) {\n  this.id = id;\n  this.el = el;\n  this.enterClass = hooks && hooks.enterClass || id + '-enter';\n  this.leaveClass = hooks && hooks.leaveClass || id + '-leave';\n  this.hooks = hooks;\n  this.vm = vm;\n  // async state\n  this.pendingCssEvent = this.pendingCssCb = this.cancel = this.pendingJsCb = this.op = this.cb = null;\n  this.justEntered = false;\n  this.entered = this.left = false;\n  this.typeCache = {};\n  // check css transition type\n  this.type = hooks && hooks.type;\n  /* istanbul ignore if */\n  if ('production' !== 'production') {}\n  // bind\n  var self = this;['enterNextTick', 'enterDone', 'leaveNextTick', 'leaveDone'].forEach(function (m) {\n    self[m] = bind(self[m], self);\n  });\n}\n\nvar p$1 = Transition.prototype;\n\n/**\n * Start an entering transition.\n *\n * 1. enter transition triggered\n * 2. call beforeEnter hook\n * 3. add enter class\n * 4. insert/show element\n * 5. call enter hook (with possible explicit js callback)\n * 6. reflow\n * 7. based on transition type:\n *    - transition:\n *        remove class now, wait for transitionend,\n *        then done if there's no explicit js callback.\n *    - animation:\n *        wait for animationend, remove class,\n *        then done if there's no explicit js callback.\n *    - no css transition:\n *        done now if there's no explicit js callback.\n * 8. wait for either done or js callback, then call\n *    afterEnter hook.\n *\n * @param {Function} op - insert/show the element\n * @param {Function} [cb]\n */\n\np$1.enter = function (op, cb) {\n  this.cancelPending();\n  this.callHook('beforeEnter');\n  this.cb = cb;\n  addClass(this.el, this.enterClass);\n  op();\n  this.entered = false;\n  this.callHookWithCb('enter');\n  if (this.entered) {\n    return; // user called done synchronously.\n  }\n  this.cancel = this.hooks && this.hooks.enterCancelled;\n  pushJob(this.enterNextTick);\n};\n\n/**\n * The \"nextTick\" phase of an entering transition, which is\n * to be pushed into a queue and executed after a reflow so\n * that removing the class can trigger a CSS transition.\n */\n\np$1.enterNextTick = function () {\n  var _this = this;\n\n  // prevent transition skipping\n  this.justEntered = true;\n  waitForTransitionStart(function () {\n    _this.justEntered = false;\n  });\n  var enterDone = this.enterDone;\n  var type = this.getCssTransitionType(this.enterClass);\n  if (!this.pendingJsCb) {\n    if (type === TYPE_TRANSITION) {\n      // trigger transition by removing enter class now\n      removeClass(this.el, this.enterClass);\n      this.setupCssCb(transitionEndEvent, enterDone);\n    } else if (type === TYPE_ANIMATION) {\n      this.setupCssCb(animationEndEvent, enterDone);\n    } else {\n      enterDone();\n    }\n  } else if (type === TYPE_TRANSITION) {\n    removeClass(this.el, this.enterClass);\n  }\n};\n\n/**\n * The \"cleanup\" phase of an entering transition.\n */\n\np$1.enterDone = function () {\n  this.entered = true;\n  this.cancel = this.pendingJsCb = null;\n  removeClass(this.el, this.enterClass);\n  this.callHook('afterEnter');\n  if (this.cb) this.cb();\n};\n\n/**\n * Start a leaving transition.\n *\n * 1. leave transition triggered.\n * 2. call beforeLeave hook\n * 3. add leave class (trigger css transition)\n * 4. call leave hook (with possible explicit js callback)\n * 5. reflow if no explicit js callback is provided\n * 6. based on transition type:\n *    - transition or animation:\n *        wait for end event, remove class, then done if\n *        there's no explicit js callback.\n *    - no css transition:\n *        done if there's no explicit js callback.\n * 7. wait for either done or js callback, then call\n *    afterLeave hook.\n *\n * @param {Function} op - remove/hide the element\n * @param {Function} [cb]\n */\n\np$1.leave = function (op, cb) {\n  this.cancelPending();\n  this.callHook('beforeLeave');\n  this.op = op;\n  this.cb = cb;\n  addClass(this.el, this.leaveClass);\n  this.left = false;\n  this.callHookWithCb('leave');\n  if (this.left) {\n    return; // user called done synchronously.\n  }\n  this.cancel = this.hooks && this.hooks.leaveCancelled;\n  // only need to handle leaveDone if\n  // 1. the transition is already done (synchronously called\n  //    by the user, which causes this.op set to null)\n  // 2. there's no explicit js callback\n  if (this.op && !this.pendingJsCb) {\n    // if a CSS transition leaves immediately after enter,\n    // the transitionend event never fires. therefore we\n    // detect such cases and end the leave immediately.\n    if (this.justEntered) {\n      this.leaveDone();\n    } else {\n      pushJob(this.leaveNextTick);\n    }\n  }\n};\n\n/**\n * The \"nextTick\" phase of a leaving transition.\n */\n\np$1.leaveNextTick = function () {\n  var type = this.getCssTransitionType(this.leaveClass);\n  if (type) {\n    var event = type === TYPE_TRANSITION ? transitionEndEvent : animationEndEvent;\n    this.setupCssCb(event, this.leaveDone);\n  } else {\n    this.leaveDone();\n  }\n};\n\n/**\n * The \"cleanup\" phase of a leaving transition.\n */\n\np$1.leaveDone = function () {\n  this.left = true;\n  this.cancel = this.pendingJsCb = null;\n  this.op();\n  removeClass(this.el, this.leaveClass);\n  this.callHook('afterLeave');\n  if (this.cb) this.cb();\n  this.op = null;\n};\n\n/**\n * Cancel any pending callbacks from a previously running\n * but not finished transition.\n */\n\np$1.cancelPending = function () {\n  this.op = this.cb = null;\n  var hasPending = false;\n  if (this.pendingCssCb) {\n    hasPending = true;\n    off(this.el, this.pendingCssEvent, this.pendingCssCb);\n    this.pendingCssEvent = this.pendingCssCb = null;\n  }\n  if (this.pendingJsCb) {\n    hasPending = true;\n    this.pendingJsCb.cancel();\n    this.pendingJsCb = null;\n  }\n  if (hasPending) {\n    removeClass(this.el, this.enterClass);\n    removeClass(this.el, this.leaveClass);\n  }\n  if (this.cancel) {\n    this.cancel.call(this.vm, this.el);\n    this.cancel = null;\n  }\n};\n\n/**\n * Call a user-provided synchronous hook function.\n *\n * @param {String} type\n */\n\np$1.callHook = function (type) {\n  if (this.hooks && this.hooks[type]) {\n    this.hooks[type].call(this.vm, this.el);\n  }\n};\n\n/**\n * Call a user-provided, potentially-async hook function.\n * We check for the length of arguments to see if the hook\n * expects a `done` callback. If true, the transition's end\n * will be determined by when the user calls that callback;\n * otherwise, the end is determined by the CSS transition or\n * animation.\n *\n * @param {String} type\n */\n\np$1.callHookWithCb = function (type) {\n  var hook = this.hooks && this.hooks[type];\n  if (hook) {\n    if (hook.length > 1) {\n      this.pendingJsCb = cancellable(this[type + 'Done']);\n    }\n    hook.call(this.vm, this.el, this.pendingJsCb);\n  }\n};\n\n/**\n * Get an element's transition type based on the\n * calculated styles.\n *\n * @param {String} className\n * @return {Number}\n */\n\np$1.getCssTransitionType = function (className) {\n  /* istanbul ignore if */\n  if (!transitionEndEvent ||\n  // skip CSS transitions if page is not visible -\n  // this solves the issue of transitionend events not\n  // firing until the page is visible again.\n  // pageVisibility API is supported in IE10+, same as\n  // CSS transitions.\n  document.hidden ||\n  // explicit js-only transition\n  this.hooks && this.hooks.css === false ||\n  // element is hidden\n  isHidden(this.el)) {\n    return;\n  }\n  var type = this.type || this.typeCache[className];\n  if (type) return type;\n  var inlineStyles = this.el.style;\n  var computedStyles = window.getComputedStyle(this.el);\n  var transDuration = inlineStyles[transDurationProp] || computedStyles[transDurationProp];\n  if (transDuration && transDuration !== '0s') {\n    type = TYPE_TRANSITION;\n  } else {\n    var animDuration = inlineStyles[animDurationProp] || computedStyles[animDurationProp];\n    if (animDuration && animDuration !== '0s') {\n      type = TYPE_ANIMATION;\n    }\n  }\n  if (type) {\n    this.typeCache[className] = type;\n  }\n  return type;\n};\n\n/**\n * Setup a CSS transitionend/animationend callback.\n *\n * @param {String} event\n * @param {Function} cb\n */\n\np$1.setupCssCb = function (event, cb) {\n  this.pendingCssEvent = event;\n  var self = this;\n  var el = this.el;\n  var onEnd = this.pendingCssCb = function (e) {\n    if (e.target === el) {\n      off(el, event, onEnd);\n      self.pendingCssEvent = self.pendingCssCb = null;\n      if (!self.pendingJsCb && cb) {\n        cb();\n      }\n    }\n  };\n  on(el, event, onEnd);\n};\n\n/**\n * Check if an element is hidden - in that case we can just\n * skip the transition alltogether.\n *\n * @param {Element} el\n * @return {Boolean}\n */\n\nfunction isHidden(el) {\n  if (/svg$/.test(el.namespaceURI)) {\n    // SVG elements do not have offset(Width|Height)\n    // so we need to check the client rect\n    var rect = el.getBoundingClientRect();\n    return !(rect.width || rect.height);\n  } else {\n    return !(el.offsetWidth || el.offsetHeight || el.getClientRects().length);\n  }\n}\n\nvar transition$1 = {\n\n  priority: TRANSITION,\n\n  update: function update(id, oldId) {\n    var el = this.el;\n    // resolve on owner vm\n    var hooks = resolveAsset(this.vm.$options, 'transitions', id);\n    id = id || 'v';\n    oldId = oldId || 'v';\n    el.__v_trans = new Transition(el, id, hooks, this.vm);\n    removeClass(el, oldId + '-transition');\n    addClass(el, id + '-transition');\n  }\n};\n\nvar internalDirectives = {\n  style: style,\n  'class': vClass,\n  component: component,\n  prop: propDef,\n  transition: transition$1\n};\n\n// special binding prefixes\nvar bindRE = /^v-bind:|^:/;\nvar onRE = /^v-on:|^@/;\nvar dirAttrRE = /^v-([^:]+)(?:$|:(.*)$)/;\nvar modifierRE = /\\.[^\\.]+/g;\nvar transitionRE = /^(v-bind:|:)?transition$/;\n\n// default directive priority\nvar DEFAULT_PRIORITY = 1000;\nvar DEFAULT_TERMINAL_PRIORITY = 2000;\n\n/**\n * Compile a template and return a reusable composite link\n * function, which recursively contains more link functions\n * inside. This top level compile function would normally\n * be called on instance root nodes, but can also be used\n * for partial compilation if the partial argument is true.\n *\n * The returned composite link function, when called, will\n * return an unlink function that tearsdown all directives\n * created during the linking phase.\n *\n * @param {Element|DocumentFragment} el\n * @param {Object} options\n * @param {Boolean} partial\n * @return {Function}\n */\n\nfunction compile(el, options, partial) {\n  // link function for the node itself.\n  var nodeLinkFn = partial || !options._asComponent ? compileNode(el, options) : null;\n  // link function for the childNodes\n  var childLinkFn = !(nodeLinkFn && nodeLinkFn.terminal) && !isScript(el) && el.hasChildNodes() ? compileNodeList(el.childNodes, options) : null;\n\n  /**\n   * A composite linker function to be called on a already\n   * compiled piece of DOM, which instantiates all directive\n   * instances.\n   *\n   * @param {Vue} vm\n   * @param {Element|DocumentFragment} el\n   * @param {Vue} [host] - host vm of transcluded content\n   * @param {Object} [scope] - v-for scope\n   * @param {Fragment} [frag] - link context fragment\n   * @return {Function|undefined}\n   */\n\n  return function compositeLinkFn(vm, el, host, scope, frag) {\n    // cache childNodes before linking parent, fix #657\n    var childNodes = toArray(el.childNodes);\n    // link\n    var dirs = linkAndCapture(function compositeLinkCapturer() {\n      if (nodeLinkFn) nodeLinkFn(vm, el, host, scope, frag);\n      if (childLinkFn) childLinkFn(vm, childNodes, host, scope, frag);\n    }, vm);\n    return makeUnlinkFn(vm, dirs);\n  };\n}\n\n/**\n * Apply a linker to a vm/element pair and capture the\n * directives created during the process.\n *\n * @param {Function} linker\n * @param {Vue} vm\n */\n\nfunction linkAndCapture(linker, vm) {\n  /* istanbul ignore if */\n  if ('production' === 'production') {\n    // reset directives before every capture in production\n    // mode, so that when unlinking we don't need to splice\n    // them out (which turns out to be a perf hit).\n    // they are kept in development mode because they are\n    // useful for Vue's own tests.\n    vm._directives = [];\n  }\n  var originalDirCount = vm._directives.length;\n  linker();\n  var dirs = vm._directives.slice(originalDirCount);\n  sortDirectives(dirs);\n  for (var i = 0, l = dirs.length; i < l; i++) {\n    dirs[i]._bind();\n  }\n  return dirs;\n}\n\n/**\n * sort directives by priority (stable sort)\n *\n * @param {Array} dirs\n */\nfunction sortDirectives(dirs) {\n  if (dirs.length === 0) return;\n\n  var groupedMap = {};\n  var i, j, k, l;\n  var index = 0;\n  var priorities = [];\n  for (i = 0, j = dirs.length; i < j; i++) {\n    var dir = dirs[i];\n    var priority = dir.descriptor.def.priority || DEFAULT_PRIORITY;\n    var array = groupedMap[priority];\n    if (!array) {\n      array = groupedMap[priority] = [];\n      priorities.push(priority);\n    }\n    array.push(dir);\n  }\n\n  priorities.sort(function (a, b) {\n    return a > b ? -1 : a === b ? 0 : 1;\n  });\n  for (i = 0, j = priorities.length; i < j; i++) {\n    var group = groupedMap[priorities[i]];\n    for (k = 0, l = group.length; k < l; k++) {\n      dirs[index++] = group[k];\n    }\n  }\n}\n\n/**\n * Linker functions return an unlink function that\n * tearsdown all directives instances generated during\n * the process.\n *\n * We create unlink functions with only the necessary\n * information to avoid retaining additional closures.\n *\n * @param {Vue} vm\n * @param {Array} dirs\n * @param {Vue} [context]\n * @param {Array} [contextDirs]\n * @return {Function}\n */\n\nfunction makeUnlinkFn(vm, dirs, context, contextDirs) {\n  function unlink(destroying) {\n    teardownDirs(vm, dirs, destroying);\n    if (context && contextDirs) {\n      teardownDirs(context, contextDirs);\n    }\n  }\n  // expose linked directives\n  unlink.dirs = dirs;\n  return unlink;\n}\n\n/**\n * Teardown partial linked directives.\n *\n * @param {Vue} vm\n * @param {Array} dirs\n * @param {Boolean} destroying\n */\n\nfunction teardownDirs(vm, dirs, destroying) {\n  var i = dirs.length;\n  while (i--) {\n    dirs[i]._teardown();\n    if ('production' !== 'production' && !destroying) {}\n  }\n}\n\n/**\n * Compile link props on an instance.\n *\n * @param {Vue} vm\n * @param {Element} el\n * @param {Object} props\n * @param {Object} [scope]\n * @return {Function}\n */\n\nfunction compileAndLinkProps(vm, el, props, scope) {\n  var propsLinkFn = compileProps(el, props, vm);\n  var propDirs = linkAndCapture(function () {\n    propsLinkFn(vm, scope);\n  }, vm);\n  return makeUnlinkFn(vm, propDirs);\n}\n\n/**\n * Compile the root element of an instance.\n *\n * 1. attrs on context container (context scope)\n * 2. attrs on the component template root node, if\n *    replace:true (child scope)\n *\n * If this is a fragment instance, we only need to compile 1.\n *\n * @param {Element} el\n * @param {Object} options\n * @param {Object} contextOptions\n * @return {Function}\n */\n\nfunction compileRoot(el, options, contextOptions) {\n  var containerAttrs = options._containerAttrs;\n  var replacerAttrs = options._replacerAttrs;\n  var contextLinkFn, replacerLinkFn;\n\n  // only need to compile other attributes for\n  // non-fragment instances\n  if (el.nodeType !== 11) {\n    // for components, container and replacer need to be\n    // compiled separately and linked in different scopes.\n    if (options._asComponent) {\n      // 2. container attributes\n      if (containerAttrs && contextOptions) {\n        contextLinkFn = compileDirectives(containerAttrs, contextOptions);\n      }\n      if (replacerAttrs) {\n        // 3. replacer attributes\n        replacerLinkFn = compileDirectives(replacerAttrs, options);\n      }\n    } else {\n      // non-component, just compile as a normal element.\n      replacerLinkFn = compileDirectives(el.attributes, options);\n    }\n  } else if ('production' !== 'production' && containerAttrs) {}\n\n  options._containerAttrs = options._replacerAttrs = null;\n  return function rootLinkFn(vm, el, scope) {\n    // link context scope dirs\n    var context = vm._context;\n    var contextDirs;\n    if (context && contextLinkFn) {\n      contextDirs = linkAndCapture(function () {\n        contextLinkFn(context, el, null, scope);\n      }, context);\n    }\n\n    // link self\n    var selfDirs = linkAndCapture(function () {\n      if (replacerLinkFn) replacerLinkFn(vm, el);\n    }, vm);\n\n    // return the unlink function that tearsdown context\n    // container directives.\n    return makeUnlinkFn(vm, selfDirs, context, contextDirs);\n  };\n}\n\n/**\n * Compile a node and return a nodeLinkFn based on the\n * node type.\n *\n * @param {Node} node\n * @param {Object} options\n * @return {Function|null}\n */\n\nfunction compileNode(node, options) {\n  var type = node.nodeType;\n  if (type === 1 && !isScript(node)) {\n    return compileElement(node, options);\n  } else if (type === 3 && node.data.trim()) {\n    return compileTextNode(node, options);\n  } else {\n    return null;\n  }\n}\n\n/**\n * Compile an element and return a nodeLinkFn.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Function|null}\n */\n\nfunction compileElement(el, options) {\n  // preprocess textareas.\n  // textarea treats its text content as the initial value.\n  // just bind it as an attr directive for value.\n  if (el.tagName === 'TEXTAREA') {\n    // a textarea which has v-pre attr should skip complie.\n    if (getAttr(el, 'v-pre') !== null) {\n      return skip;\n    }\n    var tokens = parseText(el.value);\n    if (tokens) {\n      el.setAttribute(':value', tokensToExp(tokens));\n      el.value = '';\n    }\n  }\n  var linkFn;\n  var hasAttrs = el.hasAttributes();\n  var attrs = hasAttrs && toArray(el.attributes);\n  // check terminal directives (for & if)\n  if (hasAttrs) {\n    linkFn = checkTerminalDirectives(el, attrs, options);\n  }\n  // check element directives\n  if (!linkFn) {\n    linkFn = checkElementDirectives(el, options);\n  }\n  // check component\n  if (!linkFn) {\n    linkFn = checkComponent(el, options);\n  }\n  // normal directives\n  if (!linkFn && hasAttrs) {\n    linkFn = compileDirectives(attrs, options);\n  }\n  return linkFn;\n}\n\n/**\n * Compile a textNode and return a nodeLinkFn.\n *\n * @param {TextNode} node\n * @param {Object} options\n * @return {Function|null} textNodeLinkFn\n */\n\nfunction compileTextNode(node, options) {\n  // skip marked text nodes\n  if (node._skip) {\n    return removeText;\n  }\n\n  var tokens = parseText(node.wholeText);\n  if (!tokens) {\n    return null;\n  }\n\n  // mark adjacent text nodes as skipped,\n  // because we are using node.wholeText to compile\n  // all adjacent text nodes together. This fixes\n  // issues in IE where sometimes it splits up a single\n  // text node into multiple ones.\n  var next = node.nextSibling;\n  while (next && next.nodeType === 3) {\n    next._skip = true;\n    next = next.nextSibling;\n  }\n\n  var frag = document.createDocumentFragment();\n  var el, token;\n  for (var i = 0, l = tokens.length; i < l; i++) {\n    token = tokens[i];\n    el = token.tag ? processTextToken(token, options) : document.createTextNode(token.value);\n    frag.appendChild(el);\n  }\n  return makeTextNodeLinkFn(tokens, frag, options);\n}\n\n/**\n * Linker for an skipped text node.\n *\n * @param {Vue} vm\n * @param {Text} node\n */\n\nfunction removeText(vm, node) {\n  remove(node);\n}\n\n/**\n * Process a single text token.\n *\n * @param {Object} token\n * @param {Object} options\n * @return {Node}\n */\n\nfunction processTextToken(token, options) {\n  var el;\n  if (token.oneTime) {\n    el = document.createTextNode(token.value);\n  } else {\n    if (token.html) {\n      el = document.createComment('v-html');\n      setTokenType('html');\n    } else {\n      // IE will clean up empty textNodes during\n      // frag.cloneNode(true), so we have to give it\n      // something here...\n      el = document.createTextNode(' ');\n      setTokenType('text');\n    }\n  }\n  function setTokenType(type) {\n    if (token.descriptor) return;\n    var parsed = parseDirective(token.value);\n    token.descriptor = {\n      name: type,\n      def: directives[type],\n      expression: parsed.expression,\n      filters: parsed.filters\n    };\n  }\n  return el;\n}\n\n/**\n * Build a function that processes a textNode.\n *\n * @param {Array<Object>} tokens\n * @param {DocumentFragment} frag\n */\n\nfunction makeTextNodeLinkFn(tokens, frag) {\n  return function textNodeLinkFn(vm, el, host, scope) {\n    var fragClone = frag.cloneNode(true);\n    var childNodes = toArray(fragClone.childNodes);\n    var token, value, node;\n    for (var i = 0, l = tokens.length; i < l; i++) {\n      token = tokens[i];\n      value = token.value;\n      if (token.tag) {\n        node = childNodes[i];\n        if (token.oneTime) {\n          value = (scope || vm).$eval(value);\n          if (token.html) {\n            replace(node, parseTemplate(value, true));\n          } else {\n            node.data = _toString(value);\n          }\n        } else {\n          vm._bindDir(token.descriptor, node, host, scope);\n        }\n      }\n    }\n    replace(el, fragClone);\n  };\n}\n\n/**\n * Compile a node list and return a childLinkFn.\n *\n * @param {NodeList} nodeList\n * @param {Object} options\n * @return {Function|undefined}\n */\n\nfunction compileNodeList(nodeList, options) {\n  var linkFns = [];\n  var nodeLinkFn, childLinkFn, node;\n  for (var i = 0, l = nodeList.length; i < l; i++) {\n    node = nodeList[i];\n    nodeLinkFn = compileNode(node, options);\n    childLinkFn = !(nodeLinkFn && nodeLinkFn.terminal) && node.tagName !== 'SCRIPT' && node.hasChildNodes() ? compileNodeList(node.childNodes, options) : null;\n    linkFns.push(nodeLinkFn, childLinkFn);\n  }\n  return linkFns.length ? makeChildLinkFn(linkFns) : null;\n}\n\n/**\n * Make a child link function for a node's childNodes.\n *\n * @param {Array<Function>} linkFns\n * @return {Function} childLinkFn\n */\n\nfunction makeChildLinkFn(linkFns) {\n  return function childLinkFn(vm, nodes, host, scope, frag) {\n    var node, nodeLinkFn, childrenLinkFn;\n    for (var i = 0, n = 0, l = linkFns.length; i < l; n++) {\n      node = nodes[n];\n      nodeLinkFn = linkFns[i++];\n      childrenLinkFn = linkFns[i++];\n      // cache childNodes before linking parent, fix #657\n      var childNodes = toArray(node.childNodes);\n      if (nodeLinkFn) {\n        nodeLinkFn(vm, node, host, scope, frag);\n      }\n      if (childrenLinkFn) {\n        childrenLinkFn(vm, childNodes, host, scope, frag);\n      }\n    }\n  };\n}\n\n/**\n * Check for element directives (custom elements that should\n * be resovled as terminal directives).\n *\n * @param {Element} el\n * @param {Object} options\n */\n\nfunction checkElementDirectives(el, options) {\n  var tag = el.tagName.toLowerCase();\n  if (commonTagRE.test(tag)) {\n    return;\n  }\n  var def = resolveAsset(options, 'elementDirectives', tag);\n  if (def) {\n    return makeTerminalNodeLinkFn(el, tag, '', options, def);\n  }\n}\n\n/**\n * Check if an element is a component. If yes, return\n * a component link function.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Function|undefined}\n */\n\nfunction checkComponent(el, options) {\n  var component = checkComponentAttr(el, options);\n  if (component) {\n    var ref = findRef(el);\n    var descriptor = {\n      name: 'component',\n      ref: ref,\n      expression: component.id,\n      def: internalDirectives.component,\n      modifiers: {\n        literal: !component.dynamic\n      }\n    };\n    var componentLinkFn = function componentLinkFn(vm, el, host, scope, frag) {\n      if (ref) {\n        defineReactive((scope || vm).$refs, ref, null);\n      }\n      vm._bindDir(descriptor, el, host, scope, frag);\n    };\n    componentLinkFn.terminal = true;\n    return componentLinkFn;\n  }\n}\n\n/**\n * Check an element for terminal directives in fixed order.\n * If it finds one, return a terminal link function.\n *\n * @param {Element} el\n * @param {Array} attrs\n * @param {Object} options\n * @return {Function} terminalLinkFn\n */\n\nfunction checkTerminalDirectives(el, attrs, options) {\n  // skip v-pre\n  if (getAttr(el, 'v-pre') !== null) {\n    return skip;\n  }\n  // skip v-else block, but only if following v-if\n  if (el.hasAttribute('v-else')) {\n    var prev = el.previousElementSibling;\n    if (prev && prev.hasAttribute('v-if')) {\n      return skip;\n    }\n  }\n\n  var attr, name, value, modifiers, matched, dirName, rawName, arg, def, termDef;\n  for (var i = 0, j = attrs.length; i < j; i++) {\n    attr = attrs[i];\n    name = attr.name.replace(modifierRE, '');\n    if (matched = name.match(dirAttrRE)) {\n      def = resolveAsset(options, 'directives', matched[1]);\n      if (def && def.terminal) {\n        if (!termDef || (def.priority || DEFAULT_TERMINAL_PRIORITY) > termDef.priority) {\n          termDef = def;\n          rawName = attr.name;\n          modifiers = parseModifiers(attr.name);\n          value = attr.value;\n          dirName = matched[1];\n          arg = matched[2];\n        }\n      }\n    }\n  }\n\n  if (termDef) {\n    return makeTerminalNodeLinkFn(el, dirName, value, options, termDef, rawName, arg, modifiers);\n  }\n}\n\nfunction skip() {}\nskip.terminal = true;\n\n/**\n * Build a node link function for a terminal directive.\n * A terminal link function terminates the current\n * compilation recursion and handles compilation of the\n * subtree in the directive.\n *\n * @param {Element} el\n * @param {String} dirName\n * @param {String} value\n * @param {Object} options\n * @param {Object} def\n * @param {String} [rawName]\n * @param {String} [arg]\n * @param {Object} [modifiers]\n * @return {Function} terminalLinkFn\n */\n\nfunction makeTerminalNodeLinkFn(el, dirName, value, options, def, rawName, arg, modifiers) {\n  var parsed = parseDirective(value);\n  var descriptor = {\n    name: dirName,\n    arg: arg,\n    expression: parsed.expression,\n    filters: parsed.filters,\n    raw: value,\n    attr: rawName,\n    modifiers: modifiers,\n    def: def\n  };\n  // check ref for v-for, v-if and router-view\n  if (dirName === 'for' || dirName === 'router-view') {\n    descriptor.ref = findRef(el);\n  }\n  var fn = function terminalNodeLinkFn(vm, el, host, scope, frag) {\n    if (descriptor.ref) {\n      defineReactive((scope || vm).$refs, descriptor.ref, null);\n    }\n    vm._bindDir(descriptor, el, host, scope, frag);\n  };\n  fn.terminal = true;\n  return fn;\n}\n\n/**\n * Compile the directives on an element and return a linker.\n *\n * @param {Array|NamedNodeMap} attrs\n * @param {Object} options\n * @return {Function}\n */\n\nfunction compileDirectives(attrs, options) {\n  var i = attrs.length;\n  var dirs = [];\n  var attr, name, value, rawName, rawValue, dirName, arg, modifiers, dirDef, tokens, matched;\n  while (i--) {\n    attr = attrs[i];\n    name = rawName = attr.name;\n    value = rawValue = attr.value;\n    tokens = parseText(value);\n    // reset arg\n    arg = null;\n    // check modifiers\n    modifiers = parseModifiers(name);\n    name = name.replace(modifierRE, '');\n\n    // attribute interpolations\n    if (tokens) {\n      value = tokensToExp(tokens);\n      arg = name;\n      pushDir('bind', directives.bind, tokens);\n      // warn against mixing mustaches with v-bind\n      if ('production' !== 'production') {}\n    } else\n\n      // special attribute: transition\n      if (transitionRE.test(name)) {\n        modifiers.literal = !bindRE.test(name);\n        pushDir('transition', internalDirectives.transition);\n      } else\n\n        // event handlers\n        if (onRE.test(name)) {\n          arg = name.replace(onRE, '');\n          pushDir('on', directives.on);\n        } else\n\n          // attribute bindings\n          if (bindRE.test(name)) {\n            dirName = name.replace(bindRE, '');\n            if (dirName === 'style' || dirName === 'class') {\n              pushDir(dirName, internalDirectives[dirName]);\n            } else {\n              arg = dirName;\n              pushDir('bind', directives.bind);\n            }\n          } else\n\n            // normal directives\n            if (matched = name.match(dirAttrRE)) {\n              dirName = matched[1];\n              arg = matched[2];\n\n              // skip v-else (when used with v-show)\n              if (dirName === 'else') {\n                continue;\n              }\n\n              dirDef = resolveAsset(options, 'directives', dirName, true);\n              if (dirDef) {\n                pushDir(dirName, dirDef);\n              }\n            }\n  }\n\n  /**\n   * Push a directive.\n   *\n   * @param {String} dirName\n   * @param {Object|Function} def\n   * @param {Array} [interpTokens]\n   */\n\n  function pushDir(dirName, def, interpTokens) {\n    var hasOneTimeToken = interpTokens && hasOneTime(interpTokens);\n    var parsed = !hasOneTimeToken && parseDirective(value);\n    dirs.push({\n      name: dirName,\n      attr: rawName,\n      raw: rawValue,\n      def: def,\n      arg: arg,\n      modifiers: modifiers,\n      // conversion from interpolation strings with one-time token\n      // to expression is differed until directive bind time so that we\n      // have access to the actual vm context for one-time bindings.\n      expression: parsed && parsed.expression,\n      filters: parsed && parsed.filters,\n      interp: interpTokens,\n      hasOneTime: hasOneTimeToken\n    });\n  }\n\n  if (dirs.length) {\n    return makeNodeLinkFn(dirs);\n  }\n}\n\n/**\n * Parse modifiers from directive attribute name.\n *\n * @param {String} name\n * @return {Object}\n */\n\nfunction parseModifiers(name) {\n  var res = Object.create(null);\n  var match = name.match(modifierRE);\n  if (match) {\n    var i = match.length;\n    while (i--) {\n      res[match[i].slice(1)] = true;\n    }\n  }\n  return res;\n}\n\n/**\n * Build a link function for all directives on a single node.\n *\n * @param {Array} directives\n * @return {Function} directivesLinkFn\n */\n\nfunction makeNodeLinkFn(directives) {\n  return function nodeLinkFn(vm, el, host, scope, frag) {\n    // reverse apply because it's sorted low to high\n    var i = directives.length;\n    while (i--) {\n      vm._bindDir(directives[i], el, host, scope, frag);\n    }\n  };\n}\n\n/**\n * Check if an interpolation string contains one-time tokens.\n *\n * @param {Array} tokens\n * @return {Boolean}\n */\n\nfunction hasOneTime(tokens) {\n  var i = tokens.length;\n  while (i--) {\n    if (tokens[i].oneTime) return true;\n  }\n}\n\nfunction isScript(el) {\n  return el.tagName === 'SCRIPT' && (!el.hasAttribute('type') || el.getAttribute('type') === 'text/javascript');\n}\n\nvar specialCharRE = /[^\\w\\-:\\.]/;\n\n/**\n * Process an element or a DocumentFragment based on a\n * instance option object. This allows us to transclude\n * a template node/fragment before the instance is created,\n * so the processed fragment can then be cloned and reused\n * in v-for.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Element|DocumentFragment}\n */\n\nfunction transclude(el, options) {\n  // extract container attributes to pass them down\n  // to compiler, because they need to be compiled in\n  // parent scope. we are mutating the options object here\n  // assuming the same object will be used for compile\n  // right after this.\n  if (options) {\n    options._containerAttrs = extractAttrs(el);\n  }\n  // for template tags, what we want is its content as\n  // a documentFragment (for fragment instances)\n  if (isTemplate(el)) {\n    el = parseTemplate(el);\n  }\n  if (options) {\n    if (options._asComponent && !options.template) {\n      options.template = '<slot></slot>';\n    }\n    if (options.template) {\n      options._content = extractContent(el);\n      el = transcludeTemplate(el, options);\n    }\n  }\n  if (isFragment(el)) {\n    // anchors for fragment instance\n    // passing in `persist: true` to avoid them being\n    // discarded by IE during template cloning\n    prepend(createAnchor('v-start', true), el);\n    el.appendChild(createAnchor('v-end', true));\n  }\n  return el;\n}\n\n/**\n * Process the template option.\n * If the replace option is true this will swap the $el.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Element|DocumentFragment}\n */\n\nfunction transcludeTemplate(el, options) {\n  var template = options.template;\n  var frag = parseTemplate(template, true);\n  if (frag) {\n    var replacer = frag.firstChild;\n    if (!replacer) {\n      return frag;\n    }\n    var tag = replacer.tagName && replacer.tagName.toLowerCase();\n    if (options.replace) {\n      /* istanbul ignore if */\n      if (el === document.body) {\n        'production' !== 'production' && warn('You are mounting an instance with a template to ' + '<body>. This will replace <body> entirely. You ' + 'should probably use `replace: false` here.');\n      }\n      // there are many cases where the instance must\n      // become a fragment instance: basically anything that\n      // can create more than 1 root nodes.\n      if (\n      // multi-children template\n      frag.childNodes.length > 1 ||\n      // non-element template\n      replacer.nodeType !== 1 ||\n      // single nested component\n      tag === 'component' || resolveAsset(options, 'components', tag) || hasBindAttr(replacer, 'is') ||\n      // element directive\n      resolveAsset(options, 'elementDirectives', tag) ||\n      // for block\n      replacer.hasAttribute('v-for') ||\n      // if block\n      replacer.hasAttribute('v-if')) {\n        return frag;\n      } else {\n        options._replacerAttrs = extractAttrs(replacer);\n        mergeAttrs(el, replacer);\n        return replacer;\n      }\n    } else {\n      el.appendChild(frag);\n      return el;\n    }\n  } else {\n    'production' !== 'production' && warn('Invalid template option: ' + template);\n  }\n}\n\n/**\n * Helper to extract a component container's attributes\n * into a plain object array.\n *\n * @param {Element} el\n * @return {Array}\n */\n\nfunction extractAttrs(el) {\n  if (el.nodeType === 1 && el.hasAttributes()) {\n    return toArray(el.attributes);\n  }\n}\n\n/**\n * Merge the attributes of two elements, and make sure\n * the class names are merged properly.\n *\n * @param {Element} from\n * @param {Element} to\n */\n\nfunction mergeAttrs(from, to) {\n  var attrs = from.attributes;\n  var i = attrs.length;\n  var name, value;\n  while (i--) {\n    name = attrs[i].name;\n    value = attrs[i].value;\n    if (!to.hasAttribute(name) && !specialCharRE.test(name)) {\n      to.setAttribute(name, value);\n    } else if (name === 'class' && !parseText(value) && (value = value.trim())) {\n      value.split(/\\s+/).forEach(function (cls) {\n        addClass(to, cls);\n      });\n    }\n  }\n}\n\n/**\n * Scan and determine slot content distribution.\n * We do this during transclusion instead at compile time so that\n * the distribution is decoupled from the compilation order of\n * the slots.\n *\n * @param {Element|DocumentFragment} template\n * @param {Element} content\n * @param {Vue} vm\n */\n\nfunction resolveSlots(vm, content) {\n  if (!content) {\n    return;\n  }\n  var contents = vm._slotContents = Object.create(null);\n  var el, name;\n  for (var i = 0, l = content.children.length; i < l; i++) {\n    el = content.children[i];\n    /* eslint-disable no-cond-assign */\n    if (name = el.getAttribute('slot')) {\n      (contents[name] || (contents[name] = [])).push(el);\n    }\n    /* eslint-enable no-cond-assign */\n    if ('production' !== 'production' && getBindAttr(el, 'slot')) {}\n  }\n  for (name in contents) {\n    contents[name] = extractFragment(contents[name], content);\n  }\n  if (content.hasChildNodes()) {\n    var nodes = content.childNodes;\n    if (nodes.length === 1 && nodes[0].nodeType === 3 && !nodes[0].data.trim()) {\n      return;\n    }\n    contents['default'] = extractFragment(content.childNodes, content);\n  }\n}\n\n/**\n * Extract qualified content nodes from a node list.\n *\n * @param {NodeList} nodes\n * @return {DocumentFragment}\n */\n\nfunction extractFragment(nodes, parent) {\n  var frag = document.createDocumentFragment();\n  nodes = toArray(nodes);\n  for (var i = 0, l = nodes.length; i < l; i++) {\n    var node = nodes[i];\n    if (isTemplate(node) && !node.hasAttribute('v-if') && !node.hasAttribute('v-for')) {\n      parent.removeChild(node);\n      node = parseTemplate(node, true);\n    }\n    frag.appendChild(node);\n  }\n  return frag;\n}\n\n\n\nvar compiler = Object.freeze({\n\tcompile: compile,\n\tcompileAndLinkProps: compileAndLinkProps,\n\tcompileRoot: compileRoot,\n\ttransclude: transclude,\n\tresolveSlots: resolveSlots\n});\n\nfunction stateMixin (Vue) {\n  /**\n   * Accessor for `$data` property, since setting $data\n   * requires observing the new object and updating\n   * proxied properties.\n   */\n\n  Object.defineProperty(Vue.prototype, '$data', {\n    get: function get() {\n      return this._data;\n    },\n    set: function set(newData) {\n      if (newData !== this._data) {\n        this._setData(newData);\n      }\n    }\n  });\n\n  /**\n   * Setup the scope of an instance, which contains:\n   * - observed data\n   * - computed properties\n   * - user methods\n   * - meta properties\n   */\n\n  Vue.prototype._initState = function () {\n    this._initProps();\n    this._initMeta();\n    this._initMethods();\n    this._initData();\n    this._initComputed();\n  };\n\n  /**\n   * Initialize props.\n   */\n\n  Vue.prototype._initProps = function () {\n    var options = this.$options;\n    var el = options.el;\n    var props = options.props;\n    if (props && !el) {\n      'production' !== 'production' && warn('Props will not be compiled if no `el` option is ' + 'provided at instantiation.', this);\n    }\n    // make sure to convert string selectors into element now\n    el = options.el = query(el);\n    this._propsUnlinkFn = el && el.nodeType === 1 && props\n    // props must be linked in proper scope if inside v-for\n    ? compileAndLinkProps(this, el, props, this._scope) : null;\n  };\n\n  /**\n   * Initialize the data.\n   */\n\n  Vue.prototype._initData = function () {\n    var dataFn = this.$options.data;\n    var data = this._data = dataFn ? dataFn() : {};\n    if (!isPlainObject(data)) {\n      data = {};\n      'production' !== 'production' && warn('data functions should return an object.', this);\n    }\n    var props = this._props;\n    // proxy data on instance\n    var keys = Object.keys(data);\n    var i, key;\n    i = keys.length;\n    while (i--) {\n      key = keys[i];\n      // there are two scenarios where we can proxy a data key:\n      // 1. it's not already defined as a prop\n      // 2. it's provided via a instantiation option AND there are no\n      //    template prop present\n      if (!props || !hasOwn(props, key)) {\n        this._proxy(key);\n      } else if ('production' !== 'production') {}\n    }\n    // observe data\n    observe(data, this);\n  };\n\n  /**\n   * Swap the instance's $data. Called in $data's setter.\n   *\n   * @param {Object} newData\n   */\n\n  Vue.prototype._setData = function (newData) {\n    newData = newData || {};\n    var oldData = this._data;\n    this._data = newData;\n    var keys, key, i;\n    // unproxy keys not present in new data\n    keys = Object.keys(oldData);\n    i = keys.length;\n    while (i--) {\n      key = keys[i];\n      if (!(key in newData)) {\n        this._unproxy(key);\n      }\n    }\n    // proxy keys not already proxied,\n    // and trigger change for changed values\n    keys = Object.keys(newData);\n    i = keys.length;\n    while (i--) {\n      key = keys[i];\n      if (!hasOwn(this, key)) {\n        // new property\n        this._proxy(key);\n      }\n    }\n    oldData.__ob__.removeVm(this);\n    observe(newData, this);\n    this._digest();\n  };\n\n  /**\n   * Proxy a property, so that\n   * vm.prop === vm._data.prop\n   *\n   * @param {String} key\n   */\n\n  Vue.prototype._proxy = function (key) {\n    if (!isReserved(key)) {\n      // need to store ref to self here\n      // because these getter/setters might\n      // be called by child scopes via\n      // prototype inheritance.\n      var self = this;\n      Object.defineProperty(self, key, {\n        configurable: true,\n        enumerable: true,\n        get: function proxyGetter() {\n          return self._data[key];\n        },\n        set: function proxySetter(val) {\n          self._data[key] = val;\n        }\n      });\n    }\n  };\n\n  /**\n   * Unproxy a property.\n   *\n   * @param {String} key\n   */\n\n  Vue.prototype._unproxy = function (key) {\n    if (!isReserved(key)) {\n      delete this[key];\n    }\n  };\n\n  /**\n   * Force update on every watcher in scope.\n   */\n\n  Vue.prototype._digest = function () {\n    for (var i = 0, l = this._watchers.length; i < l; i++) {\n      this._watchers[i].update(true); // shallow updates\n    }\n  };\n\n  /**\n   * Setup computed properties. They are essentially\n   * special getter/setters\n   */\n\n  function noop() {}\n  Vue.prototype._initComputed = function () {\n    var computed = this.$options.computed;\n    if (computed) {\n      for (var key in computed) {\n        var userDef = computed[key];\n        var def = {\n          enumerable: true,\n          configurable: true\n        };\n        if (typeof userDef === 'function') {\n          def.get = makeComputedGetter(userDef, this);\n          def.set = noop;\n        } else {\n          def.get = userDef.get ? userDef.cache !== false ? makeComputedGetter(userDef.get, this) : bind(userDef.get, this) : noop;\n          def.set = userDef.set ? bind(userDef.set, this) : noop;\n        }\n        Object.defineProperty(this, key, def);\n      }\n    }\n  };\n\n  function makeComputedGetter(getter, owner) {\n    var watcher = new Watcher(owner, getter, null, {\n      lazy: true\n    });\n    return function computedGetter() {\n      if (watcher.dirty) {\n        watcher.evaluate();\n      }\n      if (Dep.target) {\n        watcher.depend();\n      }\n      return watcher.value;\n    };\n  }\n\n  /**\n   * Setup instance methods. Methods must be bound to the\n   * instance since they might be passed down as a prop to\n   * child components.\n   */\n\n  Vue.prototype._initMethods = function () {\n    var methods = this.$options.methods;\n    if (methods) {\n      for (var key in methods) {\n        this[key] = bind(methods[key], this);\n      }\n    }\n  };\n\n  /**\n   * Initialize meta information like $index, $key & $value.\n   */\n\n  Vue.prototype._initMeta = function () {\n    var metas = this.$options._meta;\n    if (metas) {\n      for (var key in metas) {\n        defineReactive(this, key, metas[key]);\n      }\n    }\n  };\n}\n\nvar eventRE = /^v-on:|^@/;\n\nfunction eventsMixin (Vue) {\n  /**\n   * Setup the instance's option events & watchers.\n   * If the value is a string, we pull it from the\n   * instance's methods by name.\n   */\n\n  Vue.prototype._initEvents = function () {\n    var options = this.$options;\n    if (options._asComponent) {\n      registerComponentEvents(this, options.el);\n    }\n    registerCallbacks(this, '$on', options.events);\n    registerCallbacks(this, '$watch', options.watch);\n  };\n\n  /**\n   * Register v-on events on a child component\n   *\n   * @param {Vue} vm\n   * @param {Element} el\n   */\n\n  function registerComponentEvents(vm, el) {\n    var attrs = el.attributes;\n    var name, value, handler;\n    for (var i = 0, l = attrs.length; i < l; i++) {\n      name = attrs[i].name;\n      if (eventRE.test(name)) {\n        name = name.replace(eventRE, '');\n        // force the expression into a statement so that\n        // it always dynamically resolves the method to call (#2670)\n        // kinda ugly hack, but does the job.\n        value = attrs[i].value;\n        if (isSimplePath(value)) {\n          value += '.apply(this, $arguments)';\n        }\n        handler = (vm._scope || vm._context).$eval(value, true);\n        handler._fromParent = true;\n        vm.$on(name.replace(eventRE), handler);\n      }\n    }\n  }\n\n  /**\n   * Register callbacks for option events and watchers.\n   *\n   * @param {Vue} vm\n   * @param {String} action\n   * @param {Object} hash\n   */\n\n  function registerCallbacks(vm, action, hash) {\n    if (!hash) return;\n    var handlers, key, i, j;\n    for (key in hash) {\n      handlers = hash[key];\n      if (isArray(handlers)) {\n        for (i = 0, j = handlers.length; i < j; i++) {\n          register(vm, action, key, handlers[i]);\n        }\n      } else {\n        register(vm, action, key, handlers);\n      }\n    }\n  }\n\n  /**\n   * Helper to register an event/watch callback.\n   *\n   * @param {Vue} vm\n   * @param {String} action\n   * @param {String} key\n   * @param {Function|String|Object} handler\n   * @param {Object} [options]\n   */\n\n  function register(vm, action, key, handler, options) {\n    var type = typeof handler;\n    if (type === 'function') {\n      vm[action](key, handler, options);\n    } else if (type === 'string') {\n      var methods = vm.$options.methods;\n      var method = methods && methods[handler];\n      if (method) {\n        vm[action](key, method, options);\n      } else {\n        'production' !== 'production' && warn('Unknown method: \"' + handler + '\" when ' + 'registering callback for ' + action + ': \"' + key + '\".', vm);\n      }\n    } else if (handler && type === 'object') {\n      register(vm, action, key, handler.handler, handler);\n    }\n  }\n\n  /**\n   * Setup recursive attached/detached calls\n   */\n\n  Vue.prototype._initDOMHooks = function () {\n    this.$on('hook:attached', onAttached);\n    this.$on('hook:detached', onDetached);\n  };\n\n  /**\n   * Callback to recursively call attached hook on children\n   */\n\n  function onAttached() {\n    if (!this._isAttached) {\n      this._isAttached = true;\n      this.$children.forEach(callAttach);\n    }\n  }\n\n  /**\n   * Iterator to call attached hook\n   *\n   * @param {Vue} child\n   */\n\n  function callAttach(child) {\n    if (!child._isAttached && inDoc(child.$el)) {\n      child._callHook('attached');\n    }\n  }\n\n  /**\n   * Callback to recursively call detached hook on children\n   */\n\n  function onDetached() {\n    if (this._isAttached) {\n      this._isAttached = false;\n      this.$children.forEach(callDetach);\n    }\n  }\n\n  /**\n   * Iterator to call detached hook\n   *\n   * @param {Vue} child\n   */\n\n  function callDetach(child) {\n    if (child._isAttached && !inDoc(child.$el)) {\n      child._callHook('detached');\n    }\n  }\n\n  /**\n   * Trigger all handlers for a hook\n   *\n   * @param {String} hook\n   */\n\n  Vue.prototype._callHook = function (hook) {\n    this.$emit('pre-hook:' + hook);\n    var handlers = this.$options[hook];\n    if (handlers) {\n      for (var i = 0, j = handlers.length; i < j; i++) {\n        handlers[i].call(this);\n      }\n    }\n    this.$emit('hook:' + hook);\n  };\n}\n\nfunction noop$1() {}\n\n/**\n * A directive links a DOM element with a piece of data,\n * which is the result of evaluating an expression.\n * It registers a watcher with the expression and calls\n * the DOM update function when a change is triggered.\n *\n * @param {Object} descriptor\n *                 - {String} name\n *                 - {Object} def\n *                 - {String} expression\n *                 - {Array<Object>} [filters]\n *                 - {Object} [modifiers]\n *                 - {Boolean} literal\n *                 - {String} attr\n *                 - {String} arg\n *                 - {String} raw\n *                 - {String} [ref]\n *                 - {Array<Object>} [interp]\n *                 - {Boolean} [hasOneTime]\n * @param {Vue} vm\n * @param {Node} el\n * @param {Vue} [host] - transclusion host component\n * @param {Object} [scope] - v-for scope\n * @param {Fragment} [frag] - owner fragment\n * @constructor\n */\nfunction Directive(descriptor, vm, el, host, scope, frag) {\n  this.vm = vm;\n  this.el = el;\n  // copy descriptor properties\n  this.descriptor = descriptor;\n  this.name = descriptor.name;\n  this.expression = descriptor.expression;\n  this.arg = descriptor.arg;\n  this.modifiers = descriptor.modifiers;\n  this.filters = descriptor.filters;\n  this.literal = this.modifiers && this.modifiers.literal;\n  // private\n  this._locked = false;\n  this._bound = false;\n  this._listeners = null;\n  // link context\n  this._host = host;\n  this._scope = scope;\n  this._frag = frag;\n  // store directives on node in dev mode\n  if ('production' !== 'production' && this.el) {}\n}\n\n/**\n * Initialize the directive, mixin definition properties,\n * setup the watcher, call definition bind() and update()\n * if present.\n */\n\nDirective.prototype._bind = function () {\n  var name = this.name;\n  var descriptor = this.descriptor;\n\n  // remove attribute\n  if ((name !== 'cloak' || this.vm._isCompiled) && this.el && this.el.removeAttribute) {\n    var attr = descriptor.attr || 'v-' + name;\n    this.el.removeAttribute(attr);\n  }\n\n  // copy def properties\n  var def = descriptor.def;\n  if (typeof def === 'function') {\n    this.update = def;\n  } else {\n    extend(this, def);\n  }\n\n  // setup directive params\n  this._setupParams();\n\n  // initial bind\n  if (this.bind) {\n    this.bind();\n  }\n  this._bound = true;\n\n  if (this.literal) {\n    this.update && this.update(descriptor.raw);\n  } else if ((this.expression || this.modifiers) && (this.update || this.twoWay) && !this._checkStatement()) {\n    // wrapped updater for context\n    var dir = this;\n    if (this.update) {\n      this._update = function (val, oldVal) {\n        if (!dir._locked) {\n          dir.update(val, oldVal);\n        }\n      };\n    } else {\n      this._update = noop$1;\n    }\n    var preProcess = this._preProcess ? bind(this._preProcess, this) : null;\n    var postProcess = this._postProcess ? bind(this._postProcess, this) : null;\n    var watcher = this._watcher = new Watcher(this.vm, this.expression, this._update, // callback\n    {\n      filters: this.filters,\n      twoWay: this.twoWay,\n      deep: this.deep,\n      preProcess: preProcess,\n      postProcess: postProcess,\n      scope: this._scope\n    });\n    // v-model with inital inline value need to sync back to\n    // model instead of update to DOM on init. They would\n    // set the afterBind hook to indicate that.\n    if (this.afterBind) {\n      this.afterBind();\n    } else if (this.update) {\n      this.update(watcher.value);\n    }\n  }\n};\n\n/**\n * Setup all param attributes, e.g. track-by,\n * transition-mode, etc...\n */\n\nDirective.prototype._setupParams = function () {\n  if (!this.params) {\n    return;\n  }\n  var params = this.params;\n  // swap the params array with a fresh object.\n  this.params = Object.create(null);\n  var i = params.length;\n  var key, val, mappedKey;\n  while (i--) {\n    key = hyphenate(params[i]);\n    mappedKey = camelize(key);\n    val = getBindAttr(this.el, key);\n    if (val != null) {\n      // dynamic\n      this._setupParamWatcher(mappedKey, val);\n    } else {\n      // static\n      val = getAttr(this.el, key);\n      if (val != null) {\n        this.params[mappedKey] = val === '' ? true : val;\n      }\n    }\n  }\n};\n\n/**\n * Setup a watcher for a dynamic param.\n *\n * @param {String} key\n * @param {String} expression\n */\n\nDirective.prototype._setupParamWatcher = function (key, expression) {\n  var self = this;\n  var called = false;\n  var unwatch = (this._scope || this.vm).$watch(expression, function (val, oldVal) {\n    self.params[key] = val;\n    // since we are in immediate mode,\n    // only call the param change callbacks if this is not the first update.\n    if (called) {\n      var cb = self.paramWatchers && self.paramWatchers[key];\n      if (cb) {\n        cb.call(self, val, oldVal);\n      }\n    } else {\n      called = true;\n    }\n  }, {\n    immediate: true,\n    user: false\n  });(this._paramUnwatchFns || (this._paramUnwatchFns = [])).push(unwatch);\n};\n\n/**\n * Check if the directive is a function caller\n * and if the expression is a callable one. If both true,\n * we wrap up the expression and use it as the event\n * handler.\n *\n * e.g. on-click=\"a++\"\n *\n * @return {Boolean}\n */\n\nDirective.prototype._checkStatement = function () {\n  var expression = this.expression;\n  if (expression && this.acceptStatement && !isSimplePath(expression)) {\n    var fn = parseExpression$1(expression).get;\n    var scope = this._scope || this.vm;\n    var handler = function handler(e) {\n      scope.$event = e;\n      fn.call(scope, scope);\n      scope.$event = null;\n    };\n    if (this.filters) {\n      handler = scope._applyFilters(handler, null, this.filters);\n    }\n    this.update(handler);\n    return true;\n  }\n};\n\n/**\n * Set the corresponding value with the setter.\n * This should only be used in two-way directives\n * e.g. v-model.\n *\n * @param {*} value\n * @public\n */\n\nDirective.prototype.set = function (value) {\n  /* istanbul ignore else */\n  if (this.twoWay) {\n    this._withLock(function () {\n      this._watcher.set(value);\n    });\n  } else if ('production' !== 'production') {}\n};\n\n/**\n * Execute a function while preventing that function from\n * triggering updates on this directive instance.\n *\n * @param {Function} fn\n */\n\nDirective.prototype._withLock = function (fn) {\n  var self = this;\n  self._locked = true;\n  fn.call(self);\n  nextTick(function () {\n    self._locked = false;\n  });\n};\n\n/**\n * Convenience method that attaches a DOM event listener\n * to the directive element and autometically tears it down\n * during unbind.\n *\n * @param {String} event\n * @param {Function} handler\n * @param {Boolean} [useCapture]\n */\n\nDirective.prototype.on = function (event, handler, useCapture) {\n  on(this.el, event, handler, useCapture);(this._listeners || (this._listeners = [])).push([event, handler]);\n};\n\n/**\n * Teardown the watcher and call unbind.\n */\n\nDirective.prototype._teardown = function () {\n  if (this._bound) {\n    this._bound = false;\n    if (this.unbind) {\n      this.unbind();\n    }\n    if (this._watcher) {\n      this._watcher.teardown();\n    }\n    var listeners = this._listeners;\n    var i;\n    if (listeners) {\n      i = listeners.length;\n      while (i--) {\n        off(this.el, listeners[i][0], listeners[i][1]);\n      }\n    }\n    var unwatchFns = this._paramUnwatchFns;\n    if (unwatchFns) {\n      i = unwatchFns.length;\n      while (i--) {\n        unwatchFns[i]();\n      }\n    }\n    if ('production' !== 'production' && this.el) {}\n    this.vm = this.el = this._watcher = this._listeners = null;\n  }\n};\n\nfunction lifecycleMixin (Vue) {\n  /**\n   * Update v-ref for component.\n   *\n   * @param {Boolean} remove\n   */\n\n  Vue.prototype._updateRef = function (remove) {\n    var ref = this.$options._ref;\n    if (ref) {\n      var refs = (this._scope || this._context).$refs;\n      if (remove) {\n        if (refs[ref] === this) {\n          refs[ref] = null;\n        }\n      } else {\n        refs[ref] = this;\n      }\n    }\n  };\n\n  /**\n   * Transclude, compile and link element.\n   *\n   * If a pre-compiled linker is available, that means the\n   * passed in element will be pre-transcluded and compiled\n   * as well - all we need to do is to call the linker.\n   *\n   * Otherwise we need to call transclude/compile/link here.\n   *\n   * @param {Element} el\n   */\n\n  Vue.prototype._compile = function (el) {\n    var options = this.$options;\n\n    // transclude and init element\n    // transclude can potentially replace original\n    // so we need to keep reference; this step also injects\n    // the template and caches the original attributes\n    // on the container node and replacer node.\n    var original = el;\n    el = transclude(el, options);\n    this._initElement(el);\n\n    // handle v-pre on root node (#2026)\n    if (el.nodeType === 1 && getAttr(el, 'v-pre') !== null) {\n      return;\n    }\n\n    // root is always compiled per-instance, because\n    // container attrs and props can be different every time.\n    var contextOptions = this._context && this._context.$options;\n    var rootLinker = compileRoot(el, options, contextOptions);\n\n    // resolve slot distribution\n    resolveSlots(this, options._content);\n\n    // compile and link the rest\n    var contentLinkFn;\n    var ctor = this.constructor;\n    // component compilation can be cached\n    // as long as it's not using inline-template\n    if (options._linkerCachable) {\n      contentLinkFn = ctor.linker;\n      if (!contentLinkFn) {\n        contentLinkFn = ctor.linker = compile(el, options);\n      }\n    }\n\n    // link phase\n    // make sure to link root with prop scope!\n    var rootUnlinkFn = rootLinker(this, el, this._scope);\n    var contentUnlinkFn = contentLinkFn ? contentLinkFn(this, el) : compile(el, options)(this, el);\n\n    // register composite unlink function\n    // to be called during instance destruction\n    this._unlinkFn = function () {\n      rootUnlinkFn();\n      // passing destroying: true to avoid searching and\n      // splicing the directives\n      contentUnlinkFn(true);\n    };\n\n    // finally replace original\n    if (options.replace) {\n      replace(original, el);\n    }\n\n    this._isCompiled = true;\n    this._callHook('compiled');\n  };\n\n  /**\n   * Initialize instance element. Called in the public\n   * $mount() method.\n   *\n   * @param {Element} el\n   */\n\n  Vue.prototype._initElement = function (el) {\n    if (isFragment(el)) {\n      this._isFragment = true;\n      this.$el = this._fragmentStart = el.firstChild;\n      this._fragmentEnd = el.lastChild;\n      // set persisted text anchors to empty\n      if (this._fragmentStart.nodeType === 3) {\n        this._fragmentStart.data = this._fragmentEnd.data = '';\n      }\n      this._fragment = el;\n    } else {\n      this.$el = el;\n    }\n    this.$el.__vue__ = this;\n    this._callHook('beforeCompile');\n  };\n\n  /**\n   * Create and bind a directive to an element.\n   *\n   * @param {Object} descriptor - parsed directive descriptor\n   * @param {Node} node   - target node\n   * @param {Vue} [host] - transclusion host component\n   * @param {Object} [scope] - v-for scope\n   * @param {Fragment} [frag] - owner fragment\n   */\n\n  Vue.prototype._bindDir = function (descriptor, node, host, scope, frag) {\n    this._directives.push(new Directive(descriptor, this, node, host, scope, frag));\n  };\n\n  /**\n   * Teardown an instance, unobserves the data, unbind all the\n   * directives, turn off all the event listeners, etc.\n   *\n   * @param {Boolean} remove - whether to remove the DOM node.\n   * @param {Boolean} deferCleanup - if true, defer cleanup to\n   *                                 be called later\n   */\n\n  Vue.prototype._destroy = function (remove, deferCleanup) {\n    if (this._isBeingDestroyed) {\n      if (!deferCleanup) {\n        this._cleanup();\n      }\n      return;\n    }\n\n    var destroyReady;\n    var pendingRemoval;\n\n    var self = this;\n    // Cleanup should be called either synchronously or asynchronoysly as\n    // callback of this.$remove(), or if remove and deferCleanup are false.\n    // In any case it should be called after all other removing, unbinding and\n    // turning of is done\n    var cleanupIfPossible = function cleanupIfPossible() {\n      if (destroyReady && !pendingRemoval && !deferCleanup) {\n        self._cleanup();\n      }\n    };\n\n    // remove DOM element\n    if (remove && this.$el) {\n      pendingRemoval = true;\n      this.$remove(function () {\n        pendingRemoval = false;\n        cleanupIfPossible();\n      });\n    }\n\n    this._callHook('beforeDestroy');\n    this._isBeingDestroyed = true;\n    var i;\n    // remove self from parent. only necessary\n    // if parent is not being destroyed as well.\n    var parent = this.$parent;\n    if (parent && !parent._isBeingDestroyed) {\n      parent.$children.$remove(this);\n      // unregister ref (remove: true)\n      this._updateRef(true);\n    }\n    // destroy all children.\n    i = this.$children.length;\n    while (i--) {\n      this.$children[i].$destroy();\n    }\n    // teardown props\n    if (this._propsUnlinkFn) {\n      this._propsUnlinkFn();\n    }\n    // teardown all directives. this also tearsdown all\n    // directive-owned watchers.\n    if (this._unlinkFn) {\n      this._unlinkFn();\n    }\n    i = this._watchers.length;\n    while (i--) {\n      this._watchers[i].teardown();\n    }\n    // remove reference to self on $el\n    if (this.$el) {\n      this.$el.__vue__ = null;\n    }\n\n    destroyReady = true;\n    cleanupIfPossible();\n  };\n\n  /**\n   * Clean up to ensure garbage collection.\n   * This is called after the leave transition if there\n   * is any.\n   */\n\n  Vue.prototype._cleanup = function () {\n    if (this._isDestroyed) {\n      return;\n    }\n    // remove self from owner fragment\n    // do it in cleanup so that we can call $destroy with\n    // defer right when a fragment is about to be removed.\n    if (this._frag) {\n      this._frag.children.$remove(this);\n    }\n    // remove reference from data ob\n    // frozen object may not have observer.\n    if (this._data && this._data.__ob__) {\n      this._data.__ob__.removeVm(this);\n    }\n    // Clean up references to private properties and other\n    // instances. preserve reference to _data so that proxy\n    // accessors still work. The only potential side effect\n    // here is that mutating the instance after it's destroyed\n    // may affect the state of other components that are still\n    // observing the same object, but that seems to be a\n    // reasonable responsibility for the user rather than\n    // always throwing an error on them.\n    this.$el = this.$parent = this.$root = this.$children = this._watchers = this._context = this._scope = this._directives = null;\n    // call the last hook...\n    this._isDestroyed = true;\n    this._callHook('destroyed');\n    // turn off all instance listeners.\n    this.$off();\n  };\n}\n\nfunction miscMixin (Vue) {\n  /**\n   * Apply a list of filter (descriptors) to a value.\n   * Using plain for loops here because this will be called in\n   * the getter of any watcher with filters so it is very\n   * performance sensitive.\n   *\n   * @param {*} value\n   * @param {*} [oldValue]\n   * @param {Array} filters\n   * @param {Boolean} write\n   * @return {*}\n   */\n\n  Vue.prototype._applyFilters = function (value, oldValue, filters, write) {\n    var filter, fn, args, arg, offset, i, l, j, k;\n    for (i = 0, l = filters.length; i < l; i++) {\n      filter = filters[write ? l - i - 1 : i];\n      fn = resolveAsset(this.$options, 'filters', filter.name, true);\n      if (!fn) continue;\n      fn = write ? fn.write : fn.read || fn;\n      if (typeof fn !== 'function') continue;\n      args = write ? [value, oldValue] : [value];\n      offset = write ? 2 : 1;\n      if (filter.args) {\n        for (j = 0, k = filter.args.length; j < k; j++) {\n          arg = filter.args[j];\n          args[j + offset] = arg.dynamic ? this.$get(arg.value) : arg.value;\n        }\n      }\n      value = fn.apply(this, args);\n    }\n    return value;\n  };\n\n  /**\n   * Resolve a component, depending on whether the component\n   * is defined normally or using an async factory function.\n   * Resolves synchronously if already resolved, otherwise\n   * resolves asynchronously and caches the resolved\n   * constructor on the factory.\n   *\n   * @param {String|Function} value\n   * @param {Function} cb\n   */\n\n  Vue.prototype._resolveComponent = function (value, cb) {\n    var factory;\n    if (typeof value === 'function') {\n      factory = value;\n    } else {\n      factory = resolveAsset(this.$options, 'components', value, true);\n    }\n    /* istanbul ignore if */\n    if (!factory) {\n      return;\n    }\n    // async component factory\n    if (!factory.options) {\n      if (factory.resolved) {\n        // cached\n        cb(factory.resolved);\n      } else if (factory.requested) {\n        // pool callbacks\n        factory.pendingCallbacks.push(cb);\n      } else {\n        factory.requested = true;\n        var cbs = factory.pendingCallbacks = [cb];\n        factory.call(this, function resolve(res) {\n          if (isPlainObject(res)) {\n            res = Vue.extend(res);\n          }\n          // cache resolved\n          factory.resolved = res;\n          // invoke callbacks\n          for (var i = 0, l = cbs.length; i < l; i++) {\n            cbs[i](res);\n          }\n        }, function reject(reason) {\n          'production' !== 'production' && warn('Failed to resolve async component' + (typeof value === 'string' ? ': ' + value : '') + '. ' + (reason ? '\\nReason: ' + reason : ''));\n        });\n      }\n    } else {\n      // normal component\n      cb(factory);\n    }\n  };\n}\n\nvar filterRE$1 = /[^|]\\|[^|]/;\n\nfunction dataAPI (Vue) {\n  /**\n   * Get the value from an expression on this vm.\n   *\n   * @param {String} exp\n   * @param {Boolean} [asStatement]\n   * @return {*}\n   */\n\n  Vue.prototype.$get = function (exp, asStatement) {\n    var res = parseExpression$1(exp);\n    if (res) {\n      if (asStatement) {\n        var self = this;\n        return function statementHandler() {\n          self.$arguments = toArray(arguments);\n          var result = res.get.call(self, self);\n          self.$arguments = null;\n          return result;\n        };\n      } else {\n        try {\n          return res.get.call(this, this);\n        } catch (e) {}\n      }\n    }\n  };\n\n  /**\n   * Set the value from an expression on this vm.\n   * The expression must be a valid left-hand\n   * expression in an assignment.\n   *\n   * @param {String} exp\n   * @param {*} val\n   */\n\n  Vue.prototype.$set = function (exp, val) {\n    var res = parseExpression$1(exp, true);\n    if (res && res.set) {\n      res.set.call(this, this, val);\n    }\n  };\n\n  /**\n   * Delete a property on the VM\n   *\n   * @param {String} key\n   */\n\n  Vue.prototype.$delete = function (key) {\n    del(this._data, key);\n  };\n\n  /**\n   * Watch an expression, trigger callback when its\n   * value changes.\n   *\n   * @param {String|Function} expOrFn\n   * @param {Function} cb\n   * @param {Object} [options]\n   *                 - {Boolean} deep\n   *                 - {Boolean} immediate\n   * @return {Function} - unwatchFn\n   */\n\n  Vue.prototype.$watch = function (expOrFn, cb, options) {\n    var vm = this;\n    var parsed;\n    if (typeof expOrFn === 'string') {\n      parsed = parseDirective(expOrFn);\n      expOrFn = parsed.expression;\n    }\n    var watcher = new Watcher(vm, expOrFn, cb, {\n      deep: options && options.deep,\n      sync: options && options.sync,\n      filters: parsed && parsed.filters,\n      user: !options || options.user !== false\n    });\n    if (options && options.immediate) {\n      cb.call(vm, watcher.value);\n    }\n    return function unwatchFn() {\n      watcher.teardown();\n    };\n  };\n\n  /**\n   * Evaluate a text directive, including filters.\n   *\n   * @param {String} text\n   * @param {Boolean} [asStatement]\n   * @return {String}\n   */\n\n  Vue.prototype.$eval = function (text, asStatement) {\n    // check for filters.\n    if (filterRE$1.test(text)) {\n      var dir = parseDirective(text);\n      // the filter regex check might give false positive\n      // for pipes inside strings, so it's possible that\n      // we don't get any filters here\n      var val = this.$get(dir.expression, asStatement);\n      return dir.filters ? this._applyFilters(val, null, dir.filters) : val;\n    } else {\n      // no filter\n      return this.$get(text, asStatement);\n    }\n  };\n\n  /**\n   * Interpolate a piece of template text.\n   *\n   * @param {String} text\n   * @return {String}\n   */\n\n  Vue.prototype.$interpolate = function (text) {\n    var tokens = parseText(text);\n    var vm = this;\n    if (tokens) {\n      if (tokens.length === 1) {\n        return vm.$eval(tokens[0].value) + '';\n      } else {\n        return tokens.map(function (token) {\n          return token.tag ? vm.$eval(token.value) : token.value;\n        }).join('');\n      }\n    } else {\n      return text;\n    }\n  };\n\n  /**\n   * Log instance data as a plain JS object\n   * so that it is easier to inspect in console.\n   * This method assumes console is available.\n   *\n   * @param {String} [path]\n   */\n\n  Vue.prototype.$log = function (path) {\n    var data = path ? getPath(this._data, path) : this._data;\n    if (data) {\n      data = clean(data);\n    }\n    // include computed fields\n    if (!path) {\n      var key;\n      for (key in this.$options.computed) {\n        data[key] = clean(this[key]);\n      }\n      if (this._props) {\n        for (key in this._props) {\n          data[key] = clean(this[key]);\n        }\n      }\n    }\n    console.log(data);\n  };\n\n  /**\n   * \"clean\" a getter/setter converted object into a plain\n   * object copy.\n   *\n   * @param {Object} - obj\n   * @return {Object}\n   */\n\n  function clean(obj) {\n    return JSON.parse(JSON.stringify(obj));\n  }\n}\n\nfunction domAPI (Vue) {\n  /**\n   * Convenience on-instance nextTick. The callback is\n   * auto-bound to the instance, and this avoids component\n   * modules having to rely on the global Vue.\n   *\n   * @param {Function} fn\n   */\n\n  Vue.prototype.$nextTick = function (fn) {\n    nextTick(fn, this);\n  };\n\n  /**\n   * Append instance to target\n   *\n   * @param {Node} target\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition] - defaults to true\n   */\n\n  Vue.prototype.$appendTo = function (target, cb, withTransition) {\n    return insert(this, target, cb, withTransition, append, appendWithTransition);\n  };\n\n  /**\n   * Prepend instance to target\n   *\n   * @param {Node} target\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition] - defaults to true\n   */\n\n  Vue.prototype.$prependTo = function (target, cb, withTransition) {\n    target = query(target);\n    if (target.hasChildNodes()) {\n      this.$before(target.firstChild, cb, withTransition);\n    } else {\n      this.$appendTo(target, cb, withTransition);\n    }\n    return this;\n  };\n\n  /**\n   * Insert instance before target\n   *\n   * @param {Node} target\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition] - defaults to true\n   */\n\n  Vue.prototype.$before = function (target, cb, withTransition) {\n    return insert(this, target, cb, withTransition, beforeWithCb, beforeWithTransition);\n  };\n\n  /**\n   * Insert instance after target\n   *\n   * @param {Node} target\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition] - defaults to true\n   */\n\n  Vue.prototype.$after = function (target, cb, withTransition) {\n    target = query(target);\n    if (target.nextSibling) {\n      this.$before(target.nextSibling, cb, withTransition);\n    } else {\n      this.$appendTo(target.parentNode, cb, withTransition);\n    }\n    return this;\n  };\n\n  /**\n   * Remove instance from DOM\n   *\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition] - defaults to true\n   */\n\n  Vue.prototype.$remove = function (cb, withTransition) {\n    if (!this.$el.parentNode) {\n      return cb && cb();\n    }\n    var inDocument = this._isAttached && inDoc(this.$el);\n    // if we are not in document, no need to check\n    // for transitions\n    if (!inDocument) withTransition = false;\n    var self = this;\n    var realCb = function realCb() {\n      if (inDocument) self._callHook('detached');\n      if (cb) cb();\n    };\n    if (this._isFragment) {\n      removeNodeRange(this._fragmentStart, this._fragmentEnd, this, this._fragment, realCb);\n    } else {\n      var op = withTransition === false ? removeWithCb : removeWithTransition;\n      op(this.$el, this, realCb);\n    }\n    return this;\n  };\n\n  /**\n   * Shared DOM insertion function.\n   *\n   * @param {Vue} vm\n   * @param {Element} target\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition]\n   * @param {Function} op1 - op for non-transition insert\n   * @param {Function} op2 - op for transition insert\n   * @return vm\n   */\n\n  function insert(vm, target, cb, withTransition, op1, op2) {\n    target = query(target);\n    var targetIsDetached = !inDoc(target);\n    var op = withTransition === false || targetIsDetached ? op1 : op2;\n    var shouldCallHook = !targetIsDetached && !vm._isAttached && !inDoc(vm.$el);\n    if (vm._isFragment) {\n      mapNodeRange(vm._fragmentStart, vm._fragmentEnd, function (node) {\n        op(node, target, vm);\n      });\n      cb && cb();\n    } else {\n      op(vm.$el, target, vm, cb);\n    }\n    if (shouldCallHook) {\n      vm._callHook('attached');\n    }\n    return vm;\n  }\n\n  /**\n   * Check for selectors\n   *\n   * @param {String|Element} el\n   */\n\n  function query(el) {\n    return typeof el === 'string' ? document.querySelector(el) : el;\n  }\n\n  /**\n   * Append operation that takes a callback.\n   *\n   * @param {Node} el\n   * @param {Node} target\n   * @param {Vue} vm - unused\n   * @param {Function} [cb]\n   */\n\n  function append(el, target, vm, cb) {\n    target.appendChild(el);\n    if (cb) cb();\n  }\n\n  /**\n   * InsertBefore operation that takes a callback.\n   *\n   * @param {Node} el\n   * @param {Node} target\n   * @param {Vue} vm - unused\n   * @param {Function} [cb]\n   */\n\n  function beforeWithCb(el, target, vm, cb) {\n    before(el, target);\n    if (cb) cb();\n  }\n\n  /**\n   * Remove operation that takes a callback.\n   *\n   * @param {Node} el\n   * @param {Vue} vm - unused\n   * @param {Function} [cb]\n   */\n\n  function removeWithCb(el, vm, cb) {\n    remove(el);\n    if (cb) cb();\n  }\n}\n\nfunction eventsAPI (Vue) {\n  /**\n   * Listen on the given `event` with `fn`.\n   *\n   * @param {String} event\n   * @param {Function} fn\n   */\n\n  Vue.prototype.$on = function (event, fn) {\n    (this._events[event] || (this._events[event] = [])).push(fn);\n    modifyListenerCount(this, event, 1);\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   */\n\n  Vue.prototype.$once = function (event, fn) {\n    var self = this;\n    function on() {\n      self.$off(event, on);\n      fn.apply(this, arguments);\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   */\n\n  Vue.prototype.$off = function (event, fn) {\n    var cbs;\n    // all\n    if (!arguments.length) {\n      if (this.$parent) {\n        for (event in this._events) {\n          cbs = this._events[event];\n          if (cbs) {\n            modifyListenerCount(this, event, -cbs.length);\n          }\n        }\n      }\n      this._events = {};\n      return this;\n    }\n    // specific event\n    cbs = this._events[event];\n    if (!cbs) {\n      return this;\n    }\n    if (arguments.length === 1) {\n      modifyListenerCount(this, event, -cbs.length);\n      this._events[event] = null;\n      return this;\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        modifyListenerCount(this, event, -1);\n        cbs.splice(i, 1);\n        break;\n      }\n    }\n    return this;\n  };\n\n  /**\n   * Trigger an event on self.\n   *\n   * @param {String|Object} event\n   * @return {Boolean} shouldPropagate\n   */\n\n  Vue.prototype.$emit = function (event) {\n    var isSource = typeof event === 'string';\n    event = isSource ? event : event.name;\n    var cbs = this._events[event];\n    var shouldPropagate = isSource || !cbs;\n    if (cbs) {\n      cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n      // this is a somewhat hacky solution to the question raised\n      // in #2102: for an inline component listener like <comp @test=\"doThis\">,\n      // the propagation handling is somewhat broken. Therefore we\n      // need to treat these inline callbacks differently.\n      var hasParentCbs = isSource && cbs.some(function (cb) {\n        return cb._fromParent;\n      });\n      if (hasParentCbs) {\n        shouldPropagate = false;\n      }\n      var args = toArray(arguments, 1);\n      for (var i = 0, l = cbs.length; i < l; i++) {\n        var cb = cbs[i];\n        var res = cb.apply(this, args);\n        if (res === true && (!hasParentCbs || cb._fromParent)) {\n          shouldPropagate = true;\n        }\n      }\n    }\n    return shouldPropagate;\n  };\n\n  /**\n   * Recursively broadcast an event to all children instances.\n   *\n   * @param {String|Object} event\n   * @param {...*} additional arguments\n   */\n\n  Vue.prototype.$broadcast = function (event) {\n    var isSource = typeof event === 'string';\n    event = isSource ? event : event.name;\n    // if no child has registered for this event,\n    // then there's no need to broadcast.\n    if (!this._eventsCount[event]) return;\n    var children = this.$children;\n    var args = toArray(arguments);\n    if (isSource) {\n      // use object event to indicate non-source emit\n      // on children\n      args[0] = { name: event, source: this };\n    }\n    for (var i = 0, l = children.length; i < l; i++) {\n      var child = children[i];\n      var shouldPropagate = child.$emit.apply(child, args);\n      if (shouldPropagate) {\n        child.$broadcast.apply(child, args);\n      }\n    }\n    return this;\n  };\n\n  /**\n   * Recursively propagate an event up the parent chain.\n   *\n   * @param {String} event\n   * @param {...*} additional arguments\n   */\n\n  Vue.prototype.$dispatch = function (event) {\n    var shouldPropagate = this.$emit.apply(this, arguments);\n    if (!shouldPropagate) return;\n    var parent = this.$parent;\n    var args = toArray(arguments);\n    // use object event to indicate non-source emit\n    // on parents\n    args[0] = { name: event, source: this };\n    while (parent) {\n      shouldPropagate = parent.$emit.apply(parent, args);\n      parent = shouldPropagate ? parent.$parent : null;\n    }\n    return this;\n  };\n\n  /**\n   * Modify the listener counts on all parents.\n   * This bookkeeping allows $broadcast to return early when\n   * no child has listened to a certain event.\n   *\n   * @param {Vue} vm\n   * @param {String} event\n   * @param {Number} count\n   */\n\n  var hookRE = /^hook:/;\n  function modifyListenerCount(vm, event, count) {\n    var parent = vm.$parent;\n    // hooks do not get broadcasted so no need\n    // to do bookkeeping for them\n    if (!parent || !count || hookRE.test(event)) return;\n    while (parent) {\n      parent._eventsCount[event] = (parent._eventsCount[event] || 0) + count;\n      parent = parent.$parent;\n    }\n  }\n}\n\nfunction lifecycleAPI (Vue) {\n  /**\n   * Set instance target element and kick off the compilation\n   * process. The passed in `el` can be a selector string, an\n   * existing Element, or a DocumentFragment (for block\n   * instances).\n   *\n   * @param {Element|DocumentFragment|string} el\n   * @public\n   */\n\n  Vue.prototype.$mount = function (el) {\n    if (this._isCompiled) {\n      'production' !== 'production' && warn('$mount() should be called only once.', this);\n      return;\n    }\n    el = query(el);\n    if (!el) {\n      el = document.createElement('div');\n    }\n    this._compile(el);\n    this._initDOMHooks();\n    if (inDoc(this.$el)) {\n      this._callHook('attached');\n      ready.call(this);\n    } else {\n      this.$once('hook:attached', ready);\n    }\n    return this;\n  };\n\n  /**\n   * Mark an instance as ready.\n   */\n\n  function ready() {\n    this._isAttached = true;\n    this._isReady = true;\n    this._callHook('ready');\n  }\n\n  /**\n   * Teardown the instance, simply delegate to the internal\n   * _destroy.\n   *\n   * @param {Boolean} remove\n   * @param {Boolean} deferCleanup\n   */\n\n  Vue.prototype.$destroy = function (remove, deferCleanup) {\n    this._destroy(remove, deferCleanup);\n  };\n\n  /**\n   * Partially compile a piece of DOM and return a\n   * decompile function.\n   *\n   * @param {Element|DocumentFragment} el\n   * @param {Vue} [host]\n   * @param {Object} [scope]\n   * @param {Fragment} [frag]\n   * @return {Function}\n   */\n\n  Vue.prototype.$compile = function (el, host, scope, frag) {\n    return compile(el, this.$options, true)(this, el, host, scope, frag);\n  };\n}\n\n/**\n * The exposed Vue constructor.\n *\n * API conventions:\n * - public API methods/properties are prefixed with `$`\n * - internal methods/properties are prefixed with `_`\n * - non-prefixed properties are assumed to be proxied user\n *   data.\n *\n * @constructor\n * @param {Object} [options]\n * @public\n */\n\nfunction Vue(options) {\n  this._init(options);\n}\n\n// install internals\ninitMixin(Vue);\nstateMixin(Vue);\neventsMixin(Vue);\nlifecycleMixin(Vue);\nmiscMixin(Vue);\n\n// install instance APIs\ndataAPI(Vue);\ndomAPI(Vue);\neventsAPI(Vue);\nlifecycleAPI(Vue);\n\nvar slot = {\n\n  priority: SLOT,\n  params: ['name'],\n\n  bind: function bind() {\n    // this was resolved during component transclusion\n    var name = this.params.name || 'default';\n    var content = this.vm._slotContents && this.vm._slotContents[name];\n    if (!content || !content.hasChildNodes()) {\n      this.fallback();\n    } else {\n      this.compile(content.cloneNode(true), this.vm._context, this.vm);\n    }\n  },\n\n  compile: function compile(content, context, host) {\n    if (content && context) {\n      if (this.el.hasChildNodes() && content.childNodes.length === 1 && content.childNodes[0].nodeType === 1 && content.childNodes[0].hasAttribute('v-if')) {\n        // if the inserted slot has v-if\n        // inject fallback content as the v-else\n        var elseBlock = document.createElement('template');\n        elseBlock.setAttribute('v-else', '');\n        elseBlock.innerHTML = this.el.innerHTML;\n        // the else block should be compiled in child scope\n        elseBlock._context = this.vm;\n        content.appendChild(elseBlock);\n      }\n      var scope = host ? host._scope : this._scope;\n      this.unlink = context.$compile(content, host, scope, this._frag);\n    }\n    if (content) {\n      replace(this.el, content);\n    } else {\n      remove(this.el);\n    }\n  },\n\n  fallback: function fallback() {\n    this.compile(extractContent(this.el, true), this.vm);\n  },\n\n  unbind: function unbind() {\n    if (this.unlink) {\n      this.unlink();\n    }\n  }\n};\n\nvar partial = {\n\n  priority: PARTIAL,\n\n  params: ['name'],\n\n  // watch changes to name for dynamic partials\n  paramWatchers: {\n    name: function name(value) {\n      vIf.remove.call(this);\n      if (value) {\n        this.insert(value);\n      }\n    }\n  },\n\n  bind: function bind() {\n    this.anchor = createAnchor('v-partial');\n    replace(this.el, this.anchor);\n    this.insert(this.params.name);\n  },\n\n  insert: function insert(id) {\n    var partial = resolveAsset(this.vm.$options, 'partials', id, true);\n    if (partial) {\n      this.factory = new FragmentFactory(this.vm, partial);\n      vIf.insert.call(this);\n    }\n  },\n\n  unbind: function unbind() {\n    if (this.frag) {\n      this.frag.destroy();\n    }\n  }\n};\n\nvar elementDirectives = {\n  slot: slot,\n  partial: partial\n};\n\nvar convertArray = vFor._postProcess;\n\n/**\n * Limit filter for arrays\n *\n * @param {Number} n\n * @param {Number} offset (Decimal expected)\n */\n\nfunction limitBy(arr, n, offset) {\n  offset = offset ? parseInt(offset, 10) : 0;\n  n = toNumber(n);\n  return typeof n === 'number' ? arr.slice(offset, offset + n) : arr;\n}\n\n/**\n * Filter filter for arrays\n *\n * @param {String} search\n * @param {String} [delimiter]\n * @param {String} ...dataKeys\n */\n\nfunction filterBy(arr, search, delimiter) {\n  arr = convertArray(arr);\n  if (search == null) {\n    return arr;\n  }\n  if (typeof search === 'function') {\n    return arr.filter(search);\n  }\n  // cast to lowercase string\n  search = ('' + search).toLowerCase();\n  // allow optional `in` delimiter\n  // because why not\n  var n = delimiter === 'in' ? 3 : 2;\n  // extract and flatten keys\n  var keys = Array.prototype.concat.apply([], toArray(arguments, n));\n  var res = [];\n  var item, key, val, j;\n  for (var i = 0, l = arr.length; i < l; i++) {\n    item = arr[i];\n    val = item && item.$value || item;\n    j = keys.length;\n    if (j) {\n      while (j--) {\n        key = keys[j];\n        if (key === '$key' && contains(item.$key, search) || contains(getPath(val, key), search)) {\n          res.push(item);\n          break;\n        }\n      }\n    } else if (contains(item, search)) {\n      res.push(item);\n    }\n  }\n  return res;\n}\n\n/**\n * Order filter for arrays\n *\n * @param {String|Array<String>|Function} ...sortKeys\n * @param {Number} [order]\n */\n\nfunction orderBy(arr) {\n  var comparator = null;\n  var sortKeys = undefined;\n  arr = convertArray(arr);\n\n  // determine order (last argument)\n  var args = toArray(arguments, 1);\n  var order = args[args.length - 1];\n  if (typeof order === 'number') {\n    order = order < 0 ? -1 : 1;\n    args = args.length > 1 ? args.slice(0, -1) : args;\n  } else {\n    order = 1;\n  }\n\n  // determine sortKeys & comparator\n  var firstArg = args[0];\n  if (!firstArg) {\n    return arr;\n  } else if (typeof firstArg === 'function') {\n    // custom comparator\n    comparator = function (a, b) {\n      return firstArg(a, b) * order;\n    };\n  } else {\n    // string keys. flatten first\n    sortKeys = Array.prototype.concat.apply([], args);\n    comparator = function (a, b, i) {\n      i = i || 0;\n      return i >= sortKeys.length - 1 ? baseCompare(a, b, i) : baseCompare(a, b, i) || comparator(a, b, i + 1);\n    };\n  }\n\n  function baseCompare(a, b, sortKeyIndex) {\n    var sortKey = sortKeys[sortKeyIndex];\n    if (sortKey) {\n      if (sortKey !== '$key') {\n        if (isObject(a) && '$value' in a) a = a.$value;\n        if (isObject(b) && '$value' in b) b = b.$value;\n      }\n      a = isObject(a) ? getPath(a, sortKey) : a;\n      b = isObject(b) ? getPath(b, sortKey) : b;\n    }\n    return a === b ? 0 : a > b ? order : -order;\n  }\n\n  // sort on a copy to avoid mutating original array\n  return arr.slice().sort(comparator);\n}\n\n/**\n * String contain helper\n *\n * @param {*} val\n * @param {String} search\n */\n\nfunction contains(val, search) {\n  var i;\n  if (isPlainObject(val)) {\n    var keys = Object.keys(val);\n    i = keys.length;\n    while (i--) {\n      if (contains(val[keys[i]], search)) {\n        return true;\n      }\n    }\n  } else if (isArray(val)) {\n    i = val.length;\n    while (i--) {\n      if (contains(val[i], search)) {\n        return true;\n      }\n    }\n  } else if (val != null) {\n    return val.toString().toLowerCase().indexOf(search) > -1;\n  }\n}\n\nvar digitsRE = /(\\d{3})(?=\\d)/g;\n\n// asset collections must be a plain object.\nvar filters = {\n\n  orderBy: orderBy,\n  filterBy: filterBy,\n  limitBy: limitBy,\n\n  /**\n   * Stringify value.\n   *\n   * @param {Number} indent\n   */\n\n  json: {\n    read: function read(value, indent) {\n      return typeof value === 'string' ? value : JSON.stringify(value, null, arguments.length > 1 ? indent : 2);\n    },\n    write: function write(value) {\n      try {\n        return JSON.parse(value);\n      } catch (e) {\n        return value;\n      }\n    }\n  },\n\n  /**\n   * 'abc' => 'Abc'\n   */\n\n  capitalize: function capitalize(value) {\n    if (!value && value !== 0) return '';\n    value = value.toString();\n    return value.charAt(0).toUpperCase() + value.slice(1);\n  },\n\n  /**\n   * 'abc' => 'ABC'\n   */\n\n  uppercase: function uppercase(value) {\n    return value || value === 0 ? value.toString().toUpperCase() : '';\n  },\n\n  /**\n   * 'AbC' => 'abc'\n   */\n\n  lowercase: function lowercase(value) {\n    return value || value === 0 ? value.toString().toLowerCase() : '';\n  },\n\n  /**\n   * 12345 => $12,345.00\n   *\n   * @param {String} sign\n   * @param {Number} decimals Decimal places\n   */\n\n  currency: function currency(value, _currency, decimals) {\n    value = parseFloat(value);\n    if (!isFinite(value) || !value && value !== 0) return '';\n    _currency = _currency != null ? _currency : '$';\n    decimals = decimals != null ? decimals : 2;\n    var stringified = Math.abs(value).toFixed(decimals);\n    var _int = decimals ? stringified.slice(0, -1 - decimals) : stringified;\n    var i = _int.length % 3;\n    var head = i > 0 ? _int.slice(0, i) + (_int.length > 3 ? ',' : '') : '';\n    var _float = decimals ? stringified.slice(-1 - decimals) : '';\n    var sign = value < 0 ? '-' : '';\n    return sign + _currency + head + _int.slice(i).replace(digitsRE, '$1,') + _float;\n  },\n\n  /**\n   * 'item' => 'items'\n   *\n   * @params\n   *  an array of strings corresponding to\n   *  the single, double, triple ... forms of the word to\n   *  be pluralized. When the number to be pluralized\n   *  exceeds the length of the args, it will use the last\n   *  entry in the array.\n   *\n   *  e.g. ['single', 'double', 'triple', 'multiple']\n   */\n\n  pluralize: function pluralize(value) {\n    var args = toArray(arguments, 1);\n    var length = args.length;\n    if (length > 1) {\n      var index = value % 10 - 1;\n      return index in args ? args[index] : args[length - 1];\n    } else {\n      return args[0] + (value === 1 ? '' : 's');\n    }\n  },\n\n  /**\n   * Debounce a handler function.\n   *\n   * @param {Function} handler\n   * @param {Number} delay = 300\n   * @return {Function}\n   */\n\n  debounce: function debounce(handler, delay) {\n    if (!handler) return;\n    if (!delay) {\n      delay = 300;\n    }\n    return _debounce(handler, delay);\n  }\n};\n\nfunction installGlobalAPI (Vue) {\n  /**\n   * Vue and every constructor that extends Vue has an\n   * associated options object, which can be accessed during\n   * compilation steps as `this.constructor.options`.\n   *\n   * These can be seen as the default options of every\n   * Vue instance.\n   */\n\n  Vue.options = {\n    directives: directives,\n    elementDirectives: elementDirectives,\n    filters: filters,\n    transitions: {},\n    components: {},\n    partials: {},\n    replace: true\n  };\n\n  /**\n   * Expose useful internals\n   */\n\n  Vue.util = util;\n  Vue.config = config;\n  Vue.set = set;\n  Vue['delete'] = del;\n  Vue.nextTick = nextTick;\n\n  /**\n   * The following are exposed for advanced usage / plugins\n   */\n\n  Vue.compiler = compiler;\n  Vue.FragmentFactory = FragmentFactory;\n  Vue.internalDirectives = internalDirectives;\n  Vue.parsers = {\n    path: path,\n    text: text,\n    template: template,\n    directive: directive,\n    expression: expression\n  };\n\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\n  Vue.cid = 0;\n  var cid = 1;\n\n  /**\n   * Class inheritance\n   *\n   * @param {Object} extendOptions\n   */\n\n  Vue.extend = function (extendOptions) {\n    extendOptions = extendOptions || {};\n    var Super = this;\n    var isFirstExtend = Super.cid === 0;\n    if (isFirstExtend && extendOptions._Ctor) {\n      return extendOptions._Ctor;\n    }\n    var name = extendOptions.name || Super.options.name;\n    if ('production' !== 'production') {}\n    var Sub = createClass(name || 'VueComponent');\n    Sub.prototype = Object.create(Super.prototype);\n    Sub.prototype.constructor = Sub;\n    Sub.cid = cid++;\n    Sub.options = mergeOptions(Super.options, extendOptions);\n    Sub['super'] = Super;\n    // allow further extension\n    Sub.extend = Super.extend;\n    // create asset registers, so extended classes\n    // can have their private assets too.\n    config._assetTypes.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    // cache constructor\n    if (isFirstExtend) {\n      extendOptions._Ctor = Sub;\n    }\n    return Sub;\n  };\n\n  /**\n   * A function that returns a sub-class constructor with the\n   * given name. This gives us much nicer output when\n   * logging instances in the console.\n   *\n   * @param {String} name\n   * @return {Function}\n   */\n\n  function createClass(name) {\n    /* eslint-disable no-new-func */\n    return new Function('return function ' + classify(name) + ' (options) { this._init(options) }')();\n    /* eslint-enable no-new-func */\n  }\n\n  /**\n   * Plugin system\n   *\n   * @param {Object} plugin\n   */\n\n  Vue.use = function (plugin) {\n    /* istanbul ignore if */\n    if (plugin.installed) {\n      return;\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 {\n      plugin.apply(null, args);\n    }\n    plugin.installed = true;\n    return this;\n  };\n\n  /**\n   * Apply a global mixin by merging it into the default\n   * options.\n   */\n\n  Vue.mixin = function (mixin) {\n    Vue.options = mergeOptions(Vue.options, mixin);\n  };\n\n  /**\n   * Create asset registration methods with the following\n   * signature:\n   *\n   * @param {String} id\n   * @param {*} definition\n   */\n\n  config._assetTypes.forEach(function (type) {\n    Vue[type] = function (id, definition) {\n      if (!definition) {\n        return this.options[type + 's'][id];\n      } else {\n        /* istanbul ignore if */\n        if ('production' !== 'production') {}\n        if (type === 'component' && isPlainObject(definition)) {\n          if (!definition.name) {\n            definition.name = id;\n          }\n          definition = Vue.extend(definition);\n        }\n        this.options[type + 's'][id] = definition;\n        return definition;\n      }\n    };\n  });\n\n  // expose internal transition API\n  extend(Vue.transition, transition);\n}\n\ninstallGlobalAPI(Vue);\n\nVue.version = '1.0.28';\n\n// devtools global hook\n/* istanbul ignore next */\nsetTimeout(function () {\n  if (config.devtools) {\n    if (devtools) {\n      devtools.emit('init', Vue);\n    } else if ('production' !== 'production' && inBrowser && /Chrome\\/\\d+/.test(window.navigator.userAgent)) {}\n  }\n}, 0);\n\nreturn Vue;\n\n})));"]}