https://planetherbs.pl/wp-content/plugins/acf-for-woocommerce/public/js/vue.js?ver=1.0.0

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

535    }
536  }
537  return _isServer
538};
539
540// detect devtools
541var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
542
543/* istanbul ignore next */
544function isNative (Ctor) {
545  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
546}
547
548var hasSymbol =
549  typeof Symbol !== 'undefined' && isNative(Symbol) &&
550  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
551
552var _Set;
553/* istanbul ignore if */ // $flow-disable-line
554if (typeof Set !== 'undefined' && isNative(Set)) {
555  // use native Set when available.
556  _Set = Set;
557} else {
558  // a non-standard Set polyfill that only works with primitive keys.
559  _Set = (function () {
560    function Set () {
561      this.set = Object.create(null);
562    }
563    Set.prototype.has = function has (key) {
564      return this.set[key] === true
565    };
566    Set.prototype.add = function add (key) {
567      this.set[key] = true;
568    };
569    Set.prototype.clear = function clear () {
570      this.set = Object.create(null);
571    };
572
573    return Set;
574  }());
575}
576
577/*  */
578
579var warn = noop;
580var tip = noop;
581var generateComponentTrace = (noop); // work around flow check
582var formatComponentName = (noop);
583
584{
585  var hasConsole = typeof console !== 'undefined';
586  var classifyRE = /(?:^|[-_])(\w)/g;
587  var classify = function (str) { return str
588    .replace(classifyRE, function (c) { return c.toUpperCase(); })
589    .replace(/[-_]/g, ''); };
590
591  warn = function (msg, vm) {
592    var trace = vm ? generateComponentTrace(vm) : '';
593
594    if (config.warnHandler) {
595      config.warnHandler.call(null, msg, vm, trace);
596    } else if (hasConsole && (!config.silent)) {
597      console.error(("[Vue warn]: " + msg + trace));
598    }
599  };
600
601  tip = function (msg, vm) {
602    if (hasConsole && (!config.silent)) {
603      console.warn("[Vue tip]: " + msg + (
604        vm ? generateComponentTrace(vm) : ''
605      ));
606    }
607  };
608
609  formatComponentName = function (vm, includeFile) {
610    if (vm.$root === vm) {
611      return '<Root>'
612    }
613    var options = typeof vm === 'function' && vm.cid != null
614      ? vm.options
615      : vm._isVue
616        ? vm.$options || vm.constructor.options
617        : vm || {};
618    var name = options.name || options._componentTag;
619    var file = options.__file;
620    if (!name && file) {
621      var match = file.match(/([^/\\]+)\.vue$/);
622      name = match && match[1];
623    }
624
625    return (
626      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
627      (file && includeFile !== false ? (" at " + file) : '')
628    )
629  };
630
631  var repeat = function (str, n) {
632    var res = '';
633    while (n) {
634      if (n % 2 === 1) { res += str; }
635      if (n > 1) { str += str; }
636      n >>= 1;
637    }
638    return res
639  };
640
641  generateComponentTrace = function (vm) {
642    if (vm._isVue && vm.$parent) {
643      var tree = [];
644      var currentRecursiveSequence = 0;
645      while (vm) {
646        if (tree.length > 0) {
647          var last = tree[tree.length - 1];
648          if (last.constructor === vm.constructor) {
649            currentRecursiveSequence++;
650            vm = vm.$parent;
651            continue
652          } else if (currentRecursiveSequence > 0) {
653            tree[tree.length - 1] = [last, currentRecursiveSequence];
654            currentRecursiveSequence = 0;
655          }
656        }
657        tree.push(vm);
658        vm = vm.$parent;
659      }
660      return '\n\nfound in\n\n' + tree
661        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
662            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
663            : formatComponentName(vm))); })
664        .join('\n')
665    } else {
666      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
667    }
668  };
669}
670
671/*  */
672
673
674var uid = 0;
675
676/**
677 * A dep is an observable that can have multiple
678 * directives subscribing to it.
679 */
680var Dep = function Dep () {
681  this.id = uid++;
682  this.subs = [];
683};
684
685Dep.prototype.addSub = function addSub (sub) {
686  this.subs.push(sub);
687};
688
689Dep.prototype.removeSub = function removeSub (sub) {
690  remove(this.subs, sub);
691};
692

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

1642  var validator = prop.validator;
1643  if (validator) {
1644    if (!validator(value)) {
1645      warn(
1646        'Invalid prop: custom validator check failed for prop "' + name + '".',
1647        vm
1648      );
1649    }
1650  }
1651}
1652
1653var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
1654
1655function assertType (value, type) {
1656  var valid;
1657  var expectedType = getType(type);
1658  if (simpleCheckRE.test(expectedType)) {
1659    var t = typeof value;
1660    valid = t === expectedType.toLowerCase();
1661    // for primitive wrapper objects
1662    if (!valid && t === 'object') {
1663      valid = value instanceof type;
1664    }
1665  } else if (expectedType === 'Object') {
1666    valid = isPlainObject(value);
1667  } else if (expectedType === 'Array') {
1668    valid = Array.isArray(value);
1669  } else {
1670    valid = value instanceof type;
1671  }
1672  return {
1673    valid: valid,
1674    expectedType: expectedType
1675  }
1676}
1677
1678/**
1679 * Use function string name to check built-in types,
1680 * because a simple equality check will fail when running
1681 * across different vms / iframes.
1682 */
1683function getType (fn) {
1684  var match = fn && fn.toString().match(/^\s*function (\w+)/);
1685  return match ? match[1] : ''
1686}
1687
1688function isSameType (a, b) {
1689  return getType(a) === getType(b)
1690}
1691
1692function getTypeIndex (type, expectedTypes) {
1693  if (!Array.isArray(expectedTypes)) {
1694    return isSameType(expectedTypes, type) ? 0 : -1
1695  }
1696  for (var i = 0, len = expectedTypes.length; i < len; i++) {
1697    if (isSameType(expectedTypes[i], type)) {
1698      return i
1699    }
1700  }
1701  return -1
1702}
1703
1704/*  */
1705
1706function handleError (err, vm, info) {
1707  if (vm) {
1708    var cur = vm;
1709    while ((cur = cur.$parent)) {
1710      var hooks = cur.$options.errorCaptured;
1711      if (hooks) {
1712        for (var i = 0; i < hooks.length; i++) {
1713          try {
1714            var capture = hooks[i].call(cur, err, vm, info) === false;
1715            if (capture) { return }
1716          } catch (e) {
1717            globalHandleError(e, cur, 'errorCaptured hook');
1718          }
1719        }
1720      }
1721    }
1722  }
1723  globalHandleError(err, vm, info);
1724}
1725
1726function globalHandleError (err, vm, info) {
1727  if (config.errorHandler) {
1728    try {
1729      return config.errorHandler.call(null, err, vm, info)
1730    } catch (e) {
1731      logError(e, null, 'config.errorHandler');
1732    }
1733  }
1734  logError(err, vm, info);
1735}
1736
1737function logError (err, vm, info) {
1738  {
1739    warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
1740  }
1741  /* istanbul ignore else */
1742  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
1743    console.error(err);
1744  } else {
1745    throw err
1746  }
1747}
1748
1749/*  */
1750/* globals MessageChannel */
1751
1752var callbacks = [];
1753var pending = false;
1754
1755function flushCallbacks () {
1756  pending = false;
1757  var copies = callbacks.slice(0);
1758  callbacks.length = 0;
1759  for (var i = 0; i < copies.length; i++) {
1760    copies[i]();
1761  }
1762}
1763
1764// Here we have async deferring wrappers using both microtasks and (macro) tasks.
1765// In < 2.4 we used microtasks everywhere, but there are some scenarios where
1766// microtasks have too high a priority and fire in between supposedly
1767// sequential events (e.g. #4521, #6690) or even between bubbling of the same
1768// event (#6566). However, using (macro) tasks everywhere also has subtle problems
1769// when state is changed right before repaint (e.g. #6813, out-in transitions).
1770// Here we use microtask by default, but expose a way to force (macro) task when
1771// needed (e.g. in event handlers attached by v-on).
1772var microTimerFunc;
1773var macroTimerFunc;
1774var useMacroTask = false;
1775
1776// Determine (macro) task defer implementation.
1777// Technically setImmediate should be the ideal choice, but it's only available
1778// in IE. The only polyfill that consistently queues the callback after all DOM
1779// events triggered in the same loop is by using MessageChannel.
1780/* istanbul ignore if */
1781if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
1782  macroTimerFunc = function () {
1783    setImmediate(flushCallbacks);
1784  };
1785} else if (typeof MessageChannel !== 'undefined' && (
1786  isNative(MessageChannel) ||
1787  // PhantomJS
1788  MessageChannel.toString() === '[object MessageChannelConstructor]'
1789)) {
1790  var channel = new MessageChannel();
1791  var port = channel.port2;
1792  channel.port1.onmessage = flushCallbacks;

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

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

2342    if (isObject(res)) {
2343      if (typeof res.then === 'function') {
2344        // () => Promise
2345        if (isUndef(factory.resolved)) {
2346          res.then(resolve, reject);
2347        }
2348      } else if (isDef(res.component) && typeof res.component.then === 'function') {
2349        res.component.then(resolve, reject);
2350
2351        if (isDef(res.error)) {
2352          factory.errorComp = ensureCtor(res.error, baseCtor);
2353        }
2354
2355        if (isDef(res.loading)) {
2356          factory.loadingComp = ensureCtor(res.loading, baseCtor);
2357          if (res.delay === 0) {
2358            factory.loading = true;
2359          } else {
2360            setTimeout(function () {
2361              if (isUndef(factory.resolved) && isUndef(factory.error)) {
2362                factory.loading = true;
2363                forceRender();
2364              }
2365            }, res.delay || 200);
2366          }
2367        }
2368
2369        if (isDef(res.timeout)) {
2370          setTimeout(function () {
2371            if (isUndef(factory.resolved)) {
2372              reject(
2373                "timeout (" + (res.timeout) + "ms)"
2374              );
2375            }
2376          }, res.timeout);
2377        }
2378      }
2379    }
2380
2381    sync = false;
2382    // return in case resolved synchronously
2383    return factory.loading
2384      ? factory.loadingComp
2385      : factory.resolved
2386  }
2387}
2388
2389/*  */
2390
2391function isAsyncPlaceholder (node) {
2392  return node.isComment && node.asyncFactory
2393}
2394
2395/*  */
2396
2397function getFirstComponentChild (children) {
2398  if (Array.isArray(children)) {
2399    for (var i = 0; i < children.length; i++) {
2400      var c = children[i];
2401      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
2402        return c
2403      }
2404    }
2405  }
2406}
2407
2408/*  */
2409
2410/*  */
2411
2412function initEvents (vm) {
2413  vm._events = Object.create(null);
2414  vm._hasHookEvent = false;
2415  // init parent attached events
2416  var listeners = vm.$options._parentListeners;
2417  if (listeners) {
2418    updateComponentListeners(vm, listeners);
2419  }
2420}
2421
2422var target;
2423
2424function add (event, fn, once) {
2425  if (once) {
2426    target.$once(event, fn);
2427  } else {
2428    target.$on(event, fn);
2429  }
2430}
2431
2432function remove$1 (event, fn) {
2433  target.$off(event, fn);
2434}
2435
2436function updateComponentListeners (
2437  vm,
2438  listeners,
2439  oldListeners
2440) {
2441  target = vm;
2442  updateListeners(listeners, oldListeners || {}, add, remove$1, vm);
2443  target = undefined;
2444}
2445
2446function eventsMixin (Vue) {
2447  var hookRE = /^hook:/;
2448  Vue.prototype.$on = function (event, fn) {
2449    var this$1 = this;
2450
2451    var vm = this;
2452    if (Array.isArray(event)) {
2453      for (var i = 0, l = event.length; i < l; i++) {
2454        this$1.$on(event[i], fn);
2455      }
2456    } else {
2457      (vm._events[event] || (vm._events[event] = [])).push(fn);
2458      // optimize hook:event cost by using a boolean flag marked at registration
2459      // instead of a hash lookup
2460      if (hookRE.test(event)) {
2461        vm._hasHookEvent = true;
2462      }
2463    }
2464    return vm
2465  };
2466
2467  Vue.prototype.$once = function (event, fn) {
2468    var vm = this;
2469    function on () {
2470      vm.$off(event, on);
2471      fn.apply(vm, arguments);
2472    }
2473    on.fn = fn;
2474    vm.$on(event, on);
2475    return vm
2476  };
2477
2478  Vue.prototype.$off = function (event, fn) {
2479    var this$1 = this;
2480
2481    var vm = this;
2482    // all
2483    if (!arguments.length) {
2484      vm._events = Object.create(null);
2485      return vm
2486    }
2487    // array of events
2488    if (Array.isArray(event)) {
2489      for (var i = 0, l = event.length; i < l; i++) {
2490        this$1.$off(event[i], fn);
2491      }
2492      return vm
2493    }
2494    // specific event
2495    var cbs = vm._events[event];
2496    if (!cbs) {
2497      return vm
2498    }
2499    if (!fn) {
2500      vm._events[event] = null;
2501      return vm
2502    }
2503    if (fn) {
2504      // specific handler
2505      var cb;
2506      var i$1 = cbs.length;
2507      while (i$1--) {
2508        cb = cbs[i$1];
2509        if (cb === fn || cb.fn === fn) {
2510          cbs.splice(i$1, 1);
2511          break
2512        }
2513      }
2514    }
2515    return vm
2516  };
2517
2518  Vue.prototype.$emit = function (event) {
2519    var vm = this;
2520    {
2521      var lowerCaseEvent = event.toLowerCase();
2522      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
2523        tip(
2524          "Event \"" + lowerCaseEvent + "\" is emitted in component " +
2525          (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
2526          "Note that HTML attributes are case-insensitive and you cannot use " +
2527          "v-on to listen to camelCase events when using in-DOM templates. " +
2528          "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
2529        );
2530      }
2531    }
2532    var cbs = vm._events[event];
2533    if (cbs) {
2534      cbs = cbs.length > 1 ? toArray(cbs) : cbs;
2535      var args = toArray(arguments, 1);
2536      for (var i = 0, l = cbs.length; i < l; i++) {
2537        try {
2538          cbs[i].apply(vm, args);
2539        } catch (e) {
2540          handleError(e, vm, ("event handler for \"" + event + "\""));
2541        }
2542      }
2543    }
2544    return vm
2545  };
2546}
2547
2548/*  */
2549
2550
2551
2552/**
2553 * Runtime helper for resolving raw children VNodes into a slot object.
2554 */
2555function resolveSlots (
2556  children,
2557  context
2558) {
2559  var slots = {};
2560  if (!children) {
2561    return slots
2562  }
2563  for (var i = 0, l = children.length; i < l; i++) {
2564    var child = children[i];
2565    var data = child.data;
2566    // remove slot attribute if the node is resolved as a Vue slot node
2567    if (data && data.attrs && data.attrs.slot) {
2568      delete data.attrs.slot;
2569    }
2570    // named slots should only be respected if the vnode was rendered in the
2571    // same context.
2572    if ((child.context === context || child.fnContext === context) &&
2573      data && data.slot != null
2574    ) {
2575      var name = data.slot;
2576      var slot = (slots[name] || (slots[name] = []));
2577      if (child.tag === 'template') {
2578        slot.push.apply(slot, child.children || []);
2579      } else {
2580        slot.push(child);
2581      }
2582    } else {
2583      (slots.default || (slots.default = [])).push(child);
2584    }
2585  }
2586  // ignore slots that contains only whitespace
2587  for (var name$1 in slots) {
2588    if (slots[name$1].every(isWhitespace)) {
2589      delete slots[name$1];
2590    }
2591  }
2592  return slots
2593}
2594
2595function isWhitespace (node) {
2596  return (node.isComment && !node.asyncFactory) || node.text === ' '
2597}
2598
2599function resolveScopedSlots (
2600  fns, // see flow/vnode
2601  res
2602) {
2603  res = res || {};
2604  for (var i = 0; i < fns.length; i++) {
2605    if (Array.isArray(fns[i])) {
2606      resolveScopedSlots(fns[i], res);
2607    } else {
2608      res[fns[i].key] = fns[i].fn;
2609    }
2610  }
2611  return res
2612}
2613
2614/*  */
2615
2616var activeInstance = null;
2617var isUpdatingChildComponent = false;
2618
2619function initLifecycle (vm) {
2620  var options = vm.$options;
2621
2622  // locate first non-abstract parent
2623  var parent = options.parent;
2624  if (parent && !options.abstract) {
2625    while (parent.$options.abstract && parent.$parent) {
2626      parent = parent.$parent;
2627    }
2628    parent.$children.push(vm);
2629  }
2630
2631  vm.$parent = parent;
2632  vm.$root = parent ? parent.$root : vm;
2633
2634  vm.$children = [];
2635  vm.$refs = {};
2636
2637  vm._watcher = null;
2638  vm._inactive = null;
2639  vm._directInactive = false;
2640  vm._isMounted = false;
2641  vm._isDestroyed = false;
2642  vm._isBeingDestroyed = false;
2643}
2644
2645function lifecycleMixin (Vue) {
2646  Vue.prototype._update = function (vnode, hydrating) {
2647    var vm = this;
2648    if (vm._isMounted) {
2649      callHook(vm, 'beforeUpdate');
2650    }
2651    var prevEl = vm.$el;
2652    var prevVnode = vm._vnode;
2653    var prevActiveInstance = activeInstance;
2654    activeInstance = vm;
2655    vm._vnode = vnode;
2656    // Vue.prototype.__patch__ is injected in entry points
2657    // based on the rendering backend used.
2658    if (!prevVnode) {
2659      // initial render
2660      vm.$el = vm.__patch__(
2661        vm.$el, vnode, hydrating, false /* removeOnly */,
2662        vm.$options._parentElm,
2663        vm.$options._refElm
2664      );
2665      // no need for the ref nodes after initial patch
2666      // this prevents keeping a detached DOM tree in memory (#5851)
2667      vm.$options._parentElm = vm.$options._refElm = null;
2668    } else {
2669      // updates
2670      vm.$el = vm.__patch__(prevVnode, vnode);
2671    }
2672    activeInstance = prevActiveInstance;
2673    // update __vue__ reference
2674    if (prevEl) {
2675      prevEl.__vue__ = null;
2676    }
2677    if (vm.$el) {
2678      vm.$el.__vue__ = vm;
2679    }
2680    // if parent is an HOC, update its $el as well
2681    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
2682      vm.$parent.$el = vm.$el;
2683    }
2684    // updated hook is called by the scheduler to ensure that children are
2685    // updated in a parent's updated hook.
2686  };
2687
2688  Vue.prototype.$forceUpdate = function () {
2689    var vm = this;
2690    if (vm._watcher) {