https://iscb-cn.org.cn/weben/js/vue.js

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

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

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

1589        // return previous default value to avoid unnecessary watcher trigger
1590        if (vm && vm.$options.propsData &&
1591            vm.$options.propsData[key] === undefined &&
1592            vm._props[key] !== undefined
1593        ) {
1594            return vm._props[key]
1595        }
1596        // call factory function for non-Function types
1597        // a value is Function if its prototype is function even across different execution context
1598        return typeof def === 'function' && getType(prop.type) !== 'Function' ?
1599            def.call(vm) :
1600            def
1601    }
1602
1603    /**
1604     * Assert whether a prop is valid.
1605     */
1606    function assertProp(
1607        prop,
1608        name,
1609        value,
1610        vm,
1611        absent
1612    ) {
1613        if (prop.required && absent) {
1614            warn(
1615                'Missing required prop: "' + name + '"',
1616                vm
1617            );
1618            return
1619        }
1620        if (value == null && !prop.required) {
1621            return
1622        }
1623        var type = prop.type;
1624        var valid = !type || type === true;
1625        var expectedTypes = [];
1626        if (type) {
1627            if (!Array.isArray(type)) {
1628                type = [type];
1629            }
1630            for (var i = 0; i < type.length && !valid; i++) {
1631                var assertedType = assertType(value, type[i]);
1632                expectedTypes.push(assertedType.expectedType || '');
1633                valid = assertedType.valid;
1634            }
1635        }
1636        if (!valid) {
1637            warn(
1638                "Invalid prop: type check failed for prop \"" + name + "\"." +
1639                " Expected " + (expectedTypes.map(capitalize).join(', ')) +
1640                ", got " + (toRawType(value)) + ".",
1641                vm
1642            );
1643            return
1644        }
1645        var validator = prop.validator;
1646        if (validator) {
1647            if (!validator(value)) {
1648                warn(
1649                    'Invalid prop: custom validator check failed for prop "' + name + '".',
1650                    vm
1651                );
1652            }
1653        }
1654    }
1655
1656    var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
1657
1658    function assertType(value, type) {
1659        var valid;
1660        var expectedType = getType(type);
1661        if (simpleCheckRE.test(expectedType)) {
1662            var t = typeof value;
1663            valid = t === expectedType.toLowerCase();
1664            // for primitive wrapper objects
1665            if (!valid && t === 'object') {
1666                valid = value instanceof type;
1667            }
1668        } else if (expectedType === 'Object') {
1669            valid = isPlainObject(value);
1670        } else if (expectedType === 'Array') {
1671            valid = Array.isArray(value);
1672        } else {
1673            valid = value instanceof type;
1674        }
1675        return {
1676            valid: valid,
1677            expectedType: expectedType
1678        }
1679    }
1680
1681    /**
1682     * Use function string name to check built-in types,
1683     * because a simple equality check will fail when running
1684     * across different vms / iframes.
1685     */
1686    function getType(fn) {
1687        var match = fn && fn.toString().match(/^\s*function (\w+)/);
1688        return match ? match[1] : ''
1689    }
1690
1691    function isSameType(a, b) {
1692        return getType(a) === getType(b)
1693    }
1694
1695    function getTypeIndex(type, expectedTypes) {
1696        if (!Array.isArray(expectedTypes)) {
1697            return isSameType(expectedTypes, type) ? 0 : -1
1698        }
1699        for (var i = 0, len = expectedTypes.length; i < len; i++) {
1700            if (isSameType(expectedTypes[i], type)) {
1701                return i
1702            }
1703        }
1704        return -1
1705    }
1706
1707    /*  */
1708
1709    function handleError(err, vm, info) {
1710        if (vm) {
1711            var cur = vm;
1712            while ((cur = cur.$parent)) {
1713                var hooks = cur.$options.errorCaptured;
1714                if (hooks) {
1715                    for (var i = 0; i < hooks.length; i++) {
1716                        try {
1717                            var capture = hooks[i].call(cur, err, vm, info) === false;
1718                            if (capture) { return }
1719                        } catch (e) {
1720                            globalHandleError(e, cur, 'errorCaptured hook');
1721                        }
1722                    }
1723                }
1724            }
1725        }
1726        globalHandleError(err, vm, info);
1727    }
1728
1729    function globalHandleError(err, vm, info) {
1730        if (config.errorHandler) {
1731            try {
1732                return config.errorHandler.call(null, err, vm, info)
1733            } catch (e) {
1734                logError(e, null, 'config.errorHandler');
1735            }
1736        }
1737        logError(err, vm, info);
1738    }
1739
1740    function logError(err, vm, info) {
1741        {
1742            warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
1743        }
1744        /* istanbul ignore else */
1745        if ((inBrowser || inWeex) && typeof console !== 'undefined') {
1746            console.error(err);
1747        } else {
1748            throw err
1749        }
1750    }
1751
1752    /*  */
1753    /* globals MessageChannel */
1754
1755    var callbacks = [];
1756    var pending = false;
1757
1758    function flushCallbacks() {
1759        pending = false;
1760        var copies = callbacks.slice(0);
1761        callbacks.length = 0;
1762        for (var i = 0; i < copies.length; i++) {
1763            copies[i]();
1764        }
1765    }
1766
1767    // Here we have async deferring wrappers using both microtasks and (macro) tasks.
1768    // In < 2.4 we used microtasks everywhere, but there are some scenarios where
1769    // microtasks have too high a priority and fire in between supposedly
1770    // sequential events (e.g. #4521, #6690) or even between bubbling of the same
1771    // event (#6566). However, using (macro) tasks everywhere also has subtle problems
1772    // when state is changed right before repaint (e.g. #6813, out-in transitions).
1773    // Here we use microtask by default, but expose a way to force (macro) task when
1774    // needed (e.g. in event handlers attached by v-on).
1775    var microTimerFunc;
1776    var macroTimerFunc;
1777    var useMacroTask = false;
1778
1779    // Determine (macro) task defer implementation.
1780    // Technically setImmediate should be the ideal choice, but it's only available
1781    // in IE. The only polyfill that consistently queues the callback after all DOM
1782    // events triggered in the same loop is by using MessageChannel.
1783    /* istanbul ignore if */
1784    if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {

1910                target
1911            );
1912        };
1913
1914        var hasProxy =
1915            typeof Proxy !== 'undefined' && isNative(Proxy);
1916
1917        if (hasProxy) {
1918            var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
1919            config.keyCodes = new Proxy(config.keyCodes, {
1920                set: function set(target, key, value) {
1921                    if (isBuiltInModifier(key)) {
1922                        warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
1923                        return false
1924                    } else {
1925                        target[key] = value;
1926                        return true
1927                    }
1928                }
1929            });
1930        }
1931
1932        var hasHandler = {
1933            has: function has(target, key) {
1934                var has = key in target;
1935                var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';
1936                if (!has && !isAllowed) {
1937                    warnNonPresent(target, key);
1938                }
1939                return has || !isAllowed
1940            }
1941        };
1942
1943        var getHandler = {
1944            get: function get(target, key) {
1945                if (typeof key === 'string' && !(key in target)) {
1946                    warnNonPresent(target, key);
1947                }
1948                return target[key]
1949            }
1950        };
1951
1952        initProxy = function initProxy(vm) {
1953            if (hasProxy) {
1954                // determine which proxy handler to use
1955                var options = vm.$options;
1956                var handlers = options.render && options.render._withStripped ?
1957                    getHandler :
1958                    hasHandler;
1959                vm._renderProxy = new Proxy(vm, handlers);
1960            } else {
1961                vm._renderProxy = vm;
1962            }
1963        };
1964    }
1965
1966    /*  */
1967
1968    var seenObjects = new _Set();
1969
1970    /**
1971     * Recursively traverse an object to evoke all converted
1972     * getters, so that every nested property inside the object
1973     * is collected as a "deep" dependency.
1974     */
1975    function traverse(val) {
1976        _traverse(val, seenObjects);
1977        seenObjects.clear();
1978    }
1979
1980    function _traverse(val, seen) {
1981        var i, keys;
1982        var isA = Array.isArray(val);
1983        if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
1984            return
1985        }
1986        if (val.__ob__) {
1987            var depId = val.__ob__.dep.id;
1988            if (seen.has(depId)) {
1989                return
1990            }
1991            seen.add(depId);
1992        }
1993        if (isA) {
1994            i = val.length;
1995            while (i--) { _traverse(val[i], seen); }
1996        } else {
1997            keys = Object.keys(val);
1998            i = keys.length;
1999            while (i--) { _traverse(val[keys[i]], seen); }
2000        }
2001    }
2002
2003    /*  */
2004
2005    var normalizeEvent = cached(function(name) {
2006        var passive = name.charAt(0) === '&';
2007        name = passive ? name.slice(1) : name;
2008        var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
2009        name = once$$1 ? name.slice(1) : name;
2010        var capture = name.charAt(0) === '!';
2011        name = capture ? name.slice(1) : name;
2012        return {
2013            name: name,
2014            once: once$$1,
2015            capture: capture,
2016            passive: passive
2017        }
2018    });
2019
2020    function createFnInvoker(fns) {
2021        function invoker() {
2022            var arguments$1 = arguments;
2023
2024            var fns = invoker.fns;
2025            if (Array.isArray(fns)) {
2026                var cloned = fns.slice();
2027                for (var i = 0; i < cloned.length; i++) {
2028                    cloned[i].apply(null, arguments$1);
2029                }
2030            } else {
2031                // return handler return value for single handlers
2032                return fns.apply(null, arguments)
2033            }
2034        }
2035        invoker.fns = fns;
2036        return invoker
2037    }
2038
2039    function updateListeners(
2040        on,
2041        oldOn,
2042        add,
2043        remove$$1,
2044        vm
2045    ) {
2046        var name, def, cur, old, event;
2047        for (name in on) {
2048            def = cur = on[name];
2049            old = oldOn[name];
2050            event = normalizeEvent(name);
2051            /* istanbul ignore if */
2052            if (isUndef(cur)) {
2053                "development" !== 'production' && warn(
2054                    "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
2055                    vm
2056                );
2057            } else if (isUndef(old)) {
2058                if (isUndef(cur.fns)) {
2059                    cur = on[name] = createFnInvoker(cur);
2060                }
2061                add(event.name, cur, event.once, event.capture, event.passive, event.params);
2062            } else if (cur !== old) {
2063                old.fns = cur;
2064                on[name] = old;
2065            }
2066        }
2067        for (name in oldOn) {
2068            if (isUndef(on[name])) {
2069                event = normalizeEvent(name);
2070                remove$$1(event.name, oldOn[name], event.capture);
2071            }
2072        }
2073    }
2074
2075    /*  */
2076
2077    function mergeVNodeHook(def, hookKey, hook) {
2078        if (def instanceof VNode) {
2079            def = def.data.hook || (def.data.hook = {});
2080        }
2081        var invoker;
2082        var oldHook = def[hookKey];
2083
2084        function wrappedHook() {
2085            hook.apply(this, arguments);
2086            // important: remove merged hook to ensure it's called only once
2087            // and prevent memory leak
2088            remove(invoker.fns, wrappedHook);
2089        }
2090
2091        if (isUndef(oldHook)) {
2092            // no existing hook
2093            invoker = createFnInvoker([wrappedHook]);
2094        } else {
2095            /* istanbul ignore if */
2096            if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
2097                // already a merged invoker
2098                invoker = oldHook;
2099                invoker.fns.push(wrappedHook);
2100            } else {
2101                // existing plain hook
2102                invoker = createFnInvoker([oldHook, wrappedHook]);
2103            }
2104        }
2105
2106        invoker.merged = true;
2107        def[hookKey] = invoker;
2108    }
2109
2110    /*  */
2111
2112    function extractPropsFromVNodeData(
2113        data,
2114        Ctor,
2115        tag
2116    ) {
2117        // we are only extracting raw values here.
2118        // validation and default values are handled in the child
2119        // component itself.
2120        var propOptions = Ctor.options.props;
2121        if (isUndef(propOptions)) {
2122            return
2123        }
2124        var res = {};
2125        var attrs = data.attrs;
2126        var props = data.props;
2127        if (isDef(attrs) || isDef(props)) {
2128            for (var key in propOptions) {
2129                var altKey = hyphenate(key); {
2130                    var keyInLowerCase = key.toLowerCase();
2131                    if (
2132                        key !== keyInLowerCase &&
2133                        attrs && hasOwn(attrs, keyInLowerCase)
2134                    ) {
2135                        tip(
2136                            "Prop \"" + keyInLowerCase + "\" is passed to component " +
2137                            (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
2138                            " \"" + key + "\". " +
2139                            "Note that HTML attributes are case-insensitive and camelCased " +
2140                            "props need to use their kebab-case equivalents when using in-DOM " +
2141                            "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
2142                        );
2143                    }
2144                }
2145                checkProp(res, props, key, altKey, true) ||
2146                    checkProp(res, attrs, key, altKey, false);
2147            }
2148        }
2149        return res
2150    }
2151
2152    function checkProp(
2153        res,
2154        hash,
2155        key,
2156        altKey,
2157        preserve
2158    ) {

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

2344            if (isObject(res)) {
2345                if (typeof res.then === 'function') {
2346                    // () => Promise
2347                    if (isUndef(factory.resolved)) {
2348                        res.then(resolve, reject);
2349                    }
2350                } else if (isDef(res.component) && typeof res.component.then === 'function') {
2351                    res.component.then(resolve, reject);
2352
2353                    if (isDef(res.error)) {
2354                        factory.errorComp = ensureCtor(res.error, baseCtor);
2355                    }
2356
2357                    if (isDef(res.loading)) {
2358                        factory.loadingComp = ensureCtor(res.loading, baseCtor);
2359                        if (res.delay === 0) {
2360                            factory.loading = true;
2361                        } else {
2362                            setTimeout(function() {
2363                                if (isUndef(factory.resolved) && isUndef(factory.error)) {
2364                                    factory.loading = true;
2365                                    forceRender();
2366                                }
2367                            }, res.delay || 200);
2368                        }
2369                    }
2370
2371                    if (isDef(res.timeout)) {
2372                        setTimeout(function() {
2373                            if (isUndef(factory.resolved)) {
2374                                reject(
2375                                    "timeout (" + (res.timeout) + "ms)"
2376                                );
2377                            }
2378                        }, res.timeout);
2379                    }
2380                }
2381            }
2382
2383            sync = false;
2384            // return in case resolved synchronously
2385            return factory.loading ?
2386                factory.loadingComp :
2387                factory.resolved
2388        }
2389    }
2390
2391    /*  */
2392
2393    function isAsyncPlaceholder(node) {
2394        return node.isComment && node.asyncFactory
2395    }
2396
2397    /*  */
2398
2399    function getFirstComponentChild(children) {
2400        if (Array.isArray(children)) {
2401            for (var i = 0; i < children.length; i++) {
2402                var c = children[i];
2403                if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
2404                    return c
2405                }
2406            }
2407        }
2408    }
2409
2410    /*  */
2411
2412    /*  */
2413
2414    function initEvents(vm) {
2415        vm._events = Object.create(null);
2416        vm._hasHookEvent = false;
2417        // init parent attached events
2418        var listeners = vm.$options._parentListeners;
2419        if (listeners) {
2420            updateComponentListeners(vm, listeners);
2421        }
2422    }
2423
2424    var target;
2425
2426    function add(event, fn, once) {
2427        if (once) {
2428            target.$once(event, fn);
2429        } else {
2430            target.$on(event, fn);
2431        }
2432    }
2433
2434    function remove$1(event, fn) {
2435        target.$off(event, fn);
2436    }
2437
2438    function updateComponentListeners(
2439        vm,
2440        listeners,
2441        oldListeners
2442    ) {
2443        target = vm;
2444        updateListeners(listeners, oldListeners || {}, add, remove$1, vm);
2445        target = undefined;
2446    }
2447
2448    function eventsMixin(Vue) {
2449        var hookRE = /^hook:/;
2450        Vue.prototype.$on = function(event, fn) {
2451            var this$1 = this;
2452
2453            var vm = this;
2454            if (Array.isArray(event)) {
2455                for (var i = 0, l = event.length; i < l; i++) {
2456                    this$1.$on(event[i], fn);
2457                }
2458            } else {
2459                (vm._events[event] || (vm._events[event] = [])).push(fn);
2460                // optimize hook:event cost by using a boolean flag marked at registration
2461                // instead of a hash lookup
2462                if (hookRE.test(event)) {
2463                    vm._hasHookEvent = true;
2464                }
2465            }
2466            return vm
2467        };
2468
2469        Vue.prototype.$once = function(event, fn) {
2470            var vm = this;
2471
2472            function on() {
2473                vm.$off(event, on);
2474                fn.apply(vm, arguments);
2475            }
2476            on.fn = fn;
2477            vm.$on(event, on);
2478            return vm
2479        };
2480
2481        Vue.prototype.$off = function(event, fn) {
2482            var this$1 = this;
2483
2484            var vm = this;
2485            // all
2486            if (!arguments.length) {
2487                vm._events = Object.create(null);
2488                return vm
2489            }
2490            // array of events
2491            if (Array.isArray(event)) {
2492                for (var i = 0, l = event.length; i < l; i++) {
2493                    this$1.$off(event[i], fn);
2494                }
2495                return vm
2496            }
2497            // specific event
2498            var cbs = vm._events[event];
2499            if (!cbs) {
2500                return vm
2501            }
2502            if (!fn) {
2503                vm._events[event] = null;
2504                return vm
2505            }
2506            if (fn) {
2507                // specific handler
2508                var cb;
2509                var i$1 = cbs.length;
2510                while (i$1--) {
2511                    cb = cbs[i$1];
2512                    if (cb === fn || cb.fn === fn) {
2513                        cbs.splice(i$1, 1);
2514                        break
2515                    }
2516                }
2517            }
2518            return vm
2519        };
2520
2521        Vue.prototype.$emit = function(event) {
2522            var vm = this; {
2523                var lowerCaseEvent = event.toLowerCase();
2524                if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
2525                    tip(
2526                        "Event \"" + lowerCaseEvent + "\" is emitted in component " +
2527                        (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
2528                        "Note that HTML attributes are case-insensitive and you cannot use " +
2529                        "v-on to listen to camelCase events when using in-DOM templates. " +
2530                        "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
2531                    );
2532                }
2533            }
2534            var cbs = vm._events[event];
2535            if (cbs) {
2536                cbs = cbs.length > 1 ? toArray(cbs) : cbs;
2537                var args = toArray(arguments, 1);
2538                for (var i = 0, l = cbs.length; i < l; i++) {
2539                    try {
2540                        cbs[i].apply(vm, args);
2541                    } catch (e) {
2542                        handleError(e, vm, ("event handler for \"" + event + "\""));
2543                    }
2544                }
2545            }
2546            return vm
2547        };
2548    }
2549
2550    /*  */
2551
2552
2553
2554    /**
2555     * Runtime helper for resolving raw children VNodes into a slot object.
2556     */
2557    function resolveSlots(
2558        children,
2559        context
2560    ) {
2561        var slots = {};
2562        if (!children) {
2563            return slots
2564        }
2565        for (var i = 0, l = children.length; i < l; i++) {
2566            var child = children[i];
2567            var data = child.data;
2568            // remove slot attribute if the node is resolved as a Vue slot node
2569            if (data && data.attrs && data.attrs.slot) {
2570                delete data.attrs.slot;
2571            }
2572            // named slots should only be respected if the vnode was rendered in the
2573            // same context.
2574            if ((child.context === context || child.fnContext === context) &&
2575                data && data.slot != null
2576            ) {
2577                var name = data.slot;
2578                var slot = (slots[name] || (slots[name] = []));
2579                if (child.tag === 'template') {
2580                    slot.push.apply(slot, child.children || []);
2581                } else {
2582                    slot.push(child);
2583                }
2584            } else {
2585                (slots.default || (slots.default = [])).push(child);
2586            }
2587        }
2588        // ignore slots that contains only whitespace
2589        for (var name$1 in slots) {
2590            if (slots[name$1].every(isWhitespace)) {
2591                delete slots[name$1];
2592            }
2593        }
2594        return slots
2595    }
2596
2597    function isWhitespace(node) {
2598        return (node.isComment && !node.asyncFactory) || node.text === ' '
2599    }
2600
2601    function resolveScopedSlots(
2602        fns, // see flow/vnode
2603        res
2604    ) {
2605        res = res || {};
2606        for (var i = 0; i < fns.length; i++) {
2607            if (Array.isArray(fns[i])) {
2608                resolveScopedSlots(fns[i], res);
2609            } else {
2610                res[fns[i].key] = fns[i].fn;
2611            }
2612        }
2613        return res
2614    }
2615
2616    /*  */
2617
2618    var activeInstance = null;
2619    var isUpdatingChildComponent = false;
2620
2621    function initLifecycle(vm) {
2622        var options = vm.$options;
2623
2624        // locate first non-abstract parent
2625        var parent = options.parent;
2626        if (parent && !options.abstract) {
2627            while (parent.$options.abstract && parent.$parent) {
2628                parent = parent.$parent;
2629            }
2630            parent.$children.push(vm);
2631        }
2632
2633        vm.$parent = parent;
2634        vm.$root = parent ? parent.$root : vm;
2635
2636        vm.$children = [];
2637        vm.$refs = {};
2638
2639        vm._watcher = null;
2640        vm._inactive = null;
2641        vm._directInactive = false;
2642        vm._isMounted = false;
2643        vm._isDestroyed = false;
2644        vm._isBeingDestroyed = false;
2645    }
2646
2647    function lifecycleMixin(Vue) {
2648        Vue.prototype._update = function(vnode, hydrating) {
2649            var vm = this;
2650            if (vm._isMounted) {
2651                callHook(vm, 'beforeUpdate');
2652            }
2653            var prevEl = vm.$el;
2654            var prevVnode = vm._vnode;
2655            var prevActiveInstance = activeInstance;
2656            activeInstance = vm;
2657            vm._vnode = vnode;
2658            // Vue.prototype.__patch__ is injected in entry points
2659            // based on the rendering backend used.
2660            if (!prevVnode) {
2661                // initial render
2662                vm.$el = vm.__patch__(
2663                    vm.$el, vnode, hydrating, false /* removeOnly */ ,
2664                    vm.$options._parentElm,
2665                    vm.$options._refElm
2666                );
2667                // no need for the ref nodes after initial patch
2668                // this prevents keeping a detached DOM tree in memory (#5851)
2669                vm.$options._parentElm = vm.$options._refElm = null;
2670            } else {
2671                // updates
2672                vm.$el = vm.__patch__(prevVnode, vnode);
2673            }
2674            activeInstance = prevActiveInstance;
2675            // update __vue__ reference
2676            if (prevEl) {
2677                prevEl.__vue__ = null;
2678            }
2679            if (vm.$el) {
2680                vm.$el.__vue__ = vm;
2681            }
2682            // if parent is an HOC, update its $el as well
2683            if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
2684                vm.$parent.$el = vm.$el;
2685            }
2686            // updated hook is called by the scheduler to ensure that children are
2687            // updated in a parent's updated hook.
2688        };
2689
2690        Vue.prototype.$forceUpdate = function() {
2691            var vm = this;
2692            if (vm._watcher) {
2693                vm._watcher.update();
2694            }
2695        };
2696
2697        Vue.prototype.$destroy = function() {
2698            var vm = this;
2699            if (vm._isBeingDestroyed) {
2700                return
2701            }
2702            callHook(vm, 'beforeDestroy');
2703            vm._isBeingDestroyed = true;
2704            // remove self from parent
2705            var parent = vm.$parent;
2706            if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
2707                remove(parent.$children, vm);
2708            }
2709            // teardown watchers
2710            if (vm._watcher) {
2711                vm._watcher.teardown();
2712            }
2713            var i = vm._watchers.length;
2714            while (i--) {
2715                vm._watchers[i].teardown();
2716            }
2717            // remove reference from data ob
2718            // frozen object may not have observer.
2719            if (vm._data.__ob__) {
2720                vm._data.__ob__.vmCount--;
2721            }
2722            // call the last hook...
2723            vm._isDestroyed = true;
2724            // invoke destroy hooks on current rendered tree
2725            vm.__patch__(vm._vnode, null);
2726            // fire destroyed hook
2727            callHook(vm, 'destroyed');
2728            // turn off all instance listeners.
2729            vm.$off();
2730            // remove __vue__ reference
2731            if (vm.$el) {
2732                vm.$el.__vue__ = null;
2733            }
2734            // release circular reference (#6759)
2735            if (vm.$vnode) {
2736                vm.$vnode.parent = null;
2737            }
2738        };
2739    }
2740
2741    function mountComponent(
2742        vm,
2743        el,
2744        hydrating
2745    ) {
2746        vm.$el = el;
2747        if (!vm.$options.render) {
2748            vm.$options.render = createEmptyVNode; {
2749                /* istanbul ignore if */
2750                if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
2751                    vm.$options.el || el) {
2752                    warn(
2753                        'You are using the runtime-only build of Vue where the template ' +
2754                        'compiler is not available. Either pre-compile the templates into ' +
2755                        'render functions, or use the compiler-included build.',
2756                        vm
2757                    );
2758                } else {
2759                    warn(
2760                        'Failed to mount component: template or render function not defined.',
2761                        vm
2762                    );
2763                }
2764            }
2765        }
2766        callHook(vm, 'beforeMount');
2767
2768        var updateComponent;
2769        /* istanbul ignore if */
2770        if ("development" !== 'production' && config.performance && mark) {
2771            updateComponent = function() {
2772                var name = vm._name;
2773                var id = vm._uid;
2774                var startTag = "vue-perf-start:" + id;
2775                var endTag = "vue-perf-end:" + id;
2776
2777                mark(startTag);
2778                var vnode = vm._render();
2779                mark(endTag);
2780                measure(("vue " + name + " render"), startTag, endTag);
2781
2782                mark(startTag);
2783                vm._update(vnode, hydrating);
2784                mark(endTag);
2785                measure(("vue " + name + " patch"), startTag, endTag);
2786            };
2787        } else {
2788            updateComponent = function() {
2789                vm._update(vm._render(), hydrating);
2790            };
2791        }
2792
2793        // we set this to vm._watcher inside the watcher's constructor
2794        // since the watcher's initial patch may call $forceUpdate (e.g. inside child
2795        // component's mounted hook), which relies on vm._watcher being already defined
2796        new Watcher(vm, updateComponent, noop, null, true /* isRenderWatcher */ );
2797        hydrating = false;
2798
2799        // manually mounted instance, call mounted on self
2800        // mounted is called for render-created child components in its inserted hook
2801        if (vm.$vnode == null) {
2802            vm._isMounted = true;
2803            callHook(vm, 'mounted');
2804        }
2805        return vm
2806    }
2807
2808    function updateChildComponent(
2809        vm,
2810        propsData,
2811        listeners,
2812        parentVnode,
2813        renderChildren
2814    ) {
2815        {
2816            isUpdatingChildComponent = true;
2817        }
2818
2819        // determine whether component has slot children
2820        // we need to do this before overwriting $options._renderChildren
2821        var hasChildren = !!(
2822            renderChildren || // has new static slots
2823            vm.$options._renderChildren || // has old static slots
2824            parentVnode.data.scopedSlots || // has new scoped slots
2825            vm.$scopedSlots !== emptyObject // has old scoped slots
2826        );
2827
2828        vm.$options._parentVnode = parentVnode;
2829        vm.$vnode = parentVnode; // update vm's placeholder node without re-render
2830
2831        if (vm._vnode) { // update child tree's parent
2832            vm._vnode.parent = parentVnode;
2833        }
2834        vm.$options._renderChildren = renderChildren;
2835
2836        // update $attrs and $listeners hash
2837        // these are also reactive so they may trigger child update if the child
2838        // used them during render
2839        vm.$attrs = parentVnode.data.attrs || emptyObject;
2840        vm.$listeners = listeners || emptyObject;
2841
2842        // update props
2843        if (propsData && vm.$options.props) {
2844            toggleObserving(false);
2845            var props = vm._props;
2846            var propKeys = vm.$options._propKeys || [];
2847            for (var i = 0; i < propKeys.length; i++) {
2848                var key = propKeys[i];
2849                var propOptions = vm.$options.props; // wtf flow?
2850                props[key] = validateProp(key, propOptions, propsData, vm);
2851            }
2852            toggleObserving(true);
2853            // keep a copy of raw propsData
2854            vm.$options.propsData = propsData;
2855        }
2856
2857        // update listeners
2858        listeners = listeners || emptyObject;
2859        var oldListeners = vm.$options._parentListeners;
2860        vm.$options._parentListeners = listeners;
2861        updateComponentListeners(vm, listeners, oldListeners);
2862
2863        // resolve slots + force update if has children
2864        if (hasChildren) {
2865            vm.$slots = resolveSlots(renderChildren, parentVnode.context);
2866            vm.$forceUpdate();
2867        }
2868
2869        {
2870            isUpdatingChildComponent = false;
2871        }
2872    }
2873
2874    function isInInactiveTree(vm) {
2875        while (vm && (vm = vm.$parent)) {
2876            if (vm._inactive) { return true }
2877        }
2878        return false
2879    }
2880
2881    function activateChildComponent(vm, direct) {
2882        if (direct) {
2883            vm._directInactive = false;
2884            if (isInInactiveTree(vm)) {
2885                return
2886            }
2887        } else if (vm._directInactive) {
2888            return
2889        }
2890        if (vm._inactive || vm._inactive === null) {
2891            vm._inactive = false;
2892            for (var i = 0; i < vm.$children.length; i++) {
2893                activateChildComponent(vm.$children[i]);
2894            }
2895            callHook(vm, 'activated');
2896        }
2897    }
2898
2899    function deactivateChildComponent(vm, direct) {
2900        if (direct) {
2901            vm._directInactive = true;
2902            if (isInInactiveTree(vm)) {
2903                return
2904            }
2905        }
2906        if (!vm._inactive) {
2907            vm._inactive = true;
2908            for (var i = 0; i < vm.$children.length; i++) {
2909                deactivateChildComponent(vm.$children[i]);
2910            }
2911            callHook(vm, 'deactivated');
2912        }
2913    }
2914
2915    function callHook(vm, hook) {
2916        // #7573 disable dep collection when invoking lifecycle hooks
2917        pushTarget();
2918        var handlers = vm.$options[hook];
2919        if (handlers) {
2920            for (var i = 0, j = handlers.length; i < j; i++) {
2921                try {
2922                    handlers[i].call(vm);
2923                } catch (e) {
2924                    handleError(e, vm, (hook + " hook"));
2925                }
2926            }
2927        }
2928        if (vm._hasHookEvent) {
2929            vm.$emit('hook:' + hook);
2930        }
2931        popTarget();
2932    }
2933
2934    /*  */
2935
2936
2937    var MAX_UPDATE_COUNT = 100;
2938
2939    var queue = [];
2940    var activatedChildren = [];
2941    var has = {};
2942    var circular = {};
2943    var waiting = false;
2944    var flushing = false;
2945    var index = 0;
2946
2947    /**
2948     * Reset the scheduler's state.
2949     */
2950    function resetSchedulerState() {
2951        index = queue.length = activatedChildren.length = 0;
2952        has = {}; {
2953            circular = {};
2954        }
2955        waiting = flushing = false;
2956    }
2957
2958    /**
2959     * Flush both queues and run the watchers.
2960     */
2961    function flushSchedulerQueue() {
2962        flushing = true;
2963        var watcher, id;
2964
2965        // Sort queue before flush.
2966        // This ensures that:
2967        // 1. Components are updated from parent to child. (because parent is always
2968        //    created before the child)
2969        // 2. A component's user watchers are run before its render watcher (because
2970        //    user watchers are created before the render watcher)
2971        // 3. If a component is destroyed during a parent component's watcher run,
2972        //    its watchers can be skipped.
2973        queue.sort(function(a, b) { return a.id - b.id; });
2974
2975        // do not cache length because more watchers might be pushed
2976        // as we run existing watchers
2977        for (index = 0; index < queue.length; index++) {
2978            watcher = queue[index];
2979            id = watcher.id;
2980            has[id] = null;
2981            watcher.run();
2982            // in dev build, check and stop circular updates.
2983            if ("development" !== 'production' && has[id] != null) {
2984                circular[id] = (circular[id] || 0) + 1;
2985                if (circular[id] > MAX_UPDATE_COUNT) {
2986                    warn(
2987                        'You may have an infinite update loop ' + (
2988                            watcher.user ?
2989                            ("in watcher with expression \"" + (watcher.expression) + "\"") :
2990                            "in a component render function."
2991                        ),
2992                        watcher.vm
2993                    );
2994                    break
2995                }
2996            }
2997        }
2998
2999        // keep copies of post queues before resetting state
3000        var activatedQueue = activatedChildren.slice();
3001        var updatedQueue = queue.slice();
3002
3003        resetSchedulerState();
3004
3005        // call component updated and activated hooks
3006        callActivatedHooks(activatedQueue);
3007        callUpdatedHooks(updatedQueue);
3008
3009        // devtool hook
3010        /* istanbul ignore if */
3011        if (devtools && config.devtools) {
3012            devtools.emit('flush');
3013        }
3014    }
3015
3016    function callUpdatedHooks(queue) {
3017        var i = queue.length;
3018        while (i--) {
3019            var watcher = queue[i];
3020            var vm = watcher.vm;
3021            if (vm._watcher === watcher && vm._isMounted) {
3022                callHook(vm, 'updated');
3023            }
3024        }
3025    }
3026
3027    /**
3028     * Queue a kept-alive component that was activated during patch.
3029     * The queue will be processed after the entire tree has been patched.
3030     */
3031    function queueActivatedComponent(vm) {
3032        // setting _inactive to false here so that a render function can
3033        // rely on checking whether it's in an inactive tree (e.g. router-view)
3034        vm._inactive = false;
3035        activatedChildren.push(vm);
3036    }
3037
3038    function callActivatedHooks(queue) {
3039        for (var i = 0; i < queue.length; i++) {
3040            queue[i]._inactive = true;
3041            activateChildComponent(queue[i], true /* true */ );
3042        }
3043    }
3044
3045    /**
3046     * Push a watcher into the watcher queue.
3047     * Jobs with duplicate IDs will be skipped unless it's
3048     * pushed when the queue is being flushed.
3049     */
3050    function queueWatcher(watcher) {
3051        var id = watcher.id;
3052        if (has[id] == null) {
3053            has[id] = true;
3054            if (!flushing) {
3055                queue.push(watcher);
3056            } else {
3057                // if already flushing, splice the watcher based on its id
3058                // if already past its id, it will be run next immediately.
3059                var i = queue.length - 1;
3060                while (i > index && queue[i].id > watcher.id) {
3061                    i--;
3062                }
3063                queue.splice(i + 1, 0, watcher);
3064            }
3065            // queue the flush
3066            if (!waiting) {
3067                waiting = true;
3068                nextTick(flushSchedulerQueue);
3069            }
3070        }
3071    }
3072
3073    /*  */
3074
3075    var uid$1 = 0;
3076
3077    /**
3078     * A watcher parses an expression, collects dependencies,
3079     * and fires callback when the expression value changes.
3080     * This is used for both the $watch() api and directives.
3081     */
3082    var Watcher = function Watcher(
3083        vm,
3084        expOrFn,
3085        cb,
3086        options,
3087        isRenderWatcher
3088    ) {
3089        this.vm = vm;
3090        if (isRenderWatcher) {
3091            vm._watcher = this;
3092        }
3093        vm._watchers.push(this);
3094        // options
3095        if (options) {
3096            this.deep = !!options.deep;
3097            this.user = !!options.user;
3098            this.lazy = !!options.lazy;
3099            this.sync = !!options.sync;
3100        } else {
3101            this.deep = this.user = this.lazy = this.sync = false;
3102        }
3103        this.cb = cb;
3104        this.id = ++uid$1; // uid for batching
3105        this.active = true;
3106        this.dirty = this.lazy; // for lazy watchers
3107        this.deps = [];
3108        this.newDeps = [];
3109        this.depIds = new _Set();
3110        this.newDepIds = new _Set();
3111        this.expression = expOrFn.toString();
3112        // parse expression for getter
3113        if (typeof expOrFn === 'function') {
3114            this.getter = expOrFn;
3115        } else {
3116            this.getter = parsePath(expOrFn);
3117            if (!this.getter) {
3118                this.getter = function() {};
3119                "development" !== 'production' && warn(
3120                    "Failed watching path: \"" + expOrFn + "\" " +
3121                    'Watcher only accepts simple dot-delimited paths. ' +
3122                    'For full control, use a function instead.',
3123                    vm
3124                );
3125            }
3126        }
3127        this.value = this.lazy ?
3128            undefined :
3129            this.get();
3130    };
3131
3132    /**
3133     * Evaluate the getter, and re-collect dependencies.
3134     */
3135    Watcher.prototype.get = function get() {
3136        pushTarget(this);
3137        var value;
3138        var vm = this.vm;
3139        try {
3140            value = this.getter.call(vm, vm);
3141        } catch (e) {
3142            if (this.user) {
3143                handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
3144            } else {
3145                throw e
3146            }
3147        } finally {
3148            // "touch" every property so they are all tracked as
3149            // dependencies for deep watching
3150            if (this.deep) {
3151                traverse(value);
3152            }
3153            popTarget();
3154            this.cleanupDeps();
3155        }
3156        return value
3157    };
3158
3159    /**
3160     * Add a dependency to this directive.
3161     */
3162    Watcher.prototype.addDep = function addDep(dep) {
3163        var id = dep.id;
3164        if (!this.newDepIds.has(id)) {
3165            this.newDepIds.add(id);
3166            this.newDeps.push(dep);
3167            if (!this.depIds.has(id)) {
3168                dep.addSub(this);
3169            }
3170        }
3171    };
3172
3173    /**
3174     * Clean up for dependency collection.
3175     */
3176    Watcher.prototype.cleanupDeps = function cleanupDeps() {
3177        var this$1 = this;
3178
3179        var i = this.deps.length;
3180        while (i--) {
3181            var dep = this$1.deps[i];
3182            if (!this$1.newDepIds.has(dep.id)) {
3183                dep.removeSub(this$1);
3184            }
3185        }
3186        var tmp = this.depIds;
3187        this.depIds = this.newDepIds;
3188        this.newDepIds = tmp;
3189        this.newDepIds.clear();
3190        tmp = this.deps;
3191        this.deps = this.newDeps;
3192        this.newDeps = tmp;
3193        this.newDeps.length = 0;
3194    };
3195
3196    /**
3197     * Subscriber interface.
3198     * Will be called when a dependency changes.
3199     */