PHP Classes

File: public/js/lib/vue/dist/vue.min.js.map

Recommend this page to a friend!
  Classes of Sergey Beskorovayniy  >  Silex MVC Blog  >  public/js/lib/vue/dist/vue.min.js.map  >  Download  
File: public/js/lib/vue/dist/vue.min.js.map
Role: Auxiliary data
Content type: text/plain
Description: Auxiliary data
Class: Silex MVC Blog
MVC based blog using on the Silex micro-framework
Author: By
Last change:
Date: 5 years ago
Size: 393,645 bytes
 

Contents

Class file image Download
{"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","Cache","limit","size","head","tail","undefined","_keymap","create","pushFilter","filter","lastFilterIndex","trim","tokens","match","filterTokenRE","name","map","processFilterArg","dir","filters","push","arg","reservedArgRE","dynamic","stripped","parseDirective","s","hit","cache$1","get","inSingle","inDouble","curly","square","paren","prev","expression","put","escapeRegex","regexEscapeRE","compileRegex","open","config","delimiters","close","unsafeOpen","unsafeDelimiters","unsafeClose","tagRE","RegExp","htmlRE","cache","parseText","text","index","html","first","oneTime","lastIndex","exec","tag","tokensToExp","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","next","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","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","findVmFromFrag","__vue__","range","n","Math","floor","getTrackByKey","trackByKey","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","names","empty","identRE$1","propBindingModes","ONE_WAY","TWO_WAY","ONE_TIME","optimizedLiteral","parentPath","makePropsLinkFn","_props","inlineProps","propsData","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","sort","directiveComparator","_bind","descriptor","priority","DEFAULT_PRIORITY","contextDirs","destroying","teardownDirs","_teardown","compileAndLinkProps","propsLinkFn","propDirs","compileRoot","contextOptions","contextLinkFn","replacerLinkFn","containerAttrs","_containerAttrs","replacerAttrs","_replacerAttrs","compileDirectives","selfDirs","compileTextNode","compileElement","linkFn","checkTerminalDirectives","checkElementDirectives","checkComponent","_skip","removeText","wholeText","processTextToken","makeTextNodeLinkFn","setTokenType","directives","fragClone","nodeList","linkFns","makeChildLinkFn","childrenLinkFn","makeTerminalNodeLinkFn","component","ref","internalDirectives","modifiers","literal","componentLinkFn","skip","previousElementSibling","matched","dirName","rawName","termDef","j","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","iosVersionMatch","iosVersion","hasMutationObserverBug","indexedDB","transitionProp","animationProp","animationEndEvent","isWebkitTrans","ontransitionend","onwebkittransitionend","isWebkitAnim","onanimationend","onwebkitanimationend","nextTickHandler","pending","copies","callbacks","timerFunc","MutationObserver","setImmediate","counter","observer","textNode","characterData","Set","p","entry","shift","newer","older","returnEntry","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","[","eof",".","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.26\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\n  function 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\n  function 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\n  var 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\n  function 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\n  var literalValueRE = /^\\s?(true|false|-?[\\d\\.]+|'[^']*'|\"[^\"]*\")\\s?$/;\n\n  function 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\n  function 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\n  function _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\n  function 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\n  function 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\n  function 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-delmited string.\n   *\n   * @param {String} str\n   * @return {String}\n   */\n\n  var camelizeRE = /-(\\w)/g;\n\n  function camelize(str) {\n    return str.replace(camelizeRE, toUpper);\n  }\n\n  function 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\n  var hyphenateRE = /([a-z\\d])([A-Z])/g;\n\n  function hyphenate(str) {\n    return str.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\n  var classifyRE = /(?:^|[-_\\/])(\\w)/g;\n\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  var toString = Object.prototype.toString;\n  var OBJECT_STRING = '[object Object]';\n\n  function 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\n  var 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\n  function 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\n  function _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\n  function 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\n  function 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\n  function 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\n  var hasProto = ('__proto__' in {});\n\n  // Browser environment sniffing\n  var inBrowser = typeof window !== 'undefined' && Object.prototype.toString.call(window) !== '[object Object]';\n\n  // detect devtools\n  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n  // UA sniffing for working around browser-specific quirks\n  var UA = inBrowser && window.navigator.userAgent.toLowerCase();\n  var isIE = UA && UA.indexOf('trident') > 0;\n  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;\n  var isAndroid = UA && UA.indexOf('android') > 0;\n  var isIos = UA && /(iphone|ipad|ipod|ios)/i.test(UA);\n  var iosVersionMatch = isIos && UA.match(/os ([\\d_]+)/);\n  var iosVersion = iosVersionMatch && iosVersionMatch[1].split('_');\n\n  // detecting iOS UIWebView by indexedDB\n  var hasMutationObserverBug = iosVersion && Number(iosVersion[0]) >= 9 && Number(iosVersion[1]) >= 3 && !window.indexedDB;\n\n  var transitionProp = undefined;\n  var transitionEndEvent = undefined;\n  var animationProp = undefined;\n  var animationEndEvent = undefined;\n\n  // Transition property/event sniffing\n  if (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  /**\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\n  var nextTick = (function () {\n    var callbacks = [];\n    var pending = false;\n    var timerFunc;\n    function nextTickHandler() {\n      pending = false;\n      var copies = callbacks.slice(0);\n      callbacks = [];\n      for (var i = 0; i < copies.length; i++) {\n        copies[i]();\n      }\n    }\n\n    /* istanbul ignore if */\n    if (typeof MutationObserver !== 'undefined' && !hasMutationObserverBug) {\n      var counter = 1;\n      var observer = new MutationObserver(nextTickHandler);\n      var textNode = document.createTextNode(counter);\n      observer.observe(textNode, {\n        characterData: true\n      });\n      timerFunc = function () {\n        counter = (counter + 1) % 2;\n        textNode.data = counter;\n      };\n    } else {\n      // webpack attempts to inject a shim for setImmediate\n      // if it is used as a global, so we have to work around that to\n      // avoid bundling unnecessary code.\n      var context = inBrowser ? window : typeof global !== 'undefined' ? global : {};\n      timerFunc = context.setImmediate || setTimeout;\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\n  var _Set = undefined;\n  /* istanbul ignore if */\n  if (typeof Set !== 'undefined' && Set.toString().match(/native code/)) {\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\n  function Cache(limit) {\n    this.size = 0;\n    this.limit = limit;\n    this.head = this.tail = undefined;\n    this._keymap = Object.create(null);\n  }\n\n  var 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\n  p.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\n  p.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\n  p.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\n  var cache$1 = new Cache(1000);\n  var filterTokenRE = /[^\\s'\"]+|'[^']*'|\"[^\"]*\"/g;\n  var reservedArgRE = /^in$|^-?\\d+/;\n\n  /**\n   * Parser state\n   */\n\n  var str;\n  var dir;\n  var c;\n  var prev;\n  var i;\n  var l;\n  var lastFilterIndex;\n  var inSingle;\n  var inDouble;\n  var curly;\n  var square;\n  var paren;\n  /**\n   * Push a filter to the current directive object\n   */\n\n  function pushFilter() {\n    var exp = str.slice(lastFilterIndex, i).trim();\n    var filter;\n    if (exp) {\n      filter = {};\n      var tokens = exp.match(filterTokenRE);\n      filter.name = tokens[0];\n      if (tokens.length > 1) {\n        filter.args = tokens.slice(1).map(processFilterArg);\n      }\n    }\n    if (filter) {\n      (dir.filters = dir.filters || []).push(filter);\n    }\n    lastFilterIndex = i + 1;\n  }\n\n  /**\n   * Check if an argument is dynamic and strip quotes.\n   *\n   * @param {String} arg\n   * @return {Object}\n   */\n\n  function 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\n  function 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    inSingle = inDouble = false;\n    curly = square = paren = 0;\n    lastFilterIndex = 0;\n    dir = {};\n\n    for (i = 0, l = str.length; i < l; i++) {\n      prev = c;\n      c = str.charCodeAt(i);\n      if (inSingle) {\n        // check single quote\n        if (c === 0x27 && prev !== 0x5C) inSingle = !inSingle;\n      } else if (inDouble) {\n        // check double quote\n        if (c === 0x22 && prev !== 0x5C) inDouble = !inDouble;\n      } else if (c === 0x7C && // pipe\n      str.charCodeAt(i + 1) !== 0x7C && str.charCodeAt(i - 1) !== 0x7C) {\n        if (dir.expression == null) {\n          // first filter, end of expression\n          lastFilterIndex = i + 1;\n          dir.expression = str.slice(0, i).trim();\n        } else {\n          // already has filter\n          pushFilter();\n        }\n      } else {\n        switch (c) {\n          case 0x22:\n            inDouble = true;break; // \"\n          case 0x27:\n            inSingle = true;break; // '\n          case 0x28:\n            paren++;break; // (\n          case 0x29:\n            paren--;break; // )\n          case 0x5B:\n            square++;break; // [\n          case 0x5D:\n            square--;break; // ]\n          case 0x7B:\n            curly++;break; // {\n          case 0x7D:\n            curly--;break; // }\n        }\n      }\n    }\n\n    if (dir.expression == null) {\n      dir.expression = str.slice(0, i).trim();\n    } else if (lastFilterIndex !== 0) {\n      pushFilter();\n    }\n\n    cache$1.put(s, dir);\n    return dir;\n  }\n\nvar directive = Object.freeze({\n    parseDirective: parseDirective\n  });\n\n  var regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n  var cache = undefined;\n  var tagRE = undefined;\n  var htmlRE = undefined;\n  /**\n   * Escape a string so it can be used in a RegExp\n   * constructor.\n   *\n   * @param {String} str\n   */\n\n  function escapeRegex(str) {\n    return str.replace(regexEscapeRE, '\\\\$&');\n  }\n\n  function 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\n  function 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\n  function 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\n  function 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\n  var filterRE = /[^|]\\|[^|]/;\n  function 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\n  var delimiters = ['{{', '}}'];\n  var unsafeDelimiters = ['{{{', '}}}'];\n\n  var 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\n  var 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  var refRE = /^v-ref:/;\n\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  var 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;\n  var 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\n  function 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\n  function 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\n  var strats = config.optionMergeStrategies = Object.create(null);\n\n  /**\n   * Helper that recursively merges two data objects together.\n   */\n\n  function 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\n  strats.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\n  strats.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\n  strats.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\n  function mergeAssets(parentVal, childVal) {\n    var res = Object.create(parentVal || null);\n    return childVal ? extend(res, guardArrayAssets(childVal)) : res;\n  }\n\n  config._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\n  strats.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\n  strats.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\n  var 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  var uid$1 = 0;\n\n  /**\n   * A dep is an observable that can have multiple\n   * directives subscribing to it.\n   *\n   * @constructor\n   */\n  function 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.\n  Dep.target = null;\n\n  /**\n   * Add a directive subscriber.\n   *\n   * @param {Directive} sub\n   */\n\n  Dep.prototype.addSub = function (sub) {\n    this.subs.push(sub);\n  };\n\n  /**\n   * Remove a directive subscriber.\n   *\n   * @param {Directive} sub\n   */\n\n  Dep.prototype.removeSub = function (sub) {\n    this.subs.$remove(sub);\n  };\n\n  /**\n   * Add self as a dependency to the target watcher.\n   */\n\n  Dep.prototype.depend = function () {\n    Dep.target.addDep(this);\n  };\n\n  /**\n   * Notify all subscribers of a new value.\n   */\n\n  Dep.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\n  var arrayProto = Array.prototype;\n  var 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\n  def(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\n  def(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\n  var 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\n  var shouldConvert = true;\n\n  function 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\n  function 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\n  Observer.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\n  Observer.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\n  Observer.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\n  Observer.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\n  Observer.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\n  function 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\n  function 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\n  function 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\n  function 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\n  var 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  \tiosVersionMatch: iosVersionMatch,\n  \tiosVersion: iosVersion,\n  \thasMutationObserverBug: hasMutationObserverBug,\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\n  var uid = 0;\n\n  function 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 reigster 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\n  var pathCache = new Cache(1000);\n\n  // actions\n  var APPEND = 0;\n  var PUSH = 1;\n  var INC_SUB_PATH_DEPTH = 2;\n  var PUSH_SUB_PATH = 3;\n\n  // states\n  var BEFORE_PATH = 0;\n  var IN_PATH = 1;\n  var BEFORE_IDENT = 2;\n  var IN_IDENT = 3;\n  var IN_SUB_PATH = 4;\n  var IN_SINGLE_QUOTE = 5;\n  var IN_DOUBLE_QUOTE = 6;\n  var AFTER_PATH = 7;\n  var ERROR = 8;\n\n  var pathStateMachine = [];\n\n  pathStateMachine[BEFORE_PATH] = {\n    'ws': [BEFORE_PATH],\n    'ident': [IN_IDENT, APPEND],\n    '[': [IN_SUB_PATH],\n    'eof': [AFTER_PATH]\n  };\n\n  pathStateMachine[IN_PATH] = {\n    'ws': [IN_PATH],\n    '.': [BEFORE_IDENT],\n    '[': [IN_SUB_PATH],\n    'eof': [AFTER_PATH]\n  };\n\n  pathStateMachine[BEFORE_IDENT] = {\n    'ws': [BEFORE_IDENT],\n    'ident': [IN_IDENT, APPEND]\n  };\n\n  pathStateMachine[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\n  pathStateMachine[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\n  pathStateMachine[IN_SINGLE_QUOTE] = {\n    \"'\": [IN_SUB_PATH, APPEND],\n    'eof': ERROR,\n    'else': [IN_SINGLE_QUOTE, APPEND]\n  };\n\n  pathStateMachine[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\n  function 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\n  function 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\n  function 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\n  function 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\n  function getPath(obj, path) {\n    return parseExpression(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\n  function 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(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\n  var expressionCache = new Cache(1000);\n\n  var allowedKeywords = 'Math,Date,this,true,false,null,undefined,Infinity,NaN,' + 'isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,' + 'encodeURIComponent,parseInt,parseFloat';\n  var allowedKeywordsRE = new RegExp('^(' + allowedKeywords.replace(/,/g, '\\\\b|') + '\\\\b)');\n\n  // keywords that don't make sense inside expressions\n  var 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';\n  var improperKeywordsRE = new RegExp('^(' + improperKeywords.replace(/,/g, '\\\\b|') + '\\\\b)');\n\n  var wsRE = /\\s/g;\n  var newlineRE = /\\n/g;\n  var saveRE = /[\\{,]\\s*[\\w\\$_]+\\s*:|('(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`)|new |typeof |void /g;\n  var restoreRE = /\"(\\d+)\"/g;\n  var pathTestRE = /^[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?'\\]|\\[\".*?\"\\]|\\[\\d+\\]|\\[[A-Za-z_$][\\w$]*\\])*$/;\n  var identRE = /[^\\w$\\.](?:[A-Za-z_$][\\w$]*)/g;\n  var literalValueRE$1 = /^(?:true|false|null|undefined|Infinity|NaN)$/;\n\n  function 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\n  var 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function parseExpression(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\n  function 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,\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\n  var queue = [];\n  var userQueue = [];\n  var has = {};\n  var circular = {};\n  var waiting = false;\n\n  /**\n   * Reset the batcher's state.\n   */\n\n  function 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\n  function 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\n  function 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\n  function 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\n  var 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   */\n  function 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(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\n  Watcher.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\n  Watcher.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\n  Watcher.prototype.beforeGet = function () {\n    Dep.target = this;\n  };\n\n  /**\n   * Add a dependency to this directive.\n   *\n   * @param {Dep} dep\n   */\n\n  Watcher.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\n  Watcher.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\n  Watcher.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\n  Watcher.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\n  Watcher.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\n  Watcher.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\n  Watcher.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\n  var seenObjects = new _Set();\n  function 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\n  var 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\n  var templateCache = new Cache(1000);\n  var idSelectorCache = new Cache(1000);\n\n  var 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\n  map.td = map.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];\n\n  map.option = map.optgroup = [1, '<select multiple=\"multiple\">', '</select>'];\n\n  map.thead = map.tbody = map.colgroup = map.caption = map.tfoot = [1, '<table>', '</table>'];\n\n  map.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\n  function isRealTemplate(node) {\n    return isTemplate(node) && isFragment(node.content);\n  }\n\n  var tagRE$1 = /<([\\w:-]+)/;\n  var entityRE = /&#?\\w+?;/;\n  var 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\n  function 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\n  function 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\n  var 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\n  var 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\n  function 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\n  function 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\n  var 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   */\n  function 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\n  Fragment.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\n  function 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\n  function 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\n  function 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\n  function 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\n  Fragment.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\n  Fragment.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\n  function 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\n  function detach(child) {\n    if (child._isAttached && !inDoc(child.$el)) {\n      child._callHook('detached');\n    }\n  }\n\n  var 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   */\n  function 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\n  FragmentFactory.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\n  var ON = 700;\n  var MODEL = 800;\n  var BIND = 850;\n  var TRANSITION = 1100;\n  var EL = 1500;\n  var COMPONENT = 1500;\n  var PARTIAL = 1750;\n  var IF = 2100;\n  var FOR = 2200;\n  var SLOT = 2300;\n\n  var uid$3 = 0;\n\n  var vFor = {\n\n    priority: FOR,\n    terminal: true,\n\n    params: ['track-by', 'stagger', 'enter-stagger', 'leave-stagger'],\n\n    bind: function bind() {\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 isntance\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\n  function 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   * Find a vm from a fragment.\n   *\n   * @param {Fragment} frag\n   * @return {Vue|undefined}\n   */\n\n  function 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\n  /**\n   * Create a range array from given number.\n   *\n   * @param {Number} n\n   * @return {Array}\n   */\n\n  function 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\n  function 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  var 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\n  var 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\n  var 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\n  var 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\n  var 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\n  function 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\n  function 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\n  var 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.value;\n        if (isArray(model)) {\n          var val = self.getValue();\n          if (el.checked) {\n            if (indexOf(model, val) < 0) {\n              model.push(val);\n            }\n          } else {\n            model.$remove(val);\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\n  var handlers = {\n    text: text$2,\n    radio: radio,\n    select: select,\n    checkbox: checkbox\n  };\n\n  var 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\n  var 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\n  function 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\n  function stopFilter(handler) {\n    return function stopHandler(e) {\n      e.stopPropagation();\n      return handler.call(this, e);\n    };\n  }\n\n  function preventFilter(handler) {\n    return function preventHandler(e) {\n      e.preventDefault();\n      return handler.call(this, e);\n    };\n  }\n\n  function selfFilter(handler) {\n    return function selfHandler(e) {\n      if (e.target === e.currentTarget) {\n        return handler.call(this, e);\n      }\n    };\n  }\n\n  var 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\n  var prefixes = ['-webkit-', '-moz-', '-ms-'];\n  var camelPrefixes = ['Webkit', 'Moz', 'ms'];\n  var importantRE = /!important;?$/;\n  var propCache = Object.create(null);\n\n  var testEl = null;\n\n  var 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\n  function 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\n  function 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\n  var xlinkNS = 'http://www.w3.org/1999/xlink';\n  var xlinkRE = /^xlink:/;\n\n  // check for attributes that prohibit interpolations\n  var 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\n  var attrWithPropsRE = /^(?:value|checked|selected|muted)$/;\n  // these attributes expect enumrated values of \"true\" or \"false\"\n  // but are not boolean attributes\n  var enumeratedAttrRE = /^(?:draggable|contenteditable|spellcheck)$/;\n\n  // these attributes should set a hidden property for\n  // binding v-model to object values\n  var modelProps = {\n    value: '_value',\n    'true-value': '_trueValue',\n    'false-value': '_falseValue'\n  };\n\n  var 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\n  var 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\n  var 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\n  var 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  // must export plain object\n  var 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\n  var 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\n  function 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\n  function 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\n  var 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\n  function 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\n  var propBindingModes = config._propBindingModes;\n  var empty = {};\n\n  // regexes\n  var identRE$1 = /^[$_a-zA-Z]+[\\w$]*$/;\n  var 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\n  function compileProps(el, propOptions, vm) {\n    var props = [];\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 ('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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  var bindingModes = config._propBindingModes;\n\n  var 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\n  var queue$1 = [];\n  var queued = false;\n\n  /**\n   * Push a job into the queue.\n   *\n   * @param {Function} job\n   */\n\n  function 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\n  function 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\n  var TYPE_TRANSITION = 'transition';\n  var TYPE_ANIMATION = 'animation';\n  var transDurationProp = transitionProp + 'Duration';\n  var 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\n  var raf = inBrowser && window.requestAnimationFrame;\n  var 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   */\n  function 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\n  var 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\n  p$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\n  p$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\n  p$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\n  p$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\n  p$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\n  p$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\n  p$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\n  p$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\n  p$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\n  p$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\n  p$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\n  function 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\n  var 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\n  var internalDirectives = {\n    style: style,\n    'class': vClass,\n    component: component,\n    prop: propDef,\n    transition: transition$1\n  };\n\n  // special binding prefixes\n  var bindRE = /^v-bind:|^:/;\n  var onRE = /^v-on:|^@/;\n  var dirAttrRE = /^v-([^:]+)(?:$|:(.*)$)/;\n  var modifierRE = /\\.[^\\.]+/g;\n  var transitionRE = /^(v-bind:|:)?transition$/;\n\n  // default directive priority\n  var DEFAULT_PRIORITY = 1000;\n  var 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\n  function 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\n  function 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    dirs.sort(directiveComparator);\n    for (var i = 0, l = dirs.length; i < l; i++) {\n      dirs[i]._bind();\n    }\n    return dirs;\n  }\n\n  /**\n   * Directive priority sort comparator\n   *\n   * @param {Object} a\n   * @param {Object} b\n   */\n\n  function directiveComparator(a, b) {\n    a = a.descriptor.def.priority || DEFAULT_PRIORITY;\n    b = b.descriptor.def.priority || DEFAULT_PRIORITY;\n    return a > b ? -1 : a === b ? 0 : 1;\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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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      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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function skip() {}\n  skip.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\n  function 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 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\n  function 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\n  function 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\n  function 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\n  function hasOneTime(tokens) {\n    var i = tokens.length;\n    while (i--) {\n      if (tokens[i].oneTime) return true;\n    }\n  }\n\n  function isScript(el) {\n    return el.tagName === 'SCRIPT' && (!el.hasAttribute('type') || el.getAttribute('type') === 'text/javascript');\n  }\n\n  var 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\n  function 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\n  function transcludeTemplate(el, options) {\n    var template = options.template;\n    var frag = parseTemplate(template, true);\n    if (frag) {\n      var replacer = frag.firstChild;\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\n  function 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\n  function 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\n  function 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\n  function 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\n  var compiler = Object.freeze({\n  \tcompile: compile,\n  \tcompileAndLinkProps: compileAndLinkProps,\n  \tcompileRoot: compileRoot,\n  \ttransclude: transclude,\n  \tresolveSlots: resolveSlots\n  });\n\n  function 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\n  var eventRE = /^v-on:|^@/;\n\n  function 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\n  function 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   */\n  function 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\n  Directive.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\n  Directive.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\n  Directive.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\n  Directive.prototype._checkStatement = function () {\n    var expression = this.expression;\n    if (expression && this.acceptStatement && !isSimplePath(expression)) {\n      var fn = parseExpression(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\n  Directive.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\n  Directive.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\n  Directive.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\n  Directive.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\n  function 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\n  function 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\n  var filterRE$1 = /[^|]\\|[^|]/;\n\n  function 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(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(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\n  function 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\n  function 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\n  function 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\n  function Vue(options) {\n    this._init(options);\n  }\n\n  // install internals\n  initMixin(Vue);\n  stateMixin(Vue);\n  eventsMixin(Vue);\n  lifecycleMixin(Vue);\n  miscMixin(Vue);\n\n  // install instance APIs\n  dataAPI(Vue);\n  domAPI(Vue);\n  eventsAPI(Vue);\n  lifecycleAPI(Vue);\n\n  var 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\n  var 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\n  var elementDirectives = {\n    slot: slot,\n    partial: partial\n  };\n\n  var convertArray = vFor._postProcess;\n\n  /**\n   * Limit filter for arrays\n   *\n   * @param {Number} n\n   * @param {Number} offset (Decimal expected)\n   */\n\n  function 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\n  function 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   * Filter filter for arrays\n   *\n   * @param {String|Array<String>|Function} ...sortKeys\n   * @param {Number} [order]\n   */\n\n  function 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\n  function 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\n  var digitsRE = /(\\d{3})(?=\\d)/g;\n\n  // asset collections must be a plain object.\n  var 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\n  function 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\n  installGlobalAPI(Vue);\n\n  Vue.version = '1.0.26';\n\n  // devtools global hook\n  /* istanbul ignore next */\n  setTimeout(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\n  return Vue;\n\n}));"]}
For more information send a message to info at phpclasses dot org.