www: use vue.js
[ros_wild_thumper.git] / www / assets / javascripts / vue.js
1 /*!
2  * Vue.js v2.5.17
3  * (c) 2014-2018 Evan You
4  * Released under the MIT License.
5  */
6 (function (global, factory) {
7         typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
8         typeof define === 'function' && define.amd ? define(factory) :
9         (global.Vue = factory());
10 }(this, (function () { 'use strict';
11
12 /*  */
13
14 var emptyObject = Object.freeze({});
15
16 // these helpers produces better vm code in JS engines due to their
17 // explicitness and function inlining
18 function isUndef (v) {
19   return v === undefined || v === null
20 }
21
22 function isDef (v) {
23   return v !== undefined && v !== null
24 }
25
26 function isTrue (v) {
27   return v === true
28 }
29
30 function isFalse (v) {
31   return v === false
32 }
33
34 /**
35  * Check if value is primitive
36  */
37 function isPrimitive (value) {
38   return (
39     typeof value === 'string' ||
40     typeof value === 'number' ||
41     // $flow-disable-line
42     typeof value === 'symbol' ||
43     typeof value === 'boolean'
44   )
45 }
46
47 /**
48  * Quick object check - this is primarily used to tell
49  * Objects from primitive values when we know the value
50  * is a JSON-compliant type.
51  */
52 function isObject (obj) {
53   return obj !== null && typeof obj === 'object'
54 }
55
56 /**
57  * Get the raw type string of a value e.g. [object Object]
58  */
59 var _toString = Object.prototype.toString;
60
61 function toRawType (value) {
62   return _toString.call(value).slice(8, -1)
63 }
64
65 /**
66  * Strict object type check. Only returns true
67  * for plain JavaScript objects.
68  */
69 function isPlainObject (obj) {
70   return _toString.call(obj) === '[object Object]'
71 }
72
73 function isRegExp (v) {
74   return _toString.call(v) === '[object RegExp]'
75 }
76
77 /**
78  * Check if val is a valid array index.
79  */
80 function isValidArrayIndex (val) {
81   var n = parseFloat(String(val));
82   return n >= 0 && Math.floor(n) === n && isFinite(val)
83 }
84
85 /**
86  * Convert a value to a string that is actually rendered.
87  */
88 function toString (val) {
89   return val == null
90     ? ''
91     : typeof val === 'object'
92       ? JSON.stringify(val, null, 2)
93       : String(val)
94 }
95
96 /**
97  * Convert a input value to a number for persistence.
98  * If the conversion fails, return original string.
99  */
100 function toNumber (val) {
101   var n = parseFloat(val);
102   return isNaN(n) ? val : n
103 }
104
105 /**
106  * Make a map and return a function for checking if a key
107  * is in that map.
108  */
109 function makeMap (
110   str,
111   expectsLowerCase
112 ) {
113   var map = Object.create(null);
114   var list = str.split(',');
115   for (var i = 0; i < list.length; i++) {
116     map[list[i]] = true;
117   }
118   return expectsLowerCase
119     ? function (val) { return map[val.toLowerCase()]; }
120     : function (val) { return map[val]; }
121 }
122
123 /**
124  * Check if a tag is a built-in tag.
125  */
126 var isBuiltInTag = makeMap('slot,component', true);
127
128 /**
129  * Check if a attribute is a reserved attribute.
130  */
131 var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
132
133 /**
134  * Remove an item from an array
135  */
136 function remove (arr, item) {
137   if (arr.length) {
138     var index = arr.indexOf(item);
139     if (index > -1) {
140       return arr.splice(index, 1)
141     }
142   }
143 }
144
145 /**
146  * Check whether the object has the property.
147  */
148 var hasOwnProperty = Object.prototype.hasOwnProperty;
149 function hasOwn (obj, key) {
150   return hasOwnProperty.call(obj, key)
151 }
152
153 /**
154  * Create a cached version of a pure function.
155  */
156 function cached (fn) {
157   var cache = Object.create(null);
158   return (function cachedFn (str) {
159     var hit = cache[str];
160     return hit || (cache[str] = fn(str))
161   })
162 }
163
164 /**
165  * Camelize a hyphen-delimited string.
166  */
167 var camelizeRE = /-(\w)/g;
168 var camelize = cached(function (str) {
169   return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
170 });
171
172 /**
173  * Capitalize a string.
174  */
175 var capitalize = cached(function (str) {
176   return str.charAt(0).toUpperCase() + str.slice(1)
177 });
178
179 /**
180  * Hyphenate a camelCase string.
181  */
182 var hyphenateRE = /\B([A-Z])/g;
183 var hyphenate = cached(function (str) {
184   return str.replace(hyphenateRE, '-$1').toLowerCase()
185 });
186
187 /**
188  * Simple bind polyfill for environments that do not support it... e.g.
189  * PhantomJS 1.x. Technically we don't need this anymore since native bind is
190  * now more performant in most browsers, but removing it would be breaking for
191  * code that was able to run in PhantomJS 1.x, so this must be kept for
192  * backwards compatibility.
193  */
194
195 /* istanbul ignore next */
196 function polyfillBind (fn, ctx) {
197   function boundFn (a) {
198     var l = arguments.length;
199     return l
200       ? l > 1
201         ? fn.apply(ctx, arguments)
202         : fn.call(ctx, a)
203       : fn.call(ctx)
204   }
205
206   boundFn._length = fn.length;
207   return boundFn
208 }
209
210 function nativeBind (fn, ctx) {
211   return fn.bind(ctx)
212 }
213
214 var bind = Function.prototype.bind
215   ? nativeBind
216   : polyfillBind;
217
218 /**
219  * Convert an Array-like object to a real Array.
220  */
221 function toArray (list, start) {
222   start = start || 0;
223   var i = list.length - start;
224   var ret = new Array(i);
225   while (i--) {
226     ret[i] = list[i + start];
227   }
228   return ret
229 }
230
231 /**
232  * Mix properties into target object.
233  */
234 function extend (to, _from) {
235   for (var key in _from) {
236     to[key] = _from[key];
237   }
238   return to
239 }
240
241 /**
242  * Merge an Array of Objects into a single Object.
243  */
244 function toObject (arr) {
245   var res = {};
246   for (var i = 0; i < arr.length; i++) {
247     if (arr[i]) {
248       extend(res, arr[i]);
249     }
250   }
251   return res
252 }
253
254 /**
255  * Perform no operation.
256  * Stubbing args to make Flow happy without leaving useless transpiled code
257  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)
258  */
259 function noop (a, b, c) {}
260
261 /**
262  * Always return false.
263  */
264 var no = function (a, b, c) { return false; };
265
266 /**
267  * Return same value
268  */
269 var identity = function (_) { return _; };
270
271 /**
272  * Generate a static keys string from compiler modules.
273  */
274 function genStaticKeys (modules) {
275   return modules.reduce(function (keys, m) {
276     return keys.concat(m.staticKeys || [])
277   }, []).join(',')
278 }
279
280 /**
281  * Check if two values are loosely equal - that is,
282  * if they are plain objects, do they have the same shape?
283  */
284 function looseEqual (a, b) {
285   if (a === b) { return true }
286   var isObjectA = isObject(a);
287   var isObjectB = isObject(b);
288   if (isObjectA && isObjectB) {
289     try {
290       var isArrayA = Array.isArray(a);
291       var isArrayB = Array.isArray(b);
292       if (isArrayA && isArrayB) {
293         return a.length === b.length && a.every(function (e, i) {
294           return looseEqual(e, b[i])
295         })
296       } else if (!isArrayA && !isArrayB) {
297         var keysA = Object.keys(a);
298         var keysB = Object.keys(b);
299         return keysA.length === keysB.length && keysA.every(function (key) {
300           return looseEqual(a[key], b[key])
301         })
302       } else {
303         /* istanbul ignore next */
304         return false
305       }
306     } catch (e) {
307       /* istanbul ignore next */
308       return false
309     }
310   } else if (!isObjectA && !isObjectB) {
311     return String(a) === String(b)
312   } else {
313     return false
314   }
315 }
316
317 function looseIndexOf (arr, val) {
318   for (var i = 0; i < arr.length; i++) {
319     if (looseEqual(arr[i], val)) { return i }
320   }
321   return -1
322 }
323
324 /**
325  * Ensure a function is called only once.
326  */
327 function once (fn) {
328   var called = false;
329   return function () {
330     if (!called) {
331       called = true;
332       fn.apply(this, arguments);
333     }
334   }
335 }
336
337 var SSR_ATTR = 'data-server-rendered';
338
339 var ASSET_TYPES = [
340   'component',
341   'directive',
342   'filter'
343 ];
344
345 var LIFECYCLE_HOOKS = [
346   'beforeCreate',
347   'created',
348   'beforeMount',
349   'mounted',
350   'beforeUpdate',
351   'updated',
352   'beforeDestroy',
353   'destroyed',
354   'activated',
355   'deactivated',
356   'errorCaptured'
357 ];
358
359 /*  */
360
361 var config = ({
362   /**
363    * Option merge strategies (used in core/util/options)
364    */
365   // $flow-disable-line
366   optionMergeStrategies: Object.create(null),
367
368   /**
369    * Whether to suppress warnings.
370    */
371   silent: false,
372
373   /**
374    * Show production mode tip message on boot?
375    */
376   productionTip: "development" !== 'production',
377
378   /**
379    * Whether to enable devtools
380    */
381   devtools: "development" !== 'production',
382
383   /**
384    * Whether to record perf
385    */
386   performance: false,
387
388   /**
389    * Error handler for watcher errors
390    */
391   errorHandler: null,
392
393   /**
394    * Warn handler for watcher warns
395    */
396   warnHandler: null,
397
398   /**
399    * Ignore certain custom elements
400    */
401   ignoredElements: [],
402
403   /**
404    * Custom user key aliases for v-on
405    */
406   // $flow-disable-line
407   keyCodes: Object.create(null),
408
409   /**
410    * Check if a tag is reserved so that it cannot be registered as a
411    * component. This is platform-dependent and may be overwritten.
412    */
413   isReservedTag: no,
414
415   /**
416    * Check if an attribute is reserved so that it cannot be used as a component
417    * prop. This is platform-dependent and may be overwritten.
418    */
419   isReservedAttr: no,
420
421   /**
422    * Check if a tag is an unknown element.
423    * Platform-dependent.
424    */
425   isUnknownElement: no,
426
427   /**
428    * Get the namespace of an element
429    */
430   getTagNamespace: noop,
431
432   /**
433    * Parse the real tag name for the specific platform.
434    */
435   parsePlatformTagName: identity,
436
437   /**
438    * Check if an attribute must be bound using property, e.g. value
439    * Platform-dependent.
440    */
441   mustUseProp: no,
442
443   /**
444    * Exposed for legacy reasons
445    */
446   _lifecycleHooks: LIFECYCLE_HOOKS
447 })
448
449 /*  */
450
451 /**
452  * Check if a string starts with $ or _
453  */
454 function isReserved (str) {
455   var c = (str + '').charCodeAt(0);
456   return c === 0x24 || c === 0x5F
457 }
458
459 /**
460  * Define a property.
461  */
462 function def (obj, key, val, enumerable) {
463   Object.defineProperty(obj, key, {
464     value: val,
465     enumerable: !!enumerable,
466     writable: true,
467     configurable: true
468   });
469 }
470
471 /**
472  * Parse simple path.
473  */
474 var bailRE = /[^\w.$]/;
475 function parsePath (path) {
476   if (bailRE.test(path)) {
477     return
478   }
479   var segments = path.split('.');
480   return function (obj) {
481     for (var i = 0; i < segments.length; i++) {
482       if (!obj) { return }
483       obj = obj[segments[i]];
484     }
485     return obj
486   }
487 }
488
489 /*  */
490
491 // can we use __proto__?
492 var hasProto = '__proto__' in {};
493
494 // Browser environment sniffing
495 var inBrowser = typeof window !== 'undefined';
496 var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
497 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
498 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
499 var isIE = UA && /msie|trident/.test(UA);
500 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
501 var isEdge = UA && UA.indexOf('edge/') > 0;
502 var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
503 var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
504 var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
505
506 // Firefox has a "watch" function on Object.prototype...
507 var nativeWatch = ({}).watch;
508
509 var supportsPassive = false;
510 if (inBrowser) {
511   try {
512     var opts = {};
513     Object.defineProperty(opts, 'passive', ({
514       get: function get () {
515         /* istanbul ignore next */
516         supportsPassive = true;
517       }
518     })); // https://github.com/facebook/flow/issues/285
519     window.addEventListener('test-passive', null, opts);
520   } catch (e) {}
521 }
522
523 // this needs to be lazy-evaled because vue may be required before
524 // vue-server-renderer can set VUE_ENV
525 var _isServer;
526 var isServerRendering = function () {
527   if (_isServer === undefined) {
528     /* istanbul ignore if */
529     if (!inBrowser && !inWeex && typeof global !== 'undefined') {
530       // detect presence of vue-server-renderer and avoid
531       // Webpack shimming the process
532       _isServer = global['process'].env.VUE_ENV === 'server';
533     } else {
534       _isServer = false;
535     }
536   }
537   return _isServer
538 };
539
540 // detect devtools
541 var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
542
543 /* istanbul ignore next */
544 function isNative (Ctor) {
545   return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
546 }
547
548 var hasSymbol =
549   typeof Symbol !== 'undefined' && isNative(Symbol) &&
550   typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
551
552 var _Set;
553 /* istanbul ignore if */ // $flow-disable-line
554 if (typeof Set !== 'undefined' && isNative(Set)) {
555   // use native Set when available.
556   _Set = Set;
557 } else {
558   // a non-standard Set polyfill that only works with primitive keys.
559   _Set = (function () {
560     function Set () {
561       this.set = Object.create(null);
562     }
563     Set.prototype.has = function has (key) {
564       return this.set[key] === true
565     };
566     Set.prototype.add = function add (key) {
567       this.set[key] = true;
568     };
569     Set.prototype.clear = function clear () {
570       this.set = Object.create(null);
571     };
572
573     return Set;
574   }());
575 }
576
577 /*  */
578
579 var warn = noop;
580 var tip = noop;
581 var generateComponentTrace = (noop); // work around flow check
582 var formatComponentName = (noop);
583
584 {
585   var hasConsole = typeof console !== 'undefined';
586   var classifyRE = /(?:^|[-_])(\w)/g;
587   var classify = function (str) { return str
588     .replace(classifyRE, function (c) { return c.toUpperCase(); })
589     .replace(/[-_]/g, ''); };
590
591   warn = function (msg, vm) {
592     var trace = vm ? generateComponentTrace(vm) : '';
593
594     if (config.warnHandler) {
595       config.warnHandler.call(null, msg, vm, trace);
596     } else if (hasConsole && (!config.silent)) {
597       console.error(("[Vue warn]: " + msg + trace));
598     }
599   };
600
601   tip = function (msg, vm) {
602     if (hasConsole && (!config.silent)) {
603       console.warn("[Vue tip]: " + msg + (
604         vm ? generateComponentTrace(vm) : ''
605       ));
606     }
607   };
608
609   formatComponentName = function (vm, includeFile) {
610     if (vm.$root === vm) {
611       return '<Root>'
612     }
613     var options = typeof vm === 'function' && vm.cid != null
614       ? vm.options
615       : vm._isVue
616         ? vm.$options || vm.constructor.options
617         : vm || {};
618     var name = options.name || options._componentTag;
619     var file = options.__file;
620     if (!name && file) {
621       var match = file.match(/([^/\\]+)\.vue$/);
622       name = match && match[1];
623     }
624
625     return (
626       (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
627       (file && includeFile !== false ? (" at " + file) : '')
628     )
629   };
630
631   var repeat = function (str, n) {
632     var res = '';
633     while (n) {
634       if (n % 2 === 1) { res += str; }
635       if (n > 1) { str += str; }
636       n >>= 1;
637     }
638     return res
639   };
640
641   generateComponentTrace = function (vm) {
642     if (vm._isVue && vm.$parent) {
643       var tree = [];
644       var currentRecursiveSequence = 0;
645       while (vm) {
646         if (tree.length > 0) {
647           var last = tree[tree.length - 1];
648           if (last.constructor === vm.constructor) {
649             currentRecursiveSequence++;
650             vm = vm.$parent;
651             continue
652           } else if (currentRecursiveSequence > 0) {
653             tree[tree.length - 1] = [last, currentRecursiveSequence];
654             currentRecursiveSequence = 0;
655           }
656         }
657         tree.push(vm);
658         vm = vm.$parent;
659       }
660       return '\n\nfound in\n\n' + tree
661         .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
662             ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
663             : formatComponentName(vm))); })
664         .join('\n')
665     } else {
666       return ("\n\n(found in " + (formatComponentName(vm)) + ")")
667     }
668   };
669 }
670
671 /*  */
672
673
674 var uid = 0;
675
676 /**
677  * A dep is an observable that can have multiple
678  * directives subscribing to it.
679  */
680 var Dep = function Dep () {
681   this.id = uid++;
682   this.subs = [];
683 };
684
685 Dep.prototype.addSub = function addSub (sub) {
686   this.subs.push(sub);
687 };
688
689 Dep.prototype.removeSub = function removeSub (sub) {
690   remove(this.subs, sub);
691 };
692
693 Dep.prototype.depend = function depend () {
694   if (Dep.target) {
695     Dep.target.addDep(this);
696   }
697 };
698
699 Dep.prototype.notify = function notify () {
700   // stabilize the subscriber list first
701   var subs = this.subs.slice();
702   for (var i = 0, l = subs.length; i < l; i++) {
703     subs[i].update();
704   }
705 };
706
707 // the current target watcher being evaluated.
708 // this is globally unique because there could be only one
709 // watcher being evaluated at any time.
710 Dep.target = null;
711 var targetStack = [];
712
713 function pushTarget (_target) {
714   if (Dep.target) { targetStack.push(Dep.target); }
715   Dep.target = _target;
716 }
717
718 function popTarget () {
719   Dep.target = targetStack.pop();
720 }
721
722 /*  */
723
724 var VNode = function VNode (
725   tag,
726   data,
727   children,
728   text,
729   elm,
730   context,
731   componentOptions,
732   asyncFactory
733 ) {
734   this.tag = tag;
735   this.data = data;
736   this.children = children;
737   this.text = text;
738   this.elm = elm;
739   this.ns = undefined;
740   this.context = context;
741   this.fnContext = undefined;
742   this.fnOptions = undefined;
743   this.fnScopeId = undefined;
744   this.key = data && data.key;
745   this.componentOptions = componentOptions;
746   this.componentInstance = undefined;
747   this.parent = undefined;
748   this.raw = false;
749   this.isStatic = false;
750   this.isRootInsert = true;
751   this.isComment = false;
752   this.isCloned = false;
753   this.isOnce = false;
754   this.asyncFactory = asyncFactory;
755   this.asyncMeta = undefined;
756   this.isAsyncPlaceholder = false;
757 };
758
759 var prototypeAccessors = { child: { configurable: true } };
760
761 // DEPRECATED: alias for componentInstance for backwards compat.
762 /* istanbul ignore next */
763 prototypeAccessors.child.get = function () {
764   return this.componentInstance
765 };
766
767 Object.defineProperties( VNode.prototype, prototypeAccessors );
768
769 var createEmptyVNode = function (text) {
770   if ( text === void 0 ) text = '';
771
772   var node = new VNode();
773   node.text = text;
774   node.isComment = true;
775   return node
776 };
777
778 function createTextVNode (val) {
779   return new VNode(undefined, undefined, undefined, String(val))
780 }
781
782 // optimized shallow clone
783 // used for static nodes and slot nodes because they may be reused across
784 // multiple renders, cloning them avoids errors when DOM manipulations rely
785 // on their elm reference.
786 function cloneVNode (vnode) {
787   var cloned = new VNode(
788     vnode.tag,
789     vnode.data,
790     vnode.children,
791     vnode.text,
792     vnode.elm,
793     vnode.context,
794     vnode.componentOptions,
795     vnode.asyncFactory
796   );
797   cloned.ns = vnode.ns;
798   cloned.isStatic = vnode.isStatic;
799   cloned.key = vnode.key;
800   cloned.isComment = vnode.isComment;
801   cloned.fnContext = vnode.fnContext;
802   cloned.fnOptions = vnode.fnOptions;
803   cloned.fnScopeId = vnode.fnScopeId;
804   cloned.isCloned = true;
805   return cloned
806 }
807
808 /*
809  * not type checking this file because flow doesn't play well with
810  * dynamically accessing methods on Array prototype
811  */
812
813 var arrayProto = Array.prototype;
814 var arrayMethods = Object.create(arrayProto);
815
816 var methodsToPatch = [
817   'push',
818   'pop',
819   'shift',
820   'unshift',
821   'splice',
822   'sort',
823   'reverse'
824 ];
825
826 /**
827  * Intercept mutating methods and emit events
828  */
829 methodsToPatch.forEach(function (method) {
830   // cache original method
831   var original = arrayProto[method];
832   def(arrayMethods, method, function mutator () {
833     var args = [], len = arguments.length;
834     while ( len-- ) args[ len ] = arguments[ len ];
835
836     var result = original.apply(this, args);
837     var ob = this.__ob__;
838     var inserted;
839     switch (method) {
840       case 'push':
841       case 'unshift':
842         inserted = args;
843         break
844       case 'splice':
845         inserted = args.slice(2);
846         break
847     }
848     if (inserted) { ob.observeArray(inserted); }
849     // notify change
850     ob.dep.notify();
851     return result
852   });
853 });
854
855 /*  */
856
857 var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
858
859 /**
860  * In some cases we may want to disable observation inside a component's
861  * update computation.
862  */
863 var shouldObserve = true;
864
865 function toggleObserving (value) {
866   shouldObserve = value;
867 }
868
869 /**
870  * Observer class that is attached to each observed
871  * object. Once attached, the observer converts the target
872  * object's property keys into getter/setters that
873  * collect dependencies and dispatch updates.
874  */
875 var Observer = function Observer (value) {
876   this.value = value;
877   this.dep = new Dep();
878   this.vmCount = 0;
879   def(value, '__ob__', this);
880   if (Array.isArray(value)) {
881     var augment = hasProto
882       ? protoAugment
883       : copyAugment;
884     augment(value, arrayMethods, arrayKeys);
885     this.observeArray(value);
886   } else {
887     this.walk(value);
888   }
889 };
890
891 /**
892  * Walk through each property and convert them into
893  * getter/setters. This method should only be called when
894  * value type is Object.
895  */
896 Observer.prototype.walk = function walk (obj) {
897   var keys = Object.keys(obj);
898   for (var i = 0; i < keys.length; i++) {
899     defineReactive(obj, keys[i]);
900   }
901 };
902
903 /**
904  * Observe a list of Array items.
905  */
906 Observer.prototype.observeArray = function observeArray (items) {
907   for (var i = 0, l = items.length; i < l; i++) {
908     observe(items[i]);
909   }
910 };
911
912 // helpers
913
914 /**
915  * Augment an target Object or Array by intercepting
916  * the prototype chain using __proto__
917  */
918 function protoAugment (target, src, keys) {
919   /* eslint-disable no-proto */
920   target.__proto__ = src;
921   /* eslint-enable no-proto */
922 }
923
924 /**
925  * Augment an target Object or Array by defining
926  * hidden properties.
927  */
928 /* istanbul ignore next */
929 function copyAugment (target, src, keys) {
930   for (var i = 0, l = keys.length; i < l; i++) {
931     var key = keys[i];
932     def(target, key, src[key]);
933   }
934 }
935
936 /**
937  * Attempt to create an observer instance for a value,
938  * returns the new observer if successfully observed,
939  * or the existing observer if the value already has one.
940  */
941 function observe (value, asRootData) {
942   if (!isObject(value) || value instanceof VNode) {
943     return
944   }
945   var ob;
946   if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
947     ob = value.__ob__;
948   } else if (
949     shouldObserve &&
950     !isServerRendering() &&
951     (Array.isArray(value) || isPlainObject(value)) &&
952     Object.isExtensible(value) &&
953     !value._isVue
954   ) {
955     ob = new Observer(value);
956   }
957   if (asRootData && ob) {
958     ob.vmCount++;
959   }
960   return ob
961 }
962
963 /**
964  * Define a reactive property on an Object.
965  */
966 function defineReactive (
967   obj,
968   key,
969   val,
970   customSetter,
971   shallow
972 ) {
973   var dep = new Dep();
974
975   var property = Object.getOwnPropertyDescriptor(obj, key);
976   if (property && property.configurable === false) {
977     return
978   }
979
980   // cater for pre-defined getter/setters
981   var getter = property && property.get;
982   if (!getter && arguments.length === 2) {
983     val = obj[key];
984   }
985   var setter = property && property.set;
986
987   var childOb = !shallow && observe(val);
988   Object.defineProperty(obj, key, {
989     enumerable: true,
990     configurable: true,
991     get: function reactiveGetter () {
992       var value = getter ? getter.call(obj) : val;
993       if (Dep.target) {
994         dep.depend();
995         if (childOb) {
996           childOb.dep.depend();
997           if (Array.isArray(value)) {
998             dependArray(value);
999           }
1000         }
1001       }
1002       return value
1003     },
1004     set: function reactiveSetter (newVal) {
1005       var value = getter ? getter.call(obj) : val;
1006       /* eslint-disable no-self-compare */
1007       if (newVal === value || (newVal !== newVal && value !== value)) {
1008         return
1009       }
1010       /* eslint-enable no-self-compare */
1011       if ("development" !== 'production' && customSetter) {
1012         customSetter();
1013       }
1014       if (setter) {
1015         setter.call(obj, newVal);
1016       } else {
1017         val = newVal;
1018       }
1019       childOb = !shallow && observe(newVal);
1020       dep.notify();
1021     }
1022   });
1023 }
1024
1025 /**
1026  * Set a property on an object. Adds the new property and
1027  * triggers change notification if the property doesn't
1028  * already exist.
1029  */
1030 function set (target, key, val) {
1031   if ("development" !== 'production' &&
1032     (isUndef(target) || isPrimitive(target))
1033   ) {
1034     warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
1035   }
1036   if (Array.isArray(target) && isValidArrayIndex(key)) {
1037     target.length = Math.max(target.length, key);
1038     target.splice(key, 1, val);
1039     return val
1040   }
1041   if (key in target && !(key in Object.prototype)) {
1042     target[key] = val;
1043     return val
1044   }
1045   var ob = (target).__ob__;
1046   if (target._isVue || (ob && ob.vmCount)) {
1047     "development" !== 'production' && warn(
1048       'Avoid adding reactive properties to a Vue instance or its root $data ' +
1049       'at runtime - declare it upfront in the data option.'
1050     );
1051     return val
1052   }
1053   if (!ob) {
1054     target[key] = val;
1055     return val
1056   }
1057   defineReactive(ob.value, key, val);
1058   ob.dep.notify();
1059   return val
1060 }
1061
1062 /**
1063  * Delete a property and trigger change if necessary.
1064  */
1065 function del (target, key) {
1066   if ("development" !== 'production' &&
1067     (isUndef(target) || isPrimitive(target))
1068   ) {
1069     warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
1070   }
1071   if (Array.isArray(target) && isValidArrayIndex(key)) {
1072     target.splice(key, 1);
1073     return
1074   }
1075   var ob = (target).__ob__;
1076   if (target._isVue || (ob && ob.vmCount)) {
1077     "development" !== 'production' && warn(
1078       'Avoid deleting properties on a Vue instance or its root $data ' +
1079       '- just set it to null.'
1080     );
1081     return
1082   }
1083   if (!hasOwn(target, key)) {
1084     return
1085   }
1086   delete target[key];
1087   if (!ob) {
1088     return
1089   }
1090   ob.dep.notify();
1091 }
1092
1093 /**
1094  * Collect dependencies on array elements when the array is touched, since
1095  * we cannot intercept array element access like property getters.
1096  */
1097 function dependArray (value) {
1098   for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
1099     e = value[i];
1100     e && e.__ob__ && e.__ob__.dep.depend();
1101     if (Array.isArray(e)) {
1102       dependArray(e);
1103     }
1104   }
1105 }
1106
1107 /*  */
1108
1109 /**
1110  * Option overwriting strategies are functions that handle
1111  * how to merge a parent option value and a child option
1112  * value into the final value.
1113  */
1114 var strats = config.optionMergeStrategies;
1115
1116 /**
1117  * Options with restrictions
1118  */
1119 {
1120   strats.el = strats.propsData = function (parent, child, vm, key) {
1121     if (!vm) {
1122       warn(
1123         "option \"" + key + "\" can only be used during instance " +
1124         'creation with the `new` keyword.'
1125       );
1126     }
1127     return defaultStrat(parent, child)
1128   };
1129 }
1130
1131 /**
1132  * Helper that recursively merges two data objects together.
1133  */
1134 function mergeData (to, from) {
1135   if (!from) { return to }
1136   var key, toVal, fromVal;
1137   var keys = Object.keys(from);
1138   for (var i = 0; i < keys.length; i++) {
1139     key = keys[i];
1140     toVal = to[key];
1141     fromVal = from[key];
1142     if (!hasOwn(to, key)) {
1143       set(to, key, fromVal);
1144     } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {
1145       mergeData(toVal, fromVal);
1146     }
1147   }
1148   return to
1149 }
1150
1151 /**
1152  * Data
1153  */
1154 function mergeDataOrFn (
1155   parentVal,
1156   childVal,
1157   vm
1158 ) {
1159   if (!vm) {
1160     // in a Vue.extend merge, both should be functions
1161     if (!childVal) {
1162       return parentVal
1163     }
1164     if (!parentVal) {
1165       return childVal
1166     }
1167     // when parentVal & childVal are both present,
1168     // we need to return a function that returns the
1169     // merged result of both functions... no need to
1170     // check if parentVal is a function here because
1171     // it has to be a function to pass previous merges.
1172     return function mergedDataFn () {
1173       return mergeData(
1174         typeof childVal === 'function' ? childVal.call(this, this) : childVal,
1175         typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
1176       )
1177     }
1178   } else {
1179     return function mergedInstanceDataFn () {
1180       // instance merge
1181       var instanceData = typeof childVal === 'function'
1182         ? childVal.call(vm, vm)
1183         : childVal;
1184       var defaultData = typeof parentVal === 'function'
1185         ? parentVal.call(vm, vm)
1186         : parentVal;
1187       if (instanceData) {
1188         return mergeData(instanceData, defaultData)
1189       } else {
1190         return defaultData
1191       }
1192     }
1193   }
1194 }
1195
1196 strats.data = function (
1197   parentVal,
1198   childVal,
1199   vm
1200 ) {
1201   if (!vm) {
1202     if (childVal && typeof childVal !== 'function') {
1203       "development" !== 'production' && warn(
1204         'The "data" option should be a function ' +
1205         'that returns a per-instance value in component ' +
1206         'definitions.',
1207         vm
1208       );
1209
1210       return parentVal
1211     }
1212     return mergeDataOrFn(parentVal, childVal)
1213   }
1214
1215   return mergeDataOrFn(parentVal, childVal, vm)
1216 };
1217
1218 /**
1219  * Hooks and props are merged as arrays.
1220  */
1221 function mergeHook (
1222   parentVal,
1223   childVal
1224 ) {
1225   return childVal
1226     ? parentVal
1227       ? parentVal.concat(childVal)
1228       : Array.isArray(childVal)
1229         ? childVal
1230         : [childVal]
1231     : parentVal
1232 }
1233
1234 LIFECYCLE_HOOKS.forEach(function (hook) {
1235   strats[hook] = mergeHook;
1236 });
1237
1238 /**
1239  * Assets
1240  *
1241  * When a vm is present (instance creation), we need to do
1242  * a three-way merge between constructor options, instance
1243  * options and parent options.
1244  */
1245 function mergeAssets (
1246   parentVal,
1247   childVal,
1248   vm,
1249   key
1250 ) {
1251   var res = Object.create(parentVal || null);
1252   if (childVal) {
1253     "development" !== 'production' && assertObjectType(key, childVal, vm);
1254     return extend(res, childVal)
1255   } else {
1256     return res
1257   }
1258 }
1259
1260 ASSET_TYPES.forEach(function (type) {
1261   strats[type + 's'] = mergeAssets;
1262 });
1263
1264 /**
1265  * Watchers.
1266  *
1267  * Watchers hashes should not overwrite one
1268  * another, so we merge them as arrays.
1269  */
1270 strats.watch = function (
1271   parentVal,
1272   childVal,
1273   vm,
1274   key
1275 ) {
1276   // work around Firefox's Object.prototype.watch...
1277   if (parentVal === nativeWatch) { parentVal = undefined; }
1278   if (childVal === nativeWatch) { childVal = undefined; }
1279   /* istanbul ignore if */
1280   if (!childVal) { return Object.create(parentVal || null) }
1281   {
1282     assertObjectType(key, childVal, vm);
1283   }
1284   if (!parentVal) { return childVal }
1285   var ret = {};
1286   extend(ret, parentVal);
1287   for (var key$1 in childVal) {
1288     var parent = ret[key$1];
1289     var child = childVal[key$1];
1290     if (parent && !Array.isArray(parent)) {
1291       parent = [parent];
1292     }
1293     ret[key$1] = parent
1294       ? parent.concat(child)
1295       : Array.isArray(child) ? child : [child];
1296   }
1297   return ret
1298 };
1299
1300 /**
1301  * Other object hashes.
1302  */
1303 strats.props =
1304 strats.methods =
1305 strats.inject =
1306 strats.computed = function (
1307   parentVal,
1308   childVal,
1309   vm,
1310   key
1311 ) {
1312   if (childVal && "development" !== 'production') {
1313     assertObjectType(key, childVal, vm);
1314   }
1315   if (!parentVal) { return childVal }
1316   var ret = Object.create(null);
1317   extend(ret, parentVal);
1318   if (childVal) { extend(ret, childVal); }
1319   return ret
1320 };
1321 strats.provide = mergeDataOrFn;
1322
1323 /**
1324  * Default strategy.
1325  */
1326 var defaultStrat = function (parentVal, childVal) {
1327   return childVal === undefined
1328     ? parentVal
1329     : childVal
1330 };
1331
1332 /**
1333  * Validate component names
1334  */
1335 function checkComponents (options) {
1336   for (var key in options.components) {
1337     validateComponentName(key);
1338   }
1339 }
1340
1341 function validateComponentName (name) {
1342   if (!/^[a-zA-Z][\w-]*$/.test(name)) {
1343     warn(
1344       'Invalid component name: "' + name + '". Component names ' +
1345       'can only contain alphanumeric characters and the hyphen, ' +
1346       'and must start with a letter.'
1347     );
1348   }
1349   if (isBuiltInTag(name) || config.isReservedTag(name)) {
1350     warn(
1351       'Do not use built-in or reserved HTML elements as component ' +
1352       'id: ' + name
1353     );
1354   }
1355 }
1356
1357 /**
1358  * Ensure all props option syntax are normalized into the
1359  * Object-based format.
1360  */
1361 function normalizeProps (options, vm) {
1362   var props = options.props;
1363   if (!props) { return }
1364   var res = {};
1365   var i, val, name;
1366   if (Array.isArray(props)) {
1367     i = props.length;
1368     while (i--) {
1369       val = props[i];
1370       if (typeof val === 'string') {
1371         name = camelize(val);
1372         res[name] = { type: null };
1373       } else {
1374         warn('props must be strings when using array syntax.');
1375       }
1376     }
1377   } else if (isPlainObject(props)) {
1378     for (var key in props) {
1379       val = props[key];
1380       name = camelize(key);
1381       res[name] = isPlainObject(val)
1382         ? val
1383         : { type: val };
1384     }
1385   } else {
1386     warn(
1387       "Invalid value for option \"props\": expected an Array or an Object, " +
1388       "but got " + (toRawType(props)) + ".",
1389       vm
1390     );
1391   }
1392   options.props = res;
1393 }
1394
1395 /**
1396  * Normalize all injections into Object-based format
1397  */
1398 function normalizeInject (options, vm) {
1399   var inject = options.inject;
1400   if (!inject) { return }
1401   var normalized = options.inject = {};
1402   if (Array.isArray(inject)) {
1403     for (var i = 0; i < inject.length; i++) {
1404       normalized[inject[i]] = { from: inject[i] };
1405     }
1406   } else if (isPlainObject(inject)) {
1407     for (var key in inject) {
1408       var val = inject[key];
1409       normalized[key] = isPlainObject(val)
1410         ? extend({ from: key }, val)
1411         : { from: val };
1412     }
1413   } else {
1414     warn(
1415       "Invalid value for option \"inject\": expected an Array or an Object, " +
1416       "but got " + (toRawType(inject)) + ".",
1417       vm
1418     );
1419   }
1420 }
1421
1422 /**
1423  * Normalize raw function directives into object format.
1424  */
1425 function normalizeDirectives (options) {
1426   var dirs = options.directives;
1427   if (dirs) {
1428     for (var key in dirs) {
1429       var def = dirs[key];
1430       if (typeof def === 'function') {
1431         dirs[key] = { bind: def, update: def };
1432       }
1433     }
1434   }
1435 }
1436
1437 function assertObjectType (name, value, vm) {
1438   if (!isPlainObject(value)) {
1439     warn(
1440       "Invalid value for option \"" + name + "\": expected an Object, " +
1441       "but got " + (toRawType(value)) + ".",
1442       vm
1443     );
1444   }
1445 }
1446
1447 /**
1448  * Merge two option objects into a new one.
1449  * Core utility used in both instantiation and inheritance.
1450  */
1451 function mergeOptions (
1452   parent,
1453   child,
1454   vm
1455 ) {
1456   {
1457     checkComponents(child);
1458   }
1459
1460   if (typeof child === 'function') {
1461     child = child.options;
1462   }
1463
1464   normalizeProps(child, vm);
1465   normalizeInject(child, vm);
1466   normalizeDirectives(child);
1467   var extendsFrom = child.extends;
1468   if (extendsFrom) {
1469     parent = mergeOptions(parent, extendsFrom, vm);
1470   }
1471   if (child.mixins) {
1472     for (var i = 0, l = child.mixins.length; i < l; i++) {
1473       parent = mergeOptions(parent, child.mixins[i], vm);
1474     }
1475   }
1476   var options = {};
1477   var key;
1478   for (key in parent) {
1479     mergeField(key);
1480   }
1481   for (key in child) {
1482     if (!hasOwn(parent, key)) {
1483       mergeField(key);
1484     }
1485   }
1486   function mergeField (key) {
1487     var strat = strats[key] || defaultStrat;
1488     options[key] = strat(parent[key], child[key], vm, key);
1489   }
1490   return options
1491 }
1492
1493 /**
1494  * Resolve an asset.
1495  * This function is used because child instances need access
1496  * to assets defined in its ancestor chain.
1497  */
1498 function resolveAsset (
1499   options,
1500   type,
1501   id,
1502   warnMissing
1503 ) {
1504   /* istanbul ignore if */
1505   if (typeof id !== 'string') {
1506     return
1507   }
1508   var assets = options[type];
1509   // check local registration variations first
1510   if (hasOwn(assets, id)) { return assets[id] }
1511   var camelizedId = camelize(id);
1512   if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
1513   var PascalCaseId = capitalize(camelizedId);
1514   if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
1515   // fallback to prototype chain
1516   var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
1517   if ("development" !== 'production' && warnMissing && !res) {
1518     warn(
1519       'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
1520       options
1521     );
1522   }
1523   return res
1524 }
1525
1526 /*  */
1527
1528 function validateProp (
1529   key,
1530   propOptions,
1531   propsData,
1532   vm
1533 ) {
1534   var prop = propOptions[key];
1535   var absent = !hasOwn(propsData, key);
1536   var value = propsData[key];
1537   // boolean casting
1538   var booleanIndex = getTypeIndex(Boolean, prop.type);
1539   if (booleanIndex > -1) {
1540     if (absent && !hasOwn(prop, 'default')) {
1541       value = false;
1542     } else if (value === '' || value === hyphenate(key)) {
1543       // only cast empty string / same name to boolean if
1544       // boolean has higher priority
1545       var stringIndex = getTypeIndex(String, prop.type);
1546       if (stringIndex < 0 || booleanIndex < stringIndex) {
1547         value = true;
1548       }
1549     }
1550   }
1551   // check default value
1552   if (value === undefined) {
1553     value = getPropDefaultValue(vm, prop, key);
1554     // since the default value is a fresh copy,
1555     // make sure to observe it.
1556     var prevShouldObserve = shouldObserve;
1557     toggleObserving(true);
1558     observe(value);
1559     toggleObserving(prevShouldObserve);
1560   }
1561   {
1562     assertProp(prop, key, value, vm, absent);
1563   }
1564   return value
1565 }
1566
1567 /**
1568  * Get the default value of a prop.
1569  */
1570 function getPropDefaultValue (vm, prop, key) {
1571   // no default, return undefined
1572   if (!hasOwn(prop, 'default')) {
1573     return undefined
1574   }
1575   var def = prop.default;
1576   // warn against non-factory defaults for Object & Array
1577   if ("development" !== 'production' && isObject(def)) {
1578     warn(
1579       'Invalid default value for prop "' + key + '": ' +
1580       'Props with type Object/Array must use a factory function ' +
1581       'to return the default value.',
1582       vm
1583     );
1584   }
1585   // the raw prop value was also undefined from previous render,
1586   // return previous default value to avoid unnecessary watcher trigger
1587   if (vm && vm.$options.propsData &&
1588     vm.$options.propsData[key] === undefined &&
1589     vm._props[key] !== undefined
1590   ) {
1591     return vm._props[key]
1592   }
1593   // call factory function for non-Function types
1594   // a value is Function if its prototype is function even across different execution context
1595   return typeof def === 'function' && getType(prop.type) !== 'Function'
1596     ? def.call(vm)
1597     : def
1598 }
1599
1600 /**
1601  * Assert whether a prop is valid.
1602  */
1603 function assertProp (
1604   prop,
1605   name,
1606   value,
1607   vm,
1608   absent
1609 ) {
1610   if (prop.required && absent) {
1611     warn(
1612       'Missing required prop: "' + name + '"',
1613       vm
1614     );
1615     return
1616   }
1617   if (value == null && !prop.required) {
1618     return
1619   }
1620   var type = prop.type;
1621   var valid = !type || type === true;
1622   var expectedTypes = [];
1623   if (type) {
1624     if (!Array.isArray(type)) {
1625       type = [type];
1626     }
1627     for (var i = 0; i < type.length && !valid; i++) {
1628       var assertedType = assertType(value, type[i]);
1629       expectedTypes.push(assertedType.expectedType || '');
1630       valid = assertedType.valid;
1631     }
1632   }
1633   if (!valid) {
1634     warn(
1635       "Invalid prop: type check failed for prop \"" + name + "\"." +
1636       " Expected " + (expectedTypes.map(capitalize).join(', ')) +
1637       ", got " + (toRawType(value)) + ".",
1638       vm
1639     );
1640     return
1641   }
1642   var validator = prop.validator;
1643   if (validator) {
1644     if (!validator(value)) {
1645       warn(
1646         'Invalid prop: custom validator check failed for prop "' + name + '".',
1647         vm
1648       );
1649     }
1650   }
1651 }
1652
1653 var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
1654
1655 function assertType (value, type) {
1656   var valid;
1657   var expectedType = getType(type);
1658   if (simpleCheckRE.test(expectedType)) {
1659     var t = typeof value;
1660     valid = t === expectedType.toLowerCase();
1661     // for primitive wrapper objects
1662     if (!valid && t === 'object') {
1663       valid = value instanceof type;
1664     }
1665   } else if (expectedType === 'Object') {
1666     valid = isPlainObject(value);
1667   } else if (expectedType === 'Array') {
1668     valid = Array.isArray(value);
1669   } else {
1670     valid = value instanceof type;
1671   }
1672   return {
1673     valid: valid,
1674     expectedType: expectedType
1675   }
1676 }
1677
1678 /**
1679  * Use function string name to check built-in types,
1680  * because a simple equality check will fail when running
1681  * across different vms / iframes.
1682  */
1683 function getType (fn) {
1684   var match = fn && fn.toString().match(/^\s*function (\w+)/);
1685   return match ? match[1] : ''
1686 }
1687
1688 function isSameType (a, b) {
1689   return getType(a) === getType(b)
1690 }
1691
1692 function getTypeIndex (type, expectedTypes) {
1693   if (!Array.isArray(expectedTypes)) {
1694     return isSameType(expectedTypes, type) ? 0 : -1
1695   }
1696   for (var i = 0, len = expectedTypes.length; i < len; i++) {
1697     if (isSameType(expectedTypes[i], type)) {
1698       return i
1699     }
1700   }
1701   return -1
1702 }
1703
1704 /*  */
1705
1706 function handleError (err, vm, info) {
1707   if (vm) {
1708     var cur = vm;
1709     while ((cur = cur.$parent)) {
1710       var hooks = cur.$options.errorCaptured;
1711       if (hooks) {
1712         for (var i = 0; i < hooks.length; i++) {
1713           try {
1714             var capture = hooks[i].call(cur, err, vm, info) === false;
1715             if (capture) { return }
1716           } catch (e) {
1717             globalHandleError(e, cur, 'errorCaptured hook');
1718           }
1719         }
1720       }
1721     }
1722   }
1723   globalHandleError(err, vm, info);
1724 }
1725
1726 function globalHandleError (err, vm, info) {
1727   if (config.errorHandler) {
1728     try {
1729       return config.errorHandler.call(null, err, vm, info)
1730     } catch (e) {
1731       logError(e, null, 'config.errorHandler');
1732     }
1733   }
1734   logError(err, vm, info);
1735 }
1736
1737 function logError (err, vm, info) {
1738   {
1739     warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
1740   }
1741   /* istanbul ignore else */
1742   if ((inBrowser || inWeex) && typeof console !== 'undefined') {
1743     console.error(err);
1744   } else {
1745     throw err
1746   }
1747 }
1748
1749 /*  */
1750 /* globals MessageChannel */
1751
1752 var callbacks = [];
1753 var pending = false;
1754
1755 function flushCallbacks () {
1756   pending = false;
1757   var copies = callbacks.slice(0);
1758   callbacks.length = 0;
1759   for (var i = 0; i < copies.length; i++) {
1760     copies[i]();
1761   }
1762 }
1763
1764 // Here we have async deferring wrappers using both microtasks and (macro) tasks.
1765 // In < 2.4 we used microtasks everywhere, but there are some scenarios where
1766 // microtasks have too high a priority and fire in between supposedly
1767 // sequential events (e.g. #4521, #6690) or even between bubbling of the same
1768 // event (#6566). However, using (macro) tasks everywhere also has subtle problems
1769 // when state is changed right before repaint (e.g. #6813, out-in transitions).
1770 // Here we use microtask by default, but expose a way to force (macro) task when
1771 // needed (e.g. in event handlers attached by v-on).
1772 var microTimerFunc;
1773 var macroTimerFunc;
1774 var useMacroTask = false;
1775
1776 // Determine (macro) task defer implementation.
1777 // Technically setImmediate should be the ideal choice, but it's only available
1778 // in IE. The only polyfill that consistently queues the callback after all DOM
1779 // events triggered in the same loop is by using MessageChannel.
1780 /* istanbul ignore if */
1781 if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
1782   macroTimerFunc = function () {
1783     setImmediate(flushCallbacks);
1784   };
1785 } else if (typeof MessageChannel !== 'undefined' && (
1786   isNative(MessageChannel) ||
1787   // PhantomJS
1788   MessageChannel.toString() === '[object MessageChannelConstructor]'
1789 )) {
1790   var channel = new MessageChannel();
1791   var port = channel.port2;
1792   channel.port1.onmessage = flushCallbacks;
1793   macroTimerFunc = function () {
1794     port.postMessage(1);
1795   };
1796 } else {
1797   /* istanbul ignore next */
1798   macroTimerFunc = function () {
1799     setTimeout(flushCallbacks, 0);
1800   };
1801 }
1802
1803 // Determine microtask defer implementation.
1804 /* istanbul ignore next, $flow-disable-line */
1805 if (typeof Promise !== 'undefined' && isNative(Promise)) {
1806   var p = Promise.resolve();
1807   microTimerFunc = function () {
1808     p.then(flushCallbacks);
1809     // in problematic UIWebViews, Promise.then doesn't completely break, but
1810     // it can get stuck in a weird state where callbacks are pushed into the
1811     // microtask queue but the queue isn't being flushed, until the browser
1812     // needs to do some other work, e.g. handle a timer. Therefore we can
1813     // "force" the microtask queue to be flushed by adding an empty timer.
1814     if (isIOS) { setTimeout(noop); }
1815   };
1816 } else {
1817   // fallback to macro
1818   microTimerFunc = macroTimerFunc;
1819 }
1820
1821 /**
1822  * Wrap a function so that if any code inside triggers state change,
1823  * the changes are queued using a (macro) task instead of a microtask.
1824  */
1825 function withMacroTask (fn) {
1826   return fn._withTask || (fn._withTask = function () {
1827     useMacroTask = true;
1828     var res = fn.apply(null, arguments);
1829     useMacroTask = false;
1830     return res
1831   })
1832 }
1833
1834 function nextTick (cb, ctx) {
1835   var _resolve;
1836   callbacks.push(function () {
1837     if (cb) {
1838       try {
1839         cb.call(ctx);
1840       } catch (e) {
1841         handleError(e, ctx, 'nextTick');
1842       }
1843     } else if (_resolve) {
1844       _resolve(ctx);
1845     }
1846   });
1847   if (!pending) {
1848     pending = true;
1849     if (useMacroTask) {
1850       macroTimerFunc();
1851     } else {
1852       microTimerFunc();
1853     }
1854   }
1855   // $flow-disable-line
1856   if (!cb && typeof Promise !== 'undefined') {
1857     return new Promise(function (resolve) {
1858       _resolve = resolve;
1859     })
1860   }
1861 }
1862
1863 /*  */
1864
1865 var mark;
1866 var measure;
1867
1868 {
1869   var perf = inBrowser && window.performance;
1870   /* istanbul ignore if */
1871   if (
1872     perf &&
1873     perf.mark &&
1874     perf.measure &&
1875     perf.clearMarks &&
1876     perf.clearMeasures
1877   ) {
1878     mark = function (tag) { return perf.mark(tag); };
1879     measure = function (name, startTag, endTag) {
1880       perf.measure(name, startTag, endTag);
1881       perf.clearMarks(startTag);
1882       perf.clearMarks(endTag);
1883       perf.clearMeasures(name);
1884     };
1885   }
1886 }
1887
1888 /* not type checking this file because flow doesn't play well with Proxy */
1889
1890 var initProxy;
1891
1892 {
1893   var allowedGlobals = makeMap(
1894     'Infinity,undefined,NaN,isFinite,isNaN,' +
1895     'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
1896     'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
1897     'require' // for Webpack/Browserify
1898   );
1899
1900   var warnNonPresent = function (target, key) {
1901     warn(
1902       "Property or method \"" + key + "\" is not defined on the instance but " +
1903       'referenced during render. Make sure that this property is reactive, ' +
1904       'either in the data option, or for class-based components, by ' +
1905       'initializing the property. ' +
1906       'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
1907       target
1908     );
1909   };
1910
1911   var hasProxy =
1912     typeof Proxy !== 'undefined' && isNative(Proxy);
1913
1914   if (hasProxy) {
1915     var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
1916     config.keyCodes = new Proxy(config.keyCodes, {
1917       set: function set (target, key, value) {
1918         if (isBuiltInModifier(key)) {
1919           warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
1920           return false
1921         } else {
1922           target[key] = value;
1923           return true
1924         }
1925       }
1926     });
1927   }
1928
1929   var hasHandler = {
1930     has: function has (target, key) {
1931       var has = key in target;
1932       var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';
1933       if (!has && !isAllowed) {
1934         warnNonPresent(target, key);
1935       }
1936       return has || !isAllowed
1937     }
1938   };
1939
1940   var getHandler = {
1941     get: function get (target, key) {
1942       if (typeof key === 'string' && !(key in target)) {
1943         warnNonPresent(target, key);
1944       }
1945       return target[key]
1946     }
1947   };
1948
1949   initProxy = function initProxy (vm) {
1950     if (hasProxy) {
1951       // determine which proxy handler to use
1952       var options = vm.$options;
1953       var handlers = options.render && options.render._withStripped
1954         ? getHandler
1955         : hasHandler;
1956       vm._renderProxy = new Proxy(vm, handlers);
1957     } else {
1958       vm._renderProxy = vm;
1959     }
1960   };
1961 }
1962
1963 /*  */
1964
1965 var seenObjects = new _Set();
1966
1967 /**
1968  * Recursively traverse an object to evoke all converted
1969  * getters, so that every nested property inside the object
1970  * is collected as a "deep" dependency.
1971  */
1972 function traverse (val) {
1973   _traverse(val, seenObjects);
1974   seenObjects.clear();
1975 }
1976
1977 function _traverse (val, seen) {
1978   var i, keys;
1979   var isA = Array.isArray(val);
1980   if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
1981     return
1982   }
1983   if (val.__ob__) {
1984     var depId = val.__ob__.dep.id;
1985     if (seen.has(depId)) {
1986       return
1987     }
1988     seen.add(depId);
1989   }
1990   if (isA) {
1991     i = val.length;
1992     while (i--) { _traverse(val[i], seen); }
1993   } else {
1994     keys = Object.keys(val);
1995     i = keys.length;
1996     while (i--) { _traverse(val[keys[i]], seen); }
1997   }
1998 }
1999
2000 /*  */
2001
2002 var normalizeEvent = cached(function (name) {
2003   var passive = name.charAt(0) === '&';
2004   name = passive ? name.slice(1) : name;
2005   var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
2006   name = once$$1 ? name.slice(1) : name;
2007   var capture = name.charAt(0) === '!';
2008   name = capture ? name.slice(1) : name;
2009   return {
2010     name: name,
2011     once: once$$1,
2012     capture: capture,
2013     passive: passive
2014   }
2015 });
2016
2017 function createFnInvoker (fns) {
2018   function invoker () {
2019     var arguments$1 = arguments;
2020
2021     var fns = invoker.fns;
2022     if (Array.isArray(fns)) {
2023       var cloned = fns.slice();
2024       for (var i = 0; i < cloned.length; i++) {
2025         cloned[i].apply(null, arguments$1);
2026       }
2027     } else {
2028       // return handler return value for single handlers
2029       return fns.apply(null, arguments)
2030     }
2031   }
2032   invoker.fns = fns;
2033   return invoker
2034 }
2035
2036 function updateListeners (
2037   on,
2038   oldOn,
2039   add,
2040   remove$$1,
2041   vm
2042 ) {
2043   var name, def, cur, old, event;
2044   for (name in on) {
2045     def = cur = on[name];
2046     old = oldOn[name];
2047     event = normalizeEvent(name);
2048     /* istanbul ignore if */
2049     if (isUndef(cur)) {
2050       "development" !== 'production' && warn(
2051         "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
2052         vm
2053       );
2054     } else if (isUndef(old)) {
2055       if (isUndef(cur.fns)) {
2056         cur = on[name] = createFnInvoker(cur);
2057       }
2058       add(event.name, cur, event.once, event.capture, event.passive, event.params);
2059     } else if (cur !== old) {
2060       old.fns = cur;
2061       on[name] = old;
2062     }
2063   }
2064   for (name in oldOn) {
2065     if (isUndef(on[name])) {
2066       event = normalizeEvent(name);
2067       remove$$1(event.name, oldOn[name], event.capture);
2068     }
2069   }
2070 }
2071
2072 /*  */
2073
2074 function mergeVNodeHook (def, hookKey, hook) {
2075   if (def instanceof VNode) {
2076     def = def.data.hook || (def.data.hook = {});
2077   }
2078   var invoker;
2079   var oldHook = def[hookKey];
2080
2081   function wrappedHook () {
2082     hook.apply(this, arguments);
2083     // important: remove merged hook to ensure it's called only once
2084     // and prevent memory leak
2085     remove(invoker.fns, wrappedHook);
2086   }
2087
2088   if (isUndef(oldHook)) {
2089     // no existing hook
2090     invoker = createFnInvoker([wrappedHook]);
2091   } else {
2092     /* istanbul ignore if */
2093     if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
2094       // already a merged invoker
2095       invoker = oldHook;
2096       invoker.fns.push(wrappedHook);
2097     } else {
2098       // existing plain hook
2099       invoker = createFnInvoker([oldHook, wrappedHook]);
2100     }
2101   }
2102
2103   invoker.merged = true;
2104   def[hookKey] = invoker;
2105 }
2106
2107 /*  */
2108
2109 function extractPropsFromVNodeData (
2110   data,
2111   Ctor,
2112   tag
2113 ) {
2114   // we are only extracting raw values here.
2115   // validation and default values are handled in the child
2116   // component itself.
2117   var propOptions = Ctor.options.props;
2118   if (isUndef(propOptions)) {
2119     return
2120   }
2121   var res = {};
2122   var attrs = data.attrs;
2123   var props = data.props;
2124   if (isDef(attrs) || isDef(props)) {
2125     for (var key in propOptions) {
2126       var altKey = hyphenate(key);
2127       {
2128         var keyInLowerCase = key.toLowerCase();
2129         if (
2130           key !== keyInLowerCase &&
2131           attrs && hasOwn(attrs, keyInLowerCase)
2132         ) {
2133           tip(
2134             "Prop \"" + keyInLowerCase + "\" is passed to component " +
2135             (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
2136             " \"" + key + "\". " +
2137             "Note that HTML attributes are case-insensitive and camelCased " +
2138             "props need to use their kebab-case equivalents when using in-DOM " +
2139             "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
2140           );
2141         }
2142       }
2143       checkProp(res, props, key, altKey, true) ||
2144       checkProp(res, attrs, key, altKey, false);
2145     }
2146   }
2147   return res
2148 }
2149
2150 function checkProp (
2151   res,
2152   hash,
2153   key,
2154   altKey,
2155   preserve
2156 ) {
2157   if (isDef(hash)) {
2158     if (hasOwn(hash, key)) {
2159       res[key] = hash[key];
2160       if (!preserve) {
2161         delete hash[key];
2162       }
2163       return true
2164     } else if (hasOwn(hash, altKey)) {
2165       res[key] = hash[altKey];
2166       if (!preserve) {
2167         delete hash[altKey];
2168       }
2169       return true
2170     }
2171   }
2172   return false
2173 }
2174
2175 /*  */
2176
2177 // The template compiler attempts to minimize the need for normalization by
2178 // statically analyzing the template at compile time.
2179 //
2180 // For plain HTML markup, normalization can be completely skipped because the
2181 // generated render function is guaranteed to return Array<VNode>. There are
2182 // two cases where extra normalization is needed:
2183
2184 // 1. When the children contains components - because a functional component
2185 // may return an Array instead of a single root. In this case, just a simple
2186 // normalization is needed - if any child is an Array, we flatten the whole
2187 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
2188 // because functional components already normalize their own children.
2189 function simpleNormalizeChildren (children) {
2190   for (var i = 0; i < children.length; i++) {
2191     if (Array.isArray(children[i])) {
2192       return Array.prototype.concat.apply([], children)
2193     }
2194   }
2195   return children
2196 }
2197
2198 // 2. When the children contains constructs that always generated nested Arrays,
2199 // e.g. <template>, <slot>, v-for, or when the children is provided by user
2200 // with hand-written render functions / JSX. In such cases a full normalization
2201 // is needed to cater to all possible types of children values.
2202 function normalizeChildren (children) {
2203   return isPrimitive(children)
2204     ? [createTextVNode(children)]
2205     : Array.isArray(children)
2206       ? normalizeArrayChildren(children)
2207       : undefined
2208 }
2209
2210 function isTextNode (node) {
2211   return isDef(node) && isDef(node.text) && isFalse(node.isComment)
2212 }
2213
2214 function normalizeArrayChildren (children, nestedIndex) {
2215   var res = [];
2216   var i, c, lastIndex, last;
2217   for (i = 0; i < children.length; i++) {
2218     c = children[i];
2219     if (isUndef(c) || typeof c === 'boolean') { continue }
2220     lastIndex = res.length - 1;
2221     last = res[lastIndex];
2222     //  nested
2223     if (Array.isArray(c)) {
2224       if (c.length > 0) {
2225         c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
2226         // merge adjacent text nodes
2227         if (isTextNode(c[0]) && isTextNode(last)) {
2228           res[lastIndex] = createTextVNode(last.text + (c[0]).text);
2229           c.shift();
2230         }
2231         res.push.apply(res, c);
2232       }
2233     } else if (isPrimitive(c)) {
2234       if (isTextNode(last)) {
2235         // merge adjacent text nodes
2236         // this is necessary for SSR hydration because text nodes are
2237         // essentially merged when rendered to HTML strings
2238         res[lastIndex] = createTextVNode(last.text + c);
2239       } else if (c !== '') {
2240         // convert primitive to vnode
2241         res.push(createTextVNode(c));
2242       }
2243     } else {
2244       if (isTextNode(c) && isTextNode(last)) {
2245         // merge adjacent text nodes
2246         res[lastIndex] = createTextVNode(last.text + c.text);
2247       } else {
2248         // default key for nested array children (likely generated by v-for)
2249         if (isTrue(children._isVList) &&
2250           isDef(c.tag) &&
2251           isUndef(c.key) &&
2252           isDef(nestedIndex)) {
2253           c.key = "__vlist" + nestedIndex + "_" + i + "__";
2254         }
2255         res.push(c);
2256       }
2257     }
2258   }
2259   return res
2260 }
2261
2262 /*  */
2263
2264 function ensureCtor (comp, base) {
2265   if (
2266     comp.__esModule ||
2267     (hasSymbol && comp[Symbol.toStringTag] === 'Module')
2268   ) {
2269     comp = comp.default;
2270   }
2271   return isObject(comp)
2272     ? base.extend(comp)
2273     : comp
2274 }
2275
2276 function createAsyncPlaceholder (
2277   factory,
2278   data,
2279   context,
2280   children,
2281   tag
2282 ) {
2283   var node = createEmptyVNode();
2284   node.asyncFactory = factory;
2285   node.asyncMeta = { data: data, context: context, children: children, tag: tag };
2286   return node
2287 }
2288
2289 function resolveAsyncComponent (
2290   factory,
2291   baseCtor,
2292   context
2293 ) {
2294   if (isTrue(factory.error) && isDef(factory.errorComp)) {
2295     return factory.errorComp
2296   }
2297
2298   if (isDef(factory.resolved)) {
2299     return factory.resolved
2300   }
2301
2302   if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
2303     return factory.loadingComp
2304   }
2305
2306   if (isDef(factory.contexts)) {
2307     // already pending
2308     factory.contexts.push(context);
2309   } else {
2310     var contexts = factory.contexts = [context];
2311     var sync = true;
2312
2313     var forceRender = function () {
2314       for (var i = 0, l = contexts.length; i < l; i++) {
2315         contexts[i].$forceUpdate();
2316       }
2317     };
2318
2319     var resolve = once(function (res) {
2320       // cache resolved
2321       factory.resolved = ensureCtor(res, baseCtor);
2322       // invoke callbacks only if this is not a synchronous resolve
2323       // (async resolves are shimmed as synchronous during SSR)
2324       if (!sync) {
2325         forceRender();
2326       }
2327     });
2328
2329     var reject = once(function (reason) {
2330       "development" !== 'production' && warn(
2331         "Failed to resolve async component: " + (String(factory)) +
2332         (reason ? ("\nReason: " + reason) : '')
2333       );
2334       if (isDef(factory.errorComp)) {
2335         factory.error = true;
2336         forceRender();
2337       }
2338     });
2339
2340     var res = factory(resolve, reject);
2341
2342     if (isObject(res)) {
2343       if (typeof res.then === 'function') {
2344         // () => Promise
2345         if (isUndef(factory.resolved)) {
2346           res.then(resolve, reject);
2347         }
2348       } else if (isDef(res.component) && typeof res.component.then === 'function') {
2349         res.component.then(resolve, reject);
2350
2351         if (isDef(res.error)) {
2352           factory.errorComp = ensureCtor(res.error, baseCtor);
2353         }
2354
2355         if (isDef(res.loading)) {
2356           factory.loadingComp = ensureCtor(res.loading, baseCtor);
2357           if (res.delay === 0) {
2358             factory.loading = true;
2359           } else {
2360             setTimeout(function () {
2361               if (isUndef(factory.resolved) && isUndef(factory.error)) {
2362                 factory.loading = true;
2363                 forceRender();
2364               }
2365             }, res.delay || 200);
2366           }
2367         }
2368
2369         if (isDef(res.timeout)) {
2370           setTimeout(function () {
2371             if (isUndef(factory.resolved)) {
2372               reject(
2373                 "timeout (" + (res.timeout) + "ms)"
2374               );
2375             }
2376           }, res.timeout);
2377         }
2378       }
2379     }
2380
2381     sync = false;
2382     // return in case resolved synchronously
2383     return factory.loading
2384       ? factory.loadingComp
2385       : factory.resolved
2386   }
2387 }
2388
2389 /*  */
2390
2391 function isAsyncPlaceholder (node) {
2392   return node.isComment && node.asyncFactory
2393 }
2394
2395 /*  */
2396
2397 function getFirstComponentChild (children) {
2398   if (Array.isArray(children)) {
2399     for (var i = 0; i < children.length; i++) {
2400       var c = children[i];
2401       if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
2402         return c
2403       }
2404     }
2405   }
2406 }
2407
2408 /*  */
2409
2410 /*  */
2411
2412 function initEvents (vm) {
2413   vm._events = Object.create(null);
2414   vm._hasHookEvent = false;
2415   // init parent attached events
2416   var listeners = vm.$options._parentListeners;
2417   if (listeners) {
2418     updateComponentListeners(vm, listeners);
2419   }
2420 }
2421
2422 var target;
2423
2424 function add (event, fn, once) {
2425   if (once) {
2426     target.$once(event, fn);
2427   } else {
2428     target.$on(event, fn);
2429   }
2430 }
2431
2432 function remove$1 (event, fn) {
2433   target.$off(event, fn);
2434 }
2435
2436 function updateComponentListeners (
2437   vm,
2438   listeners,
2439   oldListeners
2440 ) {
2441   target = vm;
2442   updateListeners(listeners, oldListeners || {}, add, remove$1, vm);
2443   target = undefined;
2444 }
2445
2446 function eventsMixin (Vue) {
2447   var hookRE = /^hook:/;
2448   Vue.prototype.$on = function (event, fn) {
2449     var this$1 = this;
2450
2451     var vm = this;
2452     if (Array.isArray(event)) {
2453       for (var i = 0, l = event.length; i < l; i++) {
2454         this$1.$on(event[i], fn);
2455       }
2456     } else {
2457       (vm._events[event] || (vm._events[event] = [])).push(fn);
2458       // optimize hook:event cost by using a boolean flag marked at registration
2459       // instead of a hash lookup
2460       if (hookRE.test(event)) {
2461         vm._hasHookEvent = true;
2462       }
2463     }
2464     return vm
2465   };
2466
2467   Vue.prototype.$once = function (event, fn) {
2468     var vm = this;
2469     function on () {
2470       vm.$off(event, on);
2471       fn.apply(vm, arguments);
2472     }
2473     on.fn = fn;
2474     vm.$on(event, on);
2475     return vm
2476   };
2477
2478   Vue.prototype.$off = function (event, fn) {
2479     var this$1 = this;
2480
2481     var vm = this;
2482     // all
2483     if (!arguments.length) {
2484       vm._events = Object.create(null);
2485       return vm
2486     }
2487     // array of events
2488     if (Array.isArray(event)) {
2489       for (var i = 0, l = event.length; i < l; i++) {
2490         this$1.$off(event[i], fn);
2491       }
2492       return vm
2493     }
2494     // specific event
2495     var cbs = vm._events[event];
2496     if (!cbs) {
2497       return vm
2498     }
2499     if (!fn) {
2500       vm._events[event] = null;
2501       return vm
2502     }
2503     if (fn) {
2504       // specific handler
2505       var cb;
2506       var i$1 = cbs.length;
2507       while (i$1--) {
2508         cb = cbs[i$1];
2509         if (cb === fn || cb.fn === fn) {
2510           cbs.splice(i$1, 1);
2511           break
2512         }
2513       }
2514     }
2515     return vm
2516   };
2517
2518   Vue.prototype.$emit = function (event) {
2519     var vm = this;
2520     {
2521       var lowerCaseEvent = event.toLowerCase();
2522       if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
2523         tip(
2524           "Event \"" + lowerCaseEvent + "\" is emitted in component " +
2525           (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
2526           "Note that HTML attributes are case-insensitive and you cannot use " +
2527           "v-on to listen to camelCase events when using in-DOM templates. " +
2528           "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
2529         );
2530       }
2531     }
2532     var cbs = vm._events[event];
2533     if (cbs) {
2534       cbs = cbs.length > 1 ? toArray(cbs) : cbs;
2535       var args = toArray(arguments, 1);
2536       for (var i = 0, l = cbs.length; i < l; i++) {
2537         try {
2538           cbs[i].apply(vm, args);
2539         } catch (e) {
2540           handleError(e, vm, ("event handler for \"" + event + "\""));
2541         }
2542       }
2543     }
2544     return vm
2545   };
2546 }
2547
2548 /*  */
2549
2550
2551
2552 /**
2553  * Runtime helper for resolving raw children VNodes into a slot object.
2554  */
2555 function resolveSlots (
2556   children,
2557   context
2558 ) {
2559   var slots = {};
2560   if (!children) {
2561     return slots
2562   }
2563   for (var i = 0, l = children.length; i < l; i++) {
2564     var child = children[i];
2565     var data = child.data;
2566     // remove slot attribute if the node is resolved as a Vue slot node
2567     if (data && data.attrs && data.attrs.slot) {
2568       delete data.attrs.slot;
2569     }
2570     // named slots should only be respected if the vnode was rendered in the
2571     // same context.
2572     if ((child.context === context || child.fnContext === context) &&
2573       data && data.slot != null
2574     ) {
2575       var name = data.slot;
2576       var slot = (slots[name] || (slots[name] = []));
2577       if (child.tag === 'template') {
2578         slot.push.apply(slot, child.children || []);
2579       } else {
2580         slot.push(child);
2581       }
2582     } else {
2583       (slots.default || (slots.default = [])).push(child);
2584     }
2585   }
2586   // ignore slots that contains only whitespace
2587   for (var name$1 in slots) {
2588     if (slots[name$1].every(isWhitespace)) {
2589       delete slots[name$1];
2590     }
2591   }
2592   return slots
2593 }
2594
2595 function isWhitespace (node) {
2596   return (node.isComment && !node.asyncFactory) || node.text === ' '
2597 }
2598
2599 function resolveScopedSlots (
2600   fns, // see flow/vnode
2601   res
2602 ) {
2603   res = res || {};
2604   for (var i = 0; i < fns.length; i++) {
2605     if (Array.isArray(fns[i])) {
2606       resolveScopedSlots(fns[i], res);
2607     } else {
2608       res[fns[i].key] = fns[i].fn;
2609     }
2610   }
2611   return res
2612 }
2613
2614 /*  */
2615
2616 var activeInstance = null;
2617 var isUpdatingChildComponent = false;
2618
2619 function initLifecycle (vm) {
2620   var options = vm.$options;
2621
2622   // locate first non-abstract parent
2623   var parent = options.parent;
2624   if (parent && !options.abstract) {
2625     while (parent.$options.abstract && parent.$parent) {
2626       parent = parent.$parent;
2627     }
2628     parent.$children.push(vm);
2629   }
2630
2631   vm.$parent = parent;
2632   vm.$root = parent ? parent.$root : vm;
2633
2634   vm.$children = [];
2635   vm.$refs = {};
2636
2637   vm._watcher = null;
2638   vm._inactive = null;
2639   vm._directInactive = false;
2640   vm._isMounted = false;
2641   vm._isDestroyed = false;
2642   vm._isBeingDestroyed = false;
2643 }
2644
2645 function lifecycleMixin (Vue) {
2646   Vue.prototype._update = function (vnode, hydrating) {
2647     var vm = this;
2648     if (vm._isMounted) {
2649       callHook(vm, 'beforeUpdate');
2650     }
2651     var prevEl = vm.$el;
2652     var prevVnode = vm._vnode;
2653     var prevActiveInstance = activeInstance;
2654     activeInstance = vm;
2655     vm._vnode = vnode;
2656     // Vue.prototype.__patch__ is injected in entry points
2657     // based on the rendering backend used.
2658     if (!prevVnode) {
2659       // initial render
2660       vm.$el = vm.__patch__(
2661         vm.$el, vnode, hydrating, false /* removeOnly */,
2662         vm.$options._parentElm,
2663         vm.$options._refElm
2664       );
2665       // no need for the ref nodes after initial patch
2666       // this prevents keeping a detached DOM tree in memory (#5851)
2667       vm.$options._parentElm = vm.$options._refElm = null;
2668     } else {
2669       // updates
2670       vm.$el = vm.__patch__(prevVnode, vnode);
2671     }
2672     activeInstance = prevActiveInstance;
2673     // update __vue__ reference
2674     if (prevEl) {
2675       prevEl.__vue__ = null;
2676     }
2677     if (vm.$el) {
2678       vm.$el.__vue__ = vm;
2679     }
2680     // if parent is an HOC, update its $el as well
2681     if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
2682       vm.$parent.$el = vm.$el;
2683     }
2684     // updated hook is called by the scheduler to ensure that children are
2685     // updated in a parent's updated hook.
2686   };
2687
2688   Vue.prototype.$forceUpdate = function () {
2689     var vm = this;
2690     if (vm._watcher) {
2691       vm._watcher.update();
2692     }
2693   };
2694
2695   Vue.prototype.$destroy = function () {
2696     var vm = this;
2697     if (vm._isBeingDestroyed) {
2698       return
2699     }
2700     callHook(vm, 'beforeDestroy');
2701     vm._isBeingDestroyed = true;
2702     // remove self from parent
2703     var parent = vm.$parent;
2704     if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
2705       remove(parent.$children, vm);
2706     }
2707     // teardown watchers
2708     if (vm._watcher) {
2709       vm._watcher.teardown();
2710     }
2711     var i = vm._watchers.length;
2712     while (i--) {
2713       vm._watchers[i].teardown();
2714     }
2715     // remove reference from data ob
2716     // frozen object may not have observer.
2717     if (vm._data.__ob__) {
2718       vm._data.__ob__.vmCount--;
2719     }
2720     // call the last hook...
2721     vm._isDestroyed = true;
2722     // invoke destroy hooks on current rendered tree
2723     vm.__patch__(vm._vnode, null);
2724     // fire destroyed hook
2725     callHook(vm, 'destroyed');
2726     // turn off all instance listeners.
2727     vm.$off();
2728     // remove __vue__ reference
2729     if (vm.$el) {
2730       vm.$el.__vue__ = null;
2731     }
2732     // release circular reference (#6759)
2733     if (vm.$vnode) {
2734       vm.$vnode.parent = null;
2735     }
2736   };
2737 }
2738
2739 function mountComponent (
2740   vm,
2741   el,
2742   hydrating
2743 ) {
2744   vm.$el = el;
2745   if (!vm.$options.render) {
2746     vm.$options.render = createEmptyVNode;
2747     {
2748       /* istanbul ignore if */
2749       if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
2750         vm.$options.el || el) {
2751         warn(
2752           'You are using the runtime-only build of Vue where the template ' +
2753           'compiler is not available. Either pre-compile the templates into ' +
2754           'render functions, or use the compiler-included build.',
2755           vm
2756         );
2757       } else {
2758         warn(
2759           'Failed to mount component: template or render function not defined.',
2760           vm
2761         );
2762       }
2763     }
2764   }
2765   callHook(vm, 'beforeMount');
2766
2767   var updateComponent;
2768   /* istanbul ignore if */
2769   if ("development" !== 'production' && config.performance && mark) {
2770     updateComponent = function () {
2771       var name = vm._name;
2772       var id = vm._uid;
2773       var startTag = "vue-perf-start:" + id;
2774       var endTag = "vue-perf-end:" + id;
2775
2776       mark(startTag);
2777       var vnode = vm._render();
2778       mark(endTag);
2779       measure(("vue " + name + " render"), startTag, endTag);
2780
2781       mark(startTag);
2782       vm._update(vnode, hydrating);
2783       mark(endTag);
2784       measure(("vue " + name + " patch"), startTag, endTag);
2785     };
2786   } else {
2787     updateComponent = function () {
2788       vm._update(vm._render(), hydrating);
2789     };
2790   }
2791
2792   // we set this to vm._watcher inside the watcher's constructor
2793   // since the watcher's initial patch may call $forceUpdate (e.g. inside child
2794   // component's mounted hook), which relies on vm._watcher being already defined
2795   new Watcher(vm, updateComponent, noop, null, true /* isRenderWatcher */);
2796   hydrating = false;
2797
2798   // manually mounted instance, call mounted on self
2799   // mounted is called for render-created child components in its inserted hook
2800   if (vm.$vnode == null) {
2801     vm._isMounted = true;
2802     callHook(vm, 'mounted');
2803   }
2804   return vm
2805 }
2806
2807 function updateChildComponent (
2808   vm,
2809   propsData,
2810   listeners,
2811   parentVnode,
2812   renderChildren
2813 ) {
2814   {
2815     isUpdatingChildComponent = true;
2816   }
2817
2818   // determine whether component has slot children
2819   // we need to do this before overwriting $options._renderChildren
2820   var hasChildren = !!(
2821     renderChildren ||               // has new static slots
2822     vm.$options._renderChildren ||  // has old static slots
2823     parentVnode.data.scopedSlots || // has new scoped slots
2824     vm.$scopedSlots !== emptyObject // has old scoped slots
2825   );
2826
2827   vm.$options._parentVnode = parentVnode;
2828   vm.$vnode = parentVnode; // update vm's placeholder node without re-render
2829
2830   if (vm._vnode) { // update child tree's parent
2831     vm._vnode.parent = parentVnode;
2832   }
2833   vm.$options._renderChildren = renderChildren;
2834
2835   // update $attrs and $listeners hash
2836   // these are also reactive so they may trigger child update if the child
2837   // used them during render
2838   vm.$attrs = parentVnode.data.attrs || emptyObject;
2839   vm.$listeners = listeners || emptyObject;
2840
2841   // update props
2842   if (propsData && vm.$options.props) {
2843     toggleObserving(false);
2844     var props = vm._props;
2845     var propKeys = vm.$options._propKeys || [];
2846     for (var i = 0; i < propKeys.length; i++) {
2847       var key = propKeys[i];
2848       var propOptions = vm.$options.props; // wtf flow?
2849       props[key] = validateProp(key, propOptions, propsData, vm);
2850     }
2851     toggleObserving(true);
2852     // keep a copy of raw propsData
2853     vm.$options.propsData = propsData;
2854   }
2855
2856   // update listeners
2857   listeners = listeners || emptyObject;
2858   var oldListeners = vm.$options._parentListeners;
2859   vm.$options._parentListeners = listeners;
2860   updateComponentListeners(vm, listeners, oldListeners);
2861
2862   // resolve slots + force update if has children
2863   if (hasChildren) {
2864     vm.$slots = resolveSlots(renderChildren, parentVnode.context);
2865     vm.$forceUpdate();
2866   }
2867
2868   {
2869     isUpdatingChildComponent = false;
2870   }
2871 }
2872
2873 function isInInactiveTree (vm) {
2874   while (vm && (vm = vm.$parent)) {
2875     if (vm._inactive) { return true }
2876   }
2877   return false
2878 }
2879
2880 function activateChildComponent (vm, direct) {
2881   if (direct) {
2882     vm._directInactive = false;
2883     if (isInInactiveTree(vm)) {
2884       return
2885     }
2886   } else if (vm._directInactive) {
2887     return
2888   }
2889   if (vm._inactive || vm._inactive === null) {
2890     vm._inactive = false;
2891     for (var i = 0; i < vm.$children.length; i++) {
2892       activateChildComponent(vm.$children[i]);
2893     }
2894     callHook(vm, 'activated');
2895   }
2896 }
2897
2898 function deactivateChildComponent (vm, direct) {
2899   if (direct) {
2900     vm._directInactive = true;
2901     if (isInInactiveTree(vm)) {
2902       return
2903     }
2904   }
2905   if (!vm._inactive) {
2906     vm._inactive = true;
2907     for (var i = 0; i < vm.$children.length; i++) {
2908       deactivateChildComponent(vm.$children[i]);
2909     }
2910     callHook(vm, 'deactivated');
2911   }
2912 }
2913
2914 function callHook (vm, hook) {
2915   // #7573 disable dep collection when invoking lifecycle hooks
2916   pushTarget();
2917   var handlers = vm.$options[hook];
2918   if (handlers) {
2919     for (var i = 0, j = handlers.length; i < j; i++) {
2920       try {
2921         handlers[i].call(vm);
2922       } catch (e) {
2923         handleError(e, vm, (hook + " hook"));
2924       }
2925     }
2926   }
2927   if (vm._hasHookEvent) {
2928     vm.$emit('hook:' + hook);
2929   }
2930   popTarget();
2931 }
2932
2933 /*  */
2934
2935
2936 var MAX_UPDATE_COUNT = 100;
2937
2938 var queue = [];
2939 var activatedChildren = [];
2940 var has = {};
2941 var circular = {};
2942 var waiting = false;
2943 var flushing = false;
2944 var index = 0;
2945
2946 /**
2947  * Reset the scheduler's state.
2948  */
2949 function resetSchedulerState () {
2950   index = queue.length = activatedChildren.length = 0;
2951   has = {};
2952   {
2953     circular = {};
2954   }
2955   waiting = flushing = false;
2956 }
2957
2958 /**
2959  * Flush both queues and run the watchers.
2960  */
2961 function flushSchedulerQueue () {
2962   flushing = true;
2963   var watcher, id;
2964
2965   // Sort queue before flush.
2966   // This ensures that:
2967   // 1. Components are updated from parent to child. (because parent is always
2968   //    created before the child)
2969   // 2. A component's user watchers are run before its render watcher (because
2970   //    user watchers are created before the render watcher)
2971   // 3. If a component is destroyed during a parent component's watcher run,
2972   //    its watchers can be skipped.
2973   queue.sort(function (a, b) { return a.id - b.id; });
2974
2975   // do not cache length because more watchers might be pushed
2976   // as we run existing watchers
2977   for (index = 0; index < queue.length; index++) {
2978     watcher = queue[index];
2979     id = watcher.id;
2980     has[id] = null;
2981     watcher.run();
2982     // in dev build, check and stop circular updates.
2983     if ("development" !== 'production' && has[id] != null) {
2984       circular[id] = (circular[id] || 0) + 1;
2985       if (circular[id] > MAX_UPDATE_COUNT) {
2986         warn(
2987           'You may have an infinite update loop ' + (
2988             watcher.user
2989               ? ("in watcher with expression \"" + (watcher.expression) + "\"")
2990               : "in a component render function."
2991           ),
2992           watcher.vm
2993         );
2994         break
2995       }
2996     }
2997   }
2998
2999   // keep copies of post queues before resetting state
3000   var activatedQueue = activatedChildren.slice();
3001   var updatedQueue = queue.slice();
3002
3003   resetSchedulerState();
3004
3005   // call component updated and activated hooks
3006   callActivatedHooks(activatedQueue);
3007   callUpdatedHooks(updatedQueue);
3008
3009   // devtool hook
3010   /* istanbul ignore if */
3011   if (devtools && config.devtools) {
3012     devtools.emit('flush');
3013   }
3014 }
3015
3016 function callUpdatedHooks (queue) {
3017   var i = queue.length;
3018   while (i--) {
3019     var watcher = queue[i];
3020     var vm = watcher.vm;
3021     if (vm._watcher === watcher && vm._isMounted) {
3022       callHook(vm, 'updated');
3023     }
3024   }
3025 }
3026
3027 /**
3028  * Queue a kept-alive component that was activated during patch.
3029  * The queue will be processed after the entire tree has been patched.
3030  */
3031 function queueActivatedComponent (vm) {
3032   // setting _inactive to false here so that a render function can
3033   // rely on checking whether it's in an inactive tree (e.g. router-view)
3034   vm._inactive = false;
3035   activatedChildren.push(vm);
3036 }
3037
3038 function callActivatedHooks (queue) {
3039   for (var i = 0; i < queue.length; i++) {
3040     queue[i]._inactive = true;
3041     activateChildComponent(queue[i], true /* true */);
3042   }
3043 }
3044
3045 /**
3046  * Push a watcher into the watcher queue.
3047  * Jobs with duplicate IDs will be skipped unless it's
3048  * pushed when the queue is being flushed.
3049  */
3050 function queueWatcher (watcher) {
3051   var id = watcher.id;
3052   if (has[id] == null) {
3053     has[id] = true;
3054     if (!flushing) {
3055       queue.push(watcher);
3056     } else {
3057       // if already flushing, splice the watcher based on its id
3058       // if already past its id, it will be run next immediately.
3059       var i = queue.length - 1;
3060       while (i > index && queue[i].id > watcher.id) {
3061         i--;
3062       }
3063       queue.splice(i + 1, 0, watcher);
3064     }
3065     // queue the flush
3066     if (!waiting) {
3067       waiting = true;
3068       nextTick(flushSchedulerQueue);
3069     }
3070   }
3071 }
3072
3073 /*  */
3074
3075 var uid$1 = 0;
3076
3077 /**
3078  * A watcher parses an expression, collects dependencies,
3079  * and fires callback when the expression value changes.
3080  * This is used for both the $watch() api and directives.
3081  */
3082 var Watcher = function Watcher (
3083   vm,
3084   expOrFn,
3085   cb,
3086   options,
3087   isRenderWatcher
3088 ) {
3089   this.vm = vm;
3090   if (isRenderWatcher) {
3091     vm._watcher = this;
3092   }
3093   vm._watchers.push(this);
3094   // options
3095   if (options) {
3096     this.deep = !!options.deep;
3097     this.user = !!options.user;
3098     this.lazy = !!options.lazy;
3099     this.sync = !!options.sync;
3100   } else {
3101     this.deep = this.user = this.lazy = this.sync = false;
3102   }
3103   this.cb = cb;
3104   this.id = ++uid$1; // uid for batching
3105   this.active = true;
3106   this.dirty = this.lazy; // for lazy watchers
3107   this.deps = [];
3108   this.newDeps = [];
3109   this.depIds = new _Set();
3110   this.newDepIds = new _Set();
3111   this.expression = expOrFn.toString();
3112   // parse expression for getter
3113   if (typeof expOrFn === 'function') {
3114     this.getter = expOrFn;
3115   } else {
3116     this.getter = parsePath(expOrFn);
3117     if (!this.getter) {
3118       this.getter = function () {};
3119       "development" !== 'production' && warn(
3120         "Failed watching path: \"" + expOrFn + "\" " +
3121         'Watcher only accepts simple dot-delimited paths. ' +
3122         'For full control, use a function instead.',
3123         vm
3124       );
3125     }
3126   }
3127   this.value = this.lazy
3128     ? undefined
3129     : this.get();
3130 };
3131
3132 /**
3133  * Evaluate the getter, and re-collect dependencies.
3134  */
3135 Watcher.prototype.get = function get () {
3136   pushTarget(this);
3137   var value;
3138   var vm = this.vm;
3139   try {
3140     value = this.getter.call(vm, vm);
3141   } catch (e) {
3142     if (this.user) {
3143       handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
3144     } else {
3145       throw e
3146     }
3147   } finally {
3148     // "touch" every property so they are all tracked as
3149     // dependencies for deep watching
3150     if (this.deep) {
3151       traverse(value);
3152     }
3153     popTarget();
3154     this.cleanupDeps();
3155   }
3156   return value
3157 };
3158
3159 /**
3160  * Add a dependency to this directive.
3161  */
3162 Watcher.prototype.addDep = function addDep (dep) {
3163   var id = dep.id;
3164   if (!this.newDepIds.has(id)) {
3165     this.newDepIds.add(id);
3166     this.newDeps.push(dep);
3167     if (!this.depIds.has(id)) {
3168       dep.addSub(this);
3169     }
3170   }
3171 };
3172
3173 /**
3174  * Clean up for dependency collection.
3175  */
3176 Watcher.prototype.cleanupDeps = function cleanupDeps () {
3177     var this$1 = this;
3178
3179   var i = this.deps.length;
3180   while (i--) {
3181     var dep = this$1.deps[i];
3182     if (!this$1.newDepIds.has(dep.id)) {
3183       dep.removeSub(this$1);
3184     }
3185   }
3186   var tmp = this.depIds;
3187   this.depIds = this.newDepIds;
3188   this.newDepIds = tmp;
3189   this.newDepIds.clear();
3190   tmp = this.deps;
3191   this.deps = this.newDeps;
3192   this.newDeps = tmp;
3193   this.newDeps.length = 0;
3194 };
3195
3196 /**
3197  * Subscriber interface.
3198  * Will be called when a dependency changes.
3199  */
3200 Watcher.prototype.update = function update () {
3201   /* istanbul ignore else */
3202   if (this.lazy) {
3203     this.dirty = true;
3204   } else if (this.sync) {
3205     this.run();
3206   } else {
3207     queueWatcher(this);
3208   }
3209 };
3210
3211 /**
3212  * Scheduler job interface.
3213  * Will be called by the scheduler.
3214  */
3215 Watcher.prototype.run = function run () {
3216   if (this.active) {
3217     var value = this.get();
3218     if (
3219       value !== this.value ||
3220       // Deep watchers and watchers on Object/Arrays should fire even
3221       // when the value is the same, because the value may
3222       // have mutated.
3223       isObject(value) ||
3224       this.deep
3225     ) {
3226       // set new value
3227       var oldValue = this.value;
3228       this.value = value;
3229       if (this.user) {
3230         try {
3231           this.cb.call(this.vm, value, oldValue);
3232         } catch (e) {
3233           handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
3234         }
3235       } else {
3236         this.cb.call(this.vm, value, oldValue);
3237       }
3238     }
3239   }
3240 };
3241
3242 /**
3243  * Evaluate the value of the watcher.
3244  * This only gets called for lazy watchers.
3245  */
3246 Watcher.prototype.evaluate = function evaluate () {
3247   this.value = this.get();
3248   this.dirty = false;
3249 };
3250
3251 /**
3252  * Depend on all deps collected by this watcher.
3253  */
3254 Watcher.prototype.depend = function depend () {
3255     var this$1 = this;
3256
3257   var i = this.deps.length;
3258   while (i--) {
3259     this$1.deps[i].depend();
3260   }
3261 };
3262
3263 /**
3264  * Remove self from all dependencies' subscriber list.
3265  */
3266 Watcher.prototype.teardown = function teardown () {
3267     var this$1 = this;
3268
3269   if (this.active) {
3270     // remove self from vm's watcher list
3271     // this is a somewhat expensive operation so we skip it
3272     // if the vm is being destroyed.
3273     if (!this.vm._isBeingDestroyed) {
3274       remove(this.vm._watchers, this);
3275     }
3276     var i = this.deps.length;
3277     while (i--) {
3278       this$1.deps[i].removeSub(this$1);
3279     }
3280     this.active = false;
3281   }
3282 };
3283
3284 /*  */
3285
3286 var sharedPropertyDefinition = {
3287   enumerable: true,
3288   configurable: true,
3289   get: noop,
3290   set: noop
3291 };
3292
3293 function proxy (target, sourceKey, key) {
3294   sharedPropertyDefinition.get = function proxyGetter () {
3295     return this[sourceKey][key]
3296   };
3297   sharedPropertyDefinition.set = function proxySetter (val) {
3298     this[sourceKey][key] = val;
3299   };
3300   Object.defineProperty(target, key, sharedPropertyDefinition);
3301 }
3302
3303 function initState (vm) {
3304   vm._watchers = [];
3305   var opts = vm.$options;
3306   if (opts.props) { initProps(vm, opts.props); }
3307   if (opts.methods) { initMethods(vm, opts.methods); }
3308   if (opts.data) {
3309     initData(vm);
3310   } else {
3311     observe(vm._data = {}, true /* asRootData */);
3312   }
3313   if (opts.computed) { initComputed(vm, opts.computed); }
3314   if (opts.watch && opts.watch !== nativeWatch) {
3315     initWatch(vm, opts.watch);
3316   }
3317 }
3318
3319 function initProps (vm, propsOptions) {
3320   var propsData = vm.$options.propsData || {};
3321   var props = vm._props = {};
3322   // cache prop keys so that future props updates can iterate using Array
3323   // instead of dynamic object key enumeration.
3324   var keys = vm.$options._propKeys = [];
3325   var isRoot = !vm.$parent;
3326   // root instance props should be converted
3327   if (!isRoot) {
3328     toggleObserving(false);
3329   }
3330   var loop = function ( key ) {
3331     keys.push(key);
3332     var value = validateProp(key, propsOptions, propsData, vm);
3333     /* istanbul ignore else */
3334     {
3335       var hyphenatedKey = hyphenate(key);
3336       if (isReservedAttribute(hyphenatedKey) ||
3337           config.isReservedAttr(hyphenatedKey)) {
3338         warn(
3339           ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),
3340           vm
3341         );
3342       }
3343       defineReactive(props, key, value, function () {
3344         if (vm.$parent && !isUpdatingChildComponent) {
3345           warn(
3346             "Avoid mutating a prop directly since the value will be " +
3347             "overwritten whenever the parent component re-renders. " +
3348             "Instead, use a data or computed property based on the prop's " +
3349             "value. Prop being mutated: \"" + key + "\"",
3350             vm
3351           );
3352         }
3353       });
3354     }
3355     // static props are already proxied on the component's prototype
3356     // during Vue.extend(). We only need to proxy props defined at
3357     // instantiation here.
3358     if (!(key in vm)) {
3359       proxy(vm, "_props", key);
3360     }
3361   };
3362
3363   for (var key in propsOptions) loop( key );
3364   toggleObserving(true);
3365 }
3366
3367 function initData (vm) {
3368   var data = vm.$options.data;
3369   data = vm._data = typeof data === 'function'
3370     ? getData(data, vm)
3371     : data || {};
3372   if (!isPlainObject(data)) {
3373     data = {};
3374     "development" !== 'production' && warn(
3375       'data functions should return an object:\n' +
3376       'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
3377       vm
3378     );
3379   }
3380   // proxy data on instance
3381   var keys = Object.keys(data);
3382   var props = vm.$options.props;
3383   var methods = vm.$options.methods;
3384   var i = keys.length;
3385   while (i--) {
3386     var key = keys[i];
3387     {
3388       if (methods && hasOwn(methods, key)) {
3389         warn(
3390           ("Method \"" + key + "\" has already been defined as a data property."),
3391           vm
3392         );
3393       }
3394     }
3395     if (props && hasOwn(props, key)) {
3396       "development" !== 'production' && warn(
3397         "The data property \"" + key + "\" is already declared as a prop. " +
3398         "Use prop default value instead.",
3399         vm
3400       );
3401     } else if (!isReserved(key)) {
3402       proxy(vm, "_data", key);
3403     }
3404   }
3405   // observe data
3406   observe(data, true /* asRootData */);
3407 }
3408
3409 function getData (data, vm) {
3410   // #7573 disable dep collection when invoking data getters
3411   pushTarget();
3412   try {
3413     return data.call(vm, vm)
3414   } catch (e) {
3415     handleError(e, vm, "data()");
3416     return {}
3417   } finally {
3418     popTarget();
3419   }
3420 }
3421
3422 var computedWatcherOptions = { lazy: true };
3423
3424 function initComputed (vm, computed) {
3425   // $flow-disable-line
3426   var watchers = vm._computedWatchers = Object.create(null);
3427   // computed properties are just getters during SSR
3428   var isSSR = isServerRendering();
3429
3430   for (var key in computed) {
3431     var userDef = computed[key];
3432     var getter = typeof userDef === 'function' ? userDef : userDef.get;
3433     if ("development" !== 'production' && getter == null) {
3434       warn(
3435         ("Getter is missing for computed property \"" + key + "\"."),
3436         vm
3437       );
3438     }
3439
3440     if (!isSSR) {
3441       // create internal watcher for the computed property.
3442       watchers[key] = new Watcher(
3443         vm,
3444         getter || noop,
3445         noop,
3446         computedWatcherOptions
3447       );
3448     }
3449
3450     // component-defined computed properties are already defined on the
3451     // component prototype. We only need to define computed properties defined
3452     // at instantiation here.
3453     if (!(key in vm)) {
3454       defineComputed(vm, key, userDef);
3455     } else {
3456       if (key in vm.$data) {
3457         warn(("The computed property \"" + key + "\" is already defined in data."), vm);
3458       } else if (vm.$options.props && key in vm.$options.props) {
3459         warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
3460       }
3461     }
3462   }
3463 }
3464
3465 function defineComputed (
3466   target,
3467   key,
3468   userDef
3469 ) {
3470   var shouldCache = !isServerRendering();
3471   if (typeof userDef === 'function') {
3472     sharedPropertyDefinition.get = shouldCache
3473       ? createComputedGetter(key)
3474       : userDef;
3475     sharedPropertyDefinition.set = noop;
3476   } else {
3477     sharedPropertyDefinition.get = userDef.get
3478       ? shouldCache && userDef.cache !== false
3479         ? createComputedGetter(key)
3480         : userDef.get
3481       : noop;
3482     sharedPropertyDefinition.set = userDef.set
3483       ? userDef.set
3484       : noop;
3485   }
3486   if ("development" !== 'production' &&
3487       sharedPropertyDefinition.set === noop) {
3488     sharedPropertyDefinition.set = function () {
3489       warn(
3490         ("Computed property \"" + key + "\" was assigned to but it has no setter."),
3491         this
3492       );
3493     };
3494   }
3495   Object.defineProperty(target, key, sharedPropertyDefinition);
3496 }
3497
3498 function createComputedGetter (key) {
3499   return function computedGetter () {
3500     var watcher = this._computedWatchers && this._computedWatchers[key];
3501     if (watcher) {
3502       if (watcher.dirty) {
3503         watcher.evaluate();
3504       }
3505       if (Dep.target) {
3506         watcher.depend();
3507       }
3508       return watcher.value
3509     }
3510   }
3511 }
3512
3513 function initMethods (vm, methods) {
3514   var props = vm.$options.props;
3515   for (var key in methods) {
3516     {
3517       if (methods[key] == null) {
3518         warn(
3519           "Method \"" + key + "\" has an undefined value in the component definition. " +
3520           "Did you reference the function correctly?",
3521           vm
3522         );
3523       }
3524       if (props && hasOwn(props, key)) {
3525         warn(
3526           ("Method \"" + key + "\" has already been defined as a prop."),
3527           vm
3528         );
3529       }
3530       if ((key in vm) && isReserved(key)) {
3531         warn(
3532           "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
3533           "Avoid defining component methods that start with _ or $."
3534         );
3535       }
3536     }
3537     vm[key] = methods[key] == null ? noop : bind(methods[key], vm);
3538   }
3539 }
3540
3541 function initWatch (vm, watch) {
3542   for (var key in watch) {
3543     var handler = watch[key];
3544     if (Array.isArray(handler)) {
3545       for (var i = 0; i < handler.length; i++) {
3546         createWatcher(vm, key, handler[i]);
3547       }
3548     } else {
3549       createWatcher(vm, key, handler);
3550     }
3551   }
3552 }
3553
3554 function createWatcher (
3555   vm,
3556   expOrFn,
3557   handler,
3558   options
3559 ) {
3560   if (isPlainObject(handler)) {
3561     options = handler;
3562     handler = handler.handler;
3563   }
3564   if (typeof handler === 'string') {
3565     handler = vm[handler];
3566   }
3567   return vm.$watch(expOrFn, handler, options)
3568 }
3569
3570 function stateMixin (Vue) {
3571   // flow somehow has problems with directly declared definition object
3572   // when using Object.defineProperty, so we have to procedurally build up
3573   // the object here.
3574   var dataDef = {};
3575   dataDef.get = function () { return this._data };
3576   var propsDef = {};
3577   propsDef.get = function () { return this._props };
3578   {
3579     dataDef.set = function (newData) {
3580       warn(
3581         'Avoid replacing instance root $data. ' +
3582         'Use nested data properties instead.',
3583         this
3584       );
3585     };
3586     propsDef.set = function () {
3587       warn("$props is readonly.", this);
3588     };
3589   }
3590   Object.defineProperty(Vue.prototype, '$data', dataDef);
3591   Object.defineProperty(Vue.prototype, '$props', propsDef);
3592
3593   Vue.prototype.$set = set;
3594   Vue.prototype.$delete = del;
3595
3596   Vue.prototype.$watch = function (
3597     expOrFn,
3598     cb,
3599     options
3600   ) {
3601     var vm = this;
3602     if (isPlainObject(cb)) {
3603       return createWatcher(vm, expOrFn, cb, options)
3604     }
3605     options = options || {};
3606     options.user = true;
3607     var watcher = new Watcher(vm, expOrFn, cb, options);
3608     if (options.immediate) {
3609       cb.call(vm, watcher.value);
3610     }
3611     return function unwatchFn () {
3612       watcher.teardown();
3613     }
3614   };
3615 }
3616
3617 /*  */
3618
3619 function initProvide (vm) {
3620   var provide = vm.$options.provide;
3621   if (provide) {
3622     vm._provided = typeof provide === 'function'
3623       ? provide.call(vm)
3624       : provide;
3625   }
3626 }
3627
3628 function initInjections (vm) {
3629   var result = resolveInject(vm.$options.inject, vm);
3630   if (result) {
3631     toggleObserving(false);
3632     Object.keys(result).forEach(function (key) {
3633       /* istanbul ignore else */
3634       {
3635         defineReactive(vm, key, result[key], function () {
3636           warn(
3637             "Avoid mutating an injected value directly since the changes will be " +
3638             "overwritten whenever the provided component re-renders. " +
3639             "injection being mutated: \"" + key + "\"",
3640             vm
3641           );
3642         });
3643       }
3644     });
3645     toggleObserving(true);
3646   }
3647 }
3648
3649 function resolveInject (inject, vm) {
3650   if (inject) {
3651     // inject is :any because flow is not smart enough to figure out cached
3652     var result = Object.create(null);
3653     var keys = hasSymbol
3654       ? Reflect.ownKeys(inject).filter(function (key) {
3655         /* istanbul ignore next */
3656         return Object.getOwnPropertyDescriptor(inject, key).enumerable
3657       })
3658       : Object.keys(inject);
3659
3660     for (var i = 0; i < keys.length; i++) {
3661       var key = keys[i];
3662       var provideKey = inject[key].from;
3663       var source = vm;
3664       while (source) {
3665         if (source._provided && hasOwn(source._provided, provideKey)) {
3666           result[key] = source._provided[provideKey];
3667           break
3668         }
3669         source = source.$parent;
3670       }
3671       if (!source) {
3672         if ('default' in inject[key]) {
3673           var provideDefault = inject[key].default;
3674           result[key] = typeof provideDefault === 'function'