http://www.ntanime.com/system/resource/vue/vue.js

1(function (global, factory) {
2  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
3  typeof define === 'function' && define.amd ? define(factory) :
4  (global = global || self, global.Vue = factory());
5}(this, function () { 'use strict';
6
7  /*  */
8
9  var emptyObject = Object.freeze({});
10
11  // These helpers produce better VM code in JS engines due to their
12  // explicitness and function inlining.
13  function isUndef (v) {
14    return v === undefined || v === null
15  }
16
17  function isDef (v) {
18    return v !== undefined && v !== null
19  }
20
21  function isTrue (v) {
22    return v === true
23  }
24
25  function isFalse (v) {
26    return v === false
27  }
28
29  /**
30   * Check if value is primitive.
31   */
32  function isPrimitive (value) {
33    return (
34      typeof value === 'string' ||
35      typeof value === 'number' ||
36      // $flow-disable-line
37      typeof value === 'symbol' ||
38      typeof value === 'boolean'
39    )
40  }
41
42  /**
43   * Quick object check - this is primarily used to tell
44   * Objects from primitive values when we know the value
45   * is a JSON-compliant type.
46   */
47  function isObject (obj) {
48    return obj !== null && typeof obj === 'object'
49  }
50
51  /**
52   * Get the raw type string of a value, e.g., [object Object].
53   */
54  var _toString = Object.prototype.toString;
55
56  function toRawType (value) {
57    return _toString.call(value).slice(8, -1)
58  }
59
60  /**
61   * Strict object type check. Only returns true
62   * for plain JavaScript objects.
63   */
64  function isPlainObject (obj) {
65    return _toString.call(obj) === '[object Object]'
66  }
67
68  function isRegExp (v) {
69    return _toString.call(v) === '[object RegExp]'
70  }
71
72  /**
73   * Check if val is a valid array index.
74   */
75  function isValidArrayIndex (val) {
76    var n = parseFloat(String(val));
77    return n >= 0 && Math.floor(n) === n && isFinite(val)
78  }
79
80  function isPromise (val) {
81    return (
82      isDef(val) &&
83      typeof val.then === 'function' &&
84      typeof val.catch === 'function'
85    )
86  }
87
88  /**
89   * Convert a value to a string that is actually rendered.
90   */
91  function toString (val) {
92    return val == null
93      ? ''
94      : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
95        ? JSON.stringify(val, null, 2)
96        : String(val)
97  }
98
99  /**
100   * Convert an input value to a number for persistence.
101   * If the conversion fails, return original string.
102   */
103  function toNumber (val) {
104    var n = parseFloat(val);
105    return isNaN(n) ? val : n
106  }
107
108  /**
109   * Make a map and return a function for checking if a key
110   * is in that map.
111   */
112  function makeMap (
113    str,
114    expectsLowerCase
115  ) {
116    var map = Object.create(null);
117    var list = str.split(',');
118    for (var i = 0; i < list.length; i++) {
119      map[list[i]] = true;
120    }
121    return expectsLowerCase
122      ? function (val) { return map[val.toLowerCase()]; }
123      : function (val) { return map[val]; }
124  }
125
126  /**
127   * Check if a tag is a built-in tag.
128   */
129  var isBuiltInTag = makeMap('slot,component', true);
130
131  /**
132   * Check if an attribute is a reserved attribute.
133   */
134  var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
135
136  /**
137   * Remove an item from an array.
138   */
139  function remove (arr, item) {
140    if (arr.length) {
141      var index = arr.indexOf(item);
142      if (index > -1) {
143        return arr.splice(index, 1)
144      }
145    }
146  }
147
148  /**
149   * Check whether an object has the property.
150   */
151  var hasOwnProperty = Object.prototype.hasOwnProperty;
152  function hasOwn (obj, key) {
153    return hasOwnProperty.call(obj, key)
154  }
155
156  /**
157   * Create a cached version of a pure function.
158   */
159  function cached (fn) {
160    var cache = Object.create(null);
161    return (function cachedFn (str) {
162      var hit = cache[str];
163      return hit || (cache[str] = fn(str))
164    })
165  }
166
167  /**
168   * Camelize a hyphen-delimited string.
169   */
170  var camelizeRE = /-(\w)/g;
171  var camelize = cached(function (str) {
172    return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
173  });
174
175  /**
176   * Capitalize a string.
177   */
178  var capitalize = cached(function (str) {
179    return str.charAt(0).toUpperCase() + str.slice(1)
180  });
181
182  /**
183   * Hyphenate a camelCase string.
184   */
185  var hyphenateRE = /\B([A-Z])/g;
186  var hyphenate = cached(function (str) {
187    return str.replace(hyphenateRE, '-$1').toLowerCase()
188  });
189
190  /**
191   * Simple bind polyfill for environments that do not support it,
192   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
193   * since native bind is now performant enough in most browsers.
194   * But removing it would mean breaking code that was able to run in
195   * PhantomJS 1.x, so this must be kept for backward compatibility.
196   */
197
198  /* istanbul ignore next */
199  function polyfillBind (fn, ctx) {
200    function boundFn (a) {
201      var l = arguments.length;
202      return l
203        ? l > 1
204          ? fn.apply(ctx, arguments)
205          : fn.call(ctx, a)
206        : fn.call(ctx)
207    }
208
209    boundFn._length = fn.length;
210    return boundFn
211  }
212
213  function nativeBind (fn, ctx) {
214    return fn.bind(ctx)
215  }
216
217  var bind = Function.prototype.bind
218    ? nativeBind
219    : polyfillBind;
220
221  /**
222   * Convert an Array-like object to a real Array.
223   */
224  function toArray (list, start) {
225    start = start || 0;
226    var i = list.length - start;
227    var ret = new Array(i);
228    while (i--) {
229      ret[i] = list[i + start];
230    }
231    return ret
232  }
233
234  /**
235   * Mix properties into target object.
236   */
237  function extend (to, _from) {
238    for (var key in _from) {
239      to[key] = _from[key];
240    }
241    return to
242  }
243
244  /**
245   * Merge an Array of Objects into a single Object.
246   */
247  function toObject (arr) {
248    var res = {};
249    for (var i = 0; i < arr.length; i++) {
250      if (arr[i]) {
251        extend(res, arr[i]);
252      }
253    }
254    return res
255  }
256
257  /* eslint-disable no-unused-vars */
258
259  /**
260   * Perform no operation.
261   * Stubbing args to make Flow happy without leaving useless transpiled code
262   */
263  function noop (a, b, c) {}
264
265  /**
266   * Always return false.
267   */
268  var no = function (a, b, c) { return false; };
269
270  /* eslint-enable no-unused-vars */
271
272  /**
273   * Return the same value.
274   */
275  var identity = function (_) { return _; };
276
277  /**
278   * Generate a string containing static keys from compiler modules.
279   */
280  function genStaticKeys (modules) {
281    return modules.reduce(function (keys, m) {
282      return keys.concat(m.staticKeys || [])
283    }, []).join(',')
284  }
285
286  /**
287   * Check if two values are loosely equal - that is,
288   * if they are plain objects, do they have the same shape?
289   */
290  function looseEqual (a, b) {
291    if (a === b) { return true }
292    var isObjectA = isObject(a);
293    var isObjectB = isObject(b);
294    if (isObjectA && isObjectB) {
295      try {
296        var isArrayA = Array.isArray(a);
297        var isArrayB = Array.isArray(b);
298        if (isArrayA && isArrayB) {
299          return a.length === b.length && a.every(function (e, i) {
300            return looseEqual(e, b[i])
301          })
302        } else if (a instanceof Date && b instanceof Date) {
303          return a.getTime() === b.getTime()
304        } else if (!isArrayA && !isArrayB) {
305          var keysA = Object.keys(a);
306          var keysB = Object.keys(b);
307          return keysA.length === keysB.length && keysA.every(function (key) {
308            return looseEqual(a[key], b[key])
309          })
310        } else {
311          /* istanbul ignore next */
312          return false
313        }
314      } catch (e) {
315        /* istanbul ignore next */
316        return false
317      }
318    } else if (!isObjectA && !isObjectB) {
319      return String(a) === String(b)
320    } else {
321      return false
322    }
323  }
324
325  /**
326   * Return the first index at which a loosely equal value can be
327   * found in the array (if value is a plain object, the array must
328   * contain an object of the same shape), or -1 if it is not present.
329   */
330  function looseIndexOf (arr, val) {
331    for (var i = 0; i < arr.length; i++) {
332      if (looseEqual(arr[i], val)) { return i }
333    }
334    return -1
335  }
336
337  /**
338   * Ensure a function is called only once.
339   */
340  function once (fn) {
341    var called = false;
342    return function () {
343      if (!called) {
344        called = true;
345        fn.apply(this, arguments);
346      }
347    }
348  }
349
350  var SSR_ATTR = 'data-server-rendered';
351
352  var ASSET_TYPES = [
353    'component',
354    'directive',
355    'filter'
356  ];
357
358  var LIFECYCLE_HOOKS = [
359    'beforeCreate',
360    'created',
361    'beforeMount',
362    'mounted',
363    'beforeUpdate',
364    'updated',
365    'beforeDestroy',
366    'destroyed',
367    'activated',
368    'deactivated',
369    'errorCaptured',
370    'serverPrefetch'
371  ];
372
373  /*  */
374
375
376
377  var config = ({
378    /**
379     * Option merge strategies (used in core/util/options)
380     */
381    // $flow-disable-line
382    optionMergeStrategies: Object.create(null),
383
384    /**
385     * Whether to suppress warnings.
386     */
387    silent: false,
388
389    /**
390     * Show production mode tip message on boot?
391     */
392    productionTip: "development" !== 'production',
393
394    /**
395     * Whether to enable devtools
396     */
397    devtools: "development" !== 'production',
398
399    /**
400     * Whether to record perf
401     */
402    performance: false,
403
404    /**
405     * Error handler for watcher errors
406     */
407    errorHandler: null,
408
409    /**
410     * Warn handler for watcher warns
411     */
412    warnHandler: null,
413
414    /**
415     * Ignore certain custom elements
416     */
417    ignoredElements: [],
418
419    /**
420     * Custom user key aliases for v-on
421     */
422    // $flow-disable-line
423    keyCodes: Object.create(null),
424
425    /**
426     * Check if a tag is reserved so that it cannot be registered as a

427     * component. This is platform-dependent and may be overwritten.
428     */
429    isReservedTag: no,
430
431    /**
432     * Check if an attribute is reserved so that it cannot be used as a component
433     * prop. This is platform-dependent and may be overwritten.
434     */
435    isReservedAttr: no,
436
437    /**
438     * Check if a tag is an unknown element.
439     * Platform-dependent.
440     */
441    isUnknownElement: no,
442
443    /**
444     * Get the namespace of an element
445     */
446    getTagNamespace: noop,
447
448    /**
449     * Parse the real tag name for the specific platform.
450     */
451    parsePlatformTagName: identity,
452
453    /**
454     * Check if an attribute must be bound using property, e.g. value
455     * Platform-dependent.
456     */
457    mustUseProp: no,
458
459    /**
460     * Perform updates asynchronously. Intended to be used by Vue Test Utils
461     * This will significantly reduce performance if set to false.
462     */
463    async: true,
464
465    /**
466     * Exposed for legacy reasons
467     */
468    _lifecycleHooks: LIFECYCLE_HOOKS
469  });
470
471  /*  */
472
473  /**
474   * unicode letters used for parsing html tags, component names and property paths.
475   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
476   */
477  var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
478
479  /**
480   * Check if a string starts with $ or _
481   */
482  function isReserved (str) {
483    var c = (str + '').charCodeAt(0);
484    return c === 0x24 || c === 0x5F
485  }
486
487  /**
488   * Define a property.
489   */
490  function def (obj, key, val, enumerable) {
491    Object.defineProperty(obj, key, {
492      value: val,
493      enumerable: !!enumerable,
494      writable: true,
495      configurable: true
496    });
497  }
498
499  /**
500   * Parse simple path.
501   */
502  var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
503  function parsePath (path) {
504    if (bailRE.test(path)) {
505      return
506    }
507    var segments = path.split('.');
508    return function (obj) {
509      for (var i = 0; i < segments.length; i++) {
510        if (!obj) { return }
511        obj = obj[segments[i]];
512      }
513      return obj
514    }
515  }
516
517  /*  */
518
519  // can we use __proto__?
520  var hasProto = '__proto__' in {};
521
522  // Browser environment sniffing
523  var inBrowser = typeof window !== 'undefined';
524  var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
525  var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
526  var UA = inBrowser && window.navigator.userAgent.toLowerCase();
527  var isIE = UA && /msie|trident/.test(UA);
528  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
529  var isEdge = UA && UA.indexOf('edge/') > 0;
530  var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
531  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
532  var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
533  var isPhantomJS = UA && /phantomjs/.test(UA);
534  var isFF = UA && UA.match(/firefox\/(\d+)/);
535
536  // Firefox has a "watch" function on Object.prototype...
537  var nativeWatch = ({}).watch;
538
539  var supportsPassive = false;
540  if (inBrowser) {
541    try {
542      var opts = {};
543      Object.defineProperty(opts, 'passive', ({
544        get: function get () {
545          /* istanbul ignore next */
546          supportsPassive = true;
547        }
548      }));
549      window.addEventListener('test-passive', null, opts);
550    } catch (e) {}
551  }
552
553  // this needs to be lazy-evaled because vue may be required before
554  // vue-server-renderer can set VUE_ENV
555  var _isServer;
556  var isServerRendering = function () {
557    if (_isServer === undefined) {
558      /* istanbul ignore if */
559      if (!inBrowser && !inWeex && typeof global !== 'undefined') {
560        // detect presence of vue-server-renderer and avoid
561        // Webpack shimming the process
562        _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
563      } else {
564        _isServer = false;
565      }
566    }
567    return _isServer
568  };
569
570  // detect devtools
571  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
572
573  /* istanbul ignore next */
574  function isNative (Ctor) {
575    return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
576  }
577
578  var hasSymbol =
579    typeof Symbol !== 'undefined' && isNative(Symbol) &&
580    typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
581
582  var _Set;
583  /* istanbul ignore if */ // $flow-disable-line
584  if (typeof Set !== 'undefined' && isNative(Set)) {
585    // use native Set when available.
586    _Set = Set;
587  } else {
588    // a non-standard Set polyfill that only works with primitive keys.
589    _Set = /*@__PURE__*/(function () {
590      function Set () {
591        this.set = Object.create(null);
592      }
593      Set.prototype.has = function has (key) {
594        return this.set[key] === true
595      };
596      Set.prototype.add = function add (key) {
597        this.set[key] = true;
598      };
599      Set.prototype.clear = function clear () {
600        this.set = Object.create(null);
601      };
602
603      return Set;
604    }());
605  }
606
607  /*  */
608
609  var warn = noop;
610  var tip = noop;
611  var generateComponentTrace = (noop); // work around flow check
612  var formatComponentName = (noop);
613
614  {
615    var hasConsole = typeof console !== 'undefined';
616    var classifyRE = /(?:^|[-_])(\w)/g;
617    var classify = function (str) { return str
618      .replace(classifyRE, function (c) { return c.toUpperCase(); })
619      .replace(/[-_]/g, ''); };
620
621    warn = function (msg, vm) {
622      var trace = vm ? generateComponentTrace(vm) : '';
623
624      if (config.warnHandler) {
625        config.warnHandler.call(null, msg, vm, trace);
626      } else if (hasConsole && (!config.silent)) {
627        console.error(("[Vue warn]: " + msg + trace));
628      }
629    };
630
631    tip = function (msg, vm) {
632      if (hasConsole && (!config.silent)) {
633        console.warn("[Vue tip]: " + msg + (
634          vm ? generateComponentTrace(vm) : ''
635        ));
636      }
637    };
638
639    formatComponentName = function (vm, includeFile) {
640      if (vm.$root === vm) {
641        return '<Root>'
642      }
643      var options = typeof vm === 'function' && vm.cid != null
644        ? vm.options
645        : vm._isVue
646          ? vm.$options || vm.constructor.options
647          : vm;
648      var name = options.name || options._componentTag;
649      var file = options.__file;
650      if (!name && file) {
651        var match = file.match(/([^/\\]+)\.vue$/);
652        name = match && match[1];
653      }
654
655      return (
656        (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
657        (file && includeFile !== false ? (" at " + file) : '')
658      )
659    };
660
661    var repeat = function (str, n) {
662      var res = '';
663      while (n) {
664        if (n % 2 === 1) { res += str; }
665        if (n > 1) { str += str; }
666        n >>= 1;
667      }
668      return res
669    };
670
671    generateComponentTrace = function (vm) {
672      if (vm._isVue && vm.$parent) {
673        var tree = [];
674        var currentRecursiveSequence = 0;
675        while (vm) {
676          if (tree.length > 0) {
677            var last = tree[tree.length - 1];
678            if (last.constructor === vm.constructor) {
679              currentRecursiveSequence++;
680              vm = vm.$parent;
681              continue
682            } else if (currentRecursiveSequence > 0) {
683              tree[tree.length - 1] = [last, currentRecursiveSequence];
684              currentRecursiveSequence = 0;
685            }
686          }
687          tree.push(vm);
688          vm = vm.$parent;
689        }
690        return '\n\nfound in\n\n' + tree
691          .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
692              ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
693              : formatComponentName(vm))); })
694          .join('\n')
695      } else {
696        return ("\n\n(found in " + (formatComponentName(vm)) + ")")
697      }
698    };
699  }
700
701  /*  */
702
703  var uid = 0;
704
705  /**
706   * A dep is an observable that can have multiple
707   * directives subscribing to it.
708   */
709  var Dep = function Dep () {
710    this.id = uid++;
711    this.subs = [];
712  };
713
714  Dep.prototype.addSub = function addSub (sub) {
715    this.subs.push(sub);
716  };
717
718  Dep.prototype.removeSub = function removeSub (sub) {
719    remove(this.subs, sub);
720  };
721

