https://lotus-happiness.com/wp-content/plugins/learnpress/assets/j…?nocache=1790985586.0738&ver=3.2.6.7

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

544    // Firefox has a "watch" function on Object.prototype...
545    var nativeWatch = ({}).watch;
546
547    var supportsPassive = false;
548    if (inBrowser) {
549        try {
550            var opts = {};
551            Object.defineProperty(opts, 'passive', ({
552                get: function get () {
553                  /* istanbul ignore next */
554                    supportsPassive = true;
555                }
556            })); // https://github.com/facebook/flow/issues/285
557            window.addEventListener('test-passive', null, opts);
558        } catch (e) {}
559    }
560
561    // this needs to be lazy-evaled because vue may be required before
562    // vue-server-renderer can set VUE_ENV
563    var _isServer;
564    var isServerRendering = function () {
565        if (_isServer === undefined) {
566          /* istanbul ignore if */
567            if (!inBrowser && !inWeex && typeof global !== 'undefined') {
568                // detect presence of vue-server-renderer and avoid
569                // Webpack shimming the process
570                _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
571            } else {
572                _isServer = false;
573            }
574        }
575        return _isServer
576    };
577
578    // detect devtools
579    var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
580
581  /* istanbul ignore next */
582    function isNative (Ctor) {
583        return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
584    }
585
586    var hasSymbol =
587        typeof Symbol !== 'undefined' && isNative(Symbol) &&
588        typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
589
590    var _Set;
591  /* istanbul ignore if */ // $flow-disable-line
592    if (typeof Set !== 'undefined' && isNative(Set)) {
593        // use native Set when available.
594        _Set = Set;
595    } else {
596        // a non-standard Set polyfill that only works with primitive keys.
597        _Set = /*@__PURE__*/(function () {
598            function Set () {
599                this.set = Object.create(null);
600            }
601            Set.prototype.has = function has (key) {
602                return this.set[key] === true
603            };
604            Set.prototype.add = function add (key) {
605                this.set[key] = true;
606            };
607            Set.prototype.clear = function clear () {
608                this.set = Object.create(null);
609            };
610
611            return Set;
612        }());
613    }
614
615  /*  */
616
617    var warn = noop;
618    var tip = noop;
619    var generateComponentTrace = (noop); // work around flow check
620    var formatComponentName = (noop);
621
622    {
623        var hasConsole = typeof console !== 'undefined';
624        var classifyRE = /(?:^|[-_])(\w)/g;
625        var classify = function (str) { return str
626            .replace(classifyRE, function (c) { return c.toUpperCase(); })
627            .replace(/[-_]/g, ''); };
628
629        warn = function (msg, vm) {
630            var trace = vm ? generateComponentTrace(vm) : '';
631
632            if (config.warnHandler) {
633                config.warnHandler.call(null, msg, vm, trace);
634            } else if (hasConsole && (!config.silent)) {
635                console.error(("[Vue warn]: " + msg + trace));
636            }
637        };
638
639        tip = function (msg, vm) {
640            if (hasConsole && (!config.silent)) {
641                console.warn("[Vue tip]: " + msg + (
642                        vm ? generateComponentTrace(vm) : ''
643                    ));
644            }
645        };
646
647        formatComponentName = function (vm, includeFile) {
648            if (vm.$root === vm) {
649                return '<Root>'
650            }
651            var options = typeof vm === 'function' && vm.cid != null
652                ? vm.options
653                : vm._isVue
654                    ? vm.$options || vm.constructor.options
655                    : vm;
656            var name = options.name || options._componentTag;
657            var file = options.__file;
658            if (!name && file) {
659                var match = file.match(/([^/\\]+)\.vue$/);
660                name = match && match[1];
661            }
662
663            return (
664                (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
665                (file && includeFile !== false ? (" at " + file) : '')
666            )
667        };
668
669        var repeat = function (str, n) {
670            var res = '';
671            while (n) {
672                if (n % 2 === 1) { res += str; }
673                if (n > 1) { str += str; }
674                n >>= 1;
675            }
676            return res
677        };
678
679        generateComponentTrace = function (vm) {
680            if (vm._isVue && vm.$parent) {
681                var tree = [];
682                var currentRecursiveSequence = 0;
683                while (vm) {
684                    if (tree.length > 0) {
685                        var last = tree[tree.length - 1];
686                        if (last.constructor === vm.constructor) {
687                            currentRecursiveSequence++;
688                            vm = vm.$parent;
689                            continue
690                        } else if (currentRecursiveSequence > 0) {
691                            tree[tree.length - 1] = [last, currentRecursiveSequence];
692                            currentRecursiveSequence = 0;
693                        }
694                    }
695                    tree.push(vm);
696                    vm = vm.$parent;
697                }
698                return '\n\nfound in\n\n' + tree
699                        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
700                            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
701                            : formatComponentName(vm))); })
702                        .join('\n')
703            } else {
704                return ("\n\n(found in " + (formatComponentName(vm)) + ")")
705            }
706        };
707    }
708
709  /*  */
710
711    var uid = 0;
712
713    /**
714     * A dep is an observable that can have multiple
715     * directives subscribing to it.
716     */
717    var Dep = function Dep () {
718        this.id = uid++;
719        this.subs = [];
720    };
721
722    Dep.prototype.addSub = function addSub (sub) {
723        this.subs.push(sub);
724    };
725
726    Dep.prototype.removeSub = function removeSub (sub) {
727        remove(this.subs, sub);
728    };
729

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

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

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

2320        if (isDef(hash)) {
2321            if (hasOwn(hash, key)) {
2322                res[key] = hash[key];
2323                if (!preserve) {
2324                    delete hash[key];
2325                }
2326                return true
2327            } else if (hasOwn(hash, altKey)) {
2328                res[key] = hash[altKey];
2329                if (!preserve) {
2330                    delete hash[altKey];
2331                }
2332                return true
2333            }
2334        }
2335        return false
2336    }
2337
2338  /*  */
2339
2340    // The template compiler attempts to minimize the need for normalization by
2341    // statically analyzing the template at compile time.
2342    //
2343    // For plain HTML markup, normalization can be completely skipped because the
2344    // generated render function is guaranteed to return Array<VNode>. There are
2345    // two cases where extra normalization is needed:
2346
2347    // 1. When the children contains components - because a functional component
2348    // may return an Array instead of a single root. In this case, just a simple
2349    // normalization is needed - if any child is an Array, we flatten the whole
2350    // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
2351    // because functional components already normalize their own children.
2352    function simpleNormalizeChildren (children) {
2353        for (var i = 0; i < children.length; i++) {
2354            if (Array.isArray(children[i])) {
2355                return Array.prototype.concat.apply([], children)
2356            }
2357        }
2358        return children
2359    }
2360
2361    // 2. When the children contains constructs that always generated nested Arrays,
2362    // e.g. <template>, <slot>, v-for, or when the children is provided by user
2363    // with hand-written render functions / JSX. In such cases a full normalization
2364    // is needed to cater to all possible types of children values.
2365    function normalizeChildren (children) {
2366        return isPrimitive(children)
2367            ? [createTextVNode(children)]
2368            : Array.isArray(children)
2369                ? normalizeArrayChildren(children)
2370                : undefined
2371    }
2372
2373    function isTextNode (node) {
2374        return isDef(node) && isDef(node.text) && isFalse(node.isComment)
2375    }
2376
2377    function normalizeArrayChildren (children, nestedIndex) {
2378        var res = [];
2379        var i, c, lastIndex, last;
2380        for (i = 0; i < children.length; i++) {
2381            c = children[i];
2382            if (isUndef(c) || typeof c === 'boolean') { continue }
2383            lastIndex = res.length - 1;
2384            last = res[lastIndex];
2385            //  nested
2386            if (Array.isArray(c)) {
2387                if (c.length > 0) {
2388                    c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
2389                    // merge adjacent text nodes
2390                    if (isTextNode(c[0]) && isTextNode(last)) {
2391                        res[lastIndex] = createTextVNode(last.text + (c[0]).text);
2392                        c.shift();
2393                    }
2394                    res.push.apply(res, c);
2395                }
2396            } else if (isPrimitive(c)) {
2397                if (isTextNode(last)) {
2398                    // merge adjacent text nodes
2399                    // this is necessary for SSR hydration because text nodes are
2400                    // essentially merged when rendered to HTML strings
2401                    res[lastIndex] = createTextVNode(last.text + c);
2402                } else if (c !== '') {
2403                    // convert primitive to vnode
2404                    res.push(createTextVNode(c));
2405                }
2406            } else {
2407                if (isTextNode(c) && isTextNode(last)) {
2408                    // merge adjacent text nodes
2409                    res[lastIndex] = createTextVNode(last.text + c.text);
2410                } else {
2411                    // default key for nested array children (likely generated by v-for)
2412                    if (isTrue(children._isVList) &&
2413                        isDef(c.tag) &&
2414                        isUndef(c.key) &&
2415                        isDef(nestedIndex)) {
2416                        c.key = "__vlist" + nestedIndex + "_" + i + "__";
2417                    }
2418                    res.push(c);
2419                }
2420            }
2421        }
2422        return res
2423    }
2424
2425  /*  */
2426
2427    function initProvide (vm) {
2428        var provide = vm.$options.provide;
2429        if (provide) {
2430            vm._provided = typeof provide === 'function'
2431                ? provide.call(vm)
2432                : provide;
2433        }
2434    }
2435
2436    function initInjections (vm) {
2437        var result = resolveInject(vm.$options.inject, vm);
2438        if (result) {
2439            toggleObserving(false);
2440            Object.keys(result).forEach(function (key) {
2441              /* istanbul ignore else */
2442                {
2443                    defineReactive$$1(vm, key, result[key], function () {
2444                        warn(
2445                            "Avoid mutating an injected value directly since the changes will be " +
2446                            "overwritten whenever the provided component re-renders. " +
2447                            "injection being mutated: \"" + key + "\"",
2448                            vm
2449                        );
2450                    });
2451                }
2452            });
2453            toggleObserving(true);
2454        }
2455    }
2456
2457    function resolveInject (inject, vm) {
2458        if (inject) {
2459            // inject is :any because flow is not smart enough to figure out cached
2460            var result = Object.create(null);
2461            var keys = hasSymbol
2462                ? Reflect.ownKeys(inject)
2463                : Object.keys(inject);
2464
2465            for (var i = 0; i < keys.length; i++) {
2466                var key = keys[i];
2467                // #6574 in case the inject object is observed...
2468                if (key === '__ob__') { continue }
2469                var provideKey = inject[key].from;
2470                var source = vm;
2471                while (source) {
2472                    if (source._provided && hasOwn(source._provided, provideKey)) {
2473                        result[key] = source._provided[provideKey];
2474                        break
2475                    }
2476                    source = source.$parent;
2477                }
2478                if (!source) {
2479                    if ('default' in inject[key]) {
2480                        var provideDefault = inject[key].default;
2481                        result[key] = typeof provideDefault === 'function'
2482                            ? provideDefault.call(vm)
2483                            : provideDefault;
2484                    } else {
2485                        warn(("Injection \"" + key + "\" not found"), vm);
2486                    }
2487                }
2488            }
2489            return result
2490        }
2491    }
2492
2493  /*  */
2494
2495
2496
2497    /**
2498     * Runtime helper for resolving raw children VNodes into a slot object.
2499     */
2500    function resolveSlots (
2501        children,
2502        context
2503    ) {
2504        if (!children || !children.length) {
2505            return {}
2506        }
2507        var slots = {};
2508        for (var i = 0, l = children.length; i < l; i++) {
2509            var child = children[i];
2510            var data = child.data;
2511            // remove slot attribute if the node is resolved as a Vue slot node
2512            if (data && data.attrs && data.attrs.slot) {
2513                delete data.attrs.slot;
2514            }
2515            // named slots should only be respected if the vnode was rendered in the
2516            // same context.
2517            if ((child.context === context || child.fnContext === context) &&
2518                data && data.slot != null
2519            ) {
2520                var name = data.slot;
2521                var slot = (slots[name] || (slots[name] = []));
2522                if (child.tag === 'template') {
2523                    slot.push.apply(slot, child.children || []);
2524                } else {
2525                    slot.push(child);
2526                }
2527            } else {
2528                (slots.default || (slots.default = [])).push(child);
2529            }
2530        }
2531        // ignore slots that contains only whitespace
2532        for (var name$1 in slots) {
2533            if (slots[name$1].every(isWhitespace)) {
2534                delete slots[name$1];
2535            }
2536        }
2537        return slots
2538    }
2539
2540    function isWhitespace (node) {
2541        return (node.isComment && !node.asyncFactory) || node.text === ' '
2542    }
2543
2544  /*  */
2545
2546    function normalizeScopedSlots (
2547        slots,
2548        normalSlots,
2549        prevSlots
2550    ) {
2551        var res;
2552        var hasNormalSlots = Object.keys(normalSlots).length > 0;
2553        var isStable = slots ? !!slots.$stable : !hasNormalSlots;
2554        var key = slots && slots.$key;
2555        if (!slots) {
2556            res = {};
2557        } else if (slots._normalized) {
2558            // fast path 1: child component re-render only, parent did not change
2559            return slots._normalized
2560        } else if (
2561            isStable &&
2562            prevSlots &&
2563            prevSlots !== emptyObject &&
2564            key === prevSlots.$key &&
2565            !hasNormalSlots &&
2566            !prevSlots.$hasNormal
2567        ) {
2568            // fast path 2: stable scoped slots w/ no normal slots to proxy,
2569            // only need to normalize once
2570            return prevSlots
2571        } else {
2572            res = {};
2573            for (var key$1 in slots) {
2574                if (slots[key$1] && key$1[0] !== '$') {
2575                    res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
2576                }
2577            }
2578        }
2579        // expose normal slots on scopedSlots
2580        for (var key$2 in normalSlots) {
2581            if (!(key$2 in res)) {
2582                res[key$2] = proxyNormalSlot(normalSlots, key$2);
2583            }
2584        }
2585        // avoriaz seems to mock a non-extensible $scopedSlots object
2586        // and when that is passed down this would cause an error
2587        if (slots && Object.isExtensible(slots)) {
2588            (slots)._normalized = res;
2589        }
2590        def(res, '$stable', isStable);
2591        def(res, '$key', key);
2592        def(res, '$hasNormal', hasNormalSlots);
2593        return res
2594    }
2595
2596    function normalizeScopedSlot(normalSlots, key, fn) {
2597        var normalized = function () {
2598            var res = arguments.length ? fn.apply(null, arguments) : fn({});
2599            res = res && typeof res === 'object' && !Array.isArray(res)
2600                ? [res] // single vnode
2601                : normalizeChildren(res);
2602            return res && (
2603                res.length === 0 ||
2604                (res.length === 1 && res[0].isComment) // #9658
2605            ) ? undefined
2606                : res
2607        };
2608        // this is a slot using the new v-slot syntax without scope. although it is
2609        // compiled as a scoped slot, render fn users would expect it to be present
2610        // on this.$slots because the usage is semantically a normal slot.
2611        if (fn.proxy) {
2612            Object.defineProperty(normalSlots, key, {
2613                get: normalized,
2614                enumerable: true,
2615                configurable: true
2616            });
2617        }
2618        return normalized
2619    }
2620
2621    function proxyNormalSlot(slots, key) {
2622        return function () { return slots[key]; }
2623    }
2624
2625  /*  */
2626
2627    /**
2628     * Runtime helper for rendering v-for lists.
2629     */
2630    function renderList (
2631        val,
2632        render
2633    ) {
2634        var ret, i, l, keys, key;
2635        if (Array.isArray(val) || typeof val === 'string') {
2636            ret = new Array(val.length);
2637            for (i = 0, l = val.length; i < l; i++) {
2638                ret[i] = render(val[i], i);
2639            }
2640        } else if (typeof val === 'number') {
2641            ret = new Array(val);
2642            for (i = 0; i < val; i++) {
2643                ret[i] = render(i + 1, i);
2644            }
2645        } else if (isObject(val)) {
2646            if (hasSymbol && val[Symbol.iterator]) {
2647                ret = [];
2648                var iterator = val[Symbol.iterator]();
2649                var result = iterator.next();
2650                while (!result.done) {
2651                    ret.push(render(result.value, ret.length));
2652                    result = iterator.next();
2653                }
2654            } else {
2655                keys = Object.keys(val);
2656                ret = new Array(keys.length);
2657                for (i = 0, l = keys.length; i < l; i++) {
2658                    key = keys[i];
2659                    ret[i] = render(val[key], key, i);
2660                }
2661            }
2662        }
2663        if (!isDef(ret)) {
2664            ret = [];
2665        }
2666        (ret)._isVList = true;
2667        return ret
2668    }
2669
2670  /*  */
2671
2672    /**
2673     * Runtime helper for rendering <slot>
2674     */
2675    function renderSlot (
2676        name,
2677        fallback,
2678        props,
2679        bindObject
2680    ) {
2681        var scopedSlotFn = this.$scopedSlots[name];
2682        var nodes;
2683        if (scopedSlotFn) { // scoped slot
2684            props = props || {};
2685            if (bindObject) {
2686                if (!isObject(bindObject)) {
2687                    warn(
2688                        'slot v-bind without argument expects an Object',
2689                        this
2690                    );
2691                }
2692                props = extend(extend({}, bindObject), props);
2693            }
2694            nodes = scopedSlotFn(props) || fallback;
2695        } else {
2696            nodes = this.$slots[name] || fallback;
2697        }
2698
2699        var target = props && props.slot;
2700        if (target) {
2701            return this.$createElement('template', { slot: target }, nodes)
2702        } else {
2703            return nodes
2704        }
2705    }
2706
2707  /*  */
2708
2709    /**
2710     * Runtime helper for resolving filters
2711     */
2712    function resolveFilter (id) {
2713        return resolveAsset(this.$options, 'filters', id, true) || identity
2714    }
2715
2716  /*  */
2717
2718    function isKeyNotMatch (expect, actual) {
2719        if (Array.isArray(expect)) {
2720            return expect.indexOf(actual) === -1
2721        } else {
2722            return expect !== actual
2723        }
2724    }
2725
2726    /**
2727     * Runtime helper for checking keyCodes from config.
2728     * exposed as Vue.prototype._k
2729     * passing in eventKeyName as last argument separately for backwards compat
2730     */
2731    function checkKeyCodes (
2732        eventKeyCode,
2733        key,
2734        builtInKeyCode,
2735        eventKeyName,
2736        builtInKeyName
2737    ) {
2738        var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
2739        if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
2740            return isKeyNotMatch(builtInKeyName, eventKeyName)
2741        } else if (mappedKeyCode) {
2742            return isKeyNotMatch(mappedKeyCode, eventKeyCode)
2743        } else if (eventKeyName) {
2744            return hyphenate(eventKeyName) !== key
2745        }
2746    }
2747
2748  /*  */
2749
2750    /**
2751     * Runtime helper for merging v-bind="object" into a VNode's data.
2752     */
2753    function bindObjectProps (
2754        data,
2755        tag,
2756        value,
2757        asProp,
2758        isSync
2759    ) {
2760        if (value) {
2761            if (!isObject(value)) {
2762                warn(
2763                    'v-bind without argument expects an Object or Array value',
2764                    this
2765                );
2766            } else {
2767                if (Array.isArray(value)) {
2768                    value = toObject(value);
2769                }
2770                var hash;
2771                var loop = function ( key ) {
2772                    if (
2773                        key === 'class' ||
2774                        key === 'style' ||
2775                        isReservedAttribute(key)
2776                    ) {
2777                        hash = data;
2778                    } else {
2779                        var type = data.attrs && data.attrs.type;
2780                        hash = asProp || config.mustUseProp(tag, type, key)
2781                            ? data.domProps || (data.domProps = {})
2782                            : data.attrs || (data.attrs = {});
2783                    }
2784                    var camelizedKey = camelize(key);
2785                    var hyphenatedKey = hyphenate(key);
2786                    if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
2787                        hash[key] = value[key];
2788
2789                        if (isSync) {
2790                            var on = data.on || (data.on = {});
2791                            on[("update:" + key)] = function ($event) {
2792                                value[key] = $event;
2793                            };
2794                        }
2795                    }
2796                };
2797
2798                for (var key in value) loop( key );
2799            }
2800        }
2801        return data
2802    }
2803
2804  /*  */
2805
2806    /**
2807     * Runtime helper for rendering static trees.
2808     */