https://orangetreegolfcourse.com/wp-content/plugins/foreup-forms/assets/js/vendor.js?ver=1752007641

130/**
131 * Determine if a value is an ArrayBuffer
132 *
133 * @param {Object} val The value to test
134 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
135 */
136function isArrayBuffer(val) {
137  return toString.call(val) === '[object ArrayBuffer]';
138}
139
140/**
141 * Determine if a value is a FormData
142 *
143 * @param {Object} val The value to test
144 * @returns {boolean} True if value is an FormData, otherwise false
145 */
146function isFormData(val) {
147  return (typeof FormData !== 'undefined') && (val instanceof FormData);
148}
149
150/**
151 * Determine if a value is a view on an ArrayBuffer
152 *
153 * @param {Object} val The value to test
154 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
155 */
156function isArrayBufferView(val) {
157  var result;
158  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
159    result = ArrayBuffer.isView(val);
160  } else {
161    result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
162  }
163  return result;
164}
165
166/**
167 * Determine if a value is a String
168 *
169 * @param {Object} val The value to test
170 * @returns {boolean} True if value is a String, otherwise false
171 */
172function isString(val) {
173  return typeof val === 'string';
174}
175
176/**
177 * Determine if a value is a Number
178 *
179 * @param {Object} val The value to test
180 * @returns {boolean} True if value is a Number, otherwise false
181 */
182function isNumber(val) {
183  return typeof val === 'number';
184}
185
186/**
187 * Determine if a value is undefined
188 *
189 * @param {Object} val The value to test
190 * @returns {boolean} True if the value is undefined, otherwise false
191 */
192function isUndefined(val) {
193  return typeof val === 'undefined';
194}
195
196/**
197 * Determine if a value is an Object
198 *
199 * @param {Object} val The value to test
200 * @returns {boolean} True if value is an Object, otherwise false
201 */
202function isObject(val) {
203  return val !== null && typeof val === 'object';
204}
205
206/**
207 * Determine if a value is a Date
208 *
209 * @param {Object} val The value to test
210 * @returns {boolean} True if value is a Date, otherwise false
211 */
212function isDate(val) {
213  return toString.call(val) === '[object Date]';
214}
215
216/**
217 * Determine if a value is a File
218 *
219 * @param {Object} val The value to test
220 * @returns {boolean} True if value is a File, otherwise false
221 */
222function isFile(val) {
223  return toString.call(val) === '[object File]';
224}
225
226/**
227 * Determine if a value is a Blob
228 *
229 * @param {Object} val The value to test
230 * @returns {boolean} True if value is a Blob, otherwise false
231 */
232function isBlob(val) {
233  return toString.call(val) === '[object Blob]';
234}
235
236/**
237 * Determine if a value is a Function
238 *
239 * @param {Object} val The value to test
240 * @returns {boolean} True if value is a Function, otherwise false
241 */
242function isFunction(val) {
243  return toString.call(val) === '[object Function]';
244}
245
246/**
247 * Determine if a value is a Stream
248 *
249 * @param {Object} val The value to test
250 * @returns {boolean} True if value is a Stream, otherwise false
251 */
252function isStream(val) {
253  return isObject(val) && isFunction(val.pipe);
254}
255
256/**
257 * Determine if a value is a URLSearchParams object
258 *
259 * @param {Object} val The value to test
260 * @returns {boolean} True if value is a URLSearchParams object, otherwise false
261 */
262function isURLSearchParams(val) {
263  return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
264}
265
266/**
267 * Trim excess whitespace off the beginning and end of a string
268 *
269 * @param {String} str The String to trim
270 * @returns {String} The String freed of excess whitespace
271 */
272function trim(str) {
273  return str.replace(/^\s*/, '').replace(/\s*$/, '');
274}
275
276/**
277 * Determine if we're running in a standard browser environment
278 *
279 * This allows axios to run in a web worker, and react-native.
280 * Both environments support XMLHttpRequest, but not fully standard globals.
281 *
282 * web workers:
283 *  typeof window -> undefined
284 *  typeof document -> undefined
285 *
286 * react-native:
287 *  navigator.product -> 'ReactNative'
288 */
289function isStandardBrowserEnv() {
290  if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
291    return false;
292  }
293  return (
294    typeof window !== 'undefined' &&
295    typeof document !== 'undefined'
296  );
297}
298
299/**
300 * Iterate over an Array or an Object invoking a function for each item.
301 *
302 * If `obj` is an Array callback will be called passing
303 * the value, index, and complete array for each item.
304 *
305 * If 'obj' is an Object callback will be called passing
306 * the value, key, and complete object for each property.
307 *
308 * @param {Object|Array} obj The object to iterate
309 * @param {Function} fn The callback to invoke for each item
310 */
311function forEach(obj, fn) {
312  // Don't bother if no value provided
313  if (obj === null || typeof obj === 'undefined') {
314    return;
315  }
316
317  // Force an array if not already something iterable
318  if (typeof obj !== 'object') {
319    /*eslint no-param-reassign:0*/
320    obj = [obj];
321  }
322
323  if (isArray(obj)) {
324    // Iterate over array values
325    for (var i = 0, l = obj.length; i < l; i++) {
326      fn.call(null, obj[i], i, obj);
327    }
328  } else {
329    // Iterate over object keys
330    for (var key in obj) {
331      if (Object.prototype.hasOwnProperty.call(obj, key)) {
332        fn.call(null, obj[key], key, obj);
333      }
334    }
335  }
336}
337
338/**
339 * Accepts varargs expecting each argument to be an object, then
340 * immutably merges the properties of each object and returns result.
341 *
342 * When multiple objects contain the same key the later object in
343 * the arguments list will take precedence.
344 *
345 * Example:
346 *
347 * ```js
348 * var result = merge({foo: 123}, {foo: 456});
349 * console.log(result.foo); // outputs 456
350 * ```
351 *
352 * @param {Object} obj1 Object to merge
353 * @returns {Object} Result of all merge properties
354 */
355function merge(/* obj1, obj2, obj3, ... */) {
356  var result = {};
357  function assignValue(val, key) {
358    if (typeof result[key] === 'object' && typeof val === 'object') {
359      result[key] = merge(result[key], val);
360    } else {
361      result[key] = val;
362    }
363  }
364
365  for (var i = 0, l = arguments.length; i < l; i++) {

366    forEach(arguments[i], assignValue);
367  }
368  return result;
369}
370
371/**
372 * Extends object a by mutably adding to it the properties of object b.
373 *
374 * @param {Object} a The object to be extended
375 * @param {Object} b The object to copy properties from
376 * @param {Object} thisArg The object to bind function to
377 * @return {Object} The resulting value of object a
378 */
379function extend(a, b, thisArg) {
380  forEach(b, function assignValue(val, key) {
381    if (thisArg && typeof val === 'function') {
382      a[key] = bind(val, thisArg);
383    } else {
384      a[key] = val;
385    }
386  });
387  return a;
388}
389
390module.exports = {
391  isArray: isArray,
392  isArrayBuffer: isArrayBuffer,
393  isBuffer: isBuffer,
394  isFormData: isFormData,
395  isArrayBufferView: isArrayBufferView,
396  isString: isString,
397  isNumber: isNumber,
398  isObject: isObject,
399  isUndefined: isUndefined,
400  isDate: isDate,
401  isFile: isFile,
402  isBlob: isBlob,
403  isFunction: isFunction,
404  isStream: isStream,
405  isURLSearchParams: isURLSearchParams,
406  isStandardBrowserEnv: isStandardBrowserEnv,
407  forEach: forEach,
408  merge: merge,
409  extend: extend,
410  trim: trim
411};
412
413
414/***/ }),
415/* 1 */
416/***/ (function(module, exports) {
417
418// shim for using process in browser
419var process = module.exports = {};
420
421// cached from whatever global is present so that test runners that stub it
422// don't break things.  But we need to wrap it in a try catch in case it is
423// wrapped in strict mode code which doesn't define any globals.  It's inside a
424// function because try/catches deoptimize in certain engines.
425
426var cachedSetTimeout;
427var cachedClearTimeout;
428
429function defaultSetTimout() {
430    throw new Error('setTimeout has not been defined');
431}
432function defaultClearTimeout () {
433    throw new Error('clearTimeout has not been defined');
434}
435(function () {
436    try {
437        if (typeof setTimeout === 'function') {
438            cachedSetTimeout = setTimeout;
439        } else {
440            cachedSetTimeout = defaultSetTimout;
441        }
442    } catch (e) {
443        cachedSetTimeout = defaultSetTimout;
444    }
445    try {
446        if (typeof clearTimeout === 'function') {
447            cachedClearTimeout = clearTimeout;
448        } else {
449            cachedClearTimeout = defaultClearTimeout;
450        }
451    } catch (e) {
452        cachedClearTimeout = defaultClearTimeout;
453    }
454} ())
455function runTimeout(fun) {
456    if (cachedSetTimeout === setTimeout) {
457        //normal enviroments in sane situations
458        return setTimeout(fun, 0);
459    }
460    // if setTimeout wasn't available but was latter defined
461    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
462        cachedSetTimeout = setTimeout;
463        return setTimeout(fun, 0);
464    }
465    try {
466        // when when somebody has screwed with setTimeout but no I.E. maddness
467        return cachedSetTimeout(fun, 0);
468    } catch(e){
469        try {
470            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
471            return cachedSetTimeout.call(null, fun, 0);
472        } catch(e){
473            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
474            return cachedSetTimeout.call(this, fun, 0);
475        }
476    }
477
478
479}
480function runClearTimeout(marker) {
481    if (cachedClearTimeout === clearTimeout) {
482        //normal enviroments in sane situations
483        return clearTimeout(marker);
484    }
485    // if clearTimeout wasn't available but was latter defined
486    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
487        cachedClearTimeout = clearTimeout;
488        return clearTimeout(marker);
489    }
490    try {
491        // when when somebody has screwed with setTimeout but no I.E. maddness
492        return cachedClearTimeout(marker);
493    } catch (e){
494        try {
495            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
496            return cachedClearTimeout.call(null, marker);
497        } catch (e){
498            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
499            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
500            return cachedClearTimeout.call(this, marker);
501        }
502    }
503
504
505
506}
507var queue = [];
508var draining = false;