791    this.asyncMeta = undefined;
792    this.isAsyncPlaceholder = false;
793  };
794
795  var prototypeAccessors = { child: { configurable: true } };
796
797  // DEPRECATED: alias for componentInstance for backwards compat.
798  /* istanbul ignore next */
799  prototypeAccessors.child.get = function () {
800    return this.componentInstance
801  };
802
803  Object.defineProperties( VNode.prototype, prototypeAccessors );
804
805  var createEmptyVNode = function (text) {
806    if ( text === void 0 ) text = '';
807
808    var node = new VNode();
809    node.text = text;
810    node.isComment = true;
811    return node
812  };
813
814  function createTextVNode (val) {
815    return new VNode(undefined, undefined, undefined, String(val))
816  }
817
818  // optimized shallow clone
819  // used for static nodes and slot nodes because they may be reused across
820  // multiple renders, cloning them avoids errors when DOM manipulations rely
821  // on their elm reference.
822  function cloneVNode (vnode) {
823    var cloned = new VNode(
824      vnode.tag,
825      vnode.data,
826      // #7975
827      // clone children array to avoid mutating original in case of cloning
828      // a child.
829      vnode.children && vnode.children.slice(),
830      vnode.text,
831      vnode.elm,
832      vnode.context,
833      vnode.componentOptions,
834      vnode.asyncFactory
835    );
836    cloned.ns = vnode.ns;
837    cloned.isStatic = vnode.isStatic;
838    cloned.key = vnode.key;
839    cloned.isComment = vnode.isComment;
840    cloned.fnContext = vnode.fnContext;
841    cloned.fnOptions = vnode.fnOptions;
842    cloned.fnScopeId = vnode.fnScopeId;
843    cloned.asyncMeta = vnode.asyncMeta;
844    cloned.isCloned = true;
845    return cloned
846  }
847
848  /*
849   * not type checking this file because flow doesn't play well with
850   * dynamically accessing methods on Array prototype
851   */
852
853  var arrayProto = Array.prototype;
854  var arrayMethods = Object.create(arrayProto);
855
856  var methodsToPatch = [
857    'push',
858    'pop',
859    'shift',
860    'unshift',
861    'splice',
862    'sort',
863    'reverse'
864  ];
865
866  /**
867   * Intercept mutating methods and emit events
868   */
869  methodsToPatch.forEach(function (method) {
870    // cache original method
871    var original = arrayProto[method];
872    def(arrayMethods, method, function mutator () {
873      var args = [], len = arguments.length;
874      while ( len-- ) args[ len ] = arguments[ len ];
875
876      var result = original.apply(this, args);
877      var ob = this.__ob__;
878      var inserted;
879      switch (method) {
880        case 'push':
881        case 'unshift':
882          inserted = args;
883          break
884        case 'splice':
885          inserted = args.slice(2);
886          break
887      }
888      if (inserted) { ob.observeArray(inserted); }
889      // notify change
890      ob.dep.notify();
891      return result
892    });
893  });
894
895  /*  */
896
897  var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
898
899  /**
900   * In some cases we may want to disable observation inside a component's
901   * update computation.
902   */
903  var shouldObserve = true;
904
905  function toggleObserving (value) {
906    shouldObserve = value;
907  }
908
909  /**
910   * Observer class that is attached to each observed
911   * object. Once attached, the observer converts the target
912   * object's property keys into getter/setters that
913   * collect dependencies and dispatch updates.
914   */
915  var Observer = function Observer (value) {
916    this.value = value;
917    this.dep = new Dep();
918    this.vmCount = 0;
919    def(value, '__ob__', this);
920    if (Array.isArray(value)) {
921      if (hasProto) {
922        protoAugment(value, arrayMethods);
923      } else {
924        copyAugment(value, arrayMethods, arrayKeys);
925      }
926      this.observeArray(value);
927    } else {
928      this.walk(value);
929    }
930  };
931
932  /**
933   * Walk through all properties and convert them into
934   * getter/setters. This method should only be called when
935   * value type is Object.
936   */
937  Observer.prototype.walk = function walk (obj) {
938    var keys = Object.keys(obj);
939    for (var i = 0; i < keys.length; i++) {
940      defineReactive$$1(obj, keys[i]);
941    }
942  };
943
944  /**
945   * Observe a list of Array items.
946   */
947  Observer.prototype.observeArray = function observeArray (items) {
948    for (var i = 0, l = items.length; i < l; i++) {
949      observe(items[i]);
950    }
951  };
952
953  // helpers
954
955  /**
956   * Augment a target Object or Array by intercepting
957   * the prototype chain using __proto__
958   */
959  function protoAugment (target, src) {
960    /* eslint-disable no-proto */
961    target.__proto__ = src;
962    /* eslint-enable no-proto */
963  }
964
965  /**
966   * Augment a target Object or Array by defining
967   * hidden properties.
968   */
969  /* istanbul ignore next */
970  function copyAugment (target, src, keys) {
971    for (var i = 0, l = keys.length; i < l; i++) {
972      var key = keys[i];
973      def(target, key, src[key]);
974    }
975  }
976
977  /**
978   * Attempt to create an observer instance for a value,
979   * returns the new observer if successfully observed,
980   * or the existing observer if the value already has one.
981   */
982  function observe (value, asRootData) {
983    if (!isObject(value) || value instanceof VNode) {
984      return
985    }
986    var ob;
987    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
988      ob = value.__ob__;
989    } else if (
990      shouldObserve &&
991      !isServerRendering() &&
992      (Array.isArray(value) || isPlainObject(value)) &&
993      Object.isExtensible(value) &&
994      !value._isVue
995    ) {
996      ob = new Observer(value);
997    }
998    if (asRootData && ob) {
999      ob.vmCount++;
1000    }
1001    return ob
1002  }
1003
1004  /**
1005   * Define a reactive property on an Object.
1006   */
1007  function defineReactive$$1 (
1008    obj,
1009    key,
1010    val,
1011    customSetter,
1012    shallow
1013  ) {
1014    var dep = new Dep();
1015
1016    var property = Object.getOwnPropertyDescriptor(obj, key);
1017    if (property && property.configurable === false) {
1018      return
1019    }
1020
1021    // cater for pre-defined getter/setters
1022    var getter = property && property.get;
1023    var setter = property && property.set;
1024    if ((!getter || setter) && arguments.length === 2) {
1025      val = obj[key];
1026    }
1027
1028    var childOb = !shallow && observe(val);
1029    Object.defineProperty(obj, key, {
1030      enumerable: true,
1031      configurable: true,
1032      get: function reactiveGetter () {
1033        var value = getter ? getter.call(obj) : val;
1034        if (Dep.target) {
1035          dep.depend();
1036          if (childOb) {
1037            childOb.dep.depend();
1038            if (Array.isArray(value)) {
1039              dependArray(value);
1040            }
1041          }
1042        }
1043        return value
1044      },
1045      set: function reactiveSetter (newVal) {
1046        var value = getter ? getter.call(obj) : val;
1047        /* eslint-disable no-self-compare */
1048        if (newVal === value || (newVal !== newVal && value !== value)) {
1049          return
1050        }
1051        /* eslint-enable no-self-compare */
1052        if (customSetter) {
1053          customSetter();
1054        }
1055        // #7981: for accessor properties without setter
1056        if (getter && !setter) { return }
1057        if (setter) {
1058          setter.call(obj, newVal);
1059        } else {
1060          val = newVal;
1061        }
1062        childOb = !shallow && observe(newVal);
1063        dep.notify();
1064      }
1065    });
1066  }
1067
1068  /**
1069   * Set a property on an object. Adds the new property and
1070   * triggers change notification if the property doesn't
1071   * already exist.
1072   */
1073  function set (target, key, val) {
1074    if (isUndef(target) || isPrimitive(target)
1075    ) {
1076      warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
1077    }
1078    if (Array.isArray(target) && isValidArrayIndex(key)) {
1079      target.length = Math.max(target.length, key);
1080      target.splice(key, 1, val);
1081      return val
1082    }
1083    if (key in target && !(key in Object.prototype)) {
1084      target[key] = val;
1085      return val
1086    }
1087    var ob = (target).__ob__;
1088    if (target._isVue || (ob && ob.vmCount)) {
1089      warn(
1090        'Avoid adding reactive properties to a Vue instance or its root $data ' +
1091        'at runtime - declare it upfront in the data option.'
1092      );
1093      return val
1094    }
1095    if (!ob) {
1096      target[key] = val;
1097      return val
1098    }
1099    defineReactive$$1(ob.value, key, val);
1100    ob.dep.notify();
1101    return val
1102  }
1103
1104  /**
1105   * Delete a property and trigger change if necessary.
1106   */
1107  function del (target, key) {
1108    if (isUndef(target) || isPrimitive(target)
1109    ) {
1110      warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
1111    }
1112    if (Array.isArray(target) && isValidArrayIndex(key)) {
1113      target.splice(key, 1);
1114      return
1115    }
1116    var ob = (target).__ob__;
1117    if (target._isVue || (ob && ob.vmCount)) {
1118      warn(
1119        'Avoid deleting properties on a Vue instance or its root $data ' +
1120        '- just set it to null.'
1121      );
1122      return
1123    }
1124    if (!hasOwn(target, key)) {
1125      return
1126    }
1127    delete target[key];
1128    if (!ob) {
1129      return
1130    }
1131    ob.dep.notify();
1132  }
1133
1134  /**
1135   * Collect dependencies on array elements when the array is touched, since
1136   * we cannot intercept array element access like property getters.
1137   */
1138  function dependArray (value) {
1139    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
1140      e = value[i];
1141      e && e.__ob__ && e.__ob__.dep.depend();
1142      if (Array.isArray(e)) {
1143        dependArray(e);
1144      }
1145    }
1146  }
1147
1148  /*  */
1149
1150  /**
1151   * Option overwriting strategies are functions that handle
1152   * how to merge a parent option value and a child option
1153   * value into the final value.
1154   */
1155  var strats = config.optionMergeStrategies;
1156
1157  /**
1158   * Options with restrictions
1159   */
1160  {
1161    strats.el = strats.propsData = function (parent, child, vm, key) {
1162      if (!vm) {
1163        warn(
1164          "option \"" + key + "\" can only be used during instance " +
1165          'creation with the `new` keyword.'
1166        );
1167      }
1168      return defaultStrat(parent, child)
1169    };
1170  }
1171
1172  /**
1173   * Helper that recursively merges two data objects together.
1174   */
1175  function mergeData (to, from) {
1176    if (!from) { return to }
1177    var key, toVal, fromVal;
1178
1179    var keys = hasSymbol
1180      ? Reflect.ownKeys(from)
1181      : Object.keys(from);
1182
1183    for (var i = 0; i < keys.length; i++) {
1184      key = keys[i];
1185      // in case the object is already observed...
1186      if (key === '__ob__') { continue }
1187      toVal = to[key];
1188      fromVal = from[key];
1189      if (!hasOwn(to, key)) {
1190        set(to, key, fromVal);
1191      } else if (
1192        toVal !== fromVal &&
1193        isPlainObject(toVal) &&
1194        isPlainObject(fromVal)
1195      ) {
1196        mergeData(toVal, fromVal);
1197      }
1198    }
1199    return to
1200  }
1201
1202  /**
1203   * Data
1204   */
1205  function mergeDataOrFn (
1206    parentVal,
1207    childVal,
1208    vm
1209  ) {
1210    if (!vm) {
1211      // in a Vue.extend merge, both should be functions
1212      if (!childVal) {
1213        return parentVal
1214      }
1215      if (!parentVal) {
1216        return childVal
1217      }
1218      // when parentVal & childVal are both present,
1219      // we need to return a function that returns the
1220      // merged result of both functions... no need to
1221      // check if parentVal is a function here because
1222      // it has to be a function to pass previous merges.
1223      return function mergedDataFn () {
1224        return mergeData(
1225          typeof childVal === 'function' ? childVal.call(this, this) : childVal,
1226          typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
1227        )
1228      }
1229    } else {
1230      return function mergedInstanceDataFn () {
1231        // instance merge
1232        var instanceData = typeof childVal === 'function'
1233          ? childVal.call(vm, vm)
1234          : childVal;
1235        var defaultData = typeof parentVal === 'function'
1236          ? parentVal.call(vm, vm)
1237          : parentVal;
1238        if (instanceData) {
1239          return mergeData(instanceData, defaultData)
1240        } else {
1241          return defaultData
1242        }
1243      }
1244    }
1245  }
1246
1247  strats.data = function (
1248    parentVal,
1249    childVal,
1250    vm
1251  ) {
1252    if (!vm) {
1253      if (childVal && typeof childVal !== 'function') {
1254        warn(
1255          'The "data" option should be a function ' +
1256          'that returns a per-instance value in component ' +
1257          'definitions.',
1258          vm
1259        );
1260
1261        return parentVal
1262      }
1263      return mergeDataOrFn(parentVal, childVal)
1264    }
1265
1266    return mergeDataOrFn(parentVal, childVal, vm)
1267  };
1268
1269  /**
1270   * Hooks and props are merged as arrays.
1271   */
1272  function mergeHook (
1273    parentVal,
1274    childVal
1275  ) {
1276    var res = childVal
1277      ? parentVal
1278        ? parentVal.concat(childVal)
1279        : Array.isArray(childVal)
1280          ? childVal
1281          : [childVal]
1282      : parentVal;
1283    return res
1284      ? dedupeHooks(res)
1285      : res
1286  }
1287
1288  function dedupeHooks (hooks) {
1289    var res = [];
1290    for (var i = 0; i < hooks.length; i++) {
1291      if (res.indexOf(hooks[i]) === -1) {
1292        res.push(hooks[i]);
1293      }
1294    }
1295    return res
1296  }
1297
1298  LIFECYCLE_HOOKS.forEach(function (hook) {
1299    strats[hook] = mergeHook;
1300  });
1301
1302  /**
1303   * Assets
1304   *
1305   * When a vm is present (instance creation), we need to do
1306   * a three-way merge between constructor options, instance
1307   * options and parent options.
1308   */
1309  function mergeAssets (
1310    parentVal,
1311    childVal,
1312    vm,
1313    key
1314  ) {
1315    var res = Object.create(parentVal || null);
1316    if (childVal) {
1317      assertObjectType(key, childVal, vm);
1318      return extend(res, childVal)
1319    } else {
1320      return res
1321    }
1322  }
1323
1324  ASSET_TYPES.forEach(function (type) {
1325    strats[type + 's'] = mergeAssets;
1326  });
1327
1328  /**
1329   * Watchers.
1330   *
1331   * Watchers hashes should not overwrite one
1332   * another, so we merge them as arrays.
1333   */
1334  strats.watch = function (
1335    parentVal,
1336    childVal,
1337    vm,
1338    key
1339  ) {
1340    // work around Firefox's Object.prototype.watch...
1341    if (parentVal === nativeWatch) { parentVal = undefined; }
1342    if (childVal === nativeWatch) { childVal = undefined; }
1343    /* istanbul ignore if */
1344    if (!childVal) { return Object.create(parentVal || null) }
1345    {
1346      assertObjectType(key, childVal, vm);
1347    }
1348    if (!parentVal) { return childVal }
1349    var ret = {};
1350    extend(ret, parentVal);
1351    for (var key$1 in childVal) {
1352      var parent = ret[key$1];
1353      var child = childVal[key$1];
1354      if (parent && !Array.isArray(parent)) {
1355        parent = [parent];
1356      }
1357      ret[key$1] = parent
1358        ? parent.concat(child)
1359        : Array.isArray(child) ? child : [child];
1360    }
1361    return ret
1362  };
1363
1364  /**
1365   * Other object hashes.
1366   */
1367  strats.props =
1368  strats.methods =
1369  strats.inject =
1370  strats.computed = function (
1371    parentVal,
1372    childVal,
1373    vm,
1374    key
1375  ) {
1376    if (childVal && "development" !== 'production') {
1377      assertObjectType(key, childVal, vm);
1378    }
1379    if (!parentVal) { return childVal }
1380    var ret = Object.create(null);
1381    extend(ret, parentVal);
1382    if (childVal) { extend(ret, childVal); }
1383    return ret
1384  };
1385  strats.provide = mergeDataOrFn;
1386
1387  /**
1388   * Default strategy.
1389   */
1390  var defaultStrat = function (parentVal, childVal) {
1391    return childVal === undefined
1392      ? parentVal
1393      : childVal
1394  };
1395
1396  /**
1397   * Validate component names
1398   */
1399  function checkComponents (options) {
1400    for (var key in options.components) {
1401      validateComponentName(key);
1402    }
1403  }
1404
1405  function validateComponentName (name) {
1406    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
1407      warn(
1408        'Invalid component name: "' + name + '". Component names ' +
1409        'should conform to valid custom element name in html5 specification.'
1410      );
1411    }
1412    if (isBuiltInTag(name) || config.isReservedTag(name)) {
1413      warn(
1414        'Do not use built-in or reserved HTML elements as component ' +
1415        'id: ' + name
1416      );
1417    }
1418  }
1419
1420  /**
1421   * Ensure all props option syntax are normalized into the
1422   * Object-based format.
1423   */
1424  function normalizeProps (options, vm) {
1425    var props = options.props;
1426    if (!props) { return }
1427    var res = {};
1428    var i, val, name;
1429    if (Array.isArray(props)) {
1430      i = props.length;
1431      while (i--) {
1432        val = props[i];
1433        if (typeof val === 'string') {
1434          name = camelize(val);
1435          res[name] = { type: null };
1436        } else {
1437          warn('props must be strings when using array syntax.');
1438        }
1439      }
1440    } else if (isPlainObject(props)) {
1441      for (var key in props) {
1442        val = props[key];
1443        name = camelize(key);
1444        res[name] = isPlainObject(val)
1445          ? val
1446          : { type: val };
1447      }
1448    } else {
1449      warn(
1450        "Invalid value for option \"props\": expected an Array or an Object, " +
1451        "but got " + (toRawType(props)) + ".",
1452        vm
1453      );
1454    }
1455    options.props = res;
1456  }
1457
1458  /**
1459   * Normalize all injections into Object-based format
1460   */
1461  function normalizeInject (options, vm) {
1462    var inject = options.inject;
1463    if (!inject) { return }
1464    var normalized = options.inject = {};
1465    if (Array.isArray(inject)) {
1466      for (var i = 0; i < inject.length; i++) {
1467        normalized[inject[i]] = { from: inject[i] };
1468      }
1469    } else if (isPlainObject(inject)) {
1470      for (var key in inject) {
1471        var val = inject[key];
1472        normalized[key] = isPlainObject(val)
1473          ? extend({ from: key }, val)
1474          : { from: val };
1475      }
1476    } else {
1477      warn(
1478        "Invalid value for option \"inject\": expected an Array or an Object, " +
1479        "but got " + (toRawType(inject)) + ".",
1480        vm
1481      );
1482    }
1483  }
1484
1485  /**
1486   * Normalize raw function directives into object format.
1487   */
1488  function normalizeDirectives (options) {
1489    var dirs = options.directives;
1490    if (dirs) {
1491      for (var key in dirs) {
1492        var def$$1 = dirs[key];
1493        if (typeof def$$1 === 'function') {
1494          dirs[key] = { bind: def$$1, update: def$$1 };
1495        }
1496      }
1497    }
1498  }
1499
1500  function assertObjectType (name, value, vm) {
1501    if (!isPlainObject(value)) {
1502      warn(
1503        "Invalid value for option \"" + name + "\": expected an Object, " +
1504        "but got " + (toRawType(value)) + ".",
1505        vm
1506      );
1507    }
1508  }
1509
1510  /**
1511   * Merge two option objects into a new one.
1512   * Core utility used in both instantiation and inheritance.
1513   */
1514  function mergeOptions (
1515    parent,
1516    child,
1517    vm
1518  ) {
1519    {
1520      checkComponents(child);
1521    }
1522
1523    if (typeof child === 'function') {
1524      child = child.options;
1525    }
1526
1527    normalizeProps(child, vm);
1528    normalizeInject(child, vm);
1529    normalizeDirectives(child);
1530
1531    // Apply extends and mixins on the child options,
1532    // but only if it is a raw options object that isn't
1533    // the result of another mergeOptions call.
1534    // Only merged options has the _base property.
1535    if (!child._base) {
1536      if (child.extends) {
1537        parent = mergeOptions(parent, child.extends, vm);
1538      }
1539      if (child.mixins) {
1540        for (var i = 0, l = child.mixins.length; i < l; i++) {
1541          parent = mergeOptions(parent, child.mixins[i], vm);
1542        }
1543      }
1544    }
1545
1546    var options = {};
1547    var key;
1548    for (key in parent) {
1549      mergeField(key);
1550    }
1551    for (key in child) {
1552      if (!hasOwn(parent, key)) {
1553        mergeField(key);
1554      }
1555    }
1556    function mergeField (key) {
1557      var strat = strats[key] || defaultStrat;
1558      options[key] = strat(parent[key], child[key], vm, key);
1559    }
1560    return options
1561  }
1562
1563  /**
1564   * Resolve an asset.
1565   * This function is used because child instances need access
1566   * to assets defined in its ancestor chain.
1567   */
1568  function resolveAsset (
1569    options,
1570    type,
1571    id,
1572    warnMissing
1573  ) {
1574    /* istanbul ignore if */
1575    if (typeof id !== 'string') {
1576      return
1577    }
1578    var assets = options[type];
1579    // check local registration variations first
1580    if (hasOwn(assets, id)) { return assets[id] }
1581    var camelizedId = camelize(id);
1582    if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
1583    var PascalCaseId = capitalize(camelizedId);
1584    if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
1585    // fallback to prototype chain
1586    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
1587    if (warnMissing && !res) {
1588      warn(
1589        'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
1590        options
1591      );
1592    }
1593    return res
1594  }
1595
1596  /*  */
1597
1598
1599
1600  function validateProp (
1601    key,
1602    propOptions,
1603    propsData,
1604    vm
1605  ) {
1606    var prop = propOptions[key];
1607    var absent = !hasOwn(propsData, key);
1608    var value = propsData[key];
1609    // boolean casting
1610    var booleanIndex = getTypeIndex(Boolean, prop.type);
1611    if (booleanIndex > -1) {
1612      if (absent && !hasOwn(prop, 'default')) {
1613        value = false;
1614      } else if (value === '' || value === hyphenate(key)) {
1615        // only cast empty string / same name to boolean if
1616        // boolean has higher priority
1617        var stringIndex = getTypeIndex(String, prop.type);
1618        if (stringIndex < 0 || booleanIndex < stringIndex) {
1619          value = true;
1620        }
1621      }
1622    }
1623    // check default value
1624    if (value === undefined) {
1625      value = getPropDefaultValue(vm, prop, key);
1626      // since the default value is a fresh copy,
1627      // make sure to observe it.
1628      var prevShouldObserve = shouldObserve;
1629      toggleObserving(true);
1630      observe(value);
1631      toggleObserving(prevShouldObserve);
1632    }
1633    {
1634      assertProp(prop, key, value, vm, absent);
1635    }
1636    return value
1637  }
1638
1639  /**
1640   * Get the default value of a prop.
1641   */
1642  function getPropDefaultValue (vm, prop, key) {
1643    // no default, return undefined
1644    if (!hasOwn(prop, 'default')) {
1645      return undefined
1646    }
1647    var def = prop.default;
1648    // warn against non-factory defaults for Object & Array
1649    if (isObject(def)) {
1650      warn(
1651        'Invalid default value for prop "' + key + '": ' +
1652        'Props with type Object/Array must use a factory function ' +
1653        'to return the default value.',
1654        vm
1655      );
1656    }
1657    // the raw prop value was also undefined from previous render,

1658    // return previous default value to avoid unnecessary watcher trigger
1659    if (vm && vm.$options.propsData &&
1660      vm.$options.propsData[key] === undefined &&
1661      vm._props[key] !== undefined
1662    ) {
1663      return vm._props[key]
1664    }
1665    // call factory function for non-Function types
1666    // a value is Function if its prototype is function even across different execution context
1667    return typeof def === 'function' && getType(prop.type) !== 'Function'
1668      ? def.call(vm)
1669      : def
1670  }
1671
1672  /**
1673   * Assert whether a prop is valid.
1674   */
1675  function assertProp (
1676    prop,
1677    name,
1678    value,
1679    vm,
1680    absent
1681  ) {
1682    if (prop.required && absent) {
1683      warn(
1684        'Missing required prop: "' + name + '"',
1685        vm
1686      );
1687      return
1688    }
1689    if (value == null && !prop.required) {
1690      return
1691    }
1692    var type = prop.type;
1693    var valid = !type || type === true;
1694    var expectedTypes = [];
1695    if (type) {
1696      if (!Array.isArray(type)) {
1697        type = [type];
1698      }
1699      for (var i = 0; i < type.length && !valid; i++) {
1700        var assertedType = assertType(value, type[i]);
1701        expectedTypes.push(assertedType.expectedType || '');
1702        valid = assertedType.valid;
1703      }
1704    }
1705
1706    if (!valid) {
1707      warn(
1708        getInvalidTypeMessage(name, value, expectedTypes),
1709        vm
1710      );
1711      return
1712    }
1713    var validator = prop.validator;
1714    if (validator) {
1715      if (!validator(value)) {
1716        warn(
1717          'Invalid prop: custom validator check failed for prop "' + name + '".',
1718          vm
1719        );
1720      }
1721    }
1722  }
1723
1724  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
1725
1726  function assertType (value, type) {
1727    var valid;
1728    var expectedType = getType(type);
1729    if (simpleCheckRE.test(expectedType)) {
1730      var t = typeof value;
1731      valid = t === expectedType.toLowerCase();
1732      // for primitive wrapper objects
1733      if (!valid && t === 'object') {
1734        valid = value instanceof type;
1735      }
1736    } else if (expectedType === 'Object') {
1737      valid = isPlainObject(value);
1738    } else if (expectedType === 'Array') {
1739      valid = Array.isArray(value);
1740    } else {
1741      valid = value instanceof type;
1742    }
1743    return {
1744      valid: valid,
1745      expectedType: expectedType
1746    }
1747  }
1748
1749  /**
1750   * Use function string name to check built-in types,
1751   * because a simple equality check will fail when running
1752   * across different vms / iframes.
1753   */
1754  function getType (fn) {
1755    var match = fn && fn.toString().match(/^\s*function (\w+)/);
1756    return match ? match[1] : ''
1757  }
1758
1759  function isSameType (a, b) {
1760    return getType(a) === getType(b)
1761  }
1762
1763  function getTypeIndex (type, expectedTypes) {
1764    if (!Array.isArray(expectedTypes)) {
1765      return isSameType(expectedTypes, type) ? 0 : -1
1766    }
1767    for (var i = 0, len = expectedTypes.length; i < len; i++) {
1768      if (isSameType(expectedTypes[i], type)) {
1769        return i
1770      }
1771    }
1772    return -1
1773  }
1774
1775  function getInvalidTypeMessage (name, value, expectedTypes) {
1776    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
1777      " Expected " + (expectedTypes.map(capitalize).join(', '));
1778    var expectedType = expectedTypes[0];
1779    var receivedType = toRawType(value);
1780    var expectedValue = styleValue(value, expectedType);
1781    var receivedValue = styleValue(value, receivedType);
1782    // check if we need to specify expected value
1783    if (expectedTypes.length === 1 &&
1784        isExplicable(expectedType) &&
1785        !isBoolean(expectedType, receivedType)) {
1786      message += " with value " + expectedValue;
1787    }
1788    message += ", got " + receivedType + " ";
1789    // check if we need to specify received value
1790    if (isExplicable(receivedType)) {
1791      message += "with value " + receivedValue + ".";
1792    }
1793    return message
1794  }
1795
1796  function styleValue (value, type) {
1797    if (type === 'String') {
1798      return ("\"" + value + "\"")
1799    } else if (type === 'Number') {
1800      return ("" + (Number(value)))
1801    } else {
1802      return ("" + value)
1803    }
1804  }
1805
1806  function isExplicable (value) {
1807    var explicitTypes = ['string', 'number', 'boolean'];
1808    return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
1809  }
1810
1811  function isBoolean () {
1812    var args = [], len = arguments.length;
1813    while ( len-- ) args[ len ] = arguments[ len ];
1814
1815    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
1816  }
1817
1818  /*  */
1819
1820  function handleError (err, vm, info) {
1821    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
1822    pushTarget();
1823    try {
1824      if (vm) {
1825        var cur = vm;
1826        while ((cur = cur.$parent)) {
1827          var hooks = cur.$options.errorCaptured;
1828          if (hooks) {
1829            for (var i = 0; i < hooks.length; i++) {
1830              try {
1831                var capture = hooks[i].call(cur, err, vm, info) === false;
1832                if (capture) { return }
1833              } catch (e) {
1834                globalHandleError(e, cur, 'errorCaptured hook');
1835              }
1836            }
1837          }
1838        }
1839      }
1840      globalHandleError(err, vm, info);
1841    } finally {
1842      popTarget();
1843    }
1844  }
1845
1846  function invokeWithErrorHandling (
1847    handler,
1848    context,
1849    args,
1850    vm,
1851    info
1852  ) {
1853    var res;
1854    try {

1855      res = args ? handler.apply(context, args) : handler.call(context);
1856      if (res && !res._isVue && isPromise(res) && !res._handled) {
1857        res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
1858        // issue #9511
1859        // avoid catch triggering multiple times when nested calls
1860        res._handled = true;
1861      }
1862    } catch (e) {
1863      handleError(e, vm, info);
1864    }
1865    return res
1866  }
1867
1868  function globalHandleError (err, vm, info) {
1869    if (config.errorHandler) {
1870      try {
1871        return config.errorHandler.call(null, err, vm, info)
1872      } catch (e) {
1873        // if the user intentionally throws the original error in the handler,
1874        // do not log it twice
1875        if (e !== err) {
1876          logError(e, null, 'config.errorHandler');
1877        }
1878      }
1879    }
1880    logError(err, vm, info);
1881  }
1882
1883  function logError (err, vm, info) {
1884    {
1885      warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
1886    }
1887    /* istanbul ignore else */
1888    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
1889      console.error(err);
1890    } else {
1891      throw err
1892    }
1893  }
1894
1895  /*  */
1896
1897  var isUsingMicroTask = false;
1898
1899  var callbacks = [];
1900  var pending = false;
1901
1902  function flushCallbacks () {
1903    pending = false;
1904    var copies = callbacks.slice(0);
1905    callbacks.length = 0;
1906    for (var i = 0; i < copies.length; i++) {
1907      copies[i]();
1908    }
1909  }
1910
1911  // Here we have async deferring wrappers using microtasks.
1912  // In 2.5 we used (macro) tasks (in combination with microtasks).
1913  // However, it has subtle problems when state is changed right before repaint
1914  // (e.g. #6813, out-in transitions).
1915  // Also, using (macro) tasks in event handler would cause some weird behaviors
1916  // that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
1917  // So we now use microtasks everywhere, again.
1918  // A major drawback of this tradeoff is that there are some scenarios
1919  // where microtasks have too high a priority and fire in between supposedly
1920  // sequential events (e.g. #4521, #6690, which have workarounds)
1921  // or even between bubbling of the same event (#6566).
1922  var timerFunc;
1923
1924  // The nextTick behavior leverages the microtask queue, which can be accessed
1925  // via either native Promise.then or MutationObserver.
1926  // MutationObserver has wider support, however it is seriously bugged in
1927  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
1928  // completely stops working after triggering a few times... so, if native
1929  // Promise is available, we will use it:
1930  /* istanbul ignore next, $flow-disable-line */
1931  if (typeof Promise !== 'undefined' && isNative(Promise)) {
1932    var p = Promise.resolve();
1933    timerFunc = function () {
1934      p.then(flushCallbacks);
1935      // In problematic UIWebViews, Promise.then doesn't completely break, but
1936      // it can get stuck in a weird state where callbacks are pushed into the
1937      // microtask queue but the queue isn't being flushed, until the browser
1938      // needs to do some other work, e.g. handle a timer. Therefore we can
1939      // "force" the microtask queue to be flushed by adding an empty timer.
1940      if (isIOS) { setTimeout(noop); }
1941    };
1942    isUsingMicroTask = true;
1943  } else if (!isIE && typeof MutationObserver !== 'undefined' && (
1944    isNative(MutationObserver) ||
1945    // PhantomJS and iOS 7.x
1946    MutationObserver.toString() === '[object MutationObserverConstructor]'
1947  )) {
1948    // Use MutationObserver where native Promise is not available,
1949    // e.g. PhantomJS, iOS7, Android 4.4
1950    // (#6466 MutationObserver is unreliable in IE11)
1951    var counter = 1;
1952    var observer = new MutationObserver(flushCallbacks);
1953    var textNode = document.createTextNode(String(counter));
1954    observer.observe(textNode, {
1955      characterData: true
1956    });
1957    timerFunc = function () {
1958      counter = (counter + 1) % 2;
1959      textNode.data = String(counter);
1960    };
1961    isUsingMicroTask = true;
1962  } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
1963    // Fallback to setImmediate.
1964    // Techinically it leverages the (macro) task queue,
1965    // but it is still a better choice than setTimeout.

2311    if (isDef(hash)) {
2312      if (hasOwn(hash, key)) {
2313        res[key] = hash[key];
2314        if (!preserve) {
2315          delete hash[key];
2316        }
2317        return true
2318      } else if (hasOwn(hash, altKey)) {
2319        res[key] = hash[altKey];
2320        if (!preserve) {
2321          delete hash[altKey];
2322        }
2323        return true
2324      }
2325    }
2326    return false
2327  }
2328
2329  /*  */
2330
2331  // The template compiler attempts to minimize the need for normalization by
2332  // statically analyzing the template at compile time.
2333  //
2334  // For plain HTML markup, normalization can be completely skipped because the
2335  // generated render function is guaranteed to return Array<VNode>. There are
2336  // two cases where extra normalization is needed:
2337
2338  // 1. When the children contains components - because a functional component
2339  // may return an Array instead of a single root. In this case, just a simple
2340  // normalization is needed - if any child is an Array, we flatten the whole
2341  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
2342  // because functional components already normalize their own children.
2343  function simpleNormalizeChildren (children) {
2344    for (var i = 0; i < children.length; i++) {
2345      if (Array.isArray(children[i])) {
2346        return Array.prototype.concat.apply([], children)
2347      }
2348    }
2349    return children
2350  }
2351
2352  // 2. When the children contains constructs that always generated nested Arrays,
2353  // e.g. <template>, <slot>, v-for, or when the children is provided by user
2354  // with hand-written render functions / JSX. In such cases a full normalization
2355  // is needed to cater to all possible types of children values.
2356  function normalizeChildren (children) {
2357    return isPrimitive(children)
2358      ? [createTextVNode(children)]
2359      : Array.isArray(children)
2360        ? normalizeArrayChildren(children)
2361        : undefined
2362  }
2363
2364  function isTextNode (node) {
2365    return isDef(node) && isDef(node.text) && isFalse(node.isComment)
2366  }
2367
2368  function normalizeArrayChildren (children, nestedIndex) {
2369    var res = [];
2370    var i, c, lastIndex, last;
2371    for (i = 0; i < children.length; i++) {
2372      c = children[i];
2373      if (isUndef(c) || typeof c === 'boolean') { continue }
2374      lastIndex = res.length - 1;
2375      last = res[lastIndex];
2376      //  nested
2377      if (Array.isArray(c)) {
2378        if (c.length > 0) {
2379          c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
2380          // merge adjacent text nodes
2381          if (isTextNode(c[0]) && isTextNode(last)) {
2382            res[lastIndex] = createTextVNode(last.text + (c[0]).text);
2383            c.shift();
2384          }
2385          res.push.apply(res, c);
2386        }
2387      } else if (isPrimitive(c)) {
2388        if (isTextNode(last)) {
2389          // merge adjacent text nodes
2390          // this is necessary for SSR hydration because text nodes are
2391          // essentially merged when rendered to HTML strings
2392          res[lastIndex] = createTextVNode(last.text + c);
2393        } else if (c !== '') {
2394          // convert primitive to vnode
2395          res.push(createTextVNode(c));
2396        }
2397      } else {
2398        if (isTextNode(c) && isTextNode(last)) {
2399          // merge adjacent text nodes
2400          res[lastIndex] = createTextVNode(last.text + c.text);
2401        } else {
2402          // default key for nested array children (likely generated by v-for)
2403          if (isTrue(children._isVList) &&
2404            isDef(c.tag) &&
2405            isUndef(c.key) &&
2406            isDef(nestedIndex)) {
2407            c.key = "__vlist" + nestedIndex + "_" + i + "__";
2408          }
2409          res.push(c);
2410        }
2411      }
2412    }
2413    return res
2414  }
2415
2416  /*  */
2417
2418  function initProvide (vm) {
2419    var provide = vm.$options.provide;
2420    if (provide) {
2421      vm._provided = typeof provide === 'function'
2422        ? provide.call(vm)
2423        : provide;
2424    }
2425  }
2426
2427  function initInjections (vm) {
2428    var result = resolveInject(vm.$options.inject, vm);
2429    if (result) {
2430      toggleObserving(false);
2431      Object.keys(result).forEach(function (key) {
2432        /* istanbul ignore else */
2433        {
2434          defineReactive$$1(vm, key, result[key], function () {
2435            warn(
2436              "Avoid mutating an injected value directly since the changes will be " +
2437              "overwritten whenever the provided component re-renders. " +
2438              "injection being mutated: \"" + key + "\"",
2439              vm
2440            );
2441          });
2442        }
2443      });
2444      toggleObserving(true);
2445    }
2446  }
2447
2448  function resolveInject (inject, vm) {
2449    if (inject) {
2450      // inject is :any because flow is not smart enough to figure out cached
2451      var result = Object.create(null);
2452      var keys = hasSymbol
2453        ? Reflect.ownKeys(inject)
2454        : Object.keys(inject);
2455
2456      for (var i = 0; i < keys.length; i++) {
2457        var key = keys[i];
2458        // #6574 in case the inject object is observed...
2459        if (key === '__ob__') { continue }
2460        var provideKey = inject[key].from;
2461        var source = vm;
2462        while (source) {
2463          if (source._provided && hasOwn(source._provided, provideKey)) {
2464            result[key] = source._provided[provideKey];
2465            break
2466          }
2467          source = source.$parent;
2468        }
2469        if (!source) {
2470          if ('default' in inject[key]) {
2471            var provideDefault = inject[key].default;
2472            result[key] = typeof provideDefault === 'function'
2473              ? provideDefault.call(vm)
2474              : provideDefault;
2475          } else {
2476            warn(("Injection \"" + key + "\" not found"), vm);
2477          }
2478        }
2479      }
2480      return result
2481    }
2482  }
2483
2484  /*  */
2485
2486
2487
2488  /**
2489   * Runtime helper for resolving raw children VNodes into a slot object.
2490   */
2491  function resolveSlots (
2492    children,
2493    context
2494  ) {
2495    if (!children || !children.length) {
2496      return {}
2497    }
2498    var slots = {};
2499    for (var i = 0, l = children.length; i < l; i++) {
2500      var child = children[i];
2501      var data = child.data;
2502      // remove slot attribute if the node is resolved as a Vue slot node
2503      if (data && data.attrs && data.attrs.slot) {
2504        delete data.attrs.slot;
2505      }
2506      // named slots should only be respected if the vnode was rendered in the
2507      // same context.
2508      if ((child.context === context || child.fnContext === context) &&
2509        data && data.slot != null
2510      ) {
2511        var name = data.slot;
2512        var slot = (slots[name] || (slots[name] = []));
2513        if (child.tag === 'template') {
2514          slot.push.apply(slot, child.children || []);
2515        } else {
2516          slot.push(child);
2517        }
2518      } else {
2519        (slots.default || (slots.default = [])).push(child);
2520      }
2521    }
2522    // ignore slots that contains only whitespace
2523    for (var name$1 in slots) {
2524      if (slots[name$1].every(isWhitespace)) {
2525        delete slots[name$1];

2526      }
2527    }
2528    return slots
2529  }
2530
2531  function isWhitespace (node) {
2532    return (node.isComment && !node.asyncFactory) || node.text === ' '
2533  }
2534
2535  /*  */
2536
2537  function normalizeScopedSlots (
2538    slots,
2539    normalSlots,
2540    prevSlots
2541  ) {
2542    var res;
2543    var hasNormalSlots = Object.keys(normalSlots).length > 0;
2544    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
2545    var key = slots && slots.$key;
2546    if (!slots) {
2547      res = {};
2548    } else if (slots._normalized) {
2549      // fast path 1: child component re-render only, parent did not change
2550      return slots._normalized
2551    } else if (
2552      isStable &&
2553      prevSlots &&
2554      prevSlots !== emptyObject &&
2555      key === prevSlots.$key &&
2556      !hasNormalSlots &&
2557      !prevSlots.$hasNormal
2558    ) {
2559      // fast path 2: stable scoped slots w/ no normal slots to proxy,
2560      // only need to normalize once
2561      return prevSlots
2562    } else {
2563      res = {};
2564      for (var key$1 in slots) {
2565        if (slots[key$1] && key$1[0] !== '$') {
2566          res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
2567        }
2568      }
2569    }
2570    // expose normal slots on scopedSlots
2571    for (var key$2 in normalSlots) {
2572      if (!(key$2 in res)) {
2573        res[key$2] = proxyNormalSlot(normalSlots, key$2);
2574      }
2575    }
2576    // avoriaz seems to mock a non-extensible $scopedSlots object
2577    // and when that is passed down this would cause an error
2578    if (slots && Object.isExtensible(slots)) {
2579      (slots)._normalized = res;
2580    }
2581    def(res, '$stable', isStable);
2582    def(res, '$key', key);
2583    def(res, '$hasNormal', hasNormalSlots);
2584    return res
2585  }
2586
2587  function normalizeScopedSlot(normalSlots, key, fn) {
2588    var normalized = function () {
2589      var res = arguments.length ? fn.apply(null, arguments) : fn({});
2590      res = res && typeof res === 'object' && !Array.isArray(res)
2591        ? [res] // single vnode
2592        : normalizeChildren(res);
2593      return res && (
2594        res.length === 0 ||
2595        (res.length === 1 && res[0].isComment) // #9658
2596      ) ? undefined
2597        : res
2598    };
2599    // this is a slot using the new v-slot syntax without scope. although it is
2600    // compiled as a scoped slot, render fn users would expect it to be present
2601    // on this.$slots because the usage is semantically a normal slot.
2602    if (fn.proxy) {
2603      Object.defineProperty(normalSlots, key, {
2604        get: normalized,
2605        enumerable: true,
2606        configurable: true
2607      });
2608    }
2609    return normalized
2610  }
2611
2612  function proxyNormalSlot(slots, key) {
2613    return function () { return slots[key]; }
2614  }
2615
2616  /*  */
2617
2618  /**
2619   * Runtime helper for rendering v-for lists.
2620   */
2621  function renderList (
2622    val,
2623    render
2624  ) {
2625    var ret, i, l, keys, key;
2626    if (Array.isArray(val) || typeof val === 'string') {
2627      ret = new Array(val.length);
2628      for (i = 0, l = val.length; i < l; i++) {
2629        ret[i] = render(val[i], i);
2630      }
2631    } else if (typeof val === 'number') {
2632      ret = new Array(val);
2633      for (i = 0; i < val; i++) {
2634        ret[i] = render(i + 1, i);
2635      }
2636    } else if (isObject(val)) {
2637      if (hasSymbol && val[Symbol.iterator]) {
2638        ret = [];
2639        var iterator = val[Symbol.iterator]();
2640        var result = iterator.next();
2641        while (!result.done) {
2642          ret.push(render(result.value, ret.length));
2643          result = iterator.next();
2644        }
2645      } else {
2646        keys = Object.keys(val);
2647        ret = new Array(keys.length);
2648        for (i = 0, l = keys.length; i < l; i++) {
2649          key = keys[i];
2650          ret[i] = render(val[key], key, i);
2651        }
2652      }
2653    }
2654    if (!isDef(ret)) {
2655      ret = [];
2656    }
2657    (ret)._isVList = true;
2658    return ret
2659  }
2660
2661  /*  */
2662
2663  /**
2664   * Runtime helper for rendering <slot>
2665   */
2666  function renderSlot (
2667    name,
2668    fallback,
2669    props,
2670    bindObject
2671  ) {
2672    var scopedSlotFn = this.$scopedSlots[name];
2673    var nodes;
2674    if (scopedSlotFn) { // scoped slot
2675      props = props || {};
2676      if (bindObject) {
2677        if (!isObject(bindObject)) {
2678          warn(
2679            'slot v-bind without argument expects an Object',
2680            this
2681          );
2682        }
2683        props = extend(extend({}, bindObject), props);
2684      }
2685      nodes = scopedSlotFn(props) || fallback;
2686    } else {
2687      nodes = this.$slots[name] || fallback;
2688    }
2689
2690    var target = props && props.slot;
2691    if (target) {
2692      return this.$createElement('template', { slot: target }, nodes)
2693    } else {
2694      return nodes
2695    }
2696  }
2697
2698  /*  */
2699
2700  /**
2701   * Runtime helper for resolving filters
2702   */
2703  function resolveFilter (id) {
2704    return resolveAsset(this.$options, 'filters', id, true) || identity
2705  }
2706
2707  /*  */
2708
2709  function isKeyNotMatch (expect, actual) {
2710    if (Array.isArray(expect)) {
2711      return expect.indexOf(actual) === -1
2712    } else {
2713      return expect !== actual
2714    }
2715  }
2716
2717  /**
2718   * Runtime helper for checking keyCodes from config.
2719   * exposed as Vue.prototype._k
2720   * passing in eventKeyName as last argument separately for backwards compat
2721   */
2722  function checkKeyCodes (
2723    eventKeyCode,
2724    key,
2725    builtInKeyCode,
2726    eventKeyName,
2727    builtInKeyName
2728  ) {
2729    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
2730    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
2731      return isKeyNotMatch(builtInKeyName, eventKeyName)
2732    } else if (mappedKeyCode) {
2733      return isKeyNotMatch(mappedKeyCode, eventKeyCode)
2734    } else if (eventKeyName) {
2735      return hyphenate(eventKeyName) !== key
2736    }
2737  }
2738
2739  /*  */
2740
2741  /**
2742   * Runtime helper for merging v-bind="object" into a VNode's data.
2743   */
2744  function bindObjectProps (
2745    data,
2746    tag,
2747    value,
2748    asProp,
2749    isSync
2750  ) {
2751    if (value) {
2752      if (!isObject(value)) {
2753        warn(
2754          'v-bind without argument expects an Object or Array value',
2755          this
2756        );
2757      } else {
2758        if (Array.isArray(value)) {
2759          value = toObject(value);
2760        }
2761        var hash;
2762        var loop = function ( key ) {
2763          if (
2764            key === 'class' ||
2765            key === 'style' ||
2766            isReservedAttribute(key)
2767          ) {
2768            hash = data;
2769          } else {
2770            var type = data.attrs && data.attrs.type;
2771            hash = asProp || config.mustUseProp(tag, type, key)
2772              ? data.domProps || (data.domProps = {})
2773              : data.attrs || (data.attrs = {});
2774          }
2775          var camelizedKey = camelize(key);
2776          var hyphenatedKey = hyphenate(key);
2777          if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
2778            hash[key] = value[key];
2779
2780            if (isSync) {
2781              var on = data.on || (data.on = {});
2782              on[("update:" + key)] = function ($event) {
2783                value[key] = $event;
2784              };
2785            }
2786          }
2787        };
2788
2789        for (var key in value) loop( key );
2790      }
2791    }
2792    return data
2793  }
2794
2795  /*  */
2796
2797  /**
2798   * Runtime helper for rendering static trees.
2799   */