https://visitbusan.net/js/vue.js;jsessionid=C91B3ABAD90AA76EB8A2B0E5BA2804DC

1/*!
2 * Vue.js v2.5.13
3 * (c) 2014-2017 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
14var emptyObject = Object.freeze({});
15
16// these helpers produces better vm code in JS engines due to their
17// explicitness and function inlining
18function isUndef (v) {
19  return v === undefined || v === null
20}
21
22function isDef (v) {
23  return v !== undefined && v !== null
24}
25
26function isTrue (v) {
27  return v === true
28}
29
30function isFalse (v) {
31  return v === false
32}
33
34/**
35 * Check if value is primitive
36 */
37function 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 */
52function 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 */
59var _toString = Object.prototype.toString;
60
61function 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 */
69function isPlainObject (obj) {
70  return _toString.call(obj) === '[object Object]'
71}
72
73function isRegExp (v) {
74  return _toString.call(v) === '[object RegExp]'
75}
76
77/**
78 * Check if val is a valid array index.
79 */
80function 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 */
88function 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 */
100function 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 */
109function 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 */
126var isBuiltInTag = makeMap('slot,component', true);
127
128/**
129 * Check if a attribute is a reserved attribute.
130 */
131var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
132
133/**
134 * Remove an item from an array
135 */
136function 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 */
148var hasOwnProperty = Object.prototype.hasOwnProperty;
149function hasOwn (obj, key) {
150  return hasOwnProperty.call(obj, key)
151}
152
153/**
154 * Create a cached version of a pure function.
155 */
156function 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 */
167var camelizeRE = /-(\w)/g;
168var camelize = cached(function (str) {
169  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
170});
171
172/**
173 * Capitalize a string.
174 */
175var capitalize = cached(function (str) {
176  return str.charAt(0).toUpperCase() + str.slice(1)
177});
178
179/**
180 * Hyphenate a camelCase string.
181 */
182var hyphenateRE = /\B([A-Z])/g;
183var hyphenate = cached(function (str) {
184  return str.replace(hyphenateRE, '-$1').toLowerCase()
185});
186
187/**
188 * Simple bind, faster than native
189 */
190function bind (fn, ctx) {
191  function boundFn (a) {
192    var l = arguments.length;
193    return l
194      ? l > 1
195        ? fn.apply(ctx, arguments)
196        : fn.call(ctx, a)
197      : fn.call(ctx)
198  }
199  // record original fn length
200  boundFn._length = fn.length;
201  return boundFn
202}
203
204/**
205 * Convert an Array-like object to a real Array.
206 */
207function toArray (list, start) {
208  start = start || 0;
209  var i = list.length - start;
210  var ret = new Array(i);
211  while (i--) {
212    ret[i] = list[i + start];
213  }
214  return ret
215}
216
217/**
218 * Mix properties into target object.
219 */
220function extend (to, _from) {
221  for (var key in _from) {
222    to[key] = _from[key];
223  }
224  return to
225}
226
227/**
228 * Merge an Array of Objects into a single Object.
229 */
230function toObject (arr) {
231  var res = {};
232  for (var i = 0; i < arr.length; i++) {
233    if (arr[i]) {
234      extend(res, arr[i]);
235    }
236  }
237  return res
238}
239
240/**
241 * Perform no operation.
242 * Stubbing args to make Flow happy without leaving useless transpiled code
243 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)
244 */
245function noop (a, b, c) {}
246
247/**
248 * Always return false.
249 */
250var no = function (a, b, c) { return false; };
251
252/**
253 * Return same value
254 */
255var identity = function (_) { return _; };
256
257/**
258 * Generate a static keys string from compiler modules.
259 */
260function genStaticKeys (modules) {
261  return modules.reduce(function (keys, m) {
262    return keys.concat(m.staticKeys || [])
263  }, []).join(',')
264}
265
266/**
267 * Check if two values are loosely equal - that is,
268 * if they are plain objects, do they have the same shape?
269 */
270function looseEqual (a, b) {
271  if (a === b) { return true }
272  var isObjectA = isObject(a);
273  var isObjectB = isObject(b);
274  if (isObjectA && isObjectB) {
275    try {
276      var isArrayA = Array.isArray(a);
277      var isArrayB = Array.isArray(b);
278      if (isArrayA && isArrayB) {
279        return a.length === b.length && a.every(function (e, i) {
280          return looseEqual(e, b[i])
281        })
282      } else if (!isArrayA && !isArrayB) {
283        var keysA = Object.keys(a);
284        var keysB = Object.keys(b);
285        return keysA.length === keysB.length && keysA.every(function (key) {
286          return looseEqual(a[key], b[key])
287        })
288      } else {
289        /* istanbul ignore next */
290        return false
291      }
292    } catch (e) {
293      /* istanbul ignore next */
294      return false
295    }
296  } else if (!isObjectA && !isObjectB) {
297    return String(a) === String(b)
298  } else {
299    return false
300  }
301}
302
303function looseIndexOf (arr, val) {
304  for (var i = 0; i < arr.length; i++) {
305    if (looseEqual(arr[i], val)) { return i }
306  }
307  return -1
308}
309
310/**
311 * Ensure a function is called only once.
312 */
313function once (fn) {
314  var called = false;
315  return function () {
316    if (!called) {
317      called = true;
318      fn.apply(this, arguments);
319    }
320  }
321}
322
323var SSR_ATTR = 'data-server-rendered';
324
325var ASSET_TYPES = [
326  'component',
327  'directive',
328  'filter'
329];
330
331var LIFECYCLE_HOOKS = [
332  'beforeCreate',
333  'created',
334  'beforeMount',
335  'mounted',
336  'beforeUpdate',
337  'updated',
338  'beforeDestroy',
339  'destroyed',
340  'activated',
341  'deactivated',
342  'errorCaptured'
343];
344
345/*  */
346
347var config = ({
348  /**
349   * Option merge strategies (used in core/util/options)
350   */
351  // $flow-disable-line
352  optionMergeStrategies: Object.create(null),
353
354  /**
355   * Whether to suppress warnings.
356   */
357  silent: false,
358
359  /**
360   * Show production mode tip message on boot?
361   */
362  productionTip: "development" !== 'production',
363
364  /**
365   * Whether to enable devtools
366   */
367  devtools: "development" !== 'production',
368
369  /**
370   * Whether to record perf
371   */
372  performance: false,
373
374  /**
375   * Error handler for watcher errors
376   */
377  errorHandler: null,
378
379  /**
380   * Warn handler for watcher warns
381   */
382  warnHandler: null,
383
384  /**
385   * Ignore certain custom elements
386   */
387  ignoredElements: [],
388
389  /**
390   * Custom user key aliases for v-on
391   */
392  // $flow-disable-line
393  keyCodes: Object.create(null),
394
395  /**
396   * Check if a tag is reserved so that it cannot be registered as a
397   * component. This is platform-dependent and may be overwritten.
398   */
399  isReservedTag: no,
400
401  /**
402   * Check if an attribute is reserved so that it cannot be used as a component
403   * prop. This is platform-dependent and may be overwritten.
404   */
405  isReservedAttr: no,
406
407  /**
408   * Check if a tag is an unknown element.
409   * Platform-dependent.
410   */
411  isUnknownElement: no,
412
413  /**
414   * Get the namespace of an element
415   */
416  getTagNamespace: noop,
417
418  /**
419   * Parse the real tag name for the specific platform.
420   */
421  parsePlatformTagName: identity,
422
423  /**
424   * Check if an attribute must be bound using property, e.g. value
425   * Platform-dependent.
426   */
427  mustUseProp: no,
428
429  /**
430   * Exposed for legacy reasons
431   */
432  _lifecycleHooks: LIFECYCLE_HOOKS
433});
434
435/*  */
436
437/**
438 * Check if a string starts with $ or _
439 */
440function isReserved (str) {
441  var c = (str + '').charCodeAt(0);
442  return c === 0x24 || c === 0x5F
443}
444
445/**
446 * Define a property.
447 */
448function def (obj, key, val, enumerable) {
449  Object.defineProperty(obj, key, {
450    value: val,
451    enumerable: !!enumerable,
452    writable: true,
453    configurable: true
454  });
455}
456
457/**
458 * Parse simple path.
459 */
460var bailRE = /[^\w.$]/;
461function parsePath (path) {
462  if (bailRE.test(path)) {
463    return
464  }
465  var segments = path.split('.');
466  return function (obj) {
467    for (var i = 0; i < segments.length; i++) {
468      if (!obj) { return }
469      obj = obj[segments[i]];
470    }
471    return obj
472  }
473}
474
475/*  */
476
477
478// can we use __proto__?
479var hasProto = '__proto__' in {};
480
481// Browser environment sniffing
482var inBrowser = typeof window !== 'undefined';
483var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
484var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
485var UA = inBrowser && window.navigator.userAgent.toLowerCase();
486var isIE = UA && /msie|trident/.test(UA);
487var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
488var isEdge = UA && UA.indexOf('edge/') > 0;
489var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
490var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
491var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
492
493// Firefox has a "watch" function on Object.prototype...
494var nativeWatch = ({}).watch;
495
496var supportsPassive = false;
497if (inBrowser) {
498  try {
499    var opts = {};
500    Object.defineProperty(opts, 'passive', ({
501      get: function get () {
502        /* istanbul ignore next */
503        supportsPassive = true;
504      }
505    })); // https://github.com/facebook/flow/issues/285
506    window.addEventListener('test-passive', null, opts);
507  } catch (e) {}
508}
509
510// this needs to be lazy-evaled because vue may be required before
511// vue-server-renderer can set VUE_ENV
512var _isServer;
513var isServerRendering = function () {
514  if (_isServer === undefined) {
515    /* istanbul ignore if */
516    if (!inBrowser && typeof global !== 'undefined') {
517      // detect presence of vue-server-renderer and avoid
518      // Webpack shimming the process
519      _isServer = global['process'].env.VUE_ENV === 'server';
520    } else {
521      _isServer = false;

522    }
523  }
524  return _isServer
525};
526
527// detect devtools
528var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
529
530/* istanbul ignore next */
531function isNative (Ctor) {
532  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
533}
534
535var hasSymbol =
536  typeof Symbol !== 'undefined' && isNative(Symbol) &&
537  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
538
539var _Set;
540/* istanbul ignore if */ // $flow-disable-line
541if (typeof Set !== 'undefined' && isNative(Set)) {
542  // use native Set when available.
543  _Set = Set;
544} else {
545  // a non-standard Set polyfill that only works with primitive keys.
546  _Set = (function () {
547    function Set () {
548      this.set = Object.create(null);
549    }
550    Set.prototype.has = function has (key) {
551      return this.set[key] === true
552    };
553    Set.prototype.add = function add (key) {
554      this.set[key] = true;
555    };
556    Set.prototype.clear = function clear () {
557      this.set = Object.create(null);
558    };
559
560    return Set;
561  }());
562}
563
564/*  */
565
566var warn = noop;
567var tip = noop;
568var generateComponentTrace = (noop); // work around flow check
569var formatComponentName = (noop);
570
571{
572  var hasConsole = typeof console !== 'undefined';
573  var classifyRE = /(?:^|[-_])(\w)/g;
574  var classify = function (str) { return str
575    .replace(classifyRE, function (c) { return c.toUpperCase(); })
576    .replace(/[-_]/g, ''); };
577
578  warn = function (msg, vm) {
579    var trace = vm ? generateComponentTrace(vm) : '';
580
581    if (config.warnHandler) {
582      config.warnHandler.call(null, msg, vm, trace);
583    } else if (hasConsole && (!config.silent)) {
584      console.error(("[Vue warn]: " + msg + trace));
585    }
586  };
587
588  tip = function (msg, vm) {
589    if (hasConsole && (!config.silent)) {
590      console.warn("[Vue tip]: " + msg + (
591        vm ? generateComponentTrace(vm) : ''
592      ));
593    }
594  };
595
596  formatComponentName = function (vm, includeFile) {
597    if (vm.$root === vm) {
598      return '<Root>'
599    }
600    var options = typeof vm === 'function' && vm.cid != null
601      ? vm.options
602      : vm._isVue
603        ? vm.$options || vm.constructor.options
604        : vm || {};
605    var name = options.name || options._componentTag;
606    var file = options.__file;
607    if (!name && file) {
608      var match = file.match(/([^/\\]+)\.vue$/);
609      name = match && match[1];
610    }
611
612    return (
613      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
614      (file && includeFile !== false ? (" at " + file) : '')
615    )
616  };
617
618  var repeat = function (str, n) {
619    var res = '';
620    while (n) {
621      if (n % 2 === 1) { res += str; }
622      if (n > 1) { str += str; }
623      n >>= 1;
624    }
625    return res
626  };
627
628  generateComponentTrace = function (vm) {
629    if (vm._isVue && vm.$parent) {
630      var tree = [];
631      var currentRecursiveSequence = 0;
632      while (vm) {
633        if (tree.length > 0) {
634          var last = tree[tree.length - 1];
635          if (last.constructor === vm.constructor) {
636            currentRecursiveSequence++;
637            vm = vm.$parent;
638            continue
639          } else if (currentRecursiveSequence > 0) {
640            tree[tree.length - 1] = [last, currentRecursiveSequence];
641            currentRecursiveSequence = 0;
642          }
643        }
644        tree.push(vm);
645        vm = vm.$parent;
646      }
647      return '\n\nfound in\n\n' + tree
648        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
649            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
650            : formatComponentName(vm))); })
651        .join('\n')
652    } else {
653      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
654    }
655  };
656}
657
658/*  */
659
660
661var uid = 0;
662
663/**
664 * A dep is an observable that can have multiple
665 * directives subscribing to it.
666 */
667var Dep = function Dep () {
668  this.id = uid++;
669  this.subs = [];
670};
671
672Dep.prototype.addSub = function addSub (sub) {
673  this.subs.push(sub);
674};
675
676Dep.prototype.removeSub = function removeSub (sub) {
677  remove(this.subs, sub);
678};
679
680Dep.prototype.depend = function depend () {
681  if (Dep.target) {
682    Dep.target.addDep(this);
683  }
684};
685
686Dep.prototype.notify = function notify () {
687  // stabilize the subscriber list first
688  var subs = this.subs.slice();
689  for (var i = 0, l = subs.length; i < l; i++) {
690    subs[i].update();
691  }
692};
693
694// the current target watcher being evaluated.
695// this is globally unique because there could be only one
696// watcher being evaluated at any time.
697Dep.target = null;
698var targetStack = [];
699
700function pushTarget (_target) {
701  if (Dep.target) { targetStack.push(Dep.target); }
702  Dep.target = _target;
703}
704
705function popTarget () {
706  Dep.target = targetStack.pop();
707}
708
709/*  */
710
711var VNode = function VNode (
712  tag,
713  data,
714  children,
715  text,
716  elm,
717  context,
718  componentOptions,
719  asyncFactory
720) {
721  this.tag = tag;
722  this.data = data;
723  this.children = children;
724  this.text = text;
725  this.elm = elm;
726  this.ns = undefined;
727  this.context = context;
728  this.fnContext = undefined;
729  this.fnOptions = undefined;
730  this.fnScopeId = undefined;
731  this.key = data && data.key;
732  this.componentOptions = componentOptions;
733  this.componentInstance = undefined;
734  this.parent = undefined;
735  this.raw = false;
736  this.isStatic = false;
737  this.isRootInsert = true;
738  this.isComment = false;
739  this.isCloned = false;
740  this.isOnce = false;
741  this.asyncFactory = asyncFactory;
742  this.asyncMeta = undefined;
743  this.isAsyncPlaceholder = false;
744};
745
746var prototypeAccessors = { child: { configurable: true } };
747
748// DEPRECATED: alias for componentInstance for backwards compat.
749/* istanbul ignore next */
750prototypeAccessors.child.get = function () {
751  return this.componentInstance
752};
753
754Object.defineProperties( VNode.prototype, prototypeAccessors );
755
756var createEmptyVNode = function (text) {
757  if ( text === void 0 ) text = '';
758
759  var node = new VNode();
760  node.text = text;
761  node.isComment = true;
762  return node
763};
764
765function createTextVNode (val) {
766  return new VNode(undefined, undefined, undefined, String(val))
767}
768
769// optimized shallow clone
770// used for static nodes and slot nodes because they may be reused across
771// multiple renders, cloning them avoids errors when DOM manipulations rely
772// on their elm reference.
773function cloneVNode (vnode, deep) {
774  var componentOptions = vnode.componentOptions;
775  var cloned = new VNode(
776    vnode.tag,
777    vnode.data,
778    vnode.children,
779    vnode.text,
780    vnode.elm,
781    vnode.context,
782    componentOptions,
783    vnode.asyncFactory
784  );
785  cloned.ns = vnode.ns;
786  cloned.isStatic = vnode.isStatic;
787  cloned.key = vnode.key;
788  cloned.isComment = vnode.isComment;
789  cloned.fnContext = vnode.fnContext;
790  cloned.fnOptions = vnode.fnOptions;
791  cloned.fnScopeId = vnode.fnScopeId;
792  cloned.isCloned = true;
793  if (deep) {
794    if (vnode.children) {
795      cloned.children = cloneVNodes(vnode.children, true);
796    }
797    if (componentOptions && componentOptions.children) {
798      componentOptions.children = cloneVNodes(componentOptions.children, true);
799    }
800  }
801  return cloned
802}
803
804function cloneVNodes (vnodes, deep) {
805  var len = vnodes.length;
806  var res = new Array(len);
807  for (var i = 0; i < len; i++) {
808    res[i] = cloneVNode(vnodes[i], deep);
809  }
810  return res
811}
812
813/*
814 * not type checking this file because flow doesn't play well with
815 * dynamically accessing methods on Array prototype
816 */
817
818var arrayProto = Array.prototype;
819var arrayMethods = Object.create(arrayProto);[
820  'push',
821  'pop',
822  'shift',
823  'unshift',
824  'splice',
825  'sort',
826  'reverse'
827].forEach(function (method) {
828  // cache original method
829  var original = arrayProto[method];
830  def(arrayMethods, method, function mutator () {
831    var args = [], len = arguments.length;
832    while ( len-- ) args[ len ] = arguments[ len ];
833
834    var result = original.apply(this, args);
835    var ob = this.__ob__;
836    var inserted;
837    switch (method) {
838      case 'push':
839      case 'unshift':
840        inserted = args;
841        break
842      case 'splice':
843        inserted = args.slice(2);
844        break
845    }
846    if (inserted) { ob.observeArray(inserted); }
847    // notify change
848    ob.dep.notify();
849    return result
850  });
851});
852
853/*  */
854
855var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
856
857/**
858 * By default, when a reactive property is set, the new value is
859 * also converted to become reactive. However when passing down props,
860 * we don't want to force conversion because the value may be a nested value
861 * under a frozen data structure. Converting it would defeat the optimization.
862 */
863var observerState = {
864  shouldConvert: true
865};
866
867/**
868 * Observer class that are attached to each observed
869 * object. Once attached, the observer converts target
870 * object's property keys into getter/setters that
871 * collect dependencies and dispatches updates.
872 */
873var Observer = function Observer (value) {
874  this.value = value;
875  this.dep = new Dep();
876  this.vmCount = 0;
877  def(value, '__ob__', this);
878  if (Array.isArray(value)) {
879    var augment = hasProto
880      ? protoAugment
881      : copyAugment;
882    augment(value, arrayMethods, arrayKeys);
883    this.observeArray(value);
884  } else {
885    this.walk(value);
886  }
887};
888
889/**
890 * Walk through each property and convert them into
891 * getter/setters. This method should only be called when
892 * value type is Object.
893 */
894Observer.prototype.walk = function walk (obj) {
895  var keys = Object.keys(obj);
896  for (var i = 0; i < keys.length; i++) {
897    defineReactive(obj, keys[i], obj[keys[i]]);
898  }
899};
900
901/**
902 * Observe a list of Array items.
903 */
904Observer.prototype.observeArray = function observeArray (items) {
905  for (var i = 0, l = items.length; i < l; i++) {
906    observe(items[i]);
907  }
908};
909
910// helpers
911
912/**
913 * Augment an target Object or Array by intercepting
914 * the prototype chain using __proto__
915 */
916function protoAugment (target, src, keys) {
917  /* eslint-disable no-proto */
918  target.__proto__ = src;
919  /* eslint-enable no-proto */
920}
921
922/**
923 * Augment an target Object or Array by defining
924 * hidden properties.
925 */
926/* istanbul ignore next */
927function copyAugment (target, src, keys) {
928  for (var i = 0, l = keys.length; i < l; i++) {
929    var key = keys[i];
930    def(target, key, src[key]);
931  }
932}
933
934/**
935 * Attempt to create an observer instance for a value,
936 * returns the new observer if successfully observed,
937 * or the existing observer if the value already has one.
938 */
939function observe (value, asRootData) {
940  if (!isObject(value) || value instanceof VNode) {
941    return
942  }
943  var ob;
944  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
945    ob = value.__ob__;
946  } else if (
947    observerState.shouldConvert &&
948    !isServerRendering() &&
949    (Array.isArray(value) || isPlainObject(value)) &&
950    Object.isExtensible(value) &&
951    !value._isVue
952  ) {
953    ob = new Observer(value);
954  }
955  if (asRootData && ob) {
956    ob.vmCount++;
957  }
958  return ob
959}
960
961/**
962 * Define a reactive property on an Object.
963 */
964function defineReactive (
965  obj,
966  key,
967  val,
968  customSetter,
969  shallow
970) {
971  var dep = new Dep();
972
973  var property = Object.getOwnPropertyDescriptor(obj, key);
974  if (property && property.configurable === false) {
975    return
976  }
977
978  // cater for pre-defined getter/setters
979  var getter = property && property.get;
980  var setter = property && property.set;
981
982  var childOb = !shallow && observe(val);
983  Object.defineProperty(obj, key, {
984    enumerable: true,
985    configurable: true,
986    get: function reactiveGetter () {
987      var value = getter ? getter.call(obj) : val;
988      if (Dep.target) {
989        dep.depend();
990        if (childOb) {
991          childOb.dep.depend();
992          if (Array.isArray(value)) {
993            dependArray(value);
994          }
995        }
996      }
997      return value
998    },
999    set: function reactiveSetter (newVal) {
1000      var value = getter ? getter.call(obj) : val;
1001      /* eslint-disable no-self-compare */
1002      if (newVal === value || (newVal !== newVal && value !== value)) {
1003        return
1004      }
1005      /* eslint-enable no-self-compare */
1006      if ("development" !== 'production' && customSetter) {
1007        customSetter();
1008      }
1009      if (setter) {
1010        setter.call(obj, newVal);
1011      } else {
1012        val = newVal;
1013      }
1014      childOb = !shallow && observe(newVal);
1015      dep.notify();
1016    }
1017  });
1018}
1019
1020/**
1021 * Set a property on an object. Adds the new property and
1022 * triggers change notification if the property doesn't
1023 * already exist.
1024 */
1025function set (target, key, val) {
1026  if (Array.isArray(target) && isValidArrayIndex(key)) {
1027    target.length = Math.max(target.length, key);
1028    target.splice(key, 1, val);
1029    return val
1030  }
1031  if (key in target && !(key in Object.prototype)) {
1032    target[key] = val;
1033    return val
1034  }
1035  var ob = (target).__ob__;
1036  if (target._isVue || (ob && ob.vmCount)) {
1037    "development" !== 'production' && warn(
1038      'Avoid adding reactive properties to a Vue instance or its root $data ' +
1039      'at runtime - declare it upfront in the data option.'
1040    );
1041    return val
1042  }
1043  if (!ob) {
1044    target[key] = val;
1045    return val
1046  }
1047  defineReactive(ob.value, key, val);
1048  ob.dep.notify();
1049  return val
1050}
1051
1052/**
1053 * Delete a property and trigger change if necessary.
1054 */
1055function del (target, key) {
1056  if (Array.isArray(target) && isValidArrayIndex(key)) {
1057    target.splice(key, 1);
1058    return
1059  }
1060  var ob = (target).__ob__;
1061  if (target._isVue || (ob && ob.vmCount)) {
1062    "development" !== 'production' && warn(
1063      'Avoid deleting properties on a Vue instance or its root $data ' +
1064      '- just set it to null.'
1065    );
1066    return
1067  }
1068  if (!hasOwn(target, key)) {
1069    return
1070  }
1071  delete target[key];
1072  if (!ob) {
1073    return
1074  }
1075  ob.dep.notify();
1076}
1077
1078/**
1079 * Collect dependencies on array elements when the array is touched, since
1080 * we cannot intercept array element access like property getters.
1081 */
1082function dependArray (value) {
1083  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
1084    e = value[i];
1085    e && e.__ob__ && e.__ob__.dep.depend();
1086    if (Array.isArray(e)) {
1087      dependArray(e);
1088    }
1089  }
1090}
1091
1092/*  */
1093
1094/**
1095 * Option overwriting strategies are functions that handle
1096 * how to merge a parent option value and a child option
1097 * value into the final value.
1098 */
1099var strats = config.optionMergeStrategies;
1100
1101/**
1102 * Options with restrictions
1103 */
1104{
1105  strats.el = strats.propsData = function (parent, child, vm, key) {
1106    if (!vm) {
1107      warn(
1108        "option \"" + key + "\" can only be used during instance " +
1109        'creation with the `new` keyword.'
1110      );
1111    }
1112    return defaultStrat(parent, child)
1113  };
1114}
1115
1116/**
1117 * Helper that recursively merges two data objects together.
1118 */
1119function mergeData (to, from) {
1120  if (!from) { return to }
1121  var key, toVal, fromVal;
1122  var keys = Object.keys(from);
1123  for (var i = 0; i < keys.length; i++) {
1124    key = keys[i];
1125    toVal = to[key];
1126    fromVal = from[key];
1127    if (!hasOwn(to, key)) {
1128      set(to, key, fromVal);
1129    } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {
1130      mergeData(toVal, fromVal);
1131    }
1132  }
1133  return to
1134}
1135
1136/**
1137 * Data
1138 */
1139function mergeDataOrFn (
1140  parentVal,
1141  childVal,
1142  vm
1143) {
1144  if (!vm) {

1145    // in a Vue.extend merge, both should be functions
1146    if (!childVal) {
1147      return parentVal
1148    }
1149    if (!parentVal) {
1150      return childVal
1151    }
1152    // when parentVal & childVal are both present,
1153    // we need to return a function that returns the
1154    // merged result of both functions... no need to
1155    // check if parentVal is a function here because
1156    // it has to be a function to pass previous merges.
1157    return function mergedDataFn () {
1158      return mergeData(
1159        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
1160        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
1161      )
1162    }
1163  } else {
1164    return function mergedInstanceDataFn () {
1165      // instance merge
1166      var instanceData = typeof childVal === 'function'
1167        ? childVal.call(vm, vm)
1168        : childVal;
1169      var defaultData = typeof parentVal === 'function'
1170        ? parentVal.call(vm, vm)
1171        : parentVal;
1172      if (instanceData) {
1173        return mergeData(instanceData, defaultData)
1174      } else {
1175        return defaultData
1176      }
1177    }
1178  }
1179}
1180
1181strats.data = function (
1182  parentVal,
1183  childVal,
1184  vm
1185) {
1186  if (!vm) {
1187    if (childVal && typeof childVal !== 'function') {
1188      "development" !== 'production' && warn(
1189        'The "data" option should be a function ' +
1190        'that returns a per-instance value in component ' +
1191        'definitions.',
1192        vm
1193      );
1194
1195      return parentVal
1196    }
1197    return mergeDataOrFn(parentVal, childVal)
1198  }
1199
1200  return mergeDataOrFn(parentVal, childVal, vm)
1201};
1202
1203/**
1204 * Hooks and props are merged as arrays.
1205 */
1206function mergeHook (
1207  parentVal,
1208  childVal
1209) {
1210  return childVal
1211    ? parentVal
1212      ? parentVal.concat(childVal)
1213      : Array.isArray(childVal)
1214        ? childVal
1215        : [childVal]
1216    : parentVal
1217}
1218
1219LIFECYCLE_HOOKS.forEach(function (hook) {
1220  strats[hook] = mergeHook;
1221});
1222
1223/**
1224 * Assets
1225 *
1226 * When a vm is present (instance creation), we need to do
1227 * a three-way merge between constructor options, instance
1228 * options and parent options.
1229 */
1230function mergeAssets (
1231  parentVal,
1232  childVal,
1233  vm,
1234  key
1235) {
1236  var res = Object.create(parentVal || null);
1237  if (childVal) {
1238    "development" !== 'production' && assertObjectType(key, childVal, vm);
1239    return extend(res, childVal)
1240  } else {
1241    return res
1242  }
1243}
1244
1245ASSET_TYPES.forEach(function (type) {
1246  strats[type + 's'] = mergeAssets;
1247});
1248
1249/**
1250 * Watchers.
1251 *
1252 * Watchers hashes should not overwrite one
1253 * another, so we merge them as arrays.
1254 */
1255strats.watch = function (
1256  parentVal,
1257  childVal,
1258  vm,
1259  key
1260) {
1261  // work around Firefox's Object.prototype.watch...
1262  if (parentVal === nativeWatch) { parentVal = undefined; }
1263  if (childVal === nativeWatch) { childVal = undefined; }
1264  /* istanbul ignore if */
1265  if (!childVal) { return Object.create(parentVal || null) }
1266  {
1267    assertObjectType(key, childVal, vm);
1268  }
1269  if (!parentVal) { return childVal }
1270  var ret = {};
1271  extend(ret, parentVal);
1272  for (var key$1 in childVal) {
1273    var parent = ret[key$1];
1274    var child = childVal[key$1];
1275    if (parent && !Array.isArray(parent)) {
1276      parent = [parent];
1277    }
1278    ret[key$1] = parent
1279      ? parent.concat(child)
1280      : Array.isArray(child) ? child : [child];
1281  }
1282  return ret
1283};
1284
1285/**
1286 * Other object hashes.
1287 */
1288strats.props =
1289strats.methods =
1290strats.inject =
1291strats.computed = function (
1292  parentVal,
1293  childVal,
1294  vm,
1295  key
1296) {
1297  if (childVal && "development" !== 'production') {
1298    assertObjectType(key, childVal, vm);
1299  }
1300  if (!parentVal) { return childVal }
1301  var ret = Object.create(null);
1302  extend(ret, parentVal);
1303  if (childVal) { extend(ret, childVal); }
1304  return ret
1305};
1306strats.provide = mergeDataOrFn;
1307
1308/**
1309 * Default strategy.
1310 */
1311var defaultStrat = function (parentVal, childVal) {
1312  return childVal === undefined
1313    ? parentVal
1314    : childVal
1315};
1316
1317/**
1318 * Validate component names
1319 */
1320function checkComponents (options) {
1321  for (var key in options.components) {
1322    validateComponentName(key);
1323  }
1324}
1325
1326function validateComponentName (name) {

1526    } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {
1527      value = true;
1528    }
1529  }
1530  // check default value
1531  if (value === undefined) {
1532    value = getPropDefaultValue(vm, prop, key);
1533    // since the default value is a fresh copy,
1534    // make sure to observe it.
1535    var prevShouldConvert = observerState.shouldConvert;
1536    observerState.shouldConvert = true;
1537    observe(value);
1538    observerState.shouldConvert = prevShouldConvert;
1539  }
1540  {
1541    assertProp(prop, key, value, vm, absent);
1542  }
1543  return value
1544}
1545
1546/**
1547 * Get the default value of a prop.
1548 */
1549function getPropDefaultValue (vm, prop, key) {
1550  // no default, return undefined
1551  if (!hasOwn(prop, 'default')) {
1552    return undefined
1553  }
1554  var def = prop.default;
1555  // warn against non-factory defaults for Object & Array
1556  if ("development" !== 'production' && isObject(def)) {
1557    warn(
1558      'Invalid default value for prop "' + key + '": ' +
1559      'Props with type Object/Array must use a factory function ' +
1560      'to return the default value.',
1561      vm
1562    );
1563  }
1564  // the raw prop value was also undefined from previous render,
1565  // return previous default value to avoid unnecessary watcher trigger
1566  if (vm && vm.$options.propsData &&
1567    vm.$options.propsData[key] === undefined &&
1568    vm._props[key] !== undefined
1569  ) {
1570    return vm._props[key]
1571  }
1572  // call factory function for non-Function types
1573  // a value is Function if its prototype is function even across different execution context
1574  return typeof def === 'function' && getType(prop.type) !== 'Function'
1575    ? def.call(vm)
1576    : def
1577}
1578
1579/**
1580 * Assert whether a prop is valid.
1581 */
1582function assertProp (
1583  prop,
1584  name,
1585  value,
1586  vm,
1587  absent
1588) {
1589  if (prop.required && absent) {
1590    warn(
1591      'Missing required prop: "' + name + '"',
1592      vm
1593    );
1594    return
1595  }
1596  if (value == null && !prop.required) {
1597    return
1598  }
1599  var type = prop.type;
1600  var valid = !type || type === true;
1601  var expectedTypes = [];
1602  if (type) {
1603    if (!Array.isArray(type)) {
1604      type = [type];
1605    }
1606    for (var i = 0; i < type.length && !valid; i++) {
1607      var assertedType = assertType(value, type[i]);
1608      expectedTypes.push(assertedType.expectedType || '');
1609      valid = assertedType.valid;
1610    }
1611  }
1612  if (!valid) {
1613    warn(
1614      "Invalid prop: type check failed for prop \"" + name + "\"." +
1615      " Expected " + (expectedTypes.map(capitalize).join(', ')) +
1616      ", got " + (toRawType(value)) + ".",
1617      vm
1618    );
1619    return
1620  }

1774  macroTimerFunc = function () {
1775    setTimeout(flushCallbacks, 0);
1776  };
1777}
1778
1779// Determine MicroTask defer implementation.
1780/* istanbul ignore next, $flow-disable-line */
1781if (typeof Promise !== 'undefined' && isNative(Promise)) {
1782  var p = Promise.resolve();
1783  microTimerFunc = function () {
1784    p.then(flushCallbacks);
1785    // in problematic UIWebViews, Promise.then doesn't completely break, but
1786    // it can get stuck in a weird state where callbacks are pushed into the
1787    // microtask queue but the queue isn't being flushed, until the browser
1788    // needs to do some other work, e.g. handle a timer. Therefore we can
1789    // "force" the microtask queue to be flushed by adding an empty timer.
1790    if (isIOS) { setTimeout(noop); }
1791  };
1792} else {
1793  // fallback to macro
1794  microTimerFunc = macroTimerFunc;
1795}
1796
1797/**
1798 * Wrap a function so that if any code inside triggers state change,
1799 * the changes are queued using a Task instead of a MicroTask.
1800 */
1801function withMacroTask (fn) {
1802  return fn._withTask || (fn._withTask = function () {
1803    useMacroTask = true;
1804    var res = fn.apply(null, arguments);
1805    useMacroTask = false;
1806    return res
1807  })
1808}
1809
1810function nextTick (cb, ctx) {
1811  var _resolve;
1812  callbacks.push(function () {
1813    if (cb) {
1814      try {
1815        cb.call(ctx);
1816      } catch (e) {
1817        handleError(e, ctx, 'nextTick');
1818      }
1819    } else if (_resolve) {
1820      _resolve(ctx);
1821    }
1822  });
1823  if (!pending) {
1824    pending = true;
1825    if (useMacroTask) {
1826      macroTimerFunc();
1827    } else {
1828      microTimerFunc();
1829    }
1830  }
1831  // $flow-disable-line
1832  if (!cb && typeof Promise !== 'undefined') {
1833    return new Promise(function (resolve) {
1834      _resolve = resolve;
1835    })
1836  }
1837}
1838
1839/*  */
1840
1841var mark;
1842var measure;
1843
1844{
1845  var perf = inBrowser && window.performance;
1846  /* istanbul ignore if */
1847  if (
1848    perf &&
1849    perf.mark &&
1850    perf.measure &&
1851    perf.clearMarks &&
1852    perf.clearMeasures
1853  ) {
1854    mark = function (tag) { return perf.mark(tag); };
1855    measure = function (name, startTag, endTag) {
1856      perf.measure(name, startTag, endTag);
1857      perf.clearMarks(startTag);
1858      perf.clearMarks(endTag);
1859      perf.clearMeasures(name);
1860    };
1861  }
1862}
1863
1864/* not type checking this file because flow doesn't play well with Proxy */
1865
1866var initProxy;
1867
1868{
1869  var allowedGlobals = makeMap(
1870    'Infinity,undefined,NaN,isFinite,isNaN,' +
1871    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
1872    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
1873    'require' // for Webpack/Browserify
1874  );
1875
1876  var warnNonPresent = function (target, key) {
1877    warn(
1878      "Property or method \"" + key + "\" is not defined on the instance but " +
1879      'referenced during render. Make sure that this property is reactive, ' +
1880      'either in the data option, or for class-based components, by ' +
1881      'initializing the property. ' +
1882      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
1883      target
1884    );
1885  };
1886
1887  var hasProxy =
1888    typeof Proxy !== 'undefined' &&
1889    Proxy.toString().match(/native code/);
1890
1891  if (hasProxy) {
1892    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
1893    config.keyCodes = new Proxy(config.keyCodes, {
1894      set: function set (target, key, value) {
1895        if (isBuiltInModifier(key)) {
1896          warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
1897          return false
1898        } else {
1899          target[key] = value;
1900          return true
1901        }
1902      }
1903    });
1904  }
1905
1906  var hasHandler = {
1907    has: function has (target, key) {
1908      var has = key in target;
1909      var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';
1910      if (!has && !isAllowed) {
1911        warnNonPresent(target, key);
1912      }
1913      return has || !isAllowed
1914    }
1915  };
1916
1917  var getHandler = {
1918    get: function get (target, key) {
1919      if (typeof key === 'string' && !(key in target)) {
1920        warnNonPresent(target, key);
1921      }
1922      return target[key]
1923    }
1924  };
1925
1926  initProxy = function initProxy (vm) {
1927    if (hasProxy) {
1928      // determine which proxy handler to use
1929      var options = vm.$options;
1930      var handlers = options.render && options.render._withStripped
1931        ? getHandler
1932        : hasHandler;
1933      vm._renderProxy = new Proxy(vm, handlers);
1934    } else {
1935      vm._renderProxy = vm;
1936    }
1937  };
1938}
1939
1940/*  */
1941
1942var seenObjects = new _Set();
1943
1944/**
1945 * Recursively traverse an object to evoke all converted
1946 * getters, so that every nested property inside the object
1947 * is collected as a "deep" dependency.
1948 */
1949function traverse (val) {
1950  _traverse(val, seenObjects);
1951  seenObjects.clear();
1952}
1953
1954function _traverse (val, seen) {
1955  var i, keys;
1956  var isA = Array.isArray(val);
1957  if ((!isA && !isObject(val)) || Object.isFrozen(val)) {
1958    return
1959  }
1960  if (val.__ob__) {
1961    var depId = val.__ob__.dep.id;
1962    if (seen.has(depId)) {
1963      return
1964    }
1965    seen.add(depId);
1966  }
1967  if (isA) {
1968    i = val.length;
1969    while (i--) { _traverse(val[i], seen); }
1970  } else {
1971    keys = Object.keys(val);
1972    i = keys.length;
1973    while (i--) { _traverse(val[keys[i]], seen); }
1974  }
1975}
1976
1977/*  */
1978
1979var normalizeEvent = cached(function (name) {
1980  var passive = name.charAt(0) === '&';
1981  name = passive ? name.slice(1) : name;
1982  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
1983  name = once$$1 ? name.slice(1) : name;
1984  var capture = name.charAt(0) === '!';
1985  name = capture ? name.slice(1) : name;
1986  return {
1987    name: name,
1988    once: once$$1,
1989    capture: capture,
1990    passive: passive
1991  }
1992});
1993
1994function createFnInvoker (fns) {
1995  function invoker () {
1996    var arguments$1 = arguments;
1997
1998    var fns = invoker.fns;
1999    if (Array.isArray(fns)) {
2000      var cloned = fns.slice();
2001      for (var i = 0; i < cloned.length; i++) {
2002        cloned[i].apply(null, arguments$1);
2003      }
2004    } else {
2005      // return handler return value for single handlers
2006      return fns.apply(null, arguments)
2007    }
2008  }
2009  invoker.fns = fns;
2010  return invoker
2011}
2012
2013function updateListeners (
2014  on,
2015  oldOn,
2016  add,
2017  remove$$1,
2018  vm
2019) {
2020  var name, def, cur, old, event;
2021  for (name in on) {
2022    def = cur = on[name];
2023    old = oldOn[name];
2024    event = normalizeEvent(name);
2025    /* istanbul ignore if */
2026    if (isUndef(cur)) {
2027      "development" !== 'production' && warn(
2028        "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
2029        vm
2030      );
2031    } else if (isUndef(old)) {
2032      if (isUndef(cur.fns)) {
2033        cur = on[name] = createFnInvoker(cur);
2034      }
2035      add(event.name, cur, event.once, event.capture, event.passive, event.params);
2036    } else if (cur !== old) {
2037      old.fns = cur;
2038      on[name] = old;
2039    }
2040  }
2041  for (name in oldOn) {
2042    if (isUndef(on[name])) {
2043      event = normalizeEvent(name);
2044      remove$$1(event.name, oldOn[name], event.capture);
2045    }
2046  }
2047}
2048
2049/*  */
2050
2051function mergeVNodeHook (def, hookKey, hook) {
2052  if (def instanceof VNode) {
2053    def = def.data.hook || (def.data.hook = {});
2054  }
2055  var invoker;
2056  var oldHook = def[hookKey];
2057
2058  function wrappedHook () {
2059    hook.apply(this, arguments);
2060    // important: remove merged hook to ensure it's called only once
2061    // and prevent memory leak
2062    remove(invoker.fns, wrappedHook);
2063  }
2064
2065  if (isUndef(oldHook)) {
2066    // no existing hook
2067    invoker = createFnInvoker([wrappedHook]);
2068  } else {
2069    /* istanbul ignore if */
2070    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
2071      // already a merged invoker
2072      invoker = oldHook;
2073      invoker.fns.push(wrappedHook);
2074    } else {
2075      // existing plain hook
2076      invoker = createFnInvoker([oldHook, wrappedHook]);
2077    }
2078  }
2079
2080  invoker.merged = true;
2081  def[hookKey] = invoker;
2082}
2083
2084/*  */
2085
2086function extractPropsFromVNodeData (
2087  data,
2088  Ctor,
2089  tag
2090) {
2091  // we are only extracting raw values here.
2092  // validation and default values are handled in the child
2093  // component itself.
2094  var propOptions = Ctor.options.props;
2095  if (isUndef(propOptions)) {
2096    return
2097  }
2098  var res = {};
2099  var attrs = data.attrs;
2100  var props = data.props;
2101  if (isDef(attrs) || isDef(props)) {
2102    for (var key in propOptions) {
2103      var altKey = hyphenate(key);
2104      {
2105        var keyInLowerCase = key.toLowerCase();
2106        if (
2107          key !== keyInLowerCase &&
2108          attrs && hasOwn(attrs, keyInLowerCase)
2109        ) {
2110          tip(
2111            "Prop \"" + keyInLowerCase + "\" is passed to component " +
2112            (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
2113            " \"" + key + "\". " +
2114            "Note that HTML attributes are case-insensitive and camelCased " +
2115            "props need to use their kebab-case equivalents when using in-DOM " +
2116            "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
2117          );
2118        }
2119      }
2120      checkProp(res, props, key, altKey, true) ||
2121      checkProp(res, attrs, key, altKey, false);
2122    }
2123  }
2124  return res
2125}
2126
2127function checkProp (
2128  res,
2129  hash,
2130  key,
2131  altKey,
2132  preserve
2133) {

2134  if (isDef(hash)) {
2135    if (hasOwn(hash, key)) {
2136      res[key] = hash[key];
2137      if (!preserve) {
2138        delete hash[key];
2139      }
2140      return true
2141    } else if (hasOwn(hash, altKey)) {
2142      res[key] = hash[altKey];
2143      if (!preserve) {
2144        delete hash[altKey];
2145      }
2146      return true
2147    }
2148  }
2149  return false
2150}
2151
2152/*  */
2153
2154// The template compiler attempts to minimize the need for normalization by
2155// statically analyzing the template at compile time.
2156//
2157// For plain HTML markup, normalization can be completely skipped because the
2158// generated render function is guaranteed to return Array<VNode>. There are
2159// two cases where extra normalization is needed:
2160
2161// 1. When the children contains components - because a functional component
2162// may return an Array instead of a single root. In this case, just a simple
2163// normalization is needed - if any child is an Array, we flatten the whole
2164// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
2165// because functional components already normalize their own children.
2166function simpleNormalizeChildren (children) {
2167  for (var i = 0; i < children.length; i++) {
2168    if (Array.isArray(children[i])) {
2169      return Array.prototype.concat.apply([], children)
2170    }
2171  }
2172  return children
2173}
2174
2175// 2. When the children contains constructs that always generated nested Arrays,
2176// e.g. <template>, <slot>, v-for, or when the children is provided by user
2177// with hand-written render functions / JSX. In such cases a full normalization
2178// is needed to cater to all possible types of children values.
2179function normalizeChildren (children) {
2180  return isPrimitive(children)
2181    ? [createTextVNode(children)]
2182    : Array.isArray(children)
2183      ? normalizeArrayChildren(children)
2184      : undefined
2185}
2186
2187function isTextNode (node) {
2188  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
2189}
2190
2191function normalizeArrayChildren (children, nestedIndex) {
2192  var res = [];
2193  var i, c, lastIndex, last;
2194  for (i = 0; i < children.length; i++) {
2195    c = children[i];
2196    if (isUndef(c) || typeof c === 'boolean') { continue }
2197    lastIndex = res.length - 1;
2198    last = res[lastIndex];
2199    //  nested
2200    if (Array.isArray(c)) {
2201      if (c.length > 0) {
2202        c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
2203        // merge adjacent text nodes
2204        if (isTextNode(c[0]) && isTextNode(last)) {
2205          res[lastIndex] = createTextVNode(last.text + (c[0]).text);
2206          c.shift();
2207        }
2208        res.push.apply(res, c);
2209      }
2210    } else if (isPrimitive(c)) {
2211      if (isTextNode(last)) {
2212        // merge adjacent text nodes
2213        // this is necessary for SSR hydration because text nodes are
2214        // essentially merged when rendered to HTML strings
2215        res[lastIndex] = createTextVNode(last.text + c);
2216      } else if (c !== '') {
2217        // convert primitive to vnode
2218        res.push(createTextVNode(c));
2219      }
2220    } else {
2221      if (isTextNode(c) && isTextNode(last)) {
2222        // merge adjacent text nodes
2223        res[lastIndex] = createTextVNode(last.text + c.text);
2224      } else {
2225        // default key for nested array children (likely generated by v-for)
2226        if (isTrue(children._isVList) &&
2227          isDef(c.tag) &&
2228          isUndef(c.key) &&
2229          isDef(nestedIndex)) {
2230          c.key = "__vlist" + nestedIndex + "_" + i + "__";
2231        }
2232        res.push(c);
2233      }
2234    }
2235  }
2236  return res
2237}
2238
2239/*  */
2240
2241function ensureCtor (comp, base) {
2242  if (
2243    comp.__esModule ||
2244    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
2245  ) {
2246    comp = comp.default;
2247  }
2248  return isObject(comp)
2249    ? base.extend(comp)
2250    : comp
2251}
2252
2253function createAsyncPlaceholder (
2254  factory,
2255  data,
2256  context,
2257  children,
2258  tag
2259) {
2260  var node = createEmptyVNode();
2261  node.asyncFactory = factory;
2262  node.asyncMeta = { data: data, context: context, children: children, tag: tag };
2263  return node
2264}
2265
2266function resolveAsyncComponent (
2267  factory,
2268  baseCtor,
2269  context
2270) {
2271  if (isTrue(factory.error) && isDef(factory.errorComp)) {
2272    return factory.errorComp
2273  }
2274
2275  if (isDef(factory.resolved)) {
2276    return factory.resolved
2277  }
2278
2279  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
2280    return factory.loadingComp
2281  }
2282
2283  if (isDef(factory.contexts)) {
2284    // already pending
2285    factory.contexts.push(context);
2286  } else {
2287    var contexts = factory.contexts = [context];
2288    var sync = true;
2289
2290    var forceRender = function () {
2291      for (var i = 0, l = contexts.length; i < l; i++) {
2292        contexts[i].$forceUpdate();
2293      }
2294    };
2295
2296    var resolve = once(function (res) {
2297      // cache resolved
2298      factory.resolved = ensureCtor(res, baseCtor);
2299      // invoke callbacks only if this is not a synchronous resolve
2300      // (async resolves are shimmed as synchronous during SSR)
2301      if (!sync) {
2302        forceRender();
2303      }
2304    });
2305
2306    var reject = once(function (reason) {
2307      "development" !== 'production' && warn(
2308        "Failed to resolve async component: " + (String(factory)) +
2309        (reason ? ("\nReason: " + reason) : '')
2310      );
2311      if (isDef(factory.errorComp)) {
2312        factory.error = true;
2313        forceRender();
2314      }
2315    });
2316
2317    var res = factory(resolve, reject);
2318

2319    if (isObject(res)) {
2320      if (typeof res.then === 'function') {
2321        // () => Promise
2322        if (isUndef(factory.resolved)) {
2323          res.then(resolve, reject);
2324        }
2325      } else if (isDef(res.component) && typeof res.component.then === 'function') {
2326        res.component.then(resolve, reject);
2327
2328        if (isDef(res.error)) {
2329          factory.errorComp = ensureCtor(res.error, baseCtor);
2330        }
2331
2332        if (isDef(res.loading)) {
2333          factory.loadingComp = ensureCtor(res.loading, baseCtor);
2334          if (res.delay === 0) {
2335            factory.loading = true;
2336          } else {
2337            setTimeout(function () {
2338              if (isUndef(factory.resolved) && isUndef(factory.error)) {
2339                factory.loading = true;
2340                forceRender();
2341              }
2342            }, res.delay || 200);
2343          }
2344        }
2345
2346        if (isDef(res.timeout)) {
2347          setTimeout(function () {
2348            if (isUndef(factory.resolved)) {
2349              reject(
2350                "timeout (" + (res.timeout) + "ms)"
2351              );
2352            }
2353          }, res.timeout);
2354        }
2355      }
2356    }
2357
2358    sync = false;
2359    // return in case resolved synchronously
2360    return factory.loading
2361      ? factory.loadingComp
2362      : factory.resolved
2363  }
2364}
2365
2366/*  */
2367
2368function isAsyncPlaceholder (node) {
2369  return node.isComment && node.asyncFactory
2370}
2371
2372/*  */
2373
2374function getFirstComponentChild (children) {
2375  if (Array.isArray(children)) {
2376    for (var i = 0; i < children.length; i++) {
2377      var c = children[i];
2378      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
2379        return c
2380      }
2381    }
2382  }
2383}
2384
2385/*  */
2386
2387/*  */
2388
2389function initEvents (vm) {
2390  vm._events = Object.create(null);
2391  vm._hasHookEvent = false;
2392  // init parent attached events
2393  var listeners = vm.$options._parentListeners;
2394  if (listeners) {
2395    updateComponentListeners(vm, listeners);
2396  }
2397}
2398
2399var target;
2400
2401function add (event, fn, once) {
2402  if (once) {
2403    target.$once(event, fn);
2404  } else {
2405    target.$on(event, fn);
2406  }
2407}
2408
2409function remove$1 (event, fn) {
2410  target.$off(event, fn);
2411}
2412
2413function updateComponentListeners (
2414  vm,
2415  listeners,
2416  oldListeners
2417) {
2418  target = vm;
2419  updateListeners(listeners, oldListeners || {}, add, remove$1, vm);
2420  target = undefined;
2421}
2422
2423function eventsMixin (Vue) {
2424  var hookRE = /^hook:/;
2425  Vue.prototype.$on = function (event, fn) {
2426    var this$1 = this;
2427
2428    var vm = this;
2429    if (Array.isArray(event)) {
2430      for (var i = 0, l = event.length; i < l; i++) {
2431        this$1.$on(event[i], fn);
2432      }
2433    } else {
2434      (vm._events[event] || (vm._events[event] = [])).push(fn);
2435      // optimize hook:event cost by using a boolean flag marked at registration
2436      // instead of a hash lookup
2437      if (hookRE.test(event)) {
2438        vm._hasHookEvent = true;
2439      }
2440    }
2441    return vm
2442  };
2443
2444  Vue.prototype.$once = function (event, fn) {
2445    var vm = this;
2446    function on () {
2447      vm.$off(event, on);
2448      fn.apply(vm, arguments);
2449    }
2450    on.fn = fn;
2451    vm.$on(event, on);
2452    return vm
2453  };
2454
2455  Vue.prototype.$off = function (event, fn) {
2456    var this$1 = this;
2457
2458    var vm = this;
2459    // all
2460    if (!arguments.length) {
2461      vm._events = Object.create(null);
2462      return vm
2463    }
2464    // array of events
2465    if (Array.isArray(event)) {
2466      for (var i = 0, l = event.length; i < l; i++) {
2467        this$1.$off(event[i], fn);
2468      }
2469      return vm
2470    }
2471    // specific event
2472    var cbs = vm._events[event];
2473    if (!cbs) {
2474      return vm
2475    }
2476    if (!fn) {
2477      vm._events[event] = null;
2478      return vm
2479    }
2480    if (fn) {
2481      // specific handler
2482      var cb;
2483      var i$1 = cbs.length;
2484      while (i$1--) {
2485        cb = cbs[i$1];
2486        if (cb === fn || cb.fn === fn) {
2487          cbs.splice(i$1, 1);
2488          break
2489        }
2490      }
2491    }
2492    return vm
2493  };
2494
2495  Vue.prototype.$emit = function (event) {
2496    var vm = this;
2497    {
2498      var lowerCaseEvent = event.toLowerCase();
2499      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
2500        tip(
2501          "Event \"" + lowerCaseEvent + "\" is emitted in component " +
2502          (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
2503          "Note that HTML attributes are case-insensitive and you cannot use " +
2504          "v-on to listen to camelCase events when using in-DOM templates. " +
2505          "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
2506        );
2507      }
2508    }
2509    var cbs = vm._events[event];
2510    if (cbs) {
2511      cbs = cbs.length > 1 ? toArray(cbs) : cbs;
2512      var args = toArray(arguments, 1);
2513      for (var i = 0, l = cbs.length; i < l; i++) {
2514        try {
2515          cbs[i].apply(vm, args);
2516        } catch (e) {
2517          handleError(e, vm, ("event handler for \"" + event + "\""));
2518        }
2519      }
2520    }
2521    return vm
2522  };
2523}
2524
2525/*  */
2526
2527
2528
2529/**
2530 * Runtime helper for resolving raw children VNodes into a slot object.
2531 */
2532function resolveSlots (
2533  children,
2534  context
2535) {
2536  var slots = {};
2537  if (!children) {
2538    return slots
2539  }
2540  for (var i = 0, l = children.length; i < l; i++) {
2541    var child = children[i];
2542    var data = child.data;
2543    // remove slot attribute if the node is resolved as a Vue slot node
2544    if (data && data.attrs && data.attrs.slot) {
2545      delete data.attrs.slot;
2546    }
2547    // named slots should only be respected if the vnode was rendered in the
2548    // same context.
2549    if ((child.context === context || child.fnContext === context) &&
2550      data && data.slot != null
2551    ) {
2552      var name = data.slot;
2553      var slot = (slots[name] || (slots[name] = []));
2554      if (child.tag === 'template') {
2555        slot.push.apply(slot, child.children || []);
2556      } else {
2557        slot.push(child);
2558      }
2559    } else {
2560      (slots.default || (slots.default = [])).push(child);
2561    }
2562  }
2563  // ignore slots that contains only whitespace
2564  for (var name$1 in slots) {
2565    if (slots[name$1].every(isWhitespace)) {
2566      delete slots[name$1];
2567    }
2568  }
2569  return slots
2570}
2571
2572function isWhitespace (node) {
2573  return (node.isComment && !node.asyncFactory) || node.text === ' '
2574}
2575
2576function resolveScopedSlots (
2577  fns, // see flow/vnode
2578  res
2579) {
2580  res = res || {};
2581  for (var i = 0; i < fns.length; i++) {
2582    if (Array.isArray(fns[i])) {
2583      resolveScopedSlots(fns[i], res);
2584    } else {
2585      res[fns[i].key] = fns[i].fn;
2586    }
2587  }
2588  return res
2589}
2590
2591/*  */
2592
2593var activeInstance = null;
2594var isUpdatingChildComponent = false;
2595
2596function initLifecycle (vm) {
2597  var options = vm.$options;
2598
2599  // locate first non-abstract parent
2600  var parent = options.parent;
2601  if (parent && !options.abstract) {
2602    while (parent.$options.abstract && parent.$parent) {
2603      parent = parent.$parent;
2604    }
2605    parent.$children.push(vm);
2606  }
2607
2608  vm.$parent = parent;
2609  vm.$root = parent ? parent.$root : vm;
2610
2611  vm.$children = [];
2612  vm.$refs = {};
2613
2614  vm._watcher = null;
2615  vm._inactive = null;
2616  vm._directInactive = false;
2617  vm._isMounted = false;
2618  vm._isDestroyed = false;
2619  vm._isBeingDestroyed = false;
2620}
2621
2622function lifecycleMixin (Vue) {
2623  Vue.prototype._update = function (vnode, hydrating) {
2624    var vm = this;
2625    if (vm._isMounted) {
2626      callHook(vm, 'beforeUpdate');
2627    }
2628    var prevEl = vm.$el;
2629    var prevVnode = vm._vnode;
2630    var prevActiveInstance = activeInstance;
2631    activeInstance = vm;
2632    vm._vnode = vnode;
2633    // Vue.prototype.__patch__ is injected in entry points
2634    // based on the rendering backend used.
2635    if (!prevVnode) {
2636      // initial render
2637      vm.$el = vm.__patch__(
2638        vm.$el, vnode, hydrating, false /* removeOnly */,
2639        vm.$options._parentElm,
2640        vm.$options._refElm
2641      );
2642      // no need for the ref nodes after initial patch
2643      // this prevents keeping a detached DOM tree in memory (#5851)
2644      vm.$options._parentElm = vm.$options._refElm = null;
2645    } else {
2646      // updates
2647      vm.$el = vm.__patch__(prevVnode, vnode);
2648    }
2649    activeInstance = prevActiveInstance;
2650    // update __vue__ reference
2651    if (prevEl) {
2652      prevEl.__vue__ = null;
2653    }
2654    if (vm.$el) {
2655      vm.$el.__vue__ = vm;
2656    }
2657    // if parent is an HOC, update its $el as well
2658    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
2659      vm.$parent.$el = vm.$el;
2660    }
2661    // updated hook is called by the scheduler to ensure that children are
2662    // updated in a parent's updated hook.
2663  };
2664
2665  Vue.prototype.$forceUpdate = function () {
2666    var vm = this;
2667    if (vm._watcher) {
2668      vm._watcher.update();
2669    }
2670  };
2671
2672  Vue.prototype.$destroy = function () {
2673    var vm = this;
2674    if (vm._isBeingDestroyed) {
2675      return
2676    }
2677    callHook(vm, 'beforeDestroy');
2678    vm._isBeingDestroyed = true;
2679    // remove self from parent
2680    var parent = vm.$parent;
2681    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
2682      remove(parent.$children, vm);
2683    }
2684    // teardown watchers
2685    if (vm._watcher) {
2686      vm._watcher.teardown();
2687    }
2688    var i = vm._watchers.length;
2689    while (i--) {
2690      vm._watchers[i].teardown();
2691    }
2692    // remove reference from data ob
2693    // frozen object may not have observer.
2694    if (vm._data.__ob__) {
2695      vm._data.__ob__.vmCount--;
2696    }
2697    // call the last hook...
2698    vm._isDestroyed = true;
2699    // invoke destroy hooks on current rendered tree
2700    vm.__patch__(vm._vnode, null);
2701    // fire destroyed hook
2702    callHook(vm, 'destroyed');
2703    // turn off all instance listeners.
2704    vm.$off();
2705    // remove __vue__ reference
2706    if (vm.$el) {
2707      vm.$el.__vue__ = null;
2708    }
2709    // release circular reference (#6759)
2710    if (vm.$vnode) {
2711      vm.$vnode.parent = null;
2712    }
2713  };
2714}
2715
2716function mountComponent (
2717  vm,
2718  el,
2719  hydrating
2720) {
2721  vm.$el = el;
2722  if (!vm.$options.render) {
2723    vm.$options.render = createEmptyVNode;
2724    {
2725      /* istanbul ignore if */
2726      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
2727        vm.$options.el || el) {
2728        warn(
2729          'You are using the runtime-only build of Vue where the template ' +
2730          'compiler is not available. Either pre-compile the templates into ' +
2731          'render functions, or use the compiler-included build.',
2732          vm
2733        );
2734      } else {
2735        warn(
2736          'Failed to mount component: template or render function not defined.',
2737          vm
2738        );
2739      }
2740    }
2741  }
2742  callHook(vm, 'beforeMount');
2743
2744  var updateComponent;
2745  /* istanbul ignore if */
2746  if ("development" !== 'production' && config.performance && mark) {
2747    updateComponent = function () {
2748      var name = vm._name;
2749      var id = vm._uid;
2750      var startTag = "vue-perf-start:" + id;
2751      var endTag = "vue-perf-end:" + id;
2752
2753      mark(startTag);
2754      var vnode = vm._render();
2755      mark(endTag);
2756      measure(("vue " + name + " render"), startTag, endTag);
2757
2758      mark(startTag);
2759      vm._update(vnode, hydrating);
2760      mark(endTag);
2761      measure(("vue " + name + " patch"), startTag, endTag);
2762    };
2763  } else {
2764    updateComponent = function () {
2765      vm._update(vm._render(), hydrating);
2766    };
2767  }
2768
2769  // we set this to vm._watcher inside the watcher's constructor
2770  // since the watcher's initial patch may call $forceUpdate (e.g. inside child
2771  // component's mounted hook), which relies on vm._watcher being already defined
2772  new Watcher(vm, updateComponent, noop, null, true /* isRenderWatcher */);
2773  hydrating = false;
2774
2775  // manually mounted instance, call mounted on self
2776  // mounted is called for render-created child components in its inserted hook
2777  if (vm.$vnode == null) {
2778    vm._isMounted = true;
2779    callHook(vm, 'mounted');
2780  }
2781  return vm
2782}
2783
2784function updateChildComponent (
2785  vm,
2786  propsData,
2787  listeners,
2788  parentVnode,
2789  renderChildren
2790) {
2791  {
2792    isUpdatingChildComponent = true;
2793  }
2794
2795  // determine whether component has slot children
2796  // we need to do this before overwriting $options._renderChildren
2797  var hasChildren = !!(
2798    renderChildren ||               // has new static slots
2799    vm.$options._renderChildren ||  // has old static slots
2800    parentVnode.data.scopedSlots || // has new scoped slots
2801    vm.$scopedSlots !== emptyObject // has old scoped slots
2802  );
2803
2804  vm.$options._parentVnode = parentVnode;
2805  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
2806
2807  if (vm._vnode) { // update child tree's parent
2808    vm._vnode.parent = parentVnode;
2809  }
2810  vm.$options._renderChildren = renderChildren;
2811
2812  // update $attrs and $listeners hash
2813  // these are also reactive so they may trigger child update if the child
2814  // used them during render
2815  vm.$attrs = (parentVnode.data && parentVnode.data.attrs) || emptyObject;
2816  vm.$listeners = listeners || emptyObject;
2817
2818  // update props
2819  if (propsData && vm.$options.props) {
2820    observerState.shouldConvert = false;
2821    var props = vm._props;
2822    var propKeys = vm.$options._propKeys || [];
2823    for (var i = 0; i < propKeys.length; i++) {
2824      var key = propKeys[i];
2825      props[key] = validateProp(key, vm.$options.props, propsData, vm);
2826    }
2827    observerState.shouldConvert = true;
2828    // keep a copy of raw propsData
2829    vm.$options.propsData = propsData;
2830  }
2831
2832  // update listeners
2833  if (listeners) {
2834    var oldListeners = vm.$options._parentListeners;
2835    vm.$options._parentListeners = listeners;
2836    updateComponentListeners(vm, listeners, oldListeners);
2837  }
2838  // resolve slots + force update if has children
2839  if (hasChildren) {
2840    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
2841    vm.$forceUpdate();
2842  }
2843
2844  {
2845    isUpdatingChildComponent = false;
2846  }
2847}
2848
2849function isInInactiveTree (vm) {
2850  while (vm && (vm = vm.$parent)) {
2851    if (vm._inactive) { return true }
2852  }
2853  return false
2854}
2855
2856function activateChildComponent (vm, direct) {
2857  if (direct) {
2858    vm._directInactive = false;
2859    if (isInInactiveTree(vm)) {
2860      return
2861    }
2862  } else if (vm._directInactive) {
2863    return
2864  }
2865  if (vm._inactive || vm._inactive === null) {
2866    vm._inactive = false;
2867    for (var i = 0; i < vm.$children.length; i++) {
2868      activateChildComponent(vm.$children[i]);
2869    }
2870    callHook(vm, 'activated');
2871  }
2872}
2873
2874function deactivateChildComponent (vm, direct) {
2875  if (direct) {
2876    vm._directInactive = true;
2877    if (isInInactiveTree(vm)) {
2878      return
2879    }
2880  }
2881  if (!vm._inactive) {
2882    vm._inactive = true;
2883    for (var i = 0; i < vm.$children.length; i++) {
2884      deactivateChildComponent(vm.$children[i]);
2885    }
2886    callHook(vm, 'deactivated');
2887  }
2888}
2889
2890function callHook (vm, hook) {
2891  var handlers = vm.$options[hook];
2892  if (handlers) {
2893    for (var i = 0, j = handlers.length; i < j; i++) {
2894      try {
2895        handlers[i].call(vm);
2896      } catch (e) {
2897        handleError(e, vm, (hook + " hook"));
2898      }
2899    }
2900  }
2901  if (vm._hasHookEvent) {
2902    vm.$emit('hook:' + hook);
2903  }
2904}
2905
2906/*  */
2907
2908
2909var MAX_UPDATE_COUNT = 100;
2910
2911var queue = [];
2912var activatedChildren = [];
2913var has = {};
2914var circular = {};
2915var waiting = false;
2916var flushing = false;
2917var index = 0;
2918
2919/**
2920 * Reset the scheduler's state.
2921 */
2922function resetSchedulerState () {
2923  index = queue.length = activatedChildren.length = 0;
2924  has = {};
2925  {
2926    circular = {};
2927  }
2928  waiting = flushing = false;
2929}
2930
2931/**
2932 * Flush both queues and run the watchers.
2933 */
2934function flushSchedulerQueue () {
2935  flushing = true;
2936  var watcher, id;
2937
2938  // Sort queue before flush.
2939  // This ensures that:
2940  // 1. Components are updated from parent to child. (because parent is always
2941  //    created before the child)
2942  // 2. A component's user watchers are run before its render watcher (because
2943  //    user watchers are created before the render watcher)
2944  // 3. If a component is destroyed during a parent component's watcher run,
2945  //    its watchers can be skipped.
2946  queue.sort(function (a, b) { return a.id - b.id; });
2947
2948  // do not cache length because more watchers might be pushed
2949  // as we run existing watchers
2950  for (index = 0; index < queue.length; index++) {
2951    watcher = queue[index];
2952    id = watcher.id;
2953    has[id] = null;
2954    watcher.run();
2955    // in dev build, check and stop circular updates.
2956    if ("development" !== 'production' && has[id] != null) {
2957      circular[id] = (circular[id] || 0) + 1;
2958      if (circular[id] > MAX_UPDATE_COUNT) {
2959        warn(
2960          'You may have an infinite update loop ' + (
2961            watcher.user
2962              ? ("in watcher with expression \"" + (watcher.expression) + "\"")
2963              : "in a component render function."
2964          ),
2965          watcher.vm
2966        );
2967        break
2968      }
2969    }
2970  }
2971
2972  // keep copies of post queues before resetting state
2973  var activatedQueue = activatedChildren.slice();
2974  var updatedQueue = queue.slice();
2975
2976  resetSchedulerState();
2977
2978  // call component updated and activated hooks
2979  callActivatedHooks(activatedQueue);
2980  callUpdatedHooks(updatedQueue);
2981
2982  // devtool hook
2983  /* istanbul ignore if */
2984  if (devtools && config.devtools) {
2985    devtools.emit('flush');
2986  }
2987}
2988
2989function callUpdatedHooks (queue) {
2990  var i = queue.length;
2991  while (i--) {
2992    var watcher = queue[i];
2993    var vm = watcher.vm;
2994    if (vm._watcher === watcher && vm._isMounted) {
2995      callHook(vm, 'updated');
2996    }
2997  }
2998}
2999
3000/**
3001 * Queue a kept-alive component that was activated during patch.
3002 * The queue will be processed after the entire tree has been patched.
3003 */
3004function queueActivatedComponent (vm) {
3005  // setting _inactive to false here so that a render function can
3006  // rely on checking whether it's in an inactive tree (e.g. router-view)
3007  vm._inactive = false;
3008  activatedChildren.push(vm);
3009}
3010
3011function callActivatedHooks (queue) {
3012  for (var i = 0; i < queue.length; i++) {
3013    queue[i]._inactive = true;
3014    activateChildComponent(queue[i], true /* true */);
3015  }
3016}
3017
3018/**
3019 * Push a watcher into the watcher queue.
3020 * Jobs with duplicate IDs will be skipped unless it's
3021 * pushed when the queue is being flushed.
3022 */
3023function queueWatcher (watcher) {
3024  var id = watcher.id;
3025  if (has[id] == null) {
3026    has[id] = true;
3027    if (!flushing) {
3028      queue.push(watcher);
3029    } else {
3030      // if already flushing, splice the watcher based on its id
3031      // if already past its id, it will be run next immediately.
3032      var i = queue.length - 1;
3033      while (i > index && queue[i].id > watcher.id) {
3034        i--;
3035      }
3036      queue.splice(i + 1, 0, watcher);
3037    }
3038    // queue the flush
3039    if (!waiting) {
3040      waiting = true;
3041      nextTick(flushSchedulerQueue);
3042    }
3043  }
3044}
3045
3046/*  */
3047
3048var uid$2 = 0;
3049
3050/**
3051 * A watcher parses an expression, collects dependencies,
3052 * and fires callback when the expression value changes.
3053 * This is used for both the $watch() api and directives.
3054 */
3055var Watcher = function Watcher (
3056  vm,
3057  expOrFn,
3058  cb,
3059  options,
3060  isRenderWatcher
3061) {
3062  this.vm = vm;
3063  if (isRenderWatcher) {
3064    vm._watcher = this;
3065  }
3066  vm._watchers.push(this);
3067  // options
3068  if (options) {
3069    this.deep = !!options.deep;
3070    this.user = !!options.user;
3071    this.lazy = !!options.lazy;
3072    this.sync = !!options.sync;
3073  } else {
3074    this.deep = this.user = this.lazy = this.sync = false;
3075  }
3076  this.cb = cb;
3077  this.id = ++uid$2; // uid for batching
3078  this.active = true;
3079  this.dirty = this.lazy; // for lazy watchers
3080  this.deps = [];
3081  this.newDeps = [];
3082  this.depIds = new _Set();
3083  this.newDepIds = new _Set();
3084  this.expression = expOrFn.toString();
3085  // parse expression for getter
3086  if (typeof expOrFn === 'function') {
3087    this.getter = expOrFn;
3088  } else {
3089    this.getter = parsePath(expOrFn);
3090    if (!this.getter) {
3091      this.getter = function () {};
3092      "development" !== 'production' && warn(
3093        "Failed watching path: \"" + expOrFn + "\" " +
3094        'Watcher only accepts simple dot-delimited paths. ' +
3095        'For full control, use a function instead.',
3096        vm
3097      );
3098    }
3099  }
3100  this.value = this.lazy
3101    ? undefined
3102    : this.get();
3103};
3104
3105/**
3106 * Evaluate the getter, and re-collect dependencies.
3107 */
3108Watcher.prototype.get = function get () {
3109  pushTarget(this);
3110  var value;
3111  var vm = this.vm;
3112  try {
3113    value = this.getter.call(vm, vm);
3114  } catch (e) {
3115    if (this.user) {
3116      handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
3117    } else {
3118      throw e
3119    }
3120  } finally {
3121    // "touch" every property so they are all tracked as
3122    // dependencies for deep watching
3123    if (this.deep) {
3124      traverse(value);
3125    }
3126    popTarget();
3127    this.cleanupDeps();
3128  }
3129  return value
3130};
3131
3132/**
3133 * Add a dependency to this directive.
3134 */
3135Watcher.prototype.addDep = function addDep (dep) {
3136  var id = dep.id;
3137  if (!this.newDepIds.has(id)) {
3138    this.newDepIds.add(id);
3139    this.newDeps.push(dep);
3140    if (!this.depIds.has(id)) {
3141      dep.addSub(this);
3142    }
3143  }
3144};
3145
3146/**
3147 * Clean up for dependency collection.
3148 */
3149Watcher.prototype.cleanupDeps = function cleanupDeps () {
3150    var this$1 = this;
3151
3152  var i = this.deps.length;
3153  while (i--) {
3154    var dep = this$1.deps[i];
3155    if (!this$1.newDepIds.has(dep.id)) {
3156      dep.removeSub(this$1);
3157    }
3158  }
3159  var tmp = this.depIds;
3160  this.depIds = this.newDepIds;
3161  this.newDepIds = tmp;
3162  this.newDepIds.clear();
3163  tmp = this.deps;
3164  this.deps = this.newDeps;
3165  this.newDeps = tmp;
3166  this.newDeps.length = 0;
3167};
3168
3169/**
3170 * Subscriber interface.
3171 * Will be called when a dependency changes.
3172 */
3173Watcher.prototype.update = function update () {
3174  /* istanbul ignore else */
3175  if (this.lazy) {
3176    this.dirty = true;
3177  } else if (this.sync) {
3178    this.run();
3179  } else {
3180    queueWatcher(this);
3181  }
3182};
3183
3184/**
3185 * Scheduler job interface.
3186 * Will be called by the scheduler.
3187 */
3188Watcher.prototype.run = function run () {
3189  if (this.active) {
3190    var value = this.get();
3191    if (
3192      value !== this.value ||
3193      // Deep watchers and watchers on Object/Arrays should fire even
3194      // when the value is the same, because the value may
3195      // have mutated.
3196      isObject(value) ||
3197      this.deep
3198    ) {
3199      // set new value
3200      var oldValue = this.value;
3201      this.value = value;
3202      if (this.user) {
3203        try {
3204          this.cb.call(this.vm, value, oldValue);
3205        } catch (e) {
3206          handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
3207        }
3208      } else {
3209        this.cb.call(this.vm, value, oldValue);
3210      }
3211    }
3212  }
3213};
3214
3215/**
3216 * Evaluate the value of the watcher.
3217 * This only gets called for lazy watchers.
3218 */
3219Watcher.prototype.evaluate = function evaluate () {
3220  this.value = this.get();
3221  this.dirty = false;
3222};
3223
3224/**
3225 * Depend on all deps collected by this watcher.
3226 */
3227Watcher.prototype.depend = function depend () {
3228    var this$1 = this;
3229
3230  var i = this.deps.length;
3231  while (i--) {
3232    this$1.deps[i].depend();
3233  }
3234};
3235
3236/**
3237 * Remove self from all dependencies' subscriber list.
3238 */
3239Watcher.prototype.teardown = function teardown () {
3240    var this$1 = this;
3241
3242  if (this.active) {
3243    // remove self from vm's watcher list
3244    // this is a somewhat expensive operation so we skip it
3245    // if the vm is being destroyed.
3246    if (!this.vm._isBeingDestroyed) {
3247      remove(this.vm._watchers, this);
3248    }
3249    var i = this.deps.length;
3250    while (i--) {
3251      this$1.deps[i].removeSub(this$1);
3252    }
3253    this.active = false;
3254  }
3255};
3256
3257/*  */
3258
3259var sharedPropertyDefinition = {
3260  enumerable: true,
3261  configurable: true,
3262  get: noop,
3263  set: noop
3264};
3265
3266function proxy (target, sourceKey, key) {
3267  sharedPropertyDefinition.get = function proxyGetter () {
3268    return this[sourceKey][key]
3269  };
3270  sharedPropertyDefinition.set = function proxySetter (val) {
3271    this[sourceKey][key] = val;
3272  };
3273  Object.defineProperty(target, key, sharedPropertyDefinition);
3274}
3275
3276function initState (vm) {
3277  vm._watchers = [];
3278  var opts = vm.$options;
3279  if (opts.props) { initProps(vm, opts.props); }
3280  if (opts.methods) { initMethods(vm, opts.methods); }
3281  if (opts.data) {
3282    initData(vm);
3283  } else {
3284    observe(vm._data = {}, true /* asRootData */);
3285  }
3286  if (opts.computed) { initComputed(vm, opts.computed); }
3287  if (opts.watch && opts.watch !== nativeWatch) {
3288    initWatch(vm, opts.watch);
3289  }
3290}
3291
3292function initProps (vm, propsOptions) {
3293  var propsData = vm.$options.propsData || {};
3294  var props = vm._props = {};
3295  // cache prop keys so that future props updates can iterate using Array
3296  // instead of dynamic object key enumeration.
3297  var keys = vm.$options._propKeys = [];
3298  var isRoot = !vm.$parent;
3299  // root instance props should be converted
3300  observerState.shouldConvert = isRoot;
3301  var loop = function ( key ) {
3302    keys.push(key);
3303    var value = validateProp(key, propsOptions, propsData, vm);
3304    /* istanbul ignore else */
3305    {
3306      var hyphenatedKey = hyphenate(key);
3307      if (isReservedAttribute(hyphenatedKey) ||
3308          config.isReservedAttr(hyphenatedKey)) {
3309        warn(
3310          ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),
3311          vm
3312        );
3313      }
3314      defineReactive(props, key, value, function () {
3315        if (vm.$parent && !isUpdatingChildComponent) {
3316          warn(
3317            "Avoid mutating a prop directly since the value will be " +
3318            "overwritten whenever the parent component re-renders. " +
3319            "Instead, use a data or computed property based on the prop's " +
3320            "value. Prop being mutated: \"" + key + "\"",
3321            vm
3322          );
3323        }
3324      });
3325    }
3326    // static props are already proxied on the component's prototype
3327    // during Vue.extend(). We only need to proxy props defined at
3328    // instantiation here.
3329    if (!(key in vm)) {
3330      proxy(vm, "_props", key);
3331    }
3332  };
3333
3334  for (var key in propsOptions) loop( key );
3335  observerState.shouldConvert = true;
3336}
3337
3338function initData (vm) {
3339  var data = vm.$options.data;
3340  data = vm._data = typeof data === 'function'
3341    ? getData(data, vm)
3342    : data || {};
3343  if (!isPlainObject(data)) {
3344    data = {};
3345    "development" !== 'production' && warn(
3346      'data functions should return an object:\n' +
3347      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
3348      vm
3349    );
3350  }
3351  // proxy data on instance
3352  var keys = Object.keys(data);
3353  var props = vm.$options.props;
3354  var methods = vm.$options.methods;
3355  var i = keys.length;
3356  while (i--) {
3357    var key = keys[i];
3358    {
3359      if (methods && hasOwn(methods, key)) {
3360        warn(
3361          ("Method \"" + key + "\" has already been defined as a data property."),
3362          vm
3363        );
3364      }
3365    }
3366    if (props && hasOwn(props, key)) {
3367      "development" !== 'production' && warn(
3368        "The data property \"" + key + "\" is already declared as a prop. " +
3369        "Use prop default value instead.",
3370        vm
3371      );
3372    } else if (!isReserved(key)) {
3373      proxy(vm, "_data", key);
3374    }
3375  }
3376  // observe data
3377  observe(data, true /* asRootData */);
3378}
3379
3380function getData (data, vm) {
3381  try {
3382    return data.call(vm, vm)
3383  } catch (e) {
3384    handleError(e, vm, "data()");
3385    return {}
3386  }
3387}
3388
3389var computedWatcherOptions = { lazy: true };
3390
3391function initComputed (vm, computed) {
3392  // $flow-disable-line
3393  var watchers = vm._computedWatchers = Object.create(null);
3394  // computed properties are just getters during SSR
3395  var isSSR = isServerRendering();
3396
3397  for (var key in computed) {
3398    var userDef = computed[key];
3399    var getter = typeof userDef === 'function' ? userDef : userDef.get;
3400    if ("development" !== 'production' && getter == null) {
3401      warn(
3402        ("Getter is missing for computed property \"" + key + "\"."),
3403        vm
3404      );
3405    }
3406
3407    if (!isSSR) {
3408      // create internal watcher for the computed property.
3409      watchers[key] = new Watcher(
3410        vm,
3411        getter || noop,
3412        noop,
3413        computedWatcherOptions
3414      );
3415    }
3416
3417    // component-defined computed properties are already defined on the
3418    // component prototype. We only need to define computed properties defined
3419    // at instantiation here.
3420    if (!(key in vm)) {
3421      defineComputed(vm, key, userDef);
3422    } else {
3423      if (key in vm.$data) {
3424        warn(("The computed property \"" + key + "\" is already defined in data."), vm);
3425      } else if (vm.$options.props && key in vm.$options.props) {
3426        warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
3427      }
3428    }
3429  }
3430}
3431
3432function defineComputed (
3433  target,
3434  key,
3435  userDef
3436) {
3437  var shouldCache = !isServerRendering();
3438  if (typeof userDef === 'function') {
3439    sharedPropertyDefinition.get = shouldCache
3440      ? createComputedGetter(key)
3441      : userDef;
3442    sharedPropertyDefinition.set = noop;
3443  } else {
3444    sharedPropertyDefinition.get = userDef.get
3445      ? shouldCache && userDef.cache !== false
3446        ? createComputedGetter(key)
3447        : userDef.get
3448      : noop;
3449    sharedPropertyDefinition.set = userDef.set
3450      ? userDef.set
3451      : noop;
3452  }
3453  if ("development" !== 'production' &&
3454      sharedPropertyDefinition.set === noop) {
3455    sharedPropertyDefinition.set = function () {
3456      warn(
3457        ("Computed property \"" + key + "\" was assigned to but it has no setter."),
3458        this
3459      );
3460    };
3461  }
3462  Object.defineProperty(target, key, sharedPropertyDefinition);
3463}
3464
3465function createComputedGetter (key) {
3466  return function computedGetter () {
3467    var watcher = this._computedWatchers && this._computedWatchers[key];
3468    if (watcher) {
3469      if (watcher.dirty) {
3470        watcher.evaluate();
3471      }
3472      if (Dep.target) {