509var currentQueue;
510var queueIndex = -1;
511
512function cleanUpNextTick() {
513    if (!draining || !currentQueue) {
514        return;
515    }
516    draining = false;
517    if (currentQueue.length) {
518        queue = currentQueue.concat(queue);
519    } else {
520        queueIndex = -1;
521    }
522    if (queue.length) {
523        drainQueue();
524    }
525}
526
527function drainQueue() {
528    if (draining) {
529        return;
530    }
531    var timeout = runTimeout(cleanUpNextTick);
532    draining = true;
533
534    var len = queue.length;
535    while(len) {
536        currentQueue = queue;
537        queue = [];
538        while (++queueIndex < len) {
539            if (currentQueue) {
540                currentQueue[queueIndex].run();
541            }
542        }
543        queueIndex = -1;
544        len = queue.length;
545    }
546    currentQueue = null;
547    draining = false;
548    runClearTimeout(timeout);
549}
550
551process.nextTick = function (fun) {
552    var args = new Array(arguments.length - 1);
553    if (arguments.length > 1) {
554        for (var i = 1; i < arguments.length; i++) {
555            args[i - 1] = arguments[i];
556        }
557    }
558    queue.push(new Item(fun, args));
559    if (queue.length === 1 && !draining) {
560        runTimeout(drainQueue);
561    }
562};
563
564// v8 likes predictible objects
565function Item(fun, array) {
566    this.fun = fun;
567    this.array = array;
568}
569Item.prototype.run = function () {
570    this.fun.apply(null, this.array);
571};
572process.title = 'browser';
573process.browser = true;
574process.env = {};
575process.argv = [];
576process.version = ''; // empty string to avoid regexp issues
577process.versions = {};
578
579function noop() {}
580
581process.on = noop;
582process.addListener = noop;
583process.once = noop;
584process.off = noop;
585process.removeListener = noop;
586process.removeAllListeners = noop;
587process.emit = noop;
588process.prependListener = noop;
589process.prependOnceListener = noop;
590
591process.listeners = function (name) { return [] }
592
593process.binding = function (name) {
594    throw new Error('process.binding is not supported');
595};
596
597process.cwd = function () { return '/' };
598process.chdir = function (dir) {
599    throw new Error('process.chdir is not supported');
600};
601process.umask = function() { return 0; };
602
603
604/***/ }),
605/* 2 */
606/***/ (function(module, __webpack_exports__, __webpack_require__) {
607
608"use strict";
609Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
610/* WEBPACK VAR INJECTION */(function(process, global, setImmediate) {/*!
611 * Vue.js v2.6.11
612 * (c) 2014-2019 Evan You
613 * Released under the MIT License.
614 */
615/*  */
616
617var emptyObject = Object.freeze({});
618
619// These helpers produce better VM code in JS engines due to their
620// explicitness and function inlining.
621function isUndef (v) {
622  return v === undefined || v === null
623}
624
625function isDef (v) {
626  return v !== undefined && v !== null
627}
628
629function isTrue (v) {
630  return v === true
631}
632
633function isFalse (v) {
634  return v === false
635}
636
637/**
638 * Check if value is primitive.
639 */
640function isPrimitive (value) {
641  return (
642    typeof value === 'string' ||
643    typeof value === 'number' ||
644    // $flow-disable-line
645    typeof value === 'symbol' ||
646    typeof value === 'boolean'
647  )
648}
649
650/**
651 * Quick object check - this is primarily used to tell
652 * Objects from primitive values when we know the value
653 * is a JSON-compliant type.
654 */
655function isObject (obj) {
656  return obj !== null && typeof obj === 'object'
657}
658
659/**
660 * Get the raw type string of a value, e.g., [object Object].
661 */
662var _toString = Object.prototype.toString;
663
664function toRawType (value) {
665  return _toString.call(value).slice(8, -1)
666}
667
668/**
669 * Strict object type check. Only returns true
670 * for plain JavaScript objects.
671 */
672function isPlainObject (obj) {
673  return _toString.call(obj) === '[object Object]'
674}
675
676function isRegExp (v) {
677  return _toString.call(v) === '[object RegExp]'
678}
679
680/**
681 * Check if val is a valid array index.
682 */
683function isValidArrayIndex (val) {
684  var n = parseFloat(String(val));
685  return n >= 0 && Math.floor(n) === n && isFinite(val)
686}
687
688function isPromise (val) {
689  return (
690    isDef(val) &&
691    typeof val.then === 'function' &&
692    typeof val.catch === 'function'
693  )
694}
695
696/**
697 * Convert a value to a string that is actually rendered.
698 */
699function toString (val) {
700  return val == null
701    ? ''
702    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
703      ? JSON.stringify(val, null, 2)
704      : String(val)
705}
706
707/**
708 * Convert an input value to a number for persistence.
709 * If the conversion fails, return original string.
710 */
711function toNumber (val) {
712  var n = parseFloat(val);
713  return isNaN(n) ? val : n
714}
715
716/**
717 * Make a map and return a function for checking if a key
718 * is in that map.
719 */
720function makeMap (
721  str,
722  expectsLowerCase
723) {
724  var map = Object.create(null);
725  var list = str.split(',');
726  for (var i = 0; i < list.length; i++) {
727    map[list[i]] = true;
728  }
729  return expectsLowerCase
730    ? function (val) { return map[val.toLowerCase()]; }
731    : function (val) { return map[val]; }
732}
733
734/**
735 * Check if a tag is a built-in tag.
736 */
737var isBuiltInTag = makeMap('slot,component', true);
738
739/**
740 * Check if an attribute is a reserved attribute.
741 */
742var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
743
744/**
745 * Remove an item from an array.

746 */
747function remove (arr, item) {
748  if (arr.length) {
749    var index = arr.indexOf(item);
750    if (index > -1) {
751      return arr.splice(index, 1)
752    }
753  }
754}
755
756/**
757 * Check whether an object has the property.
758 */
759var hasOwnProperty = Object.prototype.hasOwnProperty;
760function hasOwn (obj, key) {
761  return hasOwnProperty.call(obj, key)
762}
763
764/**
765 * Create a cached version of a pure function.
766 */
767function cached (fn) {
768  var cache = Object.create(null);
769  return (function cachedFn (str) {
770    var hit = cache[str];
771    return hit || (cache[str] = fn(str))
772  })
773}
774
775/**
776 * Camelize a hyphen-delimited string.
777 */
778var camelizeRE = /-(\w)/g;
779var camelize = cached(function (str) {
780  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
781});
782
783/**
784 * Capitalize a string.
785 */
786var capitalize = cached(function (str) {
787  return str.charAt(0).toUpperCase() + str.slice(1)
788});
789
790/**
791 * Hyphenate a camelCase string.
792 */
793var hyphenateRE = /\B([A-Z])/g;
794var hyphenate = cached(function (str) {
795  return str.replace(hyphenateRE, '-$1').toLowerCase()
796});
797
798/**
799 * Simple bind polyfill for environments that do not support it,
800 * e.g., PhantomJS 1.x. Technically, we don't need this anymore
801 * since native bind is now performant enough in most browsers.
802 * But removing it would mean breaking code that was able to run in
803 * PhantomJS 1.x, so this must be kept for backward compatibility.
804 */
805
806/* istanbul ignore next */
807function polyfillBind (fn, ctx) {
808  function boundFn (a) {
809    var l = arguments.length;
810    return l
811      ? l > 1
812        ? fn.apply(ctx, arguments)
813        : fn.call(ctx, a)
814      : fn.call(ctx)
815  }
816
817  boundFn._length = fn.length;
818  return boundFn
819}
820
821function nativeBind (fn, ctx) {
822  return fn.bind(ctx)
823}
824
825var bind = Function.prototype.bind
826  ? nativeBind
827  : polyfillBind;
828
829/**
830 * Convert an Array-like object to a real Array.
831 */
832function toArray (list, start) {
833  start = start || 0;
834  var i = list.length - start;
835  var ret = new Array(i);
836  while (i--) {
837    ret[i] = list[i + start];
838  }
839  return ret
840}
841
842/**
843 * Mix properties into target object.
844 */
845function extend (to, _from) {
846  for (var key in _from) {
847    to[key] = _from[key];
848  }
849  return to
850}
851
852/**
853 * Merge an Array of Objects into a single Object.
854 */
855function toObject (arr) {
856  var res = {};
857  for (var i = 0; i < arr.length; i++) {
858    if (arr[i]) {
859      extend(res, arr[i]);
860    }
861  }
862  return res
863}
864
865/* eslint-disable no-unused-vars */
866
867/**
868 * Perform no operation.
869 * Stubbing args to make Flow happy without leaving useless transpiled code
870 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
871 */
872function noop (a, b, c) {}
873
874/**
875 * Always return false.
876 */
877var no = function (a, b, c) { return false; };
878
879/* eslint-enable no-unused-vars */
880
881/**
882 * Return the same value.
883 */
884var identity = function (_) { return _; };
885
886/**
887 * Generate a string containing static keys from compiler modules.
888 */
889function genStaticKeys (modules) {
890  return modules.reduce(function (keys, m) {
891    return keys.concat(m.staticKeys || [])
892  }, []).join(',')
893}
894
895/**
896 * Check if two values are loosely equal - that is,
897 * if they are plain objects, do they have the same shape?
898 */
899function looseEqual (a, b) {
900  if (a === b) { return true }
901  var isObjectA = isObject(a);
902  var isObjectB = isObject(b);
903  if (isObjectA && isObjectB) {
904    try {
905      var isArrayA = Array.isArray(a);
906      var isArrayB = Array.isArray(b);
907      if (isArrayA && isArrayB) {
908        return a.length === b.length && a.every(function (e, i) {
909          return looseEqual(e, b[i])
910        })
911      } else if (a instanceof Date && b instanceof Date) {
912        return a.getTime() === b.getTime()
913      } else if (!isArrayA && !isArrayB) {
914        var keysA = Object.keys(a);
915        var keysB = Object.keys(b);
916        return keysA.length === keysB.length && keysA.every(function (key) {
917          return looseEqual(a[key], b[key])
918        })
919      } else {
920        /* istanbul ignore next */
921        return false
922      }
923    } catch (e) {
924      /* istanbul ignore next */
925      return false
926    }
927  } else if (!isObjectA && !isObjectB) {
928    return String(a) === String(b)
929  } else {
930    return false
931  }
932}
933
934/**
935 * Return the first index at which a loosely equal value can be
936 * found in the array (if value is a plain object, the array must
937 * contain an object of the same shape), or -1 if it is not present.
938 */
939function looseIndexOf (arr, val) {
940  for (var i = 0; i < arr.length; i++) {
941    if (looseEqual(arr[i], val)) { return i }
942  }
943  return -1
944}
945
946/**
947 * Ensure a function is called only once.
948 */
949function once (fn) {
950  var called = false;
951  return function () {
952    if (!called) {
953      called = true;
954      fn.apply(this, arguments);
955    }
956  }
957}
958
959var SSR_ATTR = 'data-server-rendered';
960
961var ASSET_TYPES = [
962  'component',
963  'directive',
964  'filter'
965];
966
967var LIFECYCLE_HOOKS = [
968  'beforeCreate',
969  'created',
970  'beforeMount',
971  'mounted',
972  'beforeUpdate',
973  'updated',
974  'beforeDestroy',
975  'destroyed',
976  'activated',
977  'deactivated',
978  'errorCaptured',
979  'serverPrefetch'
980];
981
982/*  */
983
984
985
986var config = ({
987  /**
988   * Option merge strategies (used in core/util/options)
989   */
990  // $flow-disable-line
991  optionMergeStrategies: Object.create(null),
992
993  /**
994   * Whether to suppress warnings.
995   */
996  silent: false,
997
998  /**
999   * Show production mode tip message on boot?
1000   */
1001  productionTip: process.env.NODE_ENV !== 'production',
1002
1003  /**
1004   * Whether to enable devtools
1005   */
1006  devtools: process.env.NODE_ENV !== 'production',
1007
1008  /**
1009   * Whether to record perf
1010   */
1011  performance: false,
1012
1013  /**
1014   * Error handler for watcher errors
1015   */
1016  errorHandler: null,
1017
1018  /**
1019   * Warn handler for watcher warns
1020   */
1021  warnHandler: null,
1022
1023  /**
1024   * Ignore certain custom elements
1025   */
1026  ignoredElements: [],
1027
1028  /**
1029   * Custom user key aliases for v-on
1030   */
1031  // $flow-disable-line
1032  keyCodes: Object.create(null),
1033
1034  /**
1035   * Check if a tag is reserved so that it cannot be registered as a
1036   * component. This is platform-dependent and may be overwritten.
1037   */
1038  isReservedTag: no,
1039
1040  /**
1041   * Check if an attribute is reserved so that it cannot be used as a component
1042   * prop. This is platform-dependent and may be overwritten.
1043   */
1044  isReservedAttr: no,
1045
1046  /**
1047   * Check if a tag is an unknown element.
1048   * Platform-dependent.
1049   */
1050  isUnknownElement: no,
1051
1052  /**
1053   * Get the namespace of an element
1054   */
1055  getTagNamespace: noop,
1056
1057  /**
1058   * Parse the real tag name for the specific platform.
1059   */
1060  parsePlatformTagName: identity,
1061
1062  /**
1063   * Check if an attribute must be bound using property, e.g. value
1064   * Platform-dependent.
1065   */
1066  mustUseProp: no,
1067
1068  /**
1069   * Perform updates asynchronously. Intended to be used by Vue Test Utils
1070   * This will significantly reduce performance if set to false.
1071   */
1072  async: true,
1073
1074  /**
1075   * Exposed for legacy reasons
1076   */
1077  _lifecycleHooks: LIFECYCLE_HOOKS
1078});
1079
1080/*  */
1081
1082/**
1083 * unicode letters used for parsing html tags, component names and property paths.
1084 * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
1085 * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
1086 */
1087var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
1088
1089/**
1090 * Check if a string starts with $ or _
1091 */
1092function isReserved (str) {
1093  var c = (str + '').charCodeAt(0);
1094  return c === 0x24 || c === 0x5F
1095}
1096
1097/**
1098 * Define a property.
1099 */
1100function def (obj, key, val, enumerable) {
1101  Object.defineProperty(obj, key, {
1102    value: val,
1103    enumerable: !!enumerable,
1104    writable: true,
1105    configurable: true
1106  });
1107}
1108
1109/**
1110 * Parse simple path.
1111 */
1112var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
1113function parsePath (path) {
1114  if (bailRE.test(path)) {
1115    return
1116  }
1117  var segments = path.split('.');
1118  return function (obj) {
1119    for (var i = 0; i < segments.length; i++) {
1120      if (!obj) { return }
1121      obj = obj[segments[i]];
1122    }
1123    return obj
1124  }
1125}
1126
1127/*  */
1128
1129// can we use __proto__?
1130var hasProto = '__proto__' in {};
1131
1132// Browser environment sniffing
1133var inBrowser = typeof window !== 'undefined';
1134var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
1135var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
1136var UA = inBrowser && window.navigator.userAgent.toLowerCase();
1137var isIE = UA && /msie|trident/.test(UA);
1138var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
1139var isEdge = UA && UA.indexOf('edge/') > 0;
1140var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
1141var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
1142var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
1143var isPhantomJS = UA && /phantomjs/.test(UA);
1144var isFF = UA && UA.match(/firefox\/(\d+)/);
1145

1146// Firefox has a "watch" function on Object.prototype...
1147var nativeWatch = ({}).watch;
1148
1149var supportsPassive = false;
1150if (inBrowser) {
1151  try {
1152    var opts = {};
1153    Object.defineProperty(opts, 'passive', ({
1154      get: function get () {
1155        /* istanbul ignore next */
1156        supportsPassive = true;
1157      }
1158    })); // https://github.com/facebook/flow/issues/285
1159    window.addEventListener('test-passive', null, opts);
1160  } catch (e) {}
1161}
1162
1163// this needs to be lazy-evaled because vue may be required before
1164// vue-server-renderer can set VUE_ENV
1165var _isServer;
1166var isServerRendering = function () {
1167  if (_isServer === undefined) {
1168    /* istanbul ignore if */
1169    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
1170      // detect presence of vue-server-renderer and avoid
1171      // Webpack shimming the process
1172      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
1173    } else {
1174      _isServer = false;
1175    }
1176  }
1177  return _isServer
1178};
1179
1180// detect devtools
1181var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
1182
1183/* istanbul ignore next */
1184function isNative (Ctor) {
1185  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
1186}
1187
1188var hasSymbol =
1189  typeof Symbol !== 'undefined' && isNative(Symbol) &&
1190  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
1191
1192var _Set;
1193/* istanbul ignore if */ // $flow-disable-line
1194if (typeof Set !== 'undefined' && isNative(Set)) {
1195  // use native Set when available.
1196  _Set = Set;
1197} else {
1198  // a non-standard Set polyfill that only works with primitive keys.
1199  _Set = /*@__PURE__*/(function () {
1200    function Set () {
1201      this.set = Object.create(null);
1202    }
1203    Set.prototype.has = function has (key) {
1204      return this.set[key] === true
1205    };
1206    Set.prototype.add = function add (key) {
1207      this.set[key] = true;
1208    };
1209    Set.prototype.clear = function clear () {
1210      this.set = Object.create(null);
1211    };
1212
1213    return Set;
1214  }());
1215}
1216
1217/*  */
1218
1219var warn = noop;
1220var tip = noop;
1221var generateComponentTrace = (noop); // work around flow check
1222var formatComponentName = (noop);
1223
1224if (process.env.NODE_ENV !== 'production') {
1225  var hasConsole = typeof console !== 'undefined';
1226  var classifyRE = /(?:^|[-_])(\w)/g;
1227  var classify = function (str) { return str
1228    .replace(classifyRE, function (c) { return c.toUpperCase(); })
1229    .replace(/[-_]/g, ''); };
1230
1231  warn = function (msg, vm) {
1232    var trace = vm ? generateComponentTrace(vm) : '';
1233
1234    if (config.warnHandler) {
1235      config.warnHandler.call(null, msg, vm, trace);
1236    } else if (hasConsole && (!config.silent)) {
1237      console.error(("[Vue warn]: " + msg + trace));
1238    }
1239  };
1240
1241  tip = function (msg, vm) {
1242    if (hasConsole && (!config.silent)) {
1243      console.warn("[Vue tip]: " + msg + (
1244        vm ? generateComponentTrace(vm) : ''
1245      ));
1246    }
1247  };
1248
1249  formatComponentName = function (vm, includeFile) {
1250    if (vm.$root === vm) {
1251      return '<Root>'
1252    }
1253    var options = typeof vm === 'function' && vm.cid != null
1254      ? vm.options
1255      : vm._isVue
1256        ? vm.$options || vm.constructor.options
1257        : vm;
1258    var name = options.name || options._componentTag;
1259    var file = options.__file;
1260    if (!name && file) {
1261      var match = file.match(/([^/\\]+)\.vue$/);
1262      name = match && match[1];
1263    }
1264
1265    return (
1266      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
1267      (file && includeFile !== false ? (" at " + file) : '')
1268    )
1269  };
1270
1271  var repeat = function (str, n) {
1272    var res = '';
1273    while (n) {
1274      if (n % 2 === 1) { res += str; }
1275      if (n > 1) { str += str; }
1276      n >>= 1;
1277    }
1278    return res
1279  };
1280
1281  generateComponentTrace = function (vm) {
1282    if (vm._isVue && vm.$parent) {
1283      var tree = [];
1284      var currentRecursiveSequence = 0;
1285      while (vm) {
1286        if (tree.length > 0) {
1287          var last = tree[tree.length - 1];
1288          if (last.constructor === vm.constructor) {
1289            currentRecursiveSequence++;
1290            vm = vm.$parent;
1291            continue
1292          } else if (currentRecursiveSequence > 0) {
1293            tree[tree.length - 1] = [last, currentRecursiveSequence];
1294            currentRecursiveSequence = 0;
1295          }
1296        }
1297        tree.push(vm);
1298        vm = vm.$parent;
1299      }
1300      return '\n\nfound in\n\n' + tree
1301        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
1302            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
1303            : formatComponentName(vm))); })
1304        .join('\n')
1305    } else {
1306      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
1307    }
1308  };
1309}
1310
1311/*  */
1312
1313var uid = 0;
1314
1315/**
1316 * A dep is an observable that can have multiple
1317 * directives subscribing to it.
1318 */
1319var Dep = function Dep () {
1320  this.id = uid++;
1321  this.subs = [];
1322};
1323
1324Dep.prototype.addSub = function addSub (sub) {
1325  this.subs.push(sub);
1326};
1327
1328Dep.prototype.removeSub = function removeSub (sub) {
1329  remove(this.subs, sub);
1330};
1331

1332Dep.prototype.depend = function depend () {
1333  if (Dep.target) {
1334    Dep.target.addDep(this);
1335  }
1336};
1337
1338Dep.prototype.notify = function notify () {
1339  // stabilize the subscriber list first
1340  var subs = this.subs.slice();
1341  if (process.env.NODE_ENV !== 'production' && !config.async) {
1342    // subs aren't sorted in scheduler if not running async
1343    // we need to sort them now to make sure they fire in correct
1344    // order
1345    subs.sort(function (a, b) { return a.id - b.id; });
1346  }
1347  for (var i = 0, l = subs.length; i < l; i++) {
1348    subs[i].update();
1349  }
1350};
1351
1352// The current target watcher being evaluated.
1353// This is globally unique because only one watcher
1354// can be evaluated at a time.
1355Dep.target = null;
1356var targetStack = [];
1357
1358function pushTarget (target) {
1359  targetStack.push(target);
1360  Dep.target = target;
1361}
1362
1363function popTarget () {
1364  targetStack.pop();
1365  Dep.target = targetStack[targetStack.length - 1];
1366}
1367
1368/*  */
1369
1370var VNode = function VNode (
1371  tag,
1372  data,
1373  children,
1374  text,
1375  elm,
1376  context,
1377  componentOptions,
1378  asyncFactory
1379) {
1380  this.tag = tag;
1381  this.data = data;
1382  this.children = children;
1383  this.text = text;
1384  this.elm = elm;
1385  this.ns = undefined;
1386  this.context = context;
1387  this.fnContext = undefined;
1388  this.fnOptions = undefined;
1389  this.fnScopeId = undefined;
1390  this.key = data && data.key;
1391  this.componentOptions = componentOptions;
1392  this.componentInstance = undefined;
1393  this.parent = undefined;
1394  this.raw = false;
1395  this.isStatic = false;
1396  this.isRootInsert = true;
1397  this.isComment = false;
1398  this.isCloned = false;
1399  this.isOnce = false;
1400  this.asyncFactory = asyncFactory;
1401  this.asyncMeta = undefined;
1402  this.isAsyncPlaceholder = false;
1403};
1404
1405var prototypeAccessors = { child: { configurable: true } };
1406
1407// DEPRECATED: alias for componentInstance for backwards compat.
1408/* istanbul ignore next */
1409prototypeAccessors.child.get = function () {
1410  return this.componentInstance
1411};
1412
1413Object.defineProperties( VNode.prototype, prototypeAccessors );
1414
1415var createEmptyVNode = function (text) {
1416  if ( text === void 0 ) text = '';
1417
1418  var node = new VNode();
1419  node.text = text;
1420  node.isComment = true;
1421  return node
1422};
1423
1424function createTextVNode (val) {
1425  return new VNode(undefined, undefined, undefined, String(val))
1426}
1427
1428// optimized shallow clone
1429// used for static nodes and slot nodes because they may be reused across
1430// multiple renders, cloning them avoids errors when DOM manipulations rely
1431// on their elm reference.
1432function cloneVNode (vnode) {
1433  var cloned = new VNode(
1434    vnode.tag,
1435    vnode.data,
1436    // #7975
1437    // clone children array to avoid mutating original in case of cloning
1438    // a child.
1439    vnode.children && vnode.children.slice(),
1440    vnode.text,
1441    vnode.elm,
1442    vnode.context,
1443    vnode.componentOptions,
1444    vnode.asyncFactory
1445  );
1446  cloned.ns = vnode.ns;
1447  cloned.isStatic = vnode.isStatic;
1448  cloned.key = vnode.key;
1449  cloned.isComment = vnode.isComment;
1450  cloned.fnContext = vnode.fnContext;
1451  cloned.fnOptions = vnode.fnOptions;
1452  cloned.fnScopeId = vnode.fnScopeId;
1453  cloned.asyncMeta = vnode.asyncMeta;
1454  cloned.isCloned = true;
1455  return cloned
1456}
1457
1458/*
1459 * not type checking this file because flow doesn't play well with
1460 * dynamically accessing methods on Array prototype
1461 */
1462
1463var arrayProto = Array.prototype;
1464var arrayMethods = Object.create(arrayProto);
1465
1466var methodsToPatch = [
1467  'push',
1468  'pop',
1469  'shift',
1470  'unshift',
1471  'splice',
1472  'sort',
1473  'reverse'
1474];
1475
1476/**
1477 * Intercept mutating methods and emit events
1478 */
1479methodsToPatch.forEach(function (method) {
1480  // cache original method
1481  var original = arrayProto[method];
1482  def(arrayMethods, method, function mutator () {
1483    var args = [], len = arguments.length;
1484    while ( len-- ) args[ len ] = arguments[ len ];
1485
1486    var result = original.apply(this, args);
1487    var ob = this.__ob__;
1488    var inserted;
1489    switch (method) {
1490      case 'push':
1491      case 'unshift':
1492        inserted = args;
1493        break
1494      case 'splice':
1495        inserted = args.slice(2);
1496        break
1497    }
1498    if (inserted) { ob.observeArray(inserted); }
1499    // notify change
1500    ob.dep.notify();
1501    return result
1502  });
1503});
1504
1505/*  */
1506
1507var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
1508
1509/**
1510 * In some cases we may want to disable observation inside a component's
1511 * update computation.
1512 */
1513var shouldObserve = true;
1514
1515function toggleObserving (value) {
1516  shouldObserve = value;
1517}
1518
1519/**
1520 * Observer class that is attached to each observed
1521 * object. Once attached, the observer converts the target
1522 * object's property keys into getter/setters that
1523 * collect dependencies and dispatch updates.
1524 */
1525var Observer = function Observer (value) {
1526  this.value = value;
1527  this.dep = new Dep();
1528  this.vmCount = 0;
1529  def(value, '__ob__', this);
1530  if (Array.isArray(value)) {
1531    if (hasProto) {
1532      protoAugment(value, arrayMethods);
1533    } else {
1534      copyAugment(value, arrayMethods, arrayKeys);
1535    }
1536    this.observeArray(value);
1537  } else {
1538    this.walk(value);
1539  }
1540};
1541
1542/**
1543 * Walk through all properties and convert them into
1544 * getter/setters. This method should only be called when
1545 * value type is Object.
1546 */
1547Observer.prototype.walk = function walk (obj) {
1548  var keys = Object.keys(obj);
1549  for (var i = 0; i < keys.length; i++) {
1550    defineReactive$$1(obj, keys[i]);
1551  }
1552};
1553
1554/**
1555 * Observe a list of Array items.
1556 */
1557Observer.prototype.observeArray = function observeArray (items) {
1558  for (var i = 0, l = items.length; i < l; i++) {
1559    observe(items[i]);
1560  }
1561};
1562
1563// helpers
1564
1565/**
1566 * Augment a target Object or Array by intercepting
1567 * the prototype chain using __proto__
1568 */
1569function protoAugment (target, src) {
1570  /* eslint-disable no-proto */
1571  target.__proto__ = src;
1572  /* eslint-enable no-proto */
1573}
1574
1575/**
1576 * Augment a target Object or Array by defining
1577 * hidden properties.
1578 */
1579/* istanbul ignore next */
1580function copyAugment (target, src, keys) {
1581  for (var i = 0, l = keys.length; i < l; i++) {
1582    var key = keys[i];
1583    def(target, key, src[key]);
1584  }
1585}
1586
1587/**
1588 * Attempt to create an observer instance for a value,
1589 * returns the new observer if successfully observed,
1590 * or the existing observer if the value already has one.
1591 */
1592function observe (value, asRootData) {
1593  if (!isObject(value) || value instanceof VNode) {
1594    return
1595  }
1596  var ob;
1597  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
1598    ob = value.__ob__;
1599  } else if (
1600    shouldObserve &&
1601    !isServerRendering() &&
1602    (Array.isArray(value) || isPlainObject(value)) &&
1603    Object.isExtensible(value) &&
1604    !value._isVue
1605  ) {
1606    ob = new Observer(value);
1607  }
1608  if (asRootData && ob) {
1609    ob.vmCount++;
1610  }
1611  return ob
1612}
1613
1614/**
1615 * Define a reactive property on an Object.
1616 */
1617function defineReactive$$1 (
1618  obj,
1619  key,
1620  val,
1621  customSetter,
1622  shallow
1623) {
1624  var dep = new Dep();
1625
1626  var property = Object.getOwnPropertyDescriptor(obj, key);
1627  if (property && property.configurable === false) {
1628    return
1629  }
1630
1631  // cater for pre-defined getter/setters
1632  var getter = property && property.get;
1633  var setter = property && property.set;
1634  if ((!getter || setter) && arguments.length === 2) {
1635    val = obj[key];
1636  }
1637
1638  var childOb = !shallow && observe(val);
1639  Object.defineProperty(obj, key, {
1640    enumerable: true,
1641    configurable: true,
1642    get: function reactiveGetter () {
1643      var value = getter ? getter.call(obj) : val;
1644      if (Dep.target) {
1645        dep.depend();
1646        if (childOb) {
1647          childOb.dep.depend();
1648          if (Array.isArray(value)) {
1649            dependArray(value);
1650          }
1651        }
1652      }
1653      return value
1654    },
1655    set: function reactiveSetter (newVal) {
1656      var value = getter ? getter.call(obj) : val;
1657      /* eslint-disable no-self-compare */
1658      if (newVal === value || (newVal !== newVal && value !== value)) {
1659        return
1660      }
1661      /* eslint-enable no-self-compare */
1662      if (process.env.NODE_ENV !== 'production' && customSetter) {
1663        customSetter();
1664      }
1665      // #7981: for accessor properties without setter
1666      if (getter && !setter) { return }
1667      if (setter) {
1668        setter.call(obj, newVal);
1669      } else {
1670        val = newVal;
1671      }
1672      childOb = !shallow && observe(newVal);
1673      dep.notify();
1674    }
1675  });
1676}
1677
1678/**
1679 * Set a property on an object. Adds the new property and
1680 * triggers change notification if the property doesn't
1681 * already exist.
1682 */
1683function set (target, key, val) {
1684  if (process.env.NODE_ENV !== 'production' &&
1685    (isUndef(target) || isPrimitive(target))
1686  ) {
1687    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
1688  }
1689  if (Array.isArray(target) && isValidArrayIndex(key)) {
1690    target.length = Math.max(target.length, key);
1691    target.splice(key, 1, val);
1692    return val
1693  }
1694  if (key in target && !(key in Object.prototype)) {
1695    target[key] = val;
1696    return val
1697  }
1698  var ob = (target).__ob__;
1699  if (target._isVue || (ob && ob.vmCount)) {
1700    process.env.NODE_ENV !== 'production' && warn(
1701      'Avoid adding reactive properties to a Vue instance or its root $data ' +
1702      'at runtime - declare it upfront in the data option.'
1703    );
1704    return val
1705  }
1706  if (!ob) {
1707    target[key] = val;
1708    return val
1709  }
1710  defineReactive$$1(ob.value, key, val);
1711  ob.dep.notify();
1712  return val
1713}
1714
1715/**
1716 * Delete a property and trigger change if necessary.
1717 */
1718function del (target, key) {
1719  if (process.env.NODE_ENV !== 'production' &&
1720    (isUndef(target) || isPrimitive(target))
1721  ) {
1722    warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
1723  }
1724  if (Array.isArray(target) && isValidArrayIndex(key)) {
1725    target.splice(key, 1);
1726    return
1727  }
1728  var ob = (target).__ob__;
1729  if (target._isVue || (ob && ob.vmCount)) {
1730    process.env.NODE_ENV !== 'production' && warn(
1731      'Avoid deleting properties on a Vue instance or its root $data ' +
1732      '- just set it to null.'
1733    );
1734    return
1735  }
1736  if (!hasOwn(target, key)) {
1737    return
1738  }
1739  delete target[key];
1740  if (!ob) {
1741    return
1742  }
1743  ob.dep.notify();
1744}
1745
1746/**
1747 * Collect dependencies on array elements when the array is touched, since
1748 * we cannot intercept array element access like property getters.
1749 */
1750function dependArray (value) {
1751  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
1752    e = value[i];
1753    e && e.__ob__ && e.__ob__.dep.depend();
1754    if (Array.isArray(e)) {
1755      dependArray(e);
1756    }
1757  }
1758}
1759
1760/*  */
1761
1762/**
1763 * Option overwriting strategies are functions that handle
1764 * how to merge a parent option value and a child option
1765 * value into the final value.
1766 */
1767var strats = config.optionMergeStrategies;
1768
1769/**
1770 * Options with restrictions
1771 */
1772if (process.env.NODE_ENV !== 'production') {
1773  strats.el = strats.propsData = function (parent, child, vm, key) {
1774    if (!vm) {
1775      warn(
1776        "option \"" + key + "\" can only be used during instance " +
1777        'creation with the `new` keyword.'
1778      );
1779    }
1780    return defaultStrat(parent, child)
1781  };
1782}
1783
1784/**
1785 * Helper that recursively merges two data objects together.
1786 */
1787function mergeData (to, from) {
1788  if (!from) { return to }
1789  var key, toVal, fromVal;
1790
1791  var keys = hasSymbol
1792    ? Reflect.ownKeys(from)
1793    : Object.keys(from);
1794
1795  for (var i = 0; i < keys.length; i++) {
1796    key = keys[i];
1797    // in case the object is already observed...
1798    if (key === '__ob__') { continue }
1799    toVal = to[key];
1800    fromVal = from[key];
1801    if (!hasOwn(to, key)) {
1802      set(to, key, fromVal);
1803    } else if (
1804      toVal !== fromVal &&
1805      isPlainObject(toVal) &&
1806      isPlainObject(fromVal)
1807    ) {
1808      mergeData(toVal, fromVal);
1809    }
1810  }
1811  return to
1812}
1813
1814/**
1815 * Data
1816 */
1817function mergeDataOrFn (
1818  parentVal,
1819  childVal,
1820  vm
1821) {
1822  if (!vm) {
1823    // in a Vue.extend merge, both should be functions
1824    if (!childVal) {
1825      return parentVal
1826    }
1827    if (!parentVal) {
1828      return childVal
1829    }
1830    // when parentVal & childVal are both present,
1831    // we need to return a function that returns the
1832    // merged result of both functions... no need to
1833    // check if parentVal is a function here because
1834    // it has to be a function to pass previous merges.
1835    return function mergedDataFn () {
1836      return mergeData(
1837        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
1838        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
1839      )
1840    }
1841  } else {
1842    return function mergedInstanceDataFn () {
1843      // instance merge
1844      var instanceData = typeof childVal === 'function'
1845        ? childVal.call(vm, vm)
1846        : childVal;
1847      var defaultData = typeof parentVal === 'function'
1848        ? parentVal.call(vm, vm)
1849        : parentVal;
1850      if (instanceData) {
1851        return mergeData(instanceData, defaultData)
1852      } else {
1853        return defaultData
1854      }
1855    }
1856  }
1857}
1858
1859strats.data = function (
1860  parentVal,
1861  childVal,
1862  vm
1863) {
1864  if (!vm) {
1865    if (childVal && typeof childVal !== 'function') {
1866      process.env.NODE_ENV !== 'production' && warn(
1867        'The "data" option should be a function ' +
1868        'that returns a per-instance value in component ' +
1869        'definitions.',
1870        vm
1871      );
1872
1873      return parentVal
1874    }
1875    return mergeDataOrFn(parentVal, childVal)
1876  }
1877
1878  return mergeDataOrFn(parentVal, childVal, vm)
1879};
1880
1881/**
1882 * Hooks and props are merged as arrays.
1883 */
1884function mergeHook (
1885  parentVal,
1886  childVal
1887) {
1888  var res = childVal
1889    ? parentVal
1890      ? parentVal.concat(childVal)
1891      : Array.isArray(childVal)
1892        ? childVal
1893        : [childVal]
1894    : parentVal;
1895  return res
1896    ? dedupeHooks(res)
1897    : res
1898}
1899
1900function dedupeHooks (hooks) {
1901  var res = [];
1902  for (var i = 0; i < hooks.length; i++) {
1903    if (res.indexOf(hooks[i]) === -1) {
1904      res.push(hooks[i]);
1905    }
1906  }
1907  return res
1908}
1909
1910LIFECYCLE_HOOKS.forEach(function (hook) {
1911  strats[hook] = mergeHook;
1912});
1913
1914/**
1915 * Assets
1916 *
1917 * When a vm is present (instance creation), we need to do
1918 * a three-way merge between constructor options, instance
1919 * options and parent options.
1920 */
1921function mergeAssets (
1922  parentVal,
1923  childVal,
1924  vm,
1925  key
1926) {
1927  var res = Object.create(parentVal || null);
1928  if (childVal) {
1929    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
1930    return extend(res, childVal)
1931  } else {
1932    return res
1933  }
1934}
1935
1936ASSET_TYPES.forEach(function (type) {
1937  strats[type + 's'] = mergeAssets;
1938});
1939
1940/**
1941 * Watchers.
1942 *
1943 * Watchers hashes should not overwrite one
1944 * another, so we merge them as arrays.
1945 */
1946strats.watch = function (
1947  parentVal,
1948  childVal,
1949  vm,
1950  key
1951) {
1952  // work around Firefox's Object.prototype.watch...
1953  if (parentVal === nativeWatch) { parentVal = undefined; }
1954  if (childVal === nativeWatch) { childVal = undefined; }
1955  /* istanbul ignore if */
1956  if (!childVal) { return Object.create(parentVal || null) }
1957  if (process.env.NODE_ENV !== 'production') {
1958    assertObjectType(key, childVal, vm);
1959  }
1960  if (!parentVal) { return childVal }
1961  var ret = {};
1962  extend(ret, parentVal);
1963  for (var key$1 in childVal) {
1964    var parent = ret[key$1];
1965    var child = childVal[key$1];
1966    if (parent && !Array.isArray(parent)) {
1967      parent = [parent];
1968    }
1969    ret[key$1] = parent
1970      ? parent.concat(child)
1971      : Array.isArray(child) ? child : [child];
1972  }
1973  return ret
1974};
1975
1976/**
1977 * Other object hashes.
1978 */
1979strats.props =
1980strats.methods =
1981strats.inject =
1982strats.computed = function (
1983  parentVal,
1984  childVal,
1985  vm,
1986  key
1987) {
1988  if (childVal && process.env.NODE_ENV !== 'production') {
1989    assertObjectType(key, childVal, vm);
1990  }
1991  if (!parentVal) { return childVal }
1992  var ret = Object.create(null);
1993  extend(ret, parentVal);
1994  if (childVal) { extend(ret, childVal); }
1995  return ret
1996};
1997strats.provide = mergeDataOrFn;
1998
1999/**
2000 * Default strategy.
2001 */
2002var defaultStrat = function (parentVal, childVal) {
2003  return childVal === undefined
2004    ? parentVal
2005    : childVal
2006};
2007
2008/**
2009 * Validate component names
2010 */
2011function checkComponents (options) {
2012  for (var key in options.components) {
2013    validateComponentName(key);
2014  }
2015}
2016
2017function validateComponentName (name) {
2018  if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
2019    warn(
2020      'Invalid component name: "' + name + '". Component names ' +
2021      'should conform to valid custom element name in html5 specification.'
2022    );
2023  }
2024  if (isBuiltInTag(name) || config.isReservedTag(name)) {
2025    warn(
2026      'Do not use built-in or reserved HTML elements as component ' +
2027      'id: ' + name
2028    );
2029  }
2030}
2031
2032/**
2033 * Ensure all props option syntax are normalized into the
2034 * Object-based format.
2035 */
2036function normalizeProps (options, vm) {
2037  var props = options.props;
2038  if (!props) { return }
2039  var res = {};
2040  var i, val, name;
2041  if (Array.isArray(props)) {
2042    i = props.length;
2043    while (i--) {
2044      val = props[i];
2045      if (typeof val === 'string') {
2046        name = camelize(val);
2047        res[name] = { type: null };
2048      } else if (process.env.NODE_ENV !== 'production') {
2049        warn('props must be strings when using array syntax.');
2050      }
2051    }
2052  } else if (isPlainObject(props)) {
2053    for (var key in props) {
2054      val = props[key];
2055      name = camelize(key);
2056      res[name] = isPlainObject(val)
2057        ? val
2058        : { type: val };
2059    }
2060  } else if (process.env.NODE_ENV !== 'production') {
2061    warn(
2062      "Invalid value for option \"props\": expected an Array or an Object, " +
2063      "but got " + (toRawType(props)) + ".",
2064      vm
2065    );
2066  }
2067  options.props = res;
2068}
2069
2070/**
2071 * Normalize all injections into Object-based format
2072 */
2073function normalizeInject (options, vm) {
2074  var inject = options.inject;
2075  if (!inject) { return }
2076  var normalized = options.inject = {};
2077  if (Array.isArray(inject)) {
2078    for (var i = 0; i < inject.length; i++) {
2079      normalized[inject[i]] = { from: inject[i] };
2080    }
2081  } else if (isPlainObject(inject)) {
2082    for (var key in inject) {
2083      var val = inject[key];
2084      normalized[key] = isPlainObject(val)
2085        ? extend({ from: key }, val)
2086        : { from: val };
2087    }
2088  } else if (process.env.NODE_ENV !== 'production') {
2089    warn(
2090      "Invalid value for option \"inject\": expected an Array or an Object, " +
2091      "but got " + (toRawType(inject)) + ".",
2092      vm
2093    );
2094  }
2095}
2096
2097/**
2098 * Normalize raw function directives into object format.
2099 */
2100function normalizeDirectives (options) {
2101  var dirs = options.directives;
2102  if (dirs) {
2103    for (var key in dirs) {
2104      var def$$1 = dirs[key];
2105      if (typeof def$$1 === 'function') {
2106        dirs[key] = { bind: def$$1, update: def$$1 };
2107      }
2108    }
2109  }
2110}
2111
2112function assertObjectType (name, value, vm) {
2113  if (!isPlainObject(value)) {
2114    warn(
2115      "Invalid value for option \"" + name + "\": expected an Object, " +
2116      "but got " + (toRawType(value)) + ".",
2117      vm
2118    );
2119  }
2120}
2121
2122/**
2123 * Merge two option objects into a new one.
2124 * Core utility used in both instantiation and inheritance.
2125 */
2126function mergeOptions (
2127  parent,
2128  child,
2129  vm
2130) {
2131  if (process.env.NODE_ENV !== 'production') {
2132    checkComponents(child);
2133  }
2134
2135  if (typeof child === 'function') {
2136    child = child.options;
2137  }
2138
2139  normalizeProps(child, vm);
2140  normalizeInject(child, vm);
2141  normalizeDirectives(child);
2142
2143  // Apply extends and mixins on the child options,
2144  // but only if it is a raw options object that isn't
2145  // the result of another mergeOptions call.
2146  // Only merged options has the _base property.
2147  if (!child._base) {
2148    if (child.extends) {
2149      parent = mergeOptions(parent, child.extends, vm);
2150    }
2151    if (child.mixins) {
2152      for (var i = 0, l = child.mixins.length; i < l; i++) {
2153        parent = mergeOptions(parent, child.mixins[i], vm);
2154      }
2155    }
2156  }
2157
2158  var options = {};
2159  var key;
2160  for (key in parent) {
2161    mergeField(key);
2162  }
2163  for (key in child) {
2164    if (!hasOwn(parent, key)) {
2165      mergeField(key);
2166    }
2167  }
2168  function mergeField (key) {
2169    var strat = strats[key] || defaultStrat;
2170    options[key] = strat(parent[key], child[key], vm, key);
2171  }
2172  return options
2173}
2174
2175/**
2176 * Resolve an asset.
2177 * This function is used because child instances need access
2178 * to assets defined in its ancestor chain.
2179 */
2180function resolveAsset (
2181  options,
2182  type,
2183  id,
2184  warnMissing
2185) {
2186  /* istanbul ignore if */
2187  if (typeof id !== 'string') {
2188    return
2189  }
2190  var assets = options[type];
2191  // check local registration variations first
2192  if (hasOwn(assets, id)) { return assets[id] }
2193  var camelizedId = camelize(id);
2194  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
2195  var PascalCaseId = capitalize(camelizedId);
2196  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
2197  // fallback to prototype chain
2198  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
2199  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
2200    warn(
2201      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
2202      options
2203    );
2204  }
2205  return res
2206}
2207
2208/*  */
2209
2210
2211
2212function validateProp (
2213  key,
2214  propOptions,
2215  propsData,
2216  vm
2217) {
2218  var prop = propOptions[key];
2219  var absent = !hasOwn(propsData, key);
2220  var value = propsData[key];
2221  // boolean casting
2222  var booleanIndex = getTypeIndex(Boolean, prop.type);
2223  if (booleanIndex > -1) {
2224    if (absent && !hasOwn(prop, 'default')) {
2225      value = false;

2226    } else if (value === '' || value === hyphenate(key)) {
2227      // only cast empty string / same name to boolean if
2228      // boolean has higher priority
2229      var stringIndex = getTypeIndex(String, prop.type);
2230      if (stringIndex < 0 || booleanIndex < stringIndex) {
2231        value = true;
2232      }
2233    }
2234  }
2235  // check default value
2236  if (value === undefined) {
2237    value = getPropDefaultValue(vm, prop, key);
2238    // since the default value is a fresh copy,
2239    // make sure to observe it.
2240    var prevShouldObserve = shouldObserve;
2241    toggleObserving(true);
2242    observe(value);
2243    toggleObserving(prevShouldObserve);
2244  }
2245  if (
2246    process.env.NODE_ENV !== 'production' &&
2247    // skip validation for weex recycle-list child component props
2248    !(false)
2249  ) {
2250    assertProp(prop, key, value, vm, absent);
2251  }
2252  return value
2253}
2254
2255/**
2256 * Get the default value of a prop.
2257 */
2258function getPropDefaultValue (vm, prop, key) {
2259  // no default, return undefined
2260  if (!hasOwn(prop, 'default')) {
2261    return undefined
2262  }
2263  var def = prop.default;
2264  // warn against non-factory defaults for Object & Array
2265  if (process.env.NODE_ENV !== 'production' && isObject(def)) {
2266    warn(
2267      'Invalid default value for prop "' + key + '": ' +
2268      'Props with type Object/Array must use a factory function ' +
2269      'to return the default value.',
2270      vm
2271    );
2272  }
2273  // the raw prop value was also undefined from previous render,
2274  // return previous default value to avoid unnecessary watcher trigger
2275  if (vm && vm.$options.propsData &&
2276    vm.$options.propsData[key] === undefined &&
2277    vm._props[key] !== undefined
2278  ) {
2279    return vm._props[key]
2280  }
2281  // call factory function for non-Function types
2282  // a value is Function if its prototype is function even across different execution context
2283  return typeof def === 'function' && getType(prop.type) !== 'Function'
2284    ? def.call(vm)
2285    : def
2286}
2287
2288/**
2289 * Assert whether a prop is valid.
2290 */
2291function assertProp (
2292  prop,
2293  name,
2294  value,
2295  vm,
2296  absent
2297) {
2298  if (prop.required && absent) {
2299    warn(
2300      'Missing required prop: "' + name + '"',
2301      vm
2302    );
2303    return
2304  }
2305  if (value == null && !prop.required) {
2306    return
2307  }
2308  var type = prop.type;
2309  var valid = !type || type === true;
2310  var expectedTypes = [];
2311  if (type) {
2312    if (!Array.isArray(type)) {
2313      type = [type];
2314    }
2315    for (var i = 0; i < type.length && !valid; i++) {
2316      var assertedType = assertType(value, type[i]);
2317      expectedTypes.push(assertedType.expectedType || '');
2318      valid = assertedType.valid;
2319    }
2320  }
2321
2322  if (!valid) {
2323    warn(
2324      getInvalidTypeMessage(name, value, expectedTypes),
2325      vm
2326    );
2327    return
2328  }
2329  var validator = prop.validator;
2330  if (validator) {
2331    if (!validator(value)) {
2332      warn(
2333        'Invalid prop: custom validator check failed for prop "' + name + '".',
2334        vm
2335      );
2336    }
2337  }
2338}
2339
2340var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
2341
2342function assertType (value, type) {
2343  var valid;
2344  var expectedType = getType(type);
2345  if (simpleCheckRE.test(expectedType)) {
2346    var t = typeof value;
2347    valid = t === expectedType.toLowerCase();
2348    // for primitive wrapper objects
2349    if (!valid && t === 'object') {
2350      valid = value instanceof type;
2351    }
2352  } else if (expectedType === 'Object') {
2353    valid = isPlainObject(value);
2354  } else if (expectedType === 'Array') {
2355    valid = Array.isArray(value);
2356  } else {
2357    valid = value instanceof type;
2358  }
2359  return {
2360    valid: valid,
2361    expectedType: expectedType
2362  }
2363}
2364
2365/**
2366 * Use function string name to check built-in types,
2367 * because a simple equality check will fail when running
2368 * across different vms / iframes.
2369 */
2370function getType (fn) {
2371  var match = fn && fn.toString().match(/^\s*function (\w+)/);
2372  return match ? match[1] : ''
2373}
2374
2375function isSameType (a, b) {
2376  return getType(a) === getType(b)
2377}
2378
2379function getTypeIndex (type, expectedTypes) {
2380  if (!Array.isArray(expectedTypes)) {
2381    return isSameType(expectedTypes, type) ? 0 : -1
2382  }
2383  for (var i = 0, len = expectedTypes.length; i < len; i++) {
2384    if (isSameType(expectedTypes[i], type)) {
2385      return i
2386    }
2387  }
2388  return -1
2389}
2390
2391function getInvalidTypeMessage (name, value, expectedTypes) {
2392  var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
2393    " Expected " + (expectedTypes.map(capitalize).join(', '));
2394  var expectedType = expectedTypes[0];
2395  var receivedType = toRawType(value);
2396  var expectedValue = styleValue(value, expectedType);
2397  var receivedValue = styleValue(value, receivedType);
2398  // check if we need to specify expected value
2399  if (expectedTypes.length === 1 &&
2400      isExplicable(expectedType) &&
2401      !isBoolean(expectedType, receivedType)) {
2402    message += " with value " + expectedValue;
2403  }
2404  message += ", got " + receivedType + " ";
2405  // check if we need to specify received value
2406  if (isExplicable(receivedType)) {
2407    message += "with value " + receivedValue + ".";
2408  }
2409  return message
2410}
2411
2412function styleValue (value, type) {
2413  if (type === 'String') {
2414    return ("\"" + value + "\"")
2415  } else if (type === 'Number') {
2416    return ("" + (Number(value)))
2417  } else {
2418    return ("" + value)
2419  }
2420}
2421
2422function isExplicable (value) {
2423  var explicitTypes = ['string', 'number', 'boolean'];
2424  return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
2425}
2426
2427function isBoolean () {
2428  var args = [], len = arguments.length;
2429  while ( len-- ) args[ len ] = arguments[ len ];
2430
2431  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
2432}
2433
2434/*  */
2435
2436function handleError (err, vm, info) {
2437  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
2438  // See: https://github.com/vuejs/vuex/issues/1505
2439  pushTarget();
2440  try {
2441    if (vm) {
2442      var cur = vm;
2443      while ((cur = cur.$parent)) {
2444        var hooks = cur.$options.errorCaptured;
2445        if (hooks) {
2446          for (var i = 0; i < hooks.length; i++) {
2447            try {
2448              var capture = hooks[i].call(cur, err, vm, info) === false;
2449              if (capture) { return }
2450            } catch (e) {
2451              globalHandleError(e, cur, 'errorCaptured hook');
2452            }
2453          }
2454        }
2455      }
2456    }
2457    globalHandleError(err, vm, info);
2458  } finally {
2459    popTarget();
2460  }
2461}
2462
2463function invokeWithErrorHandling (
2464  handler,
2465  context,
2466  args,
2467  vm,
2468  info
2469) {
2470  var res;
2471  try {
2472    res = args ? handler.apply(context, args) : handler.call(context);
2473    if (res && !res._isVue && isPromise(res) && !res._handled) {
2474      res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
2475      // issue #9511
2476      // avoid catch triggering multiple times when nested calls
2477      res._handled = true;
2478    }
2479  } catch (e) {
2480    handleError(e, vm, info);
2481  }
2482  return res
2483}
2484
2485function globalHandleError (err, vm, info) {
2486  if (config.errorHandler) {
2487    try {
2488      return config.errorHandler.call(null, err, vm, info)
2489    } catch (e) {
2490      // if the user intentionally throws the original error in the handler,
2491      // do not log it twice
2492      if (e !== err) {
2493        logError(e, null, 'config.errorHandler');
2494      }
2495    }
2496  }
2497  logError(err, vm, info);
2498}
2499
2500function logError (err, vm, info) {
2501  if (process.env.NODE_ENV !== 'production') {
2502    warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
2503  }
2504  /* istanbul ignore else */
2505  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
2506    console.error(err);
2507  } else {
2508    throw err
2509  }
2510}
2511
2512/*  */
2513
2514var isUsingMicroTask = false;

2515
2516var callbacks = [];
2517var pending = false;
2518
2519function flushCallbacks () {
2520  pending = false;
2521  var copies = callbacks.slice(0);
2522  callbacks.length = 0;
2523  for (var i = 0; i < copies.length; i++) {
2524    copies[i]();
2525  }
2526}
2527
2528// Here we have async deferring wrappers using microtasks.
2529// In 2.5 we used (macro) tasks (in combination with microtasks).
2530// However, it has subtle problems when state is changed right before repaint
2531// (e.g. #6813, out-in transitions).
2532// Also, using (macro) tasks in event handler would cause some weird behaviors
2533// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
2534// So we now use microtasks everywhere, again.
2535// A major drawback of this tradeoff is that there are some scenarios
2536// where microtasks have too high a priority and fire in between supposedly
2537// sequential events (e.g. #4521, #6690, which have workarounds)
2538// or even between bubbling of the same event (#6566).
2539var timerFunc;
2540
2541// The nextTick behavior leverages the microtask queue, which can be accessed
2542// via either native Promise.then or MutationObserver.
2543// MutationObserver has wider support, however it is seriously bugged in
2544// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
2545// completely stops working after triggering a few times... so, if native
2546// Promise is available, we will use it:
2547/* istanbul ignore next, $flow-disable-line */
2548if (typeof Promise !== 'undefined' && isNative(Promise)) {
2549  var p = Promise.resolve();
2550  timerFunc = function () {
2551    p.then(flushCallbacks);
2552    // In problematic UIWebViews, Promise.then doesn't completely break, but
2553    // it can get stuck in a weird state where callbacks are pushed into the
2554    // microtask queue but the queue isn't being flushed, until the browser
2555    // needs to do some other work, e.g. handle a timer. Therefore we can
2556    // "force" the microtask queue to be flushed by adding an empty timer.
2557    if (isIOS) { setTimeout(noop); }
2558  };
2559  isUsingMicroTask = true;
2560} else if (!isIE && typeof MutationObserver !== 'undefined' && (
2561  isNative(MutationObserver) ||
2562  // PhantomJS and iOS 7.x
2563  MutationObserver.toString() === '[object MutationObserverConstructor]'
2564)) {
2565  // Use MutationObserver where native Promise is not available,
2566  // e.g. PhantomJS, iOS7, Android 4.4
2567  // (#6466 MutationObserver is unreliable in IE11)
2568  var counter = 1;
2569  var observer = new MutationObserver(flushCallbacks);
2570  var textNode = document.createTextNode(String(counter));
2571  observer.observe(textNode, {
2572    characterData: true
2573  });
2574  timerFunc = function () {
2575    counter = (counter + 1) % 2;
2576    textNode.data = String(counter);
2577  };
2578  isUsingMicroTask = true;
2579} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
2580  // Fallback to setImmediate.
2581  // Technically it leverages the (macro) task queue,
2582  // but it is still a better choice than setTimeout.
2583  timerFunc = function () {
2584    setImmediate(flushCallbacks);
2585  };
2586} else {
2587  // Fallback to setTimeout.
2588  timerFunc = function () {
2589    setTimeout(flushCallbacks, 0);
2590  };
2591}
2592
2593function nextTick (cb, ctx) {
2594  var _resolve;
2595  callbacks.push(function () {
2596    if (cb) {
2597      try {
2598        cb.call(ctx);
2599      } catch (e) {
2600        handleError(e, ctx, 'nextTick');
2601      }
2602    } else if (_resolve) {
2603      _resolve(ctx);
2604    }
2605  });
2606  if (!pending) {
2607    pending = true;
2608    timerFunc();
2609  }
2610  // $flow-disable-line
2611  if (!cb && typeof Promise !== 'undefined') {
2612    return new Promise(function (resolve) {
2613      _resolve = resolve;
2614    })
2615  }
2616}
2617
2618/*  */
2619
2620var mark;
2621var measure;
2622
2623if (process.env.NODE_ENV !== 'production') {
2624  var perf = inBrowser && window.performance;
2625  /* istanbul ignore if */
2626  if (
2627    perf &&
2628    perf.mark &&
2629    perf.measure &&
2630    perf.clearMarks &&
2631    perf.clearMeasures
2632  ) {
2633    mark = function (tag) { return perf.mark(tag); };
2634    measure = function (name, startTag, endTag) {
2635      perf.measure(name, startTag, endTag);
2636      perf.clearMarks(startTag);
2637      perf.clearMarks(endTag);
2638      // perf.clearMeasures(name)
2639    };
2640  }
2641}
2642
2643/* not type checking this file because flow doesn't play well with Proxy */
2644
2645var initProxy;
2646
2647if (process.env.NODE_ENV !== 'production') {
2648  var allowedGlobals = makeMap(
2649    'Infinity,undefined,NaN,isFinite,isNaN,' +