{"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}));"]}
|
Download
