diff options
Diffstat (limited to 'vendor/assets/javascripts/vue.full.js')
| -rw-r--r-- | vendor/assets/javascripts/vue.full.js | 15894 |
1 files changed, 6668 insertions, 9226 deletions
diff --git a/vendor/assets/javascripts/vue.full.js b/vendor/assets/javascripts/vue.full.js index 7ae95897a01..ea15bfac416 100644 --- a/vendor/assets/javascripts/vue.full.js +++ b/vendor/assets/javascripts/vue.full.js @@ -1,10073 +1,7515 @@ /*! - * Vue.js v1.0.26 - * (c) 2016 Evan You + * Vue.js v2.0.3 + * (c) 2014-2016 Evan You * Released under the MIT License. */ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global.Vue = factory()); -}(this, function () { 'use strict'; +}(this, (function () { 'use strict'; - function set(obj, key, val) { - if (hasOwn(obj, key)) { - obj[key] = val; - return; - } - if (obj._isVue) { - set(obj._data, key, val); - return; - } - var ob = obj.__ob__; - if (!ob) { - obj[key] = val; - return; - } - ob.convert(key, val); - ob.dep.notify(); - if (ob.vms) { - var i = ob.vms.length; - while (i--) { - var vm = ob.vms[i]; - vm._proxy(key); - vm._digest(); - } - } - return val; - } +/* */ - /** - * Delete a property and trigger change if necessary. - * - * @param {Object} obj - * @param {String} key - */ +/** + * Convert a value to a string that is actually rendered. + */ +function _toString (val) { + return val == null + ? '' + : typeof val === 'object' + ? JSON.stringify(val, null, 2) + : String(val) +} + +/** + * Convert a input value to a number for persistence. + * If the conversion fails, return original string. + */ +function toNumber (val) { + var n = parseFloat(val, 10); + return (n || n === 0) ? n : val +} + +/** + * Make a map and return a function for checking if a key + * is in that map. + */ +function makeMap ( + str, + expectsLowerCase +) { + var map = Object.create(null); + var list = str.split(','); + for (var i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase + ? function (val) { return map[val.toLowerCase()]; } + : function (val) { return map[val]; } +} + +/** + * Check if a tag is a built-in tag. + */ +var isBuiltInTag = makeMap('slot,component', true); - function del(obj, key) { - if (!hasOwn(obj, key)) { - return; - } - delete obj[key]; - var ob = obj.__ob__; - if (!ob) { - if (obj._isVue) { - delete obj._data[key]; - obj._digest(); - } - return; - } - ob.dep.notify(); - if (ob.vms) { - var i = ob.vms.length; - while (i--) { - var vm = ob.vms[i]; - vm._unproxy(key); - vm._digest(); - } +/** + * Remove an item from an array + */ +function remove$1 (arr, item) { + if (arr.length) { + var index = arr.indexOf(item); + if (index > -1) { + return arr.splice(index, 1) } } +} - var hasOwnProperty = Object.prototype.hasOwnProperty; - /** - * Check whether the object has the property. - * - * @param {Object} obj - * @param {String} key - * @return {Boolean} - */ +/** + * Check whether the object has the property. + */ +var hasOwnProperty = Object.prototype.hasOwnProperty; +function hasOwn (obj, key) { + return hasOwnProperty.call(obj, key) +} + +/** + * Check if value is primitive + */ +function isPrimitive (value) { + return typeof value === 'string' || typeof value === 'number' +} - function hasOwn(obj, key) { - return hasOwnProperty.call(obj, key); +/** + * Create a cached version of a pure function. + */ +function cached (fn) { + var cache = Object.create(null); + return function cachedFn (str) { + var hit = cache[str]; + return hit || (cache[str] = fn(str)) } +} - /** - * Check if an expression is a literal value. - * - * @param {String} exp - * @return {Boolean} - */ +/** + * Camelize a hyphen-delmited string. + */ +var camelizeRE = /-(\w)/g; +var camelize = cached(function (str) { + return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; }) +}); - var literalValueRE = /^\s?(true|false|-?[\d\.]+|'[^']*'|"[^"]*")\s?$/; +/** + * Capitalize a string. + */ +var capitalize = cached(function (str) { + return str.charAt(0).toUpperCase() + str.slice(1) +}); - function isLiteral(exp) { - return literalValueRE.test(exp); +/** + * Hyphenate a camelCase string. + */ +var hyphenateRE = /([^-])([A-Z])/g; +var hyphenate = cached(function (str) { + return str + .replace(hyphenateRE, '$1-$2') + .replace(hyphenateRE, '$1-$2') + .toLowerCase() +}); + +/** + * Simple bind, faster than native + */ +function bind$1 (fn, ctx) { + function boundFn (a) { + var l = arguments.length; + return l + ? l > 1 + ? fn.apply(ctx, arguments) + : fn.call(ctx, a) + : fn.call(ctx) + } + // record original fn length + boundFn._length = fn.length; + return boundFn +} + +/** + * Convert an Array-like object to a real Array. + */ +function toArray (list, start) { + start = start || 0; + var i = list.length - start; + var ret = new Array(i); + while (i--) { + ret[i] = list[i + start]; + } + return ret +} + +/** + * Mix properties into target object. + */ +function extend (to, _from) { + for (var key in _from) { + to[key] = _from[key]; } + return to +} - /** - * Check if a string starts with $ or _ - * - * @param {String} str - * @return {Boolean} - */ +/** + * Quick object check - this is primarily used to tell + * Objects from primitive values when we know the value + * is a JSON-compliant type. + */ +function isObject (obj) { + return obj !== null && typeof obj === 'object' +} - function isReserved(str) { - var c = (str + '').charCodeAt(0); - return c === 0x24 || c === 0x5F; +/** + * Strict object type check. Only returns true + * for plain JavaScript objects. + */ +var toString = Object.prototype.toString; +var OBJECT_STRING = '[object Object]'; +function isPlainObject (obj) { + return toString.call(obj) === OBJECT_STRING +} + +/** + * Merge an Array of Objects into a single Object. + */ +function toObject (arr) { + var res = {}; + for (var i = 0; i < arr.length; i++) { + if (arr[i]) { + extend(res, arr[i]); + } } + return res +} - /** - * Guard text output, make sure undefined outputs - * empty string - * - * @param {*} value - * @return {String} - */ +/** + * Perform no operation. + */ +function noop () {} - function _toString(value) { - return value == null ? '' : value.toString(); - } +/** + * Always return false. + */ +var no = function () { return false; }; - /** - * Check and convert possible numeric strings to numbers - * before setting back to data - * - * @param {*} value - * @return {*|Number} - */ +/** + * Generate a static keys string from compiler modules. + */ +function genStaticKeys (modules) { + return modules.reduce(function (keys, m) { + return keys.concat(m.staticKeys || []) + }, []).join(',') +} + +/** + * Check if two values are loosely equal - that is, + * if they are plain objects, do they have the same shape? + */ +function looseEqual (a, b) { + /* eslint-disable eqeqeq */ + return a == b || ( + isObject(a) && isObject(b) + ? JSON.stringify(a) === JSON.stringify(b) + : false + ) + /* eslint-enable eqeqeq */ +} - function toNumber(value) { - if (typeof value !== 'string') { - return value; - } else { - var parsed = Number(value); - return isNaN(parsed) ? value : parsed; - } +function looseIndexOf (arr, val) { + for (var i = 0; i < arr.length; i++) { + if (looseEqual(arr[i], val)) { return i } } + return -1 +} - /** - * Convert string boolean literals into real booleans. - * - * @param {*} value - * @return {*|Boolean} - */ - - function toBoolean(value) { - return value === 'true' ? true : value === 'false' ? false : value; - } +/* */ +var config = { /** - * Strip quotes from a string - * - * @param {String} str - * @return {String | false} + * Option merge strategies (used in core/util/options) */ - - function stripQuotes(str) { - var a = str.charCodeAt(0); - var b = str.charCodeAt(str.length - 1); - return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str; - } + optionMergeStrategies: Object.create(null), /** - * Camelize a hyphen-delmited string. - * - * @param {String} str - * @return {String} + * Whether to suppress warnings. */ - - var camelizeRE = /-(\w)/g; - - function camelize(str) { - return str.replace(camelizeRE, toUpper); - } - - function toUpper(_, c) { - return c ? c.toUpperCase() : ''; - } + silent: false, /** - * Hyphenate a camelCase string. - * - * @param {String} str - * @return {String} + * Whether to enable devtools */ - - var hyphenateRE = /([a-z\d])([A-Z])/g; - - function hyphenate(str) { - return str.replace(hyphenateRE, '$1-$2').toLowerCase(); - } + devtools: "development" !== 'production', /** - * Converts hyphen/underscore/slash delimitered names into - * camelized classNames. - * - * e.g. my-component => MyComponent - * some_else => SomeElse - * some/comp => SomeComp - * - * @param {String} str - * @return {String} + * Error handler for watcher errors */ - - var classifyRE = /(?:^|[-_\/])(\w)/g; - - function classify(str) { - return str.replace(classifyRE, toUpper); - } + errorHandler: null, /** - * Simple bind, faster than native - * - * @param {Function} fn - * @param {Object} ctx - * @return {Function} + * Ignore certain custom elements */ - - function bind(fn, ctx) { - return function (a) { - var l = arguments.length; - return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx); - }; - } + ignoredElements: null, /** - * Convert an Array-like object to a real Array. - * - * @param {Array-like} list - * @param {Number} [start] - start index - * @return {Array} + * Custom user key aliases for v-on */ - - function toArray(list, start) { - start = start || 0; - var i = list.length - start; - var ret = new Array(i); - while (i--) { - ret[i] = list[i + start]; - } - return ret; - } + keyCodes: Object.create(null), /** - * Mix properties into target object. - * - * @param {Object} to - * @param {Object} from + * Check if a tag is reserved so that it cannot be registered as a + * component. This is platform-dependent and may be overwritten. */ - - function extend(to, from) { - var keys = Object.keys(from); - var i = keys.length; - while (i--) { - to[keys[i]] = from[keys[i]]; - } - return to; - } + isReservedTag: no, /** - * Quick object check - this is primarily used to tell - * Objects from primitive values when we know the value - * is a JSON-compliant type. - * - * @param {*} obj - * @return {Boolean} + * Check if a tag is an unknown element. + * Platform-dependent. */ - - function isObject(obj) { - return obj !== null && typeof obj === 'object'; - } + isUnknownElement: no, /** - * Strict object type check. Only returns true - * for plain JavaScript objects. - * - * @param {*} obj - * @return {Boolean} + * Get the namespace of an element */ - - var toString = Object.prototype.toString; - var OBJECT_STRING = '[object Object]'; - - function isPlainObject(obj) { - return toString.call(obj) === OBJECT_STRING; - } + getTagNamespace: noop, /** - * Array type check. - * - * @param {*} obj - * @return {Boolean} + * Check if an attribute must be bound using property, e.g. value + * Platform-dependent. */ - - var isArray = Array.isArray; + mustUseProp: no, /** - * Define a property. - * - * @param {Object} obj - * @param {String} key - * @param {*} val - * @param {Boolean} [enumerable] + * List of asset types that a component can own. */ - - function def(obj, key, val, enumerable) { - Object.defineProperty(obj, key, { - value: val, - enumerable: !!enumerable, - writable: true, - configurable: true - }); - } + _assetTypes: [ + 'component', + 'directive', + 'filter' + ], /** - * Debounce a function so it only gets called after the - * input stops arriving after the given wait period. - * - * @param {Function} func - * @param {Number} wait - * @return {Function} - the debounced function + * List of lifecycle hooks. */ - - function _debounce(func, wait) { - var timeout, args, context, timestamp, result; - var later = function later() { - var last = Date.now() - timestamp; - if (last < wait && last >= 0) { - timeout = setTimeout(later, wait - last); - } else { - timeout = null; - result = func.apply(context, args); - if (!timeout) context = args = null; - } - }; - return function () { - context = this; - args = arguments; - timestamp = Date.now(); - if (!timeout) { - timeout = setTimeout(later, wait); - } - return result; - }; - } + _lifecycleHooks: [ + 'beforeCreate', + 'created', + 'beforeMount', + 'mounted', + 'beforeUpdate', + 'updated', + 'beforeDestroy', + 'destroyed', + 'activated', + 'deactivated' + ], /** - * Manual indexOf because it's slightly faster than - * native. - * - * @param {Array} arr - * @param {*} obj + * Max circular updates allowed in a scheduler flush cycle. */ - - function indexOf(arr, obj) { - var i = arr.length; - while (i--) { - if (arr[i] === obj) return i; - } - return -1; - } + _maxUpdateCount: 100, /** - * Make a cancellable version of an async callback. - * - * @param {Function} fn - * @return {Function} + * Server rendering? */ + _isServer: "client" === 'server' +}; - function cancellable(fn) { - var cb = function cb() { - if (!cb.cancelled) { - return fn.apply(this, arguments); - } - }; - cb.cancel = function () { - cb.cancelled = true; - }; - return cb; - } +/* */ - /** - * Check if two values are loosely equal - that is, - * if they are plain objects, do they have the same shape? - * - * @param {*} a - * @param {*} b - * @return {Boolean} - */ +/** + * Check if a string starts with $ or _ + */ +function isReserved (str) { + var c = (str + '').charCodeAt(0); + return c === 0x24 || c === 0x5F +} - function looseEqual(a, b) { - /* eslint-disable eqeqeq */ - return a == b || (isObject(a) && isObject(b) ? JSON.stringify(a) === JSON.stringify(b) : false); - /* eslint-enable eqeqeq */ +/** + * Define a property. + */ +function def (obj, key, val, enumerable) { + Object.defineProperty(obj, key, { + value: val, + enumerable: !!enumerable, + writable: true, + configurable: true + }); +} + +/** + * Parse simple path. + */ +var bailRE = /[^\w\.\$]/; +function parsePath (path) { + if (bailRE.test(path)) { + return + } else { + var segments = path.split('.'); + return function (obj) { + for (var i = 0; i < segments.length; i++) { + if (!obj) { return } + obj = obj[segments[i]]; + } + return obj + } } +} - var hasProto = ('__proto__' in {}); +/* */ +/* globals MutationObserver */ - // Browser environment sniffing - var inBrowser = typeof window !== 'undefined' && Object.prototype.toString.call(window) !== '[object Object]'; +// can we use __proto__? +var hasProto = '__proto__' in {}; - // detect devtools - var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; +// Browser environment sniffing +var inBrowser = + typeof window !== 'undefined' && + Object.prototype.toString.call(window) !== '[object Object]'; - // UA sniffing for working around browser-specific quirks - var UA = inBrowser && window.navigator.userAgent.toLowerCase(); - var isIE = UA && UA.indexOf('trident') > 0; - var isIE9 = UA && UA.indexOf('msie 9.0') > 0; - var isAndroid = UA && UA.indexOf('android') > 0; - var isIos = UA && /(iphone|ipad|ipod|ios)/i.test(UA); - var iosVersionMatch = isIos && UA.match(/os ([\d_]+)/); - var iosVersion = iosVersionMatch && iosVersionMatch[1].split('_'); +var UA = inBrowser && window.navigator.userAgent.toLowerCase(); +var isIE = UA && /msie|trident/.test(UA); +var isIE9 = UA && UA.indexOf('msie 9.0') > 0; +var isEdge = UA && UA.indexOf('edge/') > 0; +var isAndroid = UA && UA.indexOf('android') > 0; +var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA); - // detecting iOS UIWebView by indexedDB - var hasMutationObserverBug = iosVersion && Number(iosVersion[0]) >= 9 && Number(iosVersion[1]) >= 3 && !window.indexedDB; +// detect devtools +var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; - var transitionProp = undefined; - var transitionEndEvent = undefined; - var animationProp = undefined; - var animationEndEvent = undefined; +/* istanbul ignore next */ +function isNative (Ctor) { + return /native code/.test(Ctor.toString()) +} - // Transition property/event sniffing - if (inBrowser && !isIE9) { - var isWebkitTrans = window.ontransitionend === undefined && window.onwebkittransitionend !== undefined; - var isWebkitAnim = window.onanimationend === undefined && window.onwebkitanimationend !== undefined; - transitionProp = isWebkitTrans ? 'WebkitTransition' : 'transition'; - transitionEndEvent = isWebkitTrans ? 'webkitTransitionEnd' : 'transitionend'; - animationProp = isWebkitAnim ? 'WebkitAnimation' : 'animation'; - animationEndEvent = isWebkitAnim ? 'webkitAnimationEnd' : 'animationend'; +/** + * Defer a task to execute it asynchronously. + */ +var nextTick = (function () { + var callbacks = []; + var pending = false; + var timerFunc; + + function nextTickHandler () { + pending = false; + var copies = callbacks.slice(0); + callbacks.length = 0; + for (var i = 0; i < copies.length; i++) { + copies[i](); + } + } + + // the nextTick behavior leverages the microtask queue, which can be accessed + // via either native Promise.then or MutationObserver. + // MutationObserver has wider support, however it is seriously bugged in + // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It + // completely stops working after triggering a few times... so, if native + // Promise is available, we will use it: + /* istanbul ignore if */ + if (typeof Promise !== 'undefined' && isNative(Promise)) { + var p = Promise.resolve(); + timerFunc = function () { + p.then(nextTickHandler); + // in problematic UIWebViews, Promise.then doesn't completely break, but + // it can get stuck in a weird state where callbacks are pushed into the + // microtask queue but the queue isn't being flushed, until the browser + // needs to do some other work, e.g. handle a timer. Therefore we can + // "force" the microtask queue to be flushed by adding an empty timer. + if (isIOS) { setTimeout(noop); } + }; + } else if (typeof MutationObserver !== 'undefined' && ( + isNative(MutationObserver) || + // PhantomJS and iOS 7.x + MutationObserver.toString() === '[object MutationObserverConstructor]' + )) { + // use MutationObserver where native Promise is not available, + // e.g. PhantomJS IE11, iOS7, Android 4.4 + var counter = 1; + var observer = new MutationObserver(nextTickHandler); + var textNode = document.createTextNode(String(counter)); + observer.observe(textNode, { + characterData: true + }); + timerFunc = function () { + counter = (counter + 1) % 2; + textNode.data = String(counter); + }; + } else { + // fallback to setTimeout + /* istanbul ignore next */ + timerFunc = function () { + setTimeout(nextTickHandler, 0); + }; } - /** - * Defer a task to execute it asynchronously. Ideally this - * should be executed as a microtask, so we leverage - * MutationObserver if it's available, and fallback to - * setTimeout(0). - * - * @param {Function} cb - * @param {Object} ctx - */ - - var nextTick = (function () { - var callbacks = []; - var pending = false; - var timerFunc; - function nextTickHandler() { - pending = false; - var copies = callbacks.slice(0); - callbacks = []; - for (var i = 0; i < copies.length; i++) { - copies[i](); - } - } - - /* istanbul ignore if */ - if (typeof MutationObserver !== 'undefined' && !hasMutationObserverBug) { - var counter = 1; - var observer = new MutationObserver(nextTickHandler); - var textNode = document.createTextNode(counter); - observer.observe(textNode, { - characterData: true - }); - timerFunc = function () { - counter = (counter + 1) % 2; - textNode.data = counter; - }; - } else { - // webpack attempts to inject a shim for setImmediate - // if it is used as a global, so we have to work around that to - // avoid bundling unnecessary code. - var context = inBrowser ? window : typeof global !== 'undefined' ? global : {}; - timerFunc = context.setImmediate || setTimeout; - } - return function (cb, ctx) { - var func = ctx ? function () { - cb.call(ctx); - } : cb; - callbacks.push(func); - if (pending) return; + return function queueNextTick (cb, ctx) { + var func = ctx + ? function () { cb.call(ctx); } + : cb; + callbacks.push(func); + if (!pending) { pending = true; - timerFunc(nextTickHandler, 0); - }; - })(); + timerFunc(); + } + } +})(); - var _Set = undefined; - /* istanbul ignore if */ - if (typeof Set !== 'undefined' && Set.toString().match(/native code/)) { - // use native Set when available. - _Set = Set; - } else { - // a non-standard Set polyfill that only works with primitive keys. - _Set = function () { +var _Set; +/* istanbul ignore if */ +if (typeof Set !== 'undefined' && isNative(Set)) { + // use native Set when available. + _Set = Set; +} else { + // a non-standard Set polyfill that only works with primitive keys. + _Set = (function () { + function Set () { this.set = Object.create(null); + } + Set.prototype.has = function has (key) { + return this.set[key] !== undefined }; - _Set.prototype.has = function (key) { - return this.set[key] !== undefined; - }; - _Set.prototype.add = function (key) { + Set.prototype.add = function add (key) { this.set[key] = 1; }; - _Set.prototype.clear = function () { + Set.prototype.clear = function clear () { this.set = Object.create(null); }; - } - - function Cache(limit) { - this.size = 0; - this.limit = limit; - this.head = this.tail = undefined; - this._keymap = Object.create(null); - } - - var p = Cache.prototype; - /** - * Put <value> into the cache associated with <key>. - * Returns the entry which was removed to make room for - * the new entry. Otherwise undefined is returned. - * (i.e. if there was enough room already). - * - * @param {String} key - * @param {*} value - * @return {Entry|undefined} - */ - - p.put = function (key, value) { - var removed; - - var entry = this.get(key, true); - if (!entry) { - if (this.size === this.limit) { - removed = this.shift(); - } - entry = { - key: key - }; - this._keymap[key] = entry; - if (this.tail) { - this.tail.newer = entry; - entry.older = this.tail; - } else { - this.head = entry; + return Set; + }()); +} + +/* not type checking this file because flow doesn't play well with Proxy */ + +var hasProxy; +var proxyHandlers; +var initProxy; + +{ + var allowedGlobals = makeMap( + 'Infinity,undefined,NaN,isFinite,isNaN,' + + 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' + + 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' + + 'require' // for Webpack/Browserify + ); + + hasProxy = + typeof Proxy !== 'undefined' && + Proxy.toString().match(/native code/); + + proxyHandlers = { + has: function has (target, key) { + var has = key in target; + var isAllowed = allowedGlobals(key) || key.charAt(0) === '_'; + if (!has && !isAllowed) { + warn( + "Property or method \"" + key + "\" is not defined on the instance but " + + "referenced during render. Make sure to declare reactive data " + + "properties in the data option.", + target + ); } - this.tail = entry; - this.size++; + return has || !isAllowed } - entry.value = value; - - return removed; }; - /** - * Purge the least recently used (oldest) entry from the - * cache. Returns the removed entry or undefined if the - * cache was empty. - */ - - p.shift = function () { - var entry = this.head; - if (entry) { - this.head = this.head.newer; - this.head.older = undefined; - entry.newer = entry.older = undefined; - this._keymap[entry.key] = undefined; - this.size--; + initProxy = function initProxy (vm) { + if (hasProxy) { + vm._renderProxy = new Proxy(vm, proxyHandlers); + } else { + vm._renderProxy = vm; } - return entry; }; +} - /** - * Get and register recent use of <key>. Returns the value - * associated with <key> or undefined if not in cache. - * - * @param {String} key - * @param {Boolean} returnEntry - * @return {Entry|*} - */ +/* */ - p.get = function (key, returnEntry) { - var entry = this._keymap[key]; - if (entry === undefined) return; - if (entry === this.tail) { - return returnEntry ? entry : entry.value; - } - // HEAD--------------TAIL - // <.older .newer> - // <--- add direction -- - // A B C <D> E - if (entry.newer) { - if (entry === this.head) { - this.head = entry.newer; - } - entry.newer.older = entry.older; // C <-- E. - } - if (entry.older) { - entry.older.newer = entry.newer; // C. --> E - } - entry.newer = undefined; // D --x - entry.older = this.tail; // D. --> E - if (this.tail) { - this.tail.newer = entry; // E. <-- D - } - this.tail = entry; - return returnEntry ? entry : entry.value; - }; - var cache$1 = new Cache(1000); - var filterTokenRE = /[^\s'"]+|'[^']*'|"[^"]*"/g; - var reservedArgRE = /^in$|^-?\d+/; +var uid$2 = 0; - /** - * Parser state - */ - - var str; - var dir; - var c; - var prev; - var i; - var l; - var lastFilterIndex; - var inSingle; - var inDouble; - var curly; - var square; - var paren; - /** - * Push a filter to the current directive object - */ +/** + * A dep is an observable that can have multiple + * directives subscribing to it. + */ +var Dep = function Dep () { + this.id = uid$2++; + this.subs = []; +}; - function pushFilter() { - var exp = str.slice(lastFilterIndex, i).trim(); - var filter; - if (exp) { - filter = {}; - var tokens = exp.match(filterTokenRE); - filter.name = tokens[0]; - if (tokens.length > 1) { - filter.args = tokens.slice(1).map(processFilterArg); - } - } - if (filter) { - (dir.filters = dir.filters || []).push(filter); - } - lastFilterIndex = i + 1; - } +Dep.prototype.addSub = function addSub (sub) { + this.subs.push(sub); +}; - /** - * Check if an argument is dynamic and strip quotes. - * - * @param {String} arg - * @return {Object} - */ +Dep.prototype.removeSub = function removeSub (sub) { + remove$1(this.subs, sub); +}; - function processFilterArg(arg) { - if (reservedArgRE.test(arg)) { - return { - value: toNumber(arg), - dynamic: false - }; - } else { - var stripped = stripQuotes(arg); - var dynamic = stripped === arg; - return { - value: dynamic ? arg : stripped, - dynamic: dynamic - }; - } +Dep.prototype.depend = function depend () { + if (Dep.target) { + Dep.target.addDep(this); } +}; - /** - * Parse a directive value and extract the expression - * and its filters into a descriptor. - * - * Example: - * - * "a + 1 | uppercase" will yield: - * { - * expression: 'a + 1', - * filters: [ - * { name: 'uppercase', args: null } - * ] - * } - * - * @param {String} s - * @return {Object} - */ +Dep.prototype.notify = function notify () { + // stablize the subscriber list first + var subs = this.subs.slice(); + for (var i = 0, l = subs.length; i < l; i++) { + subs[i].update(); + } +}; - function parseDirective(s) { - var hit = cache$1.get(s); - if (hit) { - return hit; - } - - // reset parser state - str = s; - inSingle = inDouble = false; - curly = square = paren = 0; - lastFilterIndex = 0; - dir = {}; - - for (i = 0, l = str.length; i < l; i++) { - prev = c; - c = str.charCodeAt(i); - if (inSingle) { - // check single quote - if (c === 0x27 && prev !== 0x5C) inSingle = !inSingle; - } else if (inDouble) { - // check double quote - if (c === 0x22 && prev !== 0x5C) inDouble = !inDouble; - } else if (c === 0x7C && // pipe - str.charCodeAt(i + 1) !== 0x7C && str.charCodeAt(i - 1) !== 0x7C) { - if (dir.expression == null) { - // first filter, end of expression - lastFilterIndex = i + 1; - dir.expression = str.slice(0, i).trim(); - } else { - // already has filter - pushFilter(); - } - } else { - switch (c) { - case 0x22: - inDouble = true;break; // " - case 0x27: - inSingle = true;break; // ' - case 0x28: - paren++;break; // ( - case 0x29: - paren--;break; // ) - case 0x5B: - square++;break; // [ - case 0x5D: - square--;break; // ] - case 0x7B: - curly++;break; // { - case 0x7D: - curly--;break; // } - } - } - } +// the current target watcher being evaluated. +// this is globally unique because there could be only one +// watcher being evaluated at any time. +Dep.target = null; +var targetStack = []; - if (dir.expression == null) { - dir.expression = str.slice(0, i).trim(); - } else if (lastFilterIndex !== 0) { - pushFilter(); - } +function pushTarget (_target) { + if (Dep.target) { targetStack.push(Dep.target); } + Dep.target = _target; +} - cache$1.put(s, dir); - return dir; - } +function popTarget () { + Dep.target = targetStack.pop(); +} -var directive = Object.freeze({ - parseDirective: parseDirective - }); +/* */ - var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g; - var cache = undefined; - var tagRE = undefined; - var htmlRE = undefined; - /** - * Escape a string so it can be used in a RegExp - * constructor. - * - * @param {String} str - */ - function escapeRegex(str) { - return str.replace(regexEscapeRE, '\\$&'); - } +var queue = []; +var has$1 = {}; +var circular = {}; +var waiting = false; +var flushing = false; +var index = 0; - function compileRegex() { - var open = escapeRegex(config.delimiters[0]); - var close = escapeRegex(config.delimiters[1]); - var unsafeOpen = escapeRegex(config.unsafeDelimiters[0]); - var unsafeClose = escapeRegex(config.unsafeDelimiters[1]); - tagRE = new RegExp(unsafeOpen + '((?:.|\\n)+?)' + unsafeClose + '|' + open + '((?:.|\\n)+?)' + close, 'g'); - htmlRE = new RegExp('^' + unsafeOpen + '((?:.|\\n)+?)' + unsafeClose + '$'); - // reset cache - cache = new Cache(1000); +/** + * Reset the scheduler's state. + */ +function resetSchedulerState () { + queue.length = 0; + has$1 = {}; + { + circular = {}; } + waiting = flushing = false; +} - /** - * Parse a template text string into an array of tokens. - * - * @param {String} text - * @return {Array<Object> | null} - * - {String} type - * - {String} value - * - {Boolean} [html] - * - {Boolean} [oneTime] - */ - - function parseText(text) { - if (!cache) { - compileRegex(); - } - var hit = cache.get(text); - if (hit) { - return hit; - } - if (!tagRE.test(text)) { - return null; - } - var tokens = []; - var lastIndex = tagRE.lastIndex = 0; - var match, index, html, value, first, oneTime; - /* eslint-disable no-cond-assign */ - while (match = tagRE.exec(text)) { - /* eslint-enable no-cond-assign */ - index = match.index; - // push text token - if (index > lastIndex) { - tokens.push({ - value: text.slice(lastIndex, index) - }); +/** + * Flush both queues and run the watchers. + */ +function flushSchedulerQueue () { + flushing = true; + + // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child) + // 2. A component's user watchers are run before its render watcher (because + // user watchers are created before the render watcher) + // 3. If a component is destroyed during a parent component's watcher run, + // its watchers can be skipped. + queue.sort(function (a, b) { return a.id - b.id; }); + + // do not cache length because more watchers might be pushed + // as we run existing watchers + for (index = 0; index < queue.length; index++) { + var watcher = queue[index]; + var id = watcher.id; + has$1[id] = null; + watcher.run(); + // in dev build, check and stop circular updates. + if ("development" !== 'production' && has$1[id] != null) { + circular[id] = (circular[id] || 0) + 1; + if (circular[id] > config._maxUpdateCount) { + warn( + 'You may have an infinite update loop ' + ( + watcher.user + ? ("in watcher with expression \"" + (watcher.expression) + "\"") + : "in a component render function." + ), + watcher.vm + ); + break } - // tag token - html = htmlRE.test(match[0]); - value = html ? match[1] : match[2]; - first = value.charCodeAt(0); - oneTime = first === 42; // * - value = oneTime ? value.slice(1) : value; - tokens.push({ - tag: true, - value: value.trim(), - html: html, - oneTime: oneTime - }); - lastIndex = index + match[0].length; - } - if (lastIndex < text.length) { - tokens.push({ - value: text.slice(lastIndex) - }); - } - cache.put(text, tokens); - return tokens; - } - - /** - * Format a list of tokens into an expression. - * e.g. tokens parsed from 'a {{b}} c' can be serialized - * into one single expression as '"a " + b + " c"'. - * - * @param {Array} tokens - * @param {Vue} [vm] - * @return {String} - */ - - function tokensToExp(tokens, vm) { - if (tokens.length > 1) { - return tokens.map(function (token) { - return formatToken(token, vm); - }).join('+'); - } else { - return formatToken(tokens[0], vm, true); } } - /** - * Format a single token. - * - * @param {Object} token - * @param {Vue} [vm] - * @param {Boolean} [single] - * @return {String} - */ - - function formatToken(token, vm, single) { - return token.tag ? token.oneTime && vm ? '"' + vm.$eval(token.value) + '"' : inlineFilters(token.value, single) : '"' + token.value + '"'; + // devtool hook + /* istanbul ignore if */ + if (devtools && config.devtools) { + devtools.emit('flush'); } - /** - * For an attribute with multiple interpolation tags, - * e.g. attr="some-{{thing | filter}}", in order to combine - * the whole thing into a single watchable expression, we - * have to inline those filters. This function does exactly - * that. This is a bit hacky but it avoids heavy changes - * to directive parser and watcher mechanism. - * - * @param {String} exp - * @param {Boolean} single - * @return {String} - */ + resetSchedulerState(); +} - var filterRE = /[^|]\|[^|]/; - function inlineFilters(exp, single) { - if (!filterRE.test(exp)) { - return single ? exp : '(' + exp + ')'; +/** + * Push a watcher into the watcher queue. + * Jobs with duplicate IDs will be skipped unless it's + * pushed when the queue is being flushed. + */ +function queueWatcher (watcher) { + var id = watcher.id; + if (has$1[id] == null) { + has$1[id] = true; + if (!flushing) { + queue.push(watcher); } else { - var dir = parseDirective(exp); - if (!dir.filters) { - return '(' + exp + ')'; - } else { - return 'this._applyFilters(' + dir.expression + // value - ',null,' + // oldValue (null for read) - JSON.stringify(dir.filters) + // filter descriptors - ',false)'; // write? + // if already flushing, splice the watcher based on its id + // if already past its id, it will be run next immediately. + var i = queue.length - 1; + while (i >= 0 && queue[i].id > watcher.id) { + i--; } + queue.splice(Math.max(i, index) + 1, 0, watcher); } - } - -var text = Object.freeze({ - compileRegex: compileRegex, - parseText: parseText, - tokensToExp: tokensToExp - }); - - var delimiters = ['{{', '}}']; - var unsafeDelimiters = ['{{{', '}}}']; - - var config = Object.defineProperties({ - - /** - * Whether to print debug messages. - * Also enables stack trace for warnings. - * - * @type {Boolean} - */ - - debug: false, - - /** - * Whether to suppress warnings. - * - * @type {Boolean} - */ - - silent: false, - - /** - * Whether to use async rendering. - */ - - async: true, - - /** - * Whether to warn against errors caught when evaluating - * expressions. - */ - - warnExpressionErrors: true, - - /** - * Whether to allow devtools inspection. - * Disabled by default in production builds. - */ - - devtools: 'development' !== 'production', - - /** - * Internal flag to indicate the delimiters have been - * changed. - * - * @type {Boolean} - */ - - _delimitersChanged: true, - - /** - * List of asset types that a component can own. - * - * @type {Array} - */ - - _assetTypes: ['component', 'directive', 'elementDirective', 'filter', 'transition', 'partial'], - - /** - * prop binding modes - */ - - _propBindingModes: { - ONE_WAY: 0, - TWO_WAY: 1, - ONE_TIME: 2 - }, - - /** - * Max circular updates allowed in a batcher flush cycle. - */ - - _maxUpdateCount: 100 - - }, { - delimiters: { /** - * Interpolation delimiters. Changing these would trigger - * the text parser to re-compile the regular expressions. - * - * @type {Array<String>} - */ - - get: function get() { - return delimiters; - }, - set: function set(val) { - delimiters = val; - compileRegex(); - }, - configurable: true, - enumerable: true - }, - unsafeDelimiters: { - get: function get() { - return unsafeDelimiters; - }, - set: function set(val) { - unsafeDelimiters = val; - compileRegex(); - }, - configurable: true, - enumerable: true + // queue the flush + if (!waiting) { + waiting = true; + nextTick(flushSchedulerQueue); } - }); - - var warn = undefined; - var formatComponentName = undefined; - - if ('development' !== 'production') { - (function () { - var hasConsole = typeof console !== 'undefined'; - - warn = function (msg, vm) { - if (hasConsole && !config.silent) { - console.error('[Vue warn]: ' + msg + (vm ? formatComponentName(vm) : '')); - } - }; - - formatComponentName = function (vm) { - var name = vm._isVue ? vm.$options.name : vm.name; - return name ? ' (found in component: <' + hyphenate(name) + '>)' : ''; - }; - })(); } +} - /** - * Append with transition. - * - * @param {Element} el - * @param {Element} target - * @param {Vue} vm - * @param {Function} [cb] - */ - - function appendWithTransition(el, target, vm, cb) { - applyTransition(el, 1, function () { - target.appendChild(el); - }, vm, cb); - } +/* */ - /** - * InsertBefore with transition. - * - * @param {Element} el - * @param {Element} target - * @param {Vue} vm - * @param {Function} [cb] - */ +var uid$1 = 0; - function beforeWithTransition(el, target, vm, cb) { - applyTransition(el, 1, function () { - before(el, target); - }, vm, cb); +/** + * A watcher parses an expression, collects dependencies, + * and fires callback when the expression value changes. + * This is used for both the $watch() api and directives. + */ +var Watcher = function Watcher ( + vm, + expOrFn, + cb, + options +) { + if ( options === void 0 ) options = {}; + + this.vm = vm; + vm._watchers.push(this); + // options + this.deep = !!options.deep; + this.user = !!options.user; + this.lazy = !!options.lazy; + this.sync = !!options.sync; + this.expression = expOrFn.toString(); + this.cb = cb; + this.id = ++uid$1; // uid for batching + this.active = true; + this.dirty = this.lazy; // for lazy watchers + this.deps = []; + this.newDeps = []; + this.depIds = new _Set(); + this.newDepIds = new _Set(); + // parse expression for getter + if (typeof expOrFn === 'function') { + this.getter = expOrFn; + } else { + this.getter = parsePath(expOrFn); + if (!this.getter) { + this.getter = function () {}; + "development" !== 'production' && warn( + "Failed watching path: \"" + expOrFn + "\" " + + 'Watcher only accepts simple dot-delimited paths. ' + + 'For full control, use a function instead.', + vm + ); + } + } + this.value = this.lazy + ? undefined + : this.get(); +}; + +/** + * Evaluate the getter, and re-collect dependencies. + */ +Watcher.prototype.get = function get () { + pushTarget(this); + var value = this.getter.call(this.vm, this.vm); + // "touch" every property so they are all tracked as + // dependencies for deep watching + if (this.deep) { + traverse(value); + } + popTarget(); + this.cleanupDeps(); + return value +}; + +/** + * Add a dependency to this directive. + */ +Watcher.prototype.addDep = function addDep (dep) { + var id = dep.id; + if (!this.newDepIds.has(id)) { + this.newDepIds.add(id); + this.newDeps.push(dep); + if (!this.depIds.has(id)) { + dep.addSub(this); + } } +}; - /** - * Remove with transition. - * - * @param {Element} el - * @param {Vue} vm - * @param {Function} [cb] - */ - - function removeWithTransition(el, vm, cb) { - applyTransition(el, -1, function () { - remove(el); - }, vm, cb); +/** + * Clean up for dependency collection. + */ +Watcher.prototype.cleanupDeps = function cleanupDeps () { + var this$1 = this; + + var i = this.deps.length; + while (i--) { + var dep = this$1.deps[i]; + if (!this$1.newDepIds.has(dep.id)) { + dep.removeSub(this$1); + } + } + var tmp = this.depIds; + this.depIds = this.newDepIds; + this.newDepIds = tmp; + this.newDepIds.clear(); + tmp = this.deps; + this.deps = this.newDeps; + this.newDeps = tmp; + this.newDeps.length = 0; +}; + +/** + * Subscriber interface. + * Will be called when a dependency changes. + */ +Watcher.prototype.update = function update () { + /* istanbul ignore else */ + if (this.lazy) { + this.dirty = true; + } else if (this.sync) { + this.run(); + } else { + queueWatcher(this); } +}; - /** - * Apply transitions with an operation callback. - * - * @param {Element} el - * @param {Number} direction - * 1: enter - * -1: leave - * @param {Function} op - the actual DOM operation - * @param {Vue} vm - * @param {Function} [cb] - */ - - function applyTransition(el, direction, op, vm, cb) { - var transition = el.__v_trans; - if (!transition || - // skip if there are no js hooks and CSS transition is - // not supported - !transition.hooks && !transitionEndEvent || - // skip transitions for initial compile - !vm._isCompiled || - // if the vm is being manipulated by a parent directive - // during the parent's compilation phase, skip the - // animation. - vm.$parent && !vm.$parent._isCompiled) { - op(); - if (cb) cb(); - return; - } - var action = direction > 0 ? 'enter' : 'leave'; - transition[action](op, cb); - } - -var transition = Object.freeze({ - appendWithTransition: appendWithTransition, - beforeWithTransition: beforeWithTransition, - removeWithTransition: removeWithTransition, - applyTransition: applyTransition - }); - - /** - * Query an element selector if it's not an element already. - * - * @param {String|Element} el - * @return {Element} - */ - - function query(el) { - if (typeof el === 'string') { - var selector = el; - el = document.querySelector(el); - if (!el) { - 'development' !== 'production' && warn('Cannot find element: ' + selector); +/** + * Scheduler job interface. + * Will be called by the scheduler. + */ +Watcher.prototype.run = function run () { + if (this.active) { + var value = this.get(); + if ( + value !== this.value || + // Deep watchers and watchers on Object/Arrays should fire even + // when the value is the same, because the value may + // have mutated. + isObject(value) || + this.deep + ) { + // set new value + var oldValue = this.value; + this.value = value; + if (this.user) { + try { + this.cb.call(this.vm, value, oldValue); + } catch (e) { + "development" !== 'production' && warn( + ("Error in watcher \"" + (this.expression) + "\""), + this.vm + ); + /* istanbul ignore else */ + if (config.errorHandler) { + config.errorHandler.call(null, e, this.vm); + } else { + throw e + } + } + } else { + this.cb.call(this.vm, value, oldValue); } } - return el; } +}; - /** - * Check if a node is in the document. - * Note: document.documentElement.contains should work here - * but always returns false for comment nodes in phantomjs, - * making unit tests difficult. This is fixed by doing the - * contains() check on the node's parentNode instead of - * the node itself. - * - * @param {Node} node - * @return {Boolean} - */ - - function inDoc(node) { - if (!node) return false; - var doc = node.ownerDocument.documentElement; - var parent = node.parentNode; - return doc === node || doc === parent || !!(parent && parent.nodeType === 1 && doc.contains(parent)); - } +/** + * Evaluate the value of the watcher. + * This only gets called for lazy watchers. + */ +Watcher.prototype.evaluate = function evaluate () { + this.value = this.get(); + this.dirty = false; +}; - /** - * Get and remove an attribute from a node. - * - * @param {Node} node - * @param {String} _attr - */ +/** + * Depend on all deps collected by this watcher. + */ +Watcher.prototype.depend = function depend () { + var this$1 = this; - function getAttr(node, _attr) { - var val = node.getAttribute(_attr); - if (val !== null) { - node.removeAttribute(_attr); - } - return val; + var i = this.deps.length; + while (i--) { + this$1.deps[i].depend(); } +}; - /** - * Get an attribute with colon or v-bind: prefix. - * - * @param {Node} node - * @param {String} name - * @return {String|null} - */ +/** + * Remove self from all dependencies' subcriber list. + */ +Watcher.prototype.teardown = function teardown () { + var this$1 = this; - function getBindAttr(node, name) { - var val = getAttr(node, ':' + name); - if (val === null) { - val = getAttr(node, 'v-bind:' + name); + if (this.active) { + // remove self from vm's watcher list + // this is a somewhat expensive operation so we skip it + // if the vm is being destroyed or is performing a v-for + // re-render (the watcher list is then filtered by v-for). + if (!this.vm._isBeingDestroyed && !this.vm._vForRemoving) { + remove$1(this.vm._watchers, this); } - return val; - } - - /** - * Check the presence of a bind attribute. - * - * @param {Node} node - * @param {String} name - * @return {Boolean} - */ - - function hasBindAttr(node, name) { - return node.hasAttribute(name) || node.hasAttribute(':' + name) || node.hasAttribute('v-bind:' + name); - } - - /** - * Insert el before target - * - * @param {Element} el - * @param {Element} target - */ - - function before(el, target) { - target.parentNode.insertBefore(el, target); - } - - /** - * Insert el after target - * - * @param {Element} el - * @param {Element} target - */ - - function after(el, target) { - if (target.nextSibling) { - before(el, target.nextSibling); - } else { - target.parentNode.appendChild(el); + var i = this.deps.length; + while (i--) { + this$1.deps[i].removeSub(this$1); } + this.active = false; } +}; - /** - * Remove el from DOM - * - * @param {Element} el - */ - - function remove(el) { - el.parentNode.removeChild(el); - } - - /** - * Prepend el to target - * - * @param {Element} el - * @param {Element} target - */ - - function prepend(el, target) { - if (target.firstChild) { - before(el, target.firstChild); - } else { - target.appendChild(el); +/** + * Recursively traverse an object to evoke all converted + * getters, so that every nested property inside the object + * is collected as a "deep" dependency. + */ +var seenObjects = new _Set(); +function traverse (val, seen) { + var i, keys; + if (!seen) { + seen = seenObjects; + seen.clear(); + } + var isA = Array.isArray(val); + var isO = isObject(val); + if ((isA || isO) && Object.isExtensible(val)) { + if (val.__ob__) { + var depId = val.__ob__.dep.id; + if (seen.has(depId)) { + return + } else { + seen.add(depId); + } } - } - - /** - * Replace target with el - * - * @param {Element} target - * @param {Element} el - */ - - function replace(target, el) { - var parent = target.parentNode; - if (parent) { - parent.replaceChild(el, target); + if (isA) { + i = val.length; + while (i--) { traverse(val[i], seen); } + } else if (isO) { + keys = Object.keys(val); + i = keys.length; + while (i--) { traverse(val[keys[i]], seen); } } } +} - /** - * Add event listener shorthand. - * - * @param {Element} el - * @param {String} event - * @param {Function} cb - * @param {Boolean} [useCapture] - */ +/* + * not type checking this file because flow doesn't play well with + * dynamically accessing methods on Array prototype + */ - function on(el, event, cb, useCapture) { - el.addEventListener(event, cb, useCapture); - } +var arrayProto = Array.prototype; +var arrayMethods = Object.create(arrayProto);[ + 'push', + 'pop', + 'shift', + 'unshift', + 'splice', + 'sort', + 'reverse' +] +.forEach(function (method) { + // cache original method + var original = arrayProto[method]; + def(arrayMethods, method, function mutator () { + var arguments$1 = arguments; + + // avoid leaking arguments: + // http://jsperf.com/closure-with-arguments + var i = arguments.length; + var args = new Array(i); + while (i--) { + args[i] = arguments$1[i]; + } + var result = original.apply(this, args); + var ob = this.__ob__; + var inserted; + switch (method) { + case 'push': + inserted = args; + break + case 'unshift': + inserted = args; + break + case 'splice': + inserted = args.slice(2); + break + } + if (inserted) { ob.observeArray(inserted); } + // notify change + ob.dep.notify(); + return result + }); +}); - /** - * Remove event listener shorthand. - * - * @param {Element} el - * @param {String} event - * @param {Function} cb - */ +/* */ + +var arrayKeys = Object.getOwnPropertyNames(arrayMethods); - function off(el, event, cb) { - el.removeEventListener(event, cb); +/** + * By default, when a reactive property is set, the new value is + * also converted to become reactive. However when passing down props, + * we don't want to force conversion because the value may be a nested value + * under a frozen data structure. Converting it would defeat the optimization. + */ +var observerState = { + shouldConvert: true, + isSettingProps: false +}; + +/** + * Observer class that are attached to each observed + * object. Once attached, the observer converts target + * object's property keys into getter/setters that + * collect dependencies and dispatches updates. + */ +var Observer = function Observer (value) { + this.value = value; + this.dep = new Dep(); + this.vmCount = 0; + def(value, '__ob__', this); + if (Array.isArray(value)) { + var augment = hasProto + ? protoAugment + : copyAugment; + augment(value, arrayMethods, arrayKeys); + this.observeArray(value); + } else { + this.walk(value); } +}; - /** - * For IE9 compat: when both class and :class are present - * getAttribute('class') returns wrong value... - * - * @param {Element} el - * @return {String} - */ +/** + * Walk through each property and convert them into + * getter/setters. This method should only be called when + * value type is Object. + */ +Observer.prototype.walk = function walk (obj) { + var keys = Object.keys(obj); + for (var i = 0; i < keys.length; i++) { + defineReactive$$1(obj, keys[i], obj[keys[i]]); + } +}; - function getClass(el) { - var classname = el.className; - if (typeof classname === 'object') { - classname = classname.baseVal || ''; - } - return classname; +/** + * Observe a list of Array items. + */ +Observer.prototype.observeArray = function observeArray (items) { + for (var i = 0, l = items.length; i < l; i++) { + observe(items[i]); } +}; - /** - * In IE9, setAttribute('class') will result in empty class - * if the element also has the :class attribute; However in - * PhantomJS, setting `className` does not work on SVG elements... - * So we have to do a conditional check here. - * - * @param {Element} el - * @param {String} cls - */ +// helpers - function setClass(el, cls) { - /* istanbul ignore if */ - if (isIE9 && !/svg$/.test(el.namespaceURI)) { - el.className = cls; - } else { - el.setAttribute('class', cls); - } +/** + * Augment an target Object or Array by intercepting + * the prototype chain using __proto__ + */ +function protoAugment (target, src) { + /* eslint-disable no-proto */ + target.__proto__ = src; + /* eslint-enable no-proto */ +} + +/** + * Augment an target Object or Array by defining + * hidden properties. + * + * istanbul ignore next + */ +function copyAugment (target, src, keys) { + for (var i = 0, l = keys.length; i < l; i++) { + var key = keys[i]; + def(target, key, src[key]); } +} - /** - * Add class with compatibility for IE & SVG - * - * @param {Element} el - * @param {String} cls - */ - - function addClass(el, cls) { - if (el.classList) { - el.classList.add(cls); - } else { - var cur = ' ' + getClass(el) + ' '; - if (cur.indexOf(' ' + cls + ' ') < 0) { - setClass(el, (cur + cls).trim()); +/** + * Attempt to create an observer instance for a value, + * returns the new observer if successfully observed, + * or the existing observer if the value already has one. + */ +function observe (value) { + if (!isObject(value)) { + return + } + var ob; + if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) { + ob = value.__ob__; + } else if ( + observerState.shouldConvert && + !config._isServer && + (Array.isArray(value) || isPlainObject(value)) && + Object.isExtensible(value) && + !value._isVue + ) { + ob = new Observer(value); + } + return ob +} + +/** + * Define a reactive property on an Object. + */ +function defineReactive$$1 ( + obj, + key, + val, + customSetter +) { + var dep = new Dep(); + + var property = Object.getOwnPropertyDescriptor(obj, key); + if (property && property.configurable === false) { + return + } + + // cater for pre-defined getter/setters + var getter = property && property.get; + var setter = property && property.set; + + var childOb = observe(val); + Object.defineProperty(obj, key, { + enumerable: true, + configurable: true, + get: function reactiveGetter () { + var value = getter ? getter.call(obj) : val; + if (Dep.target) { + dep.depend(); + if (childOb) { + childOb.dep.depend(); + } + if (Array.isArray(value)) { + dependArray(value); + } + } + return value + }, + set: function reactiveSetter (newVal) { + var value = getter ? getter.call(obj) : val; + if (newVal === value) { + return + } + if ("development" !== 'production' && customSetter) { + customSetter(); + } + if (setter) { + setter.call(obj, newVal); + } else { + val = newVal; } + childOb = observe(newVal); + dep.notify(); } - } + }); +} - /** - * Remove class with compatibility for IE & SVG - * - * @param {Element} el - * @param {String} cls - */ +/** + * Set a property on an object. Adds the new property and + * triggers change notification if the property doesn't + * already exist. + */ +function set (obj, key, val) { + if (Array.isArray(obj)) { + obj.splice(key, 1, val); + return val + } + if (hasOwn(obj, key)) { + obj[key] = val; + return + } + var ob = obj.__ob__; + if (obj._isVue || (ob && ob.vmCount)) { + "development" !== 'production' && warn( + 'Avoid adding reactive properties to a Vue instance or its root $data ' + + 'at runtime - declare it upfront in the data option.' + ); + return + } + if (!ob) { + obj[key] = val; + return + } + defineReactive$$1(ob.value, key, val); + ob.dep.notify(); + return val +} + +/** + * Delete a property and trigger change if necessary. + */ +function del (obj, key) { + var ob = obj.__ob__; + if (obj._isVue || (ob && ob.vmCount)) { + "development" !== 'production' && warn( + 'Avoid deleting properties on a Vue instance or its root $data ' + + '- just set it to null.' + ); + return + } + if (!hasOwn(obj, key)) { + return + } + delete obj[key]; + if (!ob) { + return + } + ob.dep.notify(); +} + +/** + * Collect dependencies on array elements when the array is touched, since + * we cannot intercept array element access like property getters. + */ +function dependArray (value) { + for (var e = void 0, i = 0, l = value.length; i < l; i++) { + e = value[i]; + e && e.__ob__ && e.__ob__.dep.depend(); + if (Array.isArray(e)) { + dependArray(e); + } + } +} + +/* */ + +function initState (vm) { + vm._watchers = []; + initProps(vm); + initData(vm); + initComputed(vm); + initMethods(vm); + initWatch(vm); +} + +function initProps (vm) { + var props = vm.$options.props; + if (props) { + var propsData = vm.$options.propsData || {}; + var keys = vm.$options._propKeys = Object.keys(props); + var isRoot = !vm.$parent; + // root instance props should be converted + observerState.shouldConvert = isRoot; + var loop = function ( i ) { + var key = keys[i]; + /* istanbul ignore else */ + { + defineReactive$$1(vm, key, validateProp(key, props, propsData, vm), function () { + if (vm.$parent && !observerState.isSettingProps) { + warn( + "Avoid mutating a prop directly since the value will be " + + "overwritten whenever the parent component re-renders. " + + "Instead, use a data or computed property based on the prop's " + + "value. Prop being mutated: \"" + key + "\"", + vm + ); + } + }); + } + }; - function removeClass(el, cls) { - if (el.classList) { - el.classList.remove(cls); + for (var i = 0; i < keys.length; i++) loop( i ); + observerState.shouldConvert = true; + } +} + +function initData (vm) { + var data = vm.$options.data; + data = vm._data = typeof data === 'function' + ? data.call(vm) + : data || {}; + if (!isPlainObject(data)) { + data = {}; + "development" !== 'production' && warn( + 'data functions should return an object.', + vm + ); + } + // proxy data on instance + var keys = Object.keys(data); + var props = vm.$options.props; + var i = keys.length; + while (i--) { + if (props && hasOwn(props, keys[i])) { + "development" !== 'production' && warn( + "The data property \"" + (keys[i]) + "\" is already declared as a prop. " + + "Use prop default value instead.", + vm + ); } else { - var cur = ' ' + getClass(el) + ' '; - var tar = ' ' + cls + ' '; - while (cur.indexOf(tar) >= 0) { - cur = cur.replace(tar, ' '); + proxy(vm, keys[i]); + } + } + // observe data + observe(data); + data.__ob__ && data.__ob__.vmCount++; +} + +var computedSharedDefinition = { + enumerable: true, + configurable: true, + get: noop, + set: noop +}; + +function initComputed (vm) { + var computed = vm.$options.computed; + if (computed) { + for (var key in computed) { + var userDef = computed[key]; + if (typeof userDef === 'function') { + computedSharedDefinition.get = makeComputedGetter(userDef, vm); + computedSharedDefinition.set = noop; + } else { + computedSharedDefinition.get = userDef.get + ? userDef.cache !== false + ? makeComputedGetter(userDef.get, vm) + : bind$1(userDef.get, vm) + : noop; + computedSharedDefinition.set = userDef.set + ? bind$1(userDef.set, vm) + : noop; } - setClass(el, cur.trim()); - } - if (!el.className) { - el.removeAttribute('class'); + Object.defineProperty(vm, key, computedSharedDefinition); } } +} - /** - * Extract raw content inside an element into a temporary - * container div - * - * @param {Element} el - * @param {Boolean} asFragment - * @return {Element|DocumentFragment} - */ - - function extractContent(el, asFragment) { - var child; - var rawContent; - /* istanbul ignore if */ - if (isTemplate(el) && isFragment(el.content)) { - el = el.content; - } - if (el.hasChildNodes()) { - trimNode(el); - rawContent = asFragment ? document.createDocumentFragment() : document.createElement('div'); - /* eslint-disable no-cond-assign */ - while (child = el.firstChild) { - /* eslint-enable no-cond-assign */ - rawContent.appendChild(child); +function makeComputedGetter (getter, owner) { + var watcher = new Watcher(owner, getter, noop, { + lazy: true + }); + return function computedGetter () { + if (watcher.dirty) { + watcher.evaluate(); + } + if (Dep.target) { + watcher.depend(); + } + return watcher.value + } +} + +function initMethods (vm) { + var methods = vm.$options.methods; + if (methods) { + for (var key in methods) { + vm[key] = methods[key] == null ? noop : bind$1(methods[key], vm); + if ("development" !== 'production' && methods[key] == null) { + warn( + "method \"" + key + "\" has an undefined value in the component definition. " + + "Did you reference the function correctly?", + vm + ); } } - return rawContent; } +} - /** - * Trim possible empty head/tail text and comment - * nodes inside a parent. - * - * @param {Node} node - */ - - function trimNode(node) { - var child; - /* eslint-disable no-sequences */ - while ((child = node.firstChild, isTrimmable(child))) { - node.removeChild(child); - } - while ((child = node.lastChild, isTrimmable(child))) { - node.removeChild(child); +function initWatch (vm) { + var watch = vm.$options.watch; + if (watch) { + for (var key in watch) { + var handler = watch[key]; + if (Array.isArray(handler)) { + for (var i = 0; i < handler.length; i++) { + createWatcher(vm, key, handler[i]); + } + } else { + createWatcher(vm, key, handler); + } } - /* eslint-enable no-sequences */ } +} - function isTrimmable(node) { - return node && (node.nodeType === 3 && !node.data.trim() || node.nodeType === 8); +function createWatcher (vm, key, handler) { + var options; + if (isPlainObject(handler)) { + options = handler; + handler = handler.handler; } - - /** - * Check if an element is a template tag. - * Note if the template appears inside an SVG its tagName - * will be in lowercase. - * - * @param {Element} el - */ - - function isTemplate(el) { - return el.tagName && el.tagName.toLowerCase() === 'template'; + if (typeof handler === 'string') { + handler = vm[handler]; } + vm.$watch(key, handler, options); +} - /** - * Create an "anchor" for performing dom insertion/removals. - * This is used in a number of scenarios: - * - fragment instance - * - v-html - * - v-if - * - v-for - * - component - * - * @param {String} content - * @param {Boolean} persist - IE trashes empty textNodes on - * cloneNode(true), so in certain - * cases the anchor needs to be - * non-empty to be persisted in - * templates. - * @return {Comment|Text} - */ - - function createAnchor(content, persist) { - var anchor = config.debug ? document.createComment(content) : document.createTextNode(persist ? ' ' : ''); - anchor.__v_anchor = true; - return anchor; +function stateMixin (Vue) { + // flow somehow has problems with directly declared definition object + // when using Object.defineProperty, so we have to procedurally build up + // the object here. + var dataDef = {}; + dataDef.get = function () { + return this._data + }; + { + dataDef.set = function (newData) { + warn( + 'Avoid replacing instance root $data. ' + + 'Use nested data properties instead.', + this + ); + }; } + Object.defineProperty(Vue.prototype, '$data', dataDef); - /** - * Find a component ref attribute that starts with $. - * - * @param {Element} node - * @return {String|undefined} - */ - - var refRE = /^v-ref:/; + Vue.prototype.$set = set; + Vue.prototype.$delete = del; - function findRef(node) { - if (node.hasAttributes()) { - var attrs = node.attributes; - for (var i = 0, l = attrs.length; i < l; i++) { - var name = attrs[i].name; - if (refRE.test(name)) { - return camelize(name.replace(refRE, '')); - } - } + Vue.prototype.$watch = function ( + expOrFn, + cb, + options + ) { + var vm = this; + options = options || {}; + options.user = true; + var watcher = new Watcher(vm, expOrFn, cb, options); + if (options.immediate) { + cb.call(vm, watcher.value); } - } - - /** - * Map a function to a range of nodes . - * - * @param {Node} node - * @param {Node} end - * @param {Function} op - */ - - function mapNodeRange(node, end, op) { - var next; - while (node !== end) { - next = node.nextSibling; - op(node); - node = next; + return function unwatchFn () { + watcher.teardown(); } - op(end); - } - - /** - * Remove a range of nodes with transition, store - * the nodes in a fragment with correct ordering, - * and call callback when done. - * - * @param {Node} start - * @param {Node} end - * @param {Vue} vm - * @param {DocumentFragment} frag - * @param {Function} cb - */ + }; +} - function removeNodeRange(start, end, vm, frag, cb) { - var done = false; - var removed = 0; - var nodes = []; - mapNodeRange(start, end, function (node) { - if (node === end) done = true; - nodes.push(node); - removeWithTransition(node, vm, onRemoved); - }); - function onRemoved() { - removed++; - if (done && removed >= nodes.length) { - for (var i = 0; i < nodes.length; i++) { - frag.appendChild(nodes[i]); - } - cb && cb(); +function proxy (vm, key) { + if (!isReserved(key)) { + Object.defineProperty(vm, key, { + configurable: true, + enumerable: true, + get: function proxyGetter () { + return vm._data[key] + }, + set: function proxySetter (val) { + vm._data[key] = val; } - } - } - - /** - * Check if a node is a DocumentFragment. - * - * @param {Node} node - * @return {Boolean} - */ - - function isFragment(node) { - return node && node.nodeType === 11; + }); } - - /** - * Get outerHTML of elements, taking care - * of SVG elements in IE as well. - * - * @param {Element} el - * @return {String} - */ - - function getOuterHTML(el) { - if (el.outerHTML) { - return el.outerHTML; +} + +/* */ + +var VNode = function VNode ( + tag, + data, + children, + text, + elm, + ns, + context, + componentOptions +) { + this.tag = tag; + this.data = data; + this.children = children; + this.text = text; + this.elm = elm; + this.ns = ns; + this.context = context; + this.functionalContext = undefined; + this.key = data && data.key; + this.componentOptions = componentOptions; + this.child = undefined; + this.parent = undefined; + this.raw = false; + this.isStatic = false; + this.isRootInsert = true; + this.isComment = false; + this.isCloned = false; +}; + +var emptyVNode = function () { + var node = new VNode(); + node.text = ''; + node.isComment = true; + return node +}; + +// optimized shallow clone +// used for static nodes and slot nodes because they may be reused across +// multiple renders, cloning them avoids errors when DOM manipulations rely +// on their elm reference. +function cloneVNode (vnode) { + var cloned = new VNode( + vnode.tag, + vnode.data, + vnode.children, + vnode.text, + vnode.elm, + vnode.ns, + vnode.context, + vnode.componentOptions + ); + cloned.isStatic = vnode.isStatic; + cloned.key = vnode.key; + cloned.isCloned = true; + return cloned +} + +function cloneVNodes (vnodes) { + var res = new Array(vnodes.length); + for (var i = 0; i < vnodes.length; i++) { + res[i] = cloneVNode(vnodes[i]); + } + return res +} + +/* */ + +function mergeVNodeHook (def, hookKey, hook, key) { + key = key + hookKey; + var injectedHash = def.__injected || (def.__injected = {}); + if (!injectedHash[key]) { + injectedHash[key] = true; + var oldHook = def[hookKey]; + if (oldHook) { + def[hookKey] = function () { + oldHook.apply(this, arguments); + hook.apply(this, arguments); + }; } else { - var container = document.createElement('div'); - container.appendChild(el.cloneNode(true)); - return container.innerHTML; - } - } - - 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; - var reservedTagRE = /^(slot|partial|component)$/i; - - var isUnknownElement = undefined; - if ('development' !== 'production') { - isUnknownElement = function (el, tag) { - if (tag.indexOf('-') > -1) { - // http://stackoverflow.com/a/28210364/1070244 - return el.constructor === window.HTMLUnknownElement || el.constructor === window.HTMLElement; + def[hookKey] = hook; + } + } +} + +/* */ + +function updateListeners ( + on, + oldOn, + add, + remove$$1, + vm +) { + var name, cur, old, fn, event, capture; + for (name in on) { + cur = on[name]; + old = oldOn[name]; + if (!cur) { + "development" !== 'production' && warn( + "Invalid handler for event \"" + name + "\": got " + String(cur), + vm + ); + } else if (!old) { + capture = name.charAt(0) === '!'; + event = capture ? name.slice(1) : name; + if (Array.isArray(cur)) { + add(event, (cur.invoker = arrInvoker(cur)), capture); } else { - return (/HTMLUnknownElement/.test(el.toString()) && - // Chrome returns unknown for several HTML5 elements. - // https://code.google.com/p/chromium/issues/detail?id=540526 - // Firefox returns unknown for some "Interactive elements." - !/^(data|time|rtc|rb|details|dialog|summary)$/.test(tag) - ); - } - }; - } - - /** - * Check if an element is a component, if yes return its - * component id. - * - * @param {Element} el - * @param {Object} options - * @return {Object|undefined} - */ - - function checkComponentAttr(el, options) { - var tag = el.tagName.toLowerCase(); - var hasAttrs = el.hasAttributes(); - if (!commonTagRE.test(tag) && !reservedTagRE.test(tag)) { - if (resolveAsset(options, 'components', tag)) { - return { id: tag }; + if (!cur.invoker) { + fn = cur; + cur = on[name] = {}; + cur.fn = fn; + cur.invoker = fnInvoker(cur); + } + add(event, cur.invoker, capture); + } + } else if (cur !== old) { + if (Array.isArray(old)) { + old.length = cur.length; + for (var i = 0; i < old.length; i++) { old[i] = cur[i]; } + on[name] = old; } else { - var is = hasAttrs && getIsBinding(el, options); - if (is) { - return is; - } else if ('development' !== 'production') { - var expectedTag = options._componentNameMap && options._componentNameMap[tag]; - if (expectedTag) { - warn('Unknown custom element: <' + tag + '> - ' + 'did you mean <' + expectedTag + '>? ' + 'HTML is case-insensitive, remember to use kebab-case in templates.'); - } else if (isUnknownElement(el, tag)) { - warn('Unknown custom element: <' + tag + '> - did you ' + 'register the component correctly? For recursive components, ' + 'make sure to provide the "name" option.'); - } - } + old.fn = cur; + on[name] = old; } - } else if (hasAttrs) { - return getIsBinding(el, options); } } - - /** - * Get "is" binding from an element. - * - * @param {Element} el - * @param {Object} options - * @return {Object|undefined} - */ - - function getIsBinding(el, options) { - // dynamic syntax - var exp = el.getAttribute('is'); - if (exp != null) { - if (resolveAsset(options, 'components', exp)) { - el.removeAttribute('is'); - return { id: exp }; - } - } else { - exp = getBindAttr(el, 'is'); - if (exp != null) { - return { id: exp, dynamic: true }; - } + for (name in oldOn) { + if (!on[name]) { + event = name.charAt(0) === '!' ? name.slice(1) : name; + remove$$1(event, oldOn[name].invoker); } } +} - /** - * Option overwriting strategies are functions that handle - * how to merge a parent option value and a child option - * value into the final value. - * - * All strategy functions follow the same signature: - * - * @param {*} parentVal - * @param {*} childVal - * @param {Vue} [vm] - */ - - var strats = config.optionMergeStrategies = Object.create(null); +function arrInvoker (arr) { + return function (ev) { + var arguments$1 = arguments; - /** - * Helper that recursively merges two data objects together. - */ - - function mergeData(to, from) { - var key, toVal, fromVal; - for (key in from) { - toVal = to[key]; - fromVal = from[key]; - if (!hasOwn(to, key)) { - set(to, key, fromVal); - } else if (isObject(toVal) && isObject(fromVal)) { - mergeData(toVal, fromVal); - } + var single = arguments.length === 1; + for (var i = 0; i < arr.length; i++) { + single ? arr[i](ev) : arr[i].apply(null, arguments$1); } - return to; } +} - /** - * Data - */ +function fnInvoker (o) { + return function (ev) { + var single = arguments.length === 1; + single ? o.fn(ev) : o.fn.apply(null, arguments); + } +} - strats.data = function (parentVal, childVal, vm) { - if (!vm) { - // in a Vue.extend merge, both should be functions - if (!childVal) { - return parentVal; - } - if (typeof childVal !== 'function') { - 'development' !== 'production' && warn('The "data" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm); - return parentVal; - } - if (!parentVal) { - return childVal; - } - // when parentVal & childVal are both present, - // we need to return a function that returns the - // merged result of both functions... no need to - // check if parentVal is a function here because - // it has to be a function to pass previous merges. - return function mergedDataFn() { - return mergeData(childVal.call(this), parentVal.call(this)); - }; - } else if (parentVal || childVal) { - return function mergedInstanceDataFn() { - // instance merge - var instanceData = typeof childVal === 'function' ? childVal.call(vm) : childVal; - var defaultData = typeof parentVal === 'function' ? parentVal.call(vm) : undefined; - if (instanceData) { - return mergeData(instanceData, defaultData); +/* */ + +function normalizeChildren ( + children, + ns, + nestedIndex +) { + if (isPrimitive(children)) { + return [createTextVNode(children)] + } + if (Array.isArray(children)) { + var res = []; + for (var i = 0, l = children.length; i < l; i++) { + var c = children[i]; + var last = res[res.length - 1]; + // nested + if (Array.isArray(c)) { + res.push.apply(res, normalizeChildren(c, ns, ((nestedIndex || '') + "_" + i))); + } else if (isPrimitive(c)) { + if (last && last.text) { + last.text += String(c); + } else if (c !== '') { + // convert primitive to vnode + res.push(createTextVNode(c)); + } + } else if (c instanceof VNode) { + if (c.text && last && last.text) { + last.text += c.text; } else { - return defaultData; + // inherit parent namespace + if (ns) { + applyNS(c, ns); + } + // default key for nested array children (likely generated by v-for) + if (c.tag && c.key == null && nestedIndex != null) { + c.key = "__vlist" + nestedIndex + "_" + i + "__"; + } + res.push(c); } - }; - } - }; - - /** - * El - */ - - strats.el = function (parentVal, childVal, vm) { - if (!vm && childVal && typeof childVal !== 'function') { - 'development' !== 'production' && warn('The "el" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm); - return; + } } - var ret = childVal || parentVal; - // invoke the element factory if this is instance merge - return vm && typeof ret === 'function' ? ret.call(vm) : ret; - }; - - /** - * Hooks and param attributes are merged as arrays. - */ - - strats.init = strats.created = strats.ready = strats.attached = strats.detached = strats.beforeCompile = strats.compiled = strats.beforeDestroy = strats.destroyed = strats.activate = function (parentVal, childVal) { - return childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal; - }; - - /** - * Assets - * - * When a vm is present (instance creation), we need to do - * a three-way merge between constructor options, instance - * options and parent options. - */ - - function mergeAssets(parentVal, childVal) { - var res = Object.create(parentVal || null); - return childVal ? extend(res, guardArrayAssets(childVal)) : res; + return res } +} - config._assetTypes.forEach(function (type) { - strats[type + 's'] = mergeAssets; - }); - - /** - * Events & Watchers. - * - * Events & watchers hashes should not overwrite one - * another, so we merge them as arrays. - */ +function createTextVNode (val) { + return new VNode(undefined, undefined, undefined, String(val)) +} - strats.watch = strats.events = function (parentVal, childVal) { - if (!childVal) return parentVal; - if (!parentVal) return childVal; - var ret = {}; - extend(ret, parentVal); - for (var key in childVal) { - var parent = ret[key]; - var child = childVal[key]; - if (parent && !isArray(parent)) { - parent = [parent]; +function applyNS (vnode, ns) { + if (vnode.tag && !vnode.ns) { + vnode.ns = ns; + if (vnode.children) { + for (var i = 0, l = vnode.children.length; i < l; i++) { + applyNS(vnode.children[i], ns); } - ret[key] = parent ? parent.concat(child) : [child]; } - return ret; - }; + } +} - /** - * Other object hashes. - */ +/* */ - strats.props = strats.methods = strats.computed = function (parentVal, childVal) { - if (!childVal) return parentVal; - if (!parentVal) return childVal; - var ret = Object.create(null); - extend(ret, parentVal); - extend(ret, childVal); - return ret; - }; +function getFirstComponentChild (children) { + return children && children.filter(function (c) { return c && c.componentOptions; })[0] +} - /** - * Default strategy. - */ +/* */ - var defaultStrat = function defaultStrat(parentVal, childVal) { - return childVal === undefined ? parentVal : childVal; - }; +var activeInstance = null; - /** - * Make sure component options get converted to actual - * constructors. - * - * @param {Object} options - */ +function initLifecycle (vm) { + var options = vm.$options; - function guardComponents(options) { - if (options.components) { - var components = options.components = guardArrayAssets(options.components); - var ids = Object.keys(components); - var def; - if ('development' !== 'production') { - var map = options._componentNameMap = {}; - } - for (var i = 0, l = ids.length; i < l; i++) { - var key = ids[i]; - if (commonTagRE.test(key) || reservedTagRE.test(key)) { - 'development' !== 'production' && warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + key); - continue; - } - // record a all lowercase <-> kebab-case mapping for - // possible custom element case error warning - if ('development' !== 'production') { - map[key.replace(/-/g, '').toLowerCase()] = hyphenate(key); - } - def = components[key]; - if (isPlainObject(def)) { - components[key] = Vue.extend(def); - } - } + // locate first non-abstract parent + var parent = options.parent; + if (parent && !options.abstract) { + while (parent.$options.abstract && parent.$parent) { + parent = parent.$parent; } + parent.$children.push(vm); } - /** - * Ensure all props option syntax are normalized into the - * Object-based format. - * - * @param {Object} options - */ + vm.$parent = parent; + vm.$root = parent ? parent.$root : vm; - function guardProps(options) { - var props = options.props; - var i, val; - if (isArray(props)) { - options.props = {}; - i = props.length; - while (i--) { - val = props[i]; - if (typeof val === 'string') { - options.props[val] = null; - } else if (val.name) { - options.props[val.name] = val; - } - } - } else if (isPlainObject(props)) { - var keys = Object.keys(props); - i = keys.length; - while (i--) { - val = props[keys[i]]; - if (typeof val === 'function') { - props[keys[i]] = { type: val }; - } - } - } - } + vm.$children = []; + vm.$refs = {}; - /** - * Guard an Array-format assets option and converted it - * into the key-value Object format. - * - * @param {Object|Array} assets - * @return {Object} - */ + vm._watcher = null; + vm._inactive = false; + vm._isMounted = false; + vm._isDestroyed = false; + vm._isBeingDestroyed = false; +} - function guardArrayAssets(assets) { - if (isArray(assets)) { - var res = {}; - var i = assets.length; - var asset; - while (i--) { - asset = assets[i]; - var id = typeof asset === 'function' ? asset.options && asset.options.name || asset.id : asset.name || asset.id; - if (!id) { - 'development' !== 'production' && warn('Array-syntax assets must provide a "name" or "id" field.'); +function lifecycleMixin (Vue) { + Vue.prototype._mount = function ( + el, + hydrating + ) { + var vm = this; + vm.$el = el; + if (!vm.$options.render) { + vm.$options.render = emptyVNode; + { + /* istanbul ignore if */ + if (vm.$options.template) { + warn( + 'You are using the runtime-only build of Vue where the template ' + + 'option is not available. Either pre-compile the templates into ' + + 'render functions, or use the compiler-included build.', + vm + ); } else { - res[id] = asset; + warn( + 'Failed to mount component: template or render function not defined.', + vm + ); } } - return res; } - return assets; - } - - /** - * Merge two option objects into a new one. - * Core utility used in both instantiation and inheritance. - * - * @param {Object} parent - * @param {Object} child - * @param {Vue} [vm] - if vm is present, indicates this is - * an instantiation merge. - */ - - function mergeOptions(parent, child, vm) { - guardComponents(child); - guardProps(child); - if ('development' !== 'production') { - if (child.propsData && !vm) { - warn('propsData can only be used as an instantiation option.'); - } + callHook(vm, 'beforeMount'); + vm._watcher = new Watcher(vm, function () { + vm._update(vm._render(), hydrating); + }, noop); + hydrating = false; + // manually mounted instance, call mounted on self + // mounted is called for render-created child components in its inserted hook + if (vm.$vnode == null) { + vm._isMounted = true; + callHook(vm, 'mounted'); } - var options = {}; - var key; - if (child['extends']) { - parent = typeof child['extends'] === 'function' ? mergeOptions(parent, child['extends'].options, vm) : mergeOptions(parent, child['extends'], vm); + return vm + }; + + Vue.prototype._update = function (vnode, hydrating) { + var vm = this; + if (vm._isMounted) { + callHook(vm, 'beforeUpdate'); + } + var prevEl = vm.$el; + var prevActiveInstance = activeInstance; + activeInstance = vm; + var prevVnode = vm._vnode; + vm._vnode = vnode; + if (!prevVnode) { + // Vue.prototype.__patch__ is injected in entry points + // based on the rendering backend used. + vm.$el = vm.__patch__(vm.$el, vnode, hydrating); + } else { + vm.$el = vm.__patch__(prevVnode, vnode); } - if (child.mixins) { - for (var i = 0, l = child.mixins.length; i < l; i++) { - var mixin = child.mixins[i]; - var mixinOptions = mixin.prototype instanceof Vue ? mixin.options : mixin; - parent = mergeOptions(parent, mixinOptions, vm); - } + activeInstance = prevActiveInstance; + // update __vue__ reference + if (prevEl) { + prevEl.__vue__ = null; } - for (key in parent) { - mergeField(key); + if (vm.$el) { + vm.$el.__vue__ = vm; } - for (key in child) { - if (!hasOwn(parent, key)) { - mergeField(key); - } + // if parent is an HOC, update its $el as well + if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) { + vm.$parent.$el = vm.$el; } - function mergeField(key) { - var strat = strats[key] || defaultStrat; - options[key] = strat(parent[key], child[key], vm, key); + if (vm._isMounted) { + callHook(vm, 'updated'); } - return options; - } - - /** - * Resolve an asset. - * This function is used because child instances need access - * to assets defined in its ancestor chain. - * - * @param {Object} options - * @param {String} type - * @param {String} id - * @param {Boolean} warnMissing - * @return {Object|Function} - */ + }; - function resolveAsset(options, type, id, warnMissing) { - /* istanbul ignore if */ - if (typeof id !== 'string') { - return; + Vue.prototype._updateFromParent = function ( + propsData, + listeners, + parentVnode, + renderChildren + ) { + var vm = this; + var hasChildren = !!(vm.$options._renderChildren || renderChildren); + vm.$options._parentVnode = parentVnode; + vm.$options._renderChildren = renderChildren; + // update props + if (propsData && vm.$options.props) { + observerState.shouldConvert = false; + { + observerState.isSettingProps = true; + } + var propKeys = vm.$options._propKeys || []; + for (var i = 0; i < propKeys.length; i++) { + var key = propKeys[i]; + vm[key] = validateProp(key, vm.$options.props, propsData, vm); + } + observerState.shouldConvert = true; + { + observerState.isSettingProps = false; + } } - var assets = options[type]; - var camelizedId; - var res = assets[id] || - // camelCase ID - assets[camelizedId = camelize(id)] || - // Pascal Case ID - assets[camelizedId.charAt(0).toUpperCase() + camelizedId.slice(1)]; - if ('development' !== 'production' && warnMissing && !res) { - warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options); + // update listeners + if (listeners) { + var oldListeners = vm.$options._parentListeners; + vm.$options._parentListeners = listeners; + vm._updateListeners(listeners, oldListeners); } - return res; - } - - var uid$1 = 0; - - /** - * A dep is an observable that can have multiple - * directives subscribing to it. - * - * @constructor - */ - function Dep() { - this.id = uid$1++; - this.subs = []; - } - - // the current target watcher being evaluated. - // this is globally unique because there could be only one - // watcher being evaluated at any time. - Dep.target = null; - - /** - * Add a directive subscriber. - * - * @param {Directive} sub - */ - - Dep.prototype.addSub = function (sub) { - this.subs.push(sub); - }; - - /** - * Remove a directive subscriber. - * - * @param {Directive} sub - */ - - Dep.prototype.removeSub = function (sub) { - this.subs.$remove(sub); - }; - - /** - * Add self as a dependency to the target watcher. - */ - - Dep.prototype.depend = function () { - Dep.target.addDep(this); - }; - - /** - * Notify all subscribers of a new value. - */ - - Dep.prototype.notify = function () { - // stablize the subscriber list first - var subs = toArray(this.subs); - for (var i = 0, l = subs.length; i < l; i++) { - subs[i].update(); + // resolve slots + force update if has children + if (hasChildren) { + vm.$slots = resolveSlots(renderChildren, vm._renderContext); + vm.$forceUpdate(); } }; - var arrayProto = Array.prototype; - var arrayMethods = Object.create(arrayProto) - - /** - * Intercept mutating methods and emit events - */ - - ;['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'].forEach(function (method) { - // cache original method - var original = arrayProto[method]; - def(arrayMethods, method, function mutator() { - // avoid leaking arguments: - // http://jsperf.com/closure-with-arguments - var i = arguments.length; - var args = new Array(i); - while (i--) { - args[i] = arguments[i]; - } - var result = original.apply(this, args); - var ob = this.__ob__; - var inserted; - switch (method) { - case 'push': - inserted = args; - break; - case 'unshift': - inserted = args; - break; - case 'splice': - inserted = args.slice(2); - break; - } - if (inserted) ob.observeArray(inserted); - // notify change - ob.dep.notify(); - return result; - }); - }); - - /** - * Swap the element at the given index with a new value - * and emits corresponding event. - * - * @param {Number} index - * @param {*} val - * @return {*} - replaced element - */ - - def(arrayProto, '$set', function $set(index, val) { - if (index >= this.length) { - this.length = Number(index) + 1; + Vue.prototype.$forceUpdate = function () { + var vm = this; + if (vm._watcher) { + vm._watcher.update(); } - return this.splice(index, 1, val)[0]; - }); - - /** - * Convenience method to remove the element at given index or target element reference. - * - * @param {*} item - */ + }; - def(arrayProto, '$remove', function $remove(item) { - /* istanbul ignore if */ - if (!this.length) return; - var index = indexOf(this, item); - if (index > -1) { - return this.splice(index, 1); + Vue.prototype.$destroy = function () { + var vm = this; + if (vm._isBeingDestroyed) { + return } - }); - - var arrayKeys = Object.getOwnPropertyNames(arrayMethods); - - /** - * By default, when a reactive property is set, the new value is - * also converted to become reactive. However in certain cases, e.g. - * v-for scope alias and props, we don't want to force conversion - * because the value may be a nested value under a frozen data structure. - * - * So whenever we want to set a reactive property without forcing - * conversion on the new value, we wrap that call inside this function. - */ - - var shouldConvert = true; - - function withoutConversion(fn) { - shouldConvert = false; - fn(); - shouldConvert = true; - } - - /** - * Observer class that are attached to each observed - * object. Once attached, the observer converts target - * object's property keys into getter/setters that - * collect dependencies and dispatches updates. - * - * @param {Array|Object} value - * @constructor - */ - - function Observer(value) { - this.value = value; - this.dep = new Dep(); - def(value, '__ob__', this); - if (isArray(value)) { - var augment = hasProto ? protoAugment : copyAugment; - augment(value, arrayMethods, arrayKeys); - this.observeArray(value); - } else { - this.walk(value); + callHook(vm, 'beforeDestroy'); + vm._isBeingDestroyed = true; + // remove self from parent + var parent = vm.$parent; + if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) { + remove$1(parent.$children, vm); } - } - - // Instance methods - - /** - * Walk through each property and convert them into - * getter/setters. This method should only be called when - * value type is Object. - * - * @param {Object} obj - */ - - Observer.prototype.walk = function (obj) { - var keys = Object.keys(obj); - for (var i = 0, l = keys.length; i < l; i++) { - this.convert(keys[i], obj[keys[i]]); + // teardown watchers + if (vm._watcher) { + vm._watcher.teardown(); } + var i = vm._watchers.length; + while (i--) { + vm._watchers[i].teardown(); + } + // remove reference from data ob + // frozen object may not have observer. + if (vm._data.__ob__) { + vm._data.__ob__.vmCount--; + } + // call the last hook... + vm._isDestroyed = true; + callHook(vm, 'destroyed'); + // turn off all instance listeners. + vm.$off(); + // remove __vue__ reference + if (vm.$el) { + vm.$el.__vue__ = null; + } + // invoke destroy hooks on current rendered tree + vm.__patch__(vm._vnode, null); }; +} - /** - * Observe a list of Array items. - * - * @param {Array} items - */ - - Observer.prototype.observeArray = function (items) { - for (var i = 0, l = items.length; i < l; i++) { - observe(items[i]); +function callHook (vm, hook) { + var handlers = vm.$options[hook]; + if (handlers) { + for (var i = 0, j = handlers.length; i < j; i++) { + handlers[i].call(vm); } - }; - - /** - * Convert a property into getter/setter so we can emit - * the events when the property is accessed/changed. - * - * @param {String} key - * @param {*} val - */ - - Observer.prototype.convert = function (key, val) { - defineReactive(this.value, key, val); - }; - - /** - * Add an owner vm, so that when $set/$delete mutations - * happen we can notify owner vms to proxy the keys and - * digest the watchers. This is only called when the object - * is observed as an instance's root $data. - * - * @param {Vue} vm - */ - - Observer.prototype.addVm = function (vm) { - (this.vms || (this.vms = [])).push(vm); - }; - - /** - * Remove an owner vm. This is called when the object is - * swapped out as an instance's $data object. - * - * @param {Vue} vm - */ - - Observer.prototype.removeVm = function (vm) { - this.vms.$remove(vm); - }; + } + vm.$emit('hook:' + hook); +} - // helpers +/* */ - /** - * Augment an target Object or Array by intercepting - * the prototype chain using __proto__ - * - * @param {Object|Array} target - * @param {Object} src - */ +var hooks = { init: init, prepatch: prepatch, insert: insert, destroy: destroy$1 }; +var hooksToMerge = Object.keys(hooks); - function protoAugment(target, src) { - /* eslint-disable no-proto */ - target.__proto__ = src; - /* eslint-enable no-proto */ +function createComponent ( + Ctor, + data, + context, + children, + tag +) { + if (!Ctor) { + return } - /** - * Augment an target Object or Array by defining - * hidden properties. - * - * @param {Object|Array} target - * @param {Object} proto - */ - - function copyAugment(target, src, keys) { - for (var i = 0, l = keys.length; i < l; i++) { - var key = keys[i]; - def(target, key, src[key]); - } + if (isObject(Ctor)) { + Ctor = Vue$3.extend(Ctor); } - /** - * Attempt to create an observer instance for a value, - * returns the new observer if successfully observed, - * or the existing observer if the value already has one. - * - * @param {*} value - * @param {Vue} [vm] - * @return {Observer|undefined} - * @static - */ - - function observe(value, vm) { - if (!value || typeof value !== 'object') { - return; - } - var ob; - if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) { - ob = value.__ob__; - } else if (shouldConvert && (isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value._isVue) { - ob = new Observer(value); - } - if (ob && vm) { - ob.addVm(vm); + if (typeof Ctor !== 'function') { + { + warn(("Invalid Component definition: " + (String(Ctor))), context); } - return ob; + return } - /** - * Define a reactive property on an Object. - * - * @param {Object} obj - * @param {String} key - * @param {*} val - */ - - function defineReactive(obj, key, val) { - var dep = new Dep(); - - var property = Object.getOwnPropertyDescriptor(obj, key); - if (property && property.configurable === false) { - return; + // async component + if (!Ctor.cid) { + if (Ctor.resolved) { + Ctor = Ctor.resolved; + } else { + Ctor = resolveAsyncComponent(Ctor, function () { + // it's ok to queue this on every render because + // $forceUpdate is buffered by the scheduler. + context.$forceUpdate(); + }); + if (!Ctor) { + // return nothing if this is indeed an async component + // wait for the callback to trigger parent update. + return + } + } + } + + data = data || {}; + + // extract props + var propsData = extractProps(data, Ctor); + + // functional component + if (Ctor.options.functional) { + return createFunctionalComponent(Ctor, propsData, data, context, children) + } + + // extract listeners, since these needs to be treated as + // child component listeners instead of DOM listeners + var listeners = data.on; + // replace with listeners with .native modifier + data.on = data.nativeOn; + + if (Ctor.options.abstract) { + // abstract components do not keep anything + // other than props & listeners + data = {}; + } + + // merge component management hooks onto the placeholder node + mergeHooks(data); + + // return a placeholder vnode + var name = Ctor.options.name || tag; + var vnode = new VNode( + ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), + data, undefined, undefined, undefined, undefined, context, + { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children } + ); + return vnode +} + +function createFunctionalComponent ( + Ctor, + propsData, + data, + context, + children +) { + var props = {}; + var propOptions = Ctor.options.props; + if (propOptions) { + for (var key in propOptions) { + props[key] = validateProp(key, propOptions, propsData); + } + } + var vnode = Ctor.options.render.call( + null, + // ensure the createElement function in functional components + // gets a unique context - this is necessary for correct named slot check + bind$1(createElement, { _self: Object.create(context) }), + { + props: props, + data: data, + parent: context, + children: normalizeChildren(children), + slots: function () { return resolveSlots(children, context); } + } + ); + if (vnode instanceof VNode) { + vnode.functionalContext = context; + if (data.slot) { + (vnode.data || (vnode.data = {})).slot = data.slot; + } + } + return vnode +} + +function createComponentInstanceForVnode ( + vnode, // we know it's MountedComponentVNode but flow doesn't + parent // activeInstance in lifecycle state +) { + var vnodeComponentOptions = vnode.componentOptions; + var options = { + _isComponent: true, + parent: parent, + propsData: vnodeComponentOptions.propsData, + _componentTag: vnodeComponentOptions.tag, + _parentVnode: vnode, + _parentListeners: vnodeComponentOptions.listeners, + _renderChildren: vnodeComponentOptions.children + }; + // check inline-template render functions + var inlineTemplate = vnode.data.inlineTemplate; + if (inlineTemplate) { + options.render = inlineTemplate.render; + options.staticRenderFns = inlineTemplate.staticRenderFns; + } + return new vnodeComponentOptions.Ctor(options) +} + +function init (vnode, hydrating) { + if (!vnode.child || vnode.child._isDestroyed) { + var child = vnode.child = createComponentInstanceForVnode(vnode, activeInstance); + child.$mount(hydrating ? vnode.elm : undefined, hydrating); + } +} + +function prepatch ( + oldVnode, + vnode +) { + var options = vnode.componentOptions; + var child = vnode.child = oldVnode.child; + child._updateFromParent( + options.propsData, // updated props + options.listeners, // updated listeners + vnode, // new parent vnode + options.children // new children + ); +} + +function insert (vnode) { + if (!vnode.child._isMounted) { + vnode.child._isMounted = true; + callHook(vnode.child, 'mounted'); + } + if (vnode.data.keepAlive) { + vnode.child._inactive = false; + callHook(vnode.child, 'activated'); + } +} + +function destroy$1 (vnode) { + if (!vnode.child._isDestroyed) { + if (!vnode.data.keepAlive) { + vnode.child.$destroy(); + } else { + vnode.child._inactive = true; + callHook(vnode.child, 'deactivated'); } - - // cater for pre-defined getter/setters - var getter = property && property.get; - var setter = property && property.set; - - var childOb = observe(val); - Object.defineProperty(obj, key, { - enumerable: true, - configurable: true, - get: function reactiveGetter() { - var value = getter ? getter.call(obj) : val; - if (Dep.target) { - dep.depend(); - if (childOb) { - childOb.dep.depend(); - } - if (isArray(value)) { - for (var e, i = 0, l = value.length; i < l; i++) { - e = value[i]; - e && e.__ob__ && e.__ob__.dep.depend(); - } - } - } - return value; - }, - set: function reactiveSetter(newVal) { - var value = getter ? getter.call(obj) : val; - if (newVal === value) { - return; - } - if (setter) { - setter.call(obj, newVal); - } else { - val = newVal; - } - childOb = observe(newVal); - dep.notify(); - } - }); } +} - - - var util = Object.freeze({ - defineReactive: defineReactive, - set: set, - del: del, - hasOwn: hasOwn, - isLiteral: isLiteral, - isReserved: isReserved, - _toString: _toString, - toNumber: toNumber, - toBoolean: toBoolean, - stripQuotes: stripQuotes, - camelize: camelize, - hyphenate: hyphenate, - classify: classify, - bind: bind, - toArray: toArray, - extend: extend, - isObject: isObject, - isPlainObject: isPlainObject, - def: def, - debounce: _debounce, - indexOf: indexOf, - cancellable: cancellable, - looseEqual: looseEqual, - isArray: isArray, - hasProto: hasProto, - inBrowser: inBrowser, - devtools: devtools, - isIE: isIE, - isIE9: isIE9, - isAndroid: isAndroid, - isIos: isIos, - iosVersionMatch: iosVersionMatch, - iosVersion: iosVersion, - hasMutationObserverBug: hasMutationObserverBug, - get transitionProp () { return transitionProp; }, - get transitionEndEvent () { return transitionEndEvent; }, - get animationProp () { return animationProp; }, - get animationEndEvent () { return animationEndEvent; }, - nextTick: nextTick, - get _Set () { return _Set; }, - query: query, - inDoc: inDoc, - getAttr: getAttr, - getBindAttr: getBindAttr, - hasBindAttr: hasBindAttr, - before: before, - after: after, - remove: remove, - prepend: prepend, - replace: replace, - on: on, - off: off, - setClass: setClass, - addClass: addClass, - removeClass: removeClass, - extractContent: extractContent, - trimNode: trimNode, - isTemplate: isTemplate, - createAnchor: createAnchor, - findRef: findRef, - mapNodeRange: mapNodeRange, - removeNodeRange: removeNodeRange, - isFragment: isFragment, - getOuterHTML: getOuterHTML, - mergeOptions: mergeOptions, - resolveAsset: resolveAsset, - checkComponentAttr: checkComponentAttr, - commonTagRE: commonTagRE, - reservedTagRE: reservedTagRE, - get warn () { return warn; } - }); - - var uid = 0; - - function initMixin (Vue) { - /** - * The main init sequence. This is called for every - * instance, including ones that are created from extended - * constructors. - * - * @param {Object} options - this options object should be - * the result of merging class - * options and the options passed - * in to the constructor. - */ - - Vue.prototype._init = function (options) { - options = options || {}; - - this.$el = null; - this.$parent = options.parent; - this.$root = this.$parent ? this.$parent.$root : this; - this.$children = []; - this.$refs = {}; // child vm references - this.$els = {}; // element references - this._watchers = []; // all watchers as an array - this._directives = []; // all directives - - // a uid - this._uid = uid++; - - // a flag to avoid this being observed - this._isVue = true; - - // events bookkeeping - this._events = {}; // registered callbacks - this._eventsCount = {}; // for $broadcast optimization - - // fragment instance properties - this._isFragment = false; - this._fragment = // @type {DocumentFragment} - this._fragmentStart = // @type {Text|Comment} - this._fragmentEnd = null; // @type {Text|Comment} - - // lifecycle state - this._isCompiled = this._isDestroyed = this._isReady = this._isAttached = this._isBeingDestroyed = this._vForRemoving = false; - this._unlinkFn = null; - - // context: - // if this is a transcluded component, context - // will be the common parent vm of this instance - // and its host. - this._context = options._context || this.$parent; - - // scope: - // if this is inside an inline v-for, the scope - // will be the intermediate scope created for this - // repeat fragment. this is used for linking props - // and container directives. - this._scope = options._scope; - - // fragment: - // if this instance is compiled inside a Fragment, it - // needs to reigster itself as a child of that fragment - // for attach/detach to work properly. - this._frag = options._frag; - if (this._frag) { - this._frag.children.push(this); - } - - // push self into parent / transclusion host - if (this.$parent) { - this.$parent.$children.push(this); - } - - // merge options. - options = this.$options = mergeOptions(this.constructor.options, options, this); - - // set ref - this._updateRef(); - - // initialize data as empty object. - // it will be filled up in _initData(). - this._data = {}; - - // call init hook - this._callHook('init'); - - // initialize data observation and scope inheritance. - this._initState(); - - // setup event system and option events. - this._initEvents(); - - // call created hook - this._callHook('created'); - - // if `el` option is passed, start compilation. - if (options.el) { - this.$mount(options.el); +function resolveAsyncComponent ( + factory, + cb +) { + if (factory.requested) { + // pool callbacks + factory.pendingCallbacks.push(cb); + } else { + factory.requested = true; + var cbs = factory.pendingCallbacks = [cb]; + var sync = true; + + var resolve = function (res) { + if (isObject(res)) { + res = Vue$3.extend(res); + } + // cache resolved + factory.resolved = res; + // invoke callbacks only if this is not a synchronous resolve + // (async resolves are shimmed as synchronous during SSR) + if (!sync) { + for (var i = 0, l = cbs.length; i < l; i++) { + cbs[i](res); + } } }; - } - - var pathCache = new Cache(1000); - - // actions - var APPEND = 0; - var PUSH = 1; - var INC_SUB_PATH_DEPTH = 2; - var PUSH_SUB_PATH = 3; - - // states - var BEFORE_PATH = 0; - var IN_PATH = 1; - var BEFORE_IDENT = 2; - var IN_IDENT = 3; - var IN_SUB_PATH = 4; - var IN_SINGLE_QUOTE = 5; - var IN_DOUBLE_QUOTE = 6; - var AFTER_PATH = 7; - var ERROR = 8; - - var pathStateMachine = []; - - pathStateMachine[BEFORE_PATH] = { - 'ws': [BEFORE_PATH], - 'ident': [IN_IDENT, APPEND], - '[': [IN_SUB_PATH], - 'eof': [AFTER_PATH] - }; - pathStateMachine[IN_PATH] = { - 'ws': [IN_PATH], - '.': [BEFORE_IDENT], - '[': [IN_SUB_PATH], - 'eof': [AFTER_PATH] - }; - - pathStateMachine[BEFORE_IDENT] = { - 'ws': [BEFORE_IDENT], - 'ident': [IN_IDENT, APPEND] - }; - - pathStateMachine[IN_IDENT] = { - 'ident': [IN_IDENT, APPEND], - '0': [IN_IDENT, APPEND], - 'number': [IN_IDENT, APPEND], - 'ws': [IN_PATH, PUSH], - '.': [BEFORE_IDENT, PUSH], - '[': [IN_SUB_PATH, PUSH], - 'eof': [AFTER_PATH, PUSH] - }; - - pathStateMachine[IN_SUB_PATH] = { - "'": [IN_SINGLE_QUOTE, APPEND], - '"': [IN_DOUBLE_QUOTE, APPEND], - '[': [IN_SUB_PATH, INC_SUB_PATH_DEPTH], - ']': [IN_PATH, PUSH_SUB_PATH], - 'eof': ERROR, - 'else': [IN_SUB_PATH, APPEND] - }; - - pathStateMachine[IN_SINGLE_QUOTE] = { - "'": [IN_SUB_PATH, APPEND], - 'eof': ERROR, - 'else': [IN_SINGLE_QUOTE, APPEND] - }; - - pathStateMachine[IN_DOUBLE_QUOTE] = { - '"': [IN_SUB_PATH, APPEND], - 'eof': ERROR, - 'else': [IN_DOUBLE_QUOTE, APPEND] - }; - - /** - * Determine the type of a character in a keypath. - * - * @param {Char} ch - * @return {String} type - */ - - function getPathCharType(ch) { - if (ch === undefined) { - return 'eof'; - } - - var code = ch.charCodeAt(0); - - switch (code) { - case 0x5B: // [ - case 0x5D: // ] - case 0x2E: // . - case 0x22: // " - case 0x27: // ' - case 0x30: - // 0 - return ch; - - case 0x5F: // _ - case 0x24: - // $ - return 'ident'; + var reject = function (reason) { + "development" !== 'production' && warn( + "Failed to resolve async component: " + (String(factory)) + + (reason ? ("\nReason: " + reason) : '') + ); + }; - case 0x20: // Space - case 0x09: // Tab - case 0x0A: // Newline - case 0x0D: // Return - case 0xA0: // No-break space - case 0xFEFF: // Byte Order Mark - case 0x2028: // Line Separator - case 0x2029: - // Paragraph Separator - return 'ws'; + var res = factory(resolve, reject); + + // handle promise + if (res && typeof res.then === 'function' && !factory.resolved) { + res.then(resolve, reject); + } + + sync = false; + // return in case resolved synchronously + return factory.resolved + } +} + +function extractProps (data, Ctor) { + // we are only extrating raw values here. + // validation and default values are handled in the child + // component itself. + var propOptions = Ctor.options.props; + if (!propOptions) { + return + } + var res = {}; + var attrs = data.attrs; + var props = data.props; + var domProps = data.domProps; + if (attrs || props || domProps) { + for (var key in propOptions) { + var altKey = hyphenate(key); + checkProp(res, props, key, altKey, true) || + checkProp(res, attrs, key, altKey) || + checkProp(res, domProps, key, altKey); + } + } + return res +} + +function checkProp ( + res, + hash, + key, + altKey, + preserve +) { + if (hash) { + if (hasOwn(hash, key)) { + res[key] = hash[key]; + if (!preserve) { + delete hash[key]; + } + return true + } else if (hasOwn(hash, altKey)) { + res[key] = hash[altKey]; + if (!preserve) { + delete hash[altKey]; + } + return true + } + } + return false +} + +function mergeHooks (data) { + if (!data.hook) { + data.hook = {}; + } + for (var i = 0; i < hooksToMerge.length; i++) { + var key = hooksToMerge[i]; + var fromParent = data.hook[key]; + var ours = hooks[key]; + data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours; + } +} + +function mergeHook$1 (a, b) { + // since all hooks have at most two args, use fixed args + // to avoid having to use fn.apply(). + return function (_, __) { + a(_, __); + b(_, __); + } +} + +/* */ + +// wrapper function for providing a more flexible interface +// without getting yelled at by flow +function createElement ( + tag, + data, + children +) { + if (data && (Array.isArray(data) || typeof data !== 'object')) { + children = data; + data = undefined; + } + // make sure to use real instance instead of proxy as context + return _createElement(this._self, tag, data, children) +} + +function _createElement ( + context, + tag, + data, + children +) { + if (data && data.__ob__) { + "development" !== 'production' && warn( + "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + + 'Always create fresh vnode data objects in each render!', + context + ); + return + } + if (!tag) { + // in case of component :is set to falsy value + return emptyVNode() + } + if (typeof tag === 'string') { + var Ctor; + var ns = config.getTagNamespace(tag); + if (config.isReservedTag(tag)) { + // platform built-in elements + return new VNode( + tag, data, normalizeChildren(children, ns), + undefined, undefined, ns, context + ) + } else if ((Ctor = resolveAsset(context.$options, 'components', tag))) { + // component + return createComponent(Ctor, data, context, children, tag) + } else { + // unknown or unlisted namespaced elements + // check at runtime because it may get assigned a namespace when its + // parent normalizes children + return new VNode( + tag, data, normalizeChildren(children, ns), + undefined, undefined, ns, context + ) } + } else { + // direct component options / constructor + return createComponent(tag, data, context, children) + } +} + +/* */ + +function initRender (vm) { + vm.$vnode = null; // the placeholder node in parent tree + vm._vnode = null; // the root of the child tree + vm._staticTrees = null; + vm._renderContext = vm.$options._parentVnode && vm.$options._parentVnode.context; + vm.$slots = resolveSlots(vm.$options._renderChildren, vm._renderContext); + // bind the public createElement fn to this instance + // so that we get proper render context inside it. + vm.$createElement = bind$1(createElement, vm); + if (vm.$options.el) { + vm.$mount(vm.$options.el); + } +} + +function renderMixin (Vue) { + Vue.prototype.$nextTick = function (fn) { + nextTick(fn, this); + }; - // a-z, A-Z - if (code >= 0x61 && code <= 0x7A || code >= 0x41 && code <= 0x5A) { - return 'ident'; - } + Vue.prototype._render = function () { + var vm = this; + var ref = vm.$options; + var render = ref.render; + var staticRenderFns = ref.staticRenderFns; + var _parentVnode = ref._parentVnode; - // 1-9 - if (code >= 0x31 && code <= 0x39) { - return 'number'; + if (vm._isMounted) { + // clone slot nodes on re-renders + for (var key in vm.$slots) { + vm.$slots[key] = cloneVNodes(vm.$slots[key]); + } } - return 'else'; - } - - /** - * Format a subPath, return its plain form if it is - * a literal string or number. Otherwise prepend the - * dynamic indicator (*). - * - * @param {String} path - * @return {String} - */ - - function formatSubPath(path) { - var trimmed = path.trim(); - // invalid leading 0 - if (path.charAt(0) === '0' && isNaN(path)) { - return false; + if (staticRenderFns && !vm._staticTrees) { + vm._staticTrees = []; } - return isLiteral(trimmed) ? stripQuotes(trimmed) : '*' + trimmed; - } - - /** - * Parse a string path into an array of segments - * - * @param {String} path - * @return {Array|undefined} - */ - - function parse(path) { - var keys = []; - var index = -1; - var mode = BEFORE_PATH; - var subPathDepth = 0; - var c, newChar, key, type, transition, action, typeMap; - - var actions = []; - - actions[PUSH] = function () { - if (key !== undefined) { - keys.push(key); - key = undefined; - } - }; - - actions[APPEND] = function () { - if (key === undefined) { - key = newChar; - } else { - key += newChar; + // set parent vnode. this allows render functions to have access + // to the data on the placeholder node. + vm.$vnode = _parentVnode; + // render self + var vnode; + try { + vnode = render.call(vm._renderProxy, vm.$createElement); + } catch (e) { + { + warn(("Error when rendering " + (formatComponentName(vm)) + ":")); } - }; - - actions[INC_SUB_PATH_DEPTH] = function () { - actions[APPEND](); - subPathDepth++; - }; - - actions[PUSH_SUB_PATH] = function () { - if (subPathDepth > 0) { - subPathDepth--; - mode = IN_SUB_PATH; - actions[APPEND](); + /* istanbul ignore else */ + if (config.errorHandler) { + config.errorHandler.call(null, e, vm); } else { - subPathDepth = 0; - key = formatSubPath(key); - if (key === false) { - return false; + if (config._isServer) { + throw e } else { - actions[PUSH](); + setTimeout(function () { throw e }, 0); } } - }; - - function maybeUnescapeQuote() { - var nextChar = path[index + 1]; - if (mode === IN_SINGLE_QUOTE && nextChar === "'" || mode === IN_DOUBLE_QUOTE && nextChar === '"') { - index++; - newChar = '\\' + nextChar; - actions[APPEND](); - return true; - } + // return previous vnode to prevent render error causing blank component + vnode = vm._vnode; } - - while (mode != null) { - index++; - c = path[index]; - - if (c === '\\' && maybeUnescapeQuote()) { - continue; - } - - type = getPathCharType(c); - typeMap = pathStateMachine[mode]; - transition = typeMap[type] || typeMap['else'] || ERROR; - - if (transition === ERROR) { - return; // parse error + // return empty vnode in case the render function errored out + if (!(vnode instanceof VNode)) { + if ("development" !== 'production' && Array.isArray(vnode)) { + warn( + 'Multiple root nodes returned from render function. Render function ' + + 'should return a single root node.', + vm + ); } + vnode = emptyVNode(); + } + // set parent + vnode.parent = _parentVnode; + return vnode + }; - mode = transition[0]; - action = actions[transition[1]]; - if (action) { - newChar = transition[2]; - newChar = newChar === undefined ? c : newChar; - if (action() === false) { - return; + // shorthands used in render functions + Vue.prototype._h = createElement; + // toString for mustaches + Vue.prototype._s = _toString; + // number conversion + Vue.prototype._n = toNumber; + // empty vnode + Vue.prototype._e = emptyVNode; + // loose equal + Vue.prototype._q = looseEqual; + // loose indexOf + Vue.prototype._i = looseIndexOf; + + // render static tree by index + Vue.prototype._m = function renderStatic ( + index, + isInFor + ) { + var tree = this._staticTrees[index]; + // if has already-rendered static tree and not inside v-for, + // we can reuse the same tree by doing a shallow clone. + if (tree && !isInFor) { + return Array.isArray(tree) + ? cloneVNodes(tree) + : cloneVNode(tree) + } + // otherwise, render a fresh tree. + tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy); + if (Array.isArray(tree)) { + for (var i = 0; i < tree.length; i++) { + if (typeof tree[i] !== 'string') { + tree[i].isStatic = true; + tree[i].key = "__static__" + index + "_" + i; } } - - if (mode === AFTER_PATH) { - keys.raw = path; - return keys; - } + } else { + tree.isStatic = true; + tree.key = "__static__" + index; } - } + return tree + }; - /** - * External parse that check for a cache hit first - * - * @param {String} path - * @return {Array|undefined} - */ + // filter resolution helper + var identity = function (_) { return _; }; + Vue.prototype._f = function resolveFilter (id) { + return resolveAsset(this.$options, 'filters', id, true) || identity + }; - function parsePath(path) { - var hit = pathCache.get(path); - if (!hit) { - hit = parse(path); - if (hit) { - pathCache.put(path, hit); + // render v-for + Vue.prototype._l = function renderList ( + val, + render + ) { + var ret, i, l, keys, key; + if (Array.isArray(val)) { + ret = new Array(val.length); + for (i = 0, l = val.length; i < l; i++) { + ret[i] = render(val[i], i); + } + } else if (typeof val === 'number') { + ret = new Array(val); + for (i = 0; i < val; i++) { + ret[i] = render(i + 1, i); + } + } else if (isObject(val)) { + keys = Object.keys(val); + ret = new Array(keys.length); + for (i = 0, l = keys.length; i < l; i++) { + key = keys[i]; + ret[i] = render(val[key], key, i); } } - return hit; - } - - /** - * Get from an object from a path string - * - * @param {Object} obj - * @param {String} path - */ - - function getPath(obj, path) { - return parseExpression(path).get(obj); - } - - /** - * Warn against setting non-existent root path on a vm. - */ - - var warnNonExistent; - if ('development' !== 'production') { - warnNonExistent = function (path, vm) { - warn('You are setting a non-existent path "' + path.raw + '" ' + 'on a vm instance. Consider pre-initializing the property ' + 'with the "data" option for more reliable reactivity ' + 'and better performance.', vm); - }; - } + return ret + }; - /** - * Set on an object from a path - * - * @param {Object} obj - * @param {String | Array} path - * @param {*} val - */ + // renderSlot + Vue.prototype._t = function ( + name, + fallback + ) { + var slotNodes = this.$slots[name]; + // warn duplicate slot usage + if (slotNodes && "development" !== 'production') { + slotNodes._rendered && warn( + "Duplicate presence of slot \"" + name + "\" found in the same render tree " + + "- this will likely cause render errors.", + this + ); + slotNodes._rendered = true; + } + return slotNodes || fallback + }; - function setPath(obj, path, val) { - var original = obj; - if (typeof path === 'string') { - path = parse(path); - } - if (!path || !isObject(obj)) { - return false; - } - var last, key; - for (var i = 0, l = path.length; i < l; i++) { - last = obj; - key = path[i]; - if (key.charAt(0) === '*') { - key = parseExpression(key.slice(1)).get.call(original, original); - } - if (i < l - 1) { - obj = obj[key]; - if (!isObject(obj)) { - obj = {}; - if ('development' !== 'production' && last._isVue) { - warnNonExistent(path, last); - } - set(last, key, obj); - } + // apply v-bind object + Vue.prototype._b = function bindProps ( + data, + value, + asProp + ) { + if (value) { + if (!isObject(value)) { + "development" !== 'production' && warn( + 'v-bind without argument expects an Object or Array value', + this + ); } else { - if (isArray(obj)) { - obj.$set(key, val); - } else if (key in obj) { - obj[key] = val; - } else { - if ('development' !== 'production' && obj._isVue) { - warnNonExistent(path, obj); + if (Array.isArray(value)) { + value = toObject(value); + } + for (var key in value) { + if (key === 'class' || key === 'style') { + data[key] = value[key]; + } else { + var hash = asProp || config.mustUseProp(key) + ? data.domProps || (data.domProps = {}) + : data.attrs || (data.attrs = {}); + hash[key] = value[key]; } - set(obj, key, val); } } } - return true; - } - -var path = Object.freeze({ - parsePath: parsePath, - getPath: getPath, - setPath: setPath - }); - - var expressionCache = new Cache(1000); - - var allowedKeywords = 'Math,Date,this,true,false,null,undefined,Infinity,NaN,' + 'isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,' + 'encodeURIComponent,parseInt,parseFloat'; - var allowedKeywordsRE = new RegExp('^(' + allowedKeywords.replace(/,/g, '\\b|') + '\\b)'); - - // keywords that don't make sense inside expressions - 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'; - var improperKeywordsRE = new RegExp('^(' + improperKeywords.replace(/,/g, '\\b|') + '\\b)'); - - var wsRE = /\s/g; - var newlineRE = /\n/g; - var saveRE = /[\{,]\s*[\w\$_]+\s*:|('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`)|new |typeof |void /g; - var restoreRE = /"(\d+)"/g; - var pathTestRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/; - var identRE = /[^\w$\.](?:[A-Za-z_$][\w$]*)/g; - var literalValueRE$1 = /^(?:true|false|null|undefined|Infinity|NaN)$/; - - function noop() {} - - /** - * Save / Rewrite / Restore - * - * When rewriting paths found in an expression, it is - * possible for the same letter sequences to be found in - * strings and Object literal property keys. Therefore we - * remove and store these parts in a temporary array, and - * restore them after the path rewrite. - */ - - var saved = []; - - /** - * Save replacer - * - * The save regex can match two possible cases: - * 1. An opening object literal - * 2. A string - * If matched as a plain string, we need to escape its - * newlines, since the string needs to be preserved when - * generating the function body. - * - * @param {String} str - * @param {String} isString - str if matched as a string - * @return {String} - placeholder with index - */ - - function save(str, isString) { - var i = saved.length; - saved[i] = isString ? str.replace(newlineRE, '\\n') : str; - return '"' + i + '"'; - } - - /** - * Path rewrite replacer - * - * @param {String} raw - * @return {String} - */ + return data + }; - function rewrite(raw) { - var c = raw.charAt(0); - var path = raw.slice(1); - if (allowedKeywordsRE.test(path)) { - return raw; + // expose v-on keyCodes + Vue.prototype._k = function getKeyCodes (key) { + return config.keyCodes[key] + }; +} + +function resolveSlots ( + renderChildren, + context +) { + var slots = {}; + if (!renderChildren) { + return slots + } + var children = normalizeChildren(renderChildren) || []; + var defaultSlot = []; + var name, child; + for (var i = 0, l = children.length; i < l; i++) { + child = children[i]; + // named slots should only be respected if the vnode was rendered in the + // same context. + if ((child.context === context || child.functionalContext === context) && + child.data && (name = child.data.slot)) { + var slot = (slots[name] || (slots[name] = [])); + if (child.tag === 'template') { + slot.push.apply(slot, child.children); + } else { + slot.push(child); + } } else { - path = path.indexOf('"') > -1 ? path.replace(restoreRE, restore) : path; - return c + 'scope.' + path; + defaultSlot.push(child); } } - - /** - * Restore replacer - * - * @param {String} str - * @param {String} i - matched save index - * @return {String} - */ - - function restore(str, i) { - return saved[i]; + // ignore single whitespace + if (defaultSlot.length && !( + defaultSlot.length === 1 && + (defaultSlot[0].text === ' ' || defaultSlot[0].isComment) + )) { + slots.default = defaultSlot; } + return slots +} - /** - * Rewrite an expression, prefixing all path accessors with - * `scope.` and generate getter/setter functions. - * - * @param {String} exp - * @return {Function} - */ +/* */ - function compileGetter(exp) { - if (improperKeywordsRE.test(exp)) { - 'development' !== 'production' && warn('Avoid using reserved keywords in expression: ' + exp); - } - // reset state - saved.length = 0; - // save strings and object literal keys - var body = exp.replace(saveRE, save).replace(wsRE, ''); - // rewrite all paths - // pad 1 space here because the regex matches 1 extra char - body = (' ' + body).replace(identRE, rewrite).replace(restoreRE, restore); - return makeGetterFn(body); +function initEvents (vm) { + vm._events = Object.create(null); + // init parent attached events + var listeners = vm.$options._parentListeners; + var on = bind$1(vm.$on, vm); + var off = bind$1(vm.$off, vm); + vm._updateListeners = function (listeners, oldListeners) { + updateListeners(listeners, oldListeners || {}, on, off, vm); + }; + if (listeners) { + vm._updateListeners(listeners); } +} - /** - * Build a getter function. Requires eval. - * - * We isolate the try/catch so it doesn't affect the - * optimization of the parse function when it is not called. - * - * @param {String} body - * @return {Function|undefined} - */ +function eventsMixin (Vue) { + Vue.prototype.$on = function (event, fn) { + var vm = this;(vm._events[event] || (vm._events[event] = [])).push(fn); + return vm + }; - function makeGetterFn(body) { - try { - /* eslint-disable no-new-func */ - return new Function('scope', 'return ' + body + ';'); - /* eslint-enable no-new-func */ - } catch (e) { - if ('development' !== 'production') { - /* istanbul ignore if */ - if (e.toString().match(/unsafe-eval|CSP/)) { - warn('It seems you are using the default build of Vue.js in an environment ' + 'with Content Security Policy that prohibits unsafe-eval. ' + 'Use the CSP-compliant build instead: ' + 'http://vuejs.org/guide/installation.html#CSP-compliant-build'); - } else { - warn('Invalid expression. ' + 'Generated function body: ' + body); - } - } - return noop; + Vue.prototype.$once = function (event, fn) { + var vm = this; + function on () { + vm.$off(event, on); + fn.apply(vm, arguments); } - } - - /** - * Compile a setter function for the expression. - * - * @param {String} exp - * @return {Function|undefined} - */ + on.fn = fn; + vm.$on(event, on); + return vm + }; - function compileSetter(exp) { - var path = parsePath(exp); - if (path) { - return function (scope, val) { - setPath(scope, path, val); - }; - } else { - 'development' !== 'production' && warn('Invalid setter expression: ' + exp); + Vue.prototype.$off = function (event, fn) { + var vm = this; + // all + if (!arguments.length) { + vm._events = Object.create(null); + return vm + } + // specific event + var cbs = vm._events[event]; + if (!cbs) { + return vm + } + if (arguments.length === 1) { + vm._events[event] = null; + return vm + } + // specific handler + var cb; + var i = cbs.length; + while (i--) { + cb = cbs[i]; + if (cb === fn || cb.fn === fn) { + cbs.splice(i, 1); + break + } } - } - - /** - * Parse an expression into re-written getter/setters. - * - * @param {String} exp - * @param {Boolean} needSet - * @return {Function} - */ + return vm + }; - function parseExpression(exp, needSet) { - exp = exp.trim(); - // try cache - var hit = expressionCache.get(exp); - if (hit) { - if (needSet && !hit.set) { - hit.set = compileSetter(hit.exp); + Vue.prototype.$emit = function (event) { + var vm = this; + var cbs = vm._events[event]; + if (cbs) { + cbs = cbs.length > 1 ? toArray(cbs) : cbs; + var args = toArray(arguments, 1); + for (var i = 0, l = cbs.length; i < l; i++) { + cbs[i].apply(vm, args); } - return hit; } - var res = { exp: exp }; - res.get = isSimplePath(exp) && exp.indexOf('[') < 0 - // optimized super simple getter - ? makeGetterFn('scope.' + exp) - // dynamic getter - : compileGetter(exp); - if (needSet) { - res.set = compileSetter(exp); + return vm + }; +} + +/* */ + +var uid = 0; + +function initMixin (Vue) { + Vue.prototype._init = function (options) { + var vm = this; + // a uid + vm._uid = uid++; + // a flag to avoid this being observed + vm._isVue = true; + // merge options + if (options && options._isComponent) { + // optimize internal component instantiation + // since dynamic options merging is pretty slow, and none of the + // internal component options needs special treatment. + initInternalComponent(vm, options); + } else { + vm.$options = mergeOptions( + resolveConstructorOptions(vm), + options || {}, + vm + ); } - expressionCache.put(exp, res); - return res; - } - - /** - * Check if an expression is a simple path. - * - * @param {String} exp - * @return {Boolean} - */ - - function isSimplePath(exp) { - return pathTestRE.test(exp) && - // don't treat literal values as paths - !literalValueRE$1.test(exp) && - // Math constants e.g. Math.PI, Math.E etc. - exp.slice(0, 5) !== 'Math.'; - } - -var expression = Object.freeze({ - parseExpression: parseExpression, - isSimplePath: isSimplePath - }); - - // we have two separate queues: one for directive updates - // and one for user watcher registered via $watch(). - // we want to guarantee directive updates to be called - // before user watchers so that when user watchers are - // triggered, the DOM would have already been in updated - // state. - - var queue = []; - var userQueue = []; - var has = {}; - var circular = {}; - var waiting = false; - - /** - * Reset the batcher's state. - */ - - function resetBatcherState() { - queue.length = 0; - userQueue.length = 0; - has = {}; - circular = {}; - waiting = false; - } - - /** - * Flush both queues and run the watchers. - */ - - function flushBatcherQueue() { - var _again = true; - - _function: while (_again) { - _again = false; + /* istanbul ignore else */ + { + initProxy(vm); + } + // expose real self + vm._self = vm; + initLifecycle(vm); + initEvents(vm); + callHook(vm, 'beforeCreate'); + initState(vm); + callHook(vm, 'created'); + initRender(vm); + }; - runBatcherQueue(queue); - runBatcherQueue(userQueue); - // user watchers triggered more watchers, - // keep flushing until it depletes - if (queue.length) { - _again = true; - continue _function; - } - // dev tool hook - /* istanbul ignore if */ - if (devtools && config.devtools) { - devtools.emit('flush'); - } - resetBatcherState(); + function initInternalComponent (vm, options) { + var opts = vm.$options = Object.create(resolveConstructorOptions(vm)); + // doing this because it's faster than dynamic enumeration. + opts.parent = options.parent; + opts.propsData = options.propsData; + opts._parentVnode = options._parentVnode; + opts._parentListeners = options._parentListeners; + opts._renderChildren = options._renderChildren; + opts._componentTag = options._componentTag; + if (options.render) { + opts.render = options.render; + opts.staticRenderFns = options.staticRenderFns; } } - /** - * Run the watchers in a single queue. - * - * @param {Array} queue - */ - - function runBatcherQueue(queue) { - // do not cache length because more watchers might be pushed - // as we run existing watchers - for (var i = 0; i < queue.length; i++) { - var watcher = queue[i]; - var id = watcher.id; - has[id] = null; - watcher.run(); - // in dev build, check and stop circular updates. - if ('development' !== 'production' && has[id] != null) { - circular[id] = (circular[id] || 0) + 1; - if (circular[id] > config._maxUpdateCount) { - warn('You may have an infinite update loop for watcher ' + 'with expression "' + watcher.expression + '"', watcher.vm); - break; + function resolveConstructorOptions (vm) { + var Ctor = vm.constructor; + var options = Ctor.options; + if (Ctor.super) { + var superOptions = Ctor.super.options; + var cachedSuperOptions = Ctor.superOptions; + if (superOptions !== cachedSuperOptions) { + // super option changed + Ctor.superOptions = superOptions; + options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions); + if (options.name) { + options.components[options.name] = Ctor; } } } - queue.length = 0; + return options } +} - /** - * Push a watcher into the watcher queue. - * Jobs with duplicate IDs will be skipped unless it's - * pushed when the queue is being flushed. - * - * @param {Watcher} watcher - * properties: - * - {Number} id - * - {Function} run - */ - - function pushWatcher(watcher) { - var id = watcher.id; - if (has[id] == null) { - // push watcher into appropriate queue - var q = watcher.user ? userQueue : queue; - has[id] = q.length; - q.push(watcher); - // queue the flush - if (!waiting) { - waiting = true; - nextTick(flushBatcherQueue); - } - } - } - - var uid$2 = 0; - - /** - * A watcher parses an expression, collects dependencies, - * and fires callback when the expression value changes. - * This is used for both the $watch() api and directives. - * - * @param {Vue} vm - * @param {String|Function} expOrFn - * @param {Function} cb - * @param {Object} options - * - {Array} filters - * - {Boolean} twoWay - * - {Boolean} deep - * - {Boolean} user - * - {Boolean} sync - * - {Boolean} lazy - * - {Function} [preProcess] - * - {Function} [postProcess] - * @constructor - */ - function Watcher(vm, expOrFn, cb, options) { - // mix in options - if (options) { - extend(this, options); - } - var isFn = typeof expOrFn === 'function'; - this.vm = vm; - vm._watchers.push(this); - this.expression = expOrFn; - this.cb = cb; - this.id = ++uid$2; // uid for batching - this.active = true; - this.dirty = this.lazy; // for lazy watchers - this.deps = []; - this.newDeps = []; - this.depIds = new _Set(); - this.newDepIds = new _Set(); - this.prevError = null; // for async error stacks - // parse expression for getter/setter - if (isFn) { - this.getter = expOrFn; - this.setter = undefined; - } else { - var res = parseExpression(expOrFn, this.twoWay); - this.getter = res.get; - this.setter = res.set; - } - this.value = this.lazy ? undefined : this.get(); - // state for avoiding false triggers for deep and Array - // watchers during vm._digest() - this.queued = this.shallow = false; +function Vue$3 (options) { + if ("development" !== 'production' && + !(this instanceof Vue$3)) { + warn('Vue is a constructor and should be called with the `new` keyword'); } + this._init(options); +} - /** - * Evaluate the getter, and re-collect dependencies. - */ +initMixin(Vue$3); +stateMixin(Vue$3); +eventsMixin(Vue$3); +lifecycleMixin(Vue$3); +renderMixin(Vue$3); - Watcher.prototype.get = function () { - this.beforeGet(); - var scope = this.scope || this.vm; - var value; - try { - value = this.getter.call(scope, scope); - } catch (e) { - if ('development' !== 'production' && config.warnExpressionErrors) { - warn('Error when evaluating expression ' + '"' + this.expression + '": ' + e.toString(), this.vm); - } - } - // "touch" every property so they are all tracked as - // dependencies for deep watching - if (this.deep) { - traverse(value); - } - if (this.preProcess) { - value = this.preProcess(value); - } - if (this.filters) { - value = scope._applyFilters(value, null, this.filters, false); - } - if (this.postProcess) { - value = this.postProcess(value); - } - this.afterGet(); - return value; - }; +var warn = noop; +var formatComponentName; - /** - * Set the corresponding value with the setter. - * - * @param {*} value - */ +{ + var hasConsole = typeof console !== 'undefined'; - Watcher.prototype.set = function (value) { - var scope = this.scope || this.vm; - if (this.filters) { - value = scope._applyFilters(value, this.value, this.filters, true); - } - try { - this.setter.call(scope, scope, value); - } catch (e) { - if ('development' !== 'production' && config.warnExpressionErrors) { - warn('Error when evaluating setter ' + '"' + this.expression + '": ' + e.toString(), this.vm); - } - } - // two-way sync for v-for alias - var forContext = scope.$forContext; - if (forContext && forContext.alias === this.expression) { - if (forContext.filters) { - 'development' !== '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); - return; - } - forContext._withLock(function () { - if (scope.$key) { - // original is an object - forContext.rawValue[scope.$key] = value; - } else { - forContext.rawValue.$set(scope.$index, value); - } - }); + warn = function (msg, vm) { + if (hasConsole && (!config.silent)) { + console.error("[Vue warn]: " + msg + " " + ( + vm ? formatLocation(formatComponentName(vm)) : '' + )); } }; - /** - * Prepare for dependency collection. - */ - - Watcher.prototype.beforeGet = function () { - Dep.target = this; + formatComponentName = function (vm) { + if (vm.$root === vm) { + return 'root instance' + } + var name = vm._isVue + ? vm.$options.name || vm.$options._componentTag + : vm.name; + return ( + (name ? ("component <" + name + ">") : "anonymous component") + + (vm._isVue && vm.$options.__file ? (" at " + (vm.$options.__file)) : '') + ) }; - /** - * Add a dependency to this directive. - * - * @param {Dep} dep - */ - - Watcher.prototype.addDep = function (dep) { - var id = dep.id; - if (!this.newDepIds.has(id)) { - this.newDepIds.add(id); - this.newDeps.push(dep); - if (!this.depIds.has(id)) { - dep.addSub(this); - } + var formatLocation = function (str) { + if (str === 'anonymous component') { + str += " - use the \"name\" option for better debugging messages."; } + return ("\n(found in " + str + ")") }; +} - /** - * Clean up for dependency collection. - */ - - Watcher.prototype.afterGet = function () { - Dep.target = null; - var i = this.deps.length; - while (i--) { - var dep = this.deps[i]; - if (!this.newDepIds.has(dep.id)) { - dep.removeSub(this); - } - } - var tmp = this.depIds; - this.depIds = this.newDepIds; - this.newDepIds = tmp; - this.newDepIds.clear(); - tmp = this.deps; - this.deps = this.newDeps; - this.newDeps = tmp; - this.newDeps.length = 0; - }; +/* */ - /** - * Subscriber interface. - * Will be called when a dependency changes. - * - * @param {Boolean} shallow - */ +/** + * Option overwriting strategies are functions that handle + * how to merge a parent option value and a child option + * value into the final value. + */ +var strats = config.optionMergeStrategies; - Watcher.prototype.update = function (shallow) { - if (this.lazy) { - this.dirty = true; - } else if (this.sync || !config.async) { - this.run(); - } else { - // if queued, only overwrite shallow with non-shallow, - // but not the other way around. - this.shallow = this.queued ? shallow ? this.shallow : false : !!shallow; - this.queued = true; - // record before-push error stack in debug mode - /* istanbul ignore if */ - if ('development' !== 'production' && config.debug) { - this.prevError = new Error('[vue] async stack trace'); - } - pushWatcher(this); +/** + * Options with restrictions + */ +{ + strats.el = strats.propsData = function (parent, child, vm, key) { + if (!vm) { + warn( + "option \"" + key + "\" can only be used during instance " + + 'creation with the `new` keyword.' + ); } + return defaultStrat(parent, child) }; +} - /** - * Batcher job interface. - * Will be called by the batcher. - */ - - Watcher.prototype.run = function () { - if (this.active) { - var value = this.get(); - if (value !== this.value || - // Deep watchers and watchers on Object/Arrays should fire even - // when the value is the same, because the value may - // have mutated; but only do so if this is a - // non-shallow update (caused by a vm digest). - (isObject(value) || this.deep) && !this.shallow) { - // set new value - var oldValue = this.value; - this.value = value; - // in debug + async mode, when a watcher callbacks - // throws, we also throw the saved before-push error - // so the full cross-tick stack trace is available. - var prevError = this.prevError; - /* istanbul ignore if */ - if ('development' !== 'production' && config.debug && prevError) { - this.prevError = null; - try { - this.cb.call(this.vm, value, oldValue); - } catch (e) { - nextTick(function () { - throw prevError; - }, 0); - throw e; - } - } else { - this.cb.call(this.vm, value, oldValue); - } +/** + * Helper that recursively merges two data objects together. + */ +function mergeData (to, from) { + var key, toVal, fromVal; + for (key in from) { + toVal = to[key]; + fromVal = from[key]; + if (!hasOwn(to, key)) { + set(to, key, fromVal); + } else if (isObject(toVal) && isObject(fromVal)) { + mergeData(toVal, fromVal); + } + } + return to +} + +/** + * Data + */ +strats.data = function ( + parentVal, + childVal, + vm +) { + if (!vm) { + // in a Vue.extend merge, both should be functions + if (!childVal) { + return parentVal + } + if (typeof childVal !== 'function') { + "development" !== 'production' && warn( + 'The "data" option should be a function ' + + 'that returns a per-instance value in component ' + + 'definitions.', + vm + ); + return parentVal + } + if (!parentVal) { + return childVal + } + // when parentVal & childVal are both present, + // we need to return a function that returns the + // merged result of both functions... no need to + // check if parentVal is a function here because + // it has to be a function to pass previous merges. + return function mergedDataFn () { + return mergeData( + childVal.call(this), + parentVal.call(this) + ) + } + } else if (parentVal || childVal) { + return function mergedInstanceDataFn () { + // instance merge + var instanceData = typeof childVal === 'function' + ? childVal.call(vm) + : childVal; + var defaultData = typeof parentVal === 'function' + ? parentVal.call(vm) + : undefined; + if (instanceData) { + return mergeData(instanceData, defaultData) + } else { + return defaultData } - this.queued = this.shallow = false; } - }; - - /** - * Evaluate the value of the watcher. - * This only gets called for lazy watchers. - */ - - Watcher.prototype.evaluate = function () { - // avoid overwriting another watcher that is being - // collected. - var current = Dep.target; - this.value = this.get(); - this.dirty = false; - Dep.target = current; - }; - - /** - * Depend on all deps collected by this watcher. - */ - - Watcher.prototype.depend = function () { - var i = this.deps.length; - while (i--) { - this.deps[i].depend(); - } - }; - - /** - * Remove self from all dependencies' subcriber list. - */ + } +}; - Watcher.prototype.teardown = function () { - if (this.active) { - // remove self from vm's watcher list - // this is a somewhat expensive operation so we skip it - // if the vm is being destroyed or is performing a v-for - // re-render (the watcher list is then filtered by v-for). - if (!this.vm._isBeingDestroyed && !this.vm._vForRemoving) { - this.vm._watchers.$remove(this); +/** + * Hooks and param attributes are merged as arrays. + */ +function mergeHook ( + parentVal, + childVal +) { + return childVal + ? parentVal + ? parentVal.concat(childVal) + : Array.isArray(childVal) + ? childVal + : [childVal] + : parentVal +} + +config._lifecycleHooks.forEach(function (hook) { + strats[hook] = mergeHook; +}); + +/** + * Assets + * + * When a vm is present (instance creation), we need to do + * a three-way merge between constructor options, instance + * options and parent options. + */ +function mergeAssets (parentVal, childVal) { + var res = Object.create(parentVal || null); + return childVal + ? extend(res, childVal) + : res +} + +config._assetTypes.forEach(function (type) { + strats[type + 's'] = mergeAssets; +}); + +/** + * Watchers. + * + * Watchers hashes should not overwrite one + * another, so we merge them as arrays. + */ +strats.watch = function (parentVal, childVal) { + /* istanbul ignore if */ + if (!childVal) { return parentVal } + if (!parentVal) { return childVal } + var ret = {}; + extend(ret, parentVal); + for (var key in childVal) { + var parent = ret[key]; + var child = childVal[key]; + if (parent && !Array.isArray(parent)) { + parent = [parent]; + } + ret[key] = parent + ? parent.concat(child) + : [child]; + } + return ret +}; + +/** + * Other object hashes. + */ +strats.props = +strats.methods = +strats.computed = function (parentVal, childVal) { + if (!childVal) { return parentVal } + if (!parentVal) { return childVal } + var ret = Object.create(null); + extend(ret, parentVal); + extend(ret, childVal); + return ret +}; + +/** + * Default strategy. + */ +var defaultStrat = function (parentVal, childVal) { + return childVal === undefined + ? parentVal + : childVal +}; + +/** + * Make sure component options get converted to actual + * constructors. + */ +function normalizeComponents (options) { + if (options.components) { + var components = options.components; + var def; + for (var key in components) { + var lower = key.toLowerCase(); + if (isBuiltInTag(lower) || config.isReservedTag(lower)) { + "development" !== 'production' && warn( + 'Do not use built-in or reserved HTML elements as component ' + + 'id: ' + key + ); + continue } - var i = this.deps.length; - while (i--) { - this.deps[i].removeSub(this); + def = components[key]; + if (isPlainObject(def)) { + components[key] = Vue$3.extend(def); } - this.active = false; - this.vm = this.cb = this.value = null; } - }; - - /** - * Recrusively traverse an object to evoke all converted - * getters, so that every nested property inside the object - * is collected as a "deep" dependency. - * - * @param {*} val - */ + } +} - var seenObjects = new _Set(); - function traverse(val, seen) { - var i = undefined, - keys = undefined; - if (!seen) { - seen = seenObjects; - seen.clear(); - } - var isA = isArray(val); - var isO = isObject(val); - if ((isA || isO) && Object.isExtensible(val)) { - if (val.__ob__) { - var depId = val.__ob__.dep.id; - if (seen.has(depId)) { - return; - } else { - seen.add(depId); - } - } - if (isA) { - i = val.length; - while (i--) traverse(val[i], seen); - } else if (isO) { - keys = Object.keys(val); - i = keys.length; - while (i--) traverse(val[keys[i]], seen); +/** + * Ensure all props option syntax are normalized into the + * Object-based format. + */ +function normalizeProps (options) { + var props = options.props; + if (!props) { return } + var res = {}; + var i, val, name; + if (Array.isArray(props)) { + i = props.length; + while (i--) { + val = props[i]; + if (typeof val === 'string') { + name = camelize(val); + res[name] = { type: null }; + } else { + warn('props must be strings when using array syntax.'); } } - } - - var text$1 = { - - bind: function bind() { - this.attr = this.el.nodeType === 3 ? 'data' : 'textContent'; - }, - - update: function update(value) { - this.el[this.attr] = _toString(value); + } else if (isPlainObject(props)) { + for (var key in props) { + val = props[key]; + name = camelize(key); + res[name] = isPlainObject(val) + ? val + : { type: val }; } - }; - - var templateCache = new Cache(1000); - var idSelectorCache = new Cache(1000); - - var map = { - efault: [0, '', ''], - legend: [1, '<fieldset>', '</fieldset>'], - tr: [2, '<table><tbody>', '</tbody></table>'], - col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'] - }; - - map.td = map.th = [3, '<table><tbody><tr>', '</tr></tbody></table>']; - - map.option = map.optgroup = [1, '<select multiple="multiple">', '</select>']; - - map.thead = map.tbody = map.colgroup = map.caption = map.tfoot = [1, '<table>', '</table>']; - - 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>']; - - /** - * Check if a node is a supported template node with a - * DocumentFragment content. - * - * @param {Node} node - * @return {Boolean} - */ - - function isRealTemplate(node) { - return isTemplate(node) && isFragment(node.content); } + options.props = res; +} - var tagRE$1 = /<([\w:-]+)/; - var entityRE = /&#?\w+?;/; - var commentRE = /<!--/; - - /** - * Convert a string template to a DocumentFragment. - * Determines correct wrapping by tag types. Wrapping - * strategy found in jQuery & component/domify. - * - * @param {String} templateString - * @param {Boolean} raw - * @return {DocumentFragment} - */ - - function stringToFragment(templateString, raw) { - // try a cache hit first - var cacheKey = raw ? templateString : templateString.trim(); - var hit = templateCache.get(cacheKey); - if (hit) { - return hit; - } - - var frag = document.createDocumentFragment(); - var tagMatch = templateString.match(tagRE$1); - var entityMatch = entityRE.test(templateString); - var commentMatch = commentRE.test(templateString); - - if (!tagMatch && !entityMatch && !commentMatch) { - // text only, return a single text node. - frag.appendChild(document.createTextNode(templateString)); - } else { - var tag = tagMatch && tagMatch[1]; - var wrap = map[tag] || map.efault; - var depth = wrap[0]; - var prefix = wrap[1]; - var suffix = wrap[2]; - var node = document.createElement('div'); - - node.innerHTML = prefix + templateString + suffix; - while (depth--) { - node = node.lastChild; - } - - var child; - /* eslint-disable no-cond-assign */ - while (child = node.firstChild) { - /* eslint-enable no-cond-assign */ - frag.appendChild(child); +/** + * Normalize raw function directives into object format. + */ +function normalizeDirectives (options) { + var dirs = options.directives; + if (dirs) { + for (var key in dirs) { + var def = dirs[key]; + if (typeof def === 'function') { + dirs[key] = { bind: def, update: def }; } } - if (!raw) { - trimNode(frag); - } - templateCache.put(cacheKey, frag); - return frag; } +} - /** - * Convert a template node to a DocumentFragment. - * - * @param {Node} node - * @return {DocumentFragment} - */ - - function nodeToFragment(node) { - // if its a template tag and the browser supports it, - // its content is already a document fragment. However, iOS Safari has - // bug when using directly cloned template content with touch - // events and can cause crashes when the nodes are removed from DOM, so we - // have to treat template elements as string templates. (#2805) - /* istanbul ignore if */ - if (isRealTemplate(node)) { - return stringToFragment(node.innerHTML); - } - // script template - if (node.tagName === 'SCRIPT') { - return stringToFragment(node.textContent); - } - // normal node, clone it to avoid mutating the original - var clonedNode = cloneNode(node); - var frag = document.createDocumentFragment(); - var child; - /* eslint-disable no-cond-assign */ - while (child = clonedNode.firstChild) { - /* eslint-enable no-cond-assign */ - frag.appendChild(child); +/** + * Merge two option objects into a new one. + * Core utility used in both instantiation and inheritance. + */ +function mergeOptions ( + parent, + child, + vm +) { + normalizeComponents(child); + normalizeProps(child); + normalizeDirectives(child); + var extendsFrom = child.extends; + if (extendsFrom) { + parent = typeof extendsFrom === 'function' + ? mergeOptions(parent, extendsFrom.options, vm) + : mergeOptions(parent, extendsFrom, vm); + } + if (child.mixins) { + for (var i = 0, l = child.mixins.length; i < l; i++) { + var mixin = child.mixins[i]; + if (mixin.prototype instanceof Vue$3) { + mixin = mixin.options; + } + parent = mergeOptions(parent, mixin, vm); + } + } + var options = {}; + var key; + for (key in parent) { + mergeField(key); + } + for (key in child) { + if (!hasOwn(parent, key)) { + mergeField(key); } - trimNode(frag); - return frag; } - - // Test for the presence of the Safari template cloning bug - // https://bugs.webkit.org/showug.cgi?id=137755 - var hasBrokenTemplate = (function () { - /* istanbul ignore else */ - if (inBrowser) { - var a = document.createElement('div'); - a.innerHTML = '<template>1</template>'; - return !a.cloneNode(true).firstChild.innerHTML; - } else { - return false; - } - })(); - - // Test for IE10/11 textarea placeholder clone bug - var hasTextareaCloneBug = (function () { - /* istanbul ignore else */ - if (inBrowser) { - var t = document.createElement('textarea'); - t.placeholder = 't'; - return t.cloneNode(true).value === 't'; - } else { - return false; - } - })(); - - /** - * 1. Deal with Safari cloning nested <template> bug by - * manually cloning all template instances. - * 2. Deal with IE10/11 textarea placeholder bug by setting - * the correct value after cloning. - * - * @param {Element|DocumentFragment} node - * @return {Element|DocumentFragment} - */ - - function cloneNode(node) { - /* istanbul ignore if */ - if (!node.querySelectorAll) { - return node.cloneNode(); - } - var res = node.cloneNode(true); - var i, original, cloned; - /* istanbul ignore if */ - if (hasBrokenTemplate) { - var tempClone = res; - if (isRealTemplate(node)) { - node = node.content; - tempClone = res.content; - } - original = node.querySelectorAll('template'); - if (original.length) { - cloned = tempClone.querySelectorAll('template'); - i = cloned.length; - while (i--) { - cloned[i].parentNode.replaceChild(cloneNode(original[i]), cloned[i]); - } - } - } - /* istanbul ignore if */ - if (hasTextareaCloneBug) { - if (node.tagName === 'TEXTAREA') { - res.value = node.value; - } else { - original = node.querySelectorAll('textarea'); - if (original.length) { - cloned = res.querySelectorAll('textarea'); - i = cloned.length; - while (i--) { - cloned[i].value = original[i].value; - } - } - } - } - return res; + function mergeField (key) { + var strat = strats[key] || defaultStrat; + options[key] = strat(parent[key], child[key], vm, key); } + return options +} - /** - * Process the template option and normalizes it into a - * a DocumentFragment that can be used as a partial or a - * instance template. - * - * @param {*} template - * Possible values include: - * - DocumentFragment object - * - Node object of type Template - * - id selector: '#some-template-id' - * - template string: '<div><span>{{msg}}</span></div>' - * @param {Boolean} shouldClone - * @param {Boolean} raw - * inline HTML interpolation. Do not check for id - * selector and keep whitespace in the string. - * @return {DocumentFragment|undefined} - */ - - function parseTemplate(template, shouldClone, raw) { - var node, frag; - - // if the template is already a document fragment, - // do nothing - if (isFragment(template)) { - trimNode(template); - return shouldClone ? cloneNode(template) : template; - } - - if (typeof template === 'string') { - // id selector - if (!raw && template.charAt(0) === '#') { - // id selector can be cached too - frag = idSelectorCache.get(template); - if (!frag) { - node = document.getElementById(template.slice(1)); - if (node) { - frag = nodeToFragment(node); - // save selector to cache - idSelectorCache.put(template, frag); - } - } - } else { - // normal string template - frag = stringToFragment(template, raw); - } - } else if (template.nodeType) { - // a direct node - frag = nodeToFragment(template); - } - - return frag && shouldClone ? cloneNode(frag) : frag; +/** + * Resolve an asset. + * This function is used because child instances need access + * to assets defined in its ancestor chain. + */ +function resolveAsset ( + options, + type, + id, + warnMissing +) { + /* istanbul ignore if */ + if (typeof id !== 'string') { + return } - -var template = Object.freeze({ - cloneNode: cloneNode, - parseTemplate: parseTemplate - }); - - var html = { - - bind: function bind() { - // a comment node means this is a binding for - // {{{ inline unescaped html }}} - if (this.el.nodeType === 8) { - // hold nodes - this.nodes = []; - // replace the placeholder with proper anchor - this.anchor = createAnchor('v-html'); - replace(this.el, this.anchor); - } - }, - - update: function update(value) { - value = _toString(value); - if (this.nodes) { - this.swap(value); - } else { - this.el.innerHTML = value; - } - }, - - swap: function swap(value) { - // remove old nodes - var i = this.nodes.length; - while (i--) { - remove(this.nodes[i]); - } - // convert new value to a fragment - // do not attempt to retrieve from id selector - var frag = parseTemplate(value, true, true); - // save a reference to these nodes so we can remove later - this.nodes = toArray(frag.childNodes); - before(frag, this.anchor); - } - }; - - /** - * Abstraction for a partially-compiled fragment. - * Can optionally compile content with a child scope. - * - * @param {Function} linker - * @param {Vue} vm - * @param {DocumentFragment} frag - * @param {Vue} [host] - * @param {Object} [scope] - * @param {Fragment} [parentFrag] - */ - function Fragment(linker, vm, frag, host, scope, parentFrag) { - this.children = []; - this.childFrags = []; - this.vm = vm; - this.scope = scope; - this.inserted = false; - this.parentFrag = parentFrag; - if (parentFrag) { - parentFrag.childFrags.push(this); - } - this.unlink = linker(vm, frag, host, scope, this); - var single = this.single = frag.childNodes.length === 1 && - // do not go single mode if the only node is an anchor - !frag.childNodes[0].__v_anchor; - if (single) { - this.node = frag.childNodes[0]; - this.before = singleBefore; - this.remove = singleRemove; - } else { - this.node = createAnchor('fragment-start'); - this.end = createAnchor('fragment-end'); - this.frag = frag; - prepend(this.node, frag); - frag.appendChild(this.end); - this.before = multiBefore; - this.remove = multiRemove; - } - this.node.__v_frag = this; + var assets = options[type]; + var res = assets[id] || + // camelCase ID + assets[camelize(id)] || + // Pascal Case ID + assets[capitalize(camelize(id))]; + if ("development" !== 'production' && warnMissing && !res) { + warn( + 'Failed to resolve ' + type.slice(0, -1) + ': ' + id, + options + ); + } + return res +} + +/* */ + +function validateProp ( + key, + propOptions, + propsData, + vm +) { + var prop = propOptions[key]; + var absent = !hasOwn(propsData, key); + var value = propsData[key]; + // handle boolean props + if (isBooleanType(prop.type)) { + if (absent && !hasOwn(prop, 'default')) { + value = false; + } else if (value === '' || value === hyphenate(key)) { + value = true; + } + } + // check default value + if (value === undefined) { + value = getPropDefaultValue(vm, prop, key); + // since the default value is a fresh copy, + // make sure to observe it. + var prevShouldConvert = observerState.shouldConvert; + observerState.shouldConvert = true; + observe(value); + observerState.shouldConvert = prevShouldConvert; + } + { + assertProp(prop, key, value, vm, absent); + } + return value +} + +/** + * Get the default value of a prop. + */ +function getPropDefaultValue (vm, prop, name) { + // no default, return undefined + if (!hasOwn(prop, 'default')) { + return undefined + } + var def = prop.default; + // warn against non-factory defaults for Object & Array + if (isObject(def)) { + "development" !== 'production' && warn( + 'Invalid default value for prop "' + name + '": ' + + 'Props with type Object/Array must use a factory function ' + + 'to return the default value.', + vm + ); + } + // call factory function for non-Function types + return typeof def === 'function' && prop.type !== Function + ? def.call(vm) + : def +} + +/** + * Assert whether a prop is valid. + */ +function assertProp ( + prop, + name, + value, + vm, + absent +) { + if (prop.required && absent) { + warn( + 'Missing required prop: "' + name + '"', + vm + ); + return + } + if (value == null && !prop.required) { + return + } + var type = prop.type; + var valid = !type || type === true; + var expectedTypes = []; + if (type) { + if (!Array.isArray(type)) { + type = [type]; + } + for (var i = 0; i < type.length && !valid; i++) { + var assertedType = assertType(value, type[i]); + expectedTypes.push(assertedType.expectedType); + valid = assertedType.valid; + } + } + if (!valid) { + warn( + 'Invalid prop: type check failed for prop "' + name + '".' + + ' Expected ' + expectedTypes.map(capitalize).join(', ') + + ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.', + vm + ); + return + } + var validator = prop.validator; + if (validator) { + if (!validator(value)) { + warn( + 'Invalid prop: custom validator check failed for prop "' + name + '".', + vm + ); + } + } +} + +/** + * Assert the type of a value + */ +function assertType (value, type) { + var valid; + var expectedType = getType(type); + if (expectedType === 'String') { + valid = typeof value === (expectedType = 'string'); + } else if (expectedType === 'Number') { + valid = typeof value === (expectedType = 'number'); + } else if (expectedType === 'Boolean') { + valid = typeof value === (expectedType = 'boolean'); + } else if (expectedType === 'Function') { + valid = typeof value === (expectedType = 'function'); + } else if (expectedType === 'Object') { + valid = isPlainObject(value); + } else if (expectedType === 'Array') { + valid = Array.isArray(value); + } else { + valid = value instanceof type; } - - /** - * Call attach/detach for all components contained within - * this fragment. Also do so recursively for all child - * fragments. - * - * @param {Function} hook - */ - - Fragment.prototype.callHook = function (hook) { - var i, l; - for (i = 0, l = this.childFrags.length; i < l; i++) { - this.childFrags[i].callHook(hook); - } - for (i = 0, l = this.children.length; i < l; i++) { - hook(this.children[i]); - } - }; - - /** - * Insert fragment before target, single node version - * - * @param {Node} target - * @param {Boolean} withTransition - */ - - function singleBefore(target, withTransition) { - this.inserted = true; - var method = withTransition !== false ? beforeWithTransition : before; - method(this.node, target, this.vm); - if (inDoc(this.node)) { - this.callHook(attach); - } + return { + valid: valid, + expectedType: expectedType } +} - /** - * Remove fragment, single node version - */ +/** + * Use function string name to check built-in types, + * because a simple equality check will fail when running + * across different vms / iframes. + */ +function getType (fn) { + var match = fn && fn.toString().match(/^\s*function (\w+)/); + return match && match[1] +} - function singleRemove() { - this.inserted = false; - var shouldCallRemove = inDoc(this.node); - var self = this; - this.beforeRemove(); - removeWithTransition(this.node, this.vm, function () { - if (shouldCallRemove) { - self.callHook(detach); - } - self.destroy(); - }); +function isBooleanType (fn) { + if (!Array.isArray(fn)) { + return getType(fn) === 'Boolean' } - - /** - * Insert fragment before target, multi-nodes version - * - * @param {Node} target - * @param {Boolean} withTransition - */ - - function multiBefore(target, withTransition) { - this.inserted = true; - var vm = this.vm; - var method = withTransition !== false ? beforeWithTransition : before; - mapNodeRange(this.node, this.end, function (node) { - method(node, target, vm); - }); - if (inDoc(this.node)) { - this.callHook(attach); + for (var i = 0, len = fn.length; i < len; i++) { + if (getType(fn[i]) === 'Boolean') { + return true } } - - /** - * Remove fragment, multi-nodes version - */ - - function multiRemove() { - this.inserted = false; - var self = this; - var shouldCallRemove = inDoc(this.node); - this.beforeRemove(); - removeNodeRange(this.node, this.end, this.vm, this.frag, function () { - if (shouldCallRemove) { - self.callHook(detach); - } - self.destroy(); - }); - } - - /** - * Prepare the fragment for removal. - */ - - Fragment.prototype.beforeRemove = function () { - var i, l; - for (i = 0, l = this.childFrags.length; i < l; i++) { - // call the same method recursively on child - // fragments, depth-first - this.childFrags[i].beforeRemove(false); - } - for (i = 0, l = this.children.length; i < l; i++) { - // Call destroy for all contained instances, - // with remove:false and defer:true. - // Defer is necessary because we need to - // keep the children to call detach hooks - // on them. - this.children[i].$destroy(false, true); - } - var dirs = this.unlink.dirs; - for (i = 0, l = dirs.length; i < l; i++) { - // disable the watchers on all the directives - // so that the rendered content stays the same - // during removal. - dirs[i]._watcher && dirs[i]._watcher.teardown(); + /* istanbul ignore next */ + return false +} + + + +var util = Object.freeze({ + defineReactive: defineReactive$$1, + _toString: _toString, + toNumber: toNumber, + makeMap: makeMap, + isBuiltInTag: isBuiltInTag, + remove: remove$1, + hasOwn: hasOwn, + isPrimitive: isPrimitive, + cached: cached, + camelize: camelize, + capitalize: capitalize, + hyphenate: hyphenate, + bind: bind$1, + toArray: toArray, + extend: extend, + isObject: isObject, + isPlainObject: isPlainObject, + toObject: toObject, + noop: noop, + no: no, + genStaticKeys: genStaticKeys, + looseEqual: looseEqual, + looseIndexOf: looseIndexOf, + isReserved: isReserved, + def: def, + parsePath: parsePath, + hasProto: hasProto, + inBrowser: inBrowser, + UA: UA, + isIE: isIE, + isIE9: isIE9, + isEdge: isEdge, + isAndroid: isAndroid, + isIOS: isIOS, + devtools: devtools, + nextTick: nextTick, + get _Set () { return _Set; }, + mergeOptions: mergeOptions, + resolveAsset: resolveAsset, + get warn () { return warn; }, + get formatComponentName () { return formatComponentName; }, + validateProp: validateProp +}); + +/* */ + +function initUse (Vue) { + Vue.use = function (plugin) { + /* istanbul ignore if */ + if (plugin.installed) { + return } + // additional parameters + var args = toArray(arguments, 1); + args.unshift(this); + if (typeof plugin.install === 'function') { + plugin.install.apply(plugin, args); + } else { + plugin.apply(null, args); + } + plugin.installed = true; + return this }; +} - /** - * Destroy the fragment. - */ +/* */ - Fragment.prototype.destroy = function () { - if (this.parentFrag) { - this.parentFrag.childFrags.$remove(this); - } - this.node.__v_frag = null; - this.unlink(); +function initMixin$1 (Vue) { + Vue.mixin = function (mixin) { + Vue.options = mergeOptions(Vue.options, mixin); }; +} - /** - * Call attach hook for a Vue instance. - * - * @param {Vue} child - */ - - function attach(child) { - if (!child._isAttached && inDoc(child.$el)) { - child._callHook('attached'); - } - } +/* */ +function initExtend (Vue) { /** - * Call detach hook for a Vue instance. - * - * @param {Vue} child + * Each instance constructor, including Vue, has a unique + * cid. This enables us to create wrapped "child + * constructors" for prototypal inheritance and cache them. */ - - function detach(child) { - if (child._isAttached && !inDoc(child.$el)) { - child._callHook('detached'); - } - } - - var linkerCache = new Cache(5000); + Vue.cid = 0; + var cid = 1; /** - * A factory that can be used to create instances of a - * fragment. Caches the compiled linker if possible. - * - * @param {Vue} vm - * @param {Element|String} el + * Class inheritance */ - function FragmentFactory(vm, el) { - this.vm = vm; - var template; - var isString = typeof el === 'string'; - if (isString || isTemplate(el) && !el.hasAttribute('v-if')) { - template = parseTemplate(el, true); - } else { - template = document.createDocumentFragment(); - template.appendChild(el); - } - this.template = template; - // linker can be cached, but only for components - var linker; - var cid = vm.constructor.cid; - if (cid > 0) { - var cacheId = cid + (isString ? el : getOuterHTML(el)); - linker = linkerCache.get(cacheId); - if (!linker) { - linker = compile(template, vm.$options, true); - linkerCache.put(cacheId, linker); + Vue.extend = function (extendOptions) { + extendOptions = extendOptions || {}; + var Super = this; + var isFirstExtend = Super.cid === 0; + if (isFirstExtend && extendOptions._Ctor) { + return extendOptions._Ctor + } + var name = extendOptions.name || Super.options.name; + { + if (!/^[a-zA-Z][\w-]*$/.test(name)) { + warn( + 'Invalid component name: "' + name + '". Component names ' + + 'can only contain alphanumeric characaters and the hyphen.' + ); + name = null; } - } else { - linker = compile(template, vm.$options, true); } - this.linker = linker; - } - - /** - * Create a fragment instance with given host and scope. - * - * @param {Vue} host - * @param {Object} scope - * @param {Fragment} parentFrag - */ - - FragmentFactory.prototype.create = function (host, scope, parentFrag) { - var frag = cloneNode(this.template); - return new Fragment(this.linker, this.vm, frag, host, scope, parentFrag); + var Sub = function VueComponent (options) { + this._init(options); + }; + Sub.prototype = Object.create(Super.prototype); + Sub.prototype.constructor = Sub; + Sub.cid = cid++; + Sub.options = mergeOptions( + Super.options, + extendOptions + ); + Sub['super'] = Super; + // allow further extension + Sub.extend = Super.extend; + // create asset registers, so extended classes + // can have their private assets too. + config._assetTypes.forEach(function (type) { + Sub[type] = Super[type]; + }); + // enable recursive self-lookup + if (name) { + Sub.options.components[name] = Sub; + } + // keep a reference to the super options at extension time. + // later at instantiation we can check if Super's options have + // been updated. + Sub.superOptions = Super.options; + Sub.extendOptions = extendOptions; + // cache constructor + if (isFirstExtend) { + extendOptions._Ctor = Sub; + } + return Sub }; +} - var ON = 700; - var MODEL = 800; - var BIND = 850; - var TRANSITION = 1100; - var EL = 1500; - var COMPONENT = 1500; - var PARTIAL = 1750; - var IF = 2100; - var FOR = 2200; - var SLOT = 2300; - - var uid$3 = 0; - - var vFor = { - - priority: FOR, - terminal: true, - - params: ['track-by', 'stagger', 'enter-stagger', 'leave-stagger'], - - bind: function bind() { - // support "item in/of items" syntax - var inMatch = this.expression.match(/(.*) (?:in|of) (.*)/); - if (inMatch) { - var itMatch = inMatch[1].match(/\((.*),(.*)\)/); - if (itMatch) { - this.iterator = itMatch[1].trim(); - this.alias = itMatch[2].trim(); - } else { - this.alias = inMatch[1].trim(); - } - this.expression = inMatch[2]; - } - - if (!this.alias) { - 'development' !== 'production' && warn('Invalid v-for expression "' + this.descriptor.raw + '": ' + 'alias is required.', this.vm); - return; - } - - // uid as a cache identifier - this.id = '__v-for__' + ++uid$3; - - // check if this is an option list, - // so that we know if we need to update the <select>'s - // v-model when the option list has changed. - // because v-model has a lower priority than v-for, - // the v-model is not bound here yet, so we have to - // retrive it in the actual updateModel() function. - var tag = this.el.tagName; - this.isOption = (tag === 'OPTION' || tag === 'OPTGROUP') && this.el.parentNode.tagName === 'SELECT'; - - // setup anchor nodes - this.start = createAnchor('v-for-start'); - this.end = createAnchor('v-for-end'); - replace(this.el, this.end); - before(this.start, this.end); - - // cache - this.cache = Object.create(null); - - // fragment factory - this.factory = new FragmentFactory(this.vm, this.el); - }, - - update: function update(data) { - this.diff(data); - this.updateRef(); - this.updateModel(); - }, - - /** - * Diff, based on new data and old data, determine the - * minimum amount of DOM manipulations needed to make the - * DOM reflect the new data Array. - * - * The algorithm diffs the new data Array by storing a - * hidden reference to an owner vm instance on previously - * seen data. This allows us to achieve O(n) which is - * better than a levenshtein distance based algorithm, - * which is O(m * n). - * - * @param {Array} data - */ - - diff: function diff(data) { - // check if the Array was converted from an Object - var item = data[0]; - var convertedFromObject = this.fromObject = isObject(item) && hasOwn(item, '$key') && hasOwn(item, '$value'); - - var trackByKey = this.params.trackBy; - var oldFrags = this.frags; - var frags = this.frags = new Array(data.length); - var alias = this.alias; - var iterator = this.iterator; - var start = this.start; - var end = this.end; - var inDocument = inDoc(start); - var init = !oldFrags; - var i, l, frag, key, value, primitive; - - // First pass, go through the new Array and fill up - // the new frags array. If a piece of data has a cached - // instance for it, we reuse it. Otherwise build a new - // instance. - for (i = 0, l = data.length; i < l; i++) { - item = data[i]; - key = convertedFromObject ? item.$key : null; - value = convertedFromObject ? item.$value : item; - primitive = !isObject(value); - frag = !init && this.getCachedFrag(value, i, key); - if (frag) { - // reusable fragment - frag.reused = true; - // update $index - frag.scope.$index = i; - // update $key - if (key) { - frag.scope.$key = key; - } - // update iterator - if (iterator) { - frag.scope[iterator] = key !== null ? key : i; - } - // update data for track-by, object repeat & - // primitive values. - if (trackByKey || convertedFromObject || primitive) { - withoutConversion(function () { - frag.scope[alias] = value; - }); - } - } else { - // new isntance - frag = this.create(value, alias, i, key); - frag.fresh = !init; - } - frags[i] = frag; - if (init) { - frag.before(end); - } - } - - // we're done for the initial render. - if (init) { - return; - } - - // Second pass, go through the old fragments and - // destroy those who are not reused (and remove them - // from cache) - var removalIndex = 0; - var totalRemoved = oldFrags.length - frags.length; - // when removing a large number of fragments, watcher removal - // turns out to be a perf bottleneck, so we batch the watcher - // removals into a single filter call! - this.vm._vForRemoving = true; - for (i = 0, l = oldFrags.length; i < l; i++) { - frag = oldFrags[i]; - if (!frag.reused) { - this.deleteCachedFrag(frag); - this.remove(frag, removalIndex++, totalRemoved, inDocument); - } - } - this.vm._vForRemoving = false; - if (removalIndex) { - this.vm._watchers = this.vm._watchers.filter(function (w) { - return w.active; - }); - } - - // Final pass, move/insert new fragments into the - // right place. - var targetPrev, prevEl, currentPrev; - var insertionIndex = 0; - for (i = 0, l = frags.length; i < l; i++) { - frag = frags[i]; - // this is the frag that we should be after - targetPrev = frags[i - 1]; - prevEl = targetPrev ? targetPrev.staggerCb ? targetPrev.staggerAnchor : targetPrev.end || targetPrev.node : start; - if (frag.reused && !frag.staggerCb) { - currentPrev = findPrevFrag(frag, start, this.id); - if (currentPrev !== targetPrev && (!currentPrev || - // optimization for moving a single item. - // thanks to suggestions by @livoras in #1807 - findPrevFrag(currentPrev, start, this.id) !== targetPrev)) { - this.move(frag, prevEl); - } - } else { - // new instance, or still in stagger. - // insert with updated stagger index. - this.insert(frag, insertionIndex++, prevEl, inDocument); - } - frag.reused = frag.fresh = false; - } - }, - - /** - * Create a new fragment instance. - * - * @param {*} value - * @param {String} alias - * @param {Number} index - * @param {String} [key] - * @return {Fragment} - */ - - create: function create(value, alias, index, key) { - var host = this._host; - // create iteration scope - var parentScope = this._scope || this.vm; - var scope = Object.create(parentScope); - // ref holder for the scope - scope.$refs = Object.create(parentScope.$refs); - scope.$els = Object.create(parentScope.$els); - // make sure point $parent to parent scope - scope.$parent = parentScope; - // for two-way binding on alias - scope.$forContext = this; - // define scope properties - // important: define the scope alias without forced conversion - // so that frozen data structures remain non-reactive. - withoutConversion(function () { - defineReactive(scope, alias, value); - }); - defineReactive(scope, '$index', index); - if (key) { - defineReactive(scope, '$key', key); - } else if (scope.$key) { - // avoid accidental fallback - def(scope, '$key', null); - } - if (this.iterator) { - defineReactive(scope, this.iterator, key !== null ? key : index); - } - var frag = this.factory.create(host, scope, this._frag); - frag.forId = this.id; - this.cacheFrag(value, frag, index, key); - return frag; - }, - - /** - * Update the v-ref on owner vm. - */ - - updateRef: function updateRef() { - var ref = this.descriptor.ref; - if (!ref) return; - var hash = (this._scope || this.vm).$refs; - var refs; - if (!this.fromObject) { - refs = this.frags.map(findVmFromFrag); - } else { - refs = {}; - this.frags.forEach(function (frag) { - refs[frag.scope.$key] = findVmFromFrag(frag); - }); - } - hash[ref] = refs; - }, - - /** - * For option lists, update the containing v-model on - * parent <select>. - */ - - updateModel: function updateModel() { - if (this.isOption) { - var parent = this.start.parentNode; - var model = parent && parent.__v_model; - if (model) { - model.forceUpdate(); - } - } - }, +/* */ - /** - * Insert a fragment. Handles staggering. - * - * @param {Fragment} frag - * @param {Number} index - * @param {Node} prevEl - * @param {Boolean} inDocument - */ - - insert: function insert(frag, index, prevEl, inDocument) { - if (frag.staggerCb) { - frag.staggerCb.cancel(); - frag.staggerCb = null; - } - var staggerAmount = this.getStagger(frag, index, null, 'enter'); - if (inDocument && staggerAmount) { - // create an anchor and insert it synchronously, - // so that we can resolve the correct order without - // worrying about some elements not inserted yet - var anchor = frag.staggerAnchor; - if (!anchor) { - anchor = frag.staggerAnchor = createAnchor('stagger-anchor'); - anchor.__v_frag = frag; - } - after(anchor, prevEl); - var op = frag.staggerCb = cancellable(function () { - frag.staggerCb = null; - frag.before(anchor); - remove(anchor); - }); - setTimeout(op, staggerAmount); +function initAssetRegisters (Vue) { + /** + * Create asset registration methods. + */ + config._assetTypes.forEach(function (type) { + Vue[type] = function ( + id, + definition + ) { + if (!definition) { + return this.options[type + 's'][id] } else { - var target = prevEl.nextSibling; /* istanbul ignore if */ - if (!target) { - // reset end anchor position in case the position was messed up - // by an external drag-n-drop library. - after(this.end, prevEl); - target = this.end; - } - frag.before(target); - } - }, - - /** - * Remove a fragment. Handles staggering. - * - * @param {Fragment} frag - * @param {Number} index - * @param {Number} total - * @param {Boolean} inDocument - */ - - remove: function remove(frag, index, total, inDocument) { - if (frag.staggerCb) { - frag.staggerCb.cancel(); - frag.staggerCb = null; - // it's not possible for the same frag to be removed - // twice, so if we have a pending stagger callback, - // it means this frag is queued for enter but removed - // before its transition started. Since it is already - // destroyed, we can just leave it in detached state. - return; - } - var staggerAmount = this.getStagger(frag, index, total, 'leave'); - if (inDocument && staggerAmount) { - var op = frag.staggerCb = cancellable(function () { - frag.staggerCb = null; - frag.remove(); - }); - setTimeout(op, staggerAmount); - } else { - frag.remove(); - } - }, - - /** - * Move a fragment to a new position. - * Force no transition. - * - * @param {Fragment} frag - * @param {Node} prevEl - */ - - move: function move(frag, prevEl) { - // fix a common issue with Sortable: - // if prevEl doesn't have nextSibling, this means it's - // been dragged after the end anchor. Just re-position - // the end anchor to the end of the container. - /* istanbul ignore if */ - if (!prevEl.nextSibling) { - this.end.parentNode.appendChild(this.end); - } - frag.before(prevEl.nextSibling, false); - }, - - /** - * Cache a fragment using track-by or the object key. - * - * @param {*} value - * @param {Fragment} frag - * @param {Number} index - * @param {String} [key] - */ - - cacheFrag: function cacheFrag(value, frag, index, key) { - var trackByKey = this.params.trackBy; - var cache = this.cache; - var primitive = !isObject(value); - var id; - if (key || trackByKey || primitive) { - id = getTrackByKey(index, key, value, trackByKey); - if (!cache[id]) { - cache[id] = frag; - } else if (trackByKey !== '$index') { - 'development' !== 'production' && this.warnDuplicate(value); - } - } else { - id = this.id; - if (hasOwn(value, id)) { - if (value[id] === null) { - value[id] = frag; - } else { - 'development' !== 'production' && this.warnDuplicate(value); + { + if (type === 'component' && config.isReservedTag(id)) { + warn( + 'Do not use built-in or reserved HTML elements as component ' + + 'id: ' + id + ); } - } else if (Object.isExtensible(value)) { - def(value, id, frag); - } else if ('development' !== 'production') { - warn('Frozen v-for objects cannot be automatically tracked, make sure to ' + 'provide a track-by key.'); - } - } - frag.raw = value; - }, - - /** - * Get a cached fragment from the value/index/key - * - * @param {*} value - * @param {Number} index - * @param {String} key - * @return {Fragment} - */ - - getCachedFrag: function getCachedFrag(value, index, key) { - var trackByKey = this.params.trackBy; - var primitive = !isObject(value); - var frag; - if (key || trackByKey || primitive) { - var id = getTrackByKey(index, key, value, trackByKey); - frag = this.cache[id]; - } else { - frag = value[this.id]; - } - if (frag && (frag.reused || frag.fresh)) { - 'development' !== 'production' && this.warnDuplicate(value); - } - return frag; - }, - - /** - * Delete a fragment from cache. - * - * @param {Fragment} frag - */ - - deleteCachedFrag: function deleteCachedFrag(frag) { - var value = frag.raw; - var trackByKey = this.params.trackBy; - var scope = frag.scope; - var index = scope.$index; - // fix #948: avoid accidentally fall through to - // a parent repeater which happens to have $key. - var key = hasOwn(scope, '$key') && scope.$key; - var primitive = !isObject(value); - if (trackByKey || key || primitive) { - var id = getTrackByKey(index, key, value, trackByKey); - this.cache[id] = null; - } else { - value[this.id] = null; - frag.raw = null; - } - }, - - /** - * Get the stagger amount for an insertion/removal. - * - * @param {Fragment} frag - * @param {Number} index - * @param {Number} total - * @param {String} type - */ - - getStagger: function getStagger(frag, index, total, type) { - type = type + 'Stagger'; - var trans = frag.node.__v_trans; - var hooks = trans && trans.hooks; - var hook = hooks && (hooks[type] || hooks.stagger); - return hook ? hook.call(frag, index, total) : index * parseInt(this.params[type] || this.params.stagger, 10); - }, - - /** - * Pre-process the value before piping it through the - * filters. This is passed to and called by the watcher. - */ - - _preProcess: function _preProcess(value) { - // regardless of type, store the un-filtered raw value. - this.rawValue = value; - return value; - }, - - /** - * Post-process the value after it has been piped through - * the filters. This is passed to and called by the watcher. - * - * It is necessary for this to be called during the - * watcher's dependency collection phase because we want - * the v-for to update when the source Object is mutated. - */ - - _postProcess: function _postProcess(value) { - if (isArray(value)) { - return value; - } else if (isPlainObject(value)) { - // convert plain object to array. - var keys = Object.keys(value); - var i = keys.length; - var res = new Array(i); - var key; - while (i--) { - key = keys[i]; - res[i] = { - $key: key, - $value: value[key] - }; } - return res; - } else { - if (typeof value === 'number' && !isNaN(value)) { - value = range(value); + if (type === 'component' && isPlainObject(definition)) { + definition.name = definition.name || id; + definition = Vue.extend(definition); } - return value || []; - } - }, - - unbind: function unbind() { - if (this.descriptor.ref) { - (this._scope || this.vm).$refs[this.descriptor.ref] = null; - } - if (this.frags) { - var i = this.frags.length; - var frag; - while (i--) { - frag = this.frags[i]; - this.deleteCachedFrag(frag); - frag.destroy(); + if (type === 'directive' && typeof definition === 'function') { + definition = { bind: definition, update: definition }; } + this.options[type + 's'][id] = definition; + return definition } - } - }; - - /** - * Helper to find the previous element that is a fragment - * anchor. This is necessary because a destroyed frag's - * element could still be lingering in the DOM before its - * leaving transition finishes, but its inserted flag - * should have been set to false so we can skip them. - * - * If this is a block repeat, we want to make sure we only - * return frag that is bound to this v-for. (see #929) - * - * @param {Fragment} frag - * @param {Comment|Text} anchor - * @param {String} id - * @return {Fragment} - */ - - function findPrevFrag(frag, anchor, id) { - var el = frag.node.previousSibling; - /* istanbul ignore if */ - if (!el) return; - frag = el.__v_frag; - while ((!frag || frag.forId !== id || !frag.inserted) && el !== anchor) { - el = el.previousSibling; - /* istanbul ignore if */ - if (!el) return; - frag = el.__v_frag; - } - return frag; - } - - /** - * Find a vm from a fragment. - * - * @param {Fragment} frag - * @return {Vue|undefined} - */ - - function findVmFromFrag(frag) { - var node = frag.node; - // handle multi-node frag - if (frag.end) { - while (!node.__vue__ && node !== frag.end && node.nextSibling) { - node = node.nextSibling; + }; + }); +} + +var KeepAlive = { + name: 'keep-alive', + abstract: true, + created: function created () { + this.cache = Object.create(null); + }, + render: function render () { + var vnode = getFirstComponentChild(this.$slots.default); + if (vnode && vnode.componentOptions) { + var opts = vnode.componentOptions; + var key = vnode.key == null + // same constructor may get registered as different local components + // so cid alone is not enough (#3269) + ? opts.Ctor.cid + '::' + opts.tag + : vnode.key; + if (this.cache[key]) { + vnode.child = this.cache[key].child; + } else { + this.cache[key] = vnode; } + vnode.data.keepAlive = true; } - return node.__vue__; - } - - /** - * Create a range array from given number. - * - * @param {Number} n - * @return {Array} - */ + return vnode + }, + destroyed: function destroyed () { + var this$1 = this; - function range(n) { - var i = -1; - var ret = new Array(Math.floor(n)); - while (++i < n) { - ret[i] = i; + for (var key in this.cache) { + var vnode = this$1.cache[key]; + callHook(vnode.child, 'deactivated'); + vnode.child.$destroy(); } - return ret; } +}; - /** - * Get the track by key for an item. - * - * @param {Number} index - * @param {String} key - * @param {*} value - * @param {String} [trackByKey] - */ +var builtInComponents = { + KeepAlive: KeepAlive +}; - function getTrackByKey(index, key, value, trackByKey) { - return trackByKey ? trackByKey === '$index' ? index : trackByKey.charAt(0).match(/\w/) ? getPath(value, trackByKey) : value[trackByKey] : key || value; - } +/* */ - if ('development' !== 'production') { - vFor.warnDuplicate = function (value) { - warn('Duplicate value found in v-for="' + this.descriptor.raw + '": ' + JSON.stringify(value) + '. Use track-by="$index" if ' + 'you are expecting duplicate values.', this.vm); +function initGlobalAPI (Vue) { + // config + var configDef = {}; + configDef.get = function () { return config; }; + { + configDef.set = function () { + warn( + 'Do not replace the Vue.config object, set individual fields instead.' + ); }; } + Object.defineProperty(Vue, 'config', configDef); + Vue.util = util; + Vue.set = set; + Vue.delete = del; + Vue.nextTick = nextTick; - var vIf = { + Vue.options = Object.create(null); + config._assetTypes.forEach(function (type) { + Vue.options[type + 's'] = Object.create(null); + }); - priority: IF, - terminal: true, + extend(Vue.options.components, builtInComponents); - bind: function bind() { - var el = this.el; - if (!el.__vue__) { - // check else block - var next = el.nextElementSibling; - if (next && getAttr(next, 'v-else') !== null) { - remove(next); - this.elseEl = next; - } - // check main block - this.anchor = createAnchor('v-if'); - replace(el, this.anchor); - } else { - 'development' !== 'production' && warn('v-if="' + this.expression + '" cannot be ' + 'used on an instance root element.', this.vm); - this.invalid = true; - } - }, + initUse(Vue); + initMixin$1(Vue); + initExtend(Vue); + initAssetRegisters(Vue); +} - update: function update(value) { - if (this.invalid) return; - if (value) { - if (!this.frag) { - this.insert(); - } - } else { - this.remove(); - } - }, +initGlobalAPI(Vue$3); - insert: function insert() { - if (this.elseFrag) { - this.elseFrag.remove(); - this.elseFrag = null; - } - // lazy init factory - if (!this.factory) { - this.factory = new FragmentFactory(this.vm, this.el); - } - this.frag = this.factory.create(this._host, this._scope, this._frag); - this.frag.before(this.anchor); - }, +Object.defineProperty(Vue$3.prototype, '$isServer', { + get: function () { return config._isServer; } +}); - remove: function remove() { - if (this.frag) { - this.frag.remove(); - this.frag = null; - } - if (this.elseEl && !this.elseFrag) { - if (!this.elseFactory) { - this.elseFactory = new FragmentFactory(this.elseEl._context || this.vm, this.elseEl); - } - this.elseFrag = this.elseFactory.create(this._host, this._scope, this._frag); - this.elseFrag.before(this.anchor); - } - }, +Vue$3.version = '2.0.3'; - unbind: function unbind() { - if (this.frag) { - this.frag.destroy(); - } - if (this.elseFrag) { - this.elseFrag.destroy(); - } - } - }; +/* */ - var show = { +// attributes that should be using props for binding +var mustUseProp = makeMap('value,selected,checked,muted'); - bind: function bind() { - // check else block - var next = this.el.nextElementSibling; - if (next && getAttr(next, 'v-else') !== null) { - this.elseEl = next; - } - }, +var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck'); - update: function update(value) { - this.apply(this.el, value); - if (this.elseEl) { - this.apply(this.elseEl, !value); - } - }, +var isBooleanAttr = makeMap( + 'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' + + 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' + + 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' + + 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' + + 'required,reversed,scoped,seamless,selected,sortable,translate,' + + 'truespeed,typemustmatch,visible' +); - apply: function apply(el, value) { - if (inDoc(el)) { - applyTransition(el, value ? 1 : -1, toggle, this.vm); - } else { - toggle(); - } - function toggle() { - el.style.display = value ? '' : 'none'; - } - } - }; +var isAttr = makeMap( + 'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' + + 'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' + + 'checked,cite,class,code,codebase,color,cols,colspan,content,http-equiv,' + + 'name,contenteditable,contextmenu,controls,coords,data,datetime,default,' + + 'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,method,for,' + + 'form,formaction,headers,<th>,height,hidden,high,href,hreflang,http-equiv,' + + 'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' + + 'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' + + 'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' + + 'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' + + 'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' + + 'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' + + 'target,title,type,usemap,value,width,wrap' +); - var text$2 = { - - bind: function bind() { - var self = this; - var el = this.el; - var isRange = el.type === 'range'; - var lazy = this.params.lazy; - var number = this.params.number; - var debounce = this.params.debounce; - - // handle composition events. - // http://blog.evanyou.me/2014/01/03/composition-event/ - // skip this for Android because it handles composition - // events quite differently. Android doesn't trigger - // composition events for language input methods e.g. - // Chinese, but instead triggers them for spelling - // suggestions... (see Discussion/#162) - var composing = false; - if (!isAndroid && !isRange) { - this.on('compositionstart', function () { - composing = true; - }); - this.on('compositionend', function () { - composing = false; - // in IE11 the "compositionend" event fires AFTER - // the "input" event, so the input handler is blocked - // at the end... have to call it here. - // - // #1327: in lazy mode this is unecessary. - if (!lazy) { - self.listener(); - } - }); - } - // prevent messing with the input when user is typing, - // and force update on blur. - this.focused = false; - if (!isRange && !lazy) { - this.on('focus', function () { - self.focused = true; - }); - this.on('blur', function () { - self.focused = false; - // do not sync value after fragment removal (#2017) - if (!self._frag || self._frag.inserted) { - self.rawListener(); - } - }); - } - // Now attach the main listener - this.listener = this.rawListener = function () { - if (composing || !self._bound) { - return; - } - var val = number || isRange ? toNumber(el.value) : el.value; - self.set(val); - // force update on next tick to avoid lock & same value - // also only update when user is not typing - nextTick(function () { - if (self._bound && !self.focused) { - self.update(self._watcher.value); - } - }); - }; +var xlinkNS = 'http://www.w3.org/1999/xlink'; - // apply debounce - if (debounce) { - this.listener = _debounce(this.listener, debounce); - } - - // Support jQuery events, since jQuery.trigger() doesn't - // trigger native events in some cases and some plugins - // rely on $.trigger() - // - // We want to make sure if a listener is attached using - // jQuery, it is also removed with jQuery, that's why - // we do the check for each directive instance and - // store that check result on itself. This also allows - // easier test coverage control by unsetting the global - // jQuery variable in tests. - this.hasjQuery = typeof jQuery === 'function'; - if (this.hasjQuery) { - var method = jQuery.fn.on ? 'on' : 'bind'; - jQuery(el)[method]('change', this.rawListener); - if (!lazy) { - jQuery(el)[method]('input', this.listener); - } - } else { - this.on('change', this.rawListener); - if (!lazy) { - this.on('input', this.listener); - } - } +var isXlink = function (name) { + return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink' +}; - // IE9 doesn't fire input event on backspace/del/cut - if (!lazy && isIE9) { - this.on('cut', function () { - nextTick(self.listener); - }); - this.on('keyup', function (e) { - if (e.keyCode === 46 || e.keyCode === 8) { - self.listener(); - } - }); - } +var getXlinkProp = function (name) { + return isXlink(name) ? name.slice(6, name.length) : '' +}; - // set initial value if present - if (el.hasAttribute('value') || el.tagName === 'TEXTAREA' && el.value.trim()) { - this.afterBind = this.listener; - } - }, +var isFalsyAttrValue = function (val) { + return val == null || val === false +}; - update: function update(value) { - // #3029 only update when the value changes. This prevent - // browsers from overwriting values like selectionStart - value = _toString(value); - if (value !== this.el.value) this.el.value = value; - }, +/* */ - unbind: function unbind() { - var el = this.el; - if (this.hasjQuery) { - var method = jQuery.fn.off ? 'off' : 'unbind'; - jQuery(el)[method]('change', this.listener); - jQuery(el)[method]('input', this.listener); - } +function genClassForVnode (vnode) { + var data = vnode.data; + var parentNode = vnode; + var childNode = vnode; + while (childNode.child) { + childNode = childNode.child._vnode; + if (childNode.data) { + data = mergeClassData(childNode.data, data); } - }; - - var radio = { - - bind: function bind() { - var self = this; - var el = this.el; - - this.getValue = function () { - // value overwrite via v-bind:value - if (el.hasOwnProperty('_value')) { - return el._value; - } - var val = el.value; - if (self.params.number) { - val = toNumber(val); - } - return val; - }; - - this.listener = function () { - self.set(self.getValue()); - }; - this.on('change', this.listener); - - if (el.hasAttribute('checked')) { - this.afterBind = this.listener; - } - }, - - update: function update(value) { - this.el.checked = looseEqual(value, this.getValue()); + } + while ((parentNode = parentNode.parent)) { + if (parentNode.data) { + data = mergeClassData(data, parentNode.data); } - }; + } + return genClassFromData(data) +} - var select = { +function mergeClassData (child, parent) { + return { + staticClass: concat(child.staticClass, parent.staticClass), + class: child.class + ? [child.class, parent.class] + : parent.class + } +} - bind: function bind() { - var _this = this; +function genClassFromData (data) { + var dynamicClass = data.class; + var staticClass = data.staticClass; + if (staticClass || dynamicClass) { + return concat(staticClass, stringifyClass(dynamicClass)) + } + /* istanbul ignore next */ + return '' +} - var self = this; - var el = this.el; +function concat (a, b) { + return a ? b ? (a + ' ' + b) : a : (b || '') +} - // method to force update DOM using latest value. - this.forceUpdate = function () { - if (self._watcher) { - self.update(self._watcher.get()); +function stringifyClass (value) { + var res = ''; + if (!value) { + return res + } + if (typeof value === 'string') { + return value + } + if (Array.isArray(value)) { + var stringified; + for (var i = 0, l = value.length; i < l; i++) { + if (value[i]) { + if ((stringified = stringifyClass(value[i]))) { + res += stringified + ' '; } - }; - - // check if this is a multiple select - var multiple = this.multiple = el.hasAttribute('multiple'); - - // attach listener - this.listener = function () { - var value = getValue(el, multiple); - value = self.params.number ? isArray(value) ? value.map(toNumber) : toNumber(value) : value; - self.set(value); - }; - this.on('change', this.listener); - - // if has initial value, set afterBind - var initValue = getValue(el, multiple, true); - if (multiple && initValue.length || !multiple && initValue !== null) { - this.afterBind = this.listener; - } - - // All major browsers except Firefox resets - // selectedIndex with value -1 to 0 when the element - // is appended to a new parent, therefore we have to - // force a DOM update whenever that happens... - this.vm.$on('hook:attached', function () { - nextTick(_this.forceUpdate); - }); - if (!inDoc(el)) { - nextTick(this.forceUpdate); - } - }, - - update: function update(value) { - var el = this.el; - el.selectedIndex = -1; - var multi = this.multiple && isArray(value); - var options = el.options; - var i = options.length; - var op, val; - while (i--) { - op = options[i]; - val = op.hasOwnProperty('_value') ? op._value : op.value; - /* eslint-disable eqeqeq */ - op.selected = multi ? indexOf$1(value, val) > -1 : looseEqual(value, val); - /* eslint-enable eqeqeq */ } - }, - - unbind: function unbind() { - /* istanbul ignore next */ - this.vm.$off('hook:attached', this.forceUpdate); } - }; - - /** - * Get select value - * - * @param {SelectElement} el - * @param {Boolean} multi - * @param {Boolean} init - * @return {Array|*} - */ - - function getValue(el, multi, init) { - var res = multi ? [] : null; - var op, val, selected; - for (var i = 0, l = el.options.length; i < l; i++) { - op = el.options[i]; - selected = init ? op.hasAttribute('selected') : op.selected; - if (selected) { - val = op.hasOwnProperty('_value') ? op._value : op.value; - if (multi) { - res.push(val); - } else { - return val; - } - } + return res.slice(0, -1) + } + if (isObject(value)) { + for (var key in value) { + if (value[key]) { res += key + ' '; } } - return res; + return res.slice(0, -1) + } + /* istanbul ignore next */ + return res +} + +/* */ + +var namespaceMap = { + svg: 'http://www.w3.org/2000/svg', + math: 'http://www.w3.org/1998/Math/MathML' +}; + +var isHTMLTag = makeMap( + 'html,body,base,head,link,meta,style,title,' + + 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' + + 'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' + + 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' + + 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' + + 'embed,object,param,source,canvas,script,noscript,del,ins,' + + 'caption,col,colgroup,table,thead,tbody,td,th,tr,' + + 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' + + 'output,progress,select,textarea,' + + 'details,dialog,menu,menuitem,summary,' + + 'content,element,shadow,template' +); + +var isUnaryTag = makeMap( + 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' + + 'link,meta,param,source,track,wbr', + true +); + +// Elements that you can, intentionally, leave open +// (and which close themselves) +var canBeLeftOpenTag = makeMap( + 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source', + true +); + +// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3 +// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content +var isNonPhrasingTag = makeMap( + 'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' + + 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' + + 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' + + 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' + + 'title,tr,track', + true +); + +// this map is intentionally selective, only covering SVG elements that may +// contain child elements. +var isSVG = makeMap( + 'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font,' + + 'font-face,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' + + 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', + true +); + +var isPreTag = function (tag) { return tag === 'pre'; }; + +var isReservedTag = function (tag) { + return isHTMLTag(tag) || isSVG(tag) +}; + +function getTagNamespace (tag) { + if (isSVG(tag)) { + return 'svg' + } + // basic support for MathML + // note it doesn't support other MathML elements being component roots + if (tag === 'math') { + return 'math' + } +} + +var unknownElementCache = Object.create(null); +function isUnknownElement (tag) { + /* istanbul ignore if */ + if (!inBrowser) { + return true + } + if (isReservedTag(tag)) { + return false + } + tag = tag.toLowerCase(); + /* istanbul ignore if */ + if (unknownElementCache[tag] != null) { + return unknownElementCache[tag] + } + var el = document.createElement(tag); + if (tag.indexOf('-') > -1) { + // http://stackoverflow.com/a/28210364/1070244 + return (unknownElementCache[tag] = ( + el.constructor === window.HTMLUnknownElement || + el.constructor === window.HTMLElement + )) + } else { + return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString())) } +} - /** - * Native Array.indexOf uses strict equal, but in this - * case we need to match string/numbers with custom equal. - * - * @param {Array} arr - * @param {*} val - */ +/* */ - function indexOf$1(arr, val) { - var i = arr.length; - while (i--) { - if (looseEqual(arr[i], val)) { - return i; +/** + * Query an element selector if it's not an element already. + */ +function query (el) { + if (typeof el === 'string') { + var selector = el; + el = document.querySelector(el); + if (!el) { + "development" !== 'production' && warn( + 'Cannot find element: ' + selector + ); + return document.createElement('div') + } + } + return el +} + +/* */ + +function createElement$1 (tagName, vnode) { + var elm = document.createElement(tagName); + if (tagName !== 'select') { + return elm + } + if (vnode.data && vnode.data.attrs && 'multiple' in vnode.data.attrs) { + elm.setAttribute('multiple', 'multiple'); + } + return elm +} + +function createElementNS (namespace, tagName) { + return document.createElementNS(namespaceMap[namespace], tagName) +} + +function createTextNode (text) { + return document.createTextNode(text) +} + +function createComment (text) { + return document.createComment(text) +} + +function insertBefore (parentNode, newNode, referenceNode) { + parentNode.insertBefore(newNode, referenceNode); +} + +function removeChild (node, child) { + node.removeChild(child); +} + +function appendChild (node, child) { + node.appendChild(child); +} + +function parentNode (node) { + return node.parentNode +} + +function nextSibling (node) { + return node.nextSibling +} + +function tagName (node) { + return node.tagName +} + +function setTextContent (node, text) { + node.textContent = text; +} + +function childNodes (node) { + return node.childNodes +} + +function setAttribute (node, key, val) { + node.setAttribute(key, val); +} + + +var nodeOps = Object.freeze({ + createElement: createElement$1, + createElementNS: createElementNS, + createTextNode: createTextNode, + createComment: createComment, + insertBefore: insertBefore, + removeChild: removeChild, + appendChild: appendChild, + parentNode: parentNode, + nextSibling: nextSibling, + tagName: tagName, + setTextContent: setTextContent, + childNodes: childNodes, + setAttribute: setAttribute +}); + +/* */ + +var ref = { + create: function create (_, vnode) { + registerRef(vnode); + }, + update: function update (oldVnode, vnode) { + if (oldVnode.data.ref !== vnode.data.ref) { + registerRef(oldVnode, true); + registerRef(vnode); + } + }, + destroy: function destroy (vnode) { + registerRef(vnode, true); + } +}; + +function registerRef (vnode, isRemoval) { + var key = vnode.data.ref; + if (!key) { return } + + var vm = vnode.context; + var ref = vnode.child || vnode.elm; + var refs = vm.$refs; + if (isRemoval) { + if (Array.isArray(refs[key])) { + remove$1(refs[key], ref); + } else if (refs[key] === ref) { + refs[key] = undefined; + } + } else { + if (vnode.data.refInFor) { + if (Array.isArray(refs[key])) { + refs[key].push(ref); + } else { + refs[key] = [ref]; } + } else { + refs[key] = ref; } - return -1; } +} - var checkbox = { +/** + * Virtual DOM patching algorithm based on Snabbdom by + * Simon Friis Vindum (@paldepind) + * Licensed under the MIT License + * https://github.com/paldepind/snabbdom/blob/master/LICENSE + * + * modified by Evan You (@yyx990803) + * - bind: function bind() { - var self = this; - var el = this.el; +/* + * Not type-checking this because this file is perf-critical and the cost + * of making flow understand it is not worth it. + */ - this.getValue = function () { - return el.hasOwnProperty('_value') ? el._value : self.params.number ? toNumber(el.value) : el.value; - }; +var emptyNode = new VNode('', {}, []); - function getBooleanValue() { - var val = el.checked; - if (val && el.hasOwnProperty('_trueValue')) { - return el._trueValue; - } - if (!val && el.hasOwnProperty('_falseValue')) { - return el._falseValue; - } - return val; - } +var hooks$1 = ['create', 'update', 'remove', 'destroy']; - this.listener = function () { - var model = self._watcher.value; - if (isArray(model)) { - var val = self.getValue(); - if (el.checked) { - if (indexOf(model, val) < 0) { - model.push(val); - } - } else { - model.$remove(val); - } - } else { - self.set(getBooleanValue()); - } - }; +function isUndef (s) { + return s == null +} - this.on('change', this.listener); - if (el.hasAttribute('checked')) { - this.afterBind = this.listener; - } - }, +function isDef (s) { + return s != null +} - update: function update(value) { - var el = this.el; - if (isArray(value)) { - el.checked = indexOf(value, this.getValue()) > -1; - } else { - if (el.hasOwnProperty('_trueValue')) { - el.checked = looseEqual(value, el._trueValue); - } else { - el.checked = !!value; - } - } - } - }; +function sameVnode (vnode1, vnode2) { + return ( + vnode1.key === vnode2.key && + vnode1.tag === vnode2.tag && + vnode1.isComment === vnode2.isComment && + !vnode1.data === !vnode2.data + ) +} - var handlers = { - text: text$2, - radio: radio, - select: select, - checkbox: checkbox - }; +function createKeyToOldIdx (children, beginIdx, endIdx) { + var i, key; + var map = {}; + for (i = beginIdx; i <= endIdx; ++i) { + key = children[i].key; + if (isDef(key)) { map[key] = i; } + } + return map +} - var model = { - - priority: MODEL, - twoWay: true, - handlers: handlers, - params: ['lazy', 'number', 'debounce'], - - /** - * Possible elements: - * <select> - * <textarea> - * <input type="*"> - * - text - * - checkbox - * - radio - * - number - */ - - bind: function bind() { - // friendly warning... - this.checkFilters(); - if (this.hasRead && !this.hasWrite) { - 'development' !== '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); - } - var el = this.el; - var tag = el.tagName; - var handler; - if (tag === 'INPUT') { - handler = handlers[el.type] || handlers.text; - } else if (tag === 'SELECT') { - handler = handlers.select; - } else if (tag === 'TEXTAREA') { - handler = handlers.text; - } else { - 'development' !== 'production' && warn('v-model does not support element type: ' + tag, this.vm); - return; - } - el.__v_model = this; - handler.bind.call(this); - this.update = handler.update; - this._unbind = handler.unbind; - }, +function createPatchFunction (backend) { + var i, j; + var cbs = {}; - /** - * Check read/write filter stats. - */ - - checkFilters: function checkFilters() { - var filters = this.filters; - if (!filters) return; - var i = filters.length; - while (i--) { - var filter = resolveAsset(this.vm.$options, 'filters', filters[i].name); - if (typeof filter === 'function' || filter.read) { - this.hasRead = true; - } - if (filter.write) { - this.hasWrite = true; - } - } - }, + var modules = backend.modules; + var nodeOps = backend.nodeOps; - unbind: function unbind() { - this.el.__v_model = null; - this._unbind && this._unbind(); + for (i = 0; i < hooks$1.length; ++i) { + cbs[hooks$1[i]] = []; + for (j = 0; j < modules.length; ++j) { + if (modules[j][hooks$1[i]] !== undefined) { cbs[hooks$1[i]].push(modules[j][hooks$1[i]]); } } - }; + } - // keyCode aliases - var keyCodes = { - esc: 27, - tab: 9, - enter: 13, - space: 32, - 'delete': [8, 46], - up: 38, - left: 37, - right: 39, - down: 40 - }; + function emptyNodeAt (elm) { + return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm) + } - function keyFilter(handler, keys) { - var codes = keys.map(function (key) { - var charCode = key.charCodeAt(0); - if (charCode > 47 && charCode < 58) { - return parseInt(key, 10); + function createRmCb (childElm, listeners) { + function remove$$1 () { + if (--remove$$1.listeners === 0) { + removeElement(childElm); } - if (key.length === 1) { - charCode = key.toUpperCase().charCodeAt(0); - if (charCode > 64 && charCode < 91) { - return charCode; - } - } - return keyCodes[key]; - }); - codes = [].concat.apply([], codes); - return function keyHandler(e) { - if (codes.indexOf(e.keyCode) > -1) { - return handler.call(this, e); - } - }; + } + remove$$1.listeners = listeners; + return remove$$1 } - function stopFilter(handler) { - return function stopHandler(e) { - e.stopPropagation(); - return handler.call(this, e); - }; + function removeElement (el) { + var parent = nodeOps.parentNode(el); + nodeOps.removeChild(parent, el); } - function preventFilter(handler) { - return function preventHandler(e) { - e.preventDefault(); - return handler.call(this, e); - }; + function createElm (vnode, insertedVnodeQueue, nested) { + var i; + var data = vnode.data; + vnode.isRootInsert = !nested; + if (isDef(data)) { + if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode); } + // after calling the init hook, if the vnode is a child component + // it should've created a child instance and mounted it. the child + // component also has set the placeholder vnode's elm. + // in that case we can just return the element and be done. + if (isDef(i = vnode.child)) { + initComponent(vnode, insertedVnodeQueue); + return vnode.elm + } + } + var children = vnode.children; + var tag = vnode.tag; + if (isDef(tag)) { + { + if ( + !vnode.ns && + !(config.ignoredElements && config.ignoredElements.indexOf(tag) > -1) && + config.isUnknownElement(tag) + ) { + warn( + 'Unknown custom element: <' + tag + '> - did you ' + + 'register the component correctly? For recursive components, ' + + 'make sure to provide the "name" option.', + vnode.context + ); + } + } + vnode.elm = vnode.ns + ? nodeOps.createElementNS(vnode.ns, tag) + : nodeOps.createElement(tag, vnode); + setScope(vnode); + createChildren(vnode, children, insertedVnodeQueue); + if (isDef(data)) { + invokeCreateHooks(vnode, insertedVnodeQueue); + } + } else if (vnode.isComment) { + vnode.elm = nodeOps.createComment(vnode.text); + } else { + vnode.elm = nodeOps.createTextNode(vnode.text); + } + return vnode.elm } - function selfFilter(handler) { - return function selfHandler(e) { - if (e.target === e.currentTarget) { - return handler.call(this, e); + function createChildren (vnode, children, insertedVnodeQueue) { + if (Array.isArray(children)) { + for (var i = 0; i < children.length; ++i) { + nodeOps.appendChild(vnode.elm, createElm(children[i], insertedVnodeQueue, true)); } - }; + } else if (isPrimitive(vnode.text)) { + nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text)); + } } - var on$1 = { - - priority: ON, - acceptStatement: true, - keyCodes: keyCodes, - - bind: function bind() { - // deal with iframes - if (this.el.tagName === 'IFRAME' && this.arg !== 'load') { - var self = this; - this.iframeBind = function () { - on(self.el.contentWindow, self.arg, self.handler, self.modifiers.capture); - }; - this.on('load', this.iframeBind); - } - }, - - update: function update(handler) { - // stub a noop for v-on with no value, - // e.g. @mousedown.prevent - if (!this.descriptor.raw) { - handler = function () {}; - } - - if (typeof handler !== 'function') { - 'development' !== 'production' && warn('v-on:' + this.arg + '="' + this.expression + '" expects a function value, ' + 'got ' + handler, this.vm); - return; - } - - // apply modifiers - if (this.modifiers.stop) { - handler = stopFilter(handler); - } - if (this.modifiers.prevent) { - handler = preventFilter(handler); - } - if (this.modifiers.self) { - handler = selfFilter(handler); - } - // key filter - var keys = Object.keys(this.modifiers).filter(function (key) { - return key !== 'stop' && key !== 'prevent' && key !== 'self' && key !== 'capture'; - }); - if (keys.length) { - handler = keyFilter(handler, keys); - } - - this.reset(); - this.handler = handler; - - if (this.iframeBind) { - this.iframeBind(); - } else { - on(this.el, this.arg, this.handler, this.modifiers.capture); - } - }, - - reset: function reset() { - var el = this.iframeBind ? this.el.contentWindow : this.el; - if (this.handler) { - off(el, this.arg, this.handler); - } - }, - - unbind: function unbind() { - this.reset(); + function isPatchable (vnode) { + while (vnode.child) { + vnode = vnode.child._vnode; } - }; - - var prefixes = ['-webkit-', '-moz-', '-ms-']; - var camelPrefixes = ['Webkit', 'Moz', 'ms']; - var importantRE = /!important;?$/; - var propCache = Object.create(null); - - var testEl = null; - - var style = { - - deep: true, - - update: function update(value) { - if (typeof value === 'string') { - this.el.style.cssText = value; - } else if (isArray(value)) { - this.handleObject(value.reduce(extend, {})); - } else { - this.handleObject(value || {}); - } - }, - - handleObject: function handleObject(value) { - // cache object styles so that only changed props - // are actually updated. - var cache = this.cache || (this.cache = {}); - var name, val; - for (name in cache) { - if (!(name in value)) { - this.handleSingle(name, null); - delete cache[name]; - } - } - for (name in value) { - val = value[name]; - if (val !== cache[name]) { - cache[name] = val; - this.handleSingle(name, val); - } - } - }, + return isDef(vnode.tag) + } - handleSingle: function handleSingle(prop, value) { - prop = normalize(prop); - if (!prop) return; // unsupported prop - // cast possible numbers/booleans into strings - if (value != null) value += ''; - if (value) { - var isImportant = importantRE.test(value) ? 'important' : ''; - if (isImportant) { - /* istanbul ignore if */ - if ('development' !== 'production') { - warn('It\'s probably a bad idea to use !important with inline rules. ' + 'This feature will be deprecated in a future version of Vue.'); - } - value = value.replace(importantRE, '').trim(); - this.el.style.setProperty(prop.kebab, value, isImportant); - } else { - this.el.style[prop.camel] = value; - } - } else { - this.el.style[prop.camel] = ''; - } + function invokeCreateHooks (vnode, insertedVnodeQueue) { + for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) { + cbs.create[i$1](emptyNode, vnode); } - - }; - - /** - * Normalize a CSS property name. - * - cache result - * - auto prefix - * - camelCase -> dash-case - * - * @param {String} prop - * @return {String} - */ - - function normalize(prop) { - if (propCache[prop]) { - return propCache[prop]; + i = vnode.data.hook; // Reuse variable + if (isDef(i)) { + if (i.create) { i.create(emptyNode, vnode); } + if (i.insert) { insertedVnodeQueue.push(vnode); } } - var res = prefix(prop); - propCache[prop] = propCache[res] = res; - return res; } - /** - * Auto detect the appropriate prefix for a CSS property. - * https://gist.github.com/paulirish/523692 - * - * @param {String} prop - * @return {String} - */ - - function prefix(prop) { - prop = hyphenate(prop); - var camel = camelize(prop); - var upper = camel.charAt(0).toUpperCase() + camel.slice(1); - if (!testEl) { - testEl = document.createElement('div'); - } - var i = prefixes.length; - var prefixed; - if (camel !== 'filter' && camel in testEl.style) { - return { - kebab: prop, - camel: camel - }; + function initComponent (vnode, insertedVnodeQueue) { + if (vnode.data.pendingInsert) { + insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert); } - while (i--) { - prefixed = camelPrefixes[i] + upper; - if (prefixed in testEl.style) { - return { - kebab: prefixes[i] + prop, - camel: prefixed - }; - } - } - } - - // xlink - var xlinkNS = 'http://www.w3.org/1999/xlink'; - var xlinkRE = /^xlink:/; - - // check for attributes that prohibit interpolations - var disallowedInterpAttrRE = /^v-|^:|^@|^(?:is|transition|transition-mode|debounce|track-by|stagger|enter-stagger|leave-stagger)$/; - // these attributes should also set their corresponding properties - // because they only affect the initial state of the element - var attrWithPropsRE = /^(?:value|checked|selected|muted)$/; - // these attributes expect enumrated values of "true" or "false" - // but are not boolean attributes - var enumeratedAttrRE = /^(?:draggable|contenteditable|spellcheck)$/; - - // these attributes should set a hidden property for - // binding v-model to object values - var modelProps = { - value: '_value', - 'true-value': '_trueValue', - 'false-value': '_falseValue' - }; + vnode.elm = vnode.child.$el; + if (isPatchable(vnode)) { + invokeCreateHooks(vnode, insertedVnodeQueue); + setScope(vnode); + } else { + // empty component root. + // skip all element-related modules except for ref (#3455) + registerRef(vnode); + // make sure to invoke the insert hook + insertedVnodeQueue.push(vnode); + } + } - var bind$1 = { + // set scope id attribute for scoped CSS. + // this is implemented as a special case to avoid the overhead + // of going through the normal attribute patching process. + function setScope (vnode) { + var i; + if (isDef(i = vnode.context) && isDef(i = i.$options._scopeId)) { + nodeOps.setAttribute(vnode.elm, i, ''); + } + if (isDef(i = activeInstance) && + i !== vnode.context && + isDef(i = i.$options._scopeId)) { + nodeOps.setAttribute(vnode.elm, i, ''); + } + } - priority: BIND, + function addVnodes (parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) { + for (; startIdx <= endIdx; ++startIdx) { + nodeOps.insertBefore(parentElm, createElm(vnodes[startIdx], insertedVnodeQueue), before); + } + } - bind: function bind() { - var attr = this.arg; - var tag = this.el.tagName; - // should be deep watch on object mode - if (!attr) { - this.deep = true; + function invokeDestroyHook (vnode) { + var i, j; + var data = vnode.data; + if (isDef(data)) { + if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); } + for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); } + } + if (isDef(i = vnode.children)) { + for (j = 0; j < vnode.children.length; ++j) { + invokeDestroyHook(vnode.children[j]); } - // handle interpolation bindings - var descriptor = this.descriptor; - var tokens = descriptor.interp; - if (tokens) { - // handle interpolations with one-time tokens - if (descriptor.hasOneTime) { - this.expression = tokensToExp(tokens, this._scope || this.vm); - } - - // only allow binding on native attributes - if (disallowedInterpAttrRE.test(attr) || attr === 'name' && (tag === 'PARTIAL' || tag === 'SLOT')) { - 'development' !== 'production' && warn(attr + '="' + descriptor.raw + '": ' + 'attribute interpolation is not allowed in Vue.js ' + 'directives and special attributes.', this.vm); - this.el.removeAttribute(attr); - this.invalid = true; - } - - /* istanbul ignore if */ - if ('development' !== 'production') { - var raw = attr + '="' + descriptor.raw + '": '; - // warn src - if (attr === 'src') { - warn(raw + 'interpolation in "src" attribute will cause ' + 'a 404 request. Use v-bind:src instead.', this.vm); - } + } + } - // warn style - if (attr === 'style') { - warn(raw + 'interpolation in "style" attribute will cause ' + 'the attribute to be discarded in Internet Explorer. ' + 'Use v-bind:style instead.', this.vm); - } + function removeVnodes (parentElm, vnodes, startIdx, endIdx) { + for (; startIdx <= endIdx; ++startIdx) { + var ch = vnodes[startIdx]; + if (isDef(ch)) { + if (isDef(ch.tag)) { + removeAndInvokeRemoveHook(ch); + invokeDestroyHook(ch); + } else { // Text node + nodeOps.removeChild(parentElm, ch.elm); } } - }, + } + } - update: function update(value) { - if (this.invalid) { - return; - } - var attr = this.arg; - if (this.arg) { - this.handleSingle(attr, value); + function removeAndInvokeRemoveHook (vnode, rm) { + if (rm || isDef(vnode.data)) { + var listeners = cbs.remove.length + 1; + if (!rm) { + // directly removing + rm = createRmCb(vnode.elm, listeners); } else { - this.handleObject(value || {}); + // we have a recursively passed down rm callback + // increase the listeners count + rm.listeners += listeners; } - }, - - // share object handler with v-bind:class - handleObject: style.handleObject, - - handleSingle: function handleSingle(attr, value) { - var el = this.el; - var interp = this.descriptor.interp; - if (this.modifiers.camel) { - attr = camelize(attr); + // recursively invoke hooks on child component root node + if (isDef(i = vnode.child) && isDef(i = i._vnode) && isDef(i.data)) { + removeAndInvokeRemoveHook(i, rm); } - if (!interp && attrWithPropsRE.test(attr) && attr in el) { - var attrValue = attr === 'value' ? value == null // IE9 will set input.value to "null" for null... - ? '' : value : value; - - if (el[attr] !== attrValue) { - el[attr] = attrValue; - } + for (i = 0; i < cbs.remove.length; ++i) { + cbs.remove[i](vnode, rm); } - // set model props - var modelProp = modelProps[attr]; - if (!interp && modelProp) { - el[modelProp] = value; - // update v-model if present - var model = el.__v_model; - if (model) { - model.listener(); - } + if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) { + i(vnode, rm); + } else { + rm(); } - // do not set value attribute for textarea - if (attr === 'value' && el.tagName === 'TEXTAREA') { - el.removeAttribute(attr); - return; - } - // update attribute - if (enumeratedAttrRE.test(attr)) { - el.setAttribute(attr, value ? 'true' : 'false'); - } else if (value != null && value !== false) { - if (attr === 'class') { - // handle edge case #1960: - // class interpolation should not overwrite Vue transition class - if (el.__v_trans) { - value += ' ' + el.__v_trans.id + '-transition'; - } - setClass(el, value); - } else if (xlinkRE.test(attr)) { - el.setAttributeNS(xlinkNS, attr, value === true ? '' : value); + } else { + removeElement(vnode.elm); + } + } + + function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) { + var oldStartIdx = 0; + var newStartIdx = 0; + var oldEndIdx = oldCh.length - 1; + var oldStartVnode = oldCh[0]; + var oldEndVnode = oldCh[oldEndIdx]; + var newEndIdx = newCh.length - 1; + var newStartVnode = newCh[0]; + var newEndVnode = newCh[newEndIdx]; + var oldKeyToIdx, idxInOld, elmToMove, before; + + // removeOnly is a special flag used only by <transition-group> + // to ensure removed elements stay in correct relative positions + // during leaving transitions + var canMove = !removeOnly; + + while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { + if (isUndef(oldStartVnode)) { + oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left + } else if (isUndef(oldEndVnode)) { + oldEndVnode = oldCh[--oldEndIdx]; + } else if (sameVnode(oldStartVnode, newStartVnode)) { + patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue); + oldStartVnode = oldCh[++oldStartIdx]; + newStartVnode = newCh[++newStartIdx]; + } else if (sameVnode(oldEndVnode, newEndVnode)) { + patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue); + oldEndVnode = oldCh[--oldEndIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right + patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue); + canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm)); + oldStartVnode = oldCh[++oldStartIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left + patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue); + canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm); + oldEndVnode = oldCh[--oldEndIdx]; + newStartVnode = newCh[++newStartIdx]; + } else { + if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); } + idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null; + if (isUndef(idxInOld)) { // New element + nodeOps.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; } else { - el.setAttribute(attr, value === true ? '' : value); + elmToMove = oldCh[idxInOld]; + /* istanbul ignore if */ + if ("development" !== 'production' && !elmToMove) { + warn( + 'It seems there are duplicate keys that is causing an update error. ' + + 'Make sure each v-for item has a unique key.' + ); + } + if (elmToMove.tag !== newStartVnode.tag) { + // same key but different element. treat as new element + nodeOps.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } else { + patchVnode(elmToMove, newStartVnode, insertedVnodeQueue); + oldCh[idxInOld] = undefined; + canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } } - } else { - el.removeAttribute(attr); } } - }; - - var el = { - - priority: EL, - - bind: function bind() { - /* istanbul ignore if */ - if (!this.arg) { - return; - } - var id = this.id = camelize(this.arg); - var refs = (this._scope || this.vm).$els; - if (hasOwn(refs, id)) { - refs[id] = this.el; - } else { - defineReactive(refs, id, this.el); - } - }, - - unbind: function unbind() { - var refs = (this._scope || this.vm).$els; - if (refs[this.id] === this.el) { - refs[this.id] = null; - } + if (oldStartIdx > oldEndIdx) { + before = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm; + addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); + } else if (newStartIdx > newEndIdx) { + removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx); } - }; + } - var ref = { - bind: function bind() { - 'development' !== 'production' && warn('v-ref:' + this.arg + ' must be used on a child ' + 'component. Found on <' + this.el.tagName.toLowerCase() + '>.', this.vm); + function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) { + if (oldVnode === vnode) { + return } - }; - - var cloak = { - bind: function bind() { - var el = this.el; - this.vm.$once('pre-hook:compiled', function () { - el.removeAttribute('v-cloak'); - }); + // reuse element for static trees. + // note we only do this if the vnode is cloned - + // if the new node is not cloned it means the render functions have been + // reset by the hot-reload-api and we need to do a proper re-render. + if (vnode.isStatic && + oldVnode.isStatic && + vnode.key === oldVnode.key && + vnode.isCloned) { + vnode.elm = oldVnode.elm; + return } - }; - - // must export plain object - var directives = { - text: text$1, - html: html, - 'for': vFor, - 'if': vIf, - show: show, - model: model, - on: on$1, - bind: bind$1, - el: el, - ref: ref, - cloak: cloak - }; - - var vClass = { - - deep: true, - - update: function update(value) { - if (!value) { - this.cleanup(); - } else if (typeof value === 'string') { - this.setClass(value.trim().split(/\s+/)); - } else { - this.setClass(normalize$1(value)); + var i; + var data = vnode.data; + var hasData = isDef(data); + if (hasData && isDef(i = data.hook) && isDef(i = i.prepatch)) { + i(oldVnode, vnode); + } + var elm = vnode.elm = oldVnode.elm; + var oldCh = oldVnode.children; + var ch = vnode.children; + if (hasData && isPatchable(vnode)) { + for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); } + if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); } + } + if (isUndef(vnode.text)) { + if (isDef(oldCh) && isDef(ch)) { + if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); } + } else if (isDef(ch)) { + if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); } + addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); + } else if (isDef(oldCh)) { + removeVnodes(elm, oldCh, 0, oldCh.length - 1); + } else if (isDef(oldVnode.text)) { + nodeOps.setTextContent(elm, ''); + } + } else if (oldVnode.text !== vnode.text) { + nodeOps.setTextContent(elm, vnode.text); + } + if (hasData) { + if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); } + } + } + + function invokeInsertHook (vnode, queue, initial) { + // delay insert hooks for component root nodes, invoke them after the + // element is really inserted + if (initial && vnode.parent) { + vnode.parent.data.pendingInsert = queue; + } else { + for (var i = 0; i < queue.length; ++i) { + queue[i].data.hook.insert(queue[i]); } - }, + } + } - setClass: function setClass(value) { - this.cleanup(value); - for (var i = 0, l = value.length; i < l; i++) { - var val = value[i]; - if (val) { - apply(this.el, val, addClass); - } + var bailed = false; + function hydrate (elm, vnode, insertedVnodeQueue) { + { + if (!assertNodeMatch(elm, vnode)) { + return false } - this.prevKeys = value; - }, - - cleanup: function cleanup(value) { - var prevKeys = this.prevKeys; - if (!prevKeys) return; - var i = prevKeys.length; - while (i--) { - var key = prevKeys[i]; - if (!value || value.indexOf(key) < 0) { - apply(this.el, key, removeClass); - } + } + vnode.elm = elm; + var tag = vnode.tag; + var data = vnode.data; + var children = vnode.children; + if (isDef(data)) { + if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); } + if (isDef(i = vnode.child)) { + // child component. it should have hydrated its own tree. + initComponent(vnode, insertedVnodeQueue); + return true } } - }; - - /** - * Normalize objects and arrays (potentially containing objects) - * into array of strings. - * - * @param {Object|Array<String|Object>} value - * @return {Array<String>} - */ - - function normalize$1(value) { - var res = []; - if (isArray(value)) { - for (var i = 0, l = value.length; i < l; i++) { - var _key = value[i]; - if (_key) { - if (typeof _key === 'string') { - res.push(_key); + if (isDef(tag)) { + if (isDef(children)) { + var childNodes = nodeOps.childNodes(elm); + // empty element, allow client to pick up and populate children + if (!childNodes.length) { + createChildren(vnode, children, insertedVnodeQueue); + } else { + var childrenMatch = true; + if (childNodes.length !== children.length) { + childrenMatch = false; } else { - for (var k in _key) { - if (_key[k]) res.push(k); + for (var i$1 = 0; i$1 < children.length; i$1++) { + if (!hydrate(childNodes[i$1], children[i$1], insertedVnodeQueue)) { + childrenMatch = false; + break + } } } + if (!childrenMatch) { + if ("development" !== 'production' && + typeof console !== 'undefined' && + !bailed) { + bailed = true; + console.warn('Parent: ', elm); + console.warn('Mismatching childNodes vs. VNodes: ', childNodes, children); + } + return false + } } } - } else if (isObject(value)) { - for (var key in value) { - if (value[key]) res.push(key); + if (isDef(data)) { + invokeCreateHooks(vnode, insertedVnodeQueue); } } - return res; + return true } - /** - * Add or remove a class/classes on an element - * - * @param {Element} el - * @param {String} key The class name. This may or may not - * contain a space character, in such a - * case we'll deal with multiple class - * names at once. - * @param {Function} fn - */ - - function apply(el, key, fn) { - key = key.trim(); - if (key.indexOf(' ') === -1) { - fn(el, key); - return; - } - // The key contains one or more space characters. - // Since a class name doesn't accept such characters, we - // treat it as multiple classes. - var keys = key.split(/\s+/); - for (var i = 0, l = keys.length; i < l; i++) { - fn(el, keys[i]); + function assertNodeMatch (node, vnode) { + if (vnode.tag) { + return ( + vnode.tag.indexOf('vue-component') === 0 || + vnode.tag === nodeOps.tagName(node).toLowerCase() + ) + } else { + return _toString(vnode.text) === node.data } } - var component = { - - priority: COMPONENT, - - params: ['keep-alive', 'transition-mode', 'inline-template'], - - /** - * Setup. Two possible usages: - * - * - static: - * <comp> or <div v-component="comp"> - * - * - dynamic: - * <component :is="view"> - */ - - bind: function bind() { - if (!this.el.__vue__) { - // keep-alive cache - this.keepAlive = this.params.keepAlive; - if (this.keepAlive) { - this.cache = {}; - } - // check inline-template - if (this.params.inlineTemplate) { - // extract inline template as a DocumentFragment - this.inlineTemplate = extractContent(this.el, true); - } - // component resolution related state - this.pendingComponentCb = this.Component = null; - // transition related state - this.pendingRemovals = 0; - this.pendingRemovalCb = null; - // create a ref anchor - this.anchor = createAnchor('v-component'); - replace(this.el, this.anchor); - // remove is attribute. - // this is removed during compilation, but because compilation is - // cached, when the component is used elsewhere this attribute - // will remain at link time. - this.el.removeAttribute('is'); - this.el.removeAttribute(':is'); - // remove ref, same as above - if (this.descriptor.ref) { - this.el.removeAttribute('v-ref:' + hyphenate(this.descriptor.ref)); - } - // if static, build right now. - if (this.literal) { - this.setComponent(this.expression); - } - } else { - 'development' !== 'production' && warn('cannot mount component "' + this.expression + '" ' + 'on already mounted element: ' + this.el); - } - }, - - /** - * Public update, called by the watcher in the dynamic - * literal scenario, e.g. <component :is="view"> - */ + return function patch (oldVnode, vnode, hydrating, removeOnly) { + if (!vnode) { + if (oldVnode) { invokeDestroyHook(oldVnode); } + return + } - update: function update(value) { - if (!this.literal) { - this.setComponent(value); - } - }, + var elm, parent; + var isInitialPatch = false; + var insertedVnodeQueue = []; - /** - * Switch dynamic components. May resolve the component - * asynchronously, and perform transition based on - * specified transition mode. Accepts a few additional - * arguments specifically for vue-router. - * - * The callback is called when the full transition is - * finished. - * - * @param {String} value - * @param {Function} [cb] - */ - - setComponent: function setComponent(value, cb) { - this.invalidatePending(); - if (!value) { - // just remove current - this.unbuild(true); - this.remove(this.childVM, cb); - this.childVM = null; + if (!oldVnode) { + // empty mount, create new root element + isInitialPatch = true; + createElm(vnode, insertedVnodeQueue); + } else { + var isRealElement = isDef(oldVnode.nodeType); + if (!isRealElement && sameVnode(oldVnode, vnode)) { + patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly); } else { - var self = this; - this.resolveComponent(value, function () { - self.mountComponent(cb); - }); - } - }, - - /** - * Resolve the component constructor to use when creating - * the child vm. - * - * @param {String|Function} value - * @param {Function} cb - */ - - resolveComponent: function resolveComponent(value, cb) { - var self = this; - this.pendingComponentCb = cancellable(function (Component) { - self.ComponentName = Component.options.name || (typeof value === 'string' ? value : null); - self.Component = Component; - cb(); - }); - this.vm._resolveComponent(value, this.pendingComponentCb); - }, - - /** - * Create a new instance using the current constructor and - * replace the existing instance. This method doesn't care - * whether the new component and the old one are actually - * the same. - * - * @param {Function} [cb] - */ - - mountComponent: function mountComponent(cb) { - // actual mount - this.unbuild(true); - var self = this; - var activateHooks = this.Component.options.activate; - var cached = this.getCached(); - var newComponent = this.build(); - if (activateHooks && !cached) { - this.waitingFor = newComponent; - callActivateHooks(activateHooks, newComponent, function () { - if (self.waitingFor !== newComponent) { - return; + if (isRealElement) { + // mounting to a real element + // check if this is server-rendered content and if we can perform + // a successful hydration. + if (oldVnode.nodeType === 1 && oldVnode.hasAttribute('server-rendered')) { + oldVnode.removeAttribute('server-rendered'); + hydrating = true; } - self.waitingFor = null; - self.transition(newComponent, cb); - }); - } else { - // update ref for kept-alive component - if (cached) { - newComponent._updateRef(); - } - this.transition(newComponent, cb); - } - }, - - /** - * When the component changes or unbinds before an async - * constructor is resolved, we need to invalidate its - * pending callback. - */ - - invalidatePending: function invalidatePending() { - if (this.pendingComponentCb) { - this.pendingComponentCb.cancel(); - this.pendingComponentCb = null; - } - }, - - /** - * Instantiate/insert a new child vm. - * If keep alive and has cached instance, insert that - * instance; otherwise build a new one and cache it. - * - * @param {Object} [extraOptions] - * @return {Vue} - the created instance - */ - - build: function build(extraOptions) { - var cached = this.getCached(); - if (cached) { - return cached; - } - if (this.Component) { - // default options - var options = { - name: this.ComponentName, - el: cloneNode(this.el), - template: this.inlineTemplate, - // make sure to add the child with correct parent - // if this is a transcluded component, its parent - // should be the transclusion host. - parent: this._host || this.vm, - // if no inline-template, then the compiled - // linker can be cached for better performance. - _linkerCachable: !this.inlineTemplate, - _ref: this.descriptor.ref, - _asComponent: true, - _isRouterView: this._isRouterView, - // if this is a transcluded component, context - // will be the common parent vm of this instance - // and its host. - _context: this.vm, - // if this is inside an inline v-for, the scope - // will be the intermediate scope created for this - // repeat fragment. this is used for linking props - // and container directives. - _scope: this._scope, - // pass in the owner fragment of this component. - // this is necessary so that the fragment can keep - // track of its contained components in order to - // call attach/detach hooks for them. - _frag: this._frag - }; - // extra options - // in 1.0.0 this is used by vue-router only - /* istanbul ignore if */ - if (extraOptions) { - extend(options, extraOptions); - } - var child = new this.Component(options); - if (this.keepAlive) { - this.cache[this.Component.cid] = child; - } - /* istanbul ignore if */ - if ('development' !== 'production' && this.el.hasAttribute('transition') && child._isFragment) { - warn('Transitions will not work on a fragment instance. ' + 'Template: ' + child.$options.template, child); - } - return child; - } - }, - - /** - * Try to get a cached instance of the current component. - * - * @return {Vue|undefined} - */ - - getCached: function getCached() { - return this.keepAlive && this.cache[this.Component.cid]; - }, - - /** - * Teardown the current child, but defers cleanup so - * that we can separate the destroy and removal steps. - * - * @param {Boolean} defer - */ - - unbuild: function unbuild(defer) { - if (this.waitingFor) { - if (!this.keepAlive) { - this.waitingFor.$destroy(); - } - this.waitingFor = null; - } - var child = this.childVM; - if (!child || this.keepAlive) { - if (child) { - // remove ref - child._inactive = true; - child._updateRef(true); - } - return; - } - // the sole purpose of `deferCleanup` is so that we can - // "deactivate" the vm right now and perform DOM removal - // later. - child.$destroy(false, defer); - }, - - /** - * Remove current destroyed child and manually do - * the cleanup after removal. - * - * @param {Function} cb - */ - - remove: function remove(child, cb) { - var keepAlive = this.keepAlive; - if (child) { - // we may have a component switch when a previous - // component is still being transitioned out. - // we want to trigger only one lastest insertion cb - // when the existing transition finishes. (#1119) - this.pendingRemovals++; - this.pendingRemovalCb = cb; - var self = this; - child.$remove(function () { - self.pendingRemovals--; - if (!keepAlive) child._cleanup(); - if (!self.pendingRemovals && self.pendingRemovalCb) { - self.pendingRemovalCb(); - self.pendingRemovalCb = null; + if (hydrating) { + if (hydrate(oldVnode, vnode, insertedVnodeQueue)) { + invokeInsertHook(vnode, insertedVnodeQueue, true); + return oldVnode + } else { + warn( + 'The client-side rendered virtual DOM tree is not matching ' + + 'server-rendered content. This is likely caused by incorrect ' + + 'HTML markup, for example nesting block-level elements inside ' + + '<p>, or missing <tbody>. Bailing hydration and performing ' + + 'full client-side render.' + ); + } } - }); - } else if (cb) { - cb(); - } - }, - - /** - * Actually swap the components, depending on the - * transition mode. Defaults to simultaneous. - * - * @param {Vue} target - * @param {Function} [cb] - */ - - transition: function transition(target, cb) { - var self = this; - var current = this.childVM; - // for devtool inspection - if (current) current._inactive = true; - target._inactive = false; - this.childVM = target; - switch (self.params.transitionMode) { - case 'in-out': - target.$before(self.anchor, function () { - self.remove(current, cb); - }); - break; - case 'out-in': - self.remove(current, function () { - target.$before(self.anchor, cb); - }); - break; - default: - self.remove(current); - target.$before(self.anchor, cb); - } - }, + // either not server-rendered, or hydration failed. + // create an empty node and replace it + oldVnode = emptyNodeAt(oldVnode); + } + elm = oldVnode.elm; + parent = nodeOps.parentNode(elm); + + createElm(vnode, insertedVnodeQueue); + + // component root element replaced. + // update parent placeholder node element. + if (vnode.parent) { + vnode.parent.elm = vnode.elm; + if (isPatchable(vnode)) { + for (var i = 0; i < cbs.create.length; ++i) { + cbs.create[i](emptyNode, vnode.parent); + } + } + } - /** - * Unbind. - */ - - unbind: function unbind() { - this.invalidatePending(); - // Do not defer cleanup when unbinding - this.unbuild(); - // destroy all keep-alive cached instances - if (this.cache) { - for (var key in this.cache) { - this.cache[key].$destroy(); + if (parent !== null) { + nodeOps.insertBefore(parent, vnode.elm, nodeOps.nextSibling(elm)); + removeVnodes(parent, [oldVnode], 0, 0); + } else if (isDef(oldVnode.tag)) { + invokeDestroyHook(oldVnode); } - this.cache = null; } } - }; - - /** - * Call activate hooks in order (asynchronous) - * - * @param {Array} hooks - * @param {Vue} vm - * @param {Function} cb - */ - function callActivateHooks(hooks, vm, cb) { - var total = hooks.length; - var called = 0; - hooks[0].call(vm, next); - function next() { - if (++called >= total) { - cb(); - } else { - hooks[called].call(vm, next); - } - } + invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch); + return vnode.elm } +} - var propBindingModes = config._propBindingModes; - var empty = {}; - - // regexes - var identRE$1 = /^[$_a-zA-Z]+[\w$]*$/; - var settablePathRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\[[^\[\]]+\])*$/; - - /** - * Compile props on a root element and return - * a props link function. - * - * @param {Element|DocumentFragment} el - * @param {Array} propOptions - * @param {Vue} vm - * @return {Function} propsLinkFn - */ - - function compileProps(el, propOptions, vm) { - var props = []; - var names = Object.keys(propOptions); - var i = names.length; - var options, name, attr, value, path, parsed, prop; - while (i--) { - name = names[i]; - options = propOptions[name] || empty; +/* */ - if ('development' !== 'production' && name === '$data') { - warn('Do not use $data as prop.', vm); - continue; - } +var directives = { + create: updateDirectives, + update: updateDirectives, + destroy: function unbindDirectives (vnode) { + updateDirectives(vnode, emptyNode); + } +}; - // props could contain dashes, which will be - // interpreted as minus calculations by the parser - // so we need to camelize the path here - path = camelize(name); - if (!identRE$1.test(path)) { - 'development' !== 'production' && warn('Invalid prop key: "' + name + '". Prop keys ' + 'must be valid identifiers.', vm); - continue; - } +function updateDirectives ( + oldVnode, + vnode +) { + if (!oldVnode.data.directives && !vnode.data.directives) { + return + } + var isCreate = oldVnode === emptyNode; + var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context); + var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context); - prop = { - name: name, - path: path, - options: options, - mode: propBindingModes.ONE_WAY, - raw: null - }; + var dirsWithInsert = []; + var dirsWithPostpatch = []; - attr = hyphenate(name); - // first check dynamic version - if ((value = getBindAttr(el, attr)) === null) { - if ((value = getBindAttr(el, attr + '.sync')) !== null) { - prop.mode = propBindingModes.TWO_WAY; - } else if ((value = getBindAttr(el, attr + '.once')) !== null) { - prop.mode = propBindingModes.ONE_TIME; - } + var key, oldDir, dir; + for (key in newDirs) { + oldDir = oldDirs[key]; + dir = newDirs[key]; + if (!oldDir) { + // new directive, bind + callHook$1(dir, 'bind', vnode, oldVnode); + if (dir.def && dir.def.inserted) { + dirsWithInsert.push(dir); } - if (value !== null) { - // has dynamic binding! - prop.raw = value; - parsed = parseDirective(value); - value = parsed.expression; - prop.filters = parsed.filters; - // check binding type - if (isLiteral(value) && !parsed.filters) { - // for expressions containing literal numbers and - // booleans, there's no need to setup a prop binding, - // so we can optimize them as a one-time set. - prop.optimizedLiteral = true; - } else { - prop.dynamic = true; - // check non-settable path for two-way bindings - if ('development' !== 'production' && prop.mode === propBindingModes.TWO_WAY && !settablePathRE.test(value)) { - prop.mode = propBindingModes.ONE_WAY; - warn('Cannot bind two-way prop with non-settable ' + 'parent path: ' + value, vm); - } - } - prop.parentPath = value; - - // warn required two-way - if ('development' !== 'production' && options.twoWay && prop.mode !== propBindingModes.TWO_WAY) { - warn('Prop "' + name + '" expects a two-way binding type.', vm); - } - } else if ((value = getAttr(el, attr)) !== null) { - // has literal binding! - prop.raw = value; - } else if ('development' !== 'production') { - // check possible camelCase prop usage - var lowerCaseName = path.toLowerCase(); - value = /[A-Z\-]/.test(name) && (el.getAttribute(lowerCaseName) || el.getAttribute(':' + lowerCaseName) || el.getAttribute('v-bind:' + lowerCaseName) || el.getAttribute(':' + lowerCaseName + '.once') || el.getAttribute('v-bind:' + lowerCaseName + '.once') || el.getAttribute(':' + lowerCaseName + '.sync') || el.getAttribute('v-bind:' + lowerCaseName + '.sync')); - if (value) { - warn('Possible usage error for prop `' + lowerCaseName + '` - ' + 'did you mean `' + attr + '`? HTML is case-insensitive, remember to use ' + 'kebab-case for props in templates.', vm); - } else if (options.required) { - // warn missing required - warn('Missing required prop: ' + name, vm); - } + } else { + // existing directive, update + dir.oldValue = oldDir.value; + callHook$1(dir, 'update', vnode, oldVnode); + if (dir.def && dir.def.componentUpdated) { + dirsWithPostpatch.push(dir); } - // push prop - props.push(prop); } - return makePropsLinkFn(props); } - /** - * Build a function that applies props to a vm. - * - * @param {Array} props - * @return {Function} propsLinkFn - */ - - function makePropsLinkFn(props) { - return function propsLinkFn(vm, scope) { - // store resolved props info - vm._props = {}; - var inlineProps = vm.$options.propsData; - var i = props.length; - var prop, path, options, value, raw; - while (i--) { - prop = props[i]; - raw = prop.raw; - path = prop.path; - options = prop.options; - vm._props[path] = prop; - if (inlineProps && hasOwn(inlineProps, path)) { - initProp(vm, prop, inlineProps[path]); - }if (raw === null) { - // initialize absent prop - initProp(vm, prop, undefined); - } else if (prop.dynamic) { - // dynamic prop - if (prop.mode === propBindingModes.ONE_TIME) { - // one time binding - value = (scope || vm._context || vm).$get(prop.parentPath); - initProp(vm, prop, value); - } else { - if (vm._context) { - // dynamic binding - vm._bindDir({ - name: 'prop', - def: propDef, - prop: prop - }, null, null, scope); // el, host, scope - } else { - // root instance - initProp(vm, prop, vm.$get(prop.parentPath)); - } - } - } else if (prop.optimizedLiteral) { - // optimized literal, cast it and just set once - var stripped = stripQuotes(raw); - value = stripped === raw ? toBoolean(toNumber(raw)) : stripped; - initProp(vm, prop, value); - } else { - // string literal, but we need to cater for - // Boolean props with no value, or with same - // literal value (e.g. disabled="disabled") - // see https://github.com/vuejs/vue-loader/issues/182 - value = options.type === Boolean && (raw === '' || raw === hyphenate(prop.name)) ? true : raw; - initProp(vm, prop, value); - } - } + if (dirsWithInsert.length) { + var callInsert = function () { + dirsWithInsert.forEach(function (dir) { + callHook$1(dir, 'inserted', vnode, oldVnode); + }); }; + if (isCreate) { + mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert, 'dir-insert'); + } else { + callInsert(); + } } - /** - * Process a prop with a rawValue, applying necessary coersions, - * default values & assertions and call the given callback with - * processed value. - * - * @param {Vue} vm - * @param {Object} prop - * @param {*} rawValue - * @param {Function} fn - */ - - function processPropValue(vm, prop, rawValue, fn) { - var isSimple = prop.dynamic && isSimplePath(prop.parentPath); - var value = rawValue; - if (value === undefined) { - value = getPropDefaultValue(vm, prop); - } - value = coerceProp(prop, value, vm); - var coerced = value !== rawValue; - if (!assertProp(prop, value, vm)) { - value = undefined; - } - if (isSimple && !coerced) { - withoutConversion(function () { - fn(value); + if (dirsWithPostpatch.length) { + mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () { + dirsWithPostpatch.forEach(function (dir) { + callHook$1(dir, 'componentUpdated', vnode, oldVnode); }); - } else { - fn(value); + }, 'dir-postpatch'); + } + + if (!isCreate) { + for (key in oldDirs) { + if (!newDirs[key]) { + // no longer present, unbind + callHook$1(oldDirs[key], 'unbind', oldVnode); + } } } +} - /** - * Set a prop's initial value on a vm and its data object. - * - * @param {Vue} vm - * @param {Object} prop - * @param {*} value - */ +var emptyModifiers = Object.create(null); - function initProp(vm, prop, value) { - processPropValue(vm, prop, value, function (value) { - defineReactive(vm, prop.path, value); - }); +function normalizeDirectives$1 ( + dirs, + vm +) { + var res = Object.create(null); + if (!dirs) { + return res } + var i, dir; + for (i = 0; i < dirs.length; i++) { + dir = dirs[i]; + if (!dir.modifiers) { + dir.modifiers = emptyModifiers; + } + res[getRawDirName(dir)] = dir; + dir.def = resolveAsset(vm.$options, 'directives', dir.name, true); + } + return res +} - /** - * Update a prop's value on a vm. - * - * @param {Vue} vm - * @param {Object} prop - * @param {*} value - */ +function getRawDirName (dir) { + return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))) +} - function updateProp(vm, prop, value) { - processPropValue(vm, prop, value, function (value) { - vm[prop.path] = value; - }); +function callHook$1 (dir, hook, vnode, oldVnode) { + var fn = dir.def && dir.def[hook]; + if (fn) { + fn(vnode.elm, dir, vnode, oldVnode); } +} - /** - * Get the default value of a prop. - * - * @param {Vue} vm - * @param {Object} prop - * @return {*} - */ +var baseModules = [ + ref, + directives +]; - function getPropDefaultValue(vm, prop) { - // no default, return undefined - var options = prop.options; - if (!hasOwn(options, 'default')) { - // absent boolean value defaults to false - return options.type === Boolean ? false : undefined; - } - var def = options['default']; - // warn against non-factory defaults for Object & Array - if (isObject(def)) { - 'development' !== '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); - } - // call factory function for non-Function types - return typeof def === 'function' && options.type !== Function ? def.call(vm) : def; - } +/* */ - /** - * Assert whether a prop is valid. - * - * @param {Object} prop - * @param {*} value - * @param {Vue} vm - */ +function updateAttrs (oldVnode, vnode) { + if (!oldVnode.data.attrs && !vnode.data.attrs) { + return + } + var key, cur, old; + var elm = vnode.elm; + var oldAttrs = oldVnode.data.attrs || {}; + var attrs = vnode.data.attrs || {}; + // clone observed objects, as the user probably wants to mutate it + if (attrs.__ob__) { + attrs = vnode.data.attrs = extend({}, attrs); + } - function assertProp(prop, value, vm) { - if (!prop.options.required && ( // non-required - prop.raw === null || // abscent - value == null) // null or undefined - ) { - return true; - } - var options = prop.options; - var type = options.type; - var valid = !type; - var expectedTypes = []; - if (type) { - if (!isArray(type)) { - type = [type]; - } - for (var i = 0; i < type.length && !valid; i++) { - var assertedType = assertType(value, type[i]); - expectedTypes.push(assertedType.expectedType); - valid = assertedType.valid; - } + for (key in attrs) { + cur = attrs[key]; + old = oldAttrs[key]; + if (old !== cur) { + setAttr(elm, key, cur); } - if (!valid) { - if ('development' !== 'production') { - warn('Invalid prop: type check failed for prop "' + prop.name + '".' + ' Expected ' + expectedTypes.map(formatType).join(', ') + ', got ' + formatValue(value) + '.', vm); - } - return false; - } - var validator = options.validator; - if (validator) { - if (!validator(value)) { - 'development' !== 'production' && warn('Invalid prop: custom validator check failed for prop "' + prop.name + '".', vm); - return false; + } + for (key in oldAttrs) { + if (attrs[key] == null) { + if (isXlink(key)) { + elm.removeAttributeNS(xlinkNS, getXlinkProp(key)); + } else if (!isEnumeratedAttr(key)) { + elm.removeAttribute(key); } } - return true; } +} - /** - * Force parsing value with coerce option. - * - * @param {*} value - * @param {Object} options - * @return {*} - */ - - function coerceProp(prop, value, vm) { - var coerce = prop.options.coerce; - if (!coerce) { - return value; +function setAttr (el, key, value) { + if (isBooleanAttr(key)) { + // set attribute for blank value + // e.g. <option disabled>Select one</option> + if (isFalsyAttrValue(value)) { + el.removeAttribute(key); + } else { + el.setAttribute(key, key); } - if (typeof coerce === 'function') { - return coerce(value); + } else if (isEnumeratedAttr(key)) { + el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true'); + } else if (isXlink(key)) { + if (isFalsyAttrValue(value)) { + el.removeAttributeNS(xlinkNS, getXlinkProp(key)); } else { - 'development' !== 'production' && warn('Invalid coerce for prop "' + prop.name + '": expected function, got ' + typeof coerce + '.', vm); - return value; + el.setAttributeNS(xlinkNS, key, value); } - } - - /** - * Assert the type of a value - * - * @param {*} value - * @param {Function} type - * @return {Object} - */ - - function assertType(value, type) { - var valid; - var expectedType; - if (type === String) { - expectedType = 'string'; - valid = typeof value === expectedType; - } else if (type === Number) { - expectedType = 'number'; - valid = typeof value === expectedType; - } else if (type === Boolean) { - expectedType = 'boolean'; - valid = typeof value === expectedType; - } else if (type === Function) { - expectedType = 'function'; - valid = typeof value === expectedType; - } else if (type === Object) { - expectedType = 'object'; - valid = isPlainObject(value); - } else if (type === Array) { - expectedType = 'array'; - valid = isArray(value); + } else { + if (isFalsyAttrValue(value)) { + el.removeAttribute(key); } else { - valid = value instanceof type; + el.setAttribute(key, value); } - return { - valid: valid, - expectedType: expectedType - }; } +} - /** - * Format type for output - * - * @param {String} type - * @return {String} - */ - - function formatType(type) { - return type ? type.charAt(0).toUpperCase() + type.slice(1) : 'custom type'; - } +var attrs = { + create: updateAttrs, + update: updateAttrs +}; - /** - * Format value - * - * @param {*} value - * @return {String} - */ +/* */ - function formatValue(val) { - return Object.prototype.toString.call(val).slice(8, -1); +function updateClass (oldVnode, vnode) { + var el = vnode.elm; + var data = vnode.data; + var oldData = oldVnode.data; + if (!data.staticClass && !data.class && + (!oldData || (!oldData.staticClass && !oldData.class))) { + return } - var bindingModes = config._propBindingModes; - - var propDef = { + var cls = genClassForVnode(vnode); - bind: function bind() { - var child = this.vm; - var parent = child._context; - // passed in from compiler directly - var prop = this.descriptor.prop; - var childKey = prop.path; - var parentKey = prop.parentPath; - var twoWay = prop.mode === bindingModes.TWO_WAY; - - var parentWatcher = this.parentWatcher = new Watcher(parent, parentKey, function (val) { - updateProp(child, prop, val); - }, { - twoWay: twoWay, - filters: prop.filters, - // important: props need to be observed on the - // v-for scope if present - scope: this._scope - }); - - // set the child initial value. - initProp(child, prop, parentWatcher.value); - - // setup two-way binding - if (twoWay) { - // important: defer the child watcher creation until - // the created hook (after data observation) - var self = this; - child.$once('pre-hook:created', function () { - self.childWatcher = new Watcher(child, childKey, function (val) { - parentWatcher.set(val); - }, { - // ensure sync upward before parent sync down. - // this is necessary in cases e.g. the child - // mutates a prop array, then replaces it. (#1683) - sync: true - }); - }); - } - }, - - unbind: function unbind() { - this.parentWatcher.teardown(); - if (this.childWatcher) { - this.childWatcher.teardown(); - } - } - }; - - var queue$1 = []; - var queued = false; - - /** - * Push a job into the queue. - * - * @param {Function} job - */ - - function pushJob(job) { - queue$1.push(job); - if (!queued) { - queued = true; - nextTick(flush); - } + // handle transition classes + var transitionClass = el._transitionClasses; + if (transitionClass) { + cls = concat(cls, stringifyClass(transitionClass)); } - /** - * Flush the queue, and do one forced reflow before - * triggering transitions. - */ - - function flush() { - // Force layout - var f = document.documentElement.offsetHeight; - for (var i = 0; i < queue$1.length; i++) { - queue$1[i](); - } - queue$1 = []; - queued = false; - // dummy return, so js linters don't complain about - // unused variable f - return f; + // set the class + if (cls !== el._prevClass) { + el.setAttribute('class', cls); + el._prevClass = cls; } +} - var TYPE_TRANSITION = 'transition'; - var TYPE_ANIMATION = 'animation'; - var transDurationProp = transitionProp + 'Duration'; - var animDurationProp = animationProp + 'Duration'; +var klass = { + create: updateClass, + update: updateClass +}; - /** - * If a just-entered element is applied the - * leave class while its enter transition hasn't started yet, - * and the transitioned property has the same value for both - * enter/leave, then the leave transition will be skipped and - * the transitionend event never fires. This function ensures - * its callback to be called after a transition has started - * by waiting for double raf. - * - * It falls back to setTimeout on devices that support CSS - * transitions but not raf (e.g. Android 4.2 browser) - since - * these environments are usually slow, we are giving it a - * relatively large timeout. - */ - - var raf = inBrowser && window.requestAnimationFrame; - var waitForTransitionStart = raf - /* istanbul ignore next */ - ? function (fn) { - raf(function () { - raf(fn); - }); - } : function (fn) { - setTimeout(fn, 50); - }; +// skip type checking this file because we need to attach private properties +// to elements - /** - * A Transition object that encapsulates the state and logic - * of the transition. - * - * @param {Element} el - * @param {String} id - * @param {Object} hooks - * @param {Vue} vm - */ - function Transition(el, id, hooks, vm) { - this.id = id; - this.el = el; - this.enterClass = hooks && hooks.enterClass || id + '-enter'; - this.leaveClass = hooks && hooks.leaveClass || id + '-leave'; - this.hooks = hooks; - this.vm = vm; - // async state - this.pendingCssEvent = this.pendingCssCb = this.cancel = this.pendingJsCb = this.op = this.cb = null; - this.justEntered = false; - this.entered = this.left = false; - this.typeCache = {}; - // check css transition type - this.type = hooks && hooks.type; - /* istanbul ignore if */ - if ('development' !== 'production') { - if (this.type && this.type !== TYPE_TRANSITION && this.type !== TYPE_ANIMATION) { - warn('invalid CSS transition type for transition="' + this.id + '": ' + this.type, vm); - } - } - // bind - var self = this;['enterNextTick', 'enterDone', 'leaveNextTick', 'leaveDone'].forEach(function (m) { - self[m] = bind(self[m], self); - }); +function updateDOMListeners (oldVnode, vnode) { + if (!oldVnode.data.on && !vnode.data.on) { + return } - - var p$1 = Transition.prototype; - - /** - * Start an entering transition. - * - * 1. enter transition triggered - * 2. call beforeEnter hook - * 3. add enter class - * 4. insert/show element - * 5. call enter hook (with possible explicit js callback) - * 6. reflow - * 7. based on transition type: - * - transition: - * remove class now, wait for transitionend, - * then done if there's no explicit js callback. - * - animation: - * wait for animationend, remove class, - * then done if there's no explicit js callback. - * - no css transition: - * done now if there's no explicit js callback. - * 8. wait for either done or js callback, then call - * afterEnter hook. - * - * @param {Function} op - insert/show the element - * @param {Function} [cb] - */ - - p$1.enter = function (op, cb) { - this.cancelPending(); - this.callHook('beforeEnter'); - this.cb = cb; - addClass(this.el, this.enterClass); - op(); - this.entered = false; - this.callHookWithCb('enter'); - if (this.entered) { - return; // user called done synchronously. - } - this.cancel = this.hooks && this.hooks.enterCancelled; - pushJob(this.enterNextTick); - }; - - /** - * The "nextTick" phase of an entering transition, which is - * to be pushed into a queue and executed after a reflow so - * that removing the class can trigger a CSS transition. - */ - - p$1.enterNextTick = function () { - var _this = this; - - // prevent transition skipping - this.justEntered = true; - waitForTransitionStart(function () { - _this.justEntered = false; - }); - var enterDone = this.enterDone; - var type = this.getCssTransitionType(this.enterClass); - if (!this.pendingJsCb) { - if (type === TYPE_TRANSITION) { - // trigger transition by removing enter class now - removeClass(this.el, this.enterClass); - this.setupCssCb(transitionEndEvent, enterDone); - } else if (type === TYPE_ANIMATION) { - this.setupCssCb(animationEndEvent, enterDone); - } else { - enterDone(); + var on = vnode.data.on || {}; + var oldOn = oldVnode.data.on || {}; + var add = vnode.elm._v_add || (vnode.elm._v_add = function (event, handler, capture) { + vnode.elm.addEventListener(event, handler, capture); + }); + var remove = vnode.elm._v_remove || (vnode.elm._v_remove = function (event, handler) { + vnode.elm.removeEventListener(event, handler); + }); + updateListeners(on, oldOn, add, remove, vnode.context); +} + +var events = { + create: updateDOMListeners, + update: updateDOMListeners +}; + +/* */ + +function updateDOMProps (oldVnode, vnode) { + if (!oldVnode.data.domProps && !vnode.data.domProps) { + return + } + var key, cur; + var elm = vnode.elm; + var oldProps = oldVnode.data.domProps || {}; + var props = vnode.data.domProps || {}; + // clone observed objects, as the user probably wants to mutate it + if (props.__ob__) { + props = vnode.data.domProps = extend({}, props); + } + + for (key in oldProps) { + if (props[key] == null) { + elm[key] = undefined; + } + } + for (key in props) { + // ignore children if the node has textContent or innerHTML, + // as these will throw away existing DOM nodes and cause removal errors + // on subsequent patches (#3360) + if ((key === 'textContent' || key === 'innerHTML') && vnode.children) { + vnode.children.length = 0; + } + cur = props[key]; + if (key === 'value') { + // store value as _value as well since + // non-string values will be stringified + elm._value = cur; + // avoid resetting cursor position when value is the same + var strCur = cur == null ? '' : String(cur); + if (elm.value !== strCur && !elm.composing) { + elm.value = strCur; } - } else if (type === TYPE_TRANSITION) { - removeClass(this.el, this.enterClass); + } else { + elm[key] = cur; } - }; + } +} - /** - * The "cleanup" phase of an entering transition. - */ +var domProps = { + create: updateDOMProps, + update: updateDOMProps +}; - p$1.enterDone = function () { - this.entered = true; - this.cancel = this.pendingJsCb = null; - removeClass(this.el, this.enterClass); - this.callHook('afterEnter'); - if (this.cb) this.cb(); - }; +/* */ - /** - * Start a leaving transition. - * - * 1. leave transition triggered. - * 2. call beforeLeave hook - * 3. add leave class (trigger css transition) - * 4. call leave hook (with possible explicit js callback) - * 5. reflow if no explicit js callback is provided - * 6. based on transition type: - * - transition or animation: - * wait for end event, remove class, then done if - * there's no explicit js callback. - * - no css transition: - * done if there's no explicit js callback. - * 7. wait for either done or js callback, then call - * afterLeave hook. - * - * @param {Function} op - remove/hide the element - * @param {Function} [cb] - */ +var prefixes = ['Webkit', 'Moz', 'ms']; - p$1.leave = function (op, cb) { - this.cancelPending(); - this.callHook('beforeLeave'); - this.op = op; - this.cb = cb; - addClass(this.el, this.leaveClass); - this.left = false; - this.callHookWithCb('leave'); - if (this.left) { - return; // user called done synchronously. - } - this.cancel = this.hooks && this.hooks.leaveCancelled; - // only need to handle leaveDone if - // 1. the transition is already done (synchronously called - // by the user, which causes this.op set to null) - // 2. there's no explicit js callback - if (this.op && !this.pendingJsCb) { - // if a CSS transition leaves immediately after enter, - // the transitionend event never fires. therefore we - // detect such cases and end the leave immediately. - if (this.justEntered) { - this.leaveDone(); - } else { - pushJob(this.leaveNextTick); - } +var testEl; +var normalize = cached(function (prop) { + testEl = testEl || document.createElement('div'); + prop = camelize(prop); + if (prop !== 'filter' && (prop in testEl.style)) { + return prop + } + var upper = prop.charAt(0).toUpperCase() + prop.slice(1); + for (var i = 0; i < prefixes.length; i++) { + var prefixed = prefixes[i] + upper; + if (prefixed in testEl.style) { + return prefixed } - }; + } +}); - /** - * The "nextTick" phase of a leaving transition. - */ +function updateStyle (oldVnode, vnode) { + if ((!oldVnode.data || !oldVnode.data.style) && !vnode.data.style) { + return + } + var cur, name; + var el = vnode.elm; + var oldStyle = oldVnode.data.style || {}; + var style = vnode.data.style || {}; - p$1.leaveNextTick = function () { - var type = this.getCssTransitionType(this.leaveClass); - if (type) { - var event = type === TYPE_TRANSITION ? transitionEndEvent : animationEndEvent; - this.setupCssCb(event, this.leaveDone); - } else { - this.leaveDone(); - } - }; + // handle string + if (typeof style === 'string') { + el.style.cssText = style; + return + } - /** - * The "cleanup" phase of a leaving transition. - */ + var needClone = style.__ob__; - p$1.leaveDone = function () { - this.left = true; - this.cancel = this.pendingJsCb = null; - this.op(); - removeClass(this.el, this.leaveClass); - this.callHook('afterLeave'); - if (this.cb) this.cb(); - this.op = null; - }; + // handle array syntax + if (Array.isArray(style)) { + style = vnode.data.style = toObject(style); + } - /** - * Cancel any pending callbacks from a previously running - * but not finished transition. - */ + // clone the style for future updates, + // in case the user mutates the style object in-place. + if (needClone) { + style = vnode.data.style = extend({}, style); + } - p$1.cancelPending = function () { - this.op = this.cb = null; - var hasPending = false; - if (this.pendingCssCb) { - hasPending = true; - off(this.el, this.pendingCssEvent, this.pendingCssCb); - this.pendingCssEvent = this.pendingCssCb = null; - } - if (this.pendingJsCb) { - hasPending = true; - this.pendingJsCb.cancel(); - this.pendingJsCb = null; + for (name in oldStyle) { + if (style[name] == null) { + el.style[normalize(name)] = ''; } - if (hasPending) { - removeClass(this.el, this.enterClass); - removeClass(this.el, this.leaveClass); - } - if (this.cancel) { - this.cancel.call(this.vm, this.el); - this.cancel = null; - } - }; - - /** - * Call a user-provided synchronous hook function. - * - * @param {String} type - */ - - p$1.callHook = function (type) { - if (this.hooks && this.hooks[type]) { - this.hooks[type].call(this.vm, this.el); + } + for (name in style) { + cur = style[name]; + if (cur !== oldStyle[name]) { + // ie9 setting to null has no effect, must use empty string + el.style[normalize(name)] = cur == null ? '' : cur; } - }; - - /** - * Call a user-provided, potentially-async hook function. - * We check for the length of arguments to see if the hook - * expects a `done` callback. If true, the transition's end - * will be determined by when the user calls that callback; - * otherwise, the end is determined by the CSS transition or - * animation. - * - * @param {String} type - */ + } +} - p$1.callHookWithCb = function (type) { - var hook = this.hooks && this.hooks[type]; - if (hook) { - if (hook.length > 1) { - this.pendingJsCb = cancellable(this[type + 'Done']); - } - hook.call(this.vm, this.el, this.pendingJsCb); - } - }; +var style = { + create: updateStyle, + update: updateStyle +}; - /** - * Get an element's transition type based on the - * calculated styles. - * - * @param {String} className - * @return {Number} - */ +/* */ - p$1.getCssTransitionType = function (className) { - /* istanbul ignore if */ - if (!transitionEndEvent || - // skip CSS transitions if page is not visible - - // this solves the issue of transitionend events not - // firing until the page is visible again. - // pageVisibility API is supported in IE10+, same as - // CSS transitions. - document.hidden || - // explicit js-only transition - this.hooks && this.hooks.css === false || - // element is hidden - isHidden(this.el)) { - return; - } - var type = this.type || this.typeCache[className]; - if (type) return type; - var inlineStyles = this.el.style; - var computedStyles = window.getComputedStyle(this.el); - var transDuration = inlineStyles[transDurationProp] || computedStyles[transDurationProp]; - if (transDuration && transDuration !== '0s') { - type = TYPE_TRANSITION; +/** + * Add class with compatibility for SVG since classList is not supported on + * SVG elements in IE + */ +function addClass (el, cls) { + /* istanbul ignore else */ + if (el.classList) { + if (cls.indexOf(' ') > -1) { + cls.split(/\s+/).forEach(function (c) { return el.classList.add(c); }); } else { - var animDuration = inlineStyles[animDurationProp] || computedStyles[animDurationProp]; - if (animDuration && animDuration !== '0s') { - type = TYPE_ANIMATION; - } + el.classList.add(cls); } - if (type) { - this.typeCache[className] = type; + } else { + var cur = ' ' + el.getAttribute('class') + ' '; + if (cur.indexOf(' ' + cls + ' ') < 0) { + el.setAttribute('class', (cur + cls).trim()); } - return type; - }; - - /** - * Setup a CSS transitionend/animationend callback. - * - * @param {String} event - * @param {Function} cb - */ - - p$1.setupCssCb = function (event, cb) { - this.pendingCssEvent = event; - var self = this; - var el = this.el; - var onEnd = this.pendingCssCb = function (e) { - if (e.target === el) { - off(el, event, onEnd); - self.pendingCssEvent = self.pendingCssCb = null; - if (!self.pendingJsCb && cb) { - cb(); - } - } - }; - on(el, event, onEnd); - }; - - /** - * Check if an element is hidden - in that case we can just - * skip the transition alltogether. - * - * @param {Element} el - * @return {Boolean} - */ + } +} - function isHidden(el) { - if (/svg$/.test(el.namespaceURI)) { - // SVG elements do not have offset(Width|Height) - // so we need to check the client rect - var rect = el.getBoundingClientRect(); - return !(rect.width || rect.height); +/** + * Remove class with compatibility for SVG since classList is not supported on + * SVG elements in IE + */ +function removeClass (el, cls) { + /* istanbul ignore else */ + if (el.classList) { + if (cls.indexOf(' ') > -1) { + cls.split(/\s+/).forEach(function (c) { return el.classList.remove(c); }); } else { - return !(el.offsetWidth || el.offsetHeight || el.getClientRects().length); + el.classList.remove(cls); + } + } else { + var cur = ' ' + el.getAttribute('class') + ' '; + var tar = ' ' + cls + ' '; + while (cur.indexOf(tar) >= 0) { + cur = cur.replace(tar, ' '); } + el.setAttribute('class', cur.trim()); } +} - var transition$1 = { +/* */ - priority: TRANSITION, +var hasTransition = inBrowser && !isIE9; +var TRANSITION = 'transition'; +var ANIMATION = 'animation'; - update: function update(id, oldId) { - var el = this.el; - // resolve on owner vm - var hooks = resolveAsset(this.vm.$options, 'transitions', id); - id = id || 'v'; - oldId = oldId || 'v'; - el.__v_trans = new Transition(el, id, hooks, this.vm); - removeClass(el, oldId + '-transition'); - addClass(el, id + '-transition'); - } +// Transition property/event sniffing +var transitionProp = 'transition'; +var transitionEndEvent = 'transitionend'; +var animationProp = 'animation'; +var animationEndEvent = 'animationend'; +if (hasTransition) { + /* istanbul ignore if */ + if (window.ontransitionend === undefined && + window.onwebkittransitionend !== undefined) { + transitionProp = 'WebkitTransition'; + transitionEndEvent = 'webkitTransitionEnd'; + } + if (window.onanimationend === undefined && + window.onwebkitanimationend !== undefined) { + animationProp = 'WebkitAnimation'; + animationEndEvent = 'webkitAnimationEnd'; + } +} + +var raf = (inBrowser && window.requestAnimationFrame) || setTimeout; +function nextFrame (fn) { + raf(function () { + raf(fn); + }); +} + +function addTransitionClass (el, cls) { + (el._transitionClasses || (el._transitionClasses = [])).push(cls); + addClass(el, cls); +} + +function removeTransitionClass (el, cls) { + if (el._transitionClasses) { + remove$1(el._transitionClasses, cls); + } + removeClass(el, cls); +} + +function whenTransitionEnds ( + el, + expectedType, + cb +) { + var ref = getTransitionInfo(el, expectedType); + var type = ref.type; + var timeout = ref.timeout; + var propCount = ref.propCount; + if (!type) { return cb() } + var event = type === TRANSITION ? transitionEndEvent : animationEndEvent; + var ended = 0; + var end = function () { + el.removeEventListener(event, onEnd); + cb(); }; - - var internalDirectives = { - style: style, - 'class': vClass, - component: component, - prop: propDef, - transition: transition$1 + var onEnd = function (e) { + if (e.target === el) { + if (++ended >= propCount) { + end(); + } + } }; - - // special binding prefixes - var bindRE = /^v-bind:|^:/; - var onRE = /^v-on:|^@/; - var dirAttrRE = /^v-([^:]+)(?:$|:(.*)$)/; - var modifierRE = /\.[^\.]+/g; - var transitionRE = /^(v-bind:|:)?transition$/; - - // default directive priority - var DEFAULT_PRIORITY = 1000; - var DEFAULT_TERMINAL_PRIORITY = 2000; - - /** - * Compile a template and return a reusable composite link - * function, which recursively contains more link functions - * inside. This top level compile function would normally - * be called on instance root nodes, but can also be used - * for partial compilation if the partial argument is true. - * - * The returned composite link function, when called, will - * return an unlink function that tearsdown all directives - * created during the linking phase. - * - * @param {Element|DocumentFragment} el - * @param {Object} options - * @param {Boolean} partial - * @return {Function} - */ - - function compile(el, options, partial) { - // link function for the node itself. - var nodeLinkFn = partial || !options._asComponent ? compileNode(el, options) : null; - // link function for the childNodes - var childLinkFn = !(nodeLinkFn && nodeLinkFn.terminal) && !isScript(el) && el.hasChildNodes() ? compileNodeList(el.childNodes, options) : null; - - /** - * A composite linker function to be called on a already - * compiled piece of DOM, which instantiates all directive - * instances. - * - * @param {Vue} vm - * @param {Element|DocumentFragment} el - * @param {Vue} [host] - host vm of transcluded content - * @param {Object} [scope] - v-for scope - * @param {Fragment} [frag] - link context fragment - * @return {Function|undefined} - */ - - return function compositeLinkFn(vm, el, host, scope, frag) { - // cache childNodes before linking parent, fix #657 - var childNodes = toArray(el.childNodes); - // link - var dirs = linkAndCapture(function compositeLinkCapturer() { - if (nodeLinkFn) nodeLinkFn(vm, el, host, scope, frag); - if (childLinkFn) childLinkFn(vm, childNodes, host, scope, frag); - }, vm); - return makeUnlinkFn(vm, dirs); - }; - } - - /** - * Apply a linker to a vm/element pair and capture the - * directives created during the process. - * - * @param {Function} linker - * @param {Vue} vm - */ - - function linkAndCapture(linker, vm) { - /* istanbul ignore if */ - if ('development' === 'production') {} - var originalDirCount = vm._directives.length; - linker(); - var dirs = vm._directives.slice(originalDirCount); - dirs.sort(directiveComparator); - for (var i = 0, l = dirs.length; i < l; i++) { - dirs[i]._bind(); + setTimeout(function () { + if (ended < propCount) { + end(); + } + }, timeout + 1); + el.addEventListener(event, onEnd); +} + +var transformRE = /\b(transform|all)(,|$)/; + +function getTransitionInfo (el, expectedType) { + var styles = window.getComputedStyle(el); + var transitioneDelays = styles[transitionProp + 'Delay'].split(', '); + var transitionDurations = styles[transitionProp + 'Duration'].split(', '); + var transitionTimeout = getTimeout(transitioneDelays, transitionDurations); + var animationDelays = styles[animationProp + 'Delay'].split(', '); + var animationDurations = styles[animationProp + 'Duration'].split(', '); + var animationTimeout = getTimeout(animationDelays, animationDurations); + + var type; + var timeout = 0; + var propCount = 0; + /* istanbul ignore if */ + if (expectedType === TRANSITION) { + if (transitionTimeout > 0) { + type = TRANSITION; + timeout = transitionTimeout; + propCount = transitionDurations.length; + } + } else if (expectedType === ANIMATION) { + if (animationTimeout > 0) { + type = ANIMATION; + timeout = animationTimeout; + propCount = animationDurations.length; } - return dirs; - } - - /** - * Directive priority sort comparator - * - * @param {Object} a - * @param {Object} b - */ - - function directiveComparator(a, b) { - a = a.descriptor.def.priority || DEFAULT_PRIORITY; - b = b.descriptor.def.priority || DEFAULT_PRIORITY; - return a > b ? -1 : a === b ? 0 : 1; + } else { + timeout = Math.max(transitionTimeout, animationTimeout); + type = timeout > 0 + ? transitionTimeout > animationTimeout + ? TRANSITION + : ANIMATION + : null; + propCount = type + ? type === TRANSITION + ? transitionDurations.length + : animationDurations.length + : 0; + } + var hasTransform = + type === TRANSITION && + transformRE.test(styles[transitionProp + 'Property']); + return { + type: type, + timeout: timeout, + propCount: propCount, + hasTransform: hasTransform + } +} + +function getTimeout (delays, durations) { + return Math.max.apply(null, durations.map(function (d, i) { + return toMs(d) + toMs(delays[i]) + })) +} + +function toMs (s) { + return Number(s.slice(0, -1)) * 1000 +} + +/* */ + +function enter (vnode) { + var el = vnode.elm; + + // call leave callback now + if (el._leaveCb) { + el._leaveCb.cancelled = true; + el._leaveCb(); + } + + var data = resolveTransition(vnode.data.transition); + if (!data) { + return } - /** - * Linker functions return an unlink function that - * tearsdown all directives instances generated during - * the process. - * - * We create unlink functions with only the necessary - * information to avoid retaining additional closures. - * - * @param {Vue} vm - * @param {Array} dirs - * @param {Vue} [context] - * @param {Array} [contextDirs] - * @return {Function} - */ + /* istanbul ignore if */ + if (el._enterCb || el.nodeType !== 1) { + return + } + + var css = data.css; + var type = data.type; + var enterClass = data.enterClass; + var enterActiveClass = data.enterActiveClass; + var appearClass = data.appearClass; + var appearActiveClass = data.appearActiveClass; + var beforeEnter = data.beforeEnter; + var enter = data.enter; + var afterEnter = data.afterEnter; + var enterCancelled = data.enterCancelled; + var beforeAppear = data.beforeAppear; + var appear = data.appear; + var afterAppear = data.afterAppear; + var appearCancelled = data.appearCancelled; + + // activeInstance will always be the <transition> component managing this + // transition. One edge case to check is when the <transition> is placed + // as the root node of a child component. In that case we need to check + // <transition>'s parent for appear check. + var transitionNode = activeInstance.$vnode; + var context = transitionNode && transitionNode.parent + ? transitionNode.parent.context + : activeInstance; + + var isAppear = !context._isMounted || !vnode.isRootInsert; + + if (isAppear && !appear && appear !== '') { + return + } + + var startClass = isAppear ? appearClass : enterClass; + var activeClass = isAppear ? appearActiveClass : enterActiveClass; + var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter; + var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter; + var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter; + var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled; + + var expectsCSS = css !== false && !isIE9; + var userWantsControl = + enterHook && + // enterHook may be a bound method which exposes + // the length of original fn as _length + (enterHook._length || enterHook.length) > 1; + + var cb = el._enterCb = once(function () { + if (expectsCSS) { + removeTransitionClass(el, activeClass); + } + if (cb.cancelled) { + if (expectsCSS) { + removeTransitionClass(el, startClass); + } + enterCancelledHook && enterCancelledHook(el); + } else { + afterEnterHook && afterEnterHook(el); + } + el._enterCb = null; + }); - function makeUnlinkFn(vm, dirs, context, contextDirs) { - function unlink(destroying) { - teardownDirs(vm, dirs, destroying); - if (context && contextDirs) { - teardownDirs(context, contextDirs); + if (!vnode.data.show) { + // remove pending leave element on enter by injecting an insert hook + mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () { + var parent = el.parentNode; + var pendingNode = parent && parent._pending && parent._pending[vnode.key]; + if (pendingNode && pendingNode.tag === vnode.tag && pendingNode.elm._leaveCb) { + pendingNode.elm._leaveCb(); } - } - // expose linked directives - unlink.dirs = dirs; - return unlink; + enterHook && enterHook(el, cb); + }, 'transition-insert'); } - /** - * Teardown partial linked directives. - * - * @param {Vue} vm - * @param {Array} dirs - * @param {Boolean} destroying - */ - - function teardownDirs(vm, dirs, destroying) { - var i = dirs.length; - while (i--) { - dirs[i]._teardown(); - if ('development' !== 'production' && !destroying) { - vm._directives.$remove(dirs[i]); + // start enter transition + beforeEnterHook && beforeEnterHook(el); + if (expectsCSS) { + addTransitionClass(el, startClass); + addTransitionClass(el, activeClass); + nextFrame(function () { + removeTransitionClass(el, startClass); + if (!cb.cancelled && !userWantsControl) { + whenTransitionEnds(el, type, cb); } - } + }); } - /** - * Compile link props on an instance. - * - * @param {Vue} vm - * @param {Element} el - * @param {Object} props - * @param {Object} [scope] - * @return {Function} - */ - - function compileAndLinkProps(vm, el, props, scope) { - var propsLinkFn = compileProps(el, props, vm); - var propDirs = linkAndCapture(function () { - propsLinkFn(vm, scope); - }, vm); - return makeUnlinkFn(vm, propDirs); + if (vnode.data.show) { + enterHook && enterHook(el, cb); } - /** - * Compile the root element of an instance. - * - * 1. attrs on context container (context scope) - * 2. attrs on the component template root node, if - * replace:true (child scope) - * - * If this is a fragment instance, we only need to compile 1. - * - * @param {Element} el - * @param {Object} options - * @param {Object} contextOptions - * @return {Function} - */ - - function compileRoot(el, options, contextOptions) { - var containerAttrs = options._containerAttrs; - var replacerAttrs = options._replacerAttrs; - var contextLinkFn, replacerLinkFn; - - // only need to compile other attributes for - // non-fragment instances - if (el.nodeType !== 11) { - // for components, container and replacer need to be - // compiled separately and linked in different scopes. - if (options._asComponent) { - // 2. container attributes - if (containerAttrs && contextOptions) { - contextLinkFn = compileDirectives(containerAttrs, contextOptions); - } - if (replacerAttrs) { - // 3. replacer attributes - replacerLinkFn = compileDirectives(replacerAttrs, options); - } - } else { - // non-component, just compile as a normal element. - replacerLinkFn = compileDirectives(el.attributes, options); - } - } else if ('development' !== 'production' && containerAttrs) { - // warn container directives for fragment instances - var names = containerAttrs.filter(function (attr) { - // allow vue-loader/vueify scoped css attributes - return attr.name.indexOf('_v-') < 0 && - // allow event listeners - !onRE.test(attr.name) && - // allow slots - attr.name !== 'slot'; - }).map(function (attr) { - return '"' + attr.name + '"'; - }); - if (names.length) { - var plural = names.length > 1; - warn('Attribute' + (plural ? 's ' : ' ') + names.join(', ') + (plural ? ' are' : ' is') + ' ignored on component ' + '<' + options.el.tagName.toLowerCase() + '> because ' + 'the component is a fragment instance: ' + 'http://vuejs.org/guide/components.html#Fragment-Instance'); - } - } - - options._containerAttrs = options._replacerAttrs = null; - return function rootLinkFn(vm, el, scope) { - // link context scope dirs - var context = vm._context; - var contextDirs; - if (context && contextLinkFn) { - contextDirs = linkAndCapture(function () { - contextLinkFn(context, el, null, scope); - }, context); - } + if (!expectsCSS && !userWantsControl) { + cb(); + } +} - // link self - var selfDirs = linkAndCapture(function () { - if (replacerLinkFn) replacerLinkFn(vm, el); - }, vm); +function leave (vnode, rm) { + var el = vnode.elm; - // return the unlink function that tearsdown context - // container directives. - return makeUnlinkFn(vm, selfDirs, context, contextDirs); - }; + // call enter callback now + if (el._enterCb) { + el._enterCb.cancelled = true; + el._enterCb(); } - /** - * Compile a node and return a nodeLinkFn based on the - * node type. - * - * @param {Node} node - * @param {Object} options - * @return {Function|null} - */ + var data = resolveTransition(vnode.data.transition); + if (!data) { + return rm() + } - function compileNode(node, options) { - var type = node.nodeType; - if (type === 1 && !isScript(node)) { - return compileElement(node, options); - } else if (type === 3 && node.data.trim()) { - return compileTextNode(node, options); + /* istanbul ignore if */ + if (el._leaveCb || el.nodeType !== 1) { + return + } + + var css = data.css; + var type = data.type; + var leaveClass = data.leaveClass; + var leaveActiveClass = data.leaveActiveClass; + var beforeLeave = data.beforeLeave; + var leave = data.leave; + var afterLeave = data.afterLeave; + var leaveCancelled = data.leaveCancelled; + var delayLeave = data.delayLeave; + + var expectsCSS = css !== false && !isIE9; + var userWantsControl = + leave && + // leave hook may be a bound method which exposes + // the length of original fn as _length + (leave._length || leave.length) > 1; + + var cb = el._leaveCb = once(function () { + if (el.parentNode && el.parentNode._pending) { + el.parentNode._pending[vnode.key] = null; + } + if (expectsCSS) { + removeTransitionClass(el, leaveActiveClass); + } + if (cb.cancelled) { + if (expectsCSS) { + removeTransitionClass(el, leaveClass); + } + leaveCancelled && leaveCancelled(el); } else { - return null; + rm(); + afterLeave && afterLeave(el); } - } + el._leaveCb = null; + }); - /** - * Compile an element and return a nodeLinkFn. - * - * @param {Element} el - * @param {Object} options - * @return {Function|null} - */ + if (delayLeave) { + delayLeave(performLeave); + } else { + performLeave(); + } - function compileElement(el, options) { - // preprocess textareas. - // textarea treats its text content as the initial value. - // just bind it as an attr directive for value. - if (el.tagName === 'TEXTAREA') { - var tokens = parseText(el.value); - if (tokens) { - el.setAttribute(':value', tokensToExp(tokens)); - el.value = ''; - } - } - var linkFn; - var hasAttrs = el.hasAttributes(); - var attrs = hasAttrs && toArray(el.attributes); - // check terminal directives (for & if) - if (hasAttrs) { - linkFn = checkTerminalDirectives(el, attrs, options); + function performLeave () { + // the delayed leave may have already been cancelled + if (cb.cancelled) { + return } - // check element directives - if (!linkFn) { - linkFn = checkElementDirectives(el, options); + // record leaving element + if (!vnode.data.show) { + (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode; } - // check component - if (!linkFn) { - linkFn = checkComponent(el, options); + beforeLeave && beforeLeave(el); + if (expectsCSS) { + addTransitionClass(el, leaveClass); + addTransitionClass(el, leaveActiveClass); + nextFrame(function () { + removeTransitionClass(el, leaveClass); + if (!cb.cancelled && !userWantsControl) { + whenTransitionEnds(el, type, cb); + } + }); } - // normal directives - if (!linkFn && hasAttrs) { - linkFn = compileDirectives(attrs, options); + leave && leave(el, cb); + if (!expectsCSS && !userWantsControl) { + cb(); } - return linkFn; } +} - /** - * Compile a textNode and return a nodeLinkFn. - * - * @param {TextNode} node - * @param {Object} options - * @return {Function|null} textNodeLinkFn - */ - - function compileTextNode(node, options) { - // skip marked text nodes - if (node._skip) { - return removeText; - } - - var tokens = parseText(node.wholeText); - if (!tokens) { - return null; - } - - // mark adjacent text nodes as skipped, - // because we are using node.wholeText to compile - // all adjacent text nodes together. This fixes - // issues in IE where sometimes it splits up a single - // text node into multiple ones. - var next = node.nextSibling; - while (next && next.nodeType === 3) { - next._skip = true; - next = next.nextSibling; - } - - var frag = document.createDocumentFragment(); - var el, token; - for (var i = 0, l = tokens.length; i < l; i++) { - token = tokens[i]; - el = token.tag ? processTextToken(token, options) : document.createTextNode(token.value); - frag.appendChild(el); +function resolveTransition (def$$1) { + if (!def$$1) { + return + } + /* istanbul ignore else */ + if (typeof def$$1 === 'object') { + var res = {}; + if (def$$1.css !== false) { + extend(res, autoCssTransition(def$$1.name || 'v')); } - return makeTextNodeLinkFn(tokens, frag, options); + extend(res, def$$1); + return res + } else if (typeof def$$1 === 'string') { + return autoCssTransition(def$$1) } +} - /** - * Linker for an skipped text node. - * - * @param {Vue} vm - * @param {Text} node - */ - - function removeText(vm, node) { - remove(node); +var autoCssTransition = cached(function (name) { + return { + enterClass: (name + "-enter"), + leaveClass: (name + "-leave"), + appearClass: (name + "-enter"), + enterActiveClass: (name + "-enter-active"), + leaveActiveClass: (name + "-leave-active"), + appearActiveClass: (name + "-enter-active") } +}); - /** - * Process a single text token. - * - * @param {Object} token - * @param {Object} options - * @return {Node} - */ +function once (fn) { + var called = false; + return function () { + if (!called) { + called = true; + fn(); + } + } +} - function processTextToken(token, options) { - var el; - if (token.oneTime) { - el = document.createTextNode(token.value); +var transition = inBrowser ? { + create: function create (_, vnode) { + if (!vnode.data.show) { + enter(vnode); + } + }, + remove: function remove (vnode, rm) { + /* istanbul ignore else */ + if (!vnode.data.show) { + leave(vnode, rm); } else { - if (token.html) { - el = document.createComment('v-html'); - setTokenType('html'); - } else { - // IE will clean up empty textNodes during - // frag.cloneNode(true), so we have to give it - // something here... - el = document.createTextNode(' '); - setTokenType('text'); - } - } - function setTokenType(type) { - if (token.descriptor) return; - var parsed = parseDirective(token.value); - token.descriptor = { - name: type, - def: directives[type], - expression: parsed.expression, - filters: parsed.filters - }; + rm(); } - return el; } +} : {}; - /** - * Build a function that processes a textNode. - * - * @param {Array<Object>} tokens - * @param {DocumentFragment} frag - */ - - function makeTextNodeLinkFn(tokens, frag) { - return function textNodeLinkFn(vm, el, host, scope) { - var fragClone = frag.cloneNode(true); - var childNodes = toArray(fragClone.childNodes); - var token, value, node; - for (var i = 0, l = tokens.length; i < l; i++) { - token = tokens[i]; - value = token.value; - if (token.tag) { - node = childNodes[i]; - if (token.oneTime) { - value = (scope || vm).$eval(value); - if (token.html) { - replace(node, parseTemplate(value, true)); - } else { - node.data = _toString(value); - } - } else { - vm._bindDir(token.descriptor, node, host, scope); - } - } - } - replace(el, fragClone); - }; - } +var platformModules = [ + attrs, + klass, + events, + domProps, + style, + transition +]; - /** - * Compile a node list and return a childLinkFn. - * - * @param {NodeList} nodeList - * @param {Object} options - * @return {Function|undefined} - */ +/* */ - function compileNodeList(nodeList, options) { - var linkFns = []; - var nodeLinkFn, childLinkFn, node; - for (var i = 0, l = nodeList.length; i < l; i++) { - node = nodeList[i]; - nodeLinkFn = compileNode(node, options); - childLinkFn = !(nodeLinkFn && nodeLinkFn.terminal) && node.tagName !== 'SCRIPT' && node.hasChildNodes() ? compileNodeList(node.childNodes, options) : null; - linkFns.push(nodeLinkFn, childLinkFn); - } - return linkFns.length ? makeChildLinkFn(linkFns) : null; - } +// the directive module should be applied last, after all +// built-in modules have been applied. +var modules = platformModules.concat(baseModules); - /** - * Make a child link function for a node's childNodes. - * - * @param {Array<Function>} linkFns - * @return {Function} childLinkFn - */ +var patch$1 = createPatchFunction({ nodeOps: nodeOps, modules: modules }); - function makeChildLinkFn(linkFns) { - return function childLinkFn(vm, nodes, host, scope, frag) { - var node, nodeLinkFn, childrenLinkFn; - for (var i = 0, n = 0, l = linkFns.length; i < l; n++) { - node = nodes[n]; - nodeLinkFn = linkFns[i++]; - childrenLinkFn = linkFns[i++]; - // cache childNodes before linking parent, fix #657 - var childNodes = toArray(node.childNodes); - if (nodeLinkFn) { - nodeLinkFn(vm, node, host, scope, frag); - } - if (childrenLinkFn) { - childrenLinkFn(vm, childNodes, host, scope, frag); - } - } - }; - } +/** + * Not type checking this file because flow doesn't like attaching + * properties to Elements. + */ - /** - * Check for element directives (custom elements that should - * be resovled as terminal directives). - * - * @param {Element} el - * @param {Object} options - */ +var modelableTagRE = /^input|select|textarea|vue-component-[0-9]+(-[0-9a-zA-Z_\-]*)?$/; - function checkElementDirectives(el, options) { - var tag = el.tagName.toLowerCase(); - if (commonTagRE.test(tag)) { - return; +/* istanbul ignore if */ +if (isIE9) { + // http://www.matts411.com/post/internet-explorer-9-oninput/ + document.addEventListener('selectionchange', function () { + var el = document.activeElement; + if (el && el.vmodel) { + trigger(el, 'input'); } - var def = resolveAsset(options, 'elementDirectives', tag); - if (def) { - return makeTerminalNodeLinkFn(el, tag, '', options, def); + }); +} + +var model = { + inserted: function inserted (el, binding, vnode) { + { + if (!modelableTagRE.test(vnode.tag)) { + warn( + "v-model is not supported on element type: <" + (vnode.tag) + ">. " + + 'If you are working with contenteditable, it\'s recommended to ' + + 'wrap a library dedicated for that purpose inside a custom component.', + vnode.context + ); + } } - } - - /** - * Check if an element is a component. If yes, return - * a component link function. - * - * @param {Element} el - * @param {Object} options - * @return {Function|undefined} - */ - - function checkComponent(el, options) { - var component = checkComponentAttr(el, options); - if (component) { - var ref = findRef(el); - var descriptor = { - name: 'component', - ref: ref, - expression: component.id, - def: internalDirectives.component, - modifiers: { - literal: !component.dynamic - } - }; - var componentLinkFn = function componentLinkFn(vm, el, host, scope, frag) { - if (ref) { - defineReactive((scope || vm).$refs, ref, null); - } - vm._bindDir(descriptor, el, host, scope, frag); + if (vnode.tag === 'select') { + var cb = function () { + setSelected(el, binding, vnode.context); }; - componentLinkFn.terminal = true; - return componentLinkFn; - } - } - - /** - * Check an element for terminal directives in fixed order. - * If it finds one, return a terminal link function. - * - * @param {Element} el - * @param {Array} attrs - * @param {Object} options - * @return {Function} terminalLinkFn - */ - - function checkTerminalDirectives(el, attrs, options) { - // skip v-pre - if (getAttr(el, 'v-pre') !== null) { - return skip; - } - // skip v-else block, but only if following v-if - if (el.hasAttribute('v-else')) { - var prev = el.previousElementSibling; - if (prev && prev.hasAttribute('v-if')) { - return skip; - } - } - - var attr, name, value, modifiers, matched, dirName, rawName, arg, def, termDef; - for (var i = 0, j = attrs.length; i < j; i++) { - attr = attrs[i]; - name = attr.name.replace(modifierRE, ''); - if (matched = name.match(dirAttrRE)) { - def = resolveAsset(options, 'directives', matched[1]); - if (def && def.terminal) { - if (!termDef || (def.priority || DEFAULT_TERMINAL_PRIORITY) > termDef.priority) { - termDef = def; - rawName = attr.name; - modifiers = parseModifiers(attr.name); - value = attr.value; - dirName = matched[1]; - arg = matched[2]; - } + cb(); + /* istanbul ignore if */ + if (isIE || isEdge) { + setTimeout(cb, 0); + } + } else if ( + (vnode.tag === 'textarea' || el.type === 'text') && + !binding.modifiers.lazy + ) { + if (!isAndroid) { + el.addEventListener('compositionstart', onCompositionStart); + el.addEventListener('compositionend', onCompositionEnd); + } + /* istanbul ignore if */ + if (isIE9) { + el.vmodel = true; + } + } + }, + componentUpdated: function componentUpdated (el, binding, vnode) { + if (vnode.tag === 'select') { + setSelected(el, binding, vnode.context); + // in case the options rendered by v-for have changed, + // it's possible that the value is out-of-sync with the rendered options. + // detect such cases and filter out values that no longer has a matchig + // option in the DOM. + var needReset = el.multiple + ? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); }) + : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options); + if (needReset) { + trigger(el, 'change'); + } + } + } +}; + +function setSelected (el, binding, vm) { + var value = binding.value; + var isMultiple = el.multiple; + if (isMultiple && !Array.isArray(value)) { + "development" !== 'production' && warn( + "<select multiple v-model=\"" + (binding.expression) + "\"> " + + "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)), + vm + ); + return + } + var selected, option; + for (var i = 0, l = el.options.length; i < l; i++) { + option = el.options[i]; + if (isMultiple) { + selected = looseIndexOf(value, getValue(option)) > -1; + if (option.selected !== selected) { + option.selected = selected; + } + } else { + if (looseEqual(getValue(option), value)) { + if (el.selectedIndex !== i) { + el.selectedIndex = i; } + return } } + } + if (!isMultiple) { + el.selectedIndex = -1; + } +} - if (termDef) { - return makeTerminalNodeLinkFn(el, dirName, value, options, termDef, rawName, arg, modifiers); +function hasNoMatchingOption (value, options) { + for (var i = 0, l = options.length; i < l; i++) { + if (looseEqual(getValue(options[i]), value)) { + return false } } + return true +} - function skip() {} - skip.terminal = true; +function getValue (option) { + return '_value' in option + ? option._value + : option.value +} - /** - * Build a node link function for a terminal directive. - * A terminal link function terminates the current - * compilation recursion and handles compilation of the - * subtree in the directive. - * - * @param {Element} el - * @param {String} dirName - * @param {String} value - * @param {Object} options - * @param {Object} def - * @param {String} [rawName] - * @param {String} [arg] - * @param {Object} [modifiers] - * @return {Function} terminalLinkFn - */ +function onCompositionStart (e) { + e.target.composing = true; +} - function makeTerminalNodeLinkFn(el, dirName, value, options, def, rawName, arg, modifiers) { - var parsed = parseDirective(value); - var descriptor = { - name: dirName, - arg: arg, - expression: parsed.expression, - filters: parsed.filters, - raw: value, - attr: rawName, - modifiers: modifiers, - def: def - }; - // check ref for v-for and router-view - if (dirName === 'for' || dirName === 'router-view') { - descriptor.ref = findRef(el); - } - var fn = function terminalNodeLinkFn(vm, el, host, scope, frag) { - if (descriptor.ref) { - defineReactive((scope || vm).$refs, descriptor.ref, null); - } - vm._bindDir(descriptor, el, host, scope, frag); - }; - fn.terminal = true; - return fn; - } +function onCompositionEnd (e) { + e.target.composing = false; + trigger(e.target, 'input'); +} - /** - * Compile the directives on an element and return a linker. - * - * @param {Array|NamedNodeMap} attrs - * @param {Object} options - * @return {Function} - */ +function trigger (el, type) { + var e = document.createEvent('HTMLEvents'); + e.initEvent(type, true, true); + el.dispatchEvent(e); +} - function compileDirectives(attrs, options) { - var i = attrs.length; - var dirs = []; - var attr, name, value, rawName, rawValue, dirName, arg, modifiers, dirDef, tokens, matched; - while (i--) { - attr = attrs[i]; - name = rawName = attr.name; - value = rawValue = attr.value; - tokens = parseText(value); - // reset arg - arg = null; - // check modifiers - modifiers = parseModifiers(name); - name = name.replace(modifierRE, ''); - - // attribute interpolations - if (tokens) { - value = tokensToExp(tokens); - arg = name; - pushDir('bind', directives.bind, tokens); - // warn against mixing mustaches with v-bind - if ('development' !== 'production') { - if (name === 'class' && Array.prototype.some.call(attrs, function (attr) { - return attr.name === ':class' || attr.name === 'v-bind:class'; - })) { - warn('class="' + rawValue + '": Do not mix mustache interpolation ' + 'and v-bind for "class" on the same element. Use one or the other.', options); - } - } - } else - - // special attribute: transition - if (transitionRE.test(name)) { - modifiers.literal = !bindRE.test(name); - pushDir('transition', internalDirectives.transition); - } else - - // event handlers - if (onRE.test(name)) { - arg = name.replace(onRE, ''); - pushDir('on', directives.on); - } else - - // attribute bindings - if (bindRE.test(name)) { - dirName = name.replace(bindRE, ''); - if (dirName === 'style' || dirName === 'class') { - pushDir(dirName, internalDirectives[dirName]); - } else { - arg = dirName; - pushDir('bind', directives.bind); - } - } else - - // normal directives - if (matched = name.match(dirAttrRE)) { - dirName = matched[1]; - arg = matched[2]; - - // skip v-else (when used with v-show) - if (dirName === 'else') { - continue; - } - - dirDef = resolveAsset(options, 'directives', dirName, true); - if (dirDef) { - pushDir(dirName, dirDef); - } - } - } +/* */ - /** - * Push a directive. - * - * @param {String} dirName - * @param {Object|Function} def - * @param {Array} [interpTokens] - */ - - function pushDir(dirName, def, interpTokens) { - var hasOneTimeToken = interpTokens && hasOneTime(interpTokens); - var parsed = !hasOneTimeToken && parseDirective(value); - dirs.push({ - name: dirName, - attr: rawName, - raw: rawValue, - def: def, - arg: arg, - modifiers: modifiers, - // conversion from interpolation strings with one-time token - // to expression is differed until directive bind time so that we - // have access to the actual vm context for one-time bindings. - expression: parsed && parsed.expression, - filters: parsed && parsed.filters, - interp: interpTokens, - hasOneTime: hasOneTimeToken - }); - } +// recursively search for possible transition defined inside the component root +function locateNode (vnode) { + return vnode.child && (!vnode.data || !vnode.data.transition) + ? locateNode(vnode.child._vnode) + : vnode +} - if (dirs.length) { - return makeNodeLinkFn(dirs); - } - } +var show = { + bind: function bind (el, ref, vnode) { + var value = ref.value; - /** - * Parse modifiers from directive attribute name. - * - * @param {String} name - * @return {Object} - */ + vnode = locateNode(vnode); + var transition = vnode.data && vnode.data.transition; + if (value && transition && !isIE9) { + enter(vnode); + } + var originalDisplay = el.style.display === 'none' ? '' : el.style.display; + el.style.display = value ? originalDisplay : 'none'; + el.__vOriginalDisplay = originalDisplay; + }, + update: function update (el, ref, vnode) { + var value = ref.value; + var oldValue = ref.oldValue; - function parseModifiers(name) { - var res = Object.create(null); - var match = name.match(modifierRE); - if (match) { - var i = match.length; - while (i--) { - res[match[i].slice(1)] = true; + /* istanbul ignore if */ + if (value === oldValue) { return } + vnode = locateNode(vnode); + var transition = vnode.data && vnode.data.transition; + if (transition && !isIE9) { + if (value) { + enter(vnode); + el.style.display = el.__vOriginalDisplay; + } else { + leave(vnode, function () { + el.style.display = 'none'; + }); } - } - return res; + } else { + el.style.display = value ? el.__vOriginalDisplay : 'none'; + } + } +}; + +var platformDirectives = { + model: model, + show: show +}; + +/* */ + +// Provides transition support for a single element/component. +// supports transition mode (out-in / in-out) + +var transitionProps = { + name: String, + appear: Boolean, + css: Boolean, + mode: String, + type: String, + enterClass: String, + leaveClass: String, + enterActiveClass: String, + leaveActiveClass: String, + appearClass: String, + appearActiveClass: String +}; + +// in case the child is also an abstract component, e.g. <keep-alive> +// we want to recrusively retrieve the real component to be rendered +function getRealChild (vnode) { + var compOptions = vnode && vnode.componentOptions; + if (compOptions && compOptions.Ctor.options.abstract) { + return getRealChild(getFirstComponentChild(compOptions.children)) + } else { + return vnode } +} - /** - * Build a link function for all directives on a single node. - * - * @param {Array} directives - * @return {Function} directivesLinkFn - */ - - function makeNodeLinkFn(directives) { - return function nodeLinkFn(vm, el, host, scope, frag) { - // reverse apply because it's sorted low to high - var i = directives.length; - while (i--) { - vm._bindDir(directives[i], el, host, scope, frag); - } - }; +function extractTransitionData (comp) { + var data = {}; + var options = comp.$options; + // props + for (var key in options.propsData) { + data[key] = comp[key]; + } + // events. + // extract listeners and pass them directly to the transition methods + var listeners = options._parentListeners; + for (var key$1 in listeners) { + data[camelize(key$1)] = listeners[key$1].fn; } + return data +} - /** - * Check if an interpolation string contains one-time tokens. - * - * @param {Array} tokens - * @return {Boolean} - */ +function placeholder (h, rawChild) { + return /\d-keep-alive$/.test(rawChild.tag) + ? h('keep-alive') + : null +} - function hasOneTime(tokens) { - var i = tokens.length; - while (i--) { - if (tokens[i].oneTime) return true; +function hasParentTransition (vnode) { + while ((vnode = vnode.parent)) { + if (vnode.data.transition) { + return true } } +} - function isScript(el) { - return el.tagName === 'SCRIPT' && (!el.hasAttribute('type') || el.getAttribute('type') === 'text/javascript'); - } - - var specialCharRE = /[^\w\-:\.]/; +var Transition = { + name: 'transition', + props: transitionProps, + abstract: true, + render: function render (h) { + var this$1 = this; - /** - * Process an element or a DocumentFragment based on a - * instance option object. This allows us to transclude - * a template node/fragment before the instance is created, - * so the processed fragment can then be cloned and reused - * in v-for. - * - * @param {Element} el - * @param {Object} options - * @return {Element|DocumentFragment} - */ - - function transclude(el, options) { - // extract container attributes to pass them down - // to compiler, because they need to be compiled in - // parent scope. we are mutating the options object here - // assuming the same object will be used for compile - // right after this. - if (options) { - options._containerAttrs = extractAttrs(el); + var children = this.$slots.default; + if (!children) { + return } - // for template tags, what we want is its content as - // a documentFragment (for fragment instances) - if (isTemplate(el)) { - el = parseTemplate(el); - } - if (options) { - if (options._asComponent && !options.template) { - options.template = '<slot></slot>'; - } - if (options.template) { - options._content = extractContent(el); - el = transcludeTemplate(el, options); - } + + // filter out text nodes (possible whitespaces) + children = children.filter(function (c) { return c.tag; }); + /* istanbul ignore if */ + if (!children.length) { + return } - if (isFragment(el)) { - // anchors for fragment instance - // passing in `persist: true` to avoid them being - // discarded by IE during template cloning - prepend(createAnchor('v-start', true), el); - el.appendChild(createAnchor('v-end', true)); + + // warn multiple elements + if ("development" !== 'production' && children.length > 1) { + warn( + '<transition> can only be used on a single element. Use ' + + '<transition-group> for lists.', + this.$parent + ); } - return el; - } - /** - * Process the template option. - * If the replace option is true this will swap the $el. - * - * @param {Element} el - * @param {Object} options - * @return {Element|DocumentFragment} - */ + var mode = this.mode; - function transcludeTemplate(el, options) { - var template = options.template; - var frag = parseTemplate(template, true); - if (frag) { - var replacer = frag.firstChild; - var tag = replacer.tagName && replacer.tagName.toLowerCase(); - if (options.replace) { - /* istanbul ignore if */ - if (el === document.body) { - 'development' !== 'production' && warn('You are mounting an instance with a template to ' + '<body>. This will replace <body> entirely. You ' + 'should probably use `replace: false` here.'); - } - // there are many cases where the instance must - // become a fragment instance: basically anything that - // can create more than 1 root nodes. - if ( - // multi-children template - frag.childNodes.length > 1 || - // non-element template - replacer.nodeType !== 1 || - // single nested component - tag === 'component' || resolveAsset(options, 'components', tag) || hasBindAttr(replacer, 'is') || - // element directive - resolveAsset(options, 'elementDirectives', tag) || - // for block - replacer.hasAttribute('v-for') || - // if block - replacer.hasAttribute('v-if')) { - return frag; - } else { - options._replacerAttrs = extractAttrs(replacer); - mergeAttrs(el, replacer); - return replacer; - } - } else { - el.appendChild(frag); - return el; - } - } else { - 'development' !== 'production' && warn('Invalid template option: ' + template); + // warn invalid mode + if ("development" !== 'production' && + mode && mode !== 'in-out' && mode !== 'out-in') { + warn( + 'invalid <transition> mode: ' + mode, + this.$parent + ); } - } - /** - * Helper to extract a component container's attributes - * into a plain object array. - * - * @param {Element} el - * @return {Array} - */ + var rawChild = children[0]; - function extractAttrs(el) { - if (el.nodeType === 1 && el.hasAttributes()) { - return toArray(el.attributes); + // if this is a component root node and the component's + // parent container node also has transition, skip. + if (hasParentTransition(this.$vnode)) { + return rawChild } - } - /** - * Merge the attributes of two elements, and make sure - * the class names are merged properly. - * - * @param {Element} from - * @param {Element} to - */ - - function mergeAttrs(from, to) { - var attrs = from.attributes; - var i = attrs.length; - var name, value; - while (i--) { - name = attrs[i].name; - value = attrs[i].value; - if (!to.hasAttribute(name) && !specialCharRE.test(name)) { - to.setAttribute(name, value); - } else if (name === 'class' && !parseText(value) && (value = value.trim())) { - value.split(/\s+/).forEach(function (cls) { - addClass(to, cls); - }); + // apply transition data to child + // use getRealChild() to ignore abstract components e.g. keep-alive + var child = getRealChild(rawChild); + /* istanbul ignore if */ + if (!child) { + return rawChild + } + + if (this._leaving) { + return placeholder(h, rawChild) + } + + var key = child.key = child.key == null || child.isStatic + ? ("__v" + (child.tag + this._uid) + "__") + : child.key; + var data = (child.data || (child.data = {})).transition = extractTransitionData(this); + var oldRawChild = this._vnode; + var oldChild = getRealChild(oldRawChild); + + // mark v-show + // so that the transition module can hand over the control to the directive + if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) { + child.data.show = true; + } + + if (oldChild && oldChild.data && oldChild.key !== key) { + // replace old child transition data with fresh one + // important for dynamic transitions! + var oldData = oldChild.data.transition = extend({}, data); + + // handle transition mode + if (mode === 'out-in') { + // return placeholder node and queue update when leave finishes + this._leaving = true; + mergeVNodeHook(oldData, 'afterLeave', function () { + this$1._leaving = false; + this$1.$forceUpdate(); + }, key); + return placeholder(h, rawChild) + } else if (mode === 'in-out') { + var delayedLeave; + var performLeave = function () { delayedLeave(); }; + mergeVNodeHook(data, 'afterEnter', performLeave, key); + mergeVNodeHook(data, 'enterCancelled', performLeave, key); + mergeVNodeHook(oldData, 'delayLeave', function (leave) { + delayedLeave = leave; + }, key); + } + } + + return rawChild + } +}; + +/* */ + +// Provides transition support for list items. +// supports move transitions using the FLIP technique. + +// Because the vdom's children update algorithm is "unstable" - i.e. +// it doesn't guarantee the relative positioning of removed elements, +// we force transition-group to update its children into two passes: +// in the first pass, we remove all nodes that need to be removed, +// triggering their leaving transition; in the second pass, we insert/move +// into the final disired state. This way in the second pass removed +// nodes will remain where they should be. + +var props = extend({ + tag: String, + moveClass: String +}, transitionProps); + +delete props.mode; + +var TransitionGroup = { + props: props, + + render: function render (h) { + var tag = this.tag || this.$vnode.data.tag || 'span'; + var map = Object.create(null); + var prevChildren = this.prevChildren = this.children; + var rawChildren = this.$slots.default || []; + var children = this.children = []; + var transitionData = extractTransitionData(this); + + for (var i = 0; i < rawChildren.length; i++) { + var c = rawChildren[i]; + if (c.tag) { + if (c.key != null && String(c.key).indexOf('__vlist') !== 0) { + children.push(c); + map[c.key] = c + ;(c.data || (c.data = {})).transition = transitionData; + } else { + var opts = c.componentOptions; + var name = opts + ? (opts.Ctor.options.name || opts.tag) + : c.tag; + warn(("<transition-group> children must be keyed: <" + name + ">")); + } } } - } - - /** - * Scan and determine slot content distribution. - * We do this during transclusion instead at compile time so that - * the distribution is decoupled from the compilation order of - * the slots. - * - * @param {Element|DocumentFragment} template - * @param {Element} content - * @param {Vue} vm - */ - function resolveSlots(vm, content) { - if (!content) { - return; - } - var contents = vm._slotContents = Object.create(null); - var el, name; - for (var i = 0, l = content.children.length; i < l; i++) { - el = content.children[i]; - /* eslint-disable no-cond-assign */ - if (name = el.getAttribute('slot')) { - (contents[name] || (contents[name] = [])).push(el); + if (prevChildren) { + var kept = []; + var removed = []; + for (var i$1 = 0; i$1 < prevChildren.length; i$1++) { + var c$1 = prevChildren[i$1]; + c$1.data.transition = transitionData; + c$1.data.pos = c$1.elm.getBoundingClientRect(); + if (map[c$1.key]) { + kept.push(c$1); + } else { + removed.push(c$1); + } + } + this.kept = h(tag, null, kept); + this.removed = removed; + } + + return h(tag, null, children) + }, + + beforeUpdate: function beforeUpdate () { + // force removing pass + this.__patch__( + this._vnode, + this.kept, + false, // hydrating + true // removeOnly (!important, avoids unnecessary moves) + ); + this._vnode = this.kept; + }, + + updated: function updated () { + var children = this.prevChildren; + var moveClass = this.moveClass || (this.name + '-move'); + if (!children.length || !this.hasMove(children[0].elm, moveClass)) { + return + } + + // we divide the work into three loops to avoid mixing DOM reads and writes + // in each iteration - which helps prevent layout thrashing. + children.forEach(callPendingCbs); + children.forEach(recordPosition); + children.forEach(applyTranslation); + + // force reflow to put everything in position + var f = document.body.offsetHeight; // eslint-disable-line + + children.forEach(function (c) { + if (c.data.moved) { + var el = c.elm; + var s = el.style; + addTransitionClass(el, moveClass); + s.transform = s.WebkitTransform = s.transitionDuration = ''; + el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) { + if (!e || /transform$/.test(e.propertyName)) { + el.removeEventListener(transitionEndEvent, cb); + el._moveCb = null; + removeTransitionClass(el, moveClass); + } + }); } - /* eslint-enable no-cond-assign */ - if ('development' !== 'production' && getBindAttr(el, 'slot')) { - warn('The "slot" attribute must be static.', vm.$parent); + }); + }, + + methods: { + hasMove: function hasMove (el, moveClass) { + /* istanbul ignore if */ + if (!hasTransition) { + return false } - } - for (name in contents) { - contents[name] = extractFragment(contents[name], content); - } - if (content.hasChildNodes()) { - var nodes = content.childNodes; - if (nodes.length === 1 && nodes[0].nodeType === 3 && !nodes[0].data.trim()) { - return; + if (this._hasMove != null) { + return this._hasMove } - contents['default'] = extractFragment(content.childNodes, content); + addTransitionClass(el, moveClass); + var info = getTransitionInfo(el); + removeTransitionClass(el, moveClass); + return (this._hasMove = info.hasTransform) } } +}; - /** - * Extract qualified content nodes from a node list. - * - * @param {NodeList} nodes - * @return {DocumentFragment} - */ - - function extractFragment(nodes, parent) { - var frag = document.createDocumentFragment(); - nodes = toArray(nodes); - for (var i = 0, l = nodes.length; i < l; i++) { - var node = nodes[i]; - if (isTemplate(node) && !node.hasAttribute('v-if') && !node.hasAttribute('v-for')) { - parent.removeChild(node); - node = parseTemplate(node, true); - } - frag.appendChild(node); +function callPendingCbs (c) { + /* istanbul ignore if */ + if (c.elm._moveCb) { + c.elm._moveCb(); + } + /* istanbul ignore if */ + if (c.elm._enterCb) { + c.elm._enterCb(); + } +} + +function recordPosition (c) { + c.data.newPos = c.elm.getBoundingClientRect(); +} + +function applyTranslation (c) { + var oldPos = c.data.pos; + var newPos = c.data.newPos; + var dx = oldPos.left - newPos.left; + var dy = oldPos.top - newPos.top; + if (dx || dy) { + c.data.moved = true; + var s = c.elm.style; + s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)"; + s.transitionDuration = '0s'; + } +} + +var platformComponents = { + Transition: Transition, + TransitionGroup: TransitionGroup +}; + +/* */ + +// install platform specific utils +Vue$3.config.isUnknownElement = isUnknownElement; +Vue$3.config.isReservedTag = isReservedTag; +Vue$3.config.getTagNamespace = getTagNamespace; +Vue$3.config.mustUseProp = mustUseProp; + +// install platform runtime directives & components +extend(Vue$3.options.directives, platformDirectives); +extend(Vue$3.options.components, platformComponents); + +// install platform patch function +Vue$3.prototype.__patch__ = config._isServer ? noop : patch$1; + +// wrap mount +Vue$3.prototype.$mount = function ( + el, + hydrating +) { + el = el && !config._isServer ? query(el) : undefined; + return this._mount(el, hydrating) +}; + +// devtools global hook +/* istanbul ignore next */ +setTimeout(function () { + if (config.devtools) { + if (devtools) { + devtools.emit('init', Vue$3); + } else if ( + "development" !== 'production' && + inBrowser && /Chrome\/\d+/.test(window.navigator.userAgent) + ) { + console.log( + 'Download the Vue Devtools for a better development experience:\n' + + 'https://github.com/vuejs/vue-devtools' + ); } - return frag; } +}, 0); +/* */ +// check whether current browser encodes a char inside attribute values +function shouldDecode (content, encoded) { + var div = document.createElement('div'); + div.innerHTML = "<div a=\"" + content + "\">"; + return div.innerHTML.indexOf(encoded) > 0 +} - var compiler = Object.freeze({ - compile: compile, - compileAndLinkProps: compileAndLinkProps, - compileRoot: compileRoot, - transclude: transclude, - resolveSlots: resolveSlots - }); +// #3663 +// IE encodes newlines inside attribute values while other browsers don't +var shouldDecodeNewlines = inBrowser ? shouldDecode('\n', ' ') : false; - function stateMixin (Vue) { - /** - * Accessor for `$data` property, since setting $data - * requires observing the new object and updating - * proxied properties. - */ - - Object.defineProperty(Vue.prototype, '$data', { - get: function get() { - return this._data; - }, - set: function set(newData) { - if (newData !== this._data) { - this._setData(newData); - } - } - }); +/* */ - /** - * Setup the scope of an instance, which contains: - * - observed data - * - computed properties - * - user methods - * - meta properties - */ - - Vue.prototype._initState = function () { - this._initProps(); - this._initMeta(); - this._initMethods(); - this._initData(); - this._initComputed(); - }; +var decoder = document.createElement('div'); - /** - * Initialize props. - */ - - Vue.prototype._initProps = function () { - var options = this.$options; - var el = options.el; - var props = options.props; - if (props && !el) { - 'development' !== 'production' && warn('Props will not be compiled if no `el` option is ' + 'provided at instantiation.', this); - } - // make sure to convert string selectors into element now - el = options.el = query(el); - this._propsUnlinkFn = el && el.nodeType === 1 && props - // props must be linked in proper scope if inside v-for - ? compileAndLinkProps(this, el, props, this._scope) : null; - }; +function decode (html) { + decoder.innerHTML = html; + return decoder.textContent +} - /** - * Initialize the data. - */ - - Vue.prototype._initData = function () { - var dataFn = this.$options.data; - var data = this._data = dataFn ? dataFn() : {}; - if (!isPlainObject(data)) { - data = {}; - 'development' !== 'production' && warn('data functions should return an object.', this); - } - var props = this._props; - // proxy data on instance - var keys = Object.keys(data); - var i, key; - i = keys.length; - while (i--) { - key = keys[i]; - // there are two scenarios where we can proxy a data key: - // 1. it's not already defined as a prop - // 2. it's provided via a instantiation option AND there are no - // template prop present - if (!props || !hasOwn(props, key)) { - this._proxy(key); - } else if ('development' !== 'production') { - warn('Data field "' + key + '" is already defined ' + 'as a prop. To provide default value for a prop, use the "default" ' + 'prop option; if you want to pass prop values to an instantiation ' + 'call, use the "propsData" option.', this); - } - } - // observe data - observe(data, this); - }; +/** + * Not type-checking this file because it's mostly vendor code. + */ - /** - * Swap the instance's $data. Called in $data's setter. - * - * @param {Object} newData - */ - - Vue.prototype._setData = function (newData) { - newData = newData || {}; - var oldData = this._data; - this._data = newData; - var keys, key, i; - // unproxy keys not present in new data - keys = Object.keys(oldData); - i = keys.length; - while (i--) { - key = keys[i]; - if (!(key in newData)) { - this._unproxy(key); - } - } - // proxy keys not already proxied, - // and trigger change for changed values - keys = Object.keys(newData); - i = keys.length; - while (i--) { - key = keys[i]; - if (!hasOwn(this, key)) { - // new property - this._proxy(key); - } - } - oldData.__ob__.removeVm(this); - observe(newData, this); - this._digest(); - }; +/*! + * HTML Parser By John Resig (ejohn.org) + * Modified by Juriy "kangax" Zaytsev + * Original code by Erik Arvidsson, Mozilla Public License + * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js + */ - /** - * Proxy a property, so that - * vm.prop === vm._data.prop - * - * @param {String} key - */ - - Vue.prototype._proxy = function (key) { - if (!isReserved(key)) { - // need to store ref to self here - // because these getter/setters might - // be called by child scopes via - // prototype inheritance. - var self = this; - Object.defineProperty(self, key, { - configurable: true, - enumerable: true, - get: function proxyGetter() { - return self._data[key]; - }, - set: function proxySetter(val) { - self._data[key] = val; +// Regular Expressions for parsing tags and attributes +var singleAttrIdentifier = /([^\s"'<>\/=]+)/; +var singleAttrAssign = /(?:=)/; +var singleAttrValues = [ + // attr value double quotes + /"([^"]*)"+/.source, + // attr value, single quotes + /'([^']*)'+/.source, + // attr value, no quotes + /([^\s"'=<>`]+)/.source +]; +var attribute = new RegExp( + '^\\s*' + singleAttrIdentifier.source + + '(?:\\s*(' + singleAttrAssign.source + ')' + + '\\s*(?:' + singleAttrValues.join('|') + '))?' +); + +// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName +// but for Vue templates we can enforce a simple charset +var ncname = '[a-zA-Z_][\\w\\-\\.]*'; +var qnameCapture = '((?:' + ncname + '\\:)?' + ncname + ')'; +var startTagOpen = new RegExp('^<' + qnameCapture); +var startTagClose = /^\s*(\/?)>/; +var endTag = new RegExp('^<\\/' + qnameCapture + '[^>]*>'); +var doctype = /^<!DOCTYPE [^>]+>/i; + +var IS_REGEX_CAPTURING_BROKEN = false; +'x'.replace(/x(.)?/g, function (m, g) { + IS_REGEX_CAPTURING_BROKEN = g === ''; +}); + +// Special Elements (can contain anything) +var isSpecialTag = makeMap('script,style', true); + +var reCache = {}; + +var ltRE = /</g; +var gtRE = />/g; +var nlRE = / /g; +var ampRE = /&/g; +var quoteRE = /"/g; + +function decodeAttr (value, shouldDecodeNewlines) { + if (shouldDecodeNewlines) { + value = value.replace(nlRE, '\n'); + } + return value + .replace(ltRE, '<') + .replace(gtRE, '>') + .replace(ampRE, '&') + .replace(quoteRE, '"') +} + +function parseHTML (html, options) { + var stack = []; + var expectHTML = options.expectHTML; + var isUnaryTag$$1 = options.isUnaryTag || no; + var index = 0; + var last, lastTag; + while (html) { + last = html; + // Make sure we're not in a script or style element + if (!lastTag || !isSpecialTag(lastTag)) { + var textEnd = html.indexOf('<'); + if (textEnd === 0) { + // Comment: + if (/^<!--/.test(html)) { + var commentEnd = html.indexOf('-->'); + + if (commentEnd >= 0) { + advance(commentEnd + 3); + continue } - }); - } - }; - - /** - * Unproxy a property. - * - * @param {String} key - */ - - Vue.prototype._unproxy = function (key) { - if (!isReserved(key)) { - delete this[key]; - } - }; - - /** - * Force update on every watcher in scope. - */ + } - Vue.prototype._digest = function () { - for (var i = 0, l = this._watchers.length; i < l; i++) { - this._watchers[i].update(true); // shallow updates - } - }; + // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment + if (/^<!\[/.test(html)) { + var conditionalEnd = html.indexOf(']>'); - /** - * Setup computed properties. They are essentially - * special getter/setters - */ - - function noop() {} - Vue.prototype._initComputed = function () { - var computed = this.$options.computed; - if (computed) { - for (var key in computed) { - var userDef = computed[key]; - var def = { - enumerable: true, - configurable: true - }; - if (typeof userDef === 'function') { - def.get = makeComputedGetter(userDef, this); - def.set = noop; - } else { - def.get = userDef.get ? userDef.cache !== false ? makeComputedGetter(userDef.get, this) : bind(userDef.get, this) : noop; - def.set = userDef.set ? bind(userDef.set, this) : noop; + if (conditionalEnd >= 0) { + advance(conditionalEnd + 2); + continue } - Object.defineProperty(this, key, def); } - } - }; - function makeComputedGetter(getter, owner) { - var watcher = new Watcher(owner, getter, null, { - lazy: true - }); - return function computedGetter() { - if (watcher.dirty) { - watcher.evaluate(); + // Doctype: + var doctypeMatch = html.match(doctype); + if (doctypeMatch) { + advance(doctypeMatch[0].length); + continue } - if (Dep.target) { - watcher.depend(); - } - return watcher.value; - }; - } - /** - * Setup instance methods. Methods must be bound to the - * instance since they might be passed down as a prop to - * child components. - */ - - Vue.prototype._initMethods = function () { - var methods = this.$options.methods; - if (methods) { - for (var key in methods) { - this[key] = bind(methods[key], this); + // End tag: + var endTagMatch = html.match(endTag); + if (endTagMatch) { + var curIndex = index; + advance(endTagMatch[0].length); + parseEndTag(endTagMatch[0], endTagMatch[1], curIndex, index); + continue } - } - }; - - /** - * Initialize meta information like $index, $key & $value. - */ - Vue.prototype._initMeta = function () { - var metas = this.$options._meta; - if (metas) { - for (var key in metas) { - defineReactive(this, key, metas[key]); + // Start tag: + var startTagMatch = parseStartTag(); + if (startTagMatch) { + handleStartTag(startTagMatch); + continue } } - }; - } - - var eventRE = /^v-on:|^@/; - - function eventsMixin (Vue) { - /** - * Setup the instance's option events & watchers. - * If the value is a string, we pull it from the - * instance's methods by name. - */ - - Vue.prototype._initEvents = function () { - var options = this.$options; - if (options._asComponent) { - registerComponentEvents(this, options.el); - } - registerCallbacks(this, '$on', options.events); - registerCallbacks(this, '$watch', options.watch); - }; - /** - * Register v-on events on a child component - * - * @param {Vue} vm - * @param {Element} el - */ - - function registerComponentEvents(vm, el) { - var attrs = el.attributes; - var name, value, handler; - for (var i = 0, l = attrs.length; i < l; i++) { - name = attrs[i].name; - if (eventRE.test(name)) { - name = name.replace(eventRE, ''); - // force the expression into a statement so that - // it always dynamically resolves the method to call (#2670) - // kinda ugly hack, but does the job. - value = attrs[i].value; - if (isSimplePath(value)) { - value += '.apply(this, $arguments)'; - } - handler = (vm._scope || vm._context).$eval(value, true); - handler._fromParent = true; - vm.$on(name.replace(eventRE), handler); - } + var text = void 0; + if (textEnd >= 0) { + text = html.substring(0, textEnd); + advance(textEnd); + } else { + text = html; + html = ''; } - } - /** - * Register callbacks for option events and watchers. - * - * @param {Vue} vm - * @param {String} action - * @param {Object} hash - */ - - function registerCallbacks(vm, action, hash) { - if (!hash) return; - var handlers, key, i, j; - for (key in hash) { - handlers = hash[key]; - if (isArray(handlers)) { - for (i = 0, j = handlers.length; i < j; i++) { - register(vm, action, key, handlers[i]); - } - } else { - register(vm, action, key, handlers); - } + if (options.chars) { + options.chars(text); } + } else { + var stackedTag = lastTag.toLowerCase(); + var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i')); + var endTagLength = 0; + var rest = html.replace(reStackedTag, function (all, text, endTag) { + endTagLength = endTag.length; + if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') { + text = text + .replace(/<!--([\s\S]*?)-->/g, '$1') + .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1'); + } + if (options.chars) { + options.chars(text); + } + return '' + }); + index += html.length - rest.length; + html = rest; + parseEndTag('</' + stackedTag + '>', stackedTag, index - endTagLength, index); } - /** - * Helper to register an event/watch callback. - * - * @param {Vue} vm - * @param {String} action - * @param {String} key - * @param {Function|String|Object} handler - * @param {Object} [options] - */ - - function register(vm, action, key, handler, options) { - var type = typeof handler; - if (type === 'function') { - vm[action](key, handler, options); - } else if (type === 'string') { - var methods = vm.$options.methods; - var method = methods && methods[handler]; - if (method) { - vm[action](key, method, options); - } else { - 'development' !== 'production' && warn('Unknown method: "' + handler + '" when ' + 'registering callback for ' + action + ': "' + key + '".', vm); - } - } else if (handler && type === 'object') { - register(vm, action, key, handler.handler, handler); - } + if (html === last) { + throw new Error('Error parsing template:\n\n' + html) } + } - /** - * Setup recursive attached/detached calls - */ - - Vue.prototype._initDOMHooks = function () { - this.$on('hook:attached', onAttached); - this.$on('hook:detached', onDetached); - }; + // Clean up any remaining tags + parseEndTag(); - /** - * Callback to recursively call attached hook on children - */ + function advance (n) { + index += n; + html = html.substring(n); + } - function onAttached() { - if (!this._isAttached) { - this._isAttached = true; - this.$children.forEach(callAttach); + function parseStartTag () { + var start = html.match(startTagOpen); + if (start) { + var match = { + tagName: start[1], + attrs: [], + start: index + }; + advance(start[0].length); + var end, attr; + while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) { + advance(attr[0].length); + match.attrs.push(attr); } - } - - /** - * Iterator to call attached hook - * - * @param {Vue} child - */ - - function callAttach(child) { - if (!child._isAttached && inDoc(child.$el)) { - child._callHook('attached'); + if (end) { + match.unarySlash = end[1]; + advance(end[0].length); + match.end = index; + return match } } + } - /** - * Callback to recursively call detached hook on children - */ + function handleStartTag (match) { + var tagName = match.tagName; + var unarySlash = match.unarySlash; - function onDetached() { - if (this._isAttached) { - this._isAttached = false; - this.$children.forEach(callDetach); + if (expectHTML) { + if (lastTag === 'p' && isNonPhrasingTag(tagName)) { + parseEndTag('', lastTag); } - } - - /** - * Iterator to call detached hook - * - * @param {Vue} child - */ - - function callDetach(child) { - if (child._isAttached && !inDoc(child.$el)) { - child._callHook('detached'); + if (canBeLeftOpenTag(tagName) && lastTag === tagName) { + parseEndTag('', tagName); } } - /** - * Trigger all handlers for a hook - * - * @param {String} hook - */ + var unary = isUnaryTag$$1(tagName) || tagName === 'html' && lastTag === 'head' || !!unarySlash; - Vue.prototype._callHook = function (hook) { - this.$emit('pre-hook:' + hook); - var handlers = this.$options[hook]; - if (handlers) { - for (var i = 0, j = handlers.length; i < j; i++) { - handlers[i].call(this); - } + var l = match.attrs.length; + var attrs = new Array(l); + for (var i = 0; i < l; i++) { + var args = match.attrs[i]; + // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778 + if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) { + if (args[3] === '') { delete args[3]; } + if (args[4] === '') { delete args[4]; } + if (args[5] === '') { delete args[5]; } } - this.$emit('hook:' + hook); - }; - } + var value = args[3] || args[4] || args[5] || ''; + attrs[i] = { + name: args[1], + value: decodeAttr( + value, + options.shouldDecodeNewlines + ) + }; + } - function noop$1() {} + if (!unary) { + stack.push({ tag: tagName, attrs: attrs }); + lastTag = tagName; + unarySlash = ''; + } - /** - * A directive links a DOM element with a piece of data, - * which is the result of evaluating an expression. - * It registers a watcher with the expression and calls - * the DOM update function when a change is triggered. - * - * @param {Object} descriptor - * - {String} name - * - {Object} def - * - {String} expression - * - {Array<Object>} [filters] - * - {Object} [modifiers] - * - {Boolean} literal - * - {String} attr - * - {String} arg - * - {String} raw - * - {String} [ref] - * - {Array<Object>} [interp] - * - {Boolean} [hasOneTime] - * @param {Vue} vm - * @param {Node} el - * @param {Vue} [host] - transclusion host component - * @param {Object} [scope] - v-for scope - * @param {Fragment} [frag] - owner fragment - * @constructor - */ - function Directive(descriptor, vm, el, host, scope, frag) { - this.vm = vm; - this.el = el; - // copy descriptor properties - this.descriptor = descriptor; - this.name = descriptor.name; - this.expression = descriptor.expression; - this.arg = descriptor.arg; - this.modifiers = descriptor.modifiers; - this.filters = descriptor.filters; - this.literal = this.modifiers && this.modifiers.literal; - // private - this._locked = false; - this._bound = false; - this._listeners = null; - // link context - this._host = host; - this._scope = scope; - this._frag = frag; - // store directives on node in dev mode - if ('development' !== 'production' && this.el) { - this.el._vue_directives = this.el._vue_directives || []; - this.el._vue_directives.push(this); + if (options.start) { + options.start(tagName, attrs, unary, match.start, match.end); } } - /** - * Initialize the directive, mixin definition properties, - * setup the watcher, call definition bind() and update() - * if present. - */ - - Directive.prototype._bind = function () { - var name = this.name; - var descriptor = this.descriptor; + function parseEndTag (tag, tagName, start, end) { + var pos; + if (start == null) { start = index; } + if (end == null) { end = index; } - // remove attribute - if ((name !== 'cloak' || this.vm._isCompiled) && this.el && this.el.removeAttribute) { - var attr = descriptor.attr || 'v-' + name; - this.el.removeAttribute(attr); - } - - // copy def properties - var def = descriptor.def; - if (typeof def === 'function') { - this.update = def; + // Find the closest opened tag of the same type + if (tagName) { + var needle = tagName.toLowerCase(); + for (pos = stack.length - 1; pos >= 0; pos--) { + if (stack[pos].tag.toLowerCase() === needle) { + break + } + } } else { - extend(this, def); + // If no tag name is provided, clean shop + pos = 0; } - // setup directive params - this._setupParams(); - - // initial bind - if (this.bind) { - this.bind(); - } - this._bound = true; + if (pos >= 0) { + // Close all the open elements, up the stack + for (var i = stack.length - 1; i >= pos; i--) { + if (options.end) { + options.end(stack[i].tag, start, end); + } + } - if (this.literal) { - this.update && this.update(descriptor.raw); - } else if ((this.expression || this.modifiers) && (this.update || this.twoWay) && !this._checkStatement()) { - // wrapped updater for context - var dir = this; - if (this.update) { - this._update = function (val, oldVal) { - if (!dir._locked) { - dir.update(val, oldVal); - } - }; - } else { - this._update = noop$1; + // Remove the open elements from the stack + stack.length = pos; + lastTag = pos && stack[pos - 1].tag; + } else if (tagName.toLowerCase() === 'br') { + if (options.start) { + options.start(tagName, [], true, start, end); } - var preProcess = this._preProcess ? bind(this._preProcess, this) : null; - var postProcess = this._postProcess ? bind(this._postProcess, this) : null; - var watcher = this._watcher = new Watcher(this.vm, this.expression, this._update, // callback - { - filters: this.filters, - twoWay: this.twoWay, - deep: this.deep, - preProcess: preProcess, - postProcess: postProcess, - scope: this._scope - }); - // v-model with inital inline value need to sync back to - // model instead of update to DOM on init. They would - // set the afterBind hook to indicate that. - if (this.afterBind) { - this.afterBind(); - } else if (this.update) { - this.update(watcher.value); + } else if (tagName.toLowerCase() === 'p') { + if (options.start) { + options.start(tagName, [], false, start, end); } - } - }; - - /** - * Setup all param attributes, e.g. track-by, - * transition-mode, etc... - */ - - Directive.prototype._setupParams = function () { - if (!this.params) { - return; - } - var params = this.params; - // swap the params array with a fresh object. - this.params = Object.create(null); - var i = params.length; - var key, val, mappedKey; - while (i--) { - key = hyphenate(params[i]); - mappedKey = camelize(key); - val = getBindAttr(this.el, key); - if (val != null) { - // dynamic - this._setupParamWatcher(mappedKey, val); - } else { - // static - val = getAttr(this.el, key); - if (val != null) { - this.params[mappedKey] = val === '' ? true : val; - } + if (options.end) { + options.end(tagName, start, end); } } - }; + } +} - /** - * Setup a watcher for a dynamic param. - * - * @param {String} key - * @param {String} expression - */ +/* */ - Directive.prototype._setupParamWatcher = function (key, expression) { - var self = this; - var called = false; - var unwatch = (this._scope || this.vm).$watch(expression, function (val, oldVal) { - self.params[key] = val; - // since we are in immediate mode, - // only call the param change callbacks if this is not the first update. - if (called) { - var cb = self.paramWatchers && self.paramWatchers[key]; - if (cb) { - cb.call(self, val, oldVal); - } +function parseFilters (exp) { + var inSingle = false; + var inDouble = false; + var curly = 0; + var square = 0; + var paren = 0; + var lastFilterIndex = 0; + var c, prev, i, expression, filters; + + for (i = 0; i < exp.length; i++) { + prev = c; + c = exp.charCodeAt(i); + if (inSingle) { + // check single quote + if (c === 0x27 && prev !== 0x5C) { inSingle = !inSingle; } + } else if (inDouble) { + // check double quote + if (c === 0x22 && prev !== 0x5C) { inDouble = !inDouble; } + } else if ( + c === 0x7C && // pipe + exp.charCodeAt(i + 1) !== 0x7C && + exp.charCodeAt(i - 1) !== 0x7C && + !curly && !square && !paren + ) { + if (expression === undefined) { + // first filter, end of expression + lastFilterIndex = i + 1; + expression = exp.slice(0, i).trim(); } else { - called = true; + pushFilter(); } - }, { - immediate: true, - user: false - });(this._paramUnwatchFns || (this._paramUnwatchFns = [])).push(unwatch); - }; - - /** - * Check if the directive is a function caller - * and if the expression is a callable one. If both true, - * we wrap up the expression and use it as the event - * handler. - * - * e.g. on-click="a++" - * - * @return {Boolean} - */ - - Directive.prototype._checkStatement = function () { - var expression = this.expression; - if (expression && this.acceptStatement && !isSimplePath(expression)) { - var fn = parseExpression(expression).get; - var scope = this._scope || this.vm; - var handler = function handler(e) { - scope.$event = e; - fn.call(scope, scope); - scope.$event = null; - }; - if (this.filters) { - handler = scope._applyFilters(handler, null, this.filters); + } else { + switch (c) { + case 0x22: inDouble = true; break // " + case 0x27: inSingle = true; break // ' + case 0x28: paren++; break // ( + case 0x29: paren--; break // ) + case 0x5B: square++; break // [ + case 0x5D: square--; break // ] + case 0x7B: curly++; break // { + case 0x7D: curly--; break // } } - this.update(handler); - return true; - } - }; - - /** - * Set the corresponding value with the setter. - * This should only be used in two-way directives - * e.g. v-model. - * - * @param {*} value - * @public - */ - - Directive.prototype.set = function (value) { - /* istanbul ignore else */ - if (this.twoWay) { - this._withLock(function () { - this._watcher.set(value); - }); - } else if ('development' !== 'production') { - warn('Directive.set() can only be used inside twoWay' + 'directives.'); } - }; - - /** - * Execute a function while preventing that function from - * triggering updates on this directive instance. - * - * @param {Function} fn - */ - - Directive.prototype._withLock = function (fn) { - var self = this; - self._locked = true; - fn.call(self); - nextTick(function () { - self._locked = false; - }); - }; - - /** - * Convenience method that attaches a DOM event listener - * to the directive element and autometically tears it down - * during unbind. - * - * @param {String} event - * @param {Function} handler - * @param {Boolean} [useCapture] - */ + } - Directive.prototype.on = function (event, handler, useCapture) { - on(this.el, event, handler, useCapture);(this._listeners || (this._listeners = [])).push([event, handler]); - }; + if (expression === undefined) { + expression = exp.slice(0, i).trim(); + } else if (lastFilterIndex !== 0) { + pushFilter(); + } - /** - * Teardown the watcher and call unbind. - */ + function pushFilter () { + (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim()); + lastFilterIndex = i + 1; + } - Directive.prototype._teardown = function () { - if (this._bound) { - this._bound = false; - if (this.unbind) { - this.unbind(); - } - if (this._watcher) { - this._watcher.teardown(); - } - var listeners = this._listeners; - var i; - if (listeners) { - i = listeners.length; - while (i--) { - off(this.el, listeners[i][0], listeners[i][1]); - } - } - var unwatchFns = this._paramUnwatchFns; - if (unwatchFns) { - i = unwatchFns.length; - while (i--) { - unwatchFns[i](); - } - } - if ('development' !== 'production' && this.el) { - this.el._vue_directives.$remove(this); - } - this.vm = this.el = this._watcher = this._listeners = null; + if (filters) { + for (i = 0; i < filters.length; i++) { + expression = wrapFilter(expression, filters[i]); } - }; + } - function lifecycleMixin (Vue) { - /** - * Update v-ref for component. - * - * @param {Boolean} remove - */ - - Vue.prototype._updateRef = function (remove) { - var ref = this.$options._ref; - if (ref) { - var refs = (this._scope || this._context).$refs; - if (remove) { - if (refs[ref] === this) { - refs[ref] = null; - } - } else { - refs[ref] = this; - } - } - }; + return expression +} - /** - * Transclude, compile and link element. - * - * If a pre-compiled linker is available, that means the - * passed in element will be pre-transcluded and compiled - * as well - all we need to do is to call the linker. - * - * Otherwise we need to call transclude/compile/link here. - * - * @param {Element} el - */ - - Vue.prototype._compile = function (el) { - var options = this.$options; - - // transclude and init element - // transclude can potentially replace original - // so we need to keep reference; this step also injects - // the template and caches the original attributes - // on the container node and replacer node. - var original = el; - el = transclude(el, options); - this._initElement(el); - - // handle v-pre on root node (#2026) - if (el.nodeType === 1 && getAttr(el, 'v-pre') !== null) { - return; - } - - // root is always compiled per-instance, because - // container attrs and props can be different every time. - var contextOptions = this._context && this._context.$options; - var rootLinker = compileRoot(el, options, contextOptions); - - // resolve slot distribution - resolveSlots(this, options._content); - - // compile and link the rest - var contentLinkFn; - var ctor = this.constructor; - // component compilation can be cached - // as long as it's not using inline-template - if (options._linkerCachable) { - contentLinkFn = ctor.linker; - if (!contentLinkFn) { - contentLinkFn = ctor.linker = compile(el, options); - } +function wrapFilter (exp, filter) { + var i = filter.indexOf('('); + if (i < 0) { + // _f: resolveFilter + return ("_f(\"" + filter + "\")(" + exp + ")") + } else { + var name = filter.slice(0, i); + var args = filter.slice(i + 1); + return ("_f(\"" + name + "\")(" + exp + "," + args) + } +} + +/* */ + +var defaultTagRE = /\{\{((?:.|\n)+?)\}\}/g; +var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g; + +var buildRegex = cached(function (delimiters) { + var open = delimiters[0].replace(regexEscapeRE, '\\$&'); + var close = delimiters[1].replace(regexEscapeRE, '\\$&'); + return new RegExp(open + '((?:.|\\n)+?)' + close, 'g') +}); + +function parseText ( + text, + delimiters +) { + var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE; + if (!tagRE.test(text)) { + return + } + var tokens = []; + var lastIndex = tagRE.lastIndex = 0; + var match, index; + while ((match = tagRE.exec(text))) { + index = match.index; + // push text token + if (index > lastIndex) { + tokens.push(JSON.stringify(text.slice(lastIndex, index))); + } + // tag token + var exp = parseFilters(match[1].trim()); + tokens.push(("_s(" + exp + ")")); + lastIndex = index + match[0].length; + } + if (lastIndex < text.length) { + tokens.push(JSON.stringify(text.slice(lastIndex))); + } + return tokens.join('+') +} + +/* */ + +function baseWarn (msg) { + console.error(("[Vue parser]: " + msg)); +} + +function pluckModuleFunction ( + modules, + key +) { + return modules + ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) + : [] +} + +function addProp (el, name, value) { + (el.props || (el.props = [])).push({ name: name, value: value }); +} + +function addAttr (el, name, value) { + (el.attrs || (el.attrs = [])).push({ name: name, value: value }); +} + +function addDirective ( + el, + name, + rawName, + value, + arg, + modifiers +) { + (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers }); +} + +function addHandler ( + el, + name, + value, + modifiers, + important +) { + // check capture modifier + if (modifiers && modifiers.capture) { + delete modifiers.capture; + name = '!' + name; // mark the event as captured + } + var events; + if (modifiers && modifiers.native) { + delete modifiers.native; + events = el.nativeEvents || (el.nativeEvents = {}); + } else { + events = el.events || (el.events = {}); + } + var newHandler = { value: value, modifiers: modifiers }; + var handlers = events[name]; + /* istanbul ignore if */ + if (Array.isArray(handlers)) { + important ? handlers.unshift(newHandler) : handlers.push(newHandler); + } else if (handlers) { + events[name] = important ? [newHandler, handlers] : [handlers, newHandler]; + } else { + events[name] = newHandler; + } +} + +function getBindingAttr ( + el, + name, + getStatic +) { + var dynamicValue = + getAndRemoveAttr(el, ':' + name) || + getAndRemoveAttr(el, 'v-bind:' + name); + if (dynamicValue != null) { + return dynamicValue + } else if (getStatic !== false) { + var staticValue = getAndRemoveAttr(el, name); + if (staticValue != null) { + return JSON.stringify(staticValue) + } + } +} + +function getAndRemoveAttr (el, name) { + var val; + if ((val = el.attrsMap[name]) != null) { + var list = el.attrsList; + for (var i = 0, l = list.length; i < l; i++) { + if (list[i].name === name) { + list.splice(i, 1); + break + } + } + } + return val +} + +/* */ + +var dirRE = /^v-|^@|^:/; +var forAliasRE = /(.*?)\s+(?:in|of)\s+(.*)/; +var forIteratorRE = /\(([^,]*),([^,]*)(?:,([^,]*))?\)/; +var bindRE = /^:|^v-bind:/; +var onRE = /^@|^v-on:/; +var argRE = /:(.*)$/; +var modifierRE = /\.[^\.]+/g; +var specialNewlineRE = /\u2028|\u2029/g; + +var decodeHTMLCached = cached(decode); + +// configurable state +var warn$1; +var platformGetTagNamespace; +var platformMustUseProp; +var platformIsPreTag; +var preTransforms; +var transforms; +var postTransforms; +var delimiters; + +/** + * Convert HTML string to AST. + */ +function parse ( + template, + options +) { + warn$1 = options.warn || baseWarn; + platformGetTagNamespace = options.getTagNamespace || no; + platformMustUseProp = options.mustUseProp || no; + platformIsPreTag = options.isPreTag || no; + preTransforms = pluckModuleFunction(options.modules, 'preTransformNode'); + transforms = pluckModuleFunction(options.modules, 'transformNode'); + postTransforms = pluckModuleFunction(options.modules, 'postTransformNode'); + delimiters = options.delimiters; + var stack = []; + var preserveWhitespace = options.preserveWhitespace !== false; + var root; + var currentParent; + var inVPre = false; + var inPre = false; + var warned = false; + parseHTML(template, { + expectHTML: options.expectHTML, + isUnaryTag: options.isUnaryTag, + shouldDecodeNewlines: options.shouldDecodeNewlines, + start: function start (tag, attrs, unary) { + // check namespace. + // inherit parent ns if there is one + var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag); + + // handle IE svg bug + /* istanbul ignore if */ + if (options.isIE && ns === 'svg') { + attrs = guardIESVGBug(attrs); } - // link phase - // make sure to link root with prop scope! - var rootUnlinkFn = rootLinker(this, el, this._scope); - var contentUnlinkFn = contentLinkFn ? contentLinkFn(this, el) : compile(el, options)(this, el); - - // register composite unlink function - // to be called during instance destruction - this._unlinkFn = function () { - rootUnlinkFn(); - // passing destroying: true to avoid searching and - // splicing the directives - contentUnlinkFn(true); + var element = { + type: 1, + tag: tag, + attrsList: attrs, + attrsMap: makeAttrsMap(attrs, options.isIE), + parent: currentParent, + children: [] }; - - // finally replace original - if (options.replace) { - replace(original, el); + if (ns) { + element.ns = ns; } - this._isCompiled = true; - this._callHook('compiled'); - }; - - /** - * Initialize instance element. Called in the public - * $mount() method. - * - * @param {Element} el - */ - - Vue.prototype._initElement = function (el) { - if (isFragment(el)) { - this._isFragment = true; - this.$el = this._fragmentStart = el.firstChild; - this._fragmentEnd = el.lastChild; - // set persisted text anchors to empty - if (this._fragmentStart.nodeType === 3) { - this._fragmentStart.data = this._fragmentEnd.data = ''; - } - this._fragment = el; - } else { - this.$el = el; + if ("client" !== 'server' && isForbiddenTag(element)) { + element.forbidden = true; + "development" !== 'production' && warn$1( + 'Templates should only be responsible for mapping the state to the ' + + 'UI. Avoid placing tags with side-effects in your templates, such as ' + + "<" + tag + ">." + ); } - this.$el.__vue__ = this; - this._callHook('beforeCompile'); - }; - /** - * Create and bind a directive to an element. - * - * @param {Object} descriptor - parsed directive descriptor - * @param {Node} node - target node - * @param {Vue} [host] - transclusion host component - * @param {Object} [scope] - v-for scope - * @param {Fragment} [frag] - owner fragment - */ - - Vue.prototype._bindDir = function (descriptor, node, host, scope, frag) { - this._directives.push(new Directive(descriptor, this, node, host, scope, frag)); - }; - - /** - * Teardown an instance, unobserves the data, unbind all the - * directives, turn off all the event listeners, etc. - * - * @param {Boolean} remove - whether to remove the DOM node. - * @param {Boolean} deferCleanup - if true, defer cleanup to - * be called later - */ - - Vue.prototype._destroy = function (remove, deferCleanup) { - if (this._isBeingDestroyed) { - if (!deferCleanup) { - this._cleanup(); - } - return; + // apply pre-transforms + for (var i = 0; i < preTransforms.length; i++) { + preTransforms[i](element, options); } - var destroyReady; - var pendingRemoval; - - var self = this; - // Cleanup should be called either synchronously or asynchronoysly as - // callback of this.$remove(), or if remove and deferCleanup are false. - // In any case it should be called after all other removing, unbinding and - // turning of is done - var cleanupIfPossible = function cleanupIfPossible() { - if (destroyReady && !pendingRemoval && !deferCleanup) { - self._cleanup(); + if (!inVPre) { + processPre(element); + if (element.pre) { + inVPre = true; } - }; - - // remove DOM element - if (remove && this.$el) { - pendingRemoval = true; - this.$remove(function () { - pendingRemoval = false; - cleanupIfPossible(); - }); - } - - this._callHook('beforeDestroy'); - this._isBeingDestroyed = true; - var i; - // remove self from parent. only necessary - // if parent is not being destroyed as well. - var parent = this.$parent; - if (parent && !parent._isBeingDestroyed) { - parent.$children.$remove(this); - // unregister ref (remove: true) - this._updateRef(true); - } - // destroy all children. - i = this.$children.length; - while (i--) { - this.$children[i].$destroy(); } - // teardown props - if (this._propsUnlinkFn) { - this._propsUnlinkFn(); + if (platformIsPreTag(element.tag)) { + inPre = true; } - // teardown all directives. this also tearsdown all - // directive-owned watchers. - if (this._unlinkFn) { - this._unlinkFn(); - } - i = this._watchers.length; - while (i--) { - this._watchers[i].teardown(); - } - // remove reference to self on $el - if (this.$el) { - this.$el.__vue__ = null; - } - - destroyReady = true; - cleanupIfPossible(); - }; - - /** - * Clean up to ensure garbage collection. - * This is called after the leave transition if there - * is any. - */ - - Vue.prototype._cleanup = function () { - if (this._isDestroyed) { - return; - } - // remove self from owner fragment - // do it in cleanup so that we can call $destroy with - // defer right when a fragment is about to be removed. - if (this._frag) { - this._frag.children.$remove(this); - } - // remove reference from data ob - // frozen object may not have observer. - if (this._data && this._data.__ob__) { - this._data.__ob__.removeVm(this); - } - // Clean up references to private properties and other - // instances. preserve reference to _data so that proxy - // accessors still work. The only potential side effect - // here is that mutating the instance after it's destroyed - // may affect the state of other components that are still - // observing the same object, but that seems to be a - // reasonable responsibility for the user rather than - // always throwing an error on them. - this.$el = this.$parent = this.$root = this.$children = this._watchers = this._context = this._scope = this._directives = null; - // call the last hook... - this._isDestroyed = true; - this._callHook('destroyed'); - // turn off all instance listeners. - this.$off(); - }; - } - - function miscMixin (Vue) { - /** - * Apply a list of filter (descriptors) to a value. - * Using plain for loops here because this will be called in - * the getter of any watcher with filters so it is very - * performance sensitive. - * - * @param {*} value - * @param {*} [oldValue] - * @param {Array} filters - * @param {Boolean} write - * @return {*} - */ - - Vue.prototype._applyFilters = function (value, oldValue, filters, write) { - var filter, fn, args, arg, offset, i, l, j, k; - for (i = 0, l = filters.length; i < l; i++) { - filter = filters[write ? l - i - 1 : i]; - fn = resolveAsset(this.$options, 'filters', filter.name, true); - if (!fn) continue; - fn = write ? fn.write : fn.read || fn; - if (typeof fn !== 'function') continue; - args = write ? [value, oldValue] : [value]; - offset = write ? 2 : 1; - if (filter.args) { - for (j = 0, k = filter.args.length; j < k; j++) { - arg = filter.args[j]; - args[j + offset] = arg.dynamic ? this.$get(arg.value) : arg.value; + if (inVPre) { + processRawAttrs(element); + } else { + processFor(element); + processIf(element); + processOnce(element); + processKey(element); + + // determine whether this is a plain element after + // removing structural attributes + element.plain = !element.key && !attrs.length; + + processRef(element); + processSlot(element); + processComponent(element); + for (var i$1 = 0; i$1 < transforms.length; i$1++) { + transforms[i$1](element, options); + } + processAttrs(element); + } + + function checkRootConstraints (el) { + { + if (el.tag === 'slot' || el.tag === 'template') { + warn$1( + "Cannot use <" + (el.tag) + "> as component root element because it may " + + 'contain multiple nodes:\n' + template + ); + } + if (el.attrsMap.hasOwnProperty('v-for')) { + warn$1( + 'Cannot use v-for on stateful component root element because ' + + 'it renders multiple elements:\n' + template + ); } } - value = fn.apply(this, args); } - return value; - }; - /** - * Resolve a component, depending on whether the component - * is defined normally or using an async factory function. - * Resolves synchronously if already resolved, otherwise - * resolves asynchronously and caches the resolved - * constructor on the factory. - * - * @param {String|Function} value - * @param {Function} cb - */ - - Vue.prototype._resolveComponent = function (value, cb) { - var factory; - if (typeof value === 'function') { - factory = value; - } else { - factory = resolveAsset(this.$options, 'components', value, true); - } - /* istanbul ignore if */ - if (!factory) { - return; - } - // async component factory - if (!factory.options) { - if (factory.resolved) { - // cached - cb(factory.resolved); - } else if (factory.requested) { - // pool callbacks - factory.pendingCallbacks.push(cb); + // tree management + if (!root) { + root = element; + checkRootConstraints(root); + } else if ("development" !== 'production' && !stack.length && !warned) { + // allow 2 root elements with v-if and v-else + if (root.if && element.else) { + checkRootConstraints(element); + root.elseBlock = element; } else { - factory.requested = true; - var cbs = factory.pendingCallbacks = [cb]; - factory.call(this, function resolve(res) { - if (isPlainObject(res)) { - res = Vue.extend(res); - } - // cache resolved - factory.resolved = res; - // invoke callbacks - for (var i = 0, l = cbs.length; i < l; i++) { - cbs[i](res); - } - }, function reject(reason) { - 'development' !== 'production' && warn('Failed to resolve async component' + (typeof value === 'string' ? ': ' + value : '') + '. ' + (reason ? '\nReason: ' + reason : '')); - }); + warned = true; + warn$1( + ("Component template should contain exactly one root element:\n\n" + template) + ); } - } else { - // normal component - cb(factory); } - }; - } - - var filterRE$1 = /[^|]\|[^|]/; - - function dataAPI (Vue) { - /** - * Get the value from an expression on this vm. - * - * @param {String} exp - * @param {Boolean} [asStatement] - * @return {*} - */ - - Vue.prototype.$get = function (exp, asStatement) { - var res = parseExpression(exp); - if (res) { - if (asStatement) { - var self = this; - return function statementHandler() { - self.$arguments = toArray(arguments); - var result = res.get.call(self, self); - self.$arguments = null; - return result; - }; + if (currentParent && !element.forbidden) { + if (element.else) { + processElse(element, currentParent); } else { - try { - return res.get.call(this, this); - } catch (e) {} + currentParent.children.push(element); + element.parent = currentParent; } } - }; - - /** - * Set the value from an expression on this vm. - * The expression must be a valid left-hand - * expression in an assignment. - * - * @param {String} exp - * @param {*} val - */ - - Vue.prototype.$set = function (exp, val) { - var res = parseExpression(exp, true); - if (res && res.set) { - res.set.call(this, this, val); + if (!unary) { + currentParent = element; + stack.push(element); } - }; - - /** - * Delete a property on the VM - * - * @param {String} key - */ - - Vue.prototype.$delete = function (key) { - del(this._data, key); - }; - - /** - * Watch an expression, trigger callback when its - * value changes. - * - * @param {String|Function} expOrFn - * @param {Function} cb - * @param {Object} [options] - * - {Boolean} deep - * - {Boolean} immediate - * @return {Function} - unwatchFn - */ - - Vue.prototype.$watch = function (expOrFn, cb, options) { - var vm = this; - var parsed; - if (typeof expOrFn === 'string') { - parsed = parseDirective(expOrFn); - expOrFn = parsed.expression; - } - var watcher = new Watcher(vm, expOrFn, cb, { - deep: options && options.deep, - sync: options && options.sync, - filters: parsed && parsed.filters, - user: !options || options.user !== false - }); - if (options && options.immediate) { - cb.call(vm, watcher.value); + // apply post-transforms + for (var i$2 = 0; i$2 < postTransforms.length; i$2++) { + postTransforms[i$2](element, options); } - return function unwatchFn() { - watcher.teardown(); - }; - }; + }, - /** - * Evaluate a text directive, including filters. - * - * @param {String} text - * @param {Boolean} [asStatement] - * @return {String} - */ - - Vue.prototype.$eval = function (text, asStatement) { - // check for filters. - if (filterRE$1.test(text)) { - var dir = parseDirective(text); - // the filter regex check might give false positive - // for pipes inside strings, so it's possible that - // we don't get any filters here - var val = this.$get(dir.expression, asStatement); - return dir.filters ? this._applyFilters(val, null, dir.filters) : val; - } else { - // no filter - return this.$get(text, asStatement); + end: function end () { + // remove trailing whitespace + var element = stack[stack.length - 1]; + var lastNode = element.children[element.children.length - 1]; + if (lastNode && lastNode.type === 3 && lastNode.text === ' ') { + element.children.pop(); } - }; - - /** - * Interpolate a piece of template text. - * - * @param {String} text - * @return {String} - */ - - Vue.prototype.$interpolate = function (text) { - var tokens = parseText(text); - var vm = this; - if (tokens) { - if (tokens.length === 1) { - return vm.$eval(tokens[0].value) + ''; - } else { - return tokens.map(function (token) { - return token.tag ? vm.$eval(token.value) : token.value; - }).join(''); - } - } else { - return text; + // pop stack + stack.length -= 1; + currentParent = stack[stack.length - 1]; + // check pre state + if (element.pre) { + inVPre = false; } - }; + if (platformIsPreTag(element.tag)) { + inPre = false; + } + }, - /** - * Log instance data as a plain JS object - * so that it is easier to inspect in console. - * This method assumes console is available. - * - * @param {String} [path] - */ - - Vue.prototype.$log = function (path) { - var data = path ? getPath(this._data, path) : this._data; - if (data) { - data = clean(data); - } - // include computed fields - if (!path) { - var key; - for (key in this.$options.computed) { - data[key] = clean(this[key]); - } - if (this._props) { - for (key in this._props) { - data[key] = clean(this[key]); - } + chars: function chars (text) { + if (!currentParent) { + if ("development" !== 'production' && !warned && text === template) { + warned = true; + warn$1( + 'Component template requires a root element, rather than just text:\n\n' + template + ); + } + return + } + text = inPre || text.trim() + ? decodeHTMLCached(text) + // only preserve whitespace if its not right after a starting tag + : preserveWhitespace && currentParent.children.length ? ' ' : ''; + if (text) { + var expression; + if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) { + currentParent.children.push({ + type: 2, + expression: expression, + text: text + }); + } else { + // #3895 special character + text = text.replace(specialNewlineRE, ''); + currentParent.children.push({ + type: 3, + text: text + }); } } - console.log(data); - }; - - /** - * "clean" a getter/setter converted object into a plain - * object copy. - * - * @param {Object} - obj - * @return {Object} - */ - - function clean(obj) { - return JSON.parse(JSON.stringify(obj)); } - } - - function domAPI (Vue) { - /** - * Convenience on-instance nextTick. The callback is - * auto-bound to the instance, and this avoids component - * modules having to rely on the global Vue. - * - * @param {Function} fn - */ - - Vue.prototype.$nextTick = function (fn) { - nextTick(fn, this); - }; - - /** - * Append instance to target - * - * @param {Node} target - * @param {Function} [cb] - * @param {Boolean} [withTransition] - defaults to true - */ - - Vue.prototype.$appendTo = function (target, cb, withTransition) { - return insert(this, target, cb, withTransition, append, appendWithTransition); - }; - - /** - * Prepend instance to target - * - * @param {Node} target - * @param {Function} [cb] - * @param {Boolean} [withTransition] - defaults to true - */ - - Vue.prototype.$prependTo = function (target, cb, withTransition) { - target = query(target); - if (target.hasChildNodes()) { - this.$before(target.firstChild, cb, withTransition); - } else { - this.$appendTo(target, cb, withTransition); - } - return this; - }; - - /** - * Insert instance before target - * - * @param {Node} target - * @param {Function} [cb] - * @param {Boolean} [withTransition] - defaults to true - */ - - Vue.prototype.$before = function (target, cb, withTransition) { - return insert(this, target, cb, withTransition, beforeWithCb, beforeWithTransition); - }; - - /** - * Insert instance after target - * - * @param {Node} target - * @param {Function} [cb] - * @param {Boolean} [withTransition] - defaults to true - */ - - Vue.prototype.$after = function (target, cb, withTransition) { - target = query(target); - if (target.nextSibling) { - this.$before(target.nextSibling, cb, withTransition); - } else { - this.$appendTo(target.parentNode, cb, withTransition); - } - return this; - }; - - /** - * Remove instance from DOM - * - * @param {Function} [cb] - * @param {Boolean} [withTransition] - defaults to true - */ - - Vue.prototype.$remove = function (cb, withTransition) { - if (!this.$el.parentNode) { - return cb && cb(); - } - var inDocument = this._isAttached && inDoc(this.$el); - // if we are not in document, no need to check - // for transitions - if (!inDocument) withTransition = false; - var self = this; - var realCb = function realCb() { - if (inDocument) self._callHook('detached'); - if (cb) cb(); + }); + return root +} + +function processPre (el) { + if (getAndRemoveAttr(el, 'v-pre') != null) { + el.pre = true; + } +} + +function processRawAttrs (el) { + var l = el.attrsList.length; + if (l) { + var attrs = el.attrs = new Array(l); + for (var i = 0; i < l; i++) { + attrs[i] = { + name: el.attrsList[i].name, + value: JSON.stringify(el.attrsList[i].value) }; - if (this._isFragment) { - removeNodeRange(this._fragmentStart, this._fragmentEnd, this, this._fragment, realCb); - } else { - var op = withTransition === false ? removeWithCb : removeWithTransition; - op(this.$el, this, realCb); - } - return this; - }; - - /** - * Shared DOM insertion function. - * - * @param {Vue} vm - * @param {Element} target - * @param {Function} [cb] - * @param {Boolean} [withTransition] - * @param {Function} op1 - op for non-transition insert - * @param {Function} op2 - op for transition insert - * @return vm - */ - - function insert(vm, target, cb, withTransition, op1, op2) { - target = query(target); - var targetIsDetached = !inDoc(target); - var op = withTransition === false || targetIsDetached ? op1 : op2; - var shouldCallHook = !targetIsDetached && !vm._isAttached && !inDoc(vm.$el); - if (vm._isFragment) { - mapNodeRange(vm._fragmentStart, vm._fragmentEnd, function (node) { - op(node, target, vm); - }); - cb && cb(); - } else { - op(vm.$el, target, vm, cb); - } - if (shouldCallHook) { - vm._callHook('attached'); - } - return vm; - } - - /** - * Check for selectors - * - * @param {String|Element} el - */ - - function query(el) { - return typeof el === 'string' ? document.querySelector(el) : el; } - - /** - * Append operation that takes a callback. - * - * @param {Node} el - * @param {Node} target - * @param {Vue} vm - unused - * @param {Function} [cb] - */ - - function append(el, target, vm, cb) { - target.appendChild(el); - if (cb) cb(); + } else if (!el.pre) { + // non root node in pre blocks with no attributes + el.plain = true; + } +} + +function processKey (el) { + var exp = getBindingAttr(el, 'key'); + if (exp) { + if ("development" !== 'production' && el.tag === 'template') { + warn$1("<template> cannot be keyed. Place the key on real elements instead."); + } + el.key = exp; + } +} + +function processRef (el) { + var ref = getBindingAttr(el, 'ref'); + if (ref) { + el.ref = ref; + el.refInFor = checkInFor(el); + } +} + +function processFor (el) { + var exp; + if ((exp = getAndRemoveAttr(el, 'v-for'))) { + var inMatch = exp.match(forAliasRE); + if (!inMatch) { + "development" !== 'production' && warn$1( + ("Invalid v-for expression: " + exp) + ); + return + } + el.for = inMatch[2].trim(); + var alias = inMatch[1].trim(); + var iteratorMatch = alias.match(forIteratorRE); + if (iteratorMatch) { + el.alias = iteratorMatch[1].trim(); + el.iterator1 = iteratorMatch[2].trim(); + if (iteratorMatch[3]) { + el.iterator2 = iteratorMatch[3].trim(); + } + } else { + el.alias = alias; } + } +} - /** - * InsertBefore operation that takes a callback. - * - * @param {Node} el - * @param {Node} target - * @param {Vue} vm - unused - * @param {Function} [cb] - */ +function processIf (el) { + var exp = getAndRemoveAttr(el, 'v-if'); + if (exp) { + el.if = exp; + } + if (getAndRemoveAttr(el, 'v-else') != null) { + el.else = true; + } +} - function beforeWithCb(el, target, vm, cb) { - before(el, target); - if (cb) cb(); - } +function processElse (el, parent) { + var prev = findPrevElement(parent.children); + if (prev && prev.if) { + prev.elseBlock = el; + } else { + warn$1( + ("v-else used on element <" + (el.tag) + "> without corresponding v-if.") + ); + } +} - /** - * Remove operation that takes a callback. - * - * @param {Node} el - * @param {Vue} vm - unused - * @param {Function} [cb] - */ +function processOnce (el) { + var once = getAndRemoveAttr(el, 'v-once'); + if (once != null) { + el.once = true; + } +} - function removeWithCb(el, vm, cb) { - remove(el); - if (cb) cb(); +function processSlot (el) { + if (el.tag === 'slot') { + el.slotName = getBindingAttr(el, 'name'); + } else { + var slotTarget = getBindingAttr(el, 'slot'); + if (slotTarget) { + el.slotTarget = slotTarget; } } +} - function eventsAPI (Vue) { - /** - * Listen on the given `event` with `fn`. - * - * @param {String} event - * @param {Function} fn - */ - - Vue.prototype.$on = function (event, fn) { - (this._events[event] || (this._events[event] = [])).push(fn); - modifyListenerCount(this, event, 1); - return this; - }; - - /** - * Adds an `event` listener that will be invoked a single - * time then automatically removed. - * - * @param {String} event - * @param {Function} fn - */ - - Vue.prototype.$once = function (event, fn) { - var self = this; - function on() { - self.$off(event, on); - fn.apply(this, arguments); - } - on.fn = fn; - this.$on(event, on); - return this; - }; +function processComponent (el) { + var binding; + if ((binding = getBindingAttr(el, 'is'))) { + el.component = binding; + } + if (getAndRemoveAttr(el, 'inline-template') != null) { + el.inlineTemplate = true; + } +} - /** - * Remove the given callback for `event` or all - * registered callbacks. - * - * @param {String} event - * @param {Function} fn - */ - - Vue.prototype.$off = function (event, fn) { - var cbs; - // all - if (!arguments.length) { - if (this.$parent) { - for (event in this._events) { - cbs = this._events[event]; - if (cbs) { - modifyListenerCount(this, event, -cbs.length); - } - } - } - this._events = {}; - return this; - } - // specific event - cbs = this._events[event]; - if (!cbs) { - return this; - } - if (arguments.length === 1) { - modifyListenerCount(this, event, -cbs.length); - this._events[event] = null; - return this; - } - // specific handler - var cb; - var i = cbs.length; - while (i--) { - cb = cbs[i]; - if (cb === fn || cb.fn === fn) { - modifyListenerCount(this, event, -1); - cbs.splice(i, 1); - break; +function processAttrs (el) { + var list = el.attrsList; + var i, l, name, rawName, value, arg, modifiers, isProp; + for (i = 0, l = list.length; i < l; i++) { + name = rawName = list[i].name; + value = list[i].value; + if (dirRE.test(name)) { + // mark element as dynamic + el.hasBindings = true; + // modifiers + modifiers = parseModifiers(name); + if (modifiers) { + name = name.replace(modifierRE, ''); + } + if (bindRE.test(name)) { // v-bind + name = name.replace(bindRE, ''); + if (modifiers && modifiers.prop) { + isProp = true; + name = camelize(name); + if (name === 'innerHtml') { name = 'innerHTML'; } + } + if (isProp || platformMustUseProp(name)) { + addProp(el, name, value); + } else { + addAttr(el, name, value); } - } - return this; - }; - - /** - * Trigger an event on self. - * - * @param {String|Object} event - * @return {Boolean} shouldPropagate - */ - - Vue.prototype.$emit = function (event) { - var isSource = typeof event === 'string'; - event = isSource ? event : event.name; - var cbs = this._events[event]; - var shouldPropagate = isSource || !cbs; - if (cbs) { - cbs = cbs.length > 1 ? toArray(cbs) : cbs; - // this is a somewhat hacky solution to the question raised - // in #2102: for an inline component listener like <comp @test="doThis">, - // the propagation handling is somewhat broken. Therefore we - // need to treat these inline callbacks differently. - var hasParentCbs = isSource && cbs.some(function (cb) { - return cb._fromParent; - }); - if (hasParentCbs) { - shouldPropagate = false; + } else if (onRE.test(name)) { // v-on + name = name.replace(onRE, ''); + addHandler(el, name, value, modifiers); + } else { // normal directives + name = name.replace(dirRE, ''); + // parse arg + var argMatch = name.match(argRE); + if (argMatch && (arg = argMatch[1])) { + name = name.slice(0, -(arg.length + 1)); } - var args = toArray(arguments, 1); - for (var i = 0, l = cbs.length; i < l; i++) { - var cb = cbs[i]; - var res = cb.apply(this, args); - if (res === true && (!hasParentCbs || cb._fromParent)) { - shouldPropagate = true; - } + addDirective(el, name, rawName, value, arg, modifiers); + if ("development" !== 'production' && name === 'model') { + checkForAliasModel(el, value); } } - return shouldPropagate; - }; - - /** - * Recursively broadcast an event to all children instances. - * - * @param {String|Object} event - * @param {...*} additional arguments - */ - - Vue.prototype.$broadcast = function (event) { - var isSource = typeof event === 'string'; - event = isSource ? event : event.name; - // if no child has registered for this event, - // then there's no need to broadcast. - if (!this._eventsCount[event]) return; - var children = this.$children; - var args = toArray(arguments); - if (isSource) { - // use object event to indicate non-source emit - // on children - args[0] = { name: event, source: this }; - } - for (var i = 0, l = children.length; i < l; i++) { - var child = children[i]; - var shouldPropagate = child.$emit.apply(child, args); - if (shouldPropagate) { - child.$broadcast.apply(child, args); + } else { + // literal attribute + { + var expression = parseText(value, delimiters); + if (expression) { + warn$1( + name + "=\"" + value + "\": " + + 'Interpolation inside attributes has been deprecated. ' + + 'Use v-bind or the colon shorthand instead.' + ); } } - return this; - }; - - /** - * Recursively propagate an event up the parent chain. - * - * @param {String} event - * @param {...*} additional arguments - */ - - Vue.prototype.$dispatch = function (event) { - var shouldPropagate = this.$emit.apply(this, arguments); - if (!shouldPropagate) return; - var parent = this.$parent; - var args = toArray(arguments); - // use object event to indicate non-source emit - // on parents - args[0] = { name: event, source: this }; - while (parent) { - shouldPropagate = parent.$emit.apply(parent, args); - parent = shouldPropagate ? parent.$parent : null; - } - return this; - }; - - /** - * Modify the listener counts on all parents. - * This bookkeeping allows $broadcast to return early when - * no child has listened to a certain event. - * - * @param {Vue} vm - * @param {String} event - * @param {Number} count - */ - - var hookRE = /^hook:/; - function modifyListenerCount(vm, event, count) { - var parent = vm.$parent; - // hooks do not get broadcasted so no need - // to do bookkeeping for them - if (!parent || !count || hookRE.test(event)) return; - while (parent) { - parent._eventsCount[event] = (parent._eventsCount[event] || 0) + count; - parent = parent.$parent; - } - } - } - - function lifecycleAPI (Vue) { - /** - * Set instance target element and kick off the compilation - * process. The passed in `el` can be a selector string, an - * existing Element, or a DocumentFragment (for block - * instances). - * - * @param {Element|DocumentFragment|string} el - * @public - */ - - Vue.prototype.$mount = function (el) { - if (this._isCompiled) { - 'development' !== 'production' && warn('$mount() should be called only once.', this); - return; - } - el = query(el); - if (!el) { - el = document.createElement('div'); - } - this._compile(el); - this._initDOMHooks(); - if (inDoc(this.$el)) { - this._callHook('attached'); - ready.call(this); - } else { - this.$once('hook:attached', ready); - } - return this; - }; - - /** - * Mark an instance as ready. - */ - - function ready() { - this._isAttached = true; - this._isReady = true; - this._callHook('ready'); + addAttr(el, name, JSON.stringify(value)); } - - /** - * Teardown the instance, simply delegate to the internal - * _destroy. - * - * @param {Boolean} remove - * @param {Boolean} deferCleanup - */ - - Vue.prototype.$destroy = function (remove, deferCleanup) { - this._destroy(remove, deferCleanup); - }; - - /** - * Partially compile a piece of DOM and return a - * decompile function. - * - * @param {Element|DocumentFragment} el - * @param {Vue} [host] - * @param {Object} [scope] - * @param {Fragment} [frag] - * @return {Function} - */ - - Vue.prototype.$compile = function (el, host, scope, frag) { - return compile(el, this.$options, true)(this, el, host, scope, frag); - }; } +} - /** - * The exposed Vue constructor. - * - * API conventions: - * - public API methods/properties are prefixed with `$` - * - internal methods/properties are prefixed with `_` - * - non-prefixed properties are assumed to be proxied user - * data. - * - * @constructor - * @param {Object} [options] - * @public - */ - - function Vue(options) { - this._init(options); +function checkInFor (el) { + var parent = el; + while (parent) { + if (parent.for !== undefined) { + return true + } + parent = parent.parent; } + return false +} - // install internals - initMixin(Vue); - stateMixin(Vue); - eventsMixin(Vue); - lifecycleMixin(Vue); - miscMixin(Vue); - - // install instance APIs - dataAPI(Vue); - domAPI(Vue); - eventsAPI(Vue); - lifecycleAPI(Vue); - - var slot = { - - priority: SLOT, - params: ['name'], - - bind: function bind() { - // this was resolved during component transclusion - var name = this.params.name || 'default'; - var content = this.vm._slotContents && this.vm._slotContents[name]; - if (!content || !content.hasChildNodes()) { - this.fallback(); - } else { - this.compile(content.cloneNode(true), this.vm._context, this.vm); - } - }, - - compile: function compile(content, context, host) { - if (content && context) { - if (this.el.hasChildNodes() && content.childNodes.length === 1 && content.childNodes[0].nodeType === 1 && content.childNodes[0].hasAttribute('v-if')) { - // if the inserted slot has v-if - // inject fallback content as the v-else - var elseBlock = document.createElement('template'); - elseBlock.setAttribute('v-else', ''); - elseBlock.innerHTML = this.el.innerHTML; - // the else block should be compiled in child scope - elseBlock._context = this.vm; - content.appendChild(elseBlock); - } - var scope = host ? host._scope : this._scope; - this.unlink = context.$compile(content, host, scope, this._frag); - } - if (content) { - replace(this.el, content); +function parseModifiers (name) { + var match = name.match(modifierRE); + if (match) { + var ret = {}; + match.forEach(function (m) { ret[m.slice(1)] = true; }); + return ret + } +} + +function makeAttrsMap (attrs, isIE) { + var map = {}; + for (var i = 0, l = attrs.length; i < l; i++) { + if ("development" !== 'production' && map[attrs[i].name] && !isIE) { + warn$1('duplicate attribute: ' + attrs[i].name); + } + map[attrs[i].name] = attrs[i].value; + } + return map +} + +function findPrevElement (children) { + var i = children.length; + while (i--) { + if (children[i].tag) { return children[i] } + } +} + +function isForbiddenTag (el) { + return ( + el.tag === 'style' || + (el.tag === 'script' && ( + !el.attrsMap.type || + el.attrsMap.type === 'text/javascript' + )) + ) +} + +var ieNSBug = /^xmlns:NS\d+/; +var ieNSPrefix = /^NS\d+:/; + +/* istanbul ignore next */ +function guardIESVGBug (attrs) { + var res = []; + for (var i = 0; i < attrs.length; i++) { + var attr = attrs[i]; + if (!ieNSBug.test(attr.name)) { + attr.name = attr.name.replace(ieNSPrefix, ''); + res.push(attr); + } + } + return res +} + +function checkForAliasModel (el, value) { + var _el = el; + while (_el) { + if (_el.for && _el.alias === value) { + warn$1( + "<" + (el.tag) + " v-model=\"" + value + "\">: " + + "You are binding v-model directly to a v-for iteration alias. " + + "This will not be able to modify the v-for source array because " + + "writing to the alias is like modifying a function local variable. " + + "Consider using an array of objects and use v-model on an object property instead." + ); + } + _el = _el.parent; + } +} + +/* */ + +var isStaticKey; +var isPlatformReservedTag; + +var genStaticKeysCached = cached(genStaticKeys$1); + +/** + * Goal of the optimizier: walk the generated template AST tree + * and detect sub-trees that are purely static, i.e. parts of + * the DOM that never needs to change. + * + * Once we detect these sub-trees, we can: + * + * 1. Hoist them into constants, so that we no longer need to + * create fresh nodes for them on each re-render; + * 2. Completely skip them in the patching process. + */ +function optimize (root, options) { + if (!root) { return } + isStaticKey = genStaticKeysCached(options.staticKeys || ''); + isPlatformReservedTag = options.isReservedTag || (function () { return false; }); + // first pass: mark all non-static nodes. + markStatic(root); + // second pass: mark static roots. + markStaticRoots(root, false); +} + +function genStaticKeys$1 (keys) { + return makeMap( + 'type,tag,attrsList,attrsMap,plain,parent,children,attrs' + + (keys ? ',' + keys : '') + ) +} + +function markStatic (node) { + node.static = isStatic(node); + if (node.type === 1) { + for (var i = 0, l = node.children.length; i < l; i++) { + var child = node.children[i]; + markStatic(child); + if (!child.static) { + node.static = false; + } + } + } +} + +function markStaticRoots (node, isInFor) { + if (node.type === 1) { + if (node.once || node.static) { + node.staticRoot = true; + node.staticInFor = isInFor; + return + } + if (node.children) { + for (var i = 0, l = node.children.length; i < l; i++) { + markStaticRoots(node.children[i], isInFor || !!node.for); + } + } + } +} + +function isStatic (node) { + if (node.type === 2) { // expression + return false + } + if (node.type === 3) { // text + return true + } + return !!(node.pre || ( + !node.hasBindings && // no dynamic bindings + !node.if && !node.for && // not v-if or v-for or v-else + !isBuiltInTag(node.tag) && // not a built-in + isPlatformReservedTag(node.tag) && // not a component + !isDirectChildOfTemplateFor(node) && + Object.keys(node).every(isStaticKey) + )) +} + +function isDirectChildOfTemplateFor (node) { + while (node.parent) { + node = node.parent; + if (node.tag !== 'template') { + return false + } + if (node.for) { + return true + } + } + return false +} + +/* */ + +var simplePathRE = /^\s*[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*\s*$/; + +// keyCode aliases +var keyCodes = { + esc: 27, + tab: 9, + enter: 13, + space: 32, + up: 38, + left: 37, + right: 39, + down: 40, + 'delete': [8, 46] +}; + +var modifierCode = { + stop: '$event.stopPropagation();', + prevent: '$event.preventDefault();', + self: 'if($event.target !== $event.currentTarget)return;' +}; + +function genHandlers (events, native) { + var res = native ? 'nativeOn:{' : 'on:{'; + for (var name in events) { + res += "\"" + name + "\":" + (genHandler(events[name])) + ","; + } + return res.slice(0, -1) + '}' +} + +function genHandler ( + handler +) { + if (!handler) { + return 'function(){}' + } else if (Array.isArray(handler)) { + return ("[" + (handler.map(genHandler).join(',')) + "]") + } else if (!handler.modifiers) { + return simplePathRE.test(handler.value) + ? handler.value + : ("function($event){" + (handler.value) + "}") + } else { + var code = ''; + var keys = []; + for (var key in handler.modifiers) { + if (modifierCode[key]) { + code += modifierCode[key]; } else { - remove(this.el); - } - }, - - fallback: function fallback() { - this.compile(extractContent(this.el, true), this.vm); - }, - - unbind: function unbind() { - if (this.unlink) { - this.unlink(); + keys.push(key); } } - }; - - var partial = { - - priority: PARTIAL, - - params: ['name'], - - // watch changes to name for dynamic partials - paramWatchers: { - name: function name(value) { - vIf.remove.call(this); - if (value) { - this.insert(value); - } - } - }, + if (keys.length) { + code = genKeyFilter(keys) + code; + } + var handlerCode = simplePathRE.test(handler.value) + ? handler.value + '($event)' + : handler.value; + return 'function($event){' + code + handlerCode + '}' + } +} - bind: function bind() { - this.anchor = createAnchor('v-partial'); - replace(this.el, this.anchor); - this.insert(this.params.name); - }, +function genKeyFilter (keys) { + var code = keys.length === 1 + ? normalizeKeyCode(keys[0]) + : Array.prototype.concat.apply([], keys.map(normalizeKeyCode)); + if (Array.isArray(code)) { + return ("if(" + (code.map(function (c) { return ("$event.keyCode!==" + c); }).join('&&')) + ")return;") + } else { + return ("if($event.keyCode!==" + code + ")return;") + } +} - insert: function insert(id) { - var partial = resolveAsset(this.vm.$options, 'partials', id, true); - if (partial) { - this.factory = new FragmentFactory(this.vm, partial); - vIf.insert.call(this); - } - }, +function normalizeKeyCode (key) { + return ( + parseInt(key, 10) || // number keyCode + keyCodes[key] || // built-in alias + ("_k(" + (JSON.stringify(key)) + ")") // custom alias + ) +} - unbind: function unbind() { - if (this.frag) { - this.frag.destroy(); - } - } - }; +/* */ - var elementDirectives = { - slot: slot, - partial: partial +function bind$2 (el, dir) { + el.wrapData = function (code) { + return ("_b(" + code + "," + (dir.value) + (dir.modifiers && dir.modifiers.prop ? ',true' : '') + ")") }; +} + +var baseDirectives = { + bind: bind$2, + cloak: noop +}; + +/* */ + +// configurable state +var warn$2; +var transforms$1; +var dataGenFns; +var platformDirectives$1; +var staticRenderFns; +var currentOptions; + +function generate ( + ast, + options +) { + // save previous staticRenderFns so generate calls can be nested + var prevStaticRenderFns = staticRenderFns; + var currentStaticRenderFns = staticRenderFns = []; + currentOptions = options; + warn$2 = options.warn || baseWarn; + transforms$1 = pluckModuleFunction(options.modules, 'transformCode'); + dataGenFns = pluckModuleFunction(options.modules, 'genData'); + platformDirectives$1 = options.directives || {}; + var code = ast ? genElement(ast) : '_h("div")'; + staticRenderFns = prevStaticRenderFns; + return { + render: ("with(this){return " + code + "}"), + staticRenderFns: currentStaticRenderFns + } +} + +function genElement (el) { + if (el.staticRoot && !el.staticProcessed) { + // hoist static sub-trees out + el.staticProcessed = true; + staticRenderFns.push(("with(this){return " + (genElement(el)) + "}")); + return ("_m(" + (staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")") + } else if (el.for && !el.forProcessed) { + return genFor(el) + } else if (el.if && !el.ifProcessed) { + return genIf(el) + } else if (el.tag === 'template' && !el.slotTarget) { + return genChildren(el) || 'void 0' + } else if (el.tag === 'slot') { + return genSlot(el) + } else { + // component or element + var code; + if (el.component) { + code = genComponent(el); + } else { + var data = genData(el); + var children = el.inlineTemplate ? null : genChildren(el); + code = "_h('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")"; + } + // module transforms + for (var i = 0; i < transforms$1.length; i++) { + code = transforms$1[i](el, code); + } + return code + } +} + +function genIf (el) { + var exp = el.if; + el.ifProcessed = true; // avoid recursion + return ("(" + exp + ")?" + (genElement(el)) + ":" + (genElse(el))) +} + +function genElse (el) { + return el.elseBlock + ? genElement(el.elseBlock) + : '_e()' +} + +function genFor (el) { + var exp = el.for; + var alias = el.alias; + var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : ''; + var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : ''; + el.forProcessed = true; // avoid recursion + return "_l((" + exp + ")," + + "function(" + alias + iterator1 + iterator2 + "){" + + "return " + (genElement(el)) + + '})' +} + +function genData (el) { + if (el.plain) { + return + } + + var data = '{'; + + // directives first. + // directives may mutate the el's other properties before they are generated. + var dirs = genDirectives(el); + if (dirs) { data += dirs + ','; } + + // key + if (el.key) { + data += "key:" + (el.key) + ","; + } + // ref + if (el.ref) { + data += "ref:" + (el.ref) + ","; + } + if (el.refInFor) { + data += "refInFor:true,"; + } + // record original tag name for components using "is" attribute + if (el.component) { + data += "tag:\"" + (el.tag) + "\","; + } + // slot target + if (el.slotTarget) { + data += "slot:" + (el.slotTarget) + ","; + } + // module data generation functions + for (var i = 0; i < dataGenFns.length; i++) { + data += dataGenFns[i](el); + } + // attributes + if (el.attrs) { + data += "attrs:{" + (genProps(el.attrs)) + "},"; + } + // DOM props + if (el.props) { + data += "domProps:{" + (genProps(el.props)) + "},"; + } + // event handlers + if (el.events) { + data += (genHandlers(el.events)) + ","; + } + if (el.nativeEvents) { + data += (genHandlers(el.nativeEvents, true)) + ","; + } + // inline-template + if (el.inlineTemplate) { + var ast = el.children[0]; + if ("development" !== 'production' && ( + el.children.length > 1 || ast.type !== 1 + )) { + warn$2('Inline-template components must have exactly one child element.'); + } + if (ast.type === 1) { + var inlineRenderFns = generate(ast, currentOptions); + data += "inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}"; + } + } + data = data.replace(/,$/, '') + '}'; + // v-bind data wrap + if (el.wrapData) { + data = el.wrapData(data); + } + return data +} + +function genDirectives (el) { + var dirs = el.directives; + if (!dirs) { return } + var res = 'directives:['; + var hasRuntime = false; + var i, l, dir, needRuntime; + for (i = 0, l = dirs.length; i < l; i++) { + dir = dirs[i]; + needRuntime = true; + var gen = platformDirectives$1[dir.name] || baseDirectives[dir.name]; + if (gen) { + // compile-time directive that manipulates AST. + // returns true if it also needs a runtime counterpart. + needRuntime = !!gen(el, dir, warn$2); + } + if (needRuntime) { + hasRuntime = true; + res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:\"" + (dir.arg) + "\"") : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},"; + } + } + if (hasRuntime) { + return res.slice(0, -1) + ']' + } +} - var convertArray = vFor._postProcess; - - /** - * Limit filter for arrays - * - * @param {Number} n - * @param {Number} offset (Decimal expected) - */ - - function limitBy(arr, n, offset) { - offset = offset ? parseInt(offset, 10) : 0; - n = toNumber(n); - return typeof n === 'number' ? arr.slice(offset, offset + n) : arr; +function genChildren (el) { + if (el.children.length) { + return '[' + el.children.map(genNode).join(',') + ']' } +} - /** - * Filter filter for arrays - * - * @param {String} search - * @param {String} [delimiter] - * @param {String} ...dataKeys - */ - - function filterBy(arr, search, delimiter) { - arr = convertArray(arr); - if (search == null) { - return arr; - } - if (typeof search === 'function') { - return arr.filter(search); - } - // cast to lowercase string - search = ('' + search).toLowerCase(); - // allow optional `in` delimiter - // because why not - var n = delimiter === 'in' ? 3 : 2; - // extract and flatten keys - var keys = Array.prototype.concat.apply([], toArray(arguments, n)); - var res = []; - var item, key, val, j; - for (var i = 0, l = arr.length; i < l; i++) { - item = arr[i]; - val = item && item.$value || item; - j = keys.length; - if (j) { - while (j--) { - key = keys[j]; - if (key === '$key' && contains(item.$key, search) || contains(getPath(val, key), search)) { - res.push(item); - break; +function genNode (node) { + if (node.type === 1) { + return genElement(node) + } else { + return genText(node) + } +} + +function genText (text) { + return text.type === 2 + ? text.expression // no need for () because already wrapped in _s() + : JSON.stringify(text.text) +} + +function genSlot (el) { + var slotName = el.slotName || '"default"'; + var children = genChildren(el); + return children + ? ("_t(" + slotName + "," + children + ")") + : ("_t(" + slotName + ")") +} + +function genComponent (el) { + var children = el.inlineTemplate ? null : genChildren(el); + return ("_h(" + (el.component) + "," + (genData(el)) + (children ? ("," + children) : '') + ")") +} + +function genProps (props) { + var res = ''; + for (var i = 0; i < props.length; i++) { + var prop = props[i]; + res += "\"" + (prop.name) + "\":" + (prop.value) + ","; + } + return res.slice(0, -1) +} + +/* */ + +/** + * Compile a template. + */ +function compile$1 ( + template, + options +) { + var ast = parse(template.trim(), options); + optimize(ast, options); + var code = generate(ast, options); + return { + ast: ast, + render: code.render, + staticRenderFns: code.staticRenderFns + } +} + +/* */ + +// operators like typeof, instanceof and in are allowed +var prohibitedKeywordRE = new RegExp('\\b' + ( + 'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' + + 'super,throw,while,yield,delete,export,import,return,switch,default,' + + 'extends,finally,continue,debugger,function,arguments' +).split(',').join('\\b|\\b') + '\\b'); +// check valid identifier for v-for +var identRE = /[A-Za-z_$][\w$]*/; +// strip strings in expressions +var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g; + +// detect problematic expressions in a template +function detectErrors (ast) { + var errors = []; + if (ast) { + checkNode(ast, errors); + } + return errors +} + +function checkNode (node, errors) { + if (node.type === 1) { + for (var name in node.attrsMap) { + if (dirRE.test(name)) { + var value = node.attrsMap[name]; + if (value) { + if (name === 'v-for') { + checkFor(node, ("v-for=\"" + value + "\""), errors); + } else { + checkExpression(value, (name + "=\"" + value + "\""), errors); } } - } else if (contains(item, search)) { - res.push(item); } } - return res; + if (node.children) { + for (var i = 0; i < node.children.length; i++) { + checkNode(node.children[i], errors); + } + } + } else if (node.type === 2) { + checkExpression(node.expression, node.text, errors); } +} - /** - * Filter filter for arrays - * - * @param {String|Array<String>|Function} ...sortKeys - * @param {Number} [order] - */ - - function orderBy(arr) { - var comparator = null; - var sortKeys = undefined; - arr = convertArray(arr); +function checkFor (node, text, errors) { + checkExpression(node.for || '', text, errors); + checkIdentifier(node.alias, 'v-for alias', text, errors); + checkIdentifier(node.iterator1, 'v-for iterator', text, errors); + checkIdentifier(node.iterator2, 'v-for iterator', text, errors); +} - // determine order (last argument) - var args = toArray(arguments, 1); - var order = args[args.length - 1]; - if (typeof order === 'number') { - order = order < 0 ? -1 : 1; - args = args.length > 1 ? args.slice(0, -1) : args; - } else { - order = 1; - } +function checkIdentifier (ident, type, text, errors) { + if (typeof ident === 'string' && !identRE.test(ident)) { + errors.push(("- invalid " + type + " \"" + ident + "\" in expression: " + text)); + } +} - // determine sortKeys & comparator - var firstArg = args[0]; - if (!firstArg) { - return arr; - } else if (typeof firstArg === 'function') { - // custom comparator - comparator = function (a, b) { - return firstArg(a, b) * order; - }; +function checkExpression (exp, text, errors) { + try { + new Function(("return " + exp)); + } catch (e) { + var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE); + if (keywordMatch) { + errors.push( + "- avoid using JavaScript keyword as property name: " + + "\"" + (keywordMatch[0]) + "\" in expression " + text + ); } else { - // string keys. flatten first - sortKeys = Array.prototype.concat.apply([], args); - comparator = function (a, b, i) { - i = i || 0; - return i >= sortKeys.length - 1 ? baseCompare(a, b, i) : baseCompare(a, b, i) || comparator(a, b, i + 1); - }; - } - - function baseCompare(a, b, sortKeyIndex) { - var sortKey = sortKeys[sortKeyIndex]; - if (sortKey) { - if (sortKey !== '$key') { - if (isObject(a) && '$value' in a) a = a.$value; - if (isObject(b) && '$value' in b) b = b.$value; - } - a = isObject(a) ? getPath(a, sortKey) : a; - b = isObject(b) ? getPath(b, sortKey) : b; + errors.push(("- invalid expression: " + text)); + } + } +} + +/* */ + +function transformNode (el, options) { + var warn = options.warn || baseWarn; + var staticClass = getAndRemoveAttr(el, 'class'); + if ("development" !== 'production' && staticClass) { + var expression = parseText(staticClass, options.delimiters); + if (expression) { + warn( + "class=\"" + staticClass + "\": " + + 'Interpolation inside attributes has been deprecated. ' + + 'Use v-bind or the colon shorthand instead.' + ); + } + } + if (staticClass) { + el.staticClass = JSON.stringify(staticClass); + } + var classBinding = getBindingAttr(el, 'class', false /* getStatic */); + if (classBinding) { + el.classBinding = classBinding; + } +} + +function genData$1 (el) { + var data = ''; + if (el.staticClass) { + data += "staticClass:" + (el.staticClass) + ","; + } + if (el.classBinding) { + data += "class:" + (el.classBinding) + ","; + } + return data +} + +var klass$1 = { + staticKeys: ['staticClass'], + transformNode: transformNode, + genData: genData$1 +}; + +/* */ + +function transformNode$1 (el) { + var styleBinding = getBindingAttr(el, 'style', false /* getStatic */); + if (styleBinding) { + el.styleBinding = styleBinding; + } +} + +function genData$2 (el) { + return el.styleBinding + ? ("style:(" + (el.styleBinding) + "),") + : '' +} + +var style$1 = { + transformNode: transformNode$1, + genData: genData$2 +}; + +var modules$1 = [ + klass$1, + style$1 +]; + +/* */ + +var warn$3; + +function model$1 ( + el, + dir, + _warn +) { + warn$3 = _warn; + var value = dir.value; + var modifiers = dir.modifiers; + var tag = el.tag; + var type = el.attrsMap.type; + { + var dynamicType = el.attrsMap['v-bind:type'] || el.attrsMap[':type']; + if (tag === 'input' && dynamicType) { + warn$3( + "<input :type=\"" + dynamicType + "\" v-model=\"" + value + "\">:\n" + + "v-model does not support dynamic input types. Use v-if branches instead." + ); + } + } + if (tag === 'select') { + genSelect(el, value); + } else if (tag === 'input' && type === 'checkbox') { + genCheckboxModel(el, value); + } else if (tag === 'input' && type === 'radio') { + genRadioModel(el, value); + } else { + genDefaultModel(el, value, modifiers); + } + // ensure runtime directive metadata + return true +} + +function genCheckboxModel (el, value) { + if ("development" !== 'production' && + el.attrsMap.checked != null) { + warn$3( + "<" + (el.tag) + " v-model=\"" + value + "\" checked>:\n" + + "inline checked attributes will be ignored when using v-model. " + + 'Declare initial values in the component\'s data option instead.' + ); + } + var valueBinding = getBindingAttr(el, 'value') || 'null'; + var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'; + var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'; + addProp(el, 'checked', + "Array.isArray(" + value + ")" + + "?_i(" + value + "," + valueBinding + ")>-1" + + ":_q(" + value + "," + trueValueBinding + ")" + ); + addHandler(el, 'change', + "var $$a=" + value + "," + + '$$el=$event.target,' + + "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" + + 'if(Array.isArray($$a)){' + + "var $$v=" + valueBinding + "," + + '$$i=_i($$a,$$v);' + + "if($$c){$$i<0&&(" + value + "=$$a.concat($$v))}" + + "else{$$i>-1&&(" + value + "=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}" + + "}else{" + value + "=$$c}", + null, true + ); +} + +function genRadioModel (el, value) { + if ("development" !== 'production' && + el.attrsMap.checked != null) { + warn$3( + "<" + (el.tag) + " v-model=\"" + value + "\" checked>:\n" + + "inline checked attributes will be ignored when using v-model. " + + 'Declare initial values in the component\'s data option instead.' + ); + } + var valueBinding = getBindingAttr(el, 'value') || 'null'; + addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")")); + addHandler(el, 'change', (value + "=" + valueBinding), null, true); +} + +function genDefaultModel ( + el, + value, + modifiers +) { + { + if (el.tag === 'input' && el.attrsMap.value) { + warn$3( + "<" + (el.tag) + " v-model=\"" + value + "\" value=\"" + (el.attrsMap.value) + "\">:\n" + + 'inline value attributes will be ignored when using v-model. ' + + 'Declare initial values in the component\'s data option instead.' + ); + } + if (el.tag === 'textarea' && el.children.length) { + warn$3( + "<textarea v-model=\"" + value + "\">:\n" + + 'inline content inside <textarea> will be ignored when using v-model. ' + + 'Declare initial values in the component\'s data option instead.' + ); + } + } + + var type = el.attrsMap.type; + var ref = modifiers || {}; + var lazy = ref.lazy; + var number = ref.number; + var trim = ref.trim; + var event = lazy || (isIE && type === 'range') ? 'change' : 'input'; + var needCompositionGuard = !lazy && type !== 'range'; + var isNative = el.tag === 'input' || el.tag === 'textarea'; + + var valueExpression = isNative + ? ("$event.target.value" + (trim ? '.trim()' : '')) + : "$event"; + var code = number || type === 'number' + ? (value + "=_n(" + valueExpression + ")") + : (value + "=" + valueExpression); + if (isNative && needCompositionGuard) { + code = "if($event.target.composing)return;" + code; + } + // inputs with type="file" are read only and setting the input's + // value will throw an error. + if ("development" !== 'production' && + type === 'file') { + warn$3( + "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" + + "File inputs are read only. Use a v-on:change listener instead." + ); + } + addProp(el, 'value', isNative ? ("_s(" + value + ")") : ("(" + value + ")")); + addHandler(el, event, code, null, true); +} + +function genSelect (el, value) { + { + el.children.some(checkOptionWarning); + } + var code = value + "=Array.prototype.filter" + + ".call($event.target.options,function(o){return o.selected})" + + ".map(function(o){return \"_value\" in o ? o._value : o.value})" + + (el.attrsMap.multiple == null ? '[0]' : ''); + addHandler(el, 'change', code, null, true); +} + +function checkOptionWarning (option) { + if (option.type === 1 && + option.tag === 'option' && + option.attrsMap.selected != null) { + warn$3( + "<select v-model=\"" + (option.parent.attrsMap['v-model']) + "\">:\n" + + 'inline selected attributes on <option> will be ignored when using v-model. ' + + 'Declare initial values in the component\'s data option instead.' + ); + return true + } + return false +} + +/* */ + +function text (el, dir) { + if (dir.value) { + addProp(el, 'textContent', ("_s(" + (dir.value) + ")")); + } +} + +/* */ + +function html (el, dir) { + if (dir.value) { + addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")")); + } +} + +var directives$1 = { + model: model$1, + text: text, + html: html +}; + +/* */ + +var cache = Object.create(null); + +var baseOptions = { + isIE: isIE, + expectHTML: true, + modules: modules$1, + staticKeys: genStaticKeys(modules$1), + directives: directives$1, + isReservedTag: isReservedTag, + isUnaryTag: isUnaryTag, + mustUseProp: mustUseProp, + getTagNamespace: getTagNamespace, + isPreTag: isPreTag +}; + +function compile$$1 ( + template, + options +) { + options = options + ? extend(extend({}, baseOptions), options) + : baseOptions; + return compile$1(template, options) +} + +function compileToFunctions ( + template, + options, + vm +) { + var _warn = (options && options.warn) || warn; + // detect possible CSP restriction + /* istanbul ignore if */ + { + try { + new Function('return 1'); + } catch (e) { + if (e.toString().match(/unsafe-eval|CSP/)) { + _warn( + 'It seems you are using the standalone build of Vue.js in an ' + + 'environment with Content Security Policy that prohibits unsafe-eval. ' + + 'The template compiler cannot work in this environment. Consider ' + + 'relaxing the policy to allow unsafe-eval or pre-compiling your ' + + 'templates into render functions.' + ); } - return a === b ? 0 : a > b ? order : -order; } - - // sort on a copy to avoid mutating original array - return arr.slice().sort(comparator); } - - /** - * String contain helper - * - * @param {*} val - * @param {String} search - */ - - function contains(val, search) { - var i; - if (isPlainObject(val)) { - var keys = Object.keys(val); - i = keys.length; - while (i--) { - if (contains(val[keys[i]], search)) { - return true; - } - } - } else if (isArray(val)) { - i = val.length; - while (i--) { - if (contains(val[i], search)) { - return true; - } - } - } else if (val != null) { - return val.toString().toLowerCase().indexOf(search) > -1; + var key = options && options.delimiters + ? String(options.delimiters) + template + : template; + if (cache[key]) { + return cache[key] + } + var res = {}; + var compiled = compile$$1(template, options); + res.render = makeFunction(compiled.render); + var l = compiled.staticRenderFns.length; + res.staticRenderFns = new Array(l); + for (var i = 0; i < l; i++) { + res.staticRenderFns[i] = makeFunction(compiled.staticRenderFns[i]); + } + { + if (res.render === noop || res.staticRenderFns.some(function (fn) { return fn === noop; })) { + _warn( + "failed to compile template:\n\n" + template + "\n\n" + + detectErrors(compiled.ast).join('\n') + + '\n\n', + vm + ); } } + return (cache[key] = res) +} - var digitsRE = /(\d{3})(?=\d)/g; - - // asset collections must be a plain object. - var filters = { - - orderBy: orderBy, - filterBy: filterBy, - limitBy: limitBy, - - /** - * Stringify value. - * - * @param {Number} indent - */ - - json: { - read: function read(value, indent) { - return typeof value === 'string' ? value : JSON.stringify(value, null, arguments.length > 1 ? indent : 2); - }, - write: function write(value) { - try { - return JSON.parse(value); - } catch (e) { - return value; - } - } - }, - - /** - * 'abc' => 'Abc' - */ - - capitalize: function capitalize(value) { - if (!value && value !== 0) return ''; - value = value.toString(); - return value.charAt(0).toUpperCase() + value.slice(1); - }, - - /** - * 'abc' => 'ABC' - */ +function makeFunction (code) { + try { + return new Function(code) + } catch (e) { + return noop + } +} - uppercase: function uppercase(value) { - return value || value === 0 ? value.toString().toUpperCase() : ''; - }, +/* */ - /** - * 'AbC' => 'abc' - */ +var idToTemplate = cached(function (id) { + var el = query(id); + return el && el.innerHTML +}); - lowercase: function lowercase(value) { - return value || value === 0 ? value.toString().toLowerCase() : ''; - }, +var mount = Vue$3.prototype.$mount; +Vue$3.prototype.$mount = function ( + el, + hydrating +) { + el = el && query(el); - /** - * 12345 => $12,345.00 - * - * @param {String} sign - * @param {Number} decimals Decimal places - */ - - currency: function currency(value, _currency, decimals) { - value = parseFloat(value); - if (!isFinite(value) || !value && value !== 0) return ''; - _currency = _currency != null ? _currency : '$'; - decimals = decimals != null ? decimals : 2; - var stringified = Math.abs(value).toFixed(decimals); - var _int = decimals ? stringified.slice(0, -1 - decimals) : stringified; - var i = _int.length % 3; - var head = i > 0 ? _int.slice(0, i) + (_int.length > 3 ? ',' : '') : ''; - var _float = decimals ? stringified.slice(-1 - decimals) : ''; - var sign = value < 0 ? '-' : ''; - return sign + _currency + head + _int.slice(i).replace(digitsRE, '$1,') + _float; - }, + /* istanbul ignore if */ + if (el === document.body || el === document.documentElement) { + "development" !== 'production' && warn( + "Do not mount Vue to <html> or <body> - mount to normal elements instead." + ); + return this + } - /** - * 'item' => 'items' - * - * @params - * an array of strings corresponding to - * the single, double, triple ... forms of the word to - * be pluralized. When the number to be pluralized - * exceeds the length of the args, it will use the last - * entry in the array. - * - * e.g. ['single', 'double', 'triple', 'multiple'] - */ - - pluralize: function pluralize(value) { - var args = toArray(arguments, 1); - var length = args.length; - if (length > 1) { - var index = value % 10 - 1; - return index in args ? args[index] : args[length - 1]; + var options = this.$options; + // resolve template/el and convert to render function + if (!options.render) { + var template = options.template; + if (template) { + if (typeof template === 'string') { + if (template.charAt(0) === '#') { + template = idToTemplate(template); + } + } else if (template.nodeType) { + template = template.innerHTML; } else { - return args[0] + (value === 1 ? '' : 's'); - } - }, - - /** - * Debounce a handler function. - * - * @param {Function} handler - * @param {Number} delay = 300 - * @return {Function} - */ - - debounce: function debounce(handler, delay) { - if (!handler) return; - if (!delay) { - delay = 300; - } - return _debounce(handler, delay); - } - }; - - function installGlobalAPI (Vue) { - /** - * Vue and every constructor that extends Vue has an - * associated options object, which can be accessed during - * compilation steps as `this.constructor.options`. - * - * These can be seen as the default options of every - * Vue instance. - */ - - Vue.options = { - directives: directives, - elementDirectives: elementDirectives, - filters: filters, - transitions: {}, - components: {}, - partials: {}, - replace: true - }; - - /** - * Expose useful internals - */ - - Vue.util = util; - Vue.config = config; - Vue.set = set; - Vue['delete'] = del; - Vue.nextTick = nextTick; - - /** - * The following are exposed for advanced usage / plugins - */ - - Vue.compiler = compiler; - Vue.FragmentFactory = FragmentFactory; - Vue.internalDirectives = internalDirectives; - Vue.parsers = { - path: path, - text: text, - template: template, - directive: directive, - expression: expression - }; - - /** - * Each instance constructor, including Vue, has a unique - * cid. This enables us to create wrapped "child - * constructors" for prototypal inheritance and cache them. - */ - - Vue.cid = 0; - var cid = 1; - - /** - * Class inheritance - * - * @param {Object} extendOptions - */ - - Vue.extend = function (extendOptions) { - extendOptions = extendOptions || {}; - var Super = this; - var isFirstExtend = Super.cid === 0; - if (isFirstExtend && extendOptions._Ctor) { - return extendOptions._Ctor; - } - var name = extendOptions.name || Super.options.name; - if ('development' !== 'production') { - if (!/^[a-zA-Z][\w-]*$/.test(name)) { - warn('Invalid component name: "' + name + '". Component names ' + 'can only contain alphanumeric characaters and the hyphen.'); - name = null; + { + warn('invalid template option:' + template, this); } + return this } - var Sub = createClass(name || 'VueComponent'); - Sub.prototype = Object.create(Super.prototype); - Sub.prototype.constructor = Sub; - Sub.cid = cid++; - Sub.options = mergeOptions(Super.options, extendOptions); - Sub['super'] = Super; - // allow further extension - Sub.extend = Super.extend; - // create asset registers, so extended classes - // can have their private assets too. - config._assetTypes.forEach(function (type) { - Sub[type] = Super[type]; - }); - // enable recursive self-lookup - if (name) { - Sub.options.components[name] = Sub; - } - // cache constructor - if (isFirstExtend) { - extendOptions._Ctor = Sub; - } - return Sub; - }; - - /** - * A function that returns a sub-class constructor with the - * given name. This gives us much nicer output when - * logging instances in the console. - * - * @param {String} name - * @return {Function} - */ - - function createClass(name) { - /* eslint-disable no-new-func */ - return new Function('return function ' + classify(name) + ' (options) { this._init(options) }')(); - /* eslint-enable no-new-func */ + } else if (el) { + template = getOuterHTML(el); + } + if (template) { + var ref = compileToFunctions(template, { + warn: warn, + shouldDecodeNewlines: shouldDecodeNewlines, + delimiters: options.delimiters + }, this); + var render = ref.render; + var staticRenderFns = ref.staticRenderFns; + options.render = render; + options.staticRenderFns = staticRenderFns; } - - /** - * Plugin system - * - * @param {Object} plugin - */ - - Vue.use = function (plugin) { - /* istanbul ignore if */ - if (plugin.installed) { - return; - } - // additional parameters - var args = toArray(arguments, 1); - args.unshift(this); - if (typeof plugin.install === 'function') { - plugin.install.apply(plugin, args); - } else { - plugin.apply(null, args); - } - plugin.installed = true; - return this; - }; - - /** - * Apply a global mixin by merging it into the default - * options. - */ - - Vue.mixin = function (mixin) { - Vue.options = mergeOptions(Vue.options, mixin); - }; - - /** - * Create asset registration methods with the following - * signature: - * - * @param {String} id - * @param {*} definition - */ - - config._assetTypes.forEach(function (type) { - Vue[type] = function (id, definition) { - if (!definition) { - return this.options[type + 's'][id]; - } else { - /* istanbul ignore if */ - if ('development' !== 'production') { - if (type === 'component' && (commonTagRE.test(id) || reservedTagRE.test(id))) { - warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + id); - } - } - if (type === 'component' && isPlainObject(definition)) { - if (!definition.name) { - definition.name = id; - } - definition = Vue.extend(definition); - } - this.options[type + 's'][id] = definition; - return definition; - } - }; - }); - - // expose internal transition API - extend(Vue.transition, transition); } + return mount.call(this, el, hydrating) +}; - installGlobalAPI(Vue); - - Vue.version = '1.0.26'; +/** + * Get outerHTML of elements, taking care + * of SVG elements in IE as well. + */ +function getOuterHTML (el) { + if (el.outerHTML) { + return el.outerHTML + } else { + var container = document.createElement('div'); + container.appendChild(el.cloneNode(true)); + return container.innerHTML + } +} - // devtools global hook - /* istanbul ignore next */ - setTimeout(function () { - if (config.devtools) { - if (devtools) { - devtools.emit('init', Vue); - } else if ('development' !== 'production' && inBrowser && /Chrome\/\d+/.test(window.navigator.userAgent)) { - console.log('Download the Vue Devtools for a better development experience:\n' + 'https://github.com/vuejs/vue-devtools'); - } - } - }, 0); +Vue$3.compile = compileToFunctions; - return Vue; +return Vue$3; -}));
\ No newline at end of file +}))); |