swc/crates/swc_ecma_minifier/tests/benches-full/vue.js

!function(global1, factory) {
    'object' == typeof exports && 'undefined' != typeof module ? module.exports = factory() : 'function' == typeof define && define.amd ? define(factory) : (global1 = global1 || self).Vue = factory();
}(this, function() {
    'use strict';
    var Vue, Vue1, cid, Vue2, configDef, Vue3, dataDef, propsDef, Vue4, hookRE, Vue5, Vue6, baseCompile, _isServer, _Set, timerFunc, mark, measure, initProxy, target, len, str, chr, index$1, expressionPos, expressionEndPos, target$1, svgContainer, emptyStyle, decoder, warn$2, delimiters, transforms, preTransforms, postTransforms, platformIsPreTag, platformMustUseProp, platformGetTagNamespace, maybeComponent, isStaticKey, isPlatformReservedTag, div, emptyObject = Object.freeze({});
    function isUndef(v) {
        return null == v;
    }
    function isDef(v) {
        return null != v;
    }
    function isTrue(v) {
        return !0 === v;
    }
    function isPrimitive(value) {
        return 'string' == typeof value || 'number' == typeof value || 'symbol' == typeof value || 'boolean' == typeof value;
    }
    function isObject(obj) {
        return null !== obj && 'object' == typeof obj;
    }
    var _toString = Object.prototype.toString;
    function toRawType(value) {
        return _toString.call(value).slice(8, -1);
    }
    function isPlainObject(obj) {
        return '[object Object]' === _toString.call(obj);
    }
    function isRegExp(v) {
        return '[object RegExp]' === _toString.call(v);
    }
    function isValidArrayIndex(val) {
        var n = parseFloat(String(val));
        return n >= 0 && Math.floor(n) === n && isFinite(val);
    }
    function isPromise(val) {
        return isDef(val) && 'function' == typeof val.then && 'function' == typeof val.catch;
    }
    function toString(val) {
        return null == val ? '' : Array.isArray(val) || isPlainObject(val) && val.toString === _toString ? JSON.stringify(val, null, 2) : String(val);
    }
    function toNumber(val) {
        var n = parseFloat(val);
        return isNaN(n) ? val : n;
    }
    function makeMap(str, expectsLowerCase) {
        for(var map = Object.create(null), list = str.split(','), i = 0; i < list.length; i++)map[list[i]] = !0;
        return expectsLowerCase ? function(val) {
            return map[val.toLowerCase()];
        } : function(val) {
            return map[val];
        };
    }
    var isBuiltInTag = makeMap('slot,component', !0), isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
    function remove(arr, item) {
        if (arr.length) {
            var index = arr.indexOf(item);
            if (index > -1) return arr.splice(index, 1);
        }
    }
    var hasOwnProperty = Object.prototype.hasOwnProperty;
    function hasOwn(obj, key) {
        return hasOwnProperty.call(obj, key);
    }
    function cached(fn) {
        var cache = Object.create(null);
        return function(str) {
            return cache[str] || (cache[str] = fn(str));
        };
    }
    var camelizeRE = /-(\w)/g, camelize = cached(function(str) {
        return str.replace(camelizeRE, function(_, c) {
            return c ? c.toUpperCase() : '';
        });
    }), capitalize = cached(function(str) {
        return str.charAt(0).toUpperCase() + str.slice(1);
    }), hyphenateRE = /\B([A-Z])/g, hyphenate = cached(function(str) {
        return str.replace(hyphenateRE, '-$1').toLowerCase();
    }), bind = Function.prototype.bind ? function(fn, ctx) {
        return fn.bind(ctx);
    } : function(fn, ctx) {
        function boundFn(a) {
            var l = arguments.length;
            return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx);
        }
        return boundFn._length = fn.length, boundFn;
    };
    function toArray(list, start) {
        start = start || 0;
        for(var i = list.length - start, ret = Array(i); i--;)ret[i] = list[i + start];
        return ret;
    }
    function extend(to, _from) {
        for(var key in _from)to[key] = _from[key];
        return to;
    }
    function toObject(arr) {
        for(var res = {}, i = 0; i < arr.length; i++)arr[i] && extend(res, arr[i]);
        return res;
    }
    function noop(a, b, c) {}
    var no = function(a, b, c) {
        return !1;
    }, identity = function(_) {
        return _;
    };
    function looseEqual(a, b) {
        if (a === b) return !0;
        var isObjectA = isObject(a), isObjectB = isObject(b);
        if (isObjectA && isObjectB) try {
            var isArrayA = Array.isArray(a), isArrayB = Array.isArray(b);
            if (isArrayA && isArrayB) return a.length === b.length && a.every(function(e, i) {
                return looseEqual(e, b[i]);
            });
            if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
            if (isArrayA || isArrayB) return !1;
            var keysA = Object.keys(a), keysB = Object.keys(b);
            return keysA.length === keysB.length && keysA.every(function(key) {
                return looseEqual(a[key], b[key]);
            });
        } catch (e) {
            return !1;
        }
        else if (!isObjectA && !isObjectB) return String(a) === String(b);
        else return !1;
    }
    function looseIndexOf(arr, val) {
        for(var i = 0; i < arr.length; i++)if (looseEqual(arr[i], val)) return i;
        return -1;
    }
    function once(fn) {
        var called = !1;
        return function() {
            called || (called = !0, fn.apply(this, arguments));
        };
    }
    var SSR_ATTR = 'data-server-rendered', ASSET_TYPES = [
        'component',
        'directive',
        'filter'
    ], LIFECYCLE_HOOKS = [
        'beforeCreate',
        'created',
        'beforeMount',
        'mounted',
        'beforeUpdate',
        'updated',
        'beforeDestroy',
        'destroyed',
        'activated',
        'deactivated',
        'errorCaptured',
        'serverPrefetch'
    ], config = {
        optionMergeStrategies: Object.create(null),
        silent: !1,
        productionTip: !0,
        devtools: !0,
        performance: !1,
        errorHandler: null,
        warnHandler: null,
        ignoredElements: [],
        keyCodes: Object.create(null),
        isReservedTag: no,
        isReservedAttr: no,
        isUnknownElement: no,
        getTagNamespace: noop,
        parsePlatformTagName: identity,
        mustUseProp: no,
        async: !0,
        _lifecycleHooks: LIFECYCLE_HOOKS
    }, unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
    function isReserved(str) {
        var c = (str + '').charCodeAt(0);
        return 0x24 === c || 0x5F === c;
    }
    function def(obj, key, val, enumerable) {
        Object.defineProperty(obj, key, {
            value: val,
            enumerable: !!enumerable,
            writable: !0,
            configurable: !0
        });
    }
    var bailRE = RegExp("[^" + unicodeRegExp.source + ".$_\\d]"), hasProto = '__proto__' in {}, inBrowser = 'undefined' != typeof window, inWeex = 'undefined' != typeof WXEnvironment && !!WXEnvironment.platform, weexPlatform = inWeex && WXEnvironment.platform.toLowerCase(), UA = inBrowser && window.navigator.userAgent.toLowerCase(), isIE = UA && /msie|trident/.test(UA), isIE9 = UA && UA.indexOf('msie 9.0') > 0, isEdge = UA && UA.indexOf('edge/') > 0;
    UA && UA.indexOf('android');
    var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA) || 'ios' === weexPlatform;
    UA && /chrome\/\d+/.test(UA), UA && /phantomjs/.test(UA);
    var isFF = UA && UA.match(/firefox\/(\d+)/), nativeWatch = {}.watch, supportsPassive = !1;
    if (inBrowser) try {
        var opts = {};
        Object.defineProperty(opts, 'passive', {
            get: function() {
                supportsPassive = !0;
            }
        }), window.addEventListener('test-passive', null, opts);
    } catch (e) {}
    var isServerRendering = function() {
        return void 0 === _isServer && (_isServer = !inBrowser && !inWeex && 'undefined' != typeof global && global.process && 'server' === global.process.env.VUE_ENV), _isServer;
    }, devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
    function isNative(Ctor) {
        return 'function' == typeof Ctor && /native code/.test(Ctor.toString());
    }
    var hasSymbol = 'undefined' != typeof Symbol && isNative(Symbol) && 'undefined' != typeof Reflect && isNative(Reflect.ownKeys);
    _Set = 'undefined' != typeof Set && isNative(Set) ? Set : function() {
        function Set1() {
            this.set = Object.create(null);
        }
        return Set1.prototype.has = function(key) {
            return !0 === this.set[key];
        }, Set1.prototype.add = function(key) {
            this.set[key] = !0;
        }, Set1.prototype.clear = function() {
            this.set = Object.create(null);
        }, Set1;
    }();
    var warn = noop, tip = noop, generateComponentTrace = noop, formatComponentName = noop, hasConsole = 'undefined' != typeof console, classifyRE = /(?:^|[-_])(\w)/g;
    warn = function(msg, vm) {
        var trace = vm ? generateComponentTrace(vm) : '';
        config.warnHandler ? config.warnHandler.call(null, msg, vm, trace) : hasConsole && !config.silent && console.error("[Vue warn]: " + msg + trace);
    }, tip = function(msg, vm) {
        hasConsole && !config.silent && console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
    }, formatComponentName = function(vm, includeFile) {
        if (vm.$root === vm) return '<Root>';
        var options = 'function' == typeof vm && null != vm.cid ? vm.options : vm._isVue ? vm.$options || vm.constructor.options : vm, name = options.name || options._componentTag, file = options.__file;
        if (!name && file) {
            var match = file.match(/([^/\\]+)\.vue$/);
            name = match && match[1];
        }
        return (name ? "<" + name.replace(classifyRE, function(c) {
            return c.toUpperCase();
        }).replace(/[-_]/g, '') + ">" : "<Anonymous>") + (file && !1 !== includeFile ? " at " + file : '');
    };
    var repeat = function(str, n) {
        for(var res = ''; n;)n % 2 == 1 && (res += str), n > 1 && (str += str), n >>= 1;
        return res;
    };
    generateComponentTrace = function(vm) {
        if (!vm._isVue || !vm.$parent) return "\n\n(found in " + formatComponentName(vm) + ")";
        for(var tree = [], currentRecursiveSequence = 0; vm;){
            if (tree.length > 0) {
                var last = tree[tree.length - 1];
                if (last.constructor === vm.constructor) {
                    currentRecursiveSequence++, vm = vm.$parent;
                    continue;
                }
                currentRecursiveSequence > 0 && (tree[tree.length - 1] = [
                    last,
                    currentRecursiveSequence
                ], currentRecursiveSequence = 0);
            }
            tree.push(vm), vm = vm.$parent;
        }
        return '\n\nfound in\n\n' + tree.map(function(vm, i) {
            return "" + (0 === i ? '---> ' : repeat(' ', 5 + 2 * i)) + (Array.isArray(vm) ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)" : formatComponentName(vm));
        }).join('\n');
    };
    var uid = 0, Dep = function() {
        this.id = uid++, this.subs = [];
    };
    Dep.prototype.addSub = function(sub) {
        this.subs.push(sub);
    }, Dep.prototype.removeSub = function(sub) {
        remove(this.subs, sub);
    }, Dep.prototype.depend = function() {
        Dep.target && Dep.target.addDep(this);
    }, Dep.prototype.notify = function() {
        var subs = this.subs.slice();
        config.async || subs.sort(function(a, b) {
            return a.id - b.id;
        });
        for(var i = 0, l = subs.length; i < l; i++)subs[i].update();
    }, Dep.target = null;
    var targetStack = [];
    function pushTarget(target) {
        targetStack.push(target), Dep.target = target;
    }
    function popTarget() {
        targetStack.pop(), Dep.target = targetStack[targetStack.length - 1];
    }
    var VNode = function(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
        this.tag = tag, this.data = data, this.children = children, this.text = text, this.elm = elm, this.ns = void 0, this.context = context, this.fnContext = void 0, this.fnOptions = void 0, this.fnScopeId = void 0, this.key = data && data.key, this.componentOptions = componentOptions, this.componentInstance = void 0, this.parent = void 0, this.raw = !1, this.isStatic = !1, this.isRootInsert = !0, this.isComment = !1, this.isCloned = !1, this.isOnce = !1, this.asyncFactory = asyncFactory, this.asyncMeta = void 0, this.isAsyncPlaceholder = !1;
    }, prototypeAccessors = {
        child: {
            configurable: !0
        }
    };
    prototypeAccessors.child.get = function() {
        return this.componentInstance;
    }, Object.defineProperties(VNode.prototype, prototypeAccessors);
    var createEmptyVNode = function(text) {
        void 0 === text && (text = '');
        var node = new VNode();
        return node.text = text, node.isComment = !0, node;
    };
    function createTextVNode(val) {
        return new VNode(void 0, void 0, void 0, String(val));
    }
    function cloneVNode(vnode) {
        var cloned = new VNode(vnode.tag, vnode.data, vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
        return cloned.ns = vnode.ns, cloned.isStatic = vnode.isStatic, cloned.key = vnode.key, cloned.isComment = vnode.isComment, cloned.fnContext = vnode.fnContext, cloned.fnOptions = vnode.fnOptions, cloned.fnScopeId = vnode.fnScopeId, cloned.asyncMeta = vnode.asyncMeta, cloned.isCloned = !0, cloned;
    }
    var arrayProto = Array.prototype, arrayMethods = Object.create(arrayProto);
    [
        'push',
        'pop',
        'shift',
        'unshift',
        'splice',
        'sort',
        'reverse'
    ].forEach(function(method) {
        var original = arrayProto[method];
        def(arrayMethods, method, function() {
            for(var inserted, args = [], len = arguments.length; len--;)args[len] = arguments[len];
            var result = original.apply(this, args), ob = this.__ob__;
            switch(method){
                case 'push':
                case 'unshift':
                    inserted = args;
                    break;
                case 'splice':
                    inserted = args.slice(2);
            }
            return inserted && ob.observeArray(inserted), ob.dep.notify(), result;
        });
    });
    var arrayKeys = Object.getOwnPropertyNames(arrayMethods), shouldObserve = !0, Observer = function(value) {
        this.value = value, this.dep = new Dep(), this.vmCount = 0, def(value, '__ob__', this), Array.isArray(value) ? (hasProto ? value.__proto__ = arrayMethods : function(target, src, keys) {
            for(var i = 0, l = keys.length; i < l; i++){
                var key = keys[i];
                def(target, key, src[key]);
            }
        }(value, arrayMethods, arrayKeys), this.observeArray(value)) : this.walk(value);
    };
    function observe(value, asRootData) {
        var ob;
        if (isObject(value) && !(value instanceof VNode)) return hasOwn(value, '__ob__') && value.__ob__ instanceof Observer ? ob = value.__ob__ : shouldObserve && !isServerRendering() && (Array.isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value._isVue && (ob = new Observer(value)), asRootData && ob && ob.vmCount++, ob;
    }
    function defineReactive$$1(obj, key, val, customSetter, shallow) {
        var dep = new Dep(), property = Object.getOwnPropertyDescriptor(obj, key);
        if (!property || !1 !== property.configurable) {
            var getter = property && property.get, setter = property && property.set;
            (!getter || setter) && 2 == arguments.length && (val = obj[key]);
            var childOb = !shallow && observe(val);
            Object.defineProperty(obj, key, {
                enumerable: !0,
                configurable: !0,
                get: function() {
                    var value = getter ? getter.call(obj) : val;
                    return Dep.target && (dep.depend(), childOb && (childOb.dep.depend(), Array.isArray(value) && function dependArray(value) {
                        for(var e = void 0, i = 0, l = value.length; i < l; i++)(e = value[i]) && e.__ob__ && e.__ob__.dep.depend(), Array.isArray(e) && dependArray(e);
                    }(value))), value;
                },
                set: function(newVal) {
                    var value = getter ? getter.call(obj) : val;
                    newVal !== value && (newVal == newVal || value == value) && (customSetter && customSetter(), (!getter || setter) && (setter ? setter.call(obj, newVal) : val = newVal, childOb = !shallow && observe(newVal), dep.notify()));
                }
            });
        }
    }
    function set(target, key, val) {
        if ((isUndef(target) || isPrimitive(target)) && warn("Cannot set reactive property on undefined, null, or primitive value: " + target), Array.isArray(target) && isValidArrayIndex(key)) return target.length = Math.max(target.length, key), target.splice(key, 1, val), val;
        if (key in target && !(key in Object.prototype)) return target[key] = val, val;
        var ob = target.__ob__;
        return target._isVue || ob && ob.vmCount ? (warn("Avoid adding reactive properties to a Vue instance or its root $data at runtime - declare it upfront in the data option."), val) : ob ? (defineReactive$$1(ob.value, key, val), ob.dep.notify(), val) : (target[key] = val, val);
    }
    function del(target, key) {
        if ((isUndef(target) || isPrimitive(target)) && warn("Cannot delete reactive property on undefined, null, or primitive value: " + target), Array.isArray(target) && isValidArrayIndex(key)) {
            target.splice(key, 1);
            return;
        }
        var ob = target.__ob__;
        if (target._isVue || ob && ob.vmCount) {
            warn("Avoid deleting properties on a Vue instance or its root $data - just set it to null.");
            return;
        }
        hasOwn(target, key) && (delete target[key], ob && ob.dep.notify());
    }
    Observer.prototype.walk = function(obj) {
        for(var keys = Object.keys(obj), i = 0; i < keys.length; i++)defineReactive$$1(obj, keys[i]);
    }, Observer.prototype.observeArray = function(items) {
        for(var i = 0, l = items.length; i < l; i++)observe(items[i]);
    };
    var strats = config.optionMergeStrategies;
    function mergeData(to, from) {
        if (!from) return to;
        for(var key, toVal, fromVal, keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from), i = 0; i < keys.length; i++)'__ob__' !== (key = keys[i]) && (toVal = to[key], fromVal = from[key], hasOwn(to, key) ? toVal !== fromVal && isPlainObject(toVal) && isPlainObject(fromVal) && mergeData(toVal, fromVal) : set(to, key, fromVal));
        return to;
    }
    function mergeDataOrFn(parentVal, childVal, vm) {
        return vm ? function() {
            var instanceData = 'function' == typeof childVal ? childVal.call(vm, vm) : childVal, defaultData = 'function' == typeof parentVal ? parentVal.call(vm, vm) : parentVal;
            return instanceData ? mergeData(instanceData, defaultData) : defaultData;
        } : childVal ? parentVal ? function() {
            return mergeData('function' == typeof childVal ? childVal.call(this, this) : childVal, 'function' == typeof parentVal ? parentVal.call(this, this) : parentVal);
        } : childVal : parentVal;
    }
    function mergeHook(parentVal, childVal) {
        var res = childVal ? parentVal ? parentVal.concat(childVal) : Array.isArray(childVal) ? childVal : [
            childVal
        ] : parentVal;
        return res ? function(hooks) {
            for(var res = [], i = 0; i < hooks.length; i++)-1 === res.indexOf(hooks[i]) && res.push(hooks[i]);
            return res;
        }(res) : res;
    }
    function mergeAssets(parentVal, childVal, vm, key) {
        var res = Object.create(parentVal || null);
        return childVal ? (assertObjectType(key, childVal, vm), extend(res, childVal)) : res;
    }
    strats.el = strats.propsData = function(parent, child, vm, key) {
        return vm || warn("option \"" + key + '" can only be used during instance creation with the `new` keyword.'), defaultStrat(parent, child);
    }, strats.data = function(parentVal, childVal, vm) {
        return vm ? mergeDataOrFn(parentVal, childVal, vm) : childVal && 'function' != typeof childVal ? (warn('The "data" option should be a function that returns a per-instance value in component definitions.', vm), parentVal) : mergeDataOrFn(parentVal, childVal);
    }, LIFECYCLE_HOOKS.forEach(function(hook) {
        strats[hook] = mergeHook;
    }), ASSET_TYPES.forEach(function(type) {
        strats[type + 's'] = mergeAssets;
    }), strats.watch = function(parentVal, childVal, vm, key) {
        if (parentVal === nativeWatch && (parentVal = void 0), childVal === nativeWatch && (childVal = void 0), !childVal) return Object.create(parentVal || null);
        if (assertObjectType(key, childVal, vm), !parentVal) return childVal;
        var ret = {};
        for(var key$1 in extend(ret, parentVal), childVal){
            var parent = ret[key$1], child = childVal[key$1];
            parent && !Array.isArray(parent) && (parent = [
                parent
            ]), ret[key$1] = parent ? parent.concat(child) : Array.isArray(child) ? child : [
                child
            ];
        }
        return ret;
    }, strats.props = strats.methods = strats.inject = strats.computed = function(parentVal, childVal, vm, key) {
        if (childVal && assertObjectType(key, childVal, vm), !parentVal) return childVal;
        var ret = Object.create(null);
        return extend(ret, parentVal), childVal && extend(ret, childVal), ret;
    }, strats.provide = mergeDataOrFn;
    var defaultStrat = function(parentVal, childVal) {
        return void 0 === childVal ? parentVal : childVal;
    };
    function validateComponentName(name) {
        RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name) || warn('Invalid component name: "' + name + '". Component names should conform to valid custom element name in html5 specification.'), (isBuiltInTag(name) || config.isReservedTag(name)) && warn("Do not use built-in or reserved HTML elements as component id: " + name);
    }
    function assertObjectType(name, value, vm) {
        isPlainObject(value) || warn("Invalid value for option \"" + name + '": expected an Object, but got ' + toRawType(value) + ".", vm);
    }
    function mergeOptions(parent, child, vm) {
        if (!function(options) {
            for(var key in options.components)validateComponentName(key);
        }(child), 'function' == typeof child && (child = child.options), !function(options, vm) {
            var i, val, props = options.props;
            if (props) {
                var res = {};
                if (Array.isArray(props)) for(i = props.length; i--;)'string' == typeof (val = props[i]) ? res[camelize(val)] = {
                    type: null
                } : warn('props must be strings when using array syntax.');
                else if (isPlainObject(props)) for(var key in props)val = props[key], res[camelize(key)] = isPlainObject(val) ? val : {
                    type: val
                };
                else warn('Invalid value for option "props": expected an Array or an Object, but got ' + toRawType(props) + ".", vm);
                options.props = res;
            }
        }(child, vm), !function(options, vm) {
            var inject = options.inject;
            if (inject) {
                var normalized = options.inject = {};
                if (Array.isArray(inject)) for(var i = 0; i < inject.length; i++)normalized[inject[i]] = {
                    from: inject[i]
                };
                else if (isPlainObject(inject)) for(var key in inject){
                    var val = inject[key];
                    normalized[key] = isPlainObject(val) ? extend({
                        from: key
                    }, val) : {
                        from: val
                    };
                }
                else warn('Invalid value for option "inject": expected an Array or an Object, but got ' + toRawType(inject) + ".", vm);
            }
        }(child, vm), !function(options) {
            var dirs = options.directives;
            if (dirs) for(var key in dirs){
                var def$$1 = dirs[key];
                'function' == typeof def$$1 && (dirs[key] = {
                    bind: def$$1,
                    update: def$$1
                });
            }
        }(child), !child._base && (child.extends && (parent = mergeOptions(parent, child.extends, vm)), child.mixins)) for(var key, i = 0, l = child.mixins.length; i < l; i++)parent = mergeOptions(parent, child.mixins[i], vm);
        var options = {};
        for(key in parent)mergeField(key);
        for(key in child)hasOwn(parent, key) || mergeField(key);
        function mergeField(key) {
            var strat = strats[key] || defaultStrat;
            options[key] = strat(parent[key], child[key], vm, key);
        }
        return options;
    }
    function resolveAsset(options, type, id, warnMissing) {
        if ('string' == typeof id) {
            var assets = options[type];
            if (hasOwn(assets, id)) return assets[id];
            var camelizedId = camelize(id);
            if (hasOwn(assets, camelizedId)) return assets[camelizedId];
            var PascalCaseId = capitalize(camelizedId);
            if (hasOwn(assets, PascalCaseId)) return assets[PascalCaseId];
            var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
            return warnMissing && !res && warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options), res;
        }
    }
    function validateProp(key, propOptions, propsData, vm) {
        var prop = propOptions[key], absent = !hasOwn(propsData, key), value = propsData[key], booleanIndex = getTypeIndex(Boolean, prop.type);
        if (booleanIndex > -1) {
            if (absent && !hasOwn(prop, 'default')) value = !1;
            else if ('' === value || value === hyphenate(key)) {
                var stringIndex = getTypeIndex(String, prop.type);
                (stringIndex < 0 || booleanIndex < stringIndex) && (value = !0);
            }
        }
        if (void 0 === value) {
            value = function(vm, prop, key) {
                if (hasOwn(prop, 'default')) {
                    var def = prop.default;
                    return (isObject(def) && warn('Invalid default value for prop "' + key + '": Props with type Object/Array must use a factory function to return the default value.', vm), vm && vm.$options.propsData && void 0 === vm.$options.propsData[key] && void 0 !== vm._props[key]) ? vm._props[key] : 'function' == typeof def && 'Function' !== getType(prop.type) ? def.call(vm) : def;
                }
            }(vm, prop, key);
            var prevShouldObserve = shouldObserve;
            shouldObserve = !0, observe(value), shouldObserve = prevShouldObserve;
        }
        return function(prop, name, value, vm, absent) {
            if (prop.required && absent) {
                warn('Missing required prop: "' + name + '"', vm);
                return;
            }
            if (null != value || prop.required) {
                var message, expectedType, receivedType, expectedValue, receivedValue, type = prop.type, valid = !type || !0 === type, expectedTypes = [];
                if (type) {
                    Array.isArray(type) || (type = [
                        type
                    ]);
                    for(var i = 0; i < type.length && !valid; i++){
                        var assertedType = function(value, type) {
                            var valid, expectedType = getType(type);
                            if (simpleCheckRE.test(expectedType)) {
                                var t = typeof value;
                                (valid = t === expectedType.toLowerCase()) || 'object' !== t || (valid = value instanceof type);
                            } else valid = 'Object' === expectedType ? isPlainObject(value) : 'Array' === expectedType ? Array.isArray(value) : value instanceof type;
                            return {
                                valid: valid,
                                expectedType: expectedType
                            };
                        }(value, type[i]);
                        expectedTypes.push(assertedType.expectedType || ''), valid = assertedType.valid;
                    }
                }
                if (!valid) {
                    warn((message = "Invalid prop: type check failed for prop \"" + name + '". Expected ' + expectedTypes.map(capitalize).join(', '), expectedType = expectedTypes[0], receivedType = toRawType(value), expectedValue = styleValue(value, expectedType), receivedValue = styleValue(value, receivedType), 1 === expectedTypes.length && isExplicable(expectedType) && !function() {
                        for(var args = [], len = arguments.length; len--;)args[len] = arguments[len];
                        return args.some(function(elem) {
                            return 'boolean' === elem.toLowerCase();
                        });
                    }(expectedType, receivedType) && (message += " with value " + expectedValue), message += ", got " + receivedType + " ", isExplicable(receivedType) && (message += "with value " + receivedValue + "."), message), vm);
                    return;
                }
                var validator = prop.validator;
                validator && !validator(value) && warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
            }
        }(prop, key, value, vm, absent), value;
    }
    var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
    function getType(fn) {
        var match = fn && fn.toString().match(/^\s*function (\w+)/);
        return match ? match[1] : '';
    }
    function getTypeIndex(type, expectedTypes) {
        if (!Array.isArray(expectedTypes)) return getType(expectedTypes) === getType(type) ? 0 : -1;
        for(var i = 0, len = expectedTypes.length; i < len; i++)if (getType(expectedTypes[i]) === getType(type)) return i;
        return -1;
    }
    function styleValue(value, type) {
        return 'String' === type ? "\"" + value + "\"" : 'Number' === type ? "" + Number(value) : "" + value;
    }
    function isExplicable(value) {
        return [
            'string',
            'number',
            'boolean'
        ].some(function(elem) {
            return value.toLowerCase() === elem;
        });
    }
    function handleError(err, vm, info) {
        pushTarget();
        try {
            if (vm) for(var cur = vm; cur = cur.$parent;){
                var hooks = cur.$options.errorCaptured;
                if (hooks) for(var i = 0; i < hooks.length; i++)try {
                    if (!1 === hooks[i].call(cur, err, vm, info)) return;
                } catch (e) {
                    globalHandleError(e, cur, 'errorCaptured hook');
                }
            }
            globalHandleError(err, vm, info);
        } finally{
            popTarget();
        }
    }
    function invokeWithErrorHandling(handler, context, args, vm, info) {
        var res;
        try {
            (res = args ? handler.apply(context, args) : handler.call(context)) && !res._isVue && isPromise(res) && !res._handled && (res.catch(function(e) {
                return handleError(e, vm, info + " (Promise/async)");
            }), res._handled = !0);
        } catch (e) {
            handleError(e, vm, info);
        }
        return res;
    }
    function globalHandleError(err, vm, info) {
        if (config.errorHandler) try {
            return config.errorHandler.call(null, err, vm, info);
        } catch (e) {
            e !== err && logError(e, null, 'config.errorHandler');
        }
        logError(err, vm, info);
    }
    function logError(err, vm, info) {
        if (warn("Error in " + info + ": \"" + err.toString() + "\"", vm), (inBrowser || inWeex) && 'undefined' != typeof console) console.error(err);
        else throw err;
    }
    var isUsingMicroTask = !1, callbacks = [], pending = !1;
    function flushCallbacks() {
        pending = !1;
        var copies = callbacks.slice(0);
        callbacks.length = 0;
        for(var i = 0; i < copies.length; i++)copies[i]();
    }
    if ('undefined' != typeof Promise && isNative(Promise)) {
        var p = Promise.resolve();
        timerFunc = function() {
            p.then(flushCallbacks), isIOS && setTimeout(noop);
        }, isUsingMicroTask = !0;
    } else if (!isIE && 'undefined' != typeof MutationObserver && (isNative(MutationObserver) || '[object MutationObserverConstructor]' === MutationObserver.toString())) {
        var counter = 1, observer = new MutationObserver(flushCallbacks), textNode = document.createTextNode(String(counter));
        observer.observe(textNode, {
            characterData: !0
        }), timerFunc = function() {
            counter = (counter + 1) % 2, textNode.data = String(counter);
        }, isUsingMicroTask = !0;
    } else timerFunc = 'undefined' != typeof setImmediate && isNative(setImmediate) ? function() {
        setImmediate(flushCallbacks);
    } : function() {
        setTimeout(flushCallbacks, 0);
    };
    function nextTick(cb, ctx) {
        var _resolve;
        if (callbacks.push(function() {
            if (cb) try {
                cb.call(ctx);
            } catch (e) {
                handleError(e, ctx, 'nextTick');
            }
            else _resolve && _resolve(ctx);
        }), pending || (pending = !0, timerFunc()), !cb && 'undefined' != typeof Promise) return new Promise(function(resolve) {
            _resolve = resolve;
        });
    }
    var perf = inBrowser && window.performance;
    perf && perf.mark && perf.measure && perf.clearMarks && perf.clearMeasures && (mark = function(tag) {
        return perf.mark(tag);
    }, measure = function(name, startTag, endTag) {
        perf.measure(name, startTag, endTag), perf.clearMarks(startTag), perf.clearMarks(endTag);
    });
    var allowedGlobals = makeMap("Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,require"), warnNonPresent = function(target, key) {
        warn("Property or method \"" + key + '" is not defined on the instance but referenced during render. Make sure that this property is reactive, either in the data option, or for class-based components, by initializing the property. See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
    }, warnReservedPrefix = function(target, key) {
        warn("Property \"" + key + "\" must be accessed with \"$data." + key + '" because properties starting with "$" or "_" are not proxied in the Vue instance to prevent conflicts with Vue internals. See: https://vuejs.org/v2/api/#data', target);
    }, hasProxy = 'undefined' != typeof Proxy && isNative(Proxy);
    if (hasProxy) {
        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
        config.keyCodes = new Proxy(config.keyCodes, {
            set: function(target, key, value) {
                return isBuiltInModifier(key) ? (warn("Avoid overwriting built-in modifier in config.keyCodes: ." + key), !1) : (target[key] = value, !0);
            }
        });
    }
    var hasHandler = {
        has: function(target, key) {
            var has = key in target, isAllowed = allowedGlobals(key) || 'string' == typeof key && '_' === key.charAt(0) && !(key in target.$data);
            return has || isAllowed || (key in target.$data ? warnReservedPrefix(target, key) : warnNonPresent(target, key)), has || !isAllowed;
        }
    }, getHandler = {
        get: function(target, key) {
            return 'string' != typeof key || key in target || (key in target.$data ? warnReservedPrefix(target, key) : warnNonPresent(target, key)), target[key];
        }
    };
    initProxy = function(vm) {
        if (hasProxy) {
            var options = vm.$options, handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
            vm._renderProxy = new Proxy(vm, handlers);
        } else vm._renderProxy = vm;
    };
    var seenObjects = new _Set();
    function traverse(val) {
        (function _traverse(val, seen) {
            var i, keys, isA = Array.isArray(val);
            if (!(!isA && !isObject(val) || Object.isFrozen(val)) && !(val instanceof VNode)) {
                if (val.__ob__) {
                    var depId = val.__ob__.dep.id;
                    if (seen.has(depId)) return;
                    seen.add(depId);
                }
                if (isA) for(i = val.length; i--;)_traverse(val[i], seen);
                else for(i = (keys = Object.keys(val)).length; i--;)_traverse(val[keys[i]], seen);
            }
        })(val, seenObjects), seenObjects.clear();
    }
    var normalizeEvent = cached(function(name) {
        var passive = '&' === name.charAt(0), once$$1 = '~' === (name = passive ? name.slice(1) : name).charAt(0), capture = '!' === (name = once$$1 ? name.slice(1) : name).charAt(0);
        return {
            name: name = capture ? name.slice(1) : name,
            once: once$$1,
            capture: capture,
            passive: passive
        };
    });
    function createFnInvoker(fns, vm) {
        function invoker() {
            var arguments$1 = arguments, fns = invoker.fns;
            if (!Array.isArray(fns)) return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
            for(var cloned = fns.slice(), i = 0; i < cloned.length; i++)invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
        }
        return invoker.fns = fns, invoker;
    }
    function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
        var name, cur, old, event;
        for(name in on)cur = on[name], old = oldOn[name], event = normalizeEvent(name), isUndef(cur) ? warn("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm) : isUndef(old) ? (isUndef(cur.fns) && (cur = on[name] = createFnInvoker(cur, vm)), isTrue(event.once) && (cur = on[name] = createOnceHandler(event.name, cur, event.capture)), add(event.name, cur, event.capture, event.passive, event.params)) : cur !== old && (old.fns = cur, on[name] = old);
        for(name in oldOn)isUndef(on[name]) && remove$$1((event = normalizeEvent(name)).name, oldOn[name], event.capture);
    }
    function mergeVNodeHook(def, hookKey, hook) {
        def instanceof VNode && (def = def.data.hook || (def.data.hook = {}));
        var invoker, oldHook = def[hookKey];
        function wrappedHook() {
            hook.apply(this, arguments), remove(invoker.fns, wrappedHook);
        }
        isUndef(oldHook) ? invoker = createFnInvoker([
            wrappedHook
        ]) : isDef(oldHook.fns) && isTrue(oldHook.merged) ? (invoker = oldHook).fns.push(wrappedHook) : invoker = createFnInvoker([
            oldHook,
            wrappedHook
        ]), invoker.merged = !0, def[hookKey] = invoker;
    }
    function checkProp(res, hash, key, altKey, preserve) {
        if (isDef(hash)) {
            if (hasOwn(hash, key)) return res[key] = hash[key], preserve || delete hash[key], !0;
            if (hasOwn(hash, altKey)) return res[key] = hash[altKey], preserve || delete hash[altKey], !0;
        }
        return !1;
    }
    function normalizeChildren(children) {
        return isPrimitive(children) ? [
            createTextVNode(children)
        ] : Array.isArray(children) ? function normalizeArrayChildren(children, nestedIndex) {
            var i, c, lastIndex, last, res = [];
            for(i = 0; i < children.length; i++)!isUndef(c = children[i]) && 'boolean' != typeof c && (lastIndex = res.length - 1, last = res[lastIndex], Array.isArray(c) ? c.length > 0 && (isTextNode((c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i))[0]) && isTextNode(last) && (res[lastIndex] = createTextVNode(last.text + c[0].text), c.shift()), res.push.apply(res, c)) : isPrimitive(c) ? isTextNode(last) ? res[lastIndex] = createTextVNode(last.text + c) : '' !== c && res.push(createTextVNode(c)) : isTextNode(c) && isTextNode(last) ? res[lastIndex] = createTextVNode(last.text + c.text) : (isTrue(children._isVList) && isDef(c.tag) && isUndef(c.key) && isDef(nestedIndex) && (c.key = "__vlist" + nestedIndex + "_" + i + "__"), res.push(c)));
            return res;
        }(children) : void 0;
    }
    function isTextNode(node) {
        return isDef(node) && isDef(node.text) && !1 === node.isComment;
    }
    function resolveInject(inject, vm) {
        if (inject) {
            for(var result = Object.create(null), keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject), i = 0; i < keys.length; i++){
                var key = keys[i];
                if ('__ob__' !== key) {
                    for(var provideKey = inject[key].from, source = vm; source;){
                        if (source._provided && hasOwn(source._provided, provideKey)) {
                            result[key] = source._provided[provideKey];
                            break;
                        }
                        source = source.$parent;
                    }
                    if (!source) {
                        if ('default' in inject[key]) {
                            var provideDefault = inject[key].default;
                            result[key] = 'function' == typeof provideDefault ? provideDefault.call(vm) : provideDefault;
                        } else warn("Injection \"" + key + "\" not found", vm);
                    }
                }
            }
            return result;
        }
    }
    function resolveSlots(children, context) {
        if (!children || !children.length) return {};
        for(var slots = {}, i = 0, l = children.length; i < l; i++){
            var child = children[i], data = child.data;
            if (data && data.attrs && data.attrs.slot && delete data.attrs.slot, (child.context === context || child.fnContext === context) && data && null != data.slot) {
                var name = data.slot, slot = slots[name] || (slots[name] = []);
                'template' === child.tag ? slot.push.apply(slot, child.children || []) : slot.push(child);
            } else (slots.default || (slots.default = [])).push(child);
        }
        for(var name$1 in slots)slots[name$1].every(isWhitespace) && delete slots[name$1];
        return slots;
    }
    function isWhitespace(node) {
        return node.isComment && !node.asyncFactory || ' ' === node.text;
    }
    function normalizeScopedSlots(slots, normalSlots, prevSlots) {
        var res, hasNormalSlots = Object.keys(normalSlots).length > 0, isStable = slots ? !!slots.$stable : !hasNormalSlots, key = slots && slots.$key;
        if (slots) {
            if (slots._normalized) return slots._normalized;
            if (isStable && prevSlots && prevSlots !== emptyObject && key === prevSlots.$key && !hasNormalSlots && !prevSlots.$hasNormal) return prevSlots;
            for(var key$1 in res = {}, slots)slots[key$1] && '$' !== key$1[0] && (res[key$1] = function(normalSlots, key, fn) {
                var normalized = function() {
                    var res = arguments.length ? fn.apply(null, arguments) : fn({});
                    return (res = res && 'object' == typeof res && !Array.isArray(res) ? [
                        res
                    ] : normalizeChildren(res)) && (0 === res.length || 1 === res.length && res[0].isComment) ? void 0 : res;
                };
                return fn.proxy && Object.defineProperty(normalSlots, key, {
                    get: normalized,
                    enumerable: !0,
                    configurable: !0
                }), normalized;
            }(normalSlots, key$1, slots[key$1]));
        } else res = {};
        for(var key$2 in normalSlots)key$2 in res || (res[key$2] = function(slots, key) {
            return function() {
                return slots[key];
            };
        }(normalSlots, key$2));
        return slots && Object.isExtensible(slots) && (slots._normalized = res), def(res, '$stable', isStable), def(res, '$key', key), def(res, '$hasNormal', hasNormalSlots), res;
    }
    function renderList(val, render) {
        var ret, i, l, keys, key;
        if (Array.isArray(val) || 'string' == typeof val) for(i = 0, ret = Array(val.length), l = val.length; i < l; i++)ret[i] = render(val[i], i);
        else if ('number' == typeof val) for(i = 0, ret = Array(val); i < val; i++)ret[i] = render(i + 1, i);
        else if (isObject(val)) {
            if (hasSymbol && val[Symbol.iterator]) {
                ret = [];
                for(var iterator = val[Symbol.iterator](), result = iterator.next(); !result.done;)ret.push(render(result.value, ret.length)), result = iterator.next();
            } else for(i = 0, ret = Array((keys = Object.keys(val)).length), l = keys.length; i < l; i++)key = keys[i], ret[i] = render(val[key], key, i);
        }
        return isDef(ret) || (ret = []), ret._isVList = !0, ret;
    }
    function renderSlot(name, fallback, props, bindObject) {
        var nodes, scopedSlotFn = this.$scopedSlots[name];
        scopedSlotFn ? (props = props || {}, bindObject && (isObject(bindObject) || warn('slot v-bind without argument expects an Object', this), props = extend(extend({}, bindObject), props)), nodes = scopedSlotFn(props) || fallback) : nodes = this.$slots[name] || fallback;
        var target = props && props.slot;
        return target ? this.$createElement('template', {
            slot: target
        }, nodes) : nodes;
    }
    function resolveFilter(id) {
        return resolveAsset(this.$options, 'filters', id, !0) || identity;
    }
    function isKeyNotMatch(expect, actual) {
        return Array.isArray(expect) ? -1 === expect.indexOf(actual) : expect !== actual;
    }
    function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
        var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
        return builtInKeyName && eventKeyName && !config.keyCodes[key] ? isKeyNotMatch(builtInKeyName, eventKeyName) : mappedKeyCode ? isKeyNotMatch(mappedKeyCode, eventKeyCode) : eventKeyName ? hyphenate(eventKeyName) !== key : void 0;
    }
    function bindObjectProps(data, tag, value, asProp, isSync) {
        if (value) {
            if (isObject(value)) {
                Array.isArray(value) && (value = toObject(value));
                var hash, loop = function(key) {
                    if ('class' === key || 'style' === key || isReservedAttribute(key)) hash = data;
                    else {
                        var type = data.attrs && data.attrs.type;
                        hash = asProp || config.mustUseProp(tag, type, key) ? data.domProps || (data.domProps = {}) : data.attrs || (data.attrs = {});
                    }
                    var camelizedKey = camelize(key), hyphenatedKey = hyphenate(key);
                    camelizedKey in hash || hyphenatedKey in hash || (hash[key] = value[key], isSync && ((data.on || (data.on = {}))["update:" + key] = function($event) {
                        value[key] = $event;
                    }));
                };
                for(var key in value)loop(key);
            } else warn('v-bind without argument expects an Object or Array value', this);
        }
        return data;
    }
    function renderStatic(index, isInFor) {
        var cached = this._staticTrees || (this._staticTrees = []), tree = cached[index];
        return tree && !isInFor || markStatic(tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this), "__static__" + index, !1), tree;
    }
    function markOnce(tree, index, key) {
        return markStatic(tree, "__once__" + index + (key ? "_" + key : ""), !0), tree;
    }
    function markStatic(tree, key, isOnce) {
        if (Array.isArray(tree)) for(var i = 0; i < tree.length; i++)tree[i] && 'string' != typeof tree[i] && markStaticNode(tree[i], key + "_" + i, isOnce);
        else markStaticNode(tree, key, isOnce);
    }
    function markStaticNode(node, key, isOnce) {
        node.isStatic = !0, node.key = key, node.isOnce = isOnce;
    }
    function bindObjectListeners(data, value) {
        if (value) {
            if (isPlainObject(value)) {
                var on = data.on = data.on ? extend({}, data.on) : {};
                for(var key in value){
                    var existing = on[key], ours = value[key];
                    on[key] = existing ? [].concat(existing, ours) : ours;
                }
            } else warn('v-on without argument expects an Object value', this);
        }
        return data;
    }
    function bindDynamicKeys(baseObj, values) {
        for(var i = 0; i < values.length; i += 2){
            var key = values[i];
            'string' == typeof key && key ? baseObj[values[i]] = values[i + 1] : '' !== key && null !== key && warn("Invalid value for dynamic directive argument (expected string or null): " + key, this);
        }
        return baseObj;
    }
    function prependModifier(value, symbol) {
        return 'string' == typeof value ? symbol + value : value;
    }
    function installRenderHelpers(target) {
        target._o = markOnce, target._n = toNumber, target._s = toString, target._l = renderList, target._t = renderSlot, target._q = looseEqual, target._i = looseIndexOf, target._m = renderStatic, target._f = resolveFilter, target._k = checkKeyCodes, target._b = bindObjectProps, target._v = createTextVNode, target._e = createEmptyVNode, target._u = function resolveScopedSlots(fns, res, hasDynamicKeys, contentHashKey) {
            res = res || {
                $stable: !hasDynamicKeys
            };
            for(var i = 0; i < fns.length; i++){
                var slot = fns[i];
                Array.isArray(slot) ? resolveScopedSlots(slot, res, hasDynamicKeys) : slot && (slot.proxy && (slot.fn.proxy = !0), res[slot.key] = slot.fn);
            }
            return contentHashKey && (res.$key = contentHashKey), res;
        }, target._g = bindObjectListeners, target._d = bindDynamicKeys, target._p = prependModifier;
    }
    function FunctionalRenderContext(data, props, children, parent, Ctor) {
        var contextVm, this$1 = this, options = Ctor.options;
        hasOwn(parent, '_uid') ? (contextVm = Object.create(parent))._original = parent : (contextVm = parent, parent = parent._original);
        var isCompiled = isTrue(options._compiled), needNormalization = !isCompiled;
        this.data = data, this.props = props, this.children = children, this.parent = parent, this.listeners = data.on || emptyObject, this.injections = resolveInject(options.inject, parent), this.slots = function() {
            return this$1.$slots || normalizeScopedSlots(data.scopedSlots, this$1.$slots = resolveSlots(children, parent)), this$1.$slots;
        }, Object.defineProperty(this, 'scopedSlots', {
            enumerable: !0,
            get: function() {
                return normalizeScopedSlots(data.scopedSlots, this.slots());
            }
        }), isCompiled && (this.$options = options, this.$slots = this.slots(), this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots)), options._scopeId ? this._c = function(a, b, c, d) {
            var vnode = createElement(contextVm, a, b, c, d, needNormalization);
            return vnode && !Array.isArray(vnode) && (vnode.fnScopeId = options._scopeId, vnode.fnContext = parent), vnode;
        } : this._c = function(a, b, c, d) {
            return createElement(contextVm, a, b, c, d, needNormalization);
        };
    }
    function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
        var clone = cloneVNode(vnode);
        return clone.fnContext = contextVm, clone.fnOptions = options, (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext, data.slot && ((clone.data || (clone.data = {})).slot = data.slot), clone;
    }
    function mergeProps(to, from) {
        for(var key in from)to[camelize(key)] = from[key];
    }
    installRenderHelpers(FunctionalRenderContext.prototype);
    var componentVNodeHooks = {
        init: function(vnode, hydrating) {
            var options, inlineTemplate;
            vnode.componentInstance && !vnode.componentInstance._isDestroyed && vnode.data.keepAlive ? componentVNodeHooks.prepatch(vnode, vnode) : (vnode.componentInstance = (options = {
                _isComponent: !0,
                _parentVnode: vnode,
                parent: activeInstance
            }, isDef(inlineTemplate = vnode.data.inlineTemplate) && (options.render = inlineTemplate.render, options.staticRenderFns = inlineTemplate.staticRenderFns), new vnode.componentOptions.Ctor(options))).$mount(hydrating ? vnode.elm : void 0, hydrating);
        },
        prepatch: function(oldVnode, vnode) {
            var options = vnode.componentOptions;
            !function(vm, propsData, listeners, parentVnode, renderChildren) {
                isUpdatingChildComponent = !0;
                var newScopedSlots = parentVnode.data.scopedSlots, oldScopedSlots = vm.$scopedSlots, hasDynamicScopedSlot = !!(newScopedSlots && !newScopedSlots.$stable || oldScopedSlots !== emptyObject && !oldScopedSlots.$stable || newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key), needsForceUpdate = !!(renderChildren || vm.$options._renderChildren || hasDynamicScopedSlot);
                if (vm.$options._parentVnode = parentVnode, vm.$vnode = parentVnode, vm._vnode && (vm._vnode.parent = parentVnode), vm.$options._renderChildren = renderChildren, vm.$attrs = parentVnode.data.attrs || emptyObject, vm.$listeners = listeners || emptyObject, propsData && vm.$options.props) {
                    shouldObserve = !1;
                    for(var props = vm._props, propKeys = vm.$options._propKeys || [], i = 0; i < propKeys.length; i++){
                        var key = propKeys[i], propOptions = vm.$options.props;
                        props[key] = validateProp(key, propOptions, propsData, vm);
                    }
                    shouldObserve = !0, vm.$options.propsData = propsData;
                }
                listeners = listeners || emptyObject;
                var oldListeners = vm.$options._parentListeners;
                vm.$options._parentListeners = listeners, updateComponentListeners(vm, listeners, oldListeners), needsForceUpdate && (vm.$slots = resolveSlots(renderChildren, parentVnode.context), vm.$forceUpdate()), isUpdatingChildComponent = !1;
            }(vnode.componentInstance = oldVnode.componentInstance, options.propsData, options.listeners, vnode, options.children);
        },
        insert: function(vnode) {
            var context = vnode.context, componentInstance = vnode.componentInstance;
            componentInstance._isMounted || (componentInstance._isMounted = !0, callHook(componentInstance, 'mounted')), vnode.data.keepAlive && (context._isMounted ? (componentInstance._inactive = !1, activatedChildren.push(componentInstance)) : activateChildComponent(componentInstance, !0));
        },
        destroy: function(vnode) {
            var componentInstance = vnode.componentInstance;
            componentInstance._isDestroyed || (vnode.data.keepAlive ? function deactivateChildComponent(vm, direct) {
                if (!(direct && (vm._directInactive = !0, isInInactiveTree(vm))) && !vm._inactive) {
                    vm._inactive = !0;
                    for(var i = 0; i < vm.$children.length; i++)deactivateChildComponent(vm.$children[i]);
                    callHook(vm, 'deactivated');
                }
            }(componentInstance, !0) : componentInstance.$destroy());
        }
    }, hooksToMerge = Object.keys(componentVNodeHooks);
    function createComponent(Ctor, data, context, children, tag) {
        if (!isUndef(Ctor)) {
            var factory, data1, node, options, data2, prop, event, on, existing, callback, asyncFactory, baseCtor = context.$options._base;
            if (isObject(Ctor) && (Ctor = baseCtor.extend(Ctor)), 'function' != typeof Ctor) {
                warn("Invalid Component definition: " + String(Ctor), context);
                return;
            }
            if (isUndef(Ctor.cid) && void 0 === (Ctor = function(factory, baseCtor) {
                if (isTrue(factory.error) && isDef(factory.errorComp)) return factory.errorComp;
                if (isDef(factory.resolved)) return factory.resolved;
                var owner = currentRenderingInstance;
                if (owner && isDef(factory.owners) && -1 === factory.owners.indexOf(owner) && factory.owners.push(owner), isTrue(factory.loading) && isDef(factory.loadingComp)) return factory.loadingComp;
                if (owner && !isDef(factory.owners)) {
                    var owners = factory.owners = [
                        owner
                    ], sync = !0, timerLoading = null, timerTimeout = null;
                    owner.$on('hook:destroyed', function() {
                        return remove(owners, owner);
                    });
                    var forceRender = function(renderCompleted) {
                        for(var i = 0, l = owners.length; i < l; i++)owners[i].$forceUpdate();
                        renderCompleted && (owners.length = 0, null !== timerLoading && (clearTimeout(timerLoading), timerLoading = null), null !== timerTimeout && (clearTimeout(timerTimeout), timerTimeout = null));
                    }, resolve = once(function(res) {
                        factory.resolved = ensureCtor(res, baseCtor), sync ? owners.length = 0 : forceRender(!0);
                    }), reject = once(function(reason) {
                        warn("Failed to resolve async component: " + String(factory) + (reason ? "\nReason: " + reason : '')), isDef(factory.errorComp) && (factory.error = !0, forceRender(!0));
                    }), res = factory(resolve, reject);
                    return isObject(res) && (isPromise(res) ? isUndef(factory.resolved) && res.then(resolve, reject) : isPromise(res.component) && (res.component.then(resolve, reject), isDef(res.error) && (factory.errorComp = ensureCtor(res.error, baseCtor)), isDef(res.loading) && (factory.loadingComp = ensureCtor(res.loading, baseCtor), 0 === res.delay ? factory.loading = !0 : timerLoading = setTimeout(function() {
                        timerLoading = null, isUndef(factory.resolved) && isUndef(factory.error) && (factory.loading = !0, forceRender(!1));
                    }, res.delay || 200)), isDef(res.timeout) && (timerTimeout = setTimeout(function() {
                        timerTimeout = null, isUndef(factory.resolved) && reject("timeout (" + res.timeout + "ms)");
                    }, res.timeout)))), sync = !1, factory.loading ? factory.loadingComp : factory.resolved;
                }
            }(asyncFactory = Ctor, baseCtor))) return factory = asyncFactory, data1 = data, (node = createEmptyVNode()).asyncFactory = factory, node.asyncMeta = {
                data: data1,
                context: context,
                children: children,
                tag: tag
            }, node;
            data = data || {}, resolveConstructorOptions(Ctor), isDef(data.model) && (options = Ctor.options, data2 = data, prop = options.model && options.model.prop || 'value', event = options.model && options.model.event || 'input', (data2.attrs || (data2.attrs = {}))[prop] = data2.model.value, existing = (on = data2.on || (data2.on = {}))[event], callback = data2.model.callback, isDef(existing) ? (Array.isArray(existing) ? -1 === existing.indexOf(callback) : existing !== callback) && (on[event] = [
                callback
            ].concat(existing)) : on[event] = callback);
            var propsData = function(data, Ctor, tag) {
                var propOptions = Ctor.options.props;
                if (!isUndef(propOptions)) {
                    var res = {}, attrs = data.attrs, props = data.props;
                    if (isDef(attrs) || isDef(props)) for(var key in propOptions){
                        var altKey = hyphenate(key), keyInLowerCase = key.toLowerCase();
                        key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase) && tip("Prop \"" + keyInLowerCase + "\" is passed to component " + formatComponentName(tag || Ctor) + ', but the declared prop name is "' + key + '". Note that HTML attributes are case-insensitive and camelCased props need to use their kebab-case equivalents when using in-DOM templates. You should probably use "' + altKey + "\" instead of \"" + key + "\"."), checkProp(res, props, key, altKey, !0) || checkProp(res, attrs, key, altKey, !1);
                    }
                    return res;
                }
            }(data, Ctor, tag);
            if (isTrue(Ctor.options.functional)) return function(Ctor, propsData, data, contextVm, children) {
                var options = Ctor.options, props = {}, propOptions = options.props;
                if (isDef(propOptions)) for(var key in propOptions)props[key] = validateProp(key, propOptions, propsData || emptyObject);
                else isDef(data.attrs) && mergeProps(props, data.attrs), isDef(data.props) && mergeProps(props, data.props);
                var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor), vnode = options.render.call(null, renderContext._c, renderContext);
                if (vnode instanceof VNode) return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
                if (Array.isArray(vnode)) {
                    for(var vnodes = normalizeChildren(vnode) || [], res = Array(vnodes.length), i = 0; i < vnodes.length; i++)res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
                    return res;
                }
            }(Ctor, propsData, data, context, children);
            var listeners = data.on;
            if (data.on = data.nativeOn, isTrue(Ctor.options.abstract)) {
                var slot = data.slot;
                data = {}, slot && (data.slot = slot);
            }
            !function(data) {
                for(var hooks = data.hook || (data.hook = {}), i = 0; i < hooksToMerge.length; i++){
                    var key = hooksToMerge[i], existing = hooks[key], toMerge = componentVNodeHooks[key];
                    existing === toMerge || existing && existing._merged || (hooks[key] = existing ? function(f1, f2) {
                        var merged = function(a, b) {
                            f1(a, b), f2(a, b);
                        };
                        return merged._merged = !0, merged;
                    }(toMerge, existing) : toMerge);
                }
            }(data);
            var name = Ctor.options.name || tag;
            return new VNode("vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, void 0, void 0, void 0, context, {
                Ctor: Ctor,
                propsData: propsData,
                listeners: listeners,
                tag: tag,
                children: children
            }, asyncFactory);
        }
    }
    function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
        var tag1, data1, children1, normalizationType1, vnode, ns, Ctor, data2;
        return (Array.isArray(data) || isPrimitive(data)) && (normalizationType = children, children = data, data = void 0), isTrue(alwaysNormalize) && (normalizationType = 2), tag1 = tag, data1 = data, children1 = children, normalizationType1 = normalizationType, isDef(data1) && isDef(data1.__ob__) ? (warn("Avoid using observed data object as vnode data: " + JSON.stringify(data1) + "\nAlways create fresh vnode data objects in each render!", context), createEmptyVNode()) : (isDef(data1) && isDef(data1.is) && (tag1 = data1.is), tag1) ? (isDef(data1) && isDef(data1.key) && !isPrimitive(data1.key) && warn("Avoid using non-primitive value as key, use string/number value instead.", context), Array.isArray(children1) && 'function' == typeof children1[0] && ((data1 = data1 || {}).scopedSlots = {
            default: children1[0]
        }, children1.length = 0), 2 === normalizationType1 ? children1 = normalizeChildren(children1) : 1 === normalizationType1 && (children1 = function(children) {
            for(var i = 0; i < children.length; i++)if (Array.isArray(children[i])) return Array.prototype.concat.apply([], children);
            return children;
        }(children1)), 'string' == typeof tag1 ? (ns = context.$vnode && context.$vnode.ns || config.getTagNamespace(tag1), config.isReservedTag(tag1) ? (isDef(data1) && isDef(data1.nativeOn) && warn("The .native modifier for v-on is only valid on components but it was used on <" + tag1 + ">.", context), vnode = new VNode(config.parsePlatformTagName(tag1), data1, children1, void 0, void 0, context)) : vnode = (!data1 || !data1.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag1)) ? createComponent(Ctor, data1, context, children1, tag1) : new VNode(tag1, data1, children1, void 0, void 0, context)) : vnode = createComponent(tag1, data1, context, children1), Array.isArray(vnode)) ? vnode : isDef(vnode) ? (isDef(ns) && function applyNS(vnode, ns, force) {
            if (vnode.ns = ns, 'foreignObject' === vnode.tag && (ns = void 0, force = !0), isDef(vnode.children)) for(var i = 0, l = vnode.children.length; i < l; i++){
                var child = vnode.children[i];
                isDef(child.tag) && (isUndef(child.ns) || isTrue(force) && 'svg' !== child.tag) && applyNS(child, ns, force);
            }
        }(vnode, ns), isDef(data1) && (isObject((data2 = data1).style) && traverse(data2.style), isObject(data2.class) && traverse(data2.class)), vnode) : createEmptyVNode() : createEmptyVNode();
    }
    var currentRenderingInstance = null;
    function ensureCtor(comp, base) {
        return (comp.__esModule || hasSymbol && 'Module' === comp[Symbol.toStringTag]) && (comp = comp.default), isObject(comp) ? base.extend(comp) : comp;
    }
    function isAsyncPlaceholder(node) {
        return node.isComment && node.asyncFactory;
    }
    function getFirstComponentChild(children) {
        if (Array.isArray(children)) for(var i = 0; i < children.length; i++){
            var c = children[i];
            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) return c;
        }
    }
    function add(event, fn) {
        target.$on(event, fn);
    }
    function remove$1(event, fn) {
        target.$off(event, fn);
    }
    function createOnceHandler(event, fn) {
        var _target = target;
        return function onceHandler() {
            var res = fn.apply(null, arguments);
            null !== res && _target.$off(event, onceHandler);
        };
    }
    function updateComponentListeners(vm, listeners, oldListeners) {
        target = vm, updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm), target = void 0;
    }
    var activeInstance = null, isUpdatingChildComponent = !1;
    function setActiveInstance(vm) {
        var prevActiveInstance = activeInstance;
        return activeInstance = vm, function() {
            activeInstance = prevActiveInstance;
        };
    }
    function isInInactiveTree(vm) {
        for(; vm && (vm = vm.$parent);)if (vm._inactive) return !0;
        return !1;
    }
    function activateChildComponent(vm, direct) {
        if (direct) {
            if (vm._directInactive = !1, isInInactiveTree(vm)) return;
        } else if (vm._directInactive) return;
        if (vm._inactive || null === vm._inactive) {
            vm._inactive = !1;
            for(var i = 0; i < vm.$children.length; i++)activateChildComponent(vm.$children[i]);
            callHook(vm, 'activated');
        }
    }
    function callHook(vm, hook) {
        pushTarget();
        var handlers = vm.$options[hook], info = hook + " hook";
        if (handlers) for(var i = 0, j = handlers.length; i < j; i++)invokeWithErrorHandling(handlers[i], vm, null, vm, info);
        vm._hasHookEvent && vm.$emit('hook:' + hook), popTarget();
    }
    var queue = [], activatedChildren = [], has = {}, circular = {}, waiting = !1, flushing = !1, index = 0, currentFlushTimestamp = 0, getNow = Date.now;
    if (inBrowser && !isIE) {
        var performance = window.performance;
        performance && 'function' == typeof performance.now && getNow() > document.createEvent('Event').timeStamp && (getNow = function() {
            return performance.now();
        });
    }
    function flushSchedulerQueue() {
        for(currentFlushTimestamp = getNow(), flushing = !0, queue.sort(function(a, b) {
            return a.id - b.id;
        }), index = 0; index < queue.length; index++)if ((watcher = queue[index]).before && watcher.before(), has[id = watcher.id] = null, watcher.run(), null != has[id] && (circular[id] = (circular[id] || 0) + 1, circular[id] > 100)) {
            warn('You may have an infinite update loop ' + (watcher.user ? "in watcher with expression \"" + watcher.expression + "\"" : "in a component render function."), watcher.vm);
            break;
        }
        var watcher, id, activatedQueue = activatedChildren.slice(), updatedQueue = queue.slice();
        index = queue.length = activatedChildren.length = 0, has = {}, circular = {}, waiting = flushing = !1, function(queue) {
            for(var i = 0; i < queue.length; i++)queue[i]._inactive = !0, activateChildComponent(queue[i], !0);
        }(activatedQueue), function(queue) {
            for(var i = queue.length; i--;){
                var watcher = queue[i], vm = watcher.vm;
                vm._watcher === watcher && vm._isMounted && !vm._isDestroyed && callHook(vm, 'updated');
            }
        }(updatedQueue), devtools && config.devtools && devtools.emit('flush');
    }
    var uid$2 = 0, Watcher = function(vm, expOrFn, cb, options, isRenderWatcher) {
        this.vm = vm, isRenderWatcher && (vm._watcher = this), vm._watchers.push(this), options ? (this.deep = !!options.deep, this.user = !!options.user, this.lazy = !!options.lazy, this.sync = !!options.sync, this.before = options.before) : this.deep = this.user = this.lazy = this.sync = !1, this.cb = cb, this.id = ++uid$2, this.active = !0, this.dirty = this.lazy, this.deps = [], this.newDeps = [], this.depIds = new _Set(), this.newDepIds = new _Set(), this.expression = expOrFn.toString(), 'function' == typeof expOrFn ? this.getter = expOrFn : (this.getter = function(path) {
            if (!bailRE.test(path)) {
                var segments = path.split('.');
                return function(obj) {
                    for(var i = 0; i < segments.length; i++){
                        if (!obj) return;
                        obj = obj[segments[i]];
                    }
                    return obj;
                };
            }
        }(expOrFn), this.getter || (this.getter = noop, warn("Failed watching path: \"" + expOrFn + '" Watcher only accepts simple dot-delimited paths. For full control, use a function instead.', vm))), this.value = this.lazy ? void 0 : this.get();
    };
    Watcher.prototype.get = function() {
        pushTarget(this);
        var value, vm = this.vm;
        try {
            value = this.getter.call(vm, vm);
        } catch (e) {
            if (this.user) handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
            else throw e;
        } finally{
            this.deep && traverse(value), popTarget(), this.cleanupDeps();
        }
        return value;
    }, Watcher.prototype.addDep = function(dep) {
        var id = dep.id;
        this.newDepIds.has(id) || (this.newDepIds.add(id), this.newDeps.push(dep), this.depIds.has(id) || dep.addSub(this));
    }, Watcher.prototype.cleanupDeps = function() {
        for(var i = this.deps.length; i--;){
            var dep = this.deps[i];
            this.newDepIds.has(dep.id) || dep.removeSub(this);
        }
        var tmp = this.depIds;
        this.depIds = this.newDepIds, this.newDepIds = tmp, this.newDepIds.clear(), tmp = this.deps, this.deps = this.newDeps, this.newDeps = tmp, this.newDeps.length = 0;
    }, Watcher.prototype.update = function() {
        this.lazy ? this.dirty = !0 : this.sync ? this.run() : function(watcher) {
            var id = watcher.id;
            if (null == has[id]) {
                if (has[id] = !0, flushing) {
                    for(var i = queue.length - 1; i > index && queue[i].id > watcher.id;)i--;
                    queue.splice(i + 1, 0, watcher);
                } else queue.push(watcher);
                if (!waiting) {
                    if (waiting = !0, !config.async) {
                        flushSchedulerQueue();
                        return;
                    }
                    nextTick(flushSchedulerQueue);
                }
            }
        }(this);
    }, Watcher.prototype.run = function() {
        if (this.active) {
            var value = this.get();
            if (value !== this.value || isObject(value) || this.deep) {
                var oldValue = this.value;
                if (this.value = value, this.user) try {
                    this.cb.call(this.vm, value, oldValue);
                } catch (e) {
                    handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
                }
                else this.cb.call(this.vm, value, oldValue);
            }
        }
    }, Watcher.prototype.evaluate = function() {
        this.value = this.get(), this.dirty = !1;
    }, Watcher.prototype.depend = function() {
        for(var i = this.deps.length; i--;)this.deps[i].depend();
    }, Watcher.prototype.teardown = function() {
        if (this.active) {
            this.vm._isBeingDestroyed || remove(this.vm._watchers, this);
            for(var i = this.deps.length; i--;)this.deps[i].removeSub(this);
            this.active = !1;
        }
    };
    var sharedPropertyDefinition = {
        enumerable: !0,
        configurable: !0,
        get: noop,
        set: noop
    };
    function proxy(target, sourceKey, key) {
        sharedPropertyDefinition.get = function() {
            return this[sourceKey][key];
        }, sharedPropertyDefinition.set = function(val) {
            this[sourceKey][key] = val;
        }, Object.defineProperty(target, key, sharedPropertyDefinition);
    }
    var computedWatcherOptions = {
        lazy: !0
    };
    function defineComputed(target, key, userDef) {
        var shouldCache = !isServerRendering();
        'function' == typeof userDef ? (sharedPropertyDefinition.get = shouldCache ? createComputedGetter(key) : createGetterInvoker(userDef), sharedPropertyDefinition.set = noop) : (sharedPropertyDefinition.get = userDef.get ? shouldCache && !1 !== userDef.cache ? createComputedGetter(key) : createGetterInvoker(userDef.get) : noop, sharedPropertyDefinition.set = userDef.set || noop), sharedPropertyDefinition.set === noop && (sharedPropertyDefinition.set = function() {
            warn("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
        }), Object.defineProperty(target, key, sharedPropertyDefinition);
    }
    function createComputedGetter(key) {
        return function() {
            var watcher = this._computedWatchers && this._computedWatchers[key];
            if (watcher) return watcher.dirty && watcher.evaluate(), Dep.target && watcher.depend(), watcher.value;
        };
    }
    function createGetterInvoker(fn) {
        return function() {
            return fn.call(this, this);
        };
    }
    function createWatcher(vm, expOrFn, handler, options) {
        return isPlainObject(handler) && (options = handler, handler = handler.handler), 'string' == typeof handler && (handler = vm[handler]), vm.$watch(expOrFn, handler, options);
    }
    var uid$3 = 0;
    function resolveConstructorOptions(Ctor) {
        var options = Ctor.options;
        if (Ctor.super) {
            var superOptions = resolveConstructorOptions(Ctor.super), cachedSuperOptions = Ctor.superOptions;
            if (superOptions !== cachedSuperOptions) {
                Ctor.superOptions = superOptions;
                var modifiedOptions = function(Ctor) {
                    var modified, latest = Ctor.options, sealed = Ctor.sealedOptions;
                    for(var key in latest)latest[key] !== sealed[key] && (modified || (modified = {}), modified[key] = latest[key]);
                    return modified;
                }(Ctor);
                modifiedOptions && extend(Ctor.extendOptions, modifiedOptions), (options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions)).name && (options.components[options.name] = Ctor);
            }
        }
        return options;
    }
    function Vue7(options) {
        this instanceof Vue7 || warn('Vue is a constructor and should be called with the `new` keyword'), this._init(options);
    }
    function getComponentName(opts) {
        return opts && (opts.Ctor.options.name || opts.tag);
    }
    function matches(pattern, name) {
        return Array.isArray(pattern) ? pattern.indexOf(name) > -1 : 'string' == typeof pattern ? pattern.split(',').indexOf(name) > -1 : !!isRegExp(pattern) && pattern.test(name);
    }
    function pruneCache(keepAliveInstance, filter) {
        var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
        for(var key in cache){
            var cachedNode = cache[key];
            if (cachedNode) {
                var name = getComponentName(cachedNode.componentOptions);
                name && !filter(name) && pruneCacheEntry(cache, key, keys, _vnode);
            }
        }
    }
    function pruneCacheEntry(cache, key, keys, current) {
        var cached$$1 = cache[key];
        cached$$1 && (!current || cached$$1.tag !== current.tag) && cached$$1.componentInstance.$destroy(), cache[key] = null, remove(keys, key);
    }
    Vue7.prototype._init = function(options) {
        var vm, opts, parentVnode, vnodeComponentOptions, result, vm1, listeners, vm2, options1, parentVnode1, renderContext, parentData, vm3, opts1, vm4, provide, startTag, endTag, vm5 = this;
        vm5._uid = uid$3++, config.performance && mark && (startTag = "vue-perf-start:" + vm5._uid, endTag = "vue-perf-end:" + vm5._uid, mark(startTag)), vm5._isVue = !0, options && options._isComponent ? (opts = (vm = vm5).$options = Object.create(vm.constructor.options), parentVnode = options._parentVnode, opts.parent = options.parent, opts._parentVnode = parentVnode, vnodeComponentOptions = parentVnode.componentOptions, opts.propsData = vnodeComponentOptions.propsData, opts._parentListeners = vnodeComponentOptions.listeners, opts._renderChildren = vnodeComponentOptions.children, opts._componentTag = vnodeComponentOptions.tag, options.render && (opts.render = options.render, opts.staticRenderFns = options.staticRenderFns)) : vm5.$options = mergeOptions(resolveConstructorOptions(vm5.constructor), options || {}, vm5), initProxy(vm5), vm5._self = vm5, function(vm) {
            var options = vm.$options, parent = options.parent;
            if (parent && !options.abstract) {
                for(; parent.$options.abstract && parent.$parent;)parent = parent.$parent;
                parent.$children.push(vm);
            }
            vm.$parent = parent, vm.$root = parent ? parent.$root : vm, vm.$children = [], vm.$refs = {}, vm._watcher = null, vm._inactive = null, vm._directInactive = !1, vm._isMounted = !1, vm._isDestroyed = !1, vm._isBeingDestroyed = !1;
        }(vm5), (vm1 = vm5)._events = Object.create(null), vm1._hasHookEvent = !1, (listeners = vm1.$options._parentListeners) && updateComponentListeners(vm1, listeners), (vm2 = vm5)._vnode = null, vm2._staticTrees = null, options1 = vm2.$options, renderContext = (parentVnode1 = vm2.$vnode = options1._parentVnode) && parentVnode1.context, vm2.$slots = resolveSlots(options1._renderChildren, renderContext), vm2.$scopedSlots = emptyObject, vm2._c = function(a, b, c, d) {
            return createElement(vm2, a, b, c, d, !1);
        }, vm2.$createElement = function(a, b, c, d) {
            return createElement(vm2, a, b, c, d, !0);
        }, defineReactive$$1(vm2, '$attrs', (parentData = parentVnode1 && parentVnode1.data) && parentData.attrs || emptyObject, function() {
            isUpdatingChildComponent || warn("$attrs is readonly.", vm2);
        }, !0), defineReactive$$1(vm2, '$listeners', options1._parentListeners || emptyObject, function() {
            isUpdatingChildComponent || warn("$listeners is readonly.", vm2);
        }, !0), callHook(vm5, 'beforeCreate'), (result = resolveInject(vm5.$options.inject, vm5)) && (shouldObserve = !1, Object.keys(result).forEach(function(key) {
            defineReactive$$1(vm5, key, result[key], function() {
                warn('Avoid mutating an injected value directly since the changes will be overwritten whenever the provided component re-renders. injection being mutated: "' + key + "\"", vm5);
            });
        }), shouldObserve = !0), (vm3 = vm5)._watchers = [], (opts1 = vm3.$options).props && function(vm, propsOptions) {
            var propsData = vm.$options.propsData || {}, props = vm._props = {}, keys = vm.$options._propKeys = [], isRoot = !vm.$parent;
            isRoot || (shouldObserve = !1);
            var loop = function(key) {
                keys.push(key);
                var value = validateProp(key, propsOptions, propsData, vm), hyphenatedKey = hyphenate(key);
                (isReservedAttribute(hyphenatedKey) || config.isReservedAttr(hyphenatedKey)) && warn("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm), defineReactive$$1(props, key, value, function() {
                    isRoot || isUpdatingChildComponent || warn("Avoid mutating a prop directly since the value will be overwritten whenever the parent component re-renders. Instead, use a data or computed property based on the prop's value. Prop being mutated: \"" + key + "\"", vm);
                }), key in vm || proxy(vm, "_props", key);
            };
            for(var key in propsOptions)loop(key);
            shouldObserve = !0;
        }(vm3, opts1.props), opts1.methods && function(vm, methods) {
            var props = vm.$options.props;
            for(var key in methods)'function' != typeof methods[key] && warn("Method \"" + key + "\" has type \"" + typeof methods[key] + '" in the component definition. Did you reference the function correctly?', vm), props && hasOwn(props, key) && warn("Method \"" + key + "\" has already been defined as a prop.", vm), key in vm && isReserved(key) && warn("Method \"" + key + '" conflicts with an existing Vue instance method. Avoid defining component methods that start with _ or $.'), vm[key] = 'function' != typeof methods[key] ? noop : bind(methods[key], vm);
        }(vm3, opts1.methods), opts1.data ? function(vm) {
            var data = vm.$options.data;
            isPlainObject(data = vm._data = 'function' == typeof data ? function(data, vm) {
                pushTarget();
                try {
                    return data.call(vm, vm);
                } catch (e) {
                    return handleError(e, vm, "data()"), {};
                } finally{
                    popTarget();
                }
            }(data, vm) : data || {}) || (data = {}, warn("data functions should return an object:\nhttps://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm));
            for(var keys = Object.keys(data), props = vm.$options.props, methods = vm.$options.methods, i = keys.length; i--;){
                var key = keys[i];
                methods && hasOwn(methods, key) && warn("Method \"" + key + "\" has already been defined as a data property.", vm), props && hasOwn(props, key) ? warn("The data property \"" + key + '" is already declared as a prop. Use prop default value instead.', vm) : isReserved(key) || proxy(vm, "_data", key);
            }
            observe(data, !0);
        }(vm3) : observe(vm3._data = {}, !0), opts1.computed && function(vm, computed) {
            var watchers = vm._computedWatchers = Object.create(null), isSSR = isServerRendering();
            for(var key in computed){
                var userDef = computed[key], getter = 'function' == typeof userDef ? userDef : userDef.get;
                null == getter && warn("Getter is missing for computed property \"" + key + "\".", vm), isSSR || (watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions)), key in vm ? key in vm.$data ? warn("The computed property \"" + key + "\" is already defined in data.", vm) : vm.$options.props && key in vm.$options.props && warn("The computed property \"" + key + "\" is already defined as a prop.", vm) : defineComputed(vm, key, userDef);
            }
        }(vm3, opts1.computed), opts1.watch && opts1.watch !== nativeWatch && function(vm, watch) {
            for(var key in watch){
                var handler = watch[key];
                if (Array.isArray(handler)) for(var i = 0; i < handler.length; i++)createWatcher(vm, key, handler[i]);
                else createWatcher(vm, key, handler);
            }
        }(vm3, opts1.watch), (provide = (vm4 = vm5).$options.provide) && (vm4._provided = 'function' == typeof provide ? provide.call(vm4) : provide), callHook(vm5, 'created'), config.performance && mark && (vm5._name = formatComponentName(vm5, !1), mark(endTag), measure("vue " + vm5._name + " init", startTag, endTag)), vm5.$options.el && vm5.$mount(vm5.$options.el);
    }, Vue3 = Vue7, (dataDef = {}).get = function() {
        return this._data;
    }, (propsDef = {}).get = function() {
        return this._props;
    }, dataDef.set = function() {
        warn("Avoid replacing instance root $data. Use nested data properties instead.", this);
    }, propsDef.set = function() {
        warn("$props is readonly.", this);
    }, Object.defineProperty(Vue3.prototype, '$data', dataDef), Object.defineProperty(Vue3.prototype, '$props', propsDef), Vue3.prototype.$set = set, Vue3.prototype.$delete = del, Vue3.prototype.$watch = function(expOrFn, cb, options) {
        if (isPlainObject(cb)) return createWatcher(this, expOrFn, cb, options);
        (options = options || {}).user = !0;
        var watcher = new Watcher(this, expOrFn, cb, options);
        if (options.immediate) try {
            cb.call(this, watcher.value);
        } catch (error) {
            handleError(error, this, "callback for immediate watcher \"" + watcher.expression + "\"");
        }
        return function() {
            watcher.teardown();
        };
    }, hookRE = /^hook:/, (Vue4 = Vue7).prototype.$on = function(event, fn) {
        var vm = this;
        if (Array.isArray(event)) for(var i = 0, l = event.length; i < l; i++)vm.$on(event[i], fn);
        else (vm._events[event] || (vm._events[event] = [])).push(fn), hookRE.test(event) && (vm._hasHookEvent = !0);
        return vm;
    }, Vue4.prototype.$once = function(event, fn) {
        var vm = this;
        function on() {
            vm.$off(event, on), fn.apply(vm, arguments);
        }
        return on.fn = fn, vm.$on(event, on), vm;
    }, Vue4.prototype.$off = function(event, fn) {
        var cb, vm = this;
        if (!arguments.length) return vm._events = Object.create(null), vm;
        if (Array.isArray(event)) {
            for(var i$1 = 0, l = event.length; i$1 < l; i$1++)vm.$off(event[i$1], fn);
            return vm;
        }
        var cbs = vm._events[event];
        if (!cbs) return vm;
        if (!fn) return vm._events[event] = null, vm;
        for(var i = cbs.length; i--;)if ((cb = cbs[i]) === fn || cb.fn === fn) {
            cbs.splice(i, 1);
            break;
        }
        return vm;
    }, Vue4.prototype.$emit = function(event) {
        var lowerCaseEvent = event.toLowerCase();
        lowerCaseEvent !== event && this._events[lowerCaseEvent] && tip("Event \"" + lowerCaseEvent + "\" is emitted in component " + formatComponentName(this) + " but the handler is registered for \"" + event + '". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "' + hyphenate(event) + "\" instead of \"" + event + "\".");
        var cbs = this._events[event];
        if (cbs) {
            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
            for(var args = toArray(arguments, 1), info = "event handler for \"" + event + "\"", i = 0, l = cbs.length; i < l; i++)invokeWithErrorHandling(cbs[i], this, args, this, info);
        }
        return this;
    }, (Vue5 = Vue7).prototype._update = function(vnode, hydrating) {
        var vm = this, prevEl = vm.$el, prevVnode = vm._vnode, restoreActiveInstance = setActiveInstance(vm);
        vm._vnode = vnode, prevVnode ? vm.$el = vm.__patch__(prevVnode, vnode) : vm.$el = vm.__patch__(vm.$el, vnode, hydrating, !1), restoreActiveInstance(), prevEl && (prevEl.__vue__ = null), vm.$el && (vm.$el.__vue__ = vm), vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode && (vm.$parent.$el = vm.$el);
    }, Vue5.prototype.$forceUpdate = function() {
        this._watcher && this._watcher.update();
    }, Vue5.prototype.$destroy = function() {
        var vm = this;
        if (!vm._isBeingDestroyed) {
            callHook(vm, 'beforeDestroy'), vm._isBeingDestroyed = !0;
            var parent = vm.$parent;
            !parent || parent._isBeingDestroyed || vm.$options.abstract || remove(parent.$children, vm), vm._watcher && vm._watcher.teardown();
            for(var i = vm._watchers.length; i--;)vm._watchers[i].teardown();
            vm._data.__ob__ && vm._data.__ob__.vmCount--, vm._isDestroyed = !0, vm.__patch__(vm._vnode, null), callHook(vm, 'destroyed'), vm.$off(), vm.$el && (vm.$el.__vue__ = null), vm.$vnode && (vm.$vnode.parent = null);
        }
    }, installRenderHelpers((Vue6 = Vue7).prototype), Vue6.prototype.$nextTick = function(fn) {
        return nextTick(fn, this);
    }, Vue6.prototype._render = function() {
        var vnode, vm = this, ref = vm.$options, render = ref.render, _parentVnode = ref._parentVnode;
        _parentVnode && (vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots)), vm.$vnode = _parentVnode;
        try {
            currentRenderingInstance = vm, vnode = render.call(vm._renderProxy, vm.$createElement);
        } catch (e1) {
            if (handleError(e1, vm, "render"), vm.$options.renderError) try {
                vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e1);
            } catch (e) {
                handleError(e, vm, "renderError"), vnode = vm._vnode;
            }
            else vnode = vm._vnode;
        } finally{
            currentRenderingInstance = null;
        }
        return Array.isArray(vnode) && 1 === vnode.length && (vnode = vnode[0]), vnode instanceof VNode || (Array.isArray(vnode) && warn("Multiple root nodes returned from render function. Render function should return a single root node.", vm), vnode = createEmptyVNode()), vnode.parent = _parentVnode, vnode;
    };
    var patternTypes = [
        String,
        RegExp,
        Array
    ];
    Vue = Vue7, (configDef = {}).get = function() {
        return config;
    }, configDef.set = function() {
        warn('Do not replace the Vue.config object, set individual fields instead.');
    }, Object.defineProperty(Vue, 'config', configDef), Vue.util = {
        warn: warn,
        extend: extend,
        mergeOptions: mergeOptions,
        defineReactive: defineReactive$$1
    }, Vue.set = set, Vue.delete = del, Vue.nextTick = nextTick, Vue.observable = function(obj) {
        return observe(obj), obj;
    }, Vue.options = Object.create(null), ASSET_TYPES.forEach(function(type) {
        Vue.options[type + 's'] = Object.create(null);
    }), Vue.options._base = Vue, extend(Vue.options.components, {
        KeepAlive: {
            name: 'keep-alive',
            abstract: !0,
            props: {
                include: patternTypes,
                exclude: patternTypes,
                max: [
                    String,
                    Number
                ]
            },
            created: function() {
                this.cache = Object.create(null), this.keys = [];
            },
            destroyed: function() {
                for(var key in this.cache)pruneCacheEntry(this.cache, key, this.keys);
            },
            mounted: function() {
                var this$1 = this;
                this.$watch('include', function(val) {
                    pruneCache(this$1, function(name) {
                        return matches(val, name);
                    });
                }), this.$watch('exclude', function(val) {
                    pruneCache(this$1, function(name) {
                        return !matches(val, name);
                    });
                });
            },
            render: function() {
                var slot = this.$slots.default, vnode = getFirstComponentChild(slot), componentOptions = vnode && vnode.componentOptions;
                if (componentOptions) {
                    var name = getComponentName(componentOptions), include = this.include, exclude = this.exclude;
                    if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) return vnode;
                    var cache = this.cache, keys = this.keys, key = null == vnode.key ? componentOptions.Ctor.cid + (componentOptions.tag ? "::" + componentOptions.tag : '') : vnode.key;
                    cache[key] ? (vnode.componentInstance = cache[key].componentInstance, remove(keys, key), keys.push(key)) : (cache[key] = vnode, keys.push(key), this.max && keys.length > parseInt(this.max) && pruneCacheEntry(cache, keys[0], keys, this._vnode)), vnode.data.keepAlive = !0;
                }
                return vnode || slot && slot[0];
            }
        }
    }), Vue.use = function(plugin) {
        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
        if (installedPlugins.indexOf(plugin) > -1) return this;
        var args = toArray(arguments, 1);
        return args.unshift(this), 'function' == typeof plugin.install ? plugin.install.apply(plugin, args) : 'function' == typeof plugin && plugin.apply(null, args), installedPlugins.push(plugin), this;
    }, Vue.mixin = function(mixin) {
        return this.options = mergeOptions(this.options, mixin), this;
    }, (Vue1 = Vue).cid = 0, cid = 1, Vue1.extend = function(extendOptions) {
        extendOptions = extendOptions || {};
        var Super = this, SuperId = Super.cid, cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
        if (cachedCtors[SuperId]) return cachedCtors[SuperId];
        var name = extendOptions.name || Super.options.name;
        name && validateComponentName(name);
        var Sub = function(options) {
            this._init(options);
        };
        return Sub.prototype = Object.create(Super.prototype), Sub.prototype.constructor = Sub, Sub.cid = cid++, Sub.options = mergeOptions(Super.options, extendOptions), Sub.super = Super, Sub.options.props && function(Comp) {
            var props = Comp.options.props;
            for(var key in props)proxy(Comp.prototype, "_props", key);
        }(Sub), Sub.options.computed && function(Comp) {
            var computed = Comp.options.computed;
            for(var key in computed)defineComputed(Comp.prototype, key, computed[key]);
        }(Sub), Sub.extend = Super.extend, Sub.mixin = Super.mixin, Sub.use = Super.use, ASSET_TYPES.forEach(function(type) {
            Sub[type] = Super[type];
        }), name && (Sub.options.components[name] = Sub), Sub.superOptions = Super.options, Sub.extendOptions = extendOptions, Sub.sealedOptions = extend({}, Sub.options), cachedCtors[SuperId] = Sub, Sub;
    }, Vue2 = Vue, ASSET_TYPES.forEach(function(type) {
        Vue2[type] = function(id, definition) {
            return definition ? ('component' === type && validateComponentName(id), 'component' === type && isPlainObject(definition) && (definition.name = definition.name || id, definition = this.options._base.extend(definition)), 'directive' === type && 'function' == typeof definition && (definition = {
                bind: definition,
                update: definition
            }), this.options[type + 's'][id] = definition, definition) : this.options[type + 's'][id];
        };
    }), Object.defineProperty(Vue7.prototype, '$isServer', {
        get: isServerRendering
    }), Object.defineProperty(Vue7.prototype, '$ssrContext', {
        get: function() {
            return this.$vnode && this.$vnode.ssrContext;
        }
    }), Object.defineProperty(Vue7, 'FunctionalRenderContext', {
        value: FunctionalRenderContext
    }), Vue7.version = '2.6.12';
    var isReservedAttr = makeMap('style,class'), acceptValue = makeMap('input,textarea,option,select,progress'), mustUseProp = function(tag, type, attr) {
        return 'value' === attr && acceptValue(tag) && 'button' !== type || 'selected' === attr && 'option' === tag || 'checked' === attr && 'input' === tag || 'muted' === attr && 'video' === tag;
    }, isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck'), isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only'), isBooleanAttr = makeMap("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,translate,truespeed,typemustmatch,visible"), xlinkNS = 'http://www.w3.org/1999/xlink', isXlink = function(name) {
        return ':' === name.charAt(5) && 'xlink' === name.slice(0, 5);
    }, getXlinkProp = function(name) {
        return isXlink(name) ? name.slice(6, name.length) : '';
    }, isFalsyAttrValue = function(val) {
        return null == val || !1 === val;
    };
    function mergeClassData(child, parent) {
        return {
            staticClass: concat(child.staticClass, parent.staticClass),
            class: isDef(child.class) ? [
                child.class,
                parent.class
            ] : parent.class
        };
    }
    function concat(a, b) {
        return a ? b ? a + ' ' + b : a : b || '';
    }
    function stringifyClass(value) {
        return Array.isArray(value) ? function(value) {
            for(var stringified, res = '', i = 0, l = value.length; i < l; i++)isDef(stringified = stringifyClass(value[i])) && '' !== stringified && (res && (res += ' '), res += stringified);
            return res;
        }(value) : isObject(value) ? function(value) {
            var res = '';
            for(var key in value)value[key] && (res && (res += ' '), res += key);
            return res;
        }(value) : 'string' == typeof value ? value : '';
    }
    var namespaceMap = {
        svg: 'http://www.w3.org/2000/svg',
        math: 'http://www.w3.org/1998/Math/MathML'
    }, isHTMLTag = makeMap("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"), isSVG = makeMap("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view", !0), isReservedTag = function(tag) {
        return isHTMLTag(tag) || isSVG(tag);
    };
    function getTagNamespace(tag) {
        return isSVG(tag) ? 'svg' : 'math' === tag ? 'math' : void 0;
    }
    var unknownElementCache = Object.create(null), isTextInputType = makeMap('text,number,password,search,email,tel,url');
    function query(el) {
        return 'string' != typeof el ? el : document.querySelector(el) || (warn('Cannot find element: ' + el), document.createElement('div'));
    }
    var nodeOps = Object.freeze({
        createElement: function(tagName, vnode) {
            var elm = document.createElement(tagName);
            return 'select' !== tagName || vnode.data && vnode.data.attrs && void 0 !== vnode.data.attrs.multiple && elm.setAttribute('multiple', 'multiple'), elm;
        },
        createElementNS: function(namespace, tagName) {
            return document.createElementNS(namespaceMap[namespace], tagName);
        },
        createTextNode: function(text) {
            return document.createTextNode(text);
        },
        createComment: function(text) {
            return document.createComment(text);
        },
        insertBefore: function(parentNode, newNode, referenceNode) {
            parentNode.insertBefore(newNode, referenceNode);
        },
        removeChild: function(node, child) {
            node.removeChild(child);
        },
        appendChild: function(node, child) {
            node.appendChild(child);
        },
        parentNode: function(node) {
            return node.parentNode;
        },
        nextSibling: function(node) {
            return node.nextSibling;
        },
        tagName: function(node) {
            return node.tagName;
        },
        setTextContent: function(node, text) {
            node.textContent = text;
        },
        setStyleScope: function(node, scopeId) {
            node.setAttribute(scopeId, '');
        }
    });
    function registerRef(vnode, isRemoval) {
        var key = vnode.data.ref;
        if (isDef(key)) {
            var vm = vnode.context, ref = vnode.componentInstance || vnode.elm, refs = vm.$refs;
            isRemoval ? Array.isArray(refs[key]) ? remove(refs[key], ref) : refs[key] === ref && (refs[key] = void 0) : vnode.data.refInFor ? Array.isArray(refs[key]) ? 0 > refs[key].indexOf(ref) && refs[key].push(ref) : refs[key] = [
                ref
            ] : refs[key] = ref;
        }
    }
    var emptyNode = new VNode('', {}, []), hooks = [
        'create',
        'activate',
        'update',
        'remove',
        'destroy'
    ];
    function sameVnode(a, b) {
        return a.key === b.key && (a.tag === b.tag && a.isComment === b.isComment && isDef(a.data) === isDef(b.data) && function(a, b) {
            if ('input' !== a.tag) return !0;
            var i, typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type, typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
            return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB);
        }(a, b) || isTrue(a.isAsyncPlaceholder) && a.asyncFactory === b.asyncFactory && isUndef(b.asyncFactory.error));
    }
    function updateDirectives(oldVnode, vnode) {
        (oldVnode.data.directives || vnode.data.directives) && function(oldVnode, vnode) {
            var key, oldDir, dir, isCreate = oldVnode === emptyNode, isDestroy = vnode === emptyNode, oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context), newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context), dirsWithInsert = [], dirsWithPostpatch = [];
            for(key in newDirs)oldDir = oldDirs[key], dir = newDirs[key], oldDir ? (dir.oldValue = oldDir.value, dir.oldArg = oldDir.arg, callHook$1(dir, 'update', vnode, oldVnode), dir.def && dir.def.componentUpdated && dirsWithPostpatch.push(dir)) : (callHook$1(dir, 'bind', vnode, oldVnode), dir.def && dir.def.inserted && dirsWithInsert.push(dir));
            if (dirsWithInsert.length) {
                var callInsert = function() {
                    for(var i = 0; i < dirsWithInsert.length; i++)callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
                };
                isCreate ? mergeVNodeHook(vnode, 'insert', callInsert) : callInsert();
            }
            if (dirsWithPostpatch.length && mergeVNodeHook(vnode, 'postpatch', function() {
                for(var i = 0; i < dirsWithPostpatch.length; i++)callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
            }), !isCreate) for(key in oldDirs)newDirs[key] || callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
        }(oldVnode, vnode);
    }
    var emptyModifiers = Object.create(null);
    function normalizeDirectives$1(dirs, vm) {
        var dir, i, dir1, res = Object.create(null);
        if (!dirs) return res;
        for(i = 0; i < dirs.length; i++)(dir1 = dirs[i]).modifiers || (dir1.modifiers = emptyModifiers), res[(dir = dir1).rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.')] = dir1, dir1.def = resolveAsset(vm.$options, 'directives', dir1.name, !0);
        return res;
    }
    function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
        var fn = dir.def && dir.def[hook];
        if (fn) try {
            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
        } catch (e) {
            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
        }
    }
    function updateAttrs(oldVnode, vnode) {
        var key, cur, opts = vnode.componentOptions;
        if (!(isDef(opts) && !1 === opts.Ctor.options.inheritAttrs || isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs))) {
            var elm = vnode.elm, oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};
            for(key in isDef(attrs.__ob__) && (attrs = vnode.data.attrs = extend({}, attrs)), attrs)cur = attrs[key], oldAttrs[key] !== cur && setAttr(elm, key, cur);
            for(key in (isIE || isEdge) && attrs.value !== oldAttrs.value && setAttr(elm, 'value', attrs.value), oldAttrs)isUndef(attrs[key]) && (isXlink(key) ? elm.removeAttributeNS(xlinkNS, getXlinkProp(key)) : isEnumeratedAttr(key) || elm.removeAttribute(key));
        }
    }
    function setAttr(el, key, value) {
        if (el.tagName.indexOf('-') > -1) baseSetAttr(el, key, value);
        else if (isBooleanAttr(key)) isFalsyAttrValue(value) ? el.removeAttribute(key) : (value = 'allowfullscreen' === key && 'EMBED' === el.tagName ? 'true' : key, el.setAttribute(key, value));
        else if (isEnumeratedAttr(key)) {
            var value1;
            el.setAttribute(key, isFalsyAttrValue(value1 = value) || 'false' === value1 ? 'false' : 'contenteditable' === key && isValidContentEditableValue(value1) ? value1 : 'true');
        } else isXlink(key) ? isFalsyAttrValue(value) ? el.removeAttributeNS(xlinkNS, getXlinkProp(key)) : el.setAttributeNS(xlinkNS, key, value) : baseSetAttr(el, key, value);
    }
    function baseSetAttr(el, key, value) {
        if (isFalsyAttrValue(value)) el.removeAttribute(key);
        else {
            if (isIE && !isIE9 && 'TEXTAREA' === el.tagName && 'placeholder' === key && '' !== value && !el.__ieph) {
                var blocker = function(e) {
                    e.stopImmediatePropagation(), el.removeEventListener('input', blocker);
                };
                el.addEventListener('input', blocker), el.__ieph = !0;
            }
            el.setAttribute(key, value);
        }
    }
    function updateClass(oldVnode, vnode) {
        var el = vnode.elm, data = vnode.data, oldData = oldVnode.data;
        if (!(isUndef(data.staticClass) && isUndef(data.class) && (isUndef(oldData) || isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
            var cls = function(vnode) {
                for(var staticClass, dynamicClass, data = vnode.data, parentNode = vnode, childNode = vnode; isDef(childNode.componentInstance);)(childNode = childNode.componentInstance._vnode) && childNode.data && (data = mergeClassData(childNode.data, data));
                for(; isDef(parentNode = parentNode.parent);)parentNode && parentNode.data && (data = mergeClassData(data, parentNode.data));
                return staticClass = data.staticClass, dynamicClass = data.class, isDef(staticClass) || isDef(dynamicClass) ? concat(staticClass, stringifyClass(dynamicClass)) : '';
            }(vnode), transitionClass = el._transitionClasses;
            isDef(transitionClass) && (cls = concat(cls, stringifyClass(transitionClass))), cls !== el._prevClass && (el.setAttribute('class', cls), el._prevClass = cls);
        }
    }
    var validDivisionCharRE = /[\w).+\-_$\]]/;
    function parseFilters(exp) {
        var c, prev, i, expression, filters, inSingle = !1, inDouble = !1, inTemplateString = !1, inRegex = !1, curly = 0, square = 0, paren = 0, lastFilterIndex = 0;
        for(i = 0; i < exp.length; i++)if (prev = c, c = exp.charCodeAt(i), inSingle) 0x27 === c && 0x5C !== prev && (inSingle = !1);
        else if (inDouble) 0x22 === c && 0x5C !== prev && (inDouble = !1);
        else if (inTemplateString) 0x60 === c && 0x5C !== prev && (inTemplateString = !1);
        else if (inRegex) 0x2f === c && 0x5C !== prev && (inRegex = !1);
        else if (0x7C !== c || 0x7C === exp.charCodeAt(i + 1) || 0x7C === exp.charCodeAt(i - 1) || curly || square || paren) {
            switch(c){
                case 0x22:
                    inDouble = !0;
                    break;
                case 0x27:
                    inSingle = !0;
                    break;
                case 0x60:
                    inTemplateString = !0;
                    break;
                case 0x28:
                    paren++;
                    break;
                case 0x29:
                    paren--;
                    break;
                case 0x5B:
                    square++;
                    break;
                case 0x5D:
                    square--;
                    break;
                case 0x7B:
                    curly++;
                    break;
                case 0x7D:
                    curly--;
            }
            if (0x2f === c) {
                for(var j = i - 1, p = void 0; j >= 0 && ' ' === (p = exp.charAt(j)); j--);
                p && validDivisionCharRE.test(p) || (inRegex = !0);
            }
        } else void 0 === expression ? (lastFilterIndex = i + 1, expression = exp.slice(0, i).trim()) : pushFilter();
        function pushFilter() {
            (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim()), lastFilterIndex = i + 1;
        }
        if (void 0 === expression ? expression = exp.slice(0, i).trim() : 0 !== lastFilterIndex && pushFilter(), filters) for(i = 0; i < filters.length; i++)expression = function(exp, filter) {
            var i = filter.indexOf('(');
            if (i < 0) return "_f(\"" + filter + "\")(" + exp + ")";
            var name = filter.slice(0, i), args = filter.slice(i + 1);
            return "_f(\"" + name + "\")(" + exp + (')' !== args ? ',' + args : args);
        }(expression, filters[i]);
        return expression;
    }
    function baseWarn(msg, range) {
        console.error("[Vue compiler]: " + msg);
    }
    function pluckModuleFunction(modules, key) {
        return modules ? modules.map(function(m) {
            return m[key];
        }).filter(function(_) {
            return _;
        }) : [];
    }
    function addProp(el, name, value, range, dynamic) {
        (el.props || (el.props = [])).push(rangeSetItem({
            name: name,
            value: value,
            dynamic: dynamic
        }, range)), el.plain = !1;
    }
    function addAttr(el, name, value, range, dynamic) {
        (dynamic ? el.dynamicAttrs || (el.dynamicAttrs = []) : el.attrs || (el.attrs = [])).push(rangeSetItem({
            name: name,
            value: value,
            dynamic: dynamic
        }, range)), el.plain = !1;
    }
    function addRawAttr(el, name, value, range) {
        el.attrsMap[name] = value, el.attrsList.push(rangeSetItem({
            name: name,
            value: value
        }, range));
    }
    function prependModifierMarker(symbol, name, dynamic) {
        return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name;
    }
    function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
        modifiers = modifiers || emptyObject, warn && modifiers.prevent && modifiers.passive && warn("passive and prevent can't be used together. Passive handler can't prevent default event.", range), modifiers.right ? dynamic ? name = "(" + name + ")==='click'?'contextmenu':(" + name + ")" : 'click' === name && (name = 'contextmenu', delete modifiers.right) : modifiers.middle && (dynamic ? name = "(" + name + ")==='click'?'mouseup':(" + name + ")" : 'click' === name && (name = 'mouseup')), modifiers.capture && (delete modifiers.capture, name = prependModifierMarker('!', name, dynamic)), modifiers.once && (delete modifiers.once, name = prependModifierMarker('~', name, dynamic)), modifiers.passive && (delete modifiers.passive, name = prependModifierMarker('&', name, dynamic)), modifiers.native ? (delete modifiers.native, events = el.nativeEvents || (el.nativeEvents = {})) : events = el.events || (el.events = {});
        var events, newHandler = rangeSetItem({
            value: value.trim(),
            dynamic: dynamic
        }, range);
        modifiers !== emptyObject && (newHandler.modifiers = modifiers);
        var handlers = events[name];
        Array.isArray(handlers) ? important ? handlers.unshift(newHandler) : handlers.push(newHandler) : handlers ? events[name] = important ? [
            newHandler,
            handlers
        ] : [
            handlers,
            newHandler
        ] : events[name] = newHandler, el.plain = !1;
    }
    function getRawBindingAttr(el, name) {
        return el.rawAttrsMap[':' + name] || el.rawAttrsMap['v-bind:' + name] || el.rawAttrsMap[name];
    }
    function getBindingAttr(el, name, getStatic) {
        var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
        if (null != dynamicValue) return parseFilters(dynamicValue);
        if (!1 !== getStatic) {
            var staticValue = getAndRemoveAttr(el, name);
            if (null != staticValue) return JSON.stringify(staticValue);
        }
    }
    function getAndRemoveAttr(el, name, removeFromMap) {
        var val;
        if (null != (val = el.attrsMap[name])) {
            for(var list = el.attrsList, i = 0, l = list.length; i < l; i++)if (list[i].name === name) {
                list.splice(i, 1);
                break;
            }
        }
        return removeFromMap && delete el.attrsMap[name], val;
    }
    function getAndRemoveAttrByRegex(el, name) {
        for(var list = el.attrsList, i = 0, l = list.length; i < l; i++){
            var attr = list[i];
            if (name.test(attr.name)) return list.splice(i, 1), attr;
        }
    }
    function rangeSetItem(item, range) {
        return range && (null != range.start && (item.start = range.start), null != range.end && (item.end = range.end)), item;
    }
    function genComponentModel(el, value, modifiers) {
        var ref = modifiers || {}, number = ref.number, trim = ref.trim, valueExpression = '$$v';
        trim && (valueExpression = "(typeof $$v === 'string'? $$v.trim(): $$v)"), number && (valueExpression = "_n(" + valueExpression + ")");
        var assignment = genAssignmentCode(value, valueExpression);
        el.model = {
            value: "(" + value + ")",
            expression: JSON.stringify(value),
            callback: "function ($$v) {" + assignment + "}"
        };
    }
    function genAssignmentCode(value, assignment) {
        var res = function(val) {
            if (len = (val = val.trim()).length, 0 > val.indexOf('[') || val.lastIndexOf(']') < len - 1) return (index$1 = val.lastIndexOf('.')) > -1 ? {
                exp: val.slice(0, index$1),
                key: '"' + val.slice(index$1 + 1) + '"'
            } : {
                exp: val,
                key: null
            };
            for(str = val, index$1 = expressionPos = expressionEndPos = 0; !(index$1 >= len);)isStringStart(chr = next()) ? parseString(chr) : 0x5B === chr && function(chr) {
                var inBracket = 1;
                for(expressionPos = index$1; !(index$1 >= len);){
                    if (isStringStart(chr = next())) {
                        parseString(chr);
                        continue;
                    }
                    if (0x5B === chr && inBracket++, 0x5D === chr && inBracket--, 0 === inBracket) {
                        expressionEndPos = index$1;
                        break;
                    }
                }
            }(chr);
            return {
                exp: val.slice(0, expressionPos),
                key: val.slice(expressionPos + 1, expressionEndPos)
            };
        }(value);
        return null === res.key ? value + "=" + assignment : "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
    }
    function next() {
        return str.charCodeAt(++index$1);
    }
    function isStringStart(chr) {
        return 0x22 === chr || 0x27 === chr;
    }
    function parseString(chr) {
        for(var stringQuote = chr; !(index$1 >= len) && (chr = next()) !== stringQuote;);
    }
    function createOnceHandler$1(event, handler, capture) {
        var _target = target$1;
        return function onceHandler() {
            var res = handler.apply(null, arguments);
            null !== res && remove$2(event, onceHandler, capture, _target);
        };
    }
    var useMicrotaskFix = isUsingMicroTask && !(isFF && 53 >= Number(isFF[1]));
    function add$1(name, handler, capture, passive) {
        if (useMicrotaskFix) {
            var attachedTimestamp = currentFlushTimestamp, original = handler;
            handler = original._wrapper = function(e) {
                if (e.target === e.currentTarget || e.timeStamp >= attachedTimestamp || e.timeStamp <= 0 || e.target.ownerDocument !== document) return original.apply(this, arguments);
            };
        }
        target$1.addEventListener(name, handler, supportsPassive ? {
            capture: capture,
            passive: passive
        } : capture);
    }
    function remove$2(name, handler, capture, _target) {
        (_target || target$1).removeEventListener(name, handler._wrapper || handler, capture);
    }
    function updateDOMListeners(oldVnode, vnode) {
        if (!(isUndef(oldVnode.data.on) && isUndef(vnode.data.on))) {
            var on = vnode.data.on || {}, oldOn = oldVnode.data.on || {};
            target$1 = vnode.elm, function(on) {
                if (isDef(on.__r)) {
                    var event = isIE ? 'change' : 'input';
                    on[event] = [].concat(on.__r, on[event] || []), delete on.__r;
                }
                isDef(on.__c) && (on.change = [].concat(on.__c, on.change || []), delete on.__c);
            }(on), updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context), target$1 = void 0;
        }
    }
    function updateDOMProps(oldVnode, vnode) {
        if (!(isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps))) {
            var key, cur, elm = vnode.elm, oldProps = oldVnode.data.domProps || {}, props = vnode.data.domProps || {};
            for(key in isDef(props.__ob__) && (props = vnode.data.domProps = extend({}, props)), oldProps)key in props || (elm[key] = '');
            for(key in props){
                if (cur = props[key], 'textContent' === key || 'innerHTML' === key) {
                    if (vnode.children && (vnode.children.length = 0), cur === oldProps[key]) continue;
                    1 === elm.childNodes.length && elm.removeChild(elm.childNodes[0]);
                }
                if ('value' === key && 'PROGRESS' !== elm.tagName) {
                    elm._value = cur;
                    var strCur = isUndef(cur) ? '' : String(cur);
                    !elm.composing && ('OPTION' === elm.tagName || function(elm, checkVal) {
                        var notInFocus = !0;
                        try {
                            notInFocus = document.activeElement !== elm;
                        } catch (e) {}
                        return notInFocus && elm.value !== checkVal;
                    }(elm, strCur) || function(elm, newVal) {
                        var value = elm.value, modifiers = elm._vModifiers;
                        if (isDef(modifiers)) {
                            if (modifiers.number) return toNumber(value) !== toNumber(newVal);
                            if (modifiers.trim) return value.trim() !== newVal.trim();
                        }
                        return value !== newVal;
                    }(elm, strCur)) && (elm.value = strCur);
                } else if ('innerHTML' === key && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
                    (svgContainer = svgContainer || document.createElement('div')).innerHTML = "<svg>" + cur + "</svg>";
                    for(var svg = svgContainer.firstChild; elm.firstChild;)elm.removeChild(elm.firstChild);
                    for(; svg.firstChild;)elm.appendChild(svg.firstChild);
                } else if (cur !== oldProps[key]) try {
                    elm[key] = cur;
                } catch (e) {}
            }
        }
    }
    var parseStyleText = cached(function(cssText) {
        var res = {}, propertyDelimiter = /:(.+)/;
        return cssText.split(/;(?![^(]*\))/g).forEach(function(item) {
            if (item) {
                var tmp = item.split(propertyDelimiter);
                tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
            }
        }), res;
    });
    function normalizeStyleData(data) {
        var style = normalizeStyleBinding(data.style);
        return data.staticStyle ? extend(data.staticStyle, style) : style;
    }
    function normalizeStyleBinding(bindingStyle) {
        return Array.isArray(bindingStyle) ? toObject(bindingStyle) : 'string' == typeof bindingStyle ? parseStyleText(bindingStyle) : bindingStyle;
    }
    var cssVarRE = /^--/, importantRE = /\s*!important$/, setProp = function(el, name, val) {
        if (cssVarRE.test(name)) el.style.setProperty(name, val);
        else if (importantRE.test(val)) el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
        else {
            var normalizedName = normalize(name);
            if (Array.isArray(val)) for(var i = 0, len = val.length; i < len; i++)el.style[normalizedName] = val[i];
            else el.style[normalizedName] = val;
        }
    }, vendorNames = [
        'Webkit',
        'Moz',
        'ms'
    ], normalize = cached(function(prop) {
        if (emptyStyle = emptyStyle || document.createElement('div').style, 'filter' !== (prop = camelize(prop)) && prop in emptyStyle) return prop;
        for(var capName = prop.charAt(0).toUpperCase() + prop.slice(1), i = 0; i < vendorNames.length; i++){
            var name = vendorNames[i] + capName;
            if (name in emptyStyle) return name;
        }
    });
    function updateStyle(oldVnode, vnode) {
        var cur, name, data = vnode.data, oldData = oldVnode.data;
        if (!(isUndef(data.staticStyle) && isUndef(data.style) && isUndef(oldData.staticStyle) && isUndef(oldData.style))) {
            var el = vnode.elm, oldStaticStyle = oldData.staticStyle, oldStyleBinding = oldData.normalizedStyle || oldData.style || {}, oldStyle = oldStaticStyle || oldStyleBinding, style = normalizeStyleBinding(vnode.data.style) || {};
            vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
            var newStyle = function(vnode, checkChild) {
                var styleData, res = {};
                if (checkChild) for(var childNode = vnode; childNode.componentInstance;)(childNode = childNode.componentInstance._vnode) && childNode.data && (styleData = normalizeStyleData(childNode.data)) && extend(res, styleData);
                (styleData = normalizeStyleData(vnode.data)) && extend(res, styleData);
                for(var parentNode = vnode; parentNode = parentNode.parent;)parentNode.data && (styleData = normalizeStyleData(parentNode.data)) && extend(res, styleData);
                return res;
            }(vnode, !0);
            for(name in oldStyle)isUndef(newStyle[name]) && setProp(el, name, '');
            for(name in newStyle)(cur = newStyle[name]) !== oldStyle[name] && setProp(el, name, null == cur ? '' : cur);
        }
    }
    var whitespaceRE = /\s+/;
    function addClass(el, cls) {
        if (cls && (cls = cls.trim())) {
            if (el.classList) cls.indexOf(' ') > -1 ? cls.split(whitespaceRE).forEach(function(c) {
                return el.classList.add(c);
            }) : el.classList.add(cls);
            else {
                var cur = " " + (el.getAttribute('class') || '') + " ";
                0 > cur.indexOf(' ' + cls + ' ') && el.setAttribute('class', (cur + cls).trim());
            }
        }
    }
    function removeClass(el, cls) {
        if (cls && (cls = cls.trim())) {
            if (el.classList) cls.indexOf(' ') > -1 ? cls.split(whitespaceRE).forEach(function(c) {
                return el.classList.remove(c);
            }) : el.classList.remove(cls), el.classList.length || el.removeAttribute('class');
            else {
                for(var cur = " " + (el.getAttribute('class') || '') + " ", tar = ' ' + cls + ' '; cur.indexOf(tar) >= 0;)cur = cur.replace(tar, ' ');
                (cur = cur.trim()) ? el.setAttribute('class', cur) : el.removeAttribute('class');
            }
        }
    }
    function resolveTransition(def$$1) {
        if (def$$1) {
            if ('object' == typeof def$$1) {
                var res = {};
                return !1 !== def$$1.css && extend(res, autoCssTransition(def$$1.name || 'v')), extend(res, def$$1), res;
            }
            if ('string' == typeof def$$1) return autoCssTransition(def$$1);
        }
    }
    var autoCssTransition = cached(function(name) {
        return {
            enterClass: name + "-enter",
            enterToClass: name + "-enter-to",
            enterActiveClass: name + "-enter-active",
            leaveClass: name + "-leave",
            leaveToClass: name + "-leave-to",
            leaveActiveClass: name + "-leave-active"
        };
    }), hasTransition = inBrowser && !isIE9, TRANSITION = 'transition', ANIMATION = 'animation', transitionProp = 'transition', transitionEndEvent = 'transitionend', animationProp = 'animation', animationEndEvent = 'animationend';
    hasTransition && (void 0 === window.ontransitionend && void 0 !== window.onwebkittransitionend && (transitionProp = 'WebkitTransition', transitionEndEvent = 'webkitTransitionEnd'), void 0 === window.onanimationend && void 0 !== window.onwebkitanimationend && (animationProp = 'WebkitAnimation', animationEndEvent = 'webkitAnimationEnd'));
    var raf = inBrowser ? window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : setTimeout : function(fn) {
        return fn();
    };
    function nextFrame(fn) {
        raf(function() {
            raf(fn);
        });
    }
    function addTransitionClass(el, cls) {
        var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
        0 > transitionClasses.indexOf(cls) && (transitionClasses.push(cls), addClass(el, cls));
    }
    function removeTransitionClass(el, cls) {
        el._transitionClasses && remove(el._transitionClasses, cls), removeClass(el, cls);
    }
    function whenTransitionEnds(el, expectedType, cb) {
        var ref = getTransitionInfo(el, expectedType), type = ref.type, timeout = ref.timeout, propCount = ref.propCount;
        if (!type) return cb();
        var event = type === TRANSITION ? transitionEndEvent : animationEndEvent, ended = 0, end = function() {
            el.removeEventListener(event, onEnd), cb();
        }, onEnd = function(e) {
            e.target === el && ++ended >= propCount && end();
        };
        setTimeout(function() {
            ended < propCount && end();
        }, timeout + 1), el.addEventListener(event, onEnd);
    }
    var transformRE = /\b(transform|all)(,|$)/;
    function getTransitionInfo(el, expectedType) {
        var type, styles = window.getComputedStyle(el), transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', '), transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', '), transitionTimeout = getTimeout(transitionDelays, transitionDurations), animationDelays = (styles[animationProp + 'Delay'] || '').split(', '), animationDurations = (styles[animationProp + 'Duration'] || '').split(', '), animationTimeout = getTimeout(animationDelays, animationDurations), timeout = 0, propCount = 0;
        expectedType === TRANSITION ? transitionTimeout > 0 && (type = TRANSITION, timeout = transitionTimeout, propCount = transitionDurations.length) : expectedType === ANIMATION ? animationTimeout > 0 && (type = ANIMATION, timeout = animationTimeout, propCount = animationDurations.length) : propCount = (type = (timeout = Math.max(transitionTimeout, animationTimeout)) > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null) ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
        var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
        return {
            type: type,
            timeout: timeout,
            propCount: propCount,
            hasTransform: hasTransform
        };
    }
    function getTimeout(delays, durations) {
        for(; delays.length < durations.length;)delays = delays.concat(delays);
        return Math.max.apply(null, durations.map(function(d, i) {
            return toMs(d) + toMs(delays[i]);
        }));
    }
    function toMs(s) {
        return 1000 * Number(s.slice(0, -1).replace(',', '.'));
    }
    function enter(vnode, toggleDisplay) {
        var el = vnode.elm;
        isDef(el._leaveCb) && (el._leaveCb.cancelled = !0, el._leaveCb());
        var data = resolveTransition(vnode.data.transition);
        if (!(isUndef(data) || isDef(el._enterCb)) && 1 === el.nodeType) {
            for(var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration, context = activeInstance, transitionNode = activeInstance.$vnode; transitionNode && transitionNode.parent;)context = transitionNode.context, transitionNode = transitionNode.parent;
            var isAppear = !context._isMounted || !vnode.isRootInsert;
            if (!isAppear || appear || '' === appear) {
                var startClass = isAppear && appearClass ? appearClass : enterClass, activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass, toClass = isAppear && appearToClass ? appearToClass : enterToClass, beforeEnterHook = isAppear && beforeAppear || beforeEnter, enterHook = isAppear && 'function' == typeof appear ? appear : enter, afterEnterHook = isAppear && afterAppear || afterEnter, enterCancelledHook = isAppear && appearCancelled || enterCancelled, explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
                null != explicitEnterDuration && checkDuration(explicitEnterDuration, 'enter', vnode);
                var expectsCSS = !1 !== css && !isIE9, userWantsControl = getHookArgumentsLength(enterHook), cb = el._enterCb = once(function() {
                    expectsCSS && (removeTransitionClass(el, toClass), removeTransitionClass(el, activeClass)), cb.cancelled ? (expectsCSS && removeTransitionClass(el, startClass), enterCancelledHook && enterCancelledHook(el)) : afterEnterHook && afterEnterHook(el), el._enterCb = null;
                });
                vnode.data.show || mergeVNodeHook(vnode, 'insert', function() {
                    var parent = el.parentNode, pendingNode = parent && parent._pending && parent._pending[vnode.key];
                    pendingNode && pendingNode.tag === vnode.tag && pendingNode.elm._leaveCb && pendingNode.elm._leaveCb(), enterHook && enterHook(el, cb);
                }), beforeEnterHook && beforeEnterHook(el), expectsCSS && (addTransitionClass(el, startClass), addTransitionClass(el, activeClass), nextFrame(function() {
                    removeTransitionClass(el, startClass), cb.cancelled || (addTransitionClass(el, toClass), userWantsControl || (isValidDuration(explicitEnterDuration) ? setTimeout(cb, explicitEnterDuration) : whenTransitionEnds(el, type, cb)));
                })), vnode.data.show && (toggleDisplay && toggleDisplay(), enterHook && enterHook(el, cb)), expectsCSS || userWantsControl || cb();
            }
        }
    }
    function leave(vnode, rm) {
        var el = vnode.elm;
        isDef(el._enterCb) && (el._enterCb.cancelled = !0, el._enterCb());
        var data = resolveTransition(vnode.data.transition);
        if (isUndef(data) || 1 !== el.nodeType) return rm();
        if (!isDef(el._leaveCb)) {
            var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration, expectsCSS = !1 !== css && !isIE9, userWantsControl = getHookArgumentsLength(leave), explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
            isDef(explicitLeaveDuration) && checkDuration(explicitLeaveDuration, 'leave', vnode);
            var cb = el._leaveCb = once(function() {
                el.parentNode && el.parentNode._pending && (el.parentNode._pending[vnode.key] = null), expectsCSS && (removeTransitionClass(el, leaveToClass), removeTransitionClass(el, leaveActiveClass)), cb.cancelled ? (expectsCSS && removeTransitionClass(el, leaveClass), leaveCancelled && leaveCancelled(el)) : (rm(), afterLeave && afterLeave(el)), el._leaveCb = null;
            });
            delayLeave ? delayLeave(performLeave) : performLeave();
        }
        function performLeave() {
            !cb.cancelled && (!vnode.data.show && el.parentNode && ((el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode), beforeLeave && beforeLeave(el), expectsCSS && (addTransitionClass(el, leaveClass), addTransitionClass(el, leaveActiveClass), nextFrame(function() {
                removeTransitionClass(el, leaveClass), cb.cancelled || (addTransitionClass(el, leaveToClass), userWantsControl || (isValidDuration(explicitLeaveDuration) ? setTimeout(cb, explicitLeaveDuration) : whenTransitionEnds(el, type, cb)));
            })), leave && leave(el, cb), expectsCSS || userWantsControl || cb());
        }
    }
    function checkDuration(val, name, vnode) {
        'number' != typeof val ? warn("<transition> explicit " + name + " duration is not a valid number - got " + JSON.stringify(val) + ".", vnode.context) : isNaN(val) && warn("<transition> explicit " + name + " duration is NaN - the duration expression might be incorrect.", vnode.context);
    }
    function isValidDuration(val) {
        return 'number' == typeof val && !isNaN(val);
    }
    function getHookArgumentsLength(fn) {
        if (isUndef(fn)) return !1;
        var invokerFns = fn.fns;
        return isDef(invokerFns) ? getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns) : (fn._length || fn.length) > 1;
    }
    function _enter(_, vnode) {
        !0 !== vnode.data.show && enter(vnode);
    }
    var patch = function(backend) {
        var i, j, cbs = {}, modules = backend.modules, nodeOps = backend.nodeOps;
        for(i = 0; i < hooks.length; ++i)for(j = 0, cbs[hooks[i]] = []; j < modules.length; ++j)isDef(modules[j][hooks[i]]) && cbs[hooks[i]].push(modules[j][hooks[i]]);
        function removeNode(el) {
            var parent = nodeOps.parentNode(el);
            isDef(parent) && nodeOps.removeChild(parent, el);
        }
        function isUnknownElement$$1(vnode, inVPre) {
            return !inVPre && !vnode.ns && !(config.ignoredElements.length && config.ignoredElements.some(function(ignore) {
                return isRegExp(ignore) ? ignore.test(vnode.tag) : ignore === vnode.tag;
            })) && config.isUnknownElement(vnode.tag);
        }
        var creatingElmInVPre = 0;
        function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
            if (isDef(vnode.elm) && isDef(ownerArray) && (vnode = ownerArray[index] = cloneVNode(vnode)), vnode.isRootInsert = !nested, !function(vnode, insertedVnodeQueue, parentElm, refElm) {
                var i = vnode.data;
                if (isDef(i)) {
                    var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
                    if (isDef(i = i.hook) && isDef(i = i.init) && i(vnode, !1), isDef(vnode.componentInstance)) return initComponent(vnode, insertedVnodeQueue), insert(parentElm, vnode.elm, refElm), isTrue(isReactivated) && function(vnode, insertedVnodeQueue, parentElm, refElm) {
                        for(var i, innerNode = vnode; innerNode.componentInstance;)if (isDef(i = (innerNode = innerNode.componentInstance._vnode).data) && isDef(i = i.transition)) {
                            for(i = 0; i < cbs.activate.length; ++i)cbs.activate[i](emptyNode, innerNode);
                            insertedVnodeQueue.push(innerNode);
                            break;
                        }
                        insert(parentElm, vnode.elm, refElm);
                    }(vnode, insertedVnodeQueue, parentElm, refElm), !0;
                }
            }(vnode, insertedVnodeQueue, parentElm, refElm)) {
                var data = vnode.data, children = vnode.children, tag = vnode.tag;
                isDef(tag) ? (data && data.pre && creatingElmInVPre++, isUnknownElement$$1(vnode, creatingElmInVPre) && warn('Unknown custom element: <' + tag + '> - did you register the component correctly? For recursive components, make sure to provide the "name" option.', vnode.context), vnode.elm = vnode.ns ? nodeOps.createElementNS(vnode.ns, tag) : nodeOps.createElement(tag, vnode), setScope(vnode), createChildren(vnode, children, insertedVnodeQueue), isDef(data) && invokeCreateHooks(vnode, insertedVnodeQueue), insert(parentElm, vnode.elm, refElm), data && data.pre && creatingElmInVPre--) : isTrue(vnode.isComment) ? (vnode.elm = nodeOps.createComment(vnode.text), insert(parentElm, vnode.elm, refElm)) : (vnode.elm = nodeOps.createTextNode(vnode.text), insert(parentElm, vnode.elm, refElm));
            }
        }
        function initComponent(vnode, insertedVnodeQueue) {
            isDef(vnode.data.pendingInsert) && (insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert), vnode.data.pendingInsert = null), vnode.elm = vnode.componentInstance.$el, isPatchable(vnode) ? (invokeCreateHooks(vnode, insertedVnodeQueue), setScope(vnode)) : (registerRef(vnode), insertedVnodeQueue.push(vnode));
        }
        function insert(parent, elm, ref$$1) {
            isDef(parent) && (isDef(ref$$1) ? nodeOps.parentNode(ref$$1) === parent && nodeOps.insertBefore(parent, elm, ref$$1) : nodeOps.appendChild(parent, elm));
        }
        function createChildren(vnode, children, insertedVnodeQueue) {
            if (Array.isArray(children)) {
                checkDuplicateKeys(children);
                for(var i = 0; i < children.length; ++i)createElm(children[i], insertedVnodeQueue, vnode.elm, null, !0, children, i);
            } else isPrimitive(vnode.text) && nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
        }
        function isPatchable(vnode) {
            for(; vnode.componentInstance;)vnode = vnode.componentInstance._vnode;
            return isDef(vnode.tag);
        }
        function invokeCreateHooks(vnode, insertedVnodeQueue) {
            for(var i$1 = 0; i$1 < cbs.create.length; ++i$1)cbs.create[i$1](emptyNode, vnode);
            isDef(i = vnode.data.hook) && (isDef(i.create) && i.create(emptyNode, vnode), isDef(i.insert) && insertedVnodeQueue.push(vnode));
        }
        function setScope(vnode) {
            var i;
            if (isDef(i = vnode.fnScopeId)) nodeOps.setStyleScope(vnode.elm, i);
            else for(var ancestor = vnode; ancestor;)isDef(i = ancestor.context) && isDef(i = i.$options._scopeId) && nodeOps.setStyleScope(vnode.elm, i), ancestor = ancestor.parent;
            isDef(i = activeInstance) && i !== vnode.context && i !== vnode.fnContext && isDef(i = i.$options._scopeId) && nodeOps.setStyleScope(vnode.elm, i);
        }
        function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
            for(; startIdx <= endIdx; ++startIdx)createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, !1, vnodes, startIdx);
        }
        function invokeDestroyHook(vnode) {
            var i, j, data = vnode.data;
            if (isDef(data)) for(isDef(i = data.hook) && isDef(i = i.destroy) && i(vnode), i = 0; i < cbs.destroy.length; ++i)cbs.destroy[i](vnode);
            if (isDef(i = vnode.children)) for(j = 0; j < vnode.children.length; ++j)invokeDestroyHook(vnode.children[j]);
        }
        function removeVnodes(vnodes, startIdx, endIdx) {
            for(; startIdx <= endIdx; ++startIdx){
                var ch = vnodes[startIdx];
                isDef(ch) && (isDef(ch.tag) ? (function removeAndInvokeRemoveHook(vnode, rm) {
                    if (isDef(rm) || isDef(vnode.data)) {
                        var i, listeners = cbs.remove.length + 1;
                        for(isDef(rm) ? rm.listeners += listeners : rm = function(childElm, listeners) {
                            function remove$$1() {
                                0 == --remove$$1.listeners && removeNode(childElm);
                            }
                            return remove$$1.listeners = listeners, remove$$1;
                        }(vnode.elm, listeners), isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data) && removeAndInvokeRemoveHook(i, rm), i = 0; i < cbs.remove.length; ++i)cbs.remove[i](vnode, rm);
                        isDef(i = vnode.data.hook) && isDef(i = i.remove) ? i(vnode, rm) : rm();
                    } else removeNode(vnode.elm);
                }(ch), invokeDestroyHook(ch)) : removeNode(ch.elm));
            }
        }
        function checkDuplicateKeys(children) {
            for(var seenKeys = {}, i = 0; i < children.length; i++){
                var vnode = children[i], key = vnode.key;
                isDef(key) && (seenKeys[key] ? warn("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context) : seenKeys[key] = !0);
            }
        }
        function invokeInsertHook(vnode, queue, initial) {
            if (isTrue(initial) && isDef(vnode.parent)) vnode.parent.data.pendingInsert = queue;
            else for(var i = 0; i < queue.length; ++i)queue[i].data.hook.insert(queue[i]);
        }
        var hydrationBailed = !1, isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
        function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
            var inVPre1, i, tag = vnode.tag, data = vnode.data, children = vnode.children;
            if (inVPre = inVPre || data && data.pre, vnode.elm = elm, isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) return vnode.isAsyncPlaceholder = !0, !0;
            if (inVPre1 = inVPre, isDef(vnode.tag) ? 0 !== vnode.tag.indexOf('vue-component') && (!!isUnknownElement$$1(vnode, inVPre1) || vnode.tag.toLowerCase() !== (elm.tagName && elm.tagName.toLowerCase())) : elm.nodeType !== (vnode.isComment ? 8 : 3)) return !1;
            if (isDef(data) && (isDef(i = data.hook) && isDef(i = i.init) && i(vnode, !0), isDef(i = vnode.componentInstance))) return initComponent(vnode, insertedVnodeQueue), !0;
            if (isDef(tag)) {
                if (isDef(children)) {
                    if (elm.hasChildNodes()) {
                        if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
                            if (i !== elm.innerHTML) return 'undefined' == typeof console || hydrationBailed || (hydrationBailed = !0, console.warn('Parent: ', elm), console.warn('server innerHTML: ', i), console.warn('client innerHTML: ', elm.innerHTML)), !1;
                        } else {
                            for(var childrenMatch = !0, childNode = elm.firstChild, i$1 = 0; i$1 < children.length; i$1++){
                                if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
                                    childrenMatch = !1;
                                    break;
                                }
                                childNode = childNode.nextSibling;
                            }
                            if (!childrenMatch || childNode) return 'undefined' == typeof console || hydrationBailed || (hydrationBailed = !0, console.warn('Parent: ', elm), console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children)), !1;
                        }
                    } else createChildren(vnode, children, insertedVnodeQueue);
                }
                if (isDef(data)) {
                    var fullInvoke = !1;
                    for(var key in data)if (!isRenderedModule(key)) {
                        fullInvoke = !0, invokeCreateHooks(vnode, insertedVnodeQueue);
                        break;
                    }
                    !fullInvoke && data.class && traverse(data.class);
                }
            } else elm.data !== vnode.text && (elm.data = vnode.text);
            return !0;
        }
        return function(oldVnode, vnode, hydrating, removeOnly) {
            if (isUndef(vnode)) {
                isDef(oldVnode) && invokeDestroyHook(oldVnode);
                return;
            }
            var isInitialPatch = !1, insertedVnodeQueue = [];
            if (isUndef(oldVnode)) isInitialPatch = !0, createElm(vnode, insertedVnodeQueue);
            else {
                var elm, isRealElement = isDef(oldVnode.nodeType);
                if (!isRealElement && sameVnode(oldVnode, vnode)) !function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
                    if (oldVnode !== vnode) {
                        isDef(vnode.elm) && isDef(ownerArray) && (vnode = ownerArray[index] = cloneVNode(vnode));
                        var i, elm = vnode.elm = oldVnode.elm;
                        if (isTrue(oldVnode.isAsyncPlaceholder)) {
                            isDef(vnode.asyncFactory.resolved) ? hydrate(oldVnode.elm, vnode, insertedVnodeQueue) : vnode.isAsyncPlaceholder = !0;
                            return;
                        }
                        if (isTrue(vnode.isStatic) && isTrue(oldVnode.isStatic) && vnode.key === oldVnode.key && (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
                            vnode.componentInstance = oldVnode.componentInstance;
                            return;
                        }
                        var data = vnode.data;
                        isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch) && i(oldVnode, vnode);
                        var oldCh = oldVnode.children, ch = vnode.children;
                        if (isDef(data) && isPatchable(vnode)) {
                            for(i = 0; i < cbs.update.length; ++i)cbs.update[i](oldVnode, vnode);
                            isDef(i = data.hook) && isDef(i = i.update) && i(oldVnode, vnode);
                        }
                        isUndef(vnode.text) ? isDef(oldCh) && isDef(ch) ? oldCh !== ch && function(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
                            var oldKeyToIdx, idxInOld, vnodeToMove, oldStartIdx = 0, newStartIdx = 0, oldEndIdx = oldCh.length - 1, oldStartVnode = oldCh[0], oldEndVnode = oldCh[oldEndIdx], newEndIdx = newCh.length - 1, newStartVnode = newCh[0], newEndVnode = newCh[newEndIdx], canMove = !removeOnly;
                            for(checkDuplicateKeys(newCh); oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx;)isUndef(oldStartVnode) ? oldStartVnode = oldCh[++oldStartIdx] : isUndef(oldEndVnode) ? oldEndVnode = oldCh[--oldEndIdx] : sameVnode(oldStartVnode, newStartVnode) ? (patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx), oldStartVnode = oldCh[++oldStartIdx], newStartVnode = newCh[++newStartIdx]) : sameVnode(oldEndVnode, newEndVnode) ? (patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx), oldEndVnode = oldCh[--oldEndIdx], newEndVnode = newCh[--newEndIdx]) : sameVnode(oldStartVnode, newEndVnode) ? (patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx), canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm)), oldStartVnode = oldCh[++oldStartIdx], newEndVnode = newCh[--newEndIdx]) : sameVnode(oldEndVnode, newStartVnode) ? (patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx), canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm), oldEndVnode = oldCh[--oldEndIdx], newStartVnode = newCh[++newStartIdx]) : (isUndef(oldKeyToIdx) && (oldKeyToIdx = function(children, beginIdx, endIdx) {
                                var i, key, map = {};
                                for(i = beginIdx; i <= endIdx; ++i)isDef(key = children[i].key) && (map[key] = i);
                                return map;
                            }(oldCh, oldStartIdx, oldEndIdx)), isUndef(idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : function(node, oldCh, start, end) {
                                for(var i = start; i < end; i++){
                                    var c = oldCh[i];
                                    if (isDef(c) && sameVnode(node, c)) return i;
                                }
                            }(newStartVnode, oldCh, oldStartIdx, oldEndIdx)) ? createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, !1, newCh, newStartIdx) : sameVnode(vnodeToMove = oldCh[idxInOld], newStartVnode) ? (patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx), oldCh[idxInOld] = void 0, canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm)) : createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, !1, newCh, newStartIdx), newStartVnode = newCh[++newStartIdx]);
                            oldStartIdx > oldEndIdx ? addVnodes(parentElm, isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue) : newStartIdx > newEndIdx && removeVnodes(oldCh, oldStartIdx, oldEndIdx);
                        }(elm, oldCh, ch, insertedVnodeQueue, removeOnly) : isDef(ch) ? (checkDuplicateKeys(ch), isDef(oldVnode.text) && nodeOps.setTextContent(elm, ''), addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue)) : isDef(oldCh) ? removeVnodes(oldCh, 0, oldCh.length - 1) : isDef(oldVnode.text) && nodeOps.setTextContent(elm, '') : oldVnode.text !== vnode.text && nodeOps.setTextContent(elm, vnode.text), isDef(data) && isDef(i = data.hook) && isDef(i = i.postpatch) && i(oldVnode, vnode);
                    }
                }(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
                else {
                    if (isRealElement) {
                        if (1 === oldVnode.nodeType && oldVnode.hasAttribute(SSR_ATTR) && (oldVnode.removeAttribute(SSR_ATTR), hydrating = !0), isTrue(hydrating)) {
                            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) return invokeInsertHook(vnode, insertedVnodeQueue, !0), oldVnode;
                            warn("The client-side rendered virtual DOM tree is not matching server-rendered content. This is likely caused by incorrect HTML markup, for example nesting block-level elements inside <p>, or missing <tbody>. Bailing hydration and performing full client-side render.");
                        }
                        elm = oldVnode, oldVnode = new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], void 0, elm);
                    }
                    var oldElm = oldVnode.elm, parentElm = nodeOps.parentNode(oldElm);
                    if (createElm(vnode, insertedVnodeQueue, oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm)), isDef(vnode.parent)) for(var ancestor = vnode.parent, patchable = isPatchable(vnode); ancestor;){
                        for(var i = 0; i < cbs.destroy.length; ++i)cbs.destroy[i](ancestor);
                        if (ancestor.elm = vnode.elm, patchable) {
                            for(var i$1 = 0; i$1 < cbs.create.length; ++i$1)cbs.create[i$1](emptyNode, ancestor);
                            var insert = ancestor.data.hook.insert;
                            if (insert.merged) for(var i$2 = 1; i$2 < insert.fns.length; i$2++)insert.fns[i$2]();
                        } else registerRef(ancestor);
                        ancestor = ancestor.parent;
                    }
                    isDef(parentElm) ? removeVnodes([
                        oldVnode
                    ], 0, 0) : isDef(oldVnode.tag) && invokeDestroyHook(oldVnode);
                }
            }
            return invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch), vnode.elm;
        };
    }({
        nodeOps: nodeOps,
        modules: [
            {
                create: updateAttrs,
                update: updateAttrs
            },
            {
                create: updateClass,
                update: updateClass
            },
            {
                create: updateDOMListeners,
                update: updateDOMListeners
            },
            {
                create: updateDOMProps,
                update: updateDOMProps
            },
            {
                create: updateStyle,
                update: updateStyle
            },
            inBrowser ? {
                create: _enter,
                activate: _enter,
                remove: function(vnode, rm) {
                    !0 !== vnode.data.show ? leave(vnode, rm) : rm();
                }
            } : {}
        ].concat([
            {
                create: function(_, vnode) {
                    registerRef(vnode);
                },
                update: function(oldVnode, vnode) {
                    oldVnode.data.ref !== vnode.data.ref && (registerRef(oldVnode, !0), registerRef(vnode));
                },
                destroy: function(vnode) {
                    registerRef(vnode, !0);
                }
            },
            {
                create: updateDirectives,
                update: updateDirectives,
                destroy: function(vnode) {
                    updateDirectives(vnode, emptyNode);
                }
            }
        ])
    });
    isIE9 && document.addEventListener('selectionchange', function() {
        var el = document.activeElement;
        el && el.vmodel && trigger(el, 'input');
    });
    var directive = {
        inserted: function(el, binding, vnode, oldVnode) {
            'select' === vnode.tag ? (oldVnode.elm && !oldVnode.elm._vOptions ? mergeVNodeHook(vnode, 'postpatch', function() {
                directive.componentUpdated(el, binding, vnode);
            }) : setSelected(el, binding, vnode.context), el._vOptions = [].map.call(el.options, getValue)) : ('textarea' === vnode.tag || isTextInputType(el.type)) && (el._vModifiers = binding.modifiers, !binding.modifiers.lazy && (el.addEventListener('compositionstart', onCompositionStart), el.addEventListener('compositionend', onCompositionEnd), el.addEventListener('change', onCompositionEnd), isIE9 && (el.vmodel = !0)));
        },
        componentUpdated: function(el, binding, vnode) {
            if ('select' === vnode.tag) {
                setSelected(el, binding, vnode.context);
                var prevOptions = el._vOptions, curOptions = el._vOptions = [].map.call(el.options, getValue);
                curOptions.some(function(o, i) {
                    return !looseEqual(o, prevOptions[i]);
                }) && (el.multiple ? binding.value.some(function(v) {
                    return hasNoMatchingOption(v, curOptions);
                }) : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions)) && trigger(el, 'change');
            }
        }
    };
    function setSelected(el, binding, vm) {
        actuallySetSelected(el, binding, vm), (isIE || isEdge) && setTimeout(function() {
            actuallySetSelected(el, binding, vm);
        }, 0);
    }
    function actuallySetSelected(el, binding, vm) {
        var selected, option, value = binding.value, isMultiple = el.multiple;
        if (isMultiple && !Array.isArray(value)) {
            warn("<select multiple v-model=\"" + binding.expression + '"> expects an Array value for its binding, but got ' + Object.prototype.toString.call(value).slice(8, -1), vm);
            return;
        }
        for(var i = 0, l = el.options.length; i < l; i++)if (option = el.options[i], isMultiple) selected = looseIndexOf(value, getValue(option)) > -1, option.selected !== selected && (option.selected = selected);
        else if (looseEqual(getValue(option), value)) {
            el.selectedIndex !== i && (el.selectedIndex = i);
            return;
        }
        isMultiple || (el.selectedIndex = -1);
    }
    function hasNoMatchingOption(value, options) {
        return options.every(function(o) {
            return !looseEqual(o, value);
        });
    }
    function getValue(option) {
        return '_value' in option ? option._value : option.value;
    }
    function onCompositionStart(e) {
        e.target.composing = !0;
    }
    function onCompositionEnd(e) {
        e.target.composing && (e.target.composing = !1, trigger(e.target, 'input'));
    }
    function trigger(el, type) {
        var e = document.createEvent('HTMLEvents');
        e.initEvent(type, !0, !0), el.dispatchEvent(e);
    }
    function locateNode(vnode) {
        return !vnode.componentInstance || vnode.data && vnode.data.transition ? vnode : locateNode(vnode.componentInstance._vnode);
    }
    var transitionProps = {
        name: String,
        appear: Boolean,
        css: Boolean,
        mode: String,
        type: String,
        enterClass: String,
        leaveClass: String,
        enterToClass: String,
        leaveToClass: String,
        enterActiveClass: String,
        leaveActiveClass: String,
        appearClass: String,
        appearActiveClass: String,
        appearToClass: String,
        duration: [
            Number,
            String,
            Object
        ]
    };
    function getRealChild(vnode) {
        var compOptions = vnode && vnode.componentOptions;
        return compOptions && compOptions.Ctor.options.abstract ? getRealChild(getFirstComponentChild(compOptions.children)) : vnode;
    }
    function extractTransitionData(comp) {
        var data = {}, options = comp.$options;
        for(var key in options.propsData)data[key] = comp[key];
        var listeners = options._parentListeners;
        for(var key$1 in listeners)data[camelize(key$1)] = listeners[key$1];
        return data;
    }
    function placeholder(h, rawChild) {
        if (/\d-keep-alive$/.test(rawChild.tag)) return h('keep-alive', {
            props: rawChild.componentOptions.propsData
        });
    }
    var isNotTextNode = function(c) {
        return c.tag || isAsyncPlaceholder(c);
    }, isVShowDirective = function(d) {
        return 'show' === d.name;
    }, props = extend({
        tag: String,
        moveClass: String
    }, transitionProps);
    function callPendingCbs(c) {
        c.elm._moveCb && c.elm._moveCb(), c.elm._enterCb && c.elm._enterCb();
    }
    function recordPosition(c) {
        c.data.newPos = c.elm.getBoundingClientRect();
    }
    function applyTranslation(c) {
        var oldPos = c.data.pos, newPos = c.data.newPos, dx = oldPos.left - newPos.left, dy = oldPos.top - newPos.top;
        if (dx || dy) {
            c.data.moved = !0;
            var s = c.elm.style;
            s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)", s.transitionDuration = '0s';
        }
    }
    delete props.mode, Vue7.config.mustUseProp = mustUseProp, Vue7.config.isReservedTag = isReservedTag, Vue7.config.isReservedAttr = isReservedAttr, Vue7.config.getTagNamespace = getTagNamespace, Vue7.config.isUnknownElement = function(tag) {
        if (!inBrowser) return !0;
        if (isReservedTag(tag)) return !1;
        if (null != unknownElementCache[tag = tag.toLowerCase()]) return unknownElementCache[tag];
        var el = document.createElement(tag);
        return tag.indexOf('-') > -1 ? unknownElementCache[tag] = el.constructor === window.HTMLUnknownElement || el.constructor === window.HTMLElement : unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString());
    }, extend(Vue7.options.directives, {
        model: directive,
        show: {
            bind: function(el, ref, vnode) {
                var value = ref.value, transition$$1 = (vnode = locateNode(vnode)).data && vnode.data.transition, originalDisplay = el.__vOriginalDisplay = 'none' === el.style.display ? '' : el.style.display;
                value && transition$$1 ? (vnode.data.show = !0, enter(vnode, function() {
                    el.style.display = originalDisplay;
                })) : el.style.display = value ? originalDisplay : 'none';
            },
            update: function(el, ref, vnode) {
                var value = ref.value;
                !value != !ref.oldValue && ((vnode = locateNode(vnode)).data && vnode.data.transition ? (vnode.data.show = !0, value ? enter(vnode, function() {
                    el.style.display = el.__vOriginalDisplay;
                }) : leave(vnode, function() {
                    el.style.display = 'none';
                })) : el.style.display = value ? el.__vOriginalDisplay : 'none');
            },
            unbind: function(el, binding, vnode, oldVnode, isDestroy) {
                isDestroy || (el.style.display = el.__vOriginalDisplay);
            }
        }
    }), extend(Vue7.options.components, {
        Transition: {
            name: 'transition',
            props: transitionProps,
            abstract: !0,
            render: function(h) {
                var this$1 = this, children = this.$slots.default;
                if (children && (children = children.filter(isNotTextNode)).length) {
                    children.length > 1 && warn("<transition> can only be used on a single element. Use <transition-group> for lists.", this.$parent);
                    var mode = this.mode;
                    mode && 'in-out' !== mode && 'out-in' !== mode && warn('invalid <transition> mode: ' + mode, this.$parent);
                    var rawChild = children[0];
                    if (function(vnode) {
                        for(; vnode = vnode.parent;)if (vnode.data.transition) return !0;
                    }(this.$vnode)) return rawChild;
                    var child = getRealChild(rawChild);
                    if (!child) return rawChild;
                    if (this._leaving) return placeholder(h, rawChild);
                    var id = "__transition-" + this._uid + "-";
                    child.key = null == child.key ? child.isComment ? id + 'comment' : id + child.tag : isPrimitive(child.key) ? 0 === String(child.key).indexOf(id) ? child.key : id + child.key : child.key;
                    var data = (child.data || (child.data = {})).transition = extractTransitionData(this), oldRawChild = this._vnode, oldChild = getRealChild(oldRawChild);
                    if (child.data.directives && child.data.directives.some(isVShowDirective) && (child.data.show = !0), oldChild && oldChild.data && (child1 = child, (oldChild1 = oldChild).key !== child1.key || oldChild1.tag !== child1.tag) && !isAsyncPlaceholder(oldChild) && !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)) {
                        var oldData = oldChild.data.transition = extend({}, data);
                        if ('out-in' === mode) return this._leaving = !0, mergeVNodeHook(oldData, 'afterLeave', function() {
                            this$1._leaving = !1, this$1.$forceUpdate();
                        }), placeholder(h, rawChild);
                        if ('in-out' === mode) {
                            if (isAsyncPlaceholder(child)) return oldRawChild;
                            var child1, oldChild1, delayedLeave, performLeave = function() {
                                delayedLeave();
                            };
                            mergeVNodeHook(data, 'afterEnter', performLeave), mergeVNodeHook(data, 'enterCancelled', performLeave), mergeVNodeHook(oldData, 'delayLeave', function(leave) {
                                delayedLeave = leave;
                            });
                        }
                    }
                    return rawChild;
                }
            }
        },
        TransitionGroup: {
            props: props,
            beforeMount: function() {
                var this$1 = this, update = this._update;
                this._update = function(vnode, hydrating) {
                    var restoreActiveInstance = setActiveInstance(this$1);
                    this$1.__patch__(this$1._vnode, this$1.kept, !1, !0), this$1._vnode = this$1.kept, restoreActiveInstance(), update.call(this$1, vnode, hydrating);
                };
            },
            render: function(h) {
                for(var tag = this.tag || this.$vnode.data.tag || 'span', map = Object.create(null), prevChildren = this.prevChildren = this.children, rawChildren = this.$slots.default || [], children = this.children = [], transitionData = extractTransitionData(this), i = 0; i < rawChildren.length; i++){
                    var c = rawChildren[i];
                    if (c.tag) {
                        if (null != c.key && 0 !== String(c.key).indexOf('__vlist')) children.push(c), map[c.key] = c, (c.data || (c.data = {})).transition = transitionData;
                        else {
                            var opts = c.componentOptions;
                            warn("<transition-group> children must be keyed: <" + (opts ? opts.Ctor.options.name || opts.tag || '' : c.tag) + ">");
                        }
                    }
                }
                if (prevChildren) {
                    for(var kept = [], removed = [], i$1 = 0; i$1 < prevChildren.length; i$1++){
                        var c$1 = prevChildren[i$1];
                        c$1.data.transition = transitionData, c$1.data.pos = c$1.elm.getBoundingClientRect(), map[c$1.key] ? kept.push(c$1) : removed.push(c$1);
                    }
                    this.kept = h(tag, null, kept), this.removed = removed;
                }
                return h(tag, null, children);
            },
            updated: function() {
                var children = this.prevChildren, moveClass = this.moveClass || (this.name || 'v') + '-move';
                children.length && this.hasMove(children[0].elm, moveClass) && (children.forEach(callPendingCbs), children.forEach(recordPosition), children.forEach(applyTranslation), this._reflow = document.body.offsetHeight, children.forEach(function(c) {
                    if (c.data.moved) {
                        var el = c.elm, s = el.style;
                        addTransitionClass(el, moveClass), s.transform = s.WebkitTransform = s.transitionDuration = '', el.addEventListener(transitionEndEvent, el._moveCb = function cb(e) {
                            (!e || e.target === el) && (!e || /transform$/.test(e.propertyName)) && (el.removeEventListener(transitionEndEvent, cb), el._moveCb = null, removeTransitionClass(el, moveClass));
                        });
                    }
                }));
            },
            methods: {
                hasMove: function(el, moveClass) {
                    if (!hasTransition) return !1;
                    if (this._hasMove) return this._hasMove;
                    var clone = el.cloneNode();
                    el._transitionClasses && el._transitionClasses.forEach(function(cls) {
                        removeClass(clone, cls);
                    }), addClass(clone, moveClass), clone.style.display = 'none', this.$el.appendChild(clone);
                    var info = getTransitionInfo(clone);
                    return this.$el.removeChild(clone), this._hasMove = info.hasTransform;
                }
            }
        }
    }), Vue7.prototype.__patch__ = inBrowser ? patch : noop, Vue7.prototype.$mount = function(el, hydrating) {
        var vm, el1, hydrating1, updateComponent;
        return el = el && inBrowser ? query(el) : void 0, vm = this, el1 = el, hydrating1 = hydrating, vm.$el = el1, vm.$options.render || (vm.$options.render = createEmptyVNode, vm.$options.template && '#' !== vm.$options.template.charAt(0) || vm.$options.el || el1 ? warn("You are using the runtime-only build of Vue where the template compiler is not available. Either pre-compile the templates into render functions, or use the compiler-included build.", vm) : warn('Failed to mount component: template or render function not defined.', vm)), callHook(vm, 'beforeMount'), updateComponent = config.performance && mark ? function() {
            var name = vm._name, id = vm._uid, startTag = "vue-perf-start:" + id, endTag = "vue-perf-end:" + id;
            mark(startTag);
            var vnode = vm._render();
            mark(endTag), measure("vue " + name + " render", startTag, endTag), mark(startTag), vm._update(vnode, hydrating1), mark(endTag), measure("vue " + name + " patch", startTag, endTag);
        } : function() {
            vm._update(vm._render(), hydrating1);
        }, new Watcher(vm, updateComponent, noop, {
            before: function() {
                vm._isMounted && !vm._isDestroyed && callHook(vm, 'beforeUpdate');
            }
        }, !0), hydrating1 = !1, null == vm.$vnode && (vm._isMounted = !0, callHook(vm, 'mounted')), vm;
    }, inBrowser && setTimeout(function() {
        config.devtools && (devtools ? devtools.emit('init', Vue7) : console[console.info ? 'info' : 'log']("Download the Vue Devtools extension for a better development experience:\nhttps://github.com/vuejs/vue-devtools")), !1 !== config.productionTip && 'undefined' != typeof console && console[console.info ? 'info' : 'log']("You are running Vue in development mode.\nMake sure to turn on production mode when deploying for production.\nSee more tips at https://vuejs.org/guide/deployment.html");
    }, 0);
    var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g, regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g, buildRegex = cached(function(delimiters) {
        return RegExp(delimiters[0].replace(regexEscapeRE, '\\$&') + '((?:.|\\n)+?)' + delimiters[1].replace(regexEscapeRE, '\\$&'), 'g');
    });
    function parseText(text, delimiters) {
        var match, index, tokenValue, tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
        if (tagRE.test(text)) {
            for(var tokens = [], rawTokens = [], lastIndex = tagRE.lastIndex = 0; match = tagRE.exec(text);){
                (index = match.index) > lastIndex && (rawTokens.push(tokenValue = text.slice(lastIndex, index)), tokens.push(JSON.stringify(tokenValue)));
                var exp = parseFilters(match[1].trim());
                tokens.push("_s(" + exp + ")"), rawTokens.push({
                    '@binding': exp
                }), lastIndex = index + match[0].length;
            }
            return lastIndex < text.length && (rawTokens.push(tokenValue = text.slice(lastIndex)), tokens.push(JSON.stringify(tokenValue))), {
                expression: tokens.join('+'),
                tokens: rawTokens
            };
        }
    }
    var isUnaryTag = makeMap("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"), canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'), isNonPhrasingTag = makeMap("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"), attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/, dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/, ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*", qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")", startTagOpen = RegExp("^<" + qnameCapture), startTagClose = /^\s*(\/?)>/, endTag = RegExp("^<\\/" + qnameCapture + "[^>]*>"), doctype = /^<!DOCTYPE [^>]+>/i, comment = /^<!\--/, conditionalComment = /^<!\[/, isPlainTextElement = makeMap('script,style,textarea', !0), reCache = {}, decodingMap = {
        '&lt;': '<',
        '&gt;': '>',
        '&quot;': '"',
        '&amp;': '&',
        '&#10;': '\n',
        '&#9;': '\t',
        '&#39;': "'"
    }, encodedAttr = /&(?:lt|gt|quot|amp|#39);/g, encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g, isIgnoreNewlineTag = makeMap('pre,textarea', !0), shouldIgnoreFirstNewline = function(tag, html) {
        return tag && isIgnoreNewlineTag(tag) && '\n' === html[0];
    }, onRE = /^@|^v-on:/, dirRE = /^v-|^@|^:|^#/, forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/, forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/, stripParensRE = /^\(|\)$/g, dynamicArgRE = /^\[.*\]$/, argRE = /:(.*)$/, bindRE = /^:|^\.|^v-bind:/, modifierRE = /\.[^.\]]+(?=[^\]]*$)/g, slotRE = /^v-slot(:|$)|^#/, lineBreakRE = /[\r\n]/, whitespaceRE$1 = /\s+/g, invalidAttributeRE = /[\s"'<>\/=]/, decodeHTMLCached = cached(function(html) {
        return (decoder = decoder || document.createElement('div')).innerHTML = html, decoder.textContent;
    }), emptySlotScopeToken = "_empty_";
    function createASTElement(tag, attrs, parent) {
        return {
            type: 1,
            tag: tag,
            attrsList: attrs,
            attrsMap: function(attrs) {
                for(var map = {}, i = 0, l = attrs.length; i < l; i++)!map[attrs[i].name] || isIE || isEdge || warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]), map[attrs[i].name] = attrs[i].value;
                return map;
            }(attrs),
            rawAttrsMap: {},
            parent: parent,
            children: []
        };
    }
    function processElement(element, options) {
        (function(el) {
            var exp = getBindingAttr(el, 'key');
            if (exp) {
                if ('template' === el.tag && warn$2("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key')), el.for) {
                    var iterator = el.iterator2 || el.iterator1, parent = el.parent;
                    iterator && iterator === exp && parent && 'transition-group' === parent.tag && warn$2("Do not use v-for index as key on <transition-group> children, this is the same as not using keys.", getRawBindingAttr(el, 'key'), !0);
                }
                el.key = exp;
            }
        })(element), element.plain = !element.key && !element.scopedSlots && !element.attrsList.length, (ref = getBindingAttr(el = element, 'ref')) && (el.ref = ref, el.refInFor = function(el) {
            for(var parent = el; parent;){
                if (void 0 !== parent.for) return !0;
                parent = parent.parent;
            }
            return !1;
        }(el)), function(el) {
            'template' === el.tag ? ((slotScope = getAndRemoveAttr(el, 'scope')) && warn$2('the "scope" attribute for scoped slots have been deprecated and replaced by "slot-scope" since 2.5. The new "slot-scope" attribute can also be used on plain elements in addition to <template> to denote scoped slots.', el.rawAttrsMap.scope, !0), el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope')) : (slotScope = getAndRemoveAttr(el, 'slot-scope')) && (el.attrsMap['v-for'] && warn$2("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> (v-for takes higher priority). Use a wrapper <template> for the scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], !0), el.slotScope = slotScope);
            var slotScope, slotTarget = getBindingAttr(el, 'slot');
            if (slotTarget && (el.slotTarget = '""' === slotTarget ? '"default"' : slotTarget, el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']), 'template' === el.tag || el.slotScope || addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'))), 'template' === el.tag) {
                var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
                if (slotBinding) {
                    (el.slotTarget || el.slotScope) && warn$2("Unexpected mixed usage of different slot syntaxes.", el), el.parent && !maybeComponent(el.parent) && warn$2("<template v-slot> can only appear at the root level inside the receiving component", el);
                    var ref = getSlotName(slotBinding), name = ref.name, dynamic = ref.dynamic;
                    el.slotTarget = name, el.slotTargetDynamic = dynamic, el.slotScope = slotBinding.value || emptySlotScopeToken;
                }
            } else {
                var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
                if (slotBinding$1) {
                    maybeComponent(el) || warn$2("v-slot can only be used on components or <template>.", slotBinding$1), (el.slotScope || el.slotTarget) && warn$2("Unexpected mixed usage of different slot syntaxes.", el), el.scopedSlots && warn$2("To avoid scope ambiguity, the default slot should also use <template> syntax when there are other named slots.", slotBinding$1);
                    var slots = el.scopedSlots || (el.scopedSlots = {}), ref$1 = getSlotName(slotBinding$1), name$1 = ref$1.name, dynamic$1 = ref$1.dynamic, slotContainer = slots[name$1] = createASTElement('template', [], el);
                    slotContainer.slotTarget = name$1, slotContainer.slotTargetDynamic = dynamic$1, slotContainer.children = el.children.filter(function(c) {
                        if (!c.slotScope) return c.parent = slotContainer, !0;
                    }), slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken, el.children = [], el.plain = !1;
                }
            }
        }(element), 'slot' === (el1 = element).tag && (el1.slotName = getBindingAttr(el1, 'name'), el1.key && warn$2("`key` does not work on <slot> because slots are abstract outlets and can possibly expand into multiple elements. Use the key on a wrapping element instead.", getRawBindingAttr(el1, 'key'))), (binding = getBindingAttr(el2 = element, 'is')) && (el2.component = binding), null != getAndRemoveAttr(el2, 'inline-template') && (el2.inlineTemplate = !0);
        for(var el, ref, el1, el2, binding, i = 0; i < transforms.length; i++)element = transforms[i](element, options) || element;
        return function(el) {
            var i, l, name, rawName, value, modifiers, syncGen, isDynamic, list = el.attrsList;
            for(i = 0, l = list.length; i < l; i++)if (name = rawName = list[i].name, value = list[i].value, dirRE.test(name)) {
                if (el.hasBindings = !0, (modifiers = function(name) {
                    var match = name.match(modifierRE);
                    if (match) {
                        var ret = {};
                        return match.forEach(function(m) {
                            ret[m.slice(1)] = !0;
                        }), ret;
                    }
                }(name.replace(dirRE, ''))) && (name = name.replace(modifierRE, '')), bindRE.test(name)) name = name.replace(bindRE, ''), value = parseFilters(value), (isDynamic = dynamicArgRE.test(name)) && (name = name.slice(1, -1)), 0 === value.trim().length && warn$2("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""), modifiers && (modifiers.prop && !isDynamic && 'innerHtml' === (name = camelize(name)) && (name = 'innerHTML'), modifiers.camel && !isDynamic && (name = camelize(name)), modifiers.sync && (syncGen = genAssignmentCode(value, "$event"), isDynamic ? addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, !1, warn$2, list[i], !0) : (addHandler(el, "update:" + camelize(name), syncGen, null, !1, warn$2, list[i]), hyphenate(name) !== camelize(name) && addHandler(el, "update:" + hyphenate(name), syncGen, null, !1, warn$2, list[i])))), modifiers && modifiers.prop || !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name) ? addProp(el, name, value, list[i], isDynamic) : addAttr(el, name, value, list[i], isDynamic);
                else if (onRE.test(name)) name = name.replace(onRE, ''), (isDynamic = dynamicArgRE.test(name)) && (name = name.slice(1, -1)), addHandler(el, name, value, modifiers, !1, warn$2, list[i], isDynamic);
                else {
                    var el1, name1, value1, arg, isDynamicArg, range, argMatch = (name = name.replace(dirRE, '')).match(argRE), arg1 = argMatch && argMatch[1];
                    isDynamic = !1, arg1 && (name = name.slice(0, -(arg1.length + 1)), dynamicArgRE.test(arg1) && (arg1 = arg1.slice(1, -1), isDynamic = !0)), el1 = el, name1 = name, value1 = value, arg = arg1, isDynamicArg = isDynamic, range = list[i], (el1.directives || (el1.directives = [])).push(rangeSetItem({
                        name: name1,
                        rawName: rawName,
                        value: value1,
                        arg: arg,
                        isDynamicArg: isDynamicArg,
                        modifiers: modifiers
                    }, range)), el1.plain = !1, 'model' === name && function(el, value) {
                        for(var _el = el; _el;)_el.for && _el.alias === value && warn$2("<" + el.tag + " v-model=\"" + value + '">: You are binding v-model directly to a v-for iteration alias. This will not be able to modify the v-for source array because writing to the alias is like modifying a function local variable. Consider using an array of objects and use v-model on an object property instead.', el.rawAttrsMap['v-model']), _el = _el.parent;
                    }(el, value);
                }
            } else parseText(value, delimiters) && warn$2(name + "=\"" + value + '": Interpolation inside attributes has been removed. Use v-bind or the colon shorthand instead. For example, instead of <div id="{{ val }}">, use <div :id="val">.', list[i]), addAttr(el, name, JSON.stringify(value), list[i]), !el.component && 'muted' === name && platformMustUseProp(el.tag, el.attrsMap.type, name) && addProp(el, name, 'true', list[i]);
        }(element), element;
    }
    function processFor(el) {
        var exp;
        if (exp = getAndRemoveAttr(el, 'v-for')) {
            var res = function(exp) {
                var inMatch = exp.match(forAliasRE);
                if (inMatch) {
                    var res = {};
                    res.for = inMatch[2].trim();
                    var alias = inMatch[1].trim().replace(stripParensRE, ''), iteratorMatch = alias.match(forIteratorRE);
                    return iteratorMatch ? (res.alias = alias.replace(forIteratorRE, '').trim(), res.iterator1 = iteratorMatch[1].trim(), iteratorMatch[2] && (res.iterator2 = iteratorMatch[2].trim())) : res.alias = alias, res;
                }
            }(exp);
            res ? extend(el, res) : warn$2("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
        }
    }
    function addIfCondition(el, condition) {
        el.ifConditions || (el.ifConditions = []), el.ifConditions.push(condition);
    }
    function getSlotName(binding) {
        var name = binding.name.replace(slotRE, '');
        return name || ('#' !== binding.name[0] ? name = 'default' : warn$2("v-slot shorthand syntax requires a slot name.", binding)), dynamicArgRE.test(name) ? {
            name: name.slice(1, -1),
            dynamic: !0
        } : {
            name: "\"" + name + "\"",
            dynamic: !1
        };
    }
    var ieNSBug = /^xmlns:NS\d+/, ieNSPrefix = /^NS\d+:/;
    function cloneASTElement(el) {
        return createASTElement(el.tag, el.attrsList.slice(), el.parent);
    }
    var modules$1 = [
        {
            staticKeys: [
                'staticClass'
            ],
            transformNode: function(el, options) {
                var warn = options.warn || baseWarn, staticClass = getAndRemoveAttr(el, 'class');
                staticClass && parseText(staticClass, options.delimiters) && warn("class=\"" + staticClass + '": Interpolation inside attributes has been removed. Use v-bind or the colon shorthand instead. For example, instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap.class), staticClass && (el.staticClass = JSON.stringify(staticClass));
                var classBinding = getBindingAttr(el, 'class', !1);
                classBinding && (el.classBinding = classBinding);
            },
            genData: function(el) {
                var data = '';
                return el.staticClass && (data += "staticClass:" + el.staticClass + ","), el.classBinding && (data += "class:" + el.classBinding + ","), data;
            }
        },
        {
            staticKeys: [
                'staticStyle'
            ],
            transformNode: function(el, options) {
                var warn = options.warn || baseWarn, staticStyle = getAndRemoveAttr(el, 'style');
                staticStyle && (parseText(staticStyle, options.delimiters) && warn("style=\"" + staticStyle + '": Interpolation inside attributes has been removed. Use v-bind or the colon shorthand instead. For example, instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap.style), el.staticStyle = JSON.stringify(parseStyleText(staticStyle)));
                var styleBinding = getBindingAttr(el, 'style', !1);
                styleBinding && (el.styleBinding = styleBinding);
            },
            genData: function(el) {
                var data = '';
                return el.staticStyle && (data += "staticStyle:" + el.staticStyle + ","), el.styleBinding && (data += "style:(" + el.styleBinding + "),"), data;
            }
        },
        {
            preTransformNode: function(el, options) {
                if ('input' === el.tag) {
                    var typeBinding, map = el.attrsMap;
                    if (map['v-model'] && ((map[':type'] || map['v-bind:type']) && (typeBinding = getBindingAttr(el, 'type')), map.type || typeBinding || !map['v-bind'] || (typeBinding = "(" + map['v-bind'] + ").type"), typeBinding)) {
                        var ifCondition = getAndRemoveAttr(el, 'v-if', !0), ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "", hasElse = null != getAndRemoveAttr(el, 'v-else', !0), elseIfCondition = getAndRemoveAttr(el, 'v-else-if', !0), branch0 = cloneASTElement(el);
                        processFor(branch0), addRawAttr(branch0, 'type', 'checkbox'), processElement(branch0, options), branch0.processed = !0, branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra, addIfCondition(branch0, {
                            exp: branch0.if,
                            block: branch0
                        });
                        var branch1 = cloneASTElement(el);
                        getAndRemoveAttr(branch1, 'v-for', !0), addRawAttr(branch1, 'type', 'radio'), processElement(branch1, options), addIfCondition(branch0, {
                            exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
                            block: branch1
                        });
                        var branch2 = cloneASTElement(el);
                        return getAndRemoveAttr(branch2, 'v-for', !0), addRawAttr(branch2, ':type', typeBinding), processElement(branch2, options), addIfCondition(branch0, {
                            exp: ifCondition,
                            block: branch2
                        }), hasElse ? branch0.else = !0 : elseIfCondition && (branch0.elseif = elseIfCondition), branch0;
                    }
                }
            }
        }
    ], baseOptions = {
        expectHTML: !0,
        modules: modules$1,
        directives: {
            model: function(el, dir, _warn) {
                var code, number, valueBinding, trueValueBinding, falseValueBinding, number1, valueBinding1, value = dir.value, modifiers = dir.modifiers, tag = el.tag, type = el.attrsMap.type;
                if ('input' === tag && 'file' === type && _warn("<" + el.tag + " v-model=\"" + value + '" type="file">:\nFile inputs are read only. Use a v-on:change listener instead.', el.rawAttrsMap['v-model']), el.component) return genComponentModel(el, value, modifiers), !1;
                if ('select' === tag) addHandler(el, 'change', 'var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ' + (modifiers && modifiers.number ? '_n(val)' : 'val') + "}); " + genAssignmentCode(value, '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'), null, !0);
                else if ('input' === tag && 'checkbox' === type) number = modifiers && modifiers.number, valueBinding = getBindingAttr(el, 'value') || 'null', trueValueBinding = getBindingAttr(el, 'true-value') || 'true', falseValueBinding = getBindingAttr(el, 'false-value') || 'false', addProp(el, 'checked', "Array.isArray(" + value + ")?_i(" + value + "," + valueBinding + ")>-1" + ('true' === trueValueBinding ? ":(" + value + ")" : ":_q(" + value + "," + trueValueBinding + ")")), addHandler(el, 'change', "var $$a=" + value + ",$$el=$event.target,$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");if(Array.isArray($$a)){var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}}else{" + genAssignmentCode(value, '$$c') + "}", null, !0);
                else if ('input' === tag && 'radio' === type) number1 = modifiers && modifiers.number, valueBinding1 = getBindingAttr(el, 'value') || 'null', valueBinding1 = number1 ? "_n(" + valueBinding1 + ")" : valueBinding1, addProp(el, 'checked', "_q(" + value + "," + valueBinding1 + ")"), addHandler(el, 'change', genAssignmentCode(value, valueBinding1), null, !0);
                else if ('input' === tag || 'textarea' === tag) !function(el, value, modifiers) {
                    var type = el.attrsMap.type, value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'], typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
                    if (value$1 && !typeBinding) {
                        var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
                        _warn(binding + "=\"" + value$1 + '" conflicts with v-model on the same element because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
                    }
                    var ref = modifiers || {}, lazy = ref.lazy, number = ref.number, trim = ref.trim, valueExpression = '$event.target.value';
                    trim && (valueExpression = "$event.target.value.trim()"), number && (valueExpression = "_n(" + valueExpression + ")");
                    var code = genAssignmentCode(value, valueExpression);
                    lazy || 'range' === type || (code = "if($event.target.composing)return;" + code), addProp(el, 'value', "(" + value + ")"), addHandler(el, lazy ? 'change' : 'range' === type ? '__r' : 'input', code, null, !0), (trim || number) && addHandler(el, 'blur', '$forceUpdate()');
                }(el, value, modifiers);
                else {
                    if (!config.isReservedTag(tag)) return genComponentModel(el, value, modifiers), !1;
                    _warn("<" + el.tag + " v-model=\"" + value + "\">: v-model is not supported on this element type. If you are working with contenteditable, it's recommended to wrap a library dedicated for that purpose inside a custom component.", el.rawAttrsMap['v-model']);
                }
                return !0;
            },
            text: function(el, dir) {
                dir.value && addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
            },
            html: function(el, dir) {
                dir.value && addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
            }
        },
        isPreTag: function(tag) {
            return 'pre' === tag;
        },
        isUnaryTag: isUnaryTag,
        mustUseProp: mustUseProp,
        canBeLeftOpenTag: canBeLeftOpenTag,
        isReservedTag: isReservedTag,
        getTagNamespace: getTagNamespace,
        staticKeys: modules$1.reduce(function(keys, m) {
            return keys.concat(m.staticKeys || []);
        }, []).join(',')
    }, genStaticKeysCached = cached(function(keys) {
        return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' + (keys ? ',' + keys : ''));
    }), fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/, fnInvokeRE = /\([^)]*?\);*$/, simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/, keyCodes = {
        esc: 27,
        tab: 9,
        enter: 13,
        space: 32,
        up: 38,
        left: 37,
        right: 39,
        down: 40,
        delete: [
            8,
            46
        ]
    }, keyNames = {
        esc: [
            'Esc',
            'Escape'
        ],
        tab: 'Tab',
        enter: 'Enter',
        space: [
            ' ',
            'Spacebar'
        ],
        up: [
            'Up',
            'ArrowUp'
        ],
        left: [
            'Left',
            'ArrowLeft'
        ],
        right: [
            'Right',
            'ArrowRight'
        ],
        down: [
            'Down',
            'ArrowDown'
        ],
        delete: [
            'Backspace',
            'Delete',
            'Del'
        ]
    }, genGuard = function(condition) {
        return "if(" + condition + ")return null;";
    }, modifierCode = {
        stop: '$event.stopPropagation();',
        prevent: '$event.preventDefault();',
        self: genGuard("$event.target !== $event.currentTarget"),
        ctrl: genGuard("!$event.ctrlKey"),
        shift: genGuard("!$event.shiftKey"),
        alt: genGuard("!$event.altKey"),
        meta: genGuard("!$event.metaKey"),
        left: genGuard("'button' in $event && $event.button !== 0"),
        middle: genGuard("'button' in $event && $event.button !== 1"),
        right: genGuard("'button' in $event && $event.button !== 2")
    };
    function genHandlers(events, isNative) {
        var prefix = isNative ? 'nativeOn:' : 'on:', staticHandlers = "", dynamicHandlers = "";
        for(var name in events){
            var handlerCode = function genHandler(handler) {
                if (!handler) return 'function(){}';
                if (Array.isArray(handler)) return "[" + handler.map(function(handler) {
                    return genHandler(handler);
                }).join(',') + "]";
                var isMethodPath = simplePathRE.test(handler.value), isFunctionExpression = fnExpRE.test(handler.value), isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
                if (handler.modifiers) {
                    var code = '', genModifierCode = '', keys = [];
                    for(var key in handler.modifiers)if (modifierCode[key]) genModifierCode += modifierCode[key], keyCodes[key] && keys.push(key);
                    else if ('exact' === key) {
                        var modifiers = handler.modifiers;
                        genModifierCode += genGuard([
                            'ctrl',
                            'shift',
                            'alt',
                            'meta'
                        ].filter(function(keyModifier) {
                            return !modifiers[keyModifier];
                        }).map(function(keyModifier) {
                            return "$event." + keyModifier + "Key";
                        }).join('||'));
                    } else keys.push(key);
                    return keys.length && (code += "if(!$event.type.indexOf('key')&&" + keys.map(genFilterCode).join('&&') + ")return null;"), genModifierCode && (code += genModifierCode), "function($event){" + code + (isMethodPath ? "return " + handler.value + "($event)" : isFunctionExpression ? "return (" + handler.value + ")($event)" : isFunctionInvocation ? "return " + handler.value : handler.value) + "}";
                }
                return isMethodPath || isFunctionExpression ? handler.value : "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}";
            }(events[name]);
            events[name] && events[name].dynamic ? dynamicHandlers += name + "," + handlerCode + "," : staticHandlers += "\"" + name + "\":" + handlerCode + ",";
        }
        return (staticHandlers = "{" + staticHandlers.slice(0, -1) + "}", dynamicHandlers) ? prefix + "_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])" : prefix + staticHandlers;
    }
    function genFilterCode(key) {
        var keyVal = parseInt(key, 10);
        if (keyVal) return "$event.keyCode!==" + keyVal;
        var keyCode = keyCodes[key], keyName = keyNames[key];
        return "_k($event.keyCode," + JSON.stringify(key) + "," + JSON.stringify(keyCode) + ",$event.key," + JSON.stringify(keyName) + ")";
    }
    var baseDirectives = {
        on: function(el, dir) {
            dir.modifiers && warn("v-on without argument does not support modifiers."), el.wrapListeners = function(code) {
                return "_g(" + code + "," + dir.value + ")";
            };
        },
        bind: function(el, dir) {
            el.wrapData = function(code) {
                return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
            };
        },
        cloak: noop
    }, CodegenState = function(options) {
        this.options = options, this.warn = options.warn || baseWarn, this.transforms = pluckModuleFunction(options.modules, 'transformCode'), this.dataGenFns = pluckModuleFunction(options.modules, 'genData'), this.directives = extend(extend({}, baseDirectives), options.directives);
        var isReservedTag = options.isReservedTag || no;
        this.maybeComponent = function(el) {
            return !!el.component || !isReservedTag(el.tag);
        }, this.onceId = 0, this.staticRenderFns = [], this.pre = !1;
    };
    function generate(ast, options) {
        var state = new CodegenState(options);
        return {
            render: "with(this){return " + (ast ? genElement(ast, state) : '_c("div")') + "}",
            staticRenderFns: state.staticRenderFns
        };
    }
    function genElement(el, state) {
        if (el.parent && (el.pre = el.pre || el.parent.pre), el.staticRoot && !el.staticProcessed) return genStatic(el, state);
        if (el.once && !el.onceProcessed) return genOnce(el, state);
        if (el.for && !el.forProcessed) return genFor(el, state);
        if (el.if && !el.ifProcessed) return genIf(el, state);
        if ('template' === el.tag && !el.slotTarget && !state.pre) return genChildren(el, state) || 'void 0';
        if ('slot' === el.tag) return el1 = el, state1 = state, res = "_t(" + (el1.slotName || '"default"') + ((children = genChildren(el1, state1)) ? "," + children : ''), attrs = el1.attrs || el1.dynamicAttrs ? genProps((el1.attrs || []).concat(el1.dynamicAttrs || []).map(function(attr) {
            return {
                name: camelize(attr.name),
                value: attr.value,
                dynamic: attr.dynamic
            };
        })) : null, bind$$1 = el1.attrsMap['v-bind'], (attrs || bind$$1) && !children && (res += ",null"), attrs && (res += "," + attrs), bind$$1 && (res += (attrs ? '' : ',null') + "," + bind$$1), res + ')';
        if (el.component) componentName = el.component, el2 = el, state2 = state, children1 = el2.inlineTemplate ? null : genChildren(el2, state2, !0), code = "_c(" + componentName + "," + genData$2(el2, state2) + (children1 ? "," + children1 : '') + ")";
        else {
            (!el.plain || el.pre && state.maybeComponent(el)) && (data = genData$2(el, state));
            var el1, state1, children, res, attrs, bind$$1, code, componentName, el2, state2, children1, data, children2 = el.inlineTemplate ? null : genChildren(el, state, !0);
            code = "_c('" + el.tag + "'" + (data ? "," + data : '') + (children2 ? "," + children2 : '') + ")";
        }
        for(var i = 0; i < state.transforms.length; i++)code = state.transforms[i](el, code);
        return code;
    }
    function genStatic(el, state) {
        el.staticProcessed = !0;
        var originalPreState = state.pre;
        return el.pre && (state.pre = el.pre), state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}"), state.pre = originalPreState, "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
    }
    function genOnce(el, state) {
        if (el.onceProcessed = !0, el.if && !el.ifProcessed) return genIf(el, state);
        if (!el.staticInFor) return genStatic(el, state);
        for(var key = '', parent = el.parent; parent;){
            if (parent.for) {
                key = parent.key;
                break;
            }
            parent = parent.parent;
        }
        return key ? "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")" : (state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']), genElement(el, state));
    }
    function genIf(el, state, altGen, altEmpty) {
        return el.ifProcessed = !0, function genIfConditions(conditions, state, altGen, altEmpty) {
            if (!conditions.length) return altEmpty || '_e()';
            var condition = conditions.shift();
            if (condition.exp) return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
            return "" + genTernaryExp(condition.block);
            function genTernaryExp(el) {
                return altGen ? altGen(el, state) : el.once ? genOnce(el, state) : genElement(el, state);
            }
        }(el.ifConditions.slice(), state, altGen, altEmpty);
    }
    function genFor(el, state, altGen, altHelper) {
        var exp = el.for, alias = el.alias, iterator1 = el.iterator1 ? "," + el.iterator1 : '', iterator2 = el.iterator2 ? "," + el.iterator2 : '';
        return state.maybeComponent(el) && 'slot' !== el.tag && 'template' !== el.tag && !el.key && state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + '">: component lists rendered with v-for should have explicit keys. See https://vuejs.org/guide/list.html#key for more info.', el.rawAttrsMap['v-for'], !0), el.forProcessed = !0, (altHelper || '_l') + "((" + exp + "),function(" + alias + iterator1 + iterator2 + "){return " + (altGen || genElement)(el, state) + '})';
    }
    function genData$2(el, state) {
        var data = '{', dirs = function(el, state) {
            var i, l, dir, needRuntime, dirs = el.directives;
            if (dirs) {
                var res = 'directives:[', hasRuntime = !1;
                for(i = 0, l = dirs.length; i < l; i++){
                    dir = dirs[i], needRuntime = !0;
                    var gen = state.directives[dir.name];
                    gen && (needRuntime = !!gen(el, dir, state.warn)), needRuntime && (hasRuntime = !0, res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value) : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},");
                }
                if (hasRuntime) return res.slice(0, -1) + ']';
            }
        }(el, state);
        dirs && (data += dirs + ','), el.key && (data += "key:" + el.key + ","), el.ref && (data += "ref:" + el.ref + ","), el.refInFor && (data += "refInFor:true,"), el.pre && (data += "pre:true,"), el.component && (data += "tag:\"" + el.tag + "\",");
        for(var i = 0; i < state.dataGenFns.length; i++)data += state.dataGenFns[i](el);
        if (el.attrs && (data += "attrs:" + genProps(el.attrs) + ","), el.props && (data += "domProps:" + genProps(el.props) + ","), el.events && (data += genHandlers(el.events, !1) + ","), el.nativeEvents && (data += genHandlers(el.nativeEvents, !0) + ","), el.slotTarget && !el.slotScope && (data += "slot:" + el.slotTarget + ","), el.scopedSlots && (data += function(el, slots, state) {
            var needsForceUpdate = el.for || Object.keys(slots).some(function(key) {
                var slot = slots[key];
                return slot.slotTargetDynamic || slot.if || slot.for || function containsSlotChild(el) {
                    return 1 === el.type && ('slot' === el.tag || el.children.some(containsSlotChild));
                }(slot);
            }), needsKey = !!el.if;
            if (!needsForceUpdate) for(var parent = el.parent; parent;){
                if (parent.slotScope && parent.slotScope !== emptySlotScopeToken || parent.for) {
                    needsForceUpdate = !0;
                    break;
                }
                parent.if && (needsKey = !0), parent = parent.parent;
            }
            var generatedSlots = Object.keys(slots).map(function(key) {
                return function genScopedSlot(el, state) {
                    var isLegacySyntax = el.attrsMap['slot-scope'];
                    if (el.if && !el.ifProcessed && !isLegacySyntax) return genIf(el, state, genScopedSlot, "null");
                    if (el.for && !el.forProcessed) return genFor(el, state, genScopedSlot);
                    var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope), fn = "function(" + slotScope + "){return " + ('template' === el.tag ? el.if && isLegacySyntax ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined" : genChildren(el, state) || 'undefined' : genElement(el, state)) + "}";
                    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + (slotScope ? "" : ",proxy:true") + "}";
                }(slots[key], state);
            }).join(',');
            return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + function(str) {
                for(var hash = 5381, i = str.length; i;)hash = 33 * hash ^ str.charCodeAt(--i);
                return hash >>> 0;
            }(generatedSlots) : "") + ")";
        }(el, el.scopedSlots, state) + ","), el.model && (data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},"), el.inlineTemplate) {
            var inlineTemplate = function(el, state) {
                var ast = el.children[0];
                if ((1 !== el.children.length || 1 !== ast.type) && state.warn('Inline-template components must have exactly one child element.', {
                    start: el.start
                }), ast && 1 === ast.type) {
                    var inlineRenderFns = generate(ast, state.options);
                    return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns.map(function(code) {
                        return "function(){" + code + "}";
                    }).join(',') + "]}";
                }
            }(el, state);
            inlineTemplate && (data += inlineTemplate + ",");
        }
        return data = data.replace(/,$/, '') + '}', el.dynamicAttrs && (data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")"), el.wrapData && (data = el.wrapData(data)), el.wrapListeners && (data = el.wrapListeners(data)), data;
    }
    function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
        var children = el.children;
        if (children.length) {
            var el$1 = children[0];
            if (1 === children.length && el$1.for && 'template' !== el$1.tag && 'slot' !== el$1.tag) {
                var normalizationType = checkSkip ? state.maybeComponent(el$1) ? ",1" : ",0" : "";
                return "" + (altGenElement || genElement)(el$1, state) + normalizationType;
            }
            var normalizationType$1 = checkSkip ? function(children, maybeComponent) {
                for(var res = 0, i = 0; i < children.length; i++){
                    var el = children[i];
                    if (1 === el.type) {
                        if (needsNormalization(el) || el.ifConditions && el.ifConditions.some(function(c) {
                            return needsNormalization(c.block);
                        })) {
                            res = 2;
                            break;
                        }
                        (maybeComponent(el) || el.ifConditions && el.ifConditions.some(function(c) {
                            return maybeComponent(c.block);
                        })) && (res = 1);
                    }
                }
                return res;
            }(children, state.maybeComponent) : 0, gen = altGenNode || genNode;
            return "[" + children.map(function(c) {
                return gen(c, state);
            }).join(',') + "]" + (normalizationType$1 ? "," + normalizationType$1 : '');
        }
    }
    function needsNormalization(el) {
        return void 0 !== el.for || 'template' === el.tag || 'slot' === el.tag;
    }
    function genNode(node, state) {
        return 1 === node.type ? genElement(node, state) : 3 === node.type && node.isComment ? "_e(" + JSON.stringify(node.text) + ")" : "_v(" + (2 === node.type ? node.expression : transformSpecialNewlines(JSON.stringify(node.text))) + ")";
    }
    function genProps(props) {
        for(var staticProps = "", dynamicProps = "", i = 0; i < props.length; i++){
            var prop = props[i], value = transformSpecialNewlines(prop.value);
            prop.dynamic ? dynamicProps += prop.name + "," + value + "," : staticProps += "\"" + prop.name + "\":" + value + ",";
        }
        return (staticProps = "{" + staticProps.slice(0, -1) + "}", dynamicProps) ? "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])" : staticProps;
    }
    function transformSpecialNewlines(text) {
        return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
    }
    var prohibitedKeywordRE = RegExp('\\b' + "do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(',').join('\\b|\\b') + '\\b'), unaryOperatorsRE = RegExp('\\b' + 'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)'), stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
    function checkIdentifier(ident, type, text, warn, range) {
        if ('string' == typeof ident) try {
            Function("var " + ident + "=_");
        } catch (e) {
            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
        }
    }
    function checkExpression(exp, text, warn, range) {
        try {
            Function("return " + exp);
        } catch (e) {
            var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
            warn(keywordMatch ? 'avoid using JavaScript keyword as property name: "' + keywordMatch[0] + "\"\n  Raw expression: " + text.trim() : "invalid expression: " + e.message + " in\n\n    " + exp + "\n\n  Raw expression: " + text.trim() + "\n", range);
        }
    }
    function repeat$1(str, n) {
        var result = '';
        if (n > 0) for(; 1 & n && (result += str), !((n >>>= 1) <= 0);)str += str;
        return result;
    }
    function createFunction(code, errors) {
        try {
            return Function(code);
        } catch (err) {
            return errors.push({
                err: err,
                code: code
            }), noop;
        }
    }
    var ref$1 = (baseCompile = function(template, options) {
        var ast = function(template, options) {
            warn$2 = options.warn || baseWarn, platformIsPreTag = options.isPreTag || no, platformMustUseProp = options.mustUseProp || no, platformGetTagNamespace = options.getTagNamespace || no;
            var root, currentParent, isReservedTag = options.isReservedTag || no;
            maybeComponent = function(el) {
                return !!el.component || !isReservedTag(el.tag);
            }, transforms = pluckModuleFunction(options.modules, 'transformNode'), preTransforms = pluckModuleFunction(options.modules, 'preTransformNode'), postTransforms = pluckModuleFunction(options.modules, 'postTransformNode'), delimiters = options.delimiters;
            var stack = [], preserveWhitespace = !1 !== options.preserveWhitespace, whitespaceOption = options.whitespace, inVPre = !1, inPre = !1, warned = !1;
            function warnOnce(msg, range) {
                warned || (warned = !0, warn$2(msg, range));
            }
            function closeElement(element) {
                if (trimEndingWhitespace(element), inVPre || element.processed || (element = processElement(element, options)), stack.length || element === root || (root.if && (element.elseif || element.else) ? (checkRootConstraints(element), addIfCondition(root, {
                    exp: element.elseif,
                    block: element
                })) : warnOnce("Component template should contain exactly one root element. If you are using v-if on multiple elements, use v-else-if to chain them instead.", {
                    start: element.start
                })), currentParent && !element.forbidden) {
                    if (element.elseif || element.else) {
                        var el, prev;
                        el = element, (prev = function(children) {
                            for(var i = children.length; i--;){
                                if (1 === children[i].type) return children[i];
                                ' ' !== children[i].text && warn$2("text \"" + children[i].text.trim() + '" between v-if and v-else(-if) will be ignored.', children[i]), children.pop();
                            }
                        }(currentParent.children)) && prev.if ? addIfCondition(prev, {
                            exp: el.elseif,
                            block: el
                        }) : warn$2("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " used on element <" + el.tag + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
                    } else {
                        if (element.slotScope) {
                            var name = element.slotTarget || '"default"';
                            (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                        }
                        currentParent.children.push(element), element.parent = currentParent;
                    }
                }
                element.children = element.children.filter(function(c) {
                    return !c.slotScope;
                }), trimEndingWhitespace(element), element.pre && (inVPre = !1), platformIsPreTag(element.tag) && (inPre = !1);
                for(var i = 0; i < postTransforms.length; i++)postTransforms[i](element, options);
            }
            function trimEndingWhitespace(el) {
                if (!inPre) for(var lastNode; (lastNode = el.children[el.children.length - 1]) && 3 === lastNode.type && ' ' === lastNode.text;)el.children.pop();
            }
            function checkRootConstraints(el) {
                ('slot' === el.tag || 'template' === el.tag) && warnOnce("Cannot use <" + el.tag + "> as component root element because it may contain multiple nodes.", {
                    start: el.start
                }), el.attrsMap.hasOwnProperty('v-for') && warnOnce("Cannot use v-for on stateful component root element because it renders multiple elements.", el.rawAttrsMap['v-for']);
            }
            return function(html, options) {
                for(var last, lastTag, stack = [], expectHTML = options.expectHTML, isUnaryTag$$1 = options.isUnaryTag || no, canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no, index = 0; html;){
                    if (last = html, lastTag && isPlainTextElement(lastTag)) {
                        var endTagLength = 0, stackedTag = lastTag.toLowerCase(), reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i')), rest$1 = html.replace(reStackedTag, function(all, text, endTag) {
                            return endTagLength = endTag.length, isPlainTextElement(stackedTag) || 'noscript' === stackedTag || (text = text.replace(/<!\--([\s\S]*?)-->/g, '$1').replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1')), shouldIgnoreFirstNewline(stackedTag, text) && (text = text.slice(1)), options.chars && options.chars(text), '';
                        });
                        index += html.length - rest$1.length, html = rest$1, parseEndTag(stackedTag, index - endTagLength, index);
                    } else {
                        var textEnd = html.indexOf('<');
                        if (0 === textEnd) {
                            if (comment.test(html)) {
                                var commentEnd = html.indexOf('-->');
                                if (commentEnd >= 0) {
                                    options.shouldKeepComment && options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3), advance(commentEnd + 3);
                                    continue;
                                }
                            }
                            if (conditionalComment.test(html)) {
                                var conditionalEnd = html.indexOf(']>');
                                if (conditionalEnd >= 0) {
                                    advance(conditionalEnd + 2);
                                    continue;
                                }
                            }
                            var doctypeMatch = html.match(doctype);
                            if (doctypeMatch) {
                                advance(doctypeMatch[0].length);
                                continue;
                            }
                            var endTagMatch = html.match(endTag);
                            if (endTagMatch) {
                                var curIndex = index;
                                advance(endTagMatch[0].length), parseEndTag(endTagMatch[1], curIndex, index);
                                continue;
                            }
                            var startTagMatch = function() {
                                var start = html.match(startTagOpen);
                                if (start) {
                                    var end, attr, match = {
                                        tagName: start[1],
                                        attrs: [],
                                        start: index
                                    };
                                    for(advance(start[0].length); !(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute));)attr.start = index, advance(attr[0].length), attr.end = index, match.attrs.push(attr);
                                    if (end) return match.unarySlash = end[1], advance(end[0].length), match.end = index, match;
                                }
                            }();
                            if (startTagMatch) {
                                (function(match) {
                                    var tagName = match.tagName, unarySlash = match.unarySlash;
                                    expectHTML && ('p' === lastTag && isNonPhrasingTag(tagName) && parseEndTag(lastTag), canBeLeftOpenTag$$1(tagName) && lastTag === tagName && parseEndTag(tagName));
                                    for(var unary = isUnaryTag$$1(tagName) || !!unarySlash, l = match.attrs.length, attrs = Array(l), i = 0; i < l; i++){
                                        var args = match.attrs[i], value = args[3] || args[4] || args[5] || '', shouldDecodeNewlines = 'a' === tagName && 'href' === args[1] ? options.shouldDecodeNewlinesForHref : options.shouldDecodeNewlines;
                                        attrs[i] = {
                                            name: args[1],
                                            value: value.replace(shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr, function(match) {
                                                return decodingMap[match];
                                            })
                                        }, options.outputSourceRange && (attrs[i].start = args.start + args[0].match(/^\s*/).length, attrs[i].end = args.end);
                                    }
                                    unary || (stack.push({
                                        tag: tagName,
                                        lowerCasedTag: tagName.toLowerCase(),
                                        attrs: attrs,
                                        start: match.start,
                                        end: match.end
                                    }), lastTag = tagName), options.start && options.start(tagName, attrs, unary, match.start, match.end);
                                })(startTagMatch), shouldIgnoreFirstNewline(startTagMatch.tagName, html) && advance(1);
                                continue;
                            }
                        }
                        var text = void 0, rest = void 0, next = void 0;
                        if (textEnd >= 0) {
                            for(rest = html.slice(textEnd); !endTag.test(rest) && !startTagOpen.test(rest) && !comment.test(rest) && !conditionalComment.test(rest) && !((next = rest.indexOf('<', 1)) < 0);)textEnd += next, rest = html.slice(textEnd);
                            text = html.substring(0, textEnd);
                        }
                        textEnd < 0 && (text = html), text && advance(text.length), options.chars && text && options.chars(text, index - text.length, index);
                    }
                    if (html === last) {
                        options.chars && options.chars(html), !stack.length && options.warn && options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
                            start: index + html.length
                        });
                        break;
                    }
                }
                function advance(n) {
                    index += n, html = html.substring(n);
                }
                function parseEndTag(tagName, start, end) {
                    var pos, lowerCasedTagName;
                    if (null == start && (start = index), null == end && (end = index), tagName) for(lowerCasedTagName = tagName.toLowerCase(), pos = stack.length - 1; pos >= 0 && stack[pos].lowerCasedTag !== lowerCasedTagName; pos--);
                    else pos = 0;
                    if (pos >= 0) {
                        for(var i = stack.length - 1; i >= pos; i--)(i > pos || !tagName && options.warn) && options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
                            start: stack[i].start,
                            end: stack[i].end
                        }), options.end && options.end(stack[i].tag, start, end);
                        stack.length = pos, lastTag = pos && stack[pos - 1].tag;
                    } else 'br' === lowerCasedTagName ? options.start && options.start(tagName, [], !0, start, end) : 'p' === lowerCasedTagName && (options.start && options.start(tagName, [], !1, start, end), options.end && options.end(tagName, start, end));
                }
                parseEndTag();
            }(template, {
                warn: warn$2,
                expectHTML: options.expectHTML,
                isUnaryTag: options.isUnaryTag,
                canBeLeftOpenTag: options.canBeLeftOpenTag,
                shouldDecodeNewlines: options.shouldDecodeNewlines,
                shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
                shouldKeepComment: options.comments,
                outputSourceRange: options.outputSourceRange,
                start: function(tag, attrs, unary, start$1, end) {
                    var el, el1, el2, ns = currentParent && currentParent.ns || platformGetTagNamespace(tag);
                    isIE && 'svg' === ns && (attrs = function(attrs) {
                        for(var res = [], i = 0; i < attrs.length; i++){
                            var attr = attrs[i];
                            ieNSBug.test(attr.name) || (attr.name = attr.name.replace(ieNSPrefix, ''), res.push(attr));
                        }
                        return res;
                    }(attrs));
                    var element = createASTElement(tag, attrs, currentParent);
                    ns && (element.ns = ns), options.outputSourceRange && (element.start = start$1, element.end = end, element.rawAttrsMap = element.attrsList.reduce(function(cumulated, attr) {
                        return cumulated[attr.name] = attr, cumulated;
                    }, {})), attrs.forEach(function(attr) {
                        invalidAttributeRE.test(attr.name) && warn$2("Invalid dynamic argument expression: attribute names cannot contain spaces, quotes, <, >, / or =.", {
                            start: attr.start + attr.name.indexOf("["),
                            end: attr.start + attr.name.length
                        });
                    }), 'style' !== (el = element).tag && ('script' !== el.tag || el.attrsMap.type && 'text/javascript' !== el.attrsMap.type) || isServerRendering() || (element.forbidden = !0, warn$2("Templates should only be responsible for mapping the state to the UI. Avoid placing tags with side-effects in your templates, such as <" + tag + ">, as they will not be parsed.", {
                        start: element.start
                    }));
                    for(var i = 0; i < preTransforms.length; i++)element = preTransforms[i](element, options) || element;
                    !inVPre && (null != getAndRemoveAttr(el1 = element, 'v-pre') && (el1.pre = !0), element.pre && (inVPre = !0)), platformIsPreTag(element.tag) && (inPre = !0), inVPre ? function(el) {
                        var list = el.attrsList, len = list.length;
                        if (len) for(var attrs = el.attrs = Array(len), i = 0; i < len; i++)attrs[i] = {
                            name: list[i].name,
                            value: JSON.stringify(list[i].value)
                        }, null != list[i].start && (attrs[i].start = list[i].start, attrs[i].end = list[i].end);
                        else el.pre || (el.plain = !0);
                    }(element) : element.processed || (processFor(element), function(el) {
                        var exp = getAndRemoveAttr(el, 'v-if');
                        if (exp) el.if = exp, addIfCondition(el, {
                            exp: exp,
                            block: el
                        });
                        else {
                            null != getAndRemoveAttr(el, 'v-else') && (el.else = !0);
                            var elseif = getAndRemoveAttr(el, 'v-else-if');
                            elseif && (el.elseif = elseif);
                        }
                    }(element), null != getAndRemoveAttr(el2 = element, 'v-once') && (el2.once = !0)), root || checkRootConstraints(root = element), unary ? closeElement(element) : (currentParent = element, stack.push(element));
                },
                end: function(tag, start, end$1) {
                    var element = stack[stack.length - 1];
                    stack.length -= 1, currentParent = stack[stack.length - 1], options.outputSourceRange && (element.end = end$1), closeElement(element);
                },
                chars: function(text, start, end) {
                    if (!currentParent) {
                        text === template ? warnOnce('Component template requires a root element, rather than just text.', {
                            start: start
                        }) : (text = text.trim()) && warnOnce("text \"" + text + "\" outside root element will be ignored.", {
                            start: start
                        });
                        return;
                    }
                    if (!isIE || 'textarea' !== currentParent.tag || currentParent.attrsMap.placeholder !== text) {
                        var el, res, child, children = currentParent.children;
                        (text = inPre || text.trim() ? 'script' === (el = currentParent).tag || 'style' === el.tag ? text : decodeHTMLCached(text) : children.length ? whitespaceOption ? 'condense' === whitespaceOption && lineBreakRE.test(text) ? '' : ' ' : preserveWhitespace ? ' ' : '' : '') && (inPre || 'condense' !== whitespaceOption || (text = text.replace(whitespaceRE$1, ' ')), !inVPre && ' ' !== text && (res = parseText(text, delimiters)) ? child = {
                            type: 2,
                            expression: res.expression,
                            tokens: res.tokens,
                            text: text
                        } : ' ' === text && children.length && ' ' === children[children.length - 1].text || (child = {
                            type: 3,
                            text: text
                        }), child && (options.outputSourceRange && (child.start = start, child.end = end), children.push(child)));
                    }
                },
                comment: function(text, start, end) {
                    if (currentParent) {
                        var child = {
                            type: 3,
                            text: text,
                            isComment: !0
                        };
                        options.outputSourceRange && (child.start = start, child.end = end), currentParent.children.push(child);
                    }
                }
            }), root;
        }(template.trim(), options);
        !1 !== options.optimize && ast && (isStaticKey = genStaticKeysCached(options.staticKeys || ''), isPlatformReservedTag = options.isReservedTag || no, function markStatic$1(node) {
            if (node.static = 2 !== node.type && (3 === node.type || !!(node.pre || !node.hasBindings && !node.if && !node.for && !isBuiltInTag(node.tag) && isPlatformReservedTag(node.tag) && !function(node) {
                for(; node.parent && 'template' === (node = node.parent).tag;)if (node.for) return !0;
                return !1;
            }(node) && Object.keys(node).every(isStaticKey))), 1 === node.type && (isPlatformReservedTag(node.tag) || 'slot' === node.tag || null != node.attrsMap['inline-template'])) {
                for(var i = 0, l = node.children.length; i < l; i++){
                    var child = node.children[i];
                    markStatic$1(child), child.static || (node.static = !1);
                }
                if (node.ifConditions) for(var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++){
                    var block = node.ifConditions[i$1].block;
                    markStatic$1(block), block.static || (node.static = !1);
                }
            }
        }(ast), function markStaticRoots(node, isInFor) {
            if (1 === node.type) {
                if ((node.static || node.once) && (node.staticInFor = isInFor), node.static && node.children.length && !(1 === node.children.length && 3 === node.children[0].type)) {
                    node.staticRoot = !0;
                    return;
                }
                if (node.staticRoot = !1, node.children) for(var i = 0, l = node.children.length; i < l; i++)markStaticRoots(node.children[i], isInFor || !!node.for);
                if (node.ifConditions) for(var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++)markStaticRoots(node.ifConditions[i$1].block, isInFor);
            }
        }(ast, !1));
        var code = generate(ast, options);
        return {
            ast: ast,
            render: code.render,
            staticRenderFns: code.staticRenderFns
        };
    }, function(baseOptions) {
        var cache;
        function compile(template, options) {
            var ast, warn, finalOptions = Object.create(baseOptions), errors = [], tips = [], warn1 = function(msg, range, tip) {
                (tip ? tips : errors).push(msg);
            };
            if (options) {
                if (options.outputSourceRange) {
                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
                    warn1 = function(msg, range, tip) {
                        var data = {
                            msg: msg
                        };
                        range && (null != range.start && (data.start = range.start + leadingSpaceLength), null != range.end && (data.end = range.end + leadingSpaceLength)), (tip ? tips : errors).push(data);
                    };
                }
                for(var key in options.modules && (finalOptions.modules = (baseOptions.modules || []).concat(options.modules)), options.directives && (finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives)), options)'modules' !== key && 'directives' !== key && (finalOptions[key] = options[key]);
            }
            finalOptions.warn = warn1;
            var compiled = baseCompile(template.trim(), finalOptions);
            return ast = compiled.ast, warn = warn1, ast && function checkNode(node, warn) {
                if (1 === node.type) {
                    for(var name in node.attrsMap)if (dirRE.test(name)) {
                        var value = node.attrsMap[name];
                        if (value) {
                            var text, range = node.rawAttrsMap[name];
                            'v-for' === name ? (text = "v-for=\"" + value + "\"", checkExpression(node.for || '', text, warn, range), checkIdentifier(node.alias, 'v-for alias', text, warn, range), checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range), checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range)) : 'v-slot' === name || '#' === name[0] ? function(exp, text, warn, range) {
                                try {
                                    Function(exp, '');
                                } catch (e) {
                                    warn("invalid function parameter expression: " + e.message + " in\n\n    " + exp + "\n\n  Raw expression: " + text.trim() + "\n", range);
                                }
                            }(value, name + "=\"" + value + "\"", warn, range) : onRE.test(name) ? function(exp, text, warn, range) {
                                var stripped = exp.replace(stripStringRE, ''), keywordMatch = stripped.match(unaryOperatorsRE);
                                keywordMatch && '$' !== stripped.charAt(keywordMatch.index - 1) && warn('avoid using JavaScript unary operator as property name: "' + keywordMatch[0] + "\" in expression " + text.trim(), range), checkExpression(exp, text, warn, range);
                            }(value, name + "=\"" + value + "\"", warn, range) : checkExpression(value, name + "=\"" + value + "\"", warn, range);
                        }
                    }
                    if (node.children) for(var i = 0; i < node.children.length; i++)checkNode(node.children[i], warn);
                } else 2 === node.type && checkExpression(node.expression, node.text, warn, node);
            }(ast, warn), compiled.errors = errors, compiled.tips = tips, compiled;
        }
        return {
            compile: compile,
            compileToFunctions: (cache = Object.create(null), function(template, options, vm) {
                var warn$$1 = (options = extend({}, options)).warn || warn;
                delete options.warn;
                try {
                    Function('return 1');
                } catch (e) {
                    e.toString().match(/unsafe-eval|CSP/) && warn$$1("It seems you are using the standalone build of Vue.js in an environment with Content Security Policy that prohibits unsafe-eval. The template compiler cannot work in this environment. Consider relaxing the policy to allow unsafe-eval or pre-compiling your templates into render functions.");
                }
                var key = options.delimiters ? String(options.delimiters) + template : template;
                if (cache[key]) return cache[key];
                var compiled = compile(template, options);
                compiled.errors && compiled.errors.length && (options.outputSourceRange ? compiled.errors.forEach(function(e) {
                    warn$$1("Error compiling template:\n\n" + e.msg + "\n\n" + function(source, start, end) {
                        void 0 === start && (start = 0), void 0 === end && (end = source.length);
                        for(var lines = source.split(/\r?\n/), count = 0, res = [], i = 0; i < lines.length; i++)if ((count += lines[i].length + 1) >= start) {
                            for(var j = i - 2; j <= i + 2 || end > count; j++)if (!(j < 0) && !(j >= lines.length)) {
                                res.push("" + (j + 1) + repeat$1(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
                                var lineLength = lines[j].length;
                                if (j === i) {
                                    var pad = start - (count - lineLength) + 1, length = end > count ? lineLength - pad : end - start;
                                    res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
                                } else if (j > i) {
                                    if (end > count) {
                                        var length$1 = Math.min(end - count, lineLength);
                                        res.push("   |  " + repeat$1("^", length$1));
                                    }
                                    count += lineLength + 1;
                                }
                            }
                            break;
                        }
                        return res.join('\n');
                    }(template, e.start, e.end), vm);
                }) : warn$$1("Error compiling template:\n\n" + template + "\n\n" + compiled.errors.map(function(e) {
                    return "- " + e;
                }).join('\n') + '\n', vm)), compiled.tips && compiled.tips.length && (options.outputSourceRange ? compiled.tips.forEach(function(e) {
                    return tip(e.msg, vm);
                }) : compiled.tips.forEach(function(msg) {
                    return tip(msg, vm);
                }));
                var res = {}, fnGenErrors = [];
                return res.render = createFunction(compiled.render, fnGenErrors), res.staticRenderFns = compiled.staticRenderFns.map(function(code) {
                    return createFunction(code, fnGenErrors);
                }), compiled.errors && compiled.errors.length || !fnGenErrors.length || warn$$1("Failed to generate render function:\n\n" + fnGenErrors.map(function(ref) {
                    var err = ref.err, code = ref.code;
                    return err.toString() + " in\n\n" + code + "\n";
                }).join('\n'), vm), cache[key] = res;
            })
        };
    })(baseOptions);
    ref$1.compile;
    var compileToFunctions = ref$1.compileToFunctions;
    function getShouldDecode(href) {
        return (div = div || document.createElement('div')).innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>", div.innerHTML.indexOf('&#10;') > 0;
    }
    var shouldDecodeNewlines = !!inBrowser && getShouldDecode(!1), shouldDecodeNewlinesForHref = !!inBrowser && getShouldDecode(!0), idToTemplate = cached(function(id) {
        var el = query(id);
        return el && el.innerHTML;
    }), mount = Vue7.prototype.$mount;
    return Vue7.prototype.$mount = function(el, hydrating) {
        if ((el = el && query(el)) === document.body || el === document.documentElement) return warn("Do not mount Vue to <html> or <body> - mount to normal elements instead."), this;
        var options = this.$options;
        if (!options.render) {
            var template = options.template;
            if (template) {
                if ('string' == typeof template) '#' !== template.charAt(0) || (template = idToTemplate(template)) || warn("Template element not found or is empty: " + options.template, this);
                else {
                    if (!template.nodeType) return warn('invalid template option:' + template, this), this;
                    template = template.innerHTML;
                }
            } else el && (template = function(el) {
                if (el.outerHTML) return el.outerHTML;
                var container = document.createElement('div');
                return container.appendChild(el.cloneNode(!0)), container.innerHTML;
            }(el));
            if (template) {
                config.performance && mark && mark('compile');
                var ref = compileToFunctions(template, {
                    outputSourceRange: !0,
                    shouldDecodeNewlines: shouldDecodeNewlines,
                    shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
                    delimiters: options.delimiters,
                    comments: options.comments
                }, this), render = ref.render, staticRenderFns = ref.staticRenderFns;
                options.render = render, options.staticRenderFns = staticRenderFns, config.performance && mark && (mark('compile end'), measure("vue " + this._name + " compile", 'compile', 'compile end'));
            }
        }
        return mount.call(this, el, hydrating);
    }, Vue7.compile = compileToFunctions, Vue7;
});