https://img.bfw.wiki/static/Blog/js/vue.js

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

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

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

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

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

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

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