text: /*!
   * Vue.js v2.6.10
   * (c) 2014-2019 Evan You
   * Released under the MIT License.
   */
  (function (global, factory) {
  	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  		typeof define === 'function' && define.amd ? define(factory) :
  			(global = global || self, global.Vue = factory());
  }(this, function () { 'use strict';
  	
  	/*  */
  	
  	var emptyObject = Object.freeze({});
  	
  	// These helpers produce better VM code in JS engines due to their
  	// explicitness and function inlining.
  	function isUndef (v) {
  		return v === undefined || v === null
  	}
  	
  	function isDef (v) {
  		return v !== undefined && v !== null
  	}
  	
  	function isTrue (v) {
  		return v === true
  	}
  	
  	function isFalse (v) {
  		return v === false
  	}
  	
  	/**
  	 * Check if value is primitive.
  	 */
  	function isPrimitive (value) {
  		return (
  			typeof value === 'string' ||
  			typeof value === 'number' ||
  			// $flow-disable-line
  			typeof value === 'symbol' ||
  			typeof value === 'boolean'
  		)
  	}
  	
  	/**
  	 * Quick object check - this is primarily used to tell
  	 * Objects from primitive values when we know the value
  	 * is a JSON-compliant type.
  	 */
  	function isObject (obj) {
  		return obj !== null && typeof obj === 'object'
  	}
  	
  	/**
  	 * Get the raw type string of a value, e.g., [object Object].
  	 */
  	var _toString = Object.prototype.toString;
  	
  	function toRawType (value) {
  		return _toString.call(value).slice(8, -1)
  	}
  	
  	/**
  	 * Strict object type check. Only returns true
  	 * for plain JavaScript objects.
  	 */
  	function isPlainObject (obj) {
  		return _toString.call(obj) === '[object Object]'
  	}
  	
  	function isRegExp (v) {
  		return _toString.call(v) === '[object RegExp]'
  	}
  	
  	/**
  	 * Check if val is a valid array index.
  	 */
  	function isValidArrayIndex (val) {
  		var n = parseFloat(String(val));
  		return n >= 0 && Math.floor(n) === n && isFinite(val)
  	}
  	
  	function isPromise (val) {
  		return (
  			isDef(val) &&
  			typeof val.then === 'function' &&
  			typeof val.catch === 'function'
  		)
  	}
  	
  	/**
  	 * Convert a value to a string that is actually rendered.
  	 */
  	function toString (val) {
  		return val == null
  			? ''
  			: Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
  				? JSON.stringify(val, null, 2)
  				: String(val)
  	}
  	
  	/**
  	 * Convert an input value to a number for persistence.
  	 * If the conversion fails, return original string.
  	 */
  	function toNumber (val) {
  		var n = parseFloat(val);
  		return isNaN(n) ? val : n
  	}
  	
  	/**
  	 * Make a map and return a function for checking if a key
  	 * is in that map.
  	 */
  	function makeMap (
  		str,
  		expectsLowerCase
  	) {
  		var map = Object.create(null);
  		var list = str.split(',');
  		for (var i = 0; i < list.length; i++) {
  			map[list[i]] = true;
  		}
  		return expectsLowerCase
  			? function (val) { return map[val.toLowerCase()]; }
  			: function (val) { return map[val]; }
  	}
  	
  	/**
  	 * Check if a tag is a built-in tag.
  	 */
  	var isBuiltInTag = makeMap('slot,component', true);
  	
  	/**
  	 * Check if an attribute is a reserved attribute.
  	 */
  	var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
  	
  	/**
  	 * Remove an item from an array.
  	 */
  	function remove (arr, item) {
  		if (arr.length) {
  			var index = arr.indexOf(item);
  			if (index > -1) {
  				return arr.splice(index, 1)
  			}
  		}
  	}
  	
  	/**
  	 * Check whether an object has the property.
  	 */
  	var hasOwnProperty = Object.prototype.hasOwnProperty;
  	function hasOwn (obj, key) {
  		return hasOwnProperty.call(obj, key)
  	}
  	
  	/**
  	 * Create a cached version of a pure function.
  	 */
  	function cached (fn) {
  		var cache = Object.create(null);
  		return (function cachedFn (str) {
  			var hit = cache[str];
  			return hit || (cache[str] = fn(str))
  		})
  	}
  	
  	/**
  	 * Camelize a hyphen-delimited string.
  	 */
  	var camelizeRE = /-(\w)/g;
  	var camelize = cached(function (str) {
  		return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
  	});
  	
  	/**
  	 * Capitalize a string.
  	 */
  	var capitalize = cached(function (str) {
  		return str.charAt(0).toUpperCase() + str.slice(1)
  	});
  	
  	/**
  	 * Hyphenate a camelCase string.
  	 */
  	var hyphenateRE = /\B([A-Z])/g;
  	var hyphenate = cached(function (str) {
  		return str.replace(hyphenateRE, '-$1').toLowerCase()
  	});
  	
  	/**
  	 * Simple bind polyfill for environments that do not support it,
  	 * e.g., PhantomJS 1.x. Technically, we don't need this anymore
  	 * since native bind is now performant enough in most browsers.
  	 * But removing it would mean breaking code that was able to run in
  	 * PhantomJS 1.x, so this must be kept for backward compatibility.
  	 */
  	
  	/* istanbul ignore next */
  	function polyfillBind (fn, ctx) {
  		function boundFn (a) {
  			var l = arguments.length;
  			return l
  				? l > 1
  					? fn.apply(ctx, arguments)
  					: fn.call(ctx, a)
  				: fn.call(ctx)
  		}
  		
  		boundFn._length = fn.length;
  		return boundFn
  	}
  	
  	function nativeBind (fn, ctx) {
  		return fn.bind(ctx)
  	}
  	
  	var bind = Function.prototype.bind
  		? nativeBind
  		: polyfillBind;
  	
  	/**
  	 * Convert an Array-like object to a real Array.
  	 */
  	function toArray (list, start) {
  		start = start || 0;
  		var i = list.length - start;
  		var ret = new Array(i);
  		while (i--) {
  			ret[i] = list[i + start];
  		}
  		return ret
  	}
  	
  	/**
  	 * Mix properties into target object.
  	 */
  	function extend (to, _from) {
  		for (var key in _from) {
  			to[key] = _from[key];
  		}
  		return to
  	}
  	
  	/**
  	 * Merge an Array of Objects into a single Object.
  	 */
  	function toObject (arr) {
  		var res = {};
  		for (var i = 0; i < arr.length; i++) {
  			if (arr[i]) {
  				extend(res, arr[i]);
  			}
  		}
  		return res
  	}
  	
  	/* eslint-disable no-unused-vars */
  	
  	/**
  	 * Perform no operation.
  	 * Stubbing args to make Flow happy without leaving useless transpiled code
  	 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  	 */
  	function noop (a, b, c) {}
  	
  	/**
  	 * Always return false.
  	 */
  	var no = function (a, b, c) { return false; };
  	
  	/* eslint-enable no-unused-vars */
  	
  	/**
  	 * Return the same value.
  	 */
  	var identity = function (_) { return _; };
  	
  	/**
  	 * Generate a string containing static keys from compiler modules.
  	 */
  	function genStaticKeys (modules) {
  		return modules.reduce(function (keys, m) {
  			return keys.concat(m.staticKeys || [])
  		}, []).join(',')
  	}
  	
  	/**
  	 * Check if two values are loosely equal - that is,
  	 * if they are plain objects, do they have the same shape?
  	 */
  	function looseEqual (a, b) {
  		if (a === b) { return true }
  		var isObjectA = isObject(a);
  		var isObjectB = isObject(b);
  		if (isObjectA && isObjectB) {
  			try {
  				var isArrayA = Array.isArray(a);
  				var isArrayB = Array.isArray(b);
  				if (isArrayA && isArrayB) {
  					return a.length === b.length && a.every(function (e, i) {
  						return looseEqual(e, b[i])
  					})
  				} else if (a instanceof Date && b instanceof Date) {
  					return a.getTime() === b.getTime()
  				} else if (!isArrayA && !isArrayB) {
  					var keysA = Object.keys(a);
  					var keysB = Object.keys(b);
  					return keysA.length === keysB.length && keysA.every(function (key) {
  						return looseEqual(a[key], b[key])
  					})
  				} else {
  					/* istanbul ignore next */
  					return false
  				}
  			} catch (e) {
  				/* istanbul ignore next */
  				return false
  			}
  		} else if (!isObjectA && !isObjectB) {
  			return String(a) === String(b)
  		} else {
  			return false
  		}
  	}
  	
  	/**
  	 * Return the first index at which a loosely equal value can be
  	 * found in the array (if value is a plain object, the array must
  	 * contain an object of the same shape), or -1 if it is not present.
  	 */
  	function looseIndexOf (arr, val) {
  		for (var i = 0; i < arr.length; i++) {
  			if (looseEqual(arr[i], val)) { return i }
  		}
  		return -1
  	}
  	
  	/**
  	 * Ensure a function is called only once.
  	 */
  	function once (fn) {
  		var called = false;
  		return function () {
  			if (!called) {
  				called = true;
  				fn.apply(this, arguments);
  			}
  		}
  	}
  	
  	var SSR_ATTR = 'data-server-rendered';
  	
  	var ASSET_TYPES = [
  		'component',
  		'directive',
  		'filter'
  	];
  	
  	var LIFECYCLE_HOOKS = [
  		'beforeCreate',
  		'created',
  		'beforeMount',
  		'mounted',
  		'beforeUpdate',
  		'updated',
  		'beforeDestroy',
  		'destroyed',
  		'activated',
  		'deactivated',
  		'errorCaptured',
  		'serverPrefetch'
  	];
  	
  	/*  */
  	
  	
  	
  	var config = ({
  		/**
  		 * Option merge strategies (used in core/util/options)
  		 */
  		// $flow-disable-line
  		optionMergeStrategies: Object.create(null),
  		
  		/**
  		 * Whether to suppress warnings.
  		 */
  		silent: false,
  		
  		/**
  		 * Show production mode tip message on boot?
  		 */
  		productionTip: "development" !== 'production',
  		
  		/**
  		 * Whether to enable devtools
  		 */
  		devtools: "development" !== 'production',
  		
  		/**
  		 * Whether to record perf
  		 */
  		performance: false,
  		
  		/**
  		 * Error handler for watcher errors
  		 */
  		errorHandler: null,
  		
  		/**
  		 * Warn handler for watcher warns
  		 */
  		warnHandler: null,
  		
  		/**
  		 * Ignore certain custom elements
  		 */
  		ignoredElements: [],
  		
  		/**
  		 * Custom user key aliases for v-on
  		 */
  		// $flow-disable-line
  		keyCodes: Object.create(null),
  		
  		/**
  		 * Check if a tag is reserved so that it cannot be registered as a
  		 * component. This is platform-dependent and may be overwritten.
  		 */
  		isReservedTag: no,
  		
  		/**
  		 * Check if an attribute is reserved so that it cannot be used as a component
  		 * prop. This is platform-dependent and may be overwritten.
  		 */
  		isReservedAttr: no,
  		
  		/**
  		 * Check if a tag is an unknown element.
  		 * Platform-dependent.
  		 */
  		isUnknownElement: no,
  		
  		/**
  		 * Get the namespace of an element
  		 */
  		getTagNamespace: noop,
  		
  		/**
  		 * Parse the real tag name for the specific platform.
  		 */
  		parsePlatformTagName: identity,
  		
  		/**
  		 * Check if an attribute must be bound using property, e.g. value
  		 * Platform-dependent.
  		 */
  		mustUseProp: no,
  		
  		/**
  		 * Perform updates asynchronously. Intended to be used by Vue Test Utils
  		 * This will significantly reduce performance if set to false.
  		 */
  		async: true,
  		
  		/**
  		 * Exposed for legacy reasons
  		 */
  		_lifecycleHooks: LIFECYCLE_HOOKS
  	});
  	
  	/*  */
  	
  	/**
  	 * unicode letters used for parsing html tags, component names and property paths.
  	 * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  	 * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  	 */
  	var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
  	
  	/**
  	 * Check if a string starts with $ or _
  	 */
  	function isReserved (str) {
  		var c = (str + '').charCodeAt(0);
  		return c === 0x24 || c === 0x5F
  	}
  	
  	/**
  	 * Define a property.
  	 */
  	function def (obj, key, val, enumerable) {
  		Object.defineProperty(obj, key, {
  			value: val,
  			enumerable: !!enumerable,
  			writable: true,
  			configurable: true
  		});
  	}
  	
  	/**
  	 * Parse simple path.
  	 */
  	var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
  	function parsePath (path) {
  		if (bailRE.test(path)) {
  			return
  		}
  		var segments = path.split('.');
  		return function (obj) {
  			for (var i = 0; i < segments.length; i++) {
  				if (!obj) { return }
  				obj = obj[segments[i]];
  			}
  			return obj
  		}
  	}
  	
  	/*  */
  	
  	// can we use __proto__?
  	var hasProto = '__proto__' in {};
  	
  	// Browser environment sniffing
  	var inBrowser = typeof window !== 'undefined';
  	var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
  	var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
  	var UA = inBrowser && window.navigator.userAgent.toLowerCase();
  	var isIE = UA && /msie|trident/.test(UA);
  	var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
  	var isEdge = UA && UA.indexOf('edge/') > 0;
  	var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
  	var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
  	var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
  	var isPhantomJS = UA && /phantomjs/.test(UA);
  	var isFF = UA && UA.match(/firefox\/(\d+)/);
  	
  	// Firefox has a "watch" function on Object.prototype...
  	var nativeWatch = ({}).watch;
  	
  	var supportsPassive = false;
  	if (inBrowser) {
  		try {
  			var opts = {};
  			Object.defineProperty(opts, 'passive', ({
  				get: function get () {
  					/* istanbul ignore next */
  					supportsPassive = true;
  				}
  			})); // https://github.com/facebook/flow/issues/285
  			window.addEventListener('test-passive', null, opts);
  		} catch (e) {}
  	}
  	
  	// this needs to be lazy-evaled because vue may be required before
  	// vue-server-renderer can set VUE_ENV
  	var _isServer;
  	var isServerRendering = function () {
  		if (_isServer === undefined) {
  			/* istanbul ignore if */
  			if (!inBrowser && !inWeex && typeof global !== 'undefined') {
  				// detect presence of vue-server-renderer and avoid
  				// Webpack shimming the process
  				_isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
  			} else {
  				_isServer = false;
  			}
  		}
  		return _isServer
  	};
  	
  	// detect devtools
  	var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
  	
  	/* istanbul ignore next */
  	function isNative (Ctor) {
  		return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
  	}
  	
  	var hasSymbol =
  		typeof Symbol !== 'undefined' && isNative(Symbol) &&
  		typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
  	
  	var _Set;
  	/* istanbul ignore if */ // $flow-disable-line
  	if (typeof Set !== 'undefined' && isNative(Set)) {
  		// use native Set when available.
  		_Set = Set;
  	} else {
  		// a non-standard Set polyfill that only works with primitive keys.
  		_Set = /*@__PURE__*/(function () {
  			function Set () {
  				this.set = Object.create(null);
  			}
  			Set.prototype.has = function has (key) {
  				return this.set[key] === true
  			};
  			Set.prototype.add = function add (key) {
  				this.set[key] = true;
  			};
  			Set.prototype.clear = function clear () {
  				this.set = Object.create(null);
  			};
  			
  			return Set;
  		}());
  	}
  	
  	/*  */
  	
  	var warn = noop;
  	var tip = noop;
  	var generateComponentTrace = (noop); // work around flow check
  	var formatComponentName = (noop);
  	
  	{
  		var hasConsole = typeof console !== 'undefined';
  		var classifyRE = /(?:^|[-_])(\w)/g;
  		var classify = function (str) { return str
  		.replace(classifyRE, function (c) { return c.toUpperCase(); })
  		.replace(/[-_]/g, ''); };
  		
  		warn = function (msg, vm) {
  			var trace = vm ? generateComponentTrace(vm) : '';
  			
  			if (config.warnHandler) {
  				config.warnHandler.call(null, msg, vm, trace);
  			} else if (hasConsole && (!config.silent)) {
  				console.error(("[Vue warn]: " + msg + trace));
  			}
  		};
  		
  		tip = function (msg, vm) {
  			if (hasConsole && (!config.silent)) {
  				console.warn("[Vue tip]: " + msg + (
  					vm ? generateComponentTrace(vm) : ''
  				));
  			}
  		};
  		
  		formatComponentName = function (vm, includeFile) {
  			if (vm.$root === vm) {
  				return '<Root>'
  			}
  			var options = typeof vm === 'function' && vm.cid != null
  				? vm.options
  				: vm._isVue
  					? vm.$options || vm.constructor.options
  					: vm;
  			var name = options.name || options._componentTag;
  			var file = options.__file;
  			if (!name && file) {
  				var match = file.match(/([^/\\]+)\.vue$/);
  				name = match && match[1];
  			}
  			
  			return (
  				(name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
  				(file && includeFile !== false ? (" at " + file) : '')
  			)
  		};
  		
  		var repeat = function (str, n) {
  			var res = '';
  			while (n) {
  				if (n % 2 === 1) { res += str; }
  				if (n > 1) { str += str; }
  				n >>= 1;
  			}
  			return res
  		};
  		
  		generateComponentTrace = function (vm) {
  			if (vm._isVue && vm.$parent) {
  				var tree = [];
  				var currentRecursiveSequence = 0;
  				while (vm) {
  					if (tree.length > 0) {
  						var last = tree[tree.length - 1];
  						if (last.constructor === vm.constructor) {
  							currentRecursiveSequence++;
  							vm = vm.$parent;
  							continue
  						} else if (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 ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
  					? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
  					: formatComponentName(vm))); })
  				.join('\n')
  			} else {
  				return ("\n\n(found in " + (formatComponentName(vm)) + ")")
  			}
  		};
  	}
  	
  	/*  */
  	
  	var uid = 0;
  	
  	/**
  	 * A dep is an observable that can have multiple
  	 * directives subscribing to it.
  	 */
  	var Dep = function Dep () {
  		this.id = uid++;
  		this.subs = [];
  	};
  	
  	Dep.prototype.addSub = function addSub (sub) {
  		this.subs.push(sub);
  	};
  	
  	Dep.prototype.removeSub = function removeSub (sub) {
  		remove(this.subs, sub);
  	};
  	
  	Dep.prototype.depend = function depend () {
  		if (Dep.target) {
  			Dep.target.addDep(this);
  		}
  	};
  	
  	Dep.prototype.notify = function notify () {
  		// stabilize the subscriber list first
  		var subs = this.subs.slice();
  		if (!config.async) {
  			// subs aren't sorted in scheduler if not running async
  			// we need to sort them now to make sure they fire in correct
  			// order
  			subs.sort(function (a, b) { return a.id - b.id; });
  		}
  		for (var i = 0, l = subs.length; i < l; i++) {
  			subs[i].update();
  		}
  	};
  	
  	// The current target watcher being evaluated.
  	// This is globally unique because only one watcher
  	// can be evaluated at a time.
  	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 VNode (
  		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 = undefined;
  		this.context = context;
  		this.fnContext = undefined;
  		this.fnOptions = undefined;
  		this.fnScopeId = undefined;
  		this.key = data && data.key;
  		this.componentOptions = componentOptions;
  		this.componentInstance = undefined;
  		this.parent = undefined;
  		this.raw = false;
  		this.isStatic = false;
  		this.isRootInsert = true;
  		this.isComment = false;
  		this.isCloned = false;
  		this.isOnce = false;
  		this.asyncFactory = asyncFactory;
  		this.asyncMeta = undefined;
  		this.isAsyncPlaceholder = false;
  	};
  	
  	var prototypeAccessors = { child: { configurable: true } };
  	
  	// DEPRECATED: alias for componentInstance for backwards compat.
  	/* istanbul ignore next */
  	prototypeAccessors.child.get = function () {
  		return this.componentInstance
  	};
  	
  	Object.defineProperties( VNode.prototype, prototypeAccessors );
  	
  	var createEmptyVNode = function (text) {
  		if ( text === void 0 ) text = '';
  		
  		var node = new VNode();
  		node.text = text;
  		node.isComment = true;
  		return node
  	};
  	
  	function createTextVNode (val) {
  		return new VNode(undefined, undefined, undefined, String(val))
  	}
  	
  	// optimized shallow clone
  	// used for static nodes and slot nodes because they may be reused across
  	// multiple renders, cloning them avoids errors when DOM manipulations rely
  	// on their elm reference.
  	function cloneVNode (vnode) {
  		var cloned = new VNode(
  			vnode.tag,
  			vnode.data,
  			// #7975
  			// clone children array to avoid mutating original in case of cloning
  			// a child.
  			vnode.children && vnode.children.slice(),
  			vnode.text,
  			vnode.elm,
  			vnode.context,
  			vnode.componentOptions,
  			vnode.asyncFactory
  		);
  		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 = true;
  		return cloned
  	}
  	
  	/*
     * not type checking this file because flow doesn't play well with
     * dynamically accessing methods on Array prototype
     */
  	
  	var arrayProto = Array.prototype;
  	var arrayMethods = Object.create(arrayProto);
  	
  	var methodsToPatch = [
  		'push',
  		'pop',
  		'shift',
  		'unshift',
  		'splice',
  		'sort',
  		'reverse'
  	];
  	
  	/**
  	 * Intercept mutating methods and emit events
  	 */
  	methodsToPatch.forEach(function (method) {
  		// cache original method
  		var original = arrayProto[method];
  		def(arrayMethods, method, function mutator () {
  			var args = [], len = arguments.length;
  			while ( len-- ) args[ len ] = arguments[ len ];
  			
  			var result = original.apply(this, args);
  			var ob = this.__ob__;
  			var inserted;
  			switch (method) {
  				case 'push':
  				case 'unshift':
  					inserted = args;
  					break
  				case 'splice':
  					inserted = args.slice(2);
  					break
  			}
  			if (inserted) { ob.observeArray(inserted); }
  			// notify change
  			ob.dep.notify();
  			return result
  		});
  	});
  	
  	/*  */
  	
  	var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
  	
  	/**
  	 * In some cases we may want to disable observation inside a component's
  	 * update computation.
  	 */
  	var shouldObserve = true;
  	
  	function toggleObserving (value) {
  		shouldObserve = value;
  	}
  	
  	/**
  	 * Observer class that is attached to each observed
  	 * object. Once attached, the observer converts the target
  	 * object's property keys into getter/setters that
  	 * collect dependencies and dispatch updates.
  	 */
  	var Observer = function Observer (value) {
  		this.value = value;
  		this.dep = new Dep();
  		this.vmCount = 0;
  		def(value, '__ob__', this);
  		if (Array.isArray(value)) {
  			if (hasProto) {
  				protoAugment(value, arrayMethods);
  			} else {
  				copyAugment(value, arrayMethods, arrayKeys);
  			}
  			this.observeArray(value);
  		} else {
  			this.walk(value);
  		}
  	};
  	
  	/**
  	 * Walk through all properties and convert them into
  	 * getter/setters. This method should only be called when
  	 * value type is Object.
  	 */
  	Observer.prototype.walk = function walk (obj) {
  		var keys = Object.keys(obj);
  		for (var i = 0; i < keys.length; i++) {
  			defineReactive$$1(obj, keys[i]);
  		}
  	};
  	
  	/**
  	 * Observe a list of Array items.
  	 */
  	Observer.prototype.observeArray = function observeArray (items) {
  		for (var i = 0, l = items.length; i < l; i++) {
  			observe(items[i]);
  		}
  	};
  	
  	// helpers
  	
  	/**
  	 * Augment a target Object or Array by intercepting
  	 * the prototype chain using __proto__
  	 */
  	function protoAugment (target, src) {
  		/* eslint-disable no-proto */
  		target.__proto__ = src;
  		/* eslint-enable no-proto */
  	}
  	
  	/**
  	 * Augment a target Object or Array by defining
  	 * hidden properties.
  	 */
  	/* istanbul ignore next */
  	function copyAugment (target, src, keys) {
  		for (var i = 0, l = keys.length; i < l; i++) {
  			var key = keys[i];
  			def(target, key, src[key]);
  		}
  	}
  	
  	/**
  	 * Attempt to create an observer instance for a value,
  	 * returns the new observer if successfully observed,
  	 * or the existing observer if the value already has one.
  	 */
  	function observe (value, asRootData) {
  		if (!isObject(value) || value instanceof VNode) {
  			return
  		}
  		var ob;
  		if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
  			ob = value.__ob__;
  		} else if (
  			shouldObserve &&
  			!isServerRendering() &&
  			(Array.isArray(value) || isPlainObject(value)) &&
  			Object.isExtensible(value) &&
  			!value._isVue
  		) {
  			ob = new Observer(value);
  		}
  		if (asRootData && ob) {
  			ob.vmCount++;
  		}
  		return ob
  	}
  	
  	/**
  	 * Define a reactive property on an Object.
  	 */
  	function defineReactive$$1 (
  		obj,
  		key,
  		val,
  		customSetter,
  		shallow
  	) {
  		var dep = new Dep();
  		
  		var property = Object.getOwnPropertyDescriptor(obj, key);
  		if (property && property.configurable === false) {
  			return
  		}
  		
  		// cater for pre-defined getter/setters
  		var getter = property && property.get;
  		var setter = property && property.set;
  		if ((!getter || setter) && arguments.length === 2) {
  			val = obj[key];
  		}
  		
  		var childOb = !shallow && observe(val);
  		Object.defineProperty(obj, key, {
  			enumerable: true,
  			configurable: true,
  			get: function reactiveGetter () {
  				var value = getter ? getter.call(obj) : val;
  				if (Dep.target) {
  					dep.depend();
  					if (childOb) {
  						childOb.dep.depend();
  						if (Array.isArray(value)) {
  							dependArray(value);
  						}
  					}
  				}
  				return value
  			},
  			set: function reactiveSetter (newVal) {
  				var value = getter ? getter.call(obj) : val;
  				/* eslint-disable no-self-compare */
  				if (newVal === value || (newVal !== newVal && value !== value)) {
  					return
  				}
  				/* eslint-enable no-self-compare */
  				if (customSetter) {
  					customSetter();
  				}
  				// #7981: for accessor properties without setter
  				if (getter && !setter) { return }
  				if (setter) {
  					setter.call(obj, newVal);
  				} else {
  					val = newVal;
  				}
  				childOb = !shallow && observe(newVal);
  				dep.notify();
  			}
  		});
  	}
  	
  	/**
  	 * Set a property on an object. Adds the new property and
  	 * triggers change notification if the property doesn't
  	 * already exist.
  	 */
  	function set (target, key, val) {
  		if (isUndef(target) || isPrimitive(target)
  		) {
  			warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
  		}
  		if (Array.isArray(target) && isValidArrayIndex(key)) {
  			target.length = Math.max(target.length, key);
  			target.splice(key, 1, val);
  			return val
  		}
  		if (key in target && !(key in Object.prototype)) {
  			target[key] = val;
  			return val
  		}
  		var ob = (target).__ob__;
  		if (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.'
  			);
  			return val
  		}
  		if (!ob) {
  			target[key] = val;
  			return val
  		}
  		defineReactive$$1(ob.value, key, val);
  		ob.dep.notify();
  		return val
  	}
  	
  	/**
  	 * Delete a property and trigger change if necessary.
  	 */
  	function del (target, key) {
  		if (isUndef(target) || isPrimitive(target)
  		) {
  			warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
  		}
  		if (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
  		}
  		if (!hasOwn(target, key)) {
  			return
  		}
  		delete target[key];
  		if (!ob) {
  			return
  		}
  		ob.dep.notify();
  	}
  	
  	/**
  	 * Collect dependencies on array elements when the array is touched, since
  	 * we cannot intercept array element access like property getters.
  	 */
  	function dependArray (value) {
  		for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
  			e = value[i];
  			e && e.__ob__ && e.__ob__.dep.depend();
  			if (Array.isArray(e)) {
  				dependArray(e);
  			}
  		}
  	}
  	
  	/*  */
  	
  	/**
  	 * Option overwriting strategies are functions that handle
  	 * how to merge a parent option value and a child option
  	 * value into the final value.
  	 */
  	var strats = config.optionMergeStrategies;
  	
  	/**
  	 * Options with restrictions
  	 */
  	{
  		strats.el = strats.propsData = function (parent, child, vm, key) {
  			if (!vm) {
  				warn(
  					"option \"" + key + "\" can only be used during instance " +
  					'creation with the `new` keyword.'
  				);
  			}
  			return defaultStrat(parent, child)
  		};
  	}
  	
  	/**
  	 * Helper that recursively merges two data objects together.
  	 */
  	function mergeData (to, from) {
  		if (!from) { return to }
  		var key, toVal, fromVal;
  		
  		var keys = hasSymbol
  			? Reflect.ownKeys(from)
  			: Object.keys(from);
  		
  		for (var i = 0; i < keys.length; i++) {
  			key = keys[i];
  			// in case the object is already observed...
  			if (key === '__ob__') { continue }
  			toVal = to[key];
  			fromVal = from[key];
  			if (!hasOwn(to, key)) {
  				set(to, key, fromVal);
  			} else if (
  				toVal !== fromVal &&
  				isPlainObject(toVal) &&
  				isPlainObject(fromVal)
  			) {
  				mergeData(toVal, fromVal);
  			}
  		}
  		return to
  	}
  	
  	/**
  	 * Data
  	 */
  	function mergeDataOrFn (
  		parentVal,
  		childVal,
  		vm
  	) {
  		if (!vm) {
  			// in a Vue.extend merge, both should be functions
  			if (!childVal) {
  				return parentVal
  			}
  			if (!parentVal) {
  				return childVal
  			}
  			// when parentVal & childVal are both present,
  			// we need to return a function that returns the
  			// merged result of both functions... no need to
  			// check if parentVal is a function here because
  			// it has to be a function to pass previous merges.
  			return function mergedDataFn () {
  				return mergeData(
  					typeof childVal === 'function' ? childVal.call(this, this) : childVal,
  					typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
  				)
  			}
  		} else {
  			return function mergedInstanceDataFn () {
  				// instance merge
  				var instanceData = typeof childVal === 'function'
  					? childVal.call(vm, vm)
  					: childVal;
  				var defaultData = typeof parentVal === 'function'
  					? parentVal.call(vm, vm)
  					: parentVal;
  				if (instanceData) {
  					return mergeData(instanceData, defaultData)
  				} else {
  					return defaultData
  				}
  			}
  		}
  	}
  	
  	strats.data = function (
  		parentVal,
  		childVal,
  		vm
  	) {
  		if (!vm) {
  			if (childVal && typeof childVal !== 'function') {
  				warn(
  					'The "data" option should be a function ' +
  					'that returns a per-instance value in component ' +
  					'definitions.',
  					vm
  				);
  				
  				return parentVal
  			}
  			return mergeDataOrFn(parentVal, childVal)
  		}
  		
  		return mergeDataOrFn(parentVal, childVal, vm)
  	};
  	
  	/**
  	 * Hooks and props are merged as arrays.
  	 */
  	function mergeHook (
  		parentVal,
  		childVal
  	) {
  		var res = childVal
  			? parentVal
  				? parentVal.concat(childVal)
  				: Array.isArray(childVal)
  					? childVal
  					: [childVal]
  			: parentVal;
  		return res
  			? dedupeHooks(res)
  			: res
  	}
  	
  	function dedupeHooks (hooks) {
  		var res = [];
  		for (var i = 0; i < hooks.length; i++) {
  			if (res.indexOf(hooks[i]) === -1) {
  				res.push(hooks[i]);
  			}
  		}
  		return res
  	}
  	
  	LIFECYCLE_HOOKS.forEach(function (hook) {
  		strats[hook] = mergeHook;
  	});
  	
  	/**
  	 * Assets
  	 *
  	 * When a vm is present (instance creation), we need to do
  	 * a three-way merge between constructor options, instance
  	 * options and parent options.
  	 */
  	function mergeAssets (
  		parentVal,
  		childVal,
  		vm,
  		key
  	) {
  		var res = Object.create(parentVal || null);
  		if (childVal) {
  			assertObjectType(key, childVal, vm);
  			return extend(res, childVal)
  		} else {
  			return res
  		}
  	}
  	
  	ASSET_TYPES.forEach(function (type) {
  		strats[type + 's'] = mergeAssets;
  	});
  	
  	/**
  	 * Watchers.
  	 *
  	 * Watchers hashes should not overwrite one
  	 * another, so we merge them as arrays.
  	 */
  	strats.watch = function (
  		parentVal,
  		childVal,
  		vm,
  		key
  	) {
  		// work around Firefox's Object.prototype.watch...
  		if (parentVal === nativeWatch) { parentVal = undefined; }
  		if (childVal === nativeWatch) { childVal = undefined; }
  		/* istanbul ignore if */
  		if (!childVal) { return Object.create(parentVal || null) }
  		{
  			assertObjectType(key, childVal, vm);
  		}
  		if (!parentVal) { return childVal }
  		var ret = {};
  		extend(ret, parentVal);
  		for (var key$1 in childVal) {
  			var parent = ret[key$1];
  			var child = childVal[key$1];
  			if (parent && !Array.isArray(parent)) {
  				parent = [parent];
  			}
  			ret[key$1] = parent
  				? parent.concat(child)
  				: Array.isArray(child) ? child : [child];
  		}
  		return ret
  	};
  	
  	/**
  	 * Other object hashes.
  	 */
  	strats.props =
  		strats.methods =
  			strats.inject =
  				strats.computed = function (
  					parentVal,
  					childVal,
  					vm,
  					key
  				) {
  					if (childVal && "development" !== 'production') {
  						assertObjectType(key, childVal, vm);
  					}
  					if (!parentVal) { return childVal }
  					var ret = Object.create(null);
  					extend(ret, parentVal);
  					if (childVal) { extend(ret, childVal); }
  					return ret
  				};
  	strats.provide = mergeDataOrFn;
  	
  	/**
  	 * Default strategy.
  	 */
  	var defaultStrat = function (parentVal, childVal) {
  		return childVal === undefined
  			? parentVal
  			: childVal
  	};
  	
  	/**
  	 * Validate component names
  	 */
  	function checkComponents (options) {
  		for (var key in options.components) {
  			validateComponentName(key);
  		}
  	}
  	
  	function validateComponentName (name) {
  		if (!new 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.'
  			);
  		}
  		if (isBuiltInTag(name) || config.isReservedTag(name)) {
  			warn(
  				'Do not use built-in or reserved HTML elements as component ' +
  				'id: ' + name
  			);
  		}
  	}
  	
  	/**
  	 * Ensure all props option syntax are normalized into the
  	 * Object-based format.
  	 */
  	function normalizeProps (options, vm) {
  		var props = options.props;
  		if (!props) { return }
  		var res = {};
  		var i, val, name;
  		if (Array.isArray(props)) {
  			i = props.length;
  			while (i--) {
  				val = props[i];
  				if (typeof val === 'string') {
  					name = camelize(val);
  					res[name] = { type: null };
  				} else {
  					warn('props must be strings when using array syntax.');
  				}
  			}
  		} else if (isPlainObject(props)) {
  			for (var key in props) {
  				val = props[key];
  				name = camelize(key);
  				res[name] = 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;
  	}
  	
  	/**
  	 * Normalize all injections into Object-based format
  	 */
  	function normalizeInject (options, vm) {
  		var inject = options.inject;
  		if (!inject) { return }
  		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
  			);
  		}
  	}
  	
  	/**
  	 * Normalize raw function directives into object format.
  	 */
  	function normalizeDirectives (options) {
  		var dirs = options.directives;
  		if (dirs) {
  			for (var key in dirs) {
  				var def$$1 = dirs[key];
  				if (typeof def$$1 === 'function') {
  					dirs[key] = { bind: def$$1, update: def$$1 };
  				}
  			}
  		}
  	}
  	
  	function assertObjectType (name, value, vm) {
  		if (!isPlainObject(value)) {
  			warn(
  				"Invalid value for option \"" + name + "\": expected an Object, " +
  				"but got " + (toRawType(value)) + ".",
  				vm
  			);
  		}
  	}
  	
  	/**
  	 * Merge two option objects into a new one.
  	 * Core utility used in both instantiation and inheritance.
  	 */
  	function mergeOptions (
  		parent,
  		child,
  		vm
  	) {
  		{
  			checkComponents(child);
  		}
  		
  		if (typeof child === 'function') {
  			child = child.options;
  		}
  		
  		normalizeProps(child, vm);
  		normalizeInject(child, vm);
  		normalizeDirectives(child);
  		
  		// Apply extends and mixins on the child options,
  		// but only if it is a raw options object that isn't
  		// the result of another mergeOptions call.
  		// Only merged options has the _base property.
  		if (!child._base) {
  			if (child.extends) {
  				parent = mergeOptions(parent, child.extends, vm);
  			}
  			if (child.mixins) {
  				for (var i = 0, l = child.mixins.length; i < l; i++) {
  					parent = mergeOptions(parent, child.mixins[i], vm);
  				}
  			}
  		}
  		
  		var options = {};
  		var key;
  		for (key in parent) {
  			mergeField(key);
  		}
  		for (key in child) {
  			if (!hasOwn(parent, key)) {
  				mergeField(key);
  			}
  		}
  		function mergeField (key) {
  			var strat = strats[key] || defaultStrat;
  			options[key] = strat(parent[key], child[key], vm, key);
  		}
  		return options
  	}
  	
  	/**
  	 * Resolve an asset.
  	 * This function is used because child instances need access
  	 * to assets defined in its ancestor chain.
  	 */
  	function resolveAsset (
  		options,
  		type,
  		id,
  		warnMissing
  	) {
  		/* istanbul ignore if */
  		if (typeof id !== 'string') {
  			return
  		}
  		var assets = options[type];
  		// check local registration variations first
  		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] }
  		// fallback to prototype chain
  		var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
  		if (warnMissing && !res) {
  			warn(
  				'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
  				options
  			);
  		}
  		return res
  	}
  	
  	/*  */
  	
  	
  	
  	function validateProp (
  		key,
  		propOptions,
  		propsData,
  		vm
  	) {
  		var prop = propOptions[key];
  		var absent = !hasOwn(propsData, key);
  		var value = propsData[key];
  		// boolean casting
  		var booleanIndex = getTypeIndex(Boolean, prop.type);
  		if (booleanIndex > -1) {
  			if (absent && !hasOwn(prop, 'default')) {
  				value = false;
  			} else if (value === '' || value === hyphenate(key)) {
  				// only cast empty string / same name to boolean if
  				// boolean has higher priority
  				var stringIndex = getTypeIndex(String, prop.type);
  				if (stringIndex < 0 || booleanIndex < stringIndex) {
  					value = true;
  				}
  			}
  		}
  		// check default value
  		if (value === undefined) {
  			value = getPropDefaultValue(vm, prop, key);
  			// since the default value is a fresh copy,
  			// make sure to observe it.
  			var prevShouldObserve = shouldObserve;
  			toggleObserving(true);
  			observe(value);
  			toggleObserving(prevShouldObserve);
  		}
  		{
  			assertProp(prop, key, value, vm, absent);
  		}
  		return value
  	}
  	
  	/**
  	 * Get the default value of a prop.
  	 */
  	function getPropDefaultValue (vm, prop, key) {
  		// no default, return undefined
  		if (!hasOwn(prop, 'default')) {
  			return undefined
  		}
  		var def = prop.default;
  		// warn against non-factory defaults for Object & Array
  		if (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
  			);
  		}
  		// the raw prop value was also undefined from previous render,
  		// return previous default value to avoid unnecessary watcher trigger
  		if (vm && vm.$options.propsData &&
  			vm.$options.propsData[key] === undefined &&
  			vm._props[key] !== undefined
  		) {
  			return vm._props[key]
  		}
  		// call factory function for non-Function types
  		// a value is Function if its prototype is function even across different execution context
  		return typeof def === 'function' && getType(prop.type) !== 'Function'
  			? def.call(vm)
  			: def
  	}
  	
  	/**
  	 * Assert whether a prop is valid.
  	 */
  	function assertProp (
  		prop,
  		name,
  		value,
  		vm,
  		absent
  	) {
  		if (prop.required && absent) {
  			warn(
  				'Missing required prop: "' + name + '"',
  				vm
  			);
  			return
  		}
  		if (value == null && !prop.required) {
  			return
  		}
  		var type = prop.type;
  		var valid = !type || type === true;
  		var expectedTypes = [];
  		if (type) {
  			if (!Array.isArray(type)) {
  				type = [type];
  			}
  			for (var i = 0; i < type.length && !valid; i++) {
  				var assertedType = assertType(value, type[i]);
  				expectedTypes.push(assertedType.expectedType || '');
  				valid = assertedType.valid;
  			}
  		}
  		
  		if (!valid) {
  			warn(
  				getInvalidTypeMessage(name, value, expectedTypes),
  				vm
  			);
  			return
  		}
  		var validator = prop.validator;
  		if (validator) {
  			if (!validator(value)) {
  				warn(
  					'Invalid prop: custom validator check failed for prop "' + name + '".',
  					vm
  				);
  			}
  		}
  	}
  	
  	var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
  	
  	function assertType (value, type) {
  		var valid;
  		var expectedType = getType(type);
  		if (simpleCheckRE.test(expectedType)) {
  			var t = typeof value;
  			valid = t === expectedType.toLowerCase();
  			// for primitive wrapper objects
  			if (!valid && t === 'object') {
  				valid = value instanceof type;
  			}
  		} else if (expectedType === 'Object') {
  			valid = isPlainObject(value);
  		} else if (expectedType === 'Array') {
  			valid = Array.isArray(value);
  		} else {
  			valid = value instanceof type;
  		}
  		return {
  			valid: valid,
  			expectedType: expectedType
  		}
  	}
  	
  	/**
  	 * Use function string name to check built-in types,
  	 * because a simple equality check will fail when running
  	 * across different vms / iframes.
  	 */
  	function getType (fn) {
  		var match = fn && fn.toString().match(/^\s*function (\w+)/);
  		return match ? match[1] : ''
  	}
  	
  	function isSameType (a, b) {
  		return getType(a) === getType(b)
  	}
  	
  	function getTypeIndex (type, expectedTypes) {
  		if (!Array.isArray(expectedTypes)) {
  			return isSameType(expectedTypes, type) ? 0 : -1
  		}
  		for (var i = 0, len = expectedTypes.length; i < len; i++) {
  			if (isSameType(expectedTypes[i], type)) {
  				return i
  			}
  		}
  		return -1
  	}
  	
  	function getInvalidTypeMessage (name, value, expectedTypes) {
  		var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
  			" Expected " + (expectedTypes.map(capitalize).join(', '));
  		var expectedType = expectedTypes[0];
  		var receivedType = toRawType(value);
  		var expectedValue = styleValue(value, expectedType);
  		var receivedValue = styleValue(value, receivedType);
  		// check if we need to specify expected value
  		if (expectedTypes.length === 1 &&
  			isExplicable(expectedType) &&
  			!isBoolean(expectedType, receivedType)) {
  			message += " with value " + expectedValue;
  		}
  		message += ", got " + receivedType + " ";
  		// check if we need to specify received value
  		if (isExplicable(receivedType)) {
  			message += "with value " + receivedValue + ".";
  		}
  		return message
  	}
  	
  	function styleValue (value, type) {
  		if (type === 'String') {
  			return ("\"" + value + "\"")
  		} else if (type === 'Number') {
  			return ("" + (Number(value)))
  		} else {
  			return ("" + value)
  		}
  	}
  	
  	function isExplicable (value) {
  		var explicitTypes = ['string', 'number', 'boolean'];
  		return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
  	}
  	
  	function isBoolean () {
  		var args = [], len = arguments.length;
  		while ( len-- ) args[ len ] = arguments[ len ];
  		
  		return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
  	}
  	
  	/*  */
  	
  	function handleError (err, vm, info) {
  		// Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
  		// See: https://github.com/vuejs/vuex/issues/1505
  		pushTarget();
  		try {
  			if (vm) {
  				var cur = vm;
  				while ((cur = cur.$parent)) {
  					var hooks = cur.$options.errorCaptured;
  					if (hooks) {
  						for (var i = 0; i < hooks.length; i++) {
  							try {
  								var capture = hooks[i].call(cur, err, vm, info) === false;
  								if (capture) { 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);
  			if (res && !res._isVue && isPromise(res) && !res._handled) {
  				res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
  				// issue #9511
  				// avoid catch triggering multiple times when nested calls
  				res._handled = true;
  			}
  		} 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) {
  				// if the user intentionally throws the original error in the handler,
  				// do not log it twice
  				if (e !== err) {
  					logError(e, null, 'config.errorHandler');
  				}
  			}
  		}
  		logError(err, vm, info);
  	}
  	
  	function logError (err, vm, info) {
  		{
  			warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
  		}
  		/* istanbul ignore else */
  		if ((inBrowser || inWeex) && typeof console !== 'undefined') {
  			console.error(err);
  		} else {
  			throw err
  		}
  	}
  	
  	/*  */
  	
  	var isUsingMicroTask = false;
  	
  	var callbacks = [];
  	var pending = false;
  	
  	function flushCallbacks () {
  		pending = false;
  		var copies = callbacks.slice(0);
  		callbacks.length = 0;
  		for (var i = 0; i < copies.length; i++) {
  			copies[i]();
  		}
  	}
  	
  	// Here we have async deferring wrappers using microtasks.
  	// In 2.5 we used (macro) tasks (in combination with microtasks).
  	// However, it has subtle problems when state is changed right before repaint
  	// (e.g. #6813, out-in transitions).
  	// Also, using (macro) tasks in event handler would cause some weird behaviors
  	// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
  	// So we now use microtasks everywhere, again.
  	// A major drawback of this tradeoff is that there are some scenarios
  	// where microtasks have too high a priority and fire in between supposedly
  	// sequential events (e.g. #4521, #6690, which have workarounds)
  	// or even between bubbling of the same event (#6566).
  	var timerFunc;
  	
  	// The nextTick behavior leverages the microtask queue, which can be accessed
  	// via either native Promise.then or MutationObserver.
  	// MutationObserver has wider support, however it is seriously bugged in
  	// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
  	// completely stops working after triggering a few times... so, if native
  	// Promise is available, we will use it:
  	/* istanbul ignore next, $flow-disable-line */
  	if (typeof Promise !== 'undefined' && isNative(Promise)) {
  		var p = Promise.resolve();
  		timerFunc = function () {
  			p.then(flushCallbacks);
  			// In problematic UIWebViews, Promise.then doesn't completely break, but
  			// it can get stuck in a weird state where callbacks are pushed into the
  			// microtask queue but the queue isn't being flushed, until the browser
  			// needs to do some other work, e.g. handle a timer. Therefore we can
  			// "force" the microtask queue to be flushed by adding an empty timer.
  			if (isIOS) { setTimeout(noop); }
  		};
  		isUsingMicroTask = true;
  	} else if (!isIE && typeof MutationObserver !== 'undefined' && (
  		isNative(MutationObserver) ||
  		// PhantomJS and iOS 7.x
  		MutationObserver.toString() === '[object MutationObserverConstructor]'
  	)) {
  		// Use MutationObserver where native Promise is not available,
  		// e.g. PhantomJS, iOS7, Android 4.4
  		// (#6466 MutationObserver is unreliable in IE11)
  		var counter = 1;
  		var observer = new MutationObserver(flushCallbacks);
  		var textNode = document.createTextNode(String(counter));
  		observer.observe(textNode, {
  			characterData: true
  		});
  		timerFunc = function () {
  			counter = (counter + 1) % 2;
  			textNode.data = String(counter);
  		};
  		isUsingMicroTask = true;
  	} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
  		// Fallback to setImmediate.
  		// Techinically it leverages the (macro) task queue,
  		// but it is still a better choice than setTimeout.
  		timerFunc = function () {
  			setImmediate(flushCallbacks);
  		};
  	} else {
  		// Fallback to setTimeout.
  		timerFunc = function () {
  			setTimeout(flushCallbacks, 0);
  		};
  	}
  	
  	function nextTick (cb, ctx) {
  		var _resolve;
  		callbacks.push(function () {
  			if (cb) {
  				try {
  					cb.call(ctx);
  				} catch (e) {
  					handleError(e, ctx, 'nextTick');
  				}
  			} else if (_resolve) {
  				_resolve(ctx);
  			}
  		});
  		if (!pending) {
  			pending = true;
  			timerFunc();
  		}
  		// $flow-disable-line
  		if (!cb && typeof Promise !== 'undefined') {
  			return new Promise(function (resolve) {
  				_resolve = resolve;
  			})
  		}
  	}
  	
  	/*  */
  	
  	var mark;
  	var measure;
  	
  	{
  		var perf = inBrowser && window.performance;
  		/* istanbul ignore if */
  		if (
  			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);
  				// perf.clearMeasures(name)
  			};
  		}
  	}
  	
  	/* not type checking this file because flow doesn't play well with Proxy */
  	
  	var initProxy;
  	
  	{
  		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' // for Webpack/Browserify
  		);
  		
  		var 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
  			);
  		};
  		
  		var 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
  			);
  		};
  		
  		var hasProxy =
  			typeof Proxy !== 'undefined' && isNative(Proxy);
  		
  		if (hasProxy) {
  			var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
  			config.keyCodes = new Proxy(config.keyCodes, {
  				set: function set (target, key, value) {
  					if (isBuiltInModifier(key)) {
  						warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
  						return false
  					} else {
  						target[key] = value;
  						return true
  					}
  				}
  			});
  		}
  		
  		var hasHandler = {
  			has: function has (target, key) {
  				var has = key in target;
  				var isAllowed = allowedGlobals(key) ||
  					(typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));
  				if (!has && !isAllowed) {
  					if (key in target.$data) { warnReservedPrefix(target, key); }
  					else { warnNonPresent(target, key); }
  				}
  				return has || !isAllowed
  			}
  		};
  		
  		var getHandler = {
  			get: function get (target, key) {
  				if (typeof key === 'string' && !(key in target)) {
  					if (key in target.$data) { warnReservedPrefix(target, key); }
  					else { warnNonPresent(target, key); }
  				}
  				return target[key]
  			}
  		};
  		
  		initProxy = function initProxy (vm) {
  			if (hasProxy) {
  				// determine which proxy handler to use
  				var options = vm.$options;
  				var handlers = options.render && options.render._withStripped
  					? getHandler
  					: hasHandler;
  				vm._renderProxy = new Proxy(vm, handlers);
  			} else {
  				vm._renderProxy = vm;
  			}
  		};
  	}
  	
  	/*  */
  	
  	var seenObjects = new _Set();
  	
  	/**
  	 * Recursively traverse an object to evoke all converted
  	 * getters, so that every nested property inside the object
  	 * is collected as a "deep" dependency.
  	 */
  	function traverse (val) {
  		_traverse(val, seenObjects);
  		seenObjects.clear();
  	}
  	
  	function _traverse (val, seen) {
  		var i, keys;
  		var isA = Array.isArray(val);
  		if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
  			return
  		}
  		if (val.__ob__) {
  			var depId = val.__ob__.dep.id;
  			if (seen.has(depId)) {
  				return
  			}
  			seen.add(depId);
  		}
  		if (isA) {
  			i = val.length;
  			while (i--) { _traverse(val[i], seen); }
  		} else {
  			keys = Object.keys(val);
  			i = keys.length;
  			while (i--) { _traverse(val[keys[i]], seen); }
  		}
  	}
  	
  	/*  */
  	
  	var normalizeEvent = cached(function (name) {
  		var passive = name.charAt(0) === '&';
  		name = passive ? name.slice(1) : name;
  		var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
  		name = once$$1 ? name.slice(1) : name;
  		var capture = name.charAt(0) === '!';
  		name = capture ? name.slice(1) : name;
  		return {
  			name: name,
  			once: once$$1,
  			capture: capture,
  			passive: passive
  		}
  	});
  	
  	function createFnInvoker (fns, vm) {
  		function invoker () {
  			var arguments$1 = arguments;
  			
  			var fns = invoker.fns;
  			if (Array.isArray(fns)) {
  				var cloned = fns.slice();
  				for (var i = 0; i < cloned.length; i++) {
  					invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
  				}
  			} else {
  				// return handler return value for single handlers
  				return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
  			}
  		}
  		invoker.fns = fns;
  		return invoker
  	}
  	
  	function updateListeners (
  		on,
  		oldOn,
  		add,
  		remove$$1,
  		createOnceHandler,
  		vm
  	) {
  		var name, def$$1, cur, old, event;
  		for (name in on) {
  			def$$1 = cur = on[name];
  			old = oldOn[name];
  			event = normalizeEvent(name);
  			if (isUndef(cur)) {
  				warn(
  					"Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
  					vm
  				);
  			} else if (isUndef(old)) {
  				if (isUndef(cur.fns)) {
  					cur = on[name] = createFnInvoker(cur, vm);
  				}
  				if (isTrue(event.once)) {
  					cur = on[name] = createOnceHandler(event.name, cur, event.capture);
  				}
  				add(event.name, cur, event.capture, event.passive, event.params);
  			} else if (cur !== old) {
  				old.fns = cur;
  				on[name] = old;
  			}
  		}
  		for (name in oldOn) {
  			if (isUndef(on[name])) {
  				event = normalizeEvent(name);
  				remove$$1(event.name, oldOn[name], event.capture);
  			}
  		}
  	}
  	
  	/*  */
  	
  	function mergeVNodeHook (def, hookKey, hook) {
  		if (def instanceof VNode) {
  			def = def.data.hook || (def.data.hook = {});
  		}
  		var invoker;
  		var oldHook = def[hookKey];
  		
  		function wrappedHook () {
  			hook.apply(this, arguments);
  			// important: remove merged hook to ensure it's called only once
  			// and prevent memory leak
  			remove(invoker.fns, wrappedHook);
  		}
  		
  		if (isUndef(oldHook)) {
  			// no existing hook
  			invoker = createFnInvoker([wrappedHook]);
  		} else {
  			/* istanbul ignore if */
  			if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
  				// already a merged invoker
  				invoker = oldHook;
  				invoker.fns.push(wrappedHook);
  			} else {
  				// existing plain hook
  				invoker = createFnInvoker([oldHook, wrappedHook]);
  			}
  		}
  		
  		invoker.merged = true;
  		def[hookKey] = invoker;
  	}
  	
  	/*  */
  	
  	function extractPropsFromVNodeData (
  		data,
  		Ctor,
  		tag
  	) {
  		// we are only extracting raw values here.
  		// validation and default values are handled in the child
  		// component itself.
  		var propOptions = Ctor.options.props;
  		if (isUndef(propOptions)) {
  			return
  		}
  		var res = {};
  		var attrs = data.attrs;
  		var props = data.props;
  		if (isDef(attrs) || isDef(props)) {
  			for (var key in propOptions) {
  				var altKey = hyphenate(key);
  				{
  					var keyInLowerCase = key.toLowerCase();
  					if (
  						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, true) ||
  				checkProp(res, attrs, key, altKey, false);
  			}
  		}
  		return res
  	}
  	
  	function checkProp (
  		res,
  		hash,
  		key,
  		altKey,
  		preserve
  	) {
  		if (isDef(hash)) {
  			if (hasOwn(hash, key)) {
  				res[key] = hash[key];
  				if (!preserve) {
  					delete hash[key];
  				}
  				return true
  			} else if (hasOwn(hash, altKey)) {
  				res[key] = hash[altKey];
  				if (!preserve) {
  					delete hash[altKey];
  				}
  				return true
  			}
  		}
  		return false
  	}
  	
  	/*  */
  	
  	// The template compiler attempts to minimize the need for normalization by
  	// statically analyzing the template at compile time.
  	//
  	// For plain HTML markup, normalization can be completely skipped because the
  	// generated render function is guaranteed to return Array<VNode>. There are
  	// two cases where extra normalization is needed:
  	
  	// 1. When the children contains components - because a functional component
  	// may return an Array instead of a single root. In this case, just a simple
  	// normalization is needed - if any child is an Array, we flatten the whole
  	// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
  	// because functional components already normalize their own children.
  	function simpleNormalizeChildren (children) {
  		for (var i = 0; i < children.length; i++) {
  			if (Array.isArray(children[i])) {
  				return Array.prototype.concat.apply([], children)
  			}
  		}
  		return children
  	}
  	
  	// 2. When the children contains constructs that always generated nested Arrays,
  	// e.g. <template>, <slot>, v-for, or when the children is provided by user
  	// with hand-written render functions / JSX. In such cases a full normalization
  	// is needed to cater to all possible types of children values.
  	function normalizeChildren (children) {
  		return isPrimitive(children)
  			? [createTextVNode(children)]
  			: Array.isArray(children)
  				? normalizeArrayChildren(children)
  				: undefined
  	}
  	
  	function isTextNode (node) {
  		return isDef(node) && isDef(node.text) && isFalse(node.isComment)
  	}
  	
  	function normalizeArrayChildren (children, nestedIndex) {
  		var res = [];
  		var i, c, lastIndex, last;
  		for (i = 0; i < children.length; i++) {
  			c = children[i];
  			if (isUndef(c) || typeof c === 'boolean') { continue }
  			lastIndex = res.length - 1;
  			last = res[lastIndex];
  			//  nested
  			if (Array.isArray(c)) {
  				if (c.length > 0) {
  					c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
  					// merge adjacent text nodes
  					if (isTextNode(c[0]) && isTextNode(last)) {
  						res[lastIndex] = createTextVNode(last.text + (c[0]).text);
  						c.shift();
  					}
  					res.push.apply(res, c);
  				}
  			} else if (isPrimitive(c)) {
  				if (isTextNode(last)) {
  					// merge adjacent text nodes
  					// this is necessary for SSR hydration because text nodes are
  					// essentially merged when rendered to HTML strings
  					res[lastIndex] = createTextVNode(last.text + c);
  				} else if (c !== '') {
  					// convert primitive to vnode
  					res.push(createTextVNode(c));
  				}
  			} else {
  				if (isTextNode(c) && isTextNode(last)) {
  					// merge adjacent text nodes
  					res[lastIndex] = createTextVNode(last.text + c.text);
  				} else {
  					// default key for nested array children (likely generated by v-for)
  					if (isTrue(children._isVList) &&
  						isDef(c.tag) &&
  						isUndef(c.key) &&
  						isDef(nestedIndex)) {
  						c.key = "__vlist" + nestedIndex + "_" + i + "__";
  					}
  					res.push(c);
  				}
  			}
  		}
  		return res
  	}
  	
  	/*  */
  	
  	function initProvide (vm) {
  		var provide = vm.$options.provide;
  		if (provide) {
  			vm._provided = typeof provide === 'function'
  				? provide.call(vm)
  				: provide;
  		}
  	}
  	
  	function initInjections (vm) {
  		var result = resolveInject(vm.$options.inject, vm);
  		if (result) {
  			toggleObserving(false);
  			Object.keys(result).forEach(function (key) {
  				/* istanbul ignore else */
  				{
  					defineReactive$$1(vm, 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 + "\"",
  							vm
  						);
  					});
  				}
  			});
  			toggleObserving(true);
  		}
  	}
  	
  	function resolveInject (inject, vm) {
  		if (inject) {
  			// inject is :any because flow is not smart enough to figure out cached
  			var result = Object.create(null);
  			var keys = hasSymbol
  				? Reflect.ownKeys(inject)
  				: Object.keys(inject);
  			
  			for (var i = 0; i < keys.length; i++) {
  				var key = keys[i];
  				// #6574 in case the inject object is observed...
  				if (key === '__ob__') { continue }
  				var provideKey = inject[key].from;
  				var source = vm;
  				while (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] = typeof provideDefault === 'function'
  							? provideDefault.call(vm)
  							: provideDefault;
  					} else {
  						warn(("Injection \"" + key + "\" not found"), vm);
  					}
  				}
  			}
  			return result
  		}
  	}
  	
  	/*  */
  	
  	
  	
  	/**
  	 * Runtime helper for resolving raw children VNodes into a slot object.
  	 */
  	function resolveSlots (
  		children,
  		context
  	) {
  		if (!children || !children.length) {
  			return {}
  		}
  		var slots = {};
  		for (var i = 0, l = children.length; i < l; i++) {
  			var child = children[i];
  			var data = child.data;
  			// remove slot attribute if the node is resolved as a Vue slot node
  			if (data && data.attrs && data.attrs.slot) {
  				delete data.attrs.slot;
  			}
  			// named slots should only be respected if the vnode was rendered in the
  			// same context.
  			if ((child.context === context || child.fnContext === context) &&
  				data && data.slot != null
  			) {
  				var name = data.slot;
  				var slot = (slots[name] || (slots[name] = []));
  				if (child.tag === 'template') {
  					slot.push.apply(slot, child.children || []);
  				} else {
  					slot.push(child);
  				}
  			} else {
  				(slots.default || (slots.default = [])).push(child);
  			}
  		}
  		// ignore slots that contains only whitespace
  		for (var name$1 in slots) {
  			if (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;
  		var hasNormalSlots = Object.keys(normalSlots).length > 0;
  		var isStable = slots ? !!slots.$stable : !hasNormalSlots;
  		var key = slots && slots.$key;
  		if (!slots) {
  			res = {};
  		} else if (slots._normalized) {
  			// fast path 1: child component re-render only, parent did not change
  			return slots._normalized
  		} else if (
  			isStable &&
  			prevSlots &&
  			prevSlots !== emptyObject &&
  			key === prevSlots.$key &&
  			!hasNormalSlots &&
  			!prevSlots.$hasNormal
  		) {
  			// fast path 2: stable scoped slots w/ no normal slots to proxy,
  			// only need to normalize once
  			return prevSlots
  		} else {
  			res = {};
  			for (var key$1 in slots) {
  				if (slots[key$1] && key$1[0] !== '$') {
  					res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
  				}
  			}
  		}
  		// expose normal slots on scopedSlots
  		for (var key$2 in normalSlots) {
  			if (!(key$2 in res)) {
  				res[key$2] = proxyNormalSlot(normalSlots, key$2);
  			}
  		}
  		// avoriaz seems to mock a non-extensible $scopedSlots object
  		// and when that is passed down this would cause an error
  		if (slots && Object.isExtensible(slots)) {
  			(slots)._normalized = res;
  		}
  		def(res, '$stable', isStable);
  		def(res, '$key', key);
  		def(res, '$hasNormal', hasNormalSlots);
  		return res
  	}
  	
  	function normalizeScopedSlot(normalSlots, key, fn) {
  		var normalized = function () {
  			var res = arguments.length ? fn.apply(null, arguments) : fn({});
  			res = res && typeof res === 'object' && !Array.isArray(res)
  				? [res] // single vnode
  				: normalizeChildren(res);
  			return res && (
  				res.length === 0 ||
  				(res.length === 1 && res[0].isComment) // #9658
  			) ? undefined
  				: res
  		};
  		// this is a slot using the new v-slot syntax without scope. although it is
  		// compiled as a scoped slot, render fn users would expect it to be present
  		// on this.$slots because the usage is semantically a normal slot.
  		if (fn.proxy) {
  			Object.defineProperty(normalSlots, key, {
  				get: normalized,
  				enumerable: true,
  				configurable: true
  			});
  		}
  		return normalized
  	}
  	
  	function proxyNormalSlot(slots, key) {
  		return function () { return slots[key]; }
  	}
  	
  	/*  */
  	
  	/**
  	 * Runtime helper for rendering v-for lists.
  	 */
  	function renderList (
  		val,
  		render
  	) {
  		var ret, i, l, keys, key;
  		if (Array.isArray(val) || typeof val === 'string') {
  			ret = new Array(val.length);
  			for (i = 0, l = val.length; i < l; i++) {
  				ret[i] = render(val[i], i);
  			}
  		} else if (typeof val === 'number') {
  			ret = new Array(val);
  			for (i = 0; i < val; i++) {
  				ret[i] = render(i + 1, i);
  			}
  		} else if (isObject(val)) {
  			if (hasSymbol && val[Symbol.iterator]) {
  				ret = [];
  				var iterator = val[Symbol.iterator]();
  				var result = iterator.next();
  				while (!result.done) {
  					ret.push(render(result.value, ret.length));
  					result = iterator.next();
  				}
  			} else {
  				keys = Object.keys(val);
  				ret = new Array(keys.length);
  				for (i = 0, l = keys.length; i < l; i++) {
  					key = keys[i];
  					ret[i] = render(val[key], key, i);
  				}
  			}
  		}
  		if (!isDef(ret)) {
  			ret = [];
  		}
  		(ret)._isVList = true;
  		return ret
  	}
  	
  	/*  */
  	
  	/**
  	 * Runtime helper for rendering <slot>
  	 */
  	function renderSlot (
  		name,
  		fallback,
  		props,
  		bindObject
  	) {
  		var scopedSlotFn = this.$scopedSlots[name];
  		var nodes;
  		if (scopedSlotFn) { // scoped slot
  			props = props || {};
  			if (bindObject) {
  				if (!isObject(bindObject)) {
  					warn(
  						'slot v-bind without argument expects an Object',
  						this
  					);
  				}
  				props = extend(extend({}, bindObject), props);
  			}
  			nodes = scopedSlotFn(props) || fallback;
  		} else {
  			nodes = this.$slots[name] || fallback;
  		}
  		
  		var target = props && props.slot;
  		if (target) {
  			return this.$createElement('template', { slot: target }, nodes)
  		} else {
  			return nodes
  		}
  	}
  	
  	/*  */
  	
  	/**
  	 * Runtime helper for resolving filters
  	 */
  	function resolveFilter (id) {
  		return resolveAsset(this.$options, 'filters', id, true) || identity
  	}
  	
  	/*  */
  	
  	function isKeyNotMatch (expect, actual) {
  		if (Array.isArray(expect)) {
  			return expect.indexOf(actual) === -1
  		} else {
  			return expect !== actual
  		}
  	}
  	
  	/**
  	 * Runtime helper for checking keyCodes from config.
  	 * exposed as Vue.prototype._k
  	 * passing in eventKeyName as last argument separately for backwards compat
  	 */
  	function checkKeyCodes (
  		eventKeyCode,
  		key,
  		builtInKeyCode,
  		eventKeyName,
  		builtInKeyName
  	) {
  		var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
  		if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
  			return isKeyNotMatch(builtInKeyName, eventKeyName)
  		} else if (mappedKeyCode) {
  			return isKeyNotMatch(mappedKeyCode, eventKeyCode)
  		} else if (eventKeyName) {
  			return hyphenate(eventKeyName) !== key
  		}
  	}
  	
  	/*  */
  	
  	/**
  	 * Runtime helper for merging v-bind="object" into a VNode's data.
  	 */
  	function bindObjectProps (
  		data,
  		tag,
  		value,
  		asProp,
  		isSync
  	) {
  		if (value) {
  			if (!isObject(value)) {
  				warn(
  					'v-bind without argument expects an Object or Array value',
  					this
  				);
  			} else {
  				if (Array.isArray(value)) {
  					value = toObject(value);
  				}
  				var hash;
  				var loop = function ( key ) {
  					if (
  						key === 'class' ||
  						key === 'style' ||
  						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);
  					var hyphenatedKey = hyphenate(key);
  					if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
  						hash[key] = value[key];
  						
  						if (isSync) {
  							var on = data.on || (data.on = {});
  							on[("update:" + key)] = function ($event) {
  								value[key] = $event;
  							};
  						}
  					}
  				};
  				
  				for (var key in value) loop( key );
  			}
  		}
  		return data
  	}
  	
  	/*  */
  	
  	/**
  	 * Runtime helper for rendering static trees.
  	 */
  	function renderStatic (
  		index,
  		isInFor
  	) {
  		var cached = this._staticTrees || (this._staticTrees = []);
  		var tree = cached[index];
  		// if has already-rendered static tree and not inside v-for,
  		// we can reuse the same tree.
  		if (tree && !isInFor) {
  			return tree
  		}
  		// otherwise, render a fresh tree.
  		tree = cached[index] = this.$options.staticRenderFns[index].call(
  			this._renderProxy,
  			null,
  			this // for render fns generated for functional component templates
  		);
  		markStatic(tree, ("__static__" + index), false);
  		return tree
  	}
  	
  	/**
  	 * Runtime helper for v-once.
  	 * Effectively it means marking the node as static with a unique key.
  	 */
  	function markOnce (
  		tree,
  		index,
  		key
  	) {
  		markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
  		return tree
  	}
  	
  	function markStatic (
  		tree,
  		key,
  		isOnce
  	) {
  		if (Array.isArray(tree)) {
  			for (var i = 0; i < tree.length; i++) {
  				if (tree[i] && typeof tree[i] !== 'string') {
  					markStaticNode(tree[i], (key + "_" + i), isOnce);
  				}
  			}
  		} else {
  			markStaticNode(tree, key, isOnce);
  		}
  	}
  	
  	function markStaticNode (node, key, isOnce) {
  		node.isStatic = true;
  		node.key = key;
  		node.isOnce = isOnce;
  	}
  	
  	/*  */
  	
  	function bindObjectListeners (data, value) {
  		if (value) {
  			if (!isPlainObject(value)) {
  				warn(
  					'v-on without argument expects an Object value',
  					this
  				);
  			} else {
  				var on = data.on = data.on ? extend({}, data.on) : {};
  				for (var key in value) {
  					var existing = on[key];
  					var ours = value[key];
  					on[key] = existing ? [].concat(existing, ours) : ours;
  				}
  			}
  		}
  		return data
  	}
  	
  	/*  */
  	
  	function resolveScopedSlots (
  		fns, // see flow/vnode
  		res,
  		// the following are added in 2.6
  		hasDynamicKeys,
  		contentHashKey
  	) {
  		res = res || { $stable: !hasDynamicKeys };
  		for (var i = 0; i < fns.length; i++) {
  			var slot = fns[i];
  			if (Array.isArray(slot)) {
  				resolveScopedSlots(slot, res, hasDynamicKeys);
  			} else if (slot) {
  				// marker for reverse proxying v-slot without scope on this.$slots
  				if (slot.proxy) {
  					slot.fn.proxy = true;
  				}
  				res[slot.key] = slot.fn;
  			}
  		}
  		if (contentHashKey) {
  			(res).$key = contentHashKey;
  		}
  		return res
  	}
  	
  	/*  */
  	
  	function bindDynamicKeys (baseObj, values) {
  		for (var i = 0; i < values.length; i += 2) {
  			var key = values[i];
  			if (typeof key === 'string' && key) {
  				baseObj[values[i]] = values[i + 1];
  			} else if (key !== '' && key !== null) {
  				// null is a speical value for explicitly removing a binding
  				warn(
  					("Invalid value for dynamic directive argument (expected string or null): " + key),
  					this
  				);
  			}
  		}
  		return baseObj
  	}
  	
  	// helper to dynamically append modifier runtime markers to event names.
  	// ensure only append when value is already string, otherwise it will be cast
  	// to string and cause the type check to miss.
  	function prependModifier (value, symbol) {
  		return typeof value === 'string' ? 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 = resolveScopedSlots;
  		target._g = bindObjectListeners;
  		target._d = bindDynamicKeys;
  		target._p = prependModifier;
  	}
  	
  	/*  */
  	
  	function FunctionalRenderContext (
  		data,
  		props,
  		children,
  		parent,
  		Ctor
  	) {
  		var this$1 = this;
  		
  		var options = Ctor.options;
  		// ensure the createElement function in functional components
  		// gets a unique context - this is necessary for correct named slot check
  		var contextVm;
  		if (hasOwn(parent, '_uid')) {
  			contextVm = Object.create(parent);
  			// $flow-disable-line
  			contextVm._original = parent;
  		} else {
  			// the context vm passed in is a functional context as well.
  			// in this case we want to make sure we are able to get a hold to the
  			// real context instance.
  			contextVm = parent;
  			// $flow-disable-line
  			parent = parent._original;
  		}
  		var isCompiled = isTrue(options._compiled);
  		var 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 () {
  			if (!this$1.$slots) {
  				normalizeScopedSlots(
  					data.scopedSlots,
  					this$1.$slots = resolveSlots(children, parent)
  				);
  			}
  			return this$1.$slots
  		};
  		
  		Object.defineProperty(this, 'scopedSlots', ({
  			enumerable: true,
  			get: function get () {
  				return normalizeScopedSlots(data.scopedSlots, this.slots())
  			}
  		}));
  		
  		// support for compiled functional template
  		if (isCompiled) {
  			// exposing $options for renderStatic()
  			this.$options = options;
  			// pre-resolve slots for renderSlot()
  			this.$slots = this.slots();
  			this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
  		}
  		
  		if (options._scopeId) {
  			this._c = function (a, b, c, d) {
  				var vnode = createElement(contextVm, a, b, c, d, needNormalization);
  				if (vnode && !Array.isArray(vnode)) {
  					vnode.fnScopeId = options._scopeId;
  					vnode.fnContext = parent;
  				}
  				return vnode
  			};
  		} else {
  			this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
  		}
  	}
  	
  	installRenderHelpers(FunctionalRenderContext.prototype);
  	
  	function createFunctionalComponent (
  		Ctor,
  		propsData,
  		data,
  		contextVm,
  		children
  	) {
  		var options = Ctor.options;
  		var props = {};
  		var propOptions = options.props;
  		if (isDef(propOptions)) {
  			for (var key in propOptions) {
  				props[key] = validateProp(key, propOptions, propsData || emptyObject);
  			}
  		} else {
  			if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
  			if (isDef(data.props)) { mergeProps(props, data.props); }
  		}
  		
  		var renderContext = new FunctionalRenderContext(
  			data,
  			props,
  			children,
  			contextVm,
  			Ctor
  		);
  		
  		var vnode = options.render.call(null, renderContext._c, renderContext);
  		
  		if (vnode instanceof VNode) {
  			return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
  		} else if (Array.isArray(vnode)) {
  			var vnodes = normalizeChildren(vnode) || [];
  			var res = new Array(vnodes.length);
  			for (var i = 0; i < vnodes.length; i++) {
  				res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
  			}
  			return res
  		}
  	}
  	
  	function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
  		// #7817 clone node before setting fnContext, otherwise if the node is reused
  		// (e.g. it was from a cached normal slot) the fnContext causes named slots
  		// that should not be matched to match.
  		var clone = cloneVNode(vnode);
  		clone.fnContext = contextVm;
  		clone.fnOptions = options;
  		{
  			(clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
  		}
  		if (data.slot) {
  			(clone.data || (clone.data = {})).slot = data.slot;
  		}
  		return clone
  	}
  	
  	function mergeProps (to, from) {
  		for (var key in from) {
  			to[camelize(key)] = from[key];
  		}
  	}
  	
  	/*  */
  	
  	/*  */
  	
  	/*  */
  	
  	/*  */
  	
  	// inline hooks to be invoked on component VNodes during patch
  	var componentVNodeHooks = {
  		init: function init (vnode, hydrating) {
  			if (
  				vnode.componentInstance &&
  				!vnode.componentInstance._isDestroyed &&
  				vnode.data.keepAlive
  			) {
  				// kept-alive components, treat as a patch
  				var mountedNode = vnode; // work around flow
  				componentVNodeHooks.prepatch(mountedNode, mountedNode);
  			} else {
  				var child = vnode.componentInstance = createComponentInstanceForVnode(
  					vnode,
  					activeInstance
  				);
  				child.$mount(hydrating ? vnode.elm : undefined, hydrating);
  			}
  		},
  		
  		prepatch: function prepatch (oldVnode, vnode) {
  			var options = vnode.componentOptions;
  			var child = vnode.componentInstance = oldVnode.componentInstance;
  			updateChildComponent(
  				child,
  				options.propsData, // updated props
  				options.listeners, // updated listeners
  				vnode, // new parent vnode
  				options.children // new children
  			);
  		},
  		
  		insert: function insert (vnode) {
  			var context = vnode.context;
  			var componentInstance = vnode.componentInstance;
  			if (!componentInstance._isMounted) {
  				componentInstance._isMounted = true;
  				callHook(componentInstance, 'mounted');
  			}
  			if (vnode.data.keepAlive) {
  				if (context._isMounted) {
  					// vue-router#1212
  					// During updates, a kept-alive component's child components may
  					// change, so directly walking the tree here may call activated hooks
  					// on incorrect children. Instead we push them into a queue which will
  					// be processed after the whole patch process ended.
  					queueActivatedComponent(componentInstance);
  				} else {
  					activateChildComponent(componentInstance, true /* direct */);
  				}
  			}
  		},
  		
  		destroy: function destroy (vnode) {
  			var componentInstance = vnode.componentInstance;
  			if (!componentInstance._isDestroyed) {
  				if (!vnode.data.keepAlive) {
  					componentInstance.$destroy();
  				} else {
  					deactivateChildComponent(componentInstance, true /* direct */);
  				}
  			}
  		}
  	};
  	
  	var hooksToMerge = Object.keys(componentVNodeHooks);
  	
  	function createComponent (
  		Ctor,
  		data,
  		context,
  		children,
  		tag
  	) {
  		if (isUndef(Ctor)) {
  			return
  		}
  		
  		var baseCtor = context.$options._base;
  		
  		// plain options object: turn it into a constructor
  		if (isObject(Ctor)) {
  			Ctor = baseCtor.extend(Ctor);
  		}
  		
  		// if at this stage it's not a constructor or an async component factory,
  		// reject.
  		if (typeof Ctor !== 'function') {
  			{
  				warn(("Invalid Component definition: " + (String(Ctor))), context);
  			}
  			return
  		}
  		
  		// async component
  		var asyncFactory;
  		if (isUndef(Ctor.cid)) {
  			asyncFactory = Ctor;
  			Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
  			if (Ctor === undefined) {
  				// return a placeholder node for async component, which is rendered
  				// as a comment node but preserves all the raw information for the node.
  				// the information will be used for async server-rendering and hydration.
  				return createAsyncPlaceholder(
  					asyncFactory,
  					data,
  					context,
  					children,
  					tag
  				)
  			}
  		}
  		
  		data = data || {};
  		
  		// resolve constructor options in case global mixins are applied after
  		// component constructor creation
  		resolveConstructorOptions(Ctor);
  		
  		// transform component v-model data into props & events
  		if (isDef(data.model)) {
  			transformModel(Ctor.options, data);
  		}
  		
  		// extract props
  		var propsData = extractPropsFromVNodeData(data, Ctor, tag);
  		
  		// functional component
  		if (isTrue(Ctor.options.functional)) {
  			return createFunctionalComponent(Ctor, propsData, data, context, children)
  		}
  		
  		// extract listeners, since these needs to be treated as
  		// child component listeners instead of DOM listeners
  		var listeners = data.on;
  		// replace with listeners with .native modifier
  		// so it gets processed during parent component patch.
  		data.on = data.nativeOn;
  		
  		if (isTrue(Ctor.options.abstract)) {
  			// abstract components do not keep anything
  			// other than props & listeners & slot
  			
  			// work around flow
  			var slot = data.slot;
  			data = {};
  			if (slot) {
  				data.slot = slot;
  			}
  		}
  		
  		// install component management hooks onto the placeholder node
  		installComponentHooks(data);
  		
  		// return a placeholder vnode
  		var name = Ctor.options.name || tag;
  		var vnode = new VNode(
  			("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
  			data, undefined, undefined, undefined, context,
  			{ Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
  			asyncFactory
  		);
  		
  		return vnode
  	}
  	
  	function createComponentInstanceForVnode (
  		vnode, // we know it's MountedComponentVNode but flow doesn't
  		parent // activeInstance in lifecycle state
  	) {
  		var options = {
  			_isComponent: true,
  			_parentVnode: vnode,
  			parent: parent
  		};
  		// check inline-template render functions
  		var inlineTemplate = vnode.data.inlineTemplate;
  		if (isDef(inlineTemplate)) {
  			options.render = inlineTemplate.render;
  			options.staticRenderFns = inlineTemplate.staticRenderFns;
  		}
  		return new vnode.componentOptions.Ctor(options)
  	}
  	
  	function installComponentHooks (data) {
  		var hooks = data.hook || (data.hook = {});
  		for (var i = 0; i < hooksToMerge.length; i++) {
  			var key = hooksToMerge[i];
  			var existing = hooks[key];
  			var toMerge = componentVNodeHooks[key];
  			if (existing !== toMerge && !(existing && existing._merged)) {
  				hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
  			}
  		}
  	}
  	
  	function mergeHook$1 (f1, f2) {
  		var merged = function (a, b) {
  			// flow complains about extra args which is why we use any
  			f1(a, b);
  			f2(a, b);
  		};
  		merged._merged = true;
  		return merged
  	}
  	
  	// transform component v-model info (value and callback) into
  	// prop and event handler respectively.
  	function transformModel (options, data) {
  		var prop = (options.model && options.model.prop) || 'value';
  		var event = (options.model && options.model.event) || 'input'
  		;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
  		var on = data.on || (data.on = {});
  		var existing = on[event];
  		var callback = data.model.callback;
  		if (isDef(existing)) {
  			if (
  				Array.isArray(existing)
  					? existing.indexOf(callback) === -1
  					: existing !== callback
  			) {
  				on[event] = [callback].concat(existing);
  			}
  		} else {
  			on[event] = callback;
  		}
  	}
  	
  	/*  */
  	
  	var SIMPLE_NORMALIZE = 1;
  	var ALWAYS_NORMALIZE = 2;
  	
  	// wrapper function for providing a more flexible interface
  	// without getting yelled at by flow
  	function createElement (
  		context,
  		tag,
  		data,
  		children,
  		normalizationType,
  		alwaysNormalize
  	) {
  		if (Array.isArray(data) || isPrimitive(data)) {
  			normalizationType = children;
  			children = data;
  			data = undefined;
  		}
  		if (isTrue(alwaysNormalize)) {
  			normalizationType = ALWAYS_NORMALIZE;
  		}
  		return _createElement(context, tag, data, children, normalizationType)
  	}
  	
  	function _createElement (
  		context,
  		tag,
  		data,
  		children,
  		normalizationType
  	) {
  		if (isDef(data) && isDef((data).__ob__)) {
  			warn(
  				"Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
  				'Always create fresh vnode data objects in each render!',
  				context
  			);
  			return createEmptyVNode()
  		}
  		// object syntax in v-bind
  		if (isDef(data) && isDef(data.is)) {
  			tag = data.is;
  		}
  		if (!tag) {
  			// in case of component :is set to falsy value
  			return createEmptyVNode()
  		}
  		// warn against non-primitive key
  		if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)
  		) {
  			{
  				warn(
  					'Avoid using non-primitive value as key, ' +
  					'use string/number value instead.',
  					context
  				);
  			}
  		}
  		// support single function children as default scoped slot
  		if (Array.isArray(children) &&
  			typeof children[0] === 'function'
  		) {
  			data = data || {};
  			data.scopedSlots = { default: children[0] };
  			children.length = 0;
  		}
  		if (normalizationType === ALWAYS_NORMALIZE) {
  			children = normalizeChildren(children);
  		} else if (normalizationType === SIMPLE_NORMALIZE) {
  			children = simpleNormalizeChildren(children);
  		}
  		var vnode, ns;
  		if (typeof tag === 'string') {
  			var Ctor;
  			ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
  			if (config.isReservedTag(tag)) {
  				// platform built-in elements
  				vnode = new VNode(
  					config.parsePlatformTagName(tag), data, children,
  					undefined, undefined, context
  				);
  			} else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
  				// component
  				vnode = createComponent(Ctor, data, context, children, tag);
  			} else {
  				// unknown or unlisted namespaced elements
  				// check at runtime because it may get assigned a namespace when its
  				// parent normalizes children
  				vnode = new VNode(
  					tag, data, children,
  					undefined, undefined, context
  				);
  			}
  		} else {
  			// direct component options / constructor
  			vnode = createComponent(tag, data, context, children);
  		}
  		if (Array.isArray(vnode)) {
  			return vnode
  		} else if (isDef(vnode)) {
  			if (isDef(ns)) { applyNS(vnode, ns); }
  			if (isDef(data)) { registerDeepBindings(data); }
  			return vnode
  		} else {
  			return createEmptyVNode()
  		}
  	}
  	
  	function applyNS (vnode, ns, force) {
  		vnode.ns = ns;
  		if (vnode.tag === 'foreignObject') {
  			// use default namespace inside foreignObject
  			ns = undefined;
  			force = true;
  		}
  		if (isDef(vnode.children)) {
  			for (var i = 0, l = vnode.children.length; i < l; i++) {
  				var child = vnode.children[i];
  				if (isDef(child.tag) && (
  					isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
  					applyNS(child, ns, force);
  				}
  			}
  		}
  	}
  	
  	// ref #5318
  	// necessary to ensure parent re-render when deep bindings like :style and
  	// :class are used on slot nodes
  	function registerDeepBindings (data) {
  		if (isObject(data.style)) {
  			traverse(data.style);
  		}
  		if (isObject(data.class)) {
  			traverse(data.class);
  		}
  	}
  	
  	/*  */
  	
  	function initRender (vm) {
  		vm._vnode = null; // the root of the child tree
  		vm._staticTrees = null; // v-once cached trees
  		var options = vm.$options;
  		var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree
  		var renderContext = parentVnode && parentVnode.context;
  		vm.$slots = resolveSlots(options._renderChildren, renderContext);
  		vm.$scopedSlots = emptyObject;
  		// bind the createElement fn to this instance
  		// so that we get proper render context inside it.
  		// args order: tag, data, children, normalizationType, alwaysNormalize
  		// internal version is used by render functions compiled from templates
  		vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
  		// normalization is always applied for the public version, used in
  		// user-written render functions.
  		vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
  		
  		// $attrs & $listeners are exposed for easier HOC creation.
  		// they need to be reactive so that HOCs using them are always updated
  		var parentData = parentVnode && parentVnode.data;
  		
  		/* istanbul ignore else */
  		{
  			defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
  				!isUpdatingChildComponent && warn("$attrs is readonly.", vm);
  			}, true);
  			defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
  				!isUpdatingChildComponent && warn("$listeners is readonly.", vm);
  			}, true);
  		}
  	}
  	
  	var currentRenderingInstance = null;
  	
  	function renderMixin (Vue) {
  		// install runtime convenience helpers
  		installRenderHelpers(Vue.prototype);
  		
  		Vue.prototype.$nextTick = function (fn) {
  			return nextTick(fn, this)
  		};
  		
  		Vue.prototype._render = function () {
  			var vm = this;
  			var ref = vm.$options;
  			var render = ref.render;
  			var _parentVnode = ref._parentVnode;
  			
  			if (_parentVnode) {
  				vm.$scopedSlots = normalizeScopedSlots(
  					_parentVnode.data.scopedSlots,
  					vm.$slots,
  					vm.$scopedSlots
  				);
  			}
  			
  			// set parent vnode. this allows render functions to have access
  			// to the data on the placeholder node.
  			vm.$vnode = _parentVnode;
  			// render self
  			var vnode;
  			try {
  				// There's no need to maintain a stack becaues all render fns are called
  				// separately from one another. Nested component's render fns are called
  				// when parent component is patched.
  				currentRenderingInstance = vm;
  				vnode = render.call(vm._renderProxy, vm.$createElement);
  			} catch (e) {
  				handleError(e, vm, "render");
  				// return error render result,
  				// or previous vnode to prevent render error causing blank component
  				/* istanbul ignore else */
  				if (vm.$options.renderError) {
  					try {
  						vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
  					} catch (e) {
  						handleError(e, vm, "renderError");
  						vnode = vm._vnode;
  					}
  				} else {
  					vnode = vm._vnode;
  				}
  			} finally {
  				currentRenderingInstance = null;
  			}
  			// if the returned array contains only a single node, allow it
  			if (Array.isArray(vnode) && vnode.length === 1) {
  				vnode = vnode[0];
  			}
  			// return empty vnode in case the render function errored out
  			if (!(vnode instanceof VNode)) {
  				if (Array.isArray(vnode)) {
  					warn(
  						'Multiple root nodes returned from render function. Render function ' +
  						'should return a single root node.',
  						vm
  					);
  				}
  				vnode = createEmptyVNode();
  			}
  			// set parent
  			vnode.parent = _parentVnode;
  			return vnode
  		};
  	}
  	
  	/*  */
  	
  	function ensureCtor (comp, base) {
  		if (
  			comp.__esModule ||
  			(hasSymbol && comp[Symbol.toStringTag] === 'Module')
  		) {
  			comp = comp.default;
  		}
  		return isObject(comp)
  			? base.extend(comp)
  			: comp
  	}
  	
  	function createAsyncPlaceholder (
  		factory,
  		data,
  		context,
  		children,
  		tag
  	) {
  		var node = createEmptyVNode();
  		node.asyncFactory = factory;
  		node.asyncMeta = { data: data, context: context, children: children, tag: tag };
  		return node
  	}
  	
  	function resolveAsyncComponent (
  		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) && factory.owners.indexOf(owner) === -1) {
  			// already pending
  			factory.owners.push(owner);
  		}
  		
  		if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
  			return factory.loadingComp
  		}
  		
  		if (owner && !isDef(factory.owners)) {
  			var owners = factory.owners = [owner];
  			var sync = true;
  			var timerLoading = null;
  			var 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();
  				}
  				
  				if (renderCompleted) {
  					owners.length = 0;
  					if (timerLoading !== null) {
  						clearTimeout(timerLoading);
  						timerLoading = null;
  					}
  					if (timerTimeout !== null) {
  						clearTimeout(timerTimeout);
  						timerTimeout = null;
  					}
  				}
  			};
  			
  			var resolve = once(function (res) {
  				// cache resolved
  				factory.resolved = ensureCtor(res, baseCtor);
  				// invoke callbacks only if this is not a synchronous resolve
  				// (async resolves are shimmed as synchronous during SSR)
  				if (!sync) {
  					forceRender(true);
  				} else {
  					owners.length = 0;
  				}
  			});
  			
  			var reject = once(function (reason) {
  				warn(
  					"Failed to resolve async component: " + (String(factory)) +
  					(reason ? ("\nReason: " + reason) : '')
  				);
  				if (isDef(factory.errorComp)) {
  					factory.error = true;
  					forceRender(true);
  				}
  			});
  			
  			var res = factory(resolve, reject);
  			
  			if (isObject(res)) {
  				if (isPromise(res)) {
  					// () => Promise
  					if (isUndef(factory.resolved)) {
  						res.then(resolve, reject);
  					}
  				} else if (isPromise(res.component)) {
  					res.component.then(resolve, reject);
  					
  					if (isDef(res.error)) {
  						factory.errorComp = ensureCtor(res.error, baseCtor);
  					}
  					
  					if (isDef(res.loading)) {
  						factory.loadingComp = ensureCtor(res.loading, baseCtor);
  						if (res.delay === 0) {
  							factory.loading = true;
  						} else {
  							timerLoading = setTimeout(function () {
  								timerLoading = null;
  								if (isUndef(factory.resolved) && isUndef(factory.error)) {
  									factory.loading = true;
  									forceRender(false);
  								}
  							}, res.delay || 200);
  						}
  					}
  					
  					if (isDef(res.timeout)) {
  						timerTimeout = setTimeout(function () {
  							timerTimeout = null;
  							if (isUndef(factory.resolved)) {
  								reject(
  									"timeout (" + (res.timeout) + "ms)"
  								);
  							}
  						}, res.timeout);
  					}
  				}
  			}
  			
  			sync = false;
  			// return in case resolved synchronously
  			return factory.loading
  				? factory.loadingComp
  				: factory.resolved
  		}
  	}
  	
  	/*  */
  	
  	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 initEvents (vm) {
  		vm._events = Object.create(null);
  		vm._hasHookEvent = false;
  		// init parent attached events
  		var listeners = vm.$options._parentListeners;
  		if (listeners) {
  			updateComponentListeners(vm, listeners);
  		}
  	}
  	
  	var target;
  	
  	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);
  			if (res !== null) {
  				_target.$off(event, onceHandler);
  			}
  		}
  	}
  	
  	function updateComponentListeners (
  		vm,
  		listeners,
  		oldListeners
  	) {
  		target = vm;
  		updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
  		target = undefined;
  	}
  	
  	function eventsMixin (Vue) {
  		var hookRE = /^hook:/;
  		Vue.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);
  				// optimize hook:event cost by using a boolean flag marked at registration
  				// instead of a hash lookup
  				if (hookRE.test(event)) {
  					vm._hasHookEvent = true;
  				}
  			}
  			return vm
  		};
  		
  		Vue.prototype.$once = function (event, fn) {
  			var vm = this;
  			function on () {
  				vm.$off(event, on);
  				fn.apply(vm, arguments);
  			}
  			on.fn = fn;
  			vm.$on(event, on);
  			return vm
  		};
  		
  		Vue.prototype.$off = function (event, fn) {
  			var vm = this;
  			// all
  			if (!arguments.length) {
  				vm._events = Object.create(null);
  				return vm
  			}
  			// array of events
  			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
  			}
  			// specific event
  			var cbs = vm._events[event];
  			if (!cbs) {
  				return vm
  			}
  			if (!fn) {
  				vm._events[event] = null;
  				return vm
  			}
  			// specific handler
  			var cb;
  			var i = cbs.length;
  			while (i--) {
  				cb = cbs[i];
  				if (cb === fn || cb.fn === fn) {
  					cbs.splice(i, 1);
  					break
  				}
  			}
  			return vm
  		};
  		
  		Vue.prototype.$emit = function (event) {
  			var vm = this;
  			{
  				var lowerCaseEvent = event.toLowerCase();
  				if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
  					tip(
  						"Event \"" + lowerCaseEvent + "\" is emitted in component " +
  						(formatComponentName(vm)) + " 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 = vm._events[event];
  			if (cbs) {
  				cbs = cbs.length > 1 ? toArray(cbs) : cbs;
  				var args = toArray(arguments, 1);
  				var info = "event handler for \"" + event + "\"";
  				for (var i = 0, l = cbs.length; i < l; i++) {
  					invokeWithErrorHandling(cbs[i], vm, args, vm, info);
  				}
  			}
  			return vm
  		};
  	}
  	
  	/*  */
  	
  	var activeInstance = null;
  	var isUpdatingChildComponent = false;
  	
  	function setActiveInstance(vm) {
  		var prevActiveInstance = activeInstance;
  		activeInstance = vm;
  		return function () {
  			activeInstance = prevActiveInstance;
  		}
  	}
  	
  	function initLifecycle (vm) {
  		var options = vm.$options;
  		
  		// locate first non-abstract parent
  		var parent = options.parent;
  		if (parent && !options.abstract) {
  			while (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 = false;
  		vm._isMounted = false;
  		vm._isDestroyed = false;
  		vm._isBeingDestroyed = false;
  	}
  	
  	function lifecycleMixin (Vue) {
  		Vue.prototype._update = function (vnode, hydrating) {
  			var vm = this;
  			var prevEl = vm.$el;
  			var prevVnode = vm._vnode;
  			var restoreActiveInstance = setActiveInstance(vm);
  			vm._vnode = vnode;
  			// Vue.prototype.__patch__ is injected in entry points
  			// based on the rendering backend used.
  			if (!prevVnode) {
  				// initial render
  				vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
  			} else {
  				// updates
  				vm.$el = vm.__patch__(prevVnode, vnode);
  			}
  			restoreActiveInstance();
  			// update __vue__ reference
  			if (prevEl) {
  				prevEl.__vue__ = null;
  			}
  			if (vm.$el) {
  				vm.$el.__vue__ = vm;
  			}
  			// if parent is an HOC, update its $el as well
  			if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
  				vm.$parent.$el = vm.$el;
  			}
  			// updated hook is called by the scheduler to ensure that children are
  			// updated in a parent's updated hook.
  		};
  		
  		Vue.prototype.$forceUpdate = function () {
  			var vm = this;
  			if (vm._watcher) {
  				vm._watcher.update();
  			}
  		};
  		
  		Vue.prototype.$destroy = function () {
  			var vm = this;
  			if (vm._isBeingDestroyed) {
  				return
  			}
  			callHook(vm, 'beforeDestroy');
  			vm._isBeingDestroyed = true;
  			// remove self from parent
  			var parent = vm.$parent;
  			if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
  				remove(parent.$children, vm);
  			}
  			// teardown watchers
  			if (vm._watcher) {
  				vm._watcher.teardown();
  			}
  			var i = vm._watchers.length;
  			while (i--) {
  				vm._watchers[i].teardown();
  			}
  			// remove reference from data ob
  			// frozen object may not have observer.
  			if (vm._data.__ob__) {
  				vm._data.__ob__.vmCount--;
  			}
  			// call the last hook...
  			vm._isDestroyed = true;
  			// invoke destroy hooks on current rendered tree
  			vm.__patch__(vm._vnode, null);
  			// fire destroyed hook
  			callHook(vm, 'destroyed');
  			// turn off all instance listeners.
  			vm.$off();
  			// remove __vue__ reference
  			if (vm.$el) {
  				vm.$el.__vue__ = null;
  			}
  			// release circular reference (#6759)
  			if (vm.$vnode) {
  				vm.$vnode.parent = null;
  			}
  		};
  	}
  	
  	function mountComponent (
  		vm,
  		el,
  		hydrating
  	) {
  		vm.$el = el;
  		if (!vm.$options.render) {
  			vm.$options.render = createEmptyVNode;
  			{
  				/* istanbul ignore if */
  				if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
  					vm.$options.el || el) {
  					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
  					);
  				} else {
  					warn(
  						'Failed to mount component: template or render function not defined.',
  						vm
  					);
  				}
  			}
  		}
  		callHook(vm, 'beforeMount');
  		
  		var updateComponent;
  		/* istanbul ignore if */
  		if (config.performance && mark) {
  			updateComponent = function () {
  				var name = vm._name;
  				var id = vm._uid;
  				var startTag = "vue-perf-start:" + id;
  				var endTag = "vue-perf-end:" + id;
  				
  				mark(startTag);
  				var vnode = vm._render();
  				mark(endTag);
  				measure(("vue " + name + " render"), startTag, endTag);
  				
  				mark(startTag);
  				vm._update(vnode, hydrating);
  				mark(endTag);
  				measure(("vue " + name + " patch"), startTag, endTag);
  			};
  		} else {
  			updateComponent = function () {
  				vm._update(vm._render(), hydrating);
  			};
  		}
  		
  		// we set this to vm._watcher inside the watcher's constructor
  		// since the watcher's initial patch may call $forceUpdate (e.g. inside child
  		// component's mounted hook), which relies on vm._watcher being already defined
  		new Watcher(vm, updateComponent, noop, {
  			before: function before () {
  				if (vm._isMounted && !vm._isDestroyed) {
  					callHook(vm, 'beforeUpdate');
  				}
  			}
  		}, true /* isRenderWatcher */);
  		hydrating = false;
  		
  		// manually mounted instance, call mounted on self
  		// mounted is called for render-created child components in its inserted hook
  		if (vm.$vnode == null) {
  			vm._isMounted = true;
  			callHook(vm, 'mounted');
  		}
  		return vm
  	}
  	
  	function updateChildComponent (
  		vm,
  		propsData,
  		listeners,
  		parentVnode,
  		renderChildren
  	) {
  		{
  			isUpdatingChildComponent = true;
  		}
  		
  		// determine whether component has slot children
  		// we need to do this before overwriting $options._renderChildren.
  		
  		// check if there are dynamic scopedSlots (hand-written or compiled but with
  		// dynamic slot names). Static scoped slots compiled from template has the
  		// "$stable" marker.
  		var newScopedSlots = parentVnode.data.scopedSlots;
  		var oldScopedSlots = vm.$scopedSlots;
  		var hasDynamicScopedSlot = !!(
  			(newScopedSlots && !newScopedSlots.$stable) ||
  			(oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
  			(newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
  		);
  		
  		// Any static slot children from the parent may have changed during parent's
  		// update. Dynamic scoped slots may also have changed. In such cases, a forced
  		// update is necessary to ensure correctness.
  		var needsForceUpdate = !!(
  			renderChildren ||               // has new static slots
  			vm.$options._renderChildren ||  // has old static slots
  			hasDynamicScopedSlot
  		);
  		
  		vm.$options._parentVnode = parentVnode;
  		vm.$vnode = parentVnode; // update vm's placeholder node without re-render
  		
  		if (vm._vnode) { // update child tree's parent
  			vm._vnode.parent = parentVnode;
  		}
  		vm.$options._renderChildren = renderChildren;
  		
  		// update $attrs and $listeners hash
  		// these are also reactive so they may trigger child update if the child
  		// used them during render
  		vm.$attrs = parentVnode.data.attrs || emptyObject;
  		vm.$listeners = listeners || emptyObject;
  		
  		// update props
  		if (propsData && vm.$options.props) {
  			toggleObserving(false);
  			var props = vm._props;
  			var propKeys = vm.$options._propKeys || [];
  			for (var i = 0; i < propKeys.length; i++) {
  				var key = propKeys[i];
  				var propOptions = vm.$options.props; // wtf flow?
  				props[key] = validateProp(key, propOptions, propsData, vm);
  			}
  			toggleObserving(true);
  			// keep a copy of raw propsData
  			vm.$options.propsData = propsData;
  		}
  		
  		// update listeners
  		listeners = listeners || emptyObject;
  		var oldListeners = vm.$options._parentListeners;
  		vm.$options._parentListeners = listeners;
  		updateComponentListeners(vm, listeners, oldListeners);
  		
  		// resolve slots + force update if has children
  		if (needsForceUpdate) {
  			vm.$slots = resolveSlots(renderChildren, parentVnode.context);
  			vm.$forceUpdate();
  		}
  		
  		{
  			isUpdatingChildComponent = false;
  		}
  	}
  	
  	function isInInactiveTree (vm) {
  		while (vm && (vm = vm.$parent)) {
  			if (vm._inactive) { return true }
  		}
  		return false
  	}
  	
  	function activateChildComponent (vm, direct) {
  		if (direct) {
  			vm._directInactive = false;
  			if (isInInactiveTree(vm)) {
  				return
  			}
  		} else if (vm._directInactive) {
  			return
  		}
  		if (vm._inactive || vm._inactive === null) {
  			vm._inactive = false;
  			for (var i = 0; i < vm.$children.length; i++) {
  				activateChildComponent(vm.$children[i]);
  			}
  			callHook(vm, 'activated');
  		}
  	}
  	
  	function deactivateChildComponent (vm, direct) {
  		if (direct) {
  			vm._directInactive = true;
  			if (isInInactiveTree(vm)) {
  				return
  			}
  		}
  		if (!vm._inactive) {
  			vm._inactive = true;
  			for (var i = 0; i < vm.$children.length; i++) {
  				deactivateChildComponent(vm.$children[i]);
  			}
  			callHook(vm, 'deactivated');
  		}
  	}
  	
  	function callHook (vm, hook) {
  		// #7573 disable dep collection when invoking lifecycle hooks
  		pushTarget();
  		var handlers = vm.$options[hook];
  		var info = hook + " hook";
  		if (handlers) {
  			for (var i = 0, j = handlers.length; i < j; i++) {
  				invokeWithErrorHandling(handlers[i], vm, null, vm, info);
  			}
  		}
  		if (vm._hasHookEvent) {
  			vm.$emit('hook:' + hook);
  		}
  		popTarget();
  	}
  	
  	/*  */
  	
  	var MAX_UPDATE_COUNT = 100;
  	
  	var queue = [];
  	var activatedChildren = [];
  	var has = {};
  	var circular = {};
  	var waiting = false;
  	var flushing = false;
  	var index = 0;
  	
  	/**
  	 * Reset the scheduler's state.
  	 */
  	function resetSchedulerState () {
  		index = queue.length = activatedChildren.length = 0;
  		has = {};
  		{
  			circular = {};
  		}
  		waiting = flushing = false;
  	}
  	
  	// Async edge case #6566 requires saving the timestamp when event listeners are
  	// attached. However, calling performance.now() has a perf overhead especially
  	// if the page has thousands of event listeners. Instead, we take a timestamp
  	// every time the scheduler flushes and use that for all event listeners
  	// attached during that flush.
  	var currentFlushTimestamp = 0;
  	
  	// Async edge case fix requires storing an event listener's attach timestamp.
  	var getNow = Date.now;
  	
  	// Determine what event timestamp the browser is using. Annoyingly, the
  	// timestamp can either be hi-res (relative to page load) or low-res
  	// (relative to UNIX epoch), so in order to compare time we have to use the
  	// same timestamp type when saving the flush timestamp.
  	// All IE versions use low-res event timestamps, and have problematic clock
  	// implementations (#9632)
  	if (inBrowser && !isIE) {
  		var performance = window.performance;
  		if (
  			performance &&
  			typeof performance.now === 'function' &&
  			getNow() > document.createEvent('Event').timeStamp
  		) {
  			// if the event timestamp, although evaluated AFTER the Date.now(), is
  			// smaller than it, it means the event is using a hi-res timestamp,
  			// and we need to use the hi-res version for event listener timestamps as
  			// well.
  			getNow = function () { return performance.now(); };
  		}
  	}
  	
  	/**
  	 * Flush both queues and run the watchers.
  	 */
  	function flushSchedulerQueue () {
  		currentFlushTimestamp = getNow();
  		flushing = true;
  		var watcher, id;
  		
  		// Sort queue before flush.
  		// This ensures that:
  		// 1. Components are updated from parent to child. (because parent is always
  		//    created before the child)
  		// 2. A component's user watchers are run before its render watcher (because
  		//    user watchers are created before the render watcher)
  		// 3. If a component is destroyed during a parent component's watcher run,
  		//    its watchers can be skipped.
  		queue.sort(function (a, b) { return a.id - b.id; });
  		
  		// do not cache length because more watchers might be pushed
  		// as we run existing watchers
  		for (index = 0; index < queue.length; index++) {
  			watcher = queue[index];
  			if (watcher.before) {
  				watcher.before();
  			}
  			id = watcher.id;
  			has[id] = null;
  			watcher.run();
  			// in dev build, check and stop circular updates.
  			if (has[id] != null) {
  				circular[id] = (circular[id] || 0) + 1;
  				if (circular[id] > MAX_UPDATE_COUNT) {
  					warn(
  						'You may have an infinite update loop ' + (
  							watcher.user
  								? ("in watcher with expression \"" + (watcher.expression) + "\"")
  								: "in a component render function."
  						),
  						watcher.vm
  					);
  					break
  				}
  			}
  		}
  		
  		// keep copies of post queues before resetting state
  		var activatedQueue = activatedChildren.slice();
  		var updatedQueue = queue.slice();
  		
  		resetSchedulerState();
  		
  		// call component updated and activated hooks
  		callActivatedHooks(activatedQueue);
  		callUpdatedHooks(updatedQueue);
  		
  		// devtool hook
  		/* istanbul ignore if */
  		if (devtools && config.devtools) {
  			devtools.emit('flush');
  		}
  	}
  	
  	function callUpdatedHooks (queue) {
  		var i = queue.length;
  		while (i--) {
  			var watcher = queue[i];
  			var vm = watcher.vm;
  			if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
  				callHook(vm, 'updated');
  			}
  		}
  	}
  	
  	/**
  	 * Queue a kept-alive component that was activated during patch.
  	 * The queue will be processed after the entire tree has been patched.
  	 */
  	function queueActivatedComponent (vm) {
  		// setting _inactive to false here so that a render function can
  		// rely on checking whether it's in an inactive tree (e.g. router-view)
  		vm._inactive = false;
  		activatedChildren.push(vm);
  	}
  	
  	function callActivatedHooks (queue) {
  		for (var i = 0; i < queue.length; i++) {
  			queue[i]._inactive = true;
  			activateChildComponent(queue[i], true /* true */);
  		}
  	}
  	
  	/**
  	 * Push a watcher into the watcher queue.
  	 * Jobs with duplicate IDs will be skipped unless it's
  	 * pushed when the queue is being flushed.
  	 */
  	function queueWatcher (watcher) {
  		var id = watcher.id;
  		if (has[id] == null) {
  			has[id] = true;
  			if (!flushing) {
  				queue.push(watcher);
  			} else {
  				// if already flushing, splice the watcher based on its id
  				// if already past its id, it will be run next immediately.
  				var i = queue.length - 1;
  				while (i > index && queue[i].id > watcher.id) {
  					i--;
  				}
  				queue.splice(i + 1, 0, watcher);
  			}
  			// queue the flush
  			if (!waiting) {
  				waiting = true;
  				
  				if (!config.async) {
  					flushSchedulerQueue();
  					return
  				}
  				nextTick(flushSchedulerQueue);
  			}
  		}
  	}
  	
  	/*  */
  	
  	
  	
  	var uid$2 = 0;
  	
  	/**
  	 * A watcher parses an expression, collects dependencies,
  	 * and fires callback when the expression value changes.
  	 * This is used for both the $watch() api and directives.
  	 */
  	var Watcher = function Watcher (
  		vm,
  		expOrFn,
  		cb,
  		options,
  		isRenderWatcher
  	) {
  		this.vm = vm;
  		if (isRenderWatcher) {
  			vm._watcher = this;
  		}
  		vm._watchers.push(this);
  		// options
  		if (options) {
  			this.deep = !!options.deep;
  			this.user = !!options.user;
  			this.lazy = !!options.lazy;
  			this.sync = !!options.sync;
  			this.before = options.before;
  		} else {
  			this.deep = this.user = this.lazy = this.sync = false;
  		}
  		this.cb = cb;
  		this.id = ++uid$2; // uid for batching
  		this.active = true;
  		this.dirty = this.lazy; // for lazy watchers
  		this.deps = [];
  		this.newDeps = [];
  		this.depIds = new _Set();
  		this.newDepIds = new _Set();
  		this.expression = expOrFn.toString();
  		// parse expression for getter
  		if (typeof expOrFn === 'function') {
  			this.getter = expOrFn;
  		} else {
  			this.getter = parsePath(expOrFn);
  			if (!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
  			? undefined
  			: this.get();
  	};
  	
  	/**
  	 * Evaluate the getter, and re-collect dependencies.
  	 */
  	Watcher.prototype.get = function get () {
  		pushTarget(this);
  		var value;
  		var 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 {
  			// "touch" every property so they are all tracked as
  			// dependencies for deep watching
  			if (this.deep) {
  				traverse(value);
  			}
  			popTarget();
  			this.cleanupDeps();
  		}
  		return value
  	};
  	
  	/**
  	 * Add a dependency to this directive.
  	 */
  	Watcher.prototype.addDep = function addDep (dep) {
  		var id = dep.id;
  		if (!this.newDepIds.has(id)) {
  			this.newDepIds.add(id);
  			this.newDeps.push(dep);
  			if (!this.depIds.has(id)) {
  				dep.addSub(this);
  			}
  		}
  	};
  	
  	/**
  	 * Clean up for dependency collection.
  	 */
  	Watcher.prototype.cleanupDeps = function cleanupDeps () {
  		var i = this.deps.length;
  		while (i--) {
  			var dep = this.deps[i];
  			if (!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;
  	};
  	
  	/**
  	 * Subscriber interface.
  	 * Will be called when a dependency changes.
  	 */
  	Watcher.prototype.update = function update () {
  		/* istanbul ignore else */
  		if (this.lazy) {
  			this.dirty = true;
  		} else if (this.sync) {
  			this.run();
  		} else {
  			queueWatcher(this);
  		}
  	};
  	
  	/**
  	 * Scheduler job interface.
  	 * Will be called by the scheduler.
  	 */
  	Watcher.prototype.run = function run () {
  		if (this.active) {
  			var value = this.get();
  			if (
  				value !== this.value ||
  				// Deep watchers and watchers on Object/Arrays should fire even
  				// when the value is the same, because the value may
  				// have mutated.
  				isObject(value) ||
  				this.deep
  			) {
  				// set new value
  				var oldValue = this.value;
  				this.value = value;
  				if (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);
  				}
  			}
  		}
  	};
  	
  	/**
  	 * Evaluate the value of the watcher.
  	 * This only gets called for lazy watchers.
  	 */
  	Watcher.prototype.evaluate = function evaluate () {
  		this.value = this.get();
  		this.dirty = false;
  	};
  	
  	/**
  	 * Depend on all deps collected by this watcher.
  	 */
  	Watcher.prototype.depend = function depend () {
  		var i = this.deps.length;
  		while (i--) {
  			this.deps[i].depend();
  		}
  	};
  	
  	/**
  	 * Remove self from all dependencies' subscriber list.
  	 */
  	Watcher.prototype.teardown = function teardown () {
  		if (this.active) {
  			// remove self from vm's watcher list
  			// this is a somewhat expensive operation so we skip it
  			// if the vm is being destroyed.
  			if (!this.vm._isBeingDestroyed) {
  				remove(this.vm._watchers, this);
  			}
  			var i = this.deps.length;
  			while (i--) {
  				this.deps[i].removeSub(this);
  			}
  			this.active = false;
  		}
  	};
  	
  	/*  */
  	
  	var sharedPropertyDefinition = {
  		enumerable: true,
  		configurable: true,
  		get: noop,
  		set: noop
  	};
  	
  	function proxy (target, sourceKey, key) {
  		sharedPropertyDefinition.get = function proxyGetter () {
  			return this[sourceKey][key]
  		};
  		sharedPropertyDefinition.set = function proxySetter (val) {
  			this[sourceKey][key] = val;
  		};
  		Object.defineProperty(target, key, sharedPropertyDefinition);
  	}
  	
  	function initState (vm) {
  		vm._watchers = [];
  		var opts = vm.$options;
  		if (opts.props) { initProps(vm, opts.props); }
  		if (opts.methods) { initMethods(vm, opts.methods); }
  		if (opts.data) {
  			initData(vm);
  		} else {
  			observe(vm._data = {}, true /* asRootData */);
  		}
  		if (opts.computed) { initComputed(vm, opts.computed); }
  		if (opts.watch && opts.watch !== nativeWatch) {
  			initWatch(vm, opts.watch);
  		}
  	}
  	
  	function initProps (vm, propsOptions) {
  		var propsData = vm.$options.propsData || {};
  		var props = vm._props = {};
  		// cache prop keys so that future props updates can iterate using Array
  		// instead of dynamic object key enumeration.
  		var keys = vm.$options._propKeys = [];
  		var isRoot = !vm.$parent;
  		// root instance props should be converted
  		if (!isRoot) {
  			toggleObserving(false);
  		}
  		var loop = function ( key ) {
  			keys.push(key);
  			var value = validateProp(key, propsOptions, propsData, vm);
  			/* istanbul ignore else */
  			{
  				var hyphenatedKey = hyphenate(key);
  				if (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 () {
  					if (!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
  						);
  					}
  				});
  			}
  			// static props are already proxied on the component's prototype
  			// during Vue.extend(). We only need to proxy props defined at
  			// instantiation here.
  			if (!(key in vm)) {
  				proxy(vm, "_props", key);
  			}
  		};
  		
  		for (var key in propsOptions) loop( key );
  		toggleObserving(true);
  	}
  	
  	function initData (vm) {
  		var data = vm.$options.data;
  		data = vm._data = typeof data === 'function'
  			? getData(data, vm)
  			: data || {};
  		if (!isPlainObject(data)) {
  			data = {};
  			warn(
  				'data functions should return an object:\n' +
  				'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
  				vm
  			);
  		}
  		// proxy data on instance
  		var keys = Object.keys(data);
  		var props = vm.$options.props;
  		var methods = vm.$options.methods;
  		var i = keys.length;
  		while (i--) {
  			var key = keys[i];
  			{
  				if (methods && hasOwn(methods, key)) {
  					warn(
  						("Method \"" + key + "\" has already been defined as a data property."),
  						vm
  					);
  				}
  			}
  			if (props && hasOwn(props, key)) {
  				warn(
  					"The data property \"" + key + "\" is already declared as a prop. " +
  					"Use prop default value instead.",
  					vm
  				);
  			} else if (!isReserved(key)) {
  				proxy(vm, "_data", key);
  			}
  		}
  		// observe data
  		observe(data, true /* asRootData */);
  	}
  	
  	function getData (data, vm) {
  		// #7573 disable dep collection when invoking data getters
  		pushTarget();
  		try {
  			return data.call(vm, vm)
  		} catch (e) {
  			handleError(e, vm, "data()");
  			return {}
  		} finally {
  			popTarget();
  		}
  	}
  	
  	var computedWatcherOptions = { lazy: true };
  	
  	function initComputed (vm, computed) {
  		// $flow-disable-line
  		var watchers = vm._computedWatchers = Object.create(null);
  		// computed properties are just getters during SSR
  		var isSSR = isServerRendering();
  		
  		for (var key in computed) {
  			var userDef = computed[key];
  			var getter = typeof userDef === 'function' ? userDef : userDef.get;
  			if (getter == null) {
  				warn(
  					("Getter is missing for computed property \"" + key + "\"."),
  					vm
  				);
  			}
  			
  			if (!isSSR) {
  				// create internal watcher for the computed property.
  				watchers[key] = new Watcher(
  					vm,
  					getter || noop,
  					noop,
  					computedWatcherOptions
  				);
  			}
  			
  			// component-defined computed properties are already defined on the
  			// component prototype. We only need to define computed properties defined
  			// at instantiation here.
  			if (!(key in vm)) {
  				defineComputed(vm, key, userDef);
  			} else {
  				if (key in vm.$data) {
  					warn(("The computed property \"" + key + "\" is already defined in data."), vm);
  				} else if (vm.$options.props && key in vm.$options.props) {
  					warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
  				}
  			}
  		}
  	}
  	
  	function defineComputed (
  		target,
  		key,
  		userDef
  	) {
  		var shouldCache = !isServerRendering();
  		if (typeof userDef === 'function') {
  			sharedPropertyDefinition.get = shouldCache
  				? createComputedGetter(key)
  				: createGetterInvoker(userDef);
  			sharedPropertyDefinition.set = noop;
  		} else {
  			sharedPropertyDefinition.get = userDef.get
  				? shouldCache && userDef.cache !== false
  					? createComputedGetter(key)
  					: createGetterInvoker(userDef.get)
  				: noop;
  			sharedPropertyDefinition.set = userDef.set || noop;
  		}
  		if (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 computedGetter () {
  			var watcher = this._computedWatchers && this._computedWatchers[key];
  			if (watcher) {
  				if (watcher.dirty) {
  					watcher.evaluate();
  				}
  				if (Dep.target) {
  					watcher.depend();
  				}
  				return watcher.value
  			}
  		}
  	}
  	
  	function createGetterInvoker(fn) {
  		return function computedGetter () {
  			return fn.call(this, this)
  		}
  	}
  	
  	function initMethods (vm, methods) {
  		var props = vm.$options.props;
  		for (var key in methods) {
  			{
  				if (typeof methods[key] !== 'function') {
  					warn(
  						"Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
  						"Did you reference the function correctly?",
  						vm
  					);
  				}
  				if (props && hasOwn(props, key)) {
  					warn(
  						("Method \"" + key + "\" has already been defined as a prop."),
  						vm
  					);
  				}
  				if ((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] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
  		}
  	}
  	
  	function initWatch (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);
  			}
  		}
  	}
  	
  	function createWatcher (
  		vm,
  		expOrFn,
  		handler,
  		options
  	) {
  		if (isPlainObject(handler)) {
  			options = handler;
  			handler = handler.handler;
  		}
  		if (typeof handler === 'string') {
  			handler = vm[handler];
  		}
  		return vm.$watch(expOrFn, handler, options)
  	}
  	
  	function stateMixin (Vue) {
  		// flow somehow has problems with directly declared definition object
  		// when using Object.defineProperty, so we have to procedurally build up
  		// the object here.
  		var dataDef = {};
  		dataDef.get = function () { return this._data };
  		var propsDef = {};
  		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(Vue.prototype, '$data', dataDef);
  		Object.defineProperty(Vue.prototype, '$props', propsDef);
  		
  		Vue.prototype.$set = set;
  		Vue.prototype.$delete = del;
  		
  		Vue.prototype.$watch = function (
  			expOrFn,
  			cb,
  			options
  		) {
  			var vm = this;
  			if (isPlainObject(cb)) {
  				return createWatcher(vm, expOrFn, cb, options)
  			}
  			options = options || {};
  			options.user = true;
  			var watcher = new Watcher(vm, expOrFn, cb, options);
  			if (options.immediate) {
  				try {
  					cb.call(vm, watcher.value);
  				} catch (error) {
  					handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
  				}
  			}
  			return function unwatchFn () {
  				watcher.teardown();
  			}
  		};
  	}
  	
  	/*  */
  	
  	var uid$3 = 0;
  	
  	function initMixin (Vue) {
  		Vue.prototype._init = function (options) {
  			var vm = this;
  			// a uid
  			vm._uid = uid$3++;
  			
  			var startTag, endTag;
  			/* istanbul ignore if */
  			if (config.performance && mark) {
  				startTag = "vue-perf-start:" + (vm._uid);
  				endTag = "vue-perf-end:" + (vm._uid);
  				mark(startTag);
  			}
  			
  			// a flag to avoid this being observed
  			vm._isVue = true;
  			// merge options
  			if (options && options._isComponent) {
  				// optimize internal component instantiation
  				// since dynamic options merging is pretty slow, and none of the
  				// internal component options needs special treatment.
  				initInternalComponent(vm, options);
  			} else {
  				vm.$options = mergeOptions(
  					resolveConstructorOptions(vm.constructor),
  					options || {},
  					vm
  				);
  			}
  			/* istanbul ignore else */
  			{
  				initProxy(vm);
  			}
  			// expose real self
  			vm._self = vm;
  			initLifecycle(vm);
  			initEvents(vm);
  			initRender(vm);
  			callHook(vm, 'beforeCreate');
  			initInjections(vm); // resolve injections before data/props
  			initState(vm);
  			initProvide(vm); // resolve provide after data/props
  			callHook(vm, 'created');
  			
  			/* istanbul ignore if */
  			if (config.performance && mark) {
  				vm._name = formatComponentName(vm, false);
  				mark(endTag);
  				measure(("vue " + (vm._name) + " init"), startTag, endTag);
  			}
  			
  			if (vm.$options.el) {
  				vm.$mount(vm.$options.el);
  			}
  		};
  	}
  	
  	function initInternalComponent (vm, options) {
  		var opts = vm.$options = Object.create(vm.constructor.options);
  		// doing this because it's faster than dynamic enumeration.
  		var parentVnode = options._parentVnode;
  		opts.parent = options.parent;
  		opts._parentVnode = parentVnode;
  		
  		var vnodeComponentOptions = parentVnode.componentOptions;
  		opts.propsData = vnodeComponentOptions.propsData;
  		opts._parentListeners = vnodeComponentOptions.listeners;
  		opts._renderChildren = vnodeComponentOptions.children;
  		opts._componentTag = vnodeComponentOptions.tag;
  		
  		if (options.render) {
  			opts.render = options.render;
  			opts.staticRenderFns = options.staticRenderFns;
  		}
  	}
  	
  	function resolveConstructorOptions (Ctor) {
  		var options = Ctor.options;
  		if (Ctor.super) {
  			var superOptions = resolveConstructorOptions(Ctor.super);
  			var cachedSuperOptions = Ctor.superOptions;
  			if (superOptions !== cachedSuperOptions) {
  				// super option changed,
  				// need to resolve new options.
  				Ctor.superOptions = superOptions;
  				// check if there are any late-modified/attached options (#4976)
  				var modifiedOptions = resolveModifiedOptions(Ctor);
  				// update base extend options
  				if (modifiedOptions) {
  					extend(Ctor.extendOptions, modifiedOptions);
  				}
  				options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
  				if (options.name) {
  					options.components[options.name] = Ctor;
  				}
  			}
  		}
  		return options
  	}
  	
  	function resolveModifiedOptions (Ctor) {
  		var modified;
  		var latest = Ctor.options;
  		var sealed = Ctor.sealedOptions;
  		for (var key in latest) {
  			if (latest[key] !== sealed[key]) {
  				if (!modified) { modified = {}; }
  				modified[key] = latest[key];
  			}
  		}
  		return modified
  	}
  	
  	function Vue (options) {
  		if (!(this instanceof Vue)
  		) {
  			warn('Vue is a constructor and should be called with the `new` keyword');
  		}
  		this._init(options);
  	}
  	
  	initMixin(Vue);
  	stateMixin(Vue);
  	eventsMixin(Vue);
  	lifecycleMixin(Vue);
  	renderMixin(Vue);
  	
  	/*  */
  	
  	function initUse (Vue) {
  		Vue.use = function (plugin) {
  			var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
  			if (installedPlugins.indexOf(plugin) > -1) {
  				return this
  			}
  			
  			// additional parameters
  			var args = toArray(arguments, 1);
  			args.unshift(this);
  			if (typeof plugin.install === 'function') {
  				plugin.install.apply(plugin, args);
  			} else if (typeof plugin === 'function') {
  				plugin.apply(null, args);
  			}
  			installedPlugins.push(plugin);
  			return this
  		};
  	}
  	
  	/*  */
  	
  	function initMixin$1 (Vue) {
  		Vue.mixin = function (mixin) {
  			this.options = mergeOptions(this.options, mixin);
  			return this
  		};
  	}
  	
  	/*  */
  	
  	function initExtend (Vue) {
  		/**
  		 * Each instance constructor, including Vue, has a unique
  		 * cid. This enables us to create wrapped "child
  		 * constructors" for prototypal inheritance and cache them.
  		 */
  		Vue.cid = 0;
  		var cid = 1;
  		
  		/**
  		 * Class inheritance
  		 */
  		Vue.extend = function (extendOptions) {
  			extendOptions = extendOptions || {};
  			var Super = this;
  			var SuperId = Super.cid;
  			var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
  			if (cachedCtors[SuperId]) {
  				return cachedCtors[SuperId]
  			}
  			
  			var name = extendOptions.name || Super.options.name;
  			if (name) {
  				validateComponentName(name);
  			}
  			
  			var Sub = function VueComponent (options) {
  				this._init(options);
  			};
  			Sub.prototype = Object.create(Super.prototype);
  			Sub.prototype.constructor = Sub;
  			Sub.cid = cid++;
  			Sub.options = mergeOptions(
  				Super.options,
  				extendOptions
  			);
  			Sub['super'] = Super;
  			
  			// For props and computed properties, we define the proxy getters on
  			// the Vue instances at extension time, on the extended prototype. This
  			// avoids Object.defineProperty calls for each instance created.
  			if (Sub.options.props) {
  				initProps$1(Sub);
  			}
  			if (Sub.options.computed) {
  				initComputed$1(Sub);
  			}
  			
  			// allow further extension/mixin/plugin usage
  			Sub.extend = Super.extend;
  			Sub.mixin = Super.mixin;
  			Sub.use = Super.use;
  			
  			// create asset registers, so extended classes
  			// can have their private assets too.
  			ASSET_TYPES.forEach(function (type) {
  				Sub[type] = Super[type];
  			});
  			// enable recursive self-lookup
  			if (name) {
  				Sub.options.components[name] = Sub;
  			}
  			
  			// keep a reference to the super options at extension time.
  			// later at instantiation we can check if Super's options have
  			// been updated.
  			Sub.superOptions = Super.options;
  			Sub.extendOptions = extendOptions;
  			Sub.sealedOptions = extend({}, Sub.options);
  			
  			// cache constructor
  			cachedCtors[SuperId] = Sub;
  			return Sub
  		};
  	}
  	
  	function initProps$1 (Comp) {
  		var props = Comp.options.props;
  		for (var key in props) {
  			proxy(Comp.prototype, "_props", key);
  		}
  	}
  	
  	function initComputed$1 (Comp) {
  		var computed = Comp.options.computed;
  		for (var key in computed) {
  			defineComputed(Comp.prototype, key, computed[key]);
  		}
  	}
  	
  	/*  */
  	
  	function initAssetRegisters (Vue) {
  		/**
  		 * Create asset registration methods.
  		 */
  		ASSET_TYPES.forEach(function (type) {
  			Vue[type] = function (
  				id,
  				definition
  			) {
  				if (!definition) {
  					return this.options[type + 's'][id]
  				} else {
  					/* istanbul ignore if */
  					if (type === 'component') {
  						validateComponentName(id);
  					}
  					if (type === 'component' && isPlainObject(definition)) {
  						definition.name = definition.name || id;
  						definition = this.options._base.extend(definition);
  					}
  					if (type === 'directive' && typeof definition === 'function') {
  						definition = { bind: definition, update: definition };
  					}
  					this.options[type + 's'][id] = definition;
  					return definition
  				}
  			};
  		});
  	}
  	
  	/*  */
  	
  	
  	
  	function getComponentName (opts) {
  		return opts && (opts.Ctor.options.name || opts.tag)
  	}
  	
  	function matches (pattern, name) {
  		if (Array.isArray(pattern)) {
  			return pattern.indexOf(name) > -1
  		} else if (typeof pattern === 'string') {
  			return pattern.split(',').indexOf(name) > -1
  		} else if (isRegExp(pattern)) {
  			return pattern.test(name)
  		}
  		/* istanbul ignore next */
  		return false
  	}
  	
  	function pruneCache (keepAliveInstance, filter) {
  		var cache = keepAliveInstance.cache;
  		var keys = keepAliveInstance.keys;
  		var _vnode = keepAliveInstance._vnode;
  		for (var key in cache) {
  			var cachedNode = cache[key];
  			if (cachedNode) {
  				var name = getComponentName(cachedNode.componentOptions);
  				if (name && !filter(name)) {
  					pruneCacheEntry(cache, key, keys, _vnode);
  				}
  			}
  		}
  	}
  	
  	function pruneCacheEntry (
  		cache,
  		key,
  		keys,
  		current
  	) {
  		var cached$$1 = cache[key];
  		if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
  			cached$$1.componentInstance.$destroy();
  		}
  		cache[key] = null;
  		remove(keys, key);
  	}
  	
  	var patternTypes = [String, RegExp, Array];
  	
  	var KeepAlive = {
  		name: 'keep-alive',
  		abstract: true,
  		
  		props: {
  			include: patternTypes,
  			exclude: patternTypes,
  			max: [String, Number]
  		},
  		
  		created: function created () {
  			this.cache = Object.create(null);
  			this.keys = [];
  		},
  		
  		destroyed: function destroyed () {
  			for (var key in this.cache) {
  				pruneCacheEntry(this.cache, key, this.keys);
  			}
  		},
  		
  		mounted: function mounted () {
  			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 render () {
  			var slot = this.$slots.default;
  			var vnode = getFirstComponentChild(slot);
  			var componentOptions = vnode && vnode.componentOptions;
  			if (componentOptions) {
  				// check pattern
  				var name = getComponentName(componentOptions);
  				var ref = this;
  				var include = ref.include;
  				var exclude = ref.exclude;
  				if (
  					// not included
  					(include && (!name || !matches(include, name))) ||
  					// excluded
  					(exclude && name && matches(exclude, name))
  				) {
  					return vnode
  				}
  				
  				var ref$1 = this;
  				var cache = ref$1.cache;
  				var keys = ref$1.keys;
  				var key = vnode.key == null
  					// same constructor may get registered as different local components
  					// so cid alone is not enough (#3269)
  					? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
  					: vnode.key;
  				if (cache[key]) {
  					vnode.componentInstance = cache[key].componentInstance;
  					// make current key freshest
  					remove(keys, key);
  					keys.push(key);
  				} else {
  					cache[key] = vnode;
  					keys.push(key);
  					// prune oldest entry
  					if (this.max && keys.length > parseInt(this.max)) {
  						pruneCacheEntry(cache, keys[0], keys, this._vnode);
  					}
  				}
  				
  				vnode.data.keepAlive = true;
  			}
  			return vnode || (slot && slot[0])
  		}
  	};
  	
  	var builtInComponents = {
  		KeepAlive: KeepAlive
  	};
  	
  	/*  */
  	
  	function initGlobalAPI (Vue) {
  		// config
  		var configDef = {};
  		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);
  		
  		// exposed util methods.
  		// NOTE: these are not considered part of the public API - avoid relying on
  		// them unless you are aware of the risk.
  		Vue.util = {
  			warn: warn,
  			extend: extend,
  			mergeOptions: mergeOptions,
  			defineReactive: defineReactive$$1
  		};
  		
  		Vue.set = set;
  		Vue.delete = del;
  		Vue.nextTick = nextTick;
  		
  		// 2.6 explicit observable API
  		Vue.observable = function (obj) {
  			observe(obj);
  			return obj
  		};
  		
  		Vue.options = Object.create(null);
  		ASSET_TYPES.forEach(function (type) {
  			Vue.options[type + 's'] = Object.create(null);
  		});
  		
  		// this is used to identify the "base" constructor to extend all plain-object
  		// components with in Weex's multi-instance scenarios.
  		Vue.options._base = Vue;
  		
  		extend(Vue.options.components, builtInComponents);
  		
  		initUse(Vue);
  		initMixin$1(Vue);
  		initExtend(Vue);
  		initAssetRegisters(Vue);
  	}
  	
  	initGlobalAPI(Vue);
  	
  	Object.defineProperty(Vue.prototype, '$isServer', {
  		get: isServerRendering
  	});
  	
  	Object.defineProperty(Vue.prototype, '$ssrContext', {
  		get: function get () {
  			/* istanbul ignore next */
  			return this.$vnode && this.$vnode.ssrContext
  		}
  	});
  	
  	// expose FunctionalRenderContext for ssr runtime helper installation
  	Object.defineProperty(Vue, 'FunctionalRenderContext', {
  		value: FunctionalRenderContext
  	});
  	
  	Vue.version = '2.6.10';
  	
  	/*  */
  	
  	// these are reserved for web because they are directly compiled away
  	// during template compilation
  	var isReservedAttr = makeMap('style,class');
  	
  	// attributes that should be using props for binding
  	var acceptValue = makeMap('input,textarea,option,select,progress');
  	var mustUseProp = function (tag, type, attr) {
  		return (
  			(attr === 'value' && acceptValue(tag)) && type !== 'button' ||
  			(attr === 'selected' && tag === 'option') ||
  			(attr === 'checked' && tag === 'input') ||
  			(attr === 'muted' && tag === 'video')
  		)
  	};
  	
  	var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
  	
  	var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
  	
  	var convertEnumeratedValue = function (key, value) {
  		return isFalsyAttrValue(value) || value === 'false'
  			? 'false'
  			// allow arbitrary string value for contenteditable
  			: key === 'contenteditable' && isValidContentEditableValue(value)
  				? value
  				: 'true'
  	};
  	
  	var 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'
  	);
  	
  	var xlinkNS = 'http://www.w3.org/1999/xlink';
  	
  	var isXlink = function (name) {
  		return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
  	};
  	
  	var getXlinkProp = function (name) {
  		return isXlink(name) ? name.slice(6, name.length) : ''
  	};
  	
  	var isFalsyAttrValue = function (val) {
  		return val == null || val === false
  	};
  	
  	/*  */
  	
  	function genClassForVnode (vnode) {
  		var data = vnode.data;
  		var parentNode = vnode;
  		var childNode = vnode;
  		while (isDef(childNode.componentInstance)) {
  			childNode = childNode.componentInstance._vnode;
  			if (childNode && childNode.data) {
  				data = mergeClassData(childNode.data, data);
  			}
  		}
  		while (isDef(parentNode = parentNode.parent)) {
  			if (parentNode && parentNode.data) {
  				data = mergeClassData(data, parentNode.data);
  			}
  		}
  		return renderClass(data.staticClass, data.class)
  	}
  	
  	function mergeClassData (child, parent) {
  		return {
  			staticClass: concat(child.staticClass, parent.staticClass),
  			class: isDef(child.class)
  				? [child.class, parent.class]
  				: parent.class
  		}
  	}
  	
  	function renderClass (
  		staticClass,
  		dynamicClass
  	) {
  		if (isDef(staticClass) || isDef(dynamicClass)) {
  			return concat(staticClass, stringifyClass(dynamicClass))
  		}
  		/* istanbul ignore next */
  		return ''
  	}
  	
  	function concat (a, b) {
  		return a ? b ? (a + ' ' + b) : a : (b || '')
  	}
  	
  	function stringifyClass (value) {
  		if (Array.isArray(value)) {
  			return stringifyArray(value)
  		}
  		if (isObject(value)) {
  			return stringifyObject(value)
  		}
  		if (typeof value === 'string') {
  			return value
  		}
  		/* istanbul ignore next */
  		return ''
  	}
  	
  	function stringifyArray (value) {
  		var res = '';
  		var stringified;
  		for (var i = 0, l = value.length; i < l; i++) {
  			if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
  				if (res) { res += ' '; }
  				res += stringified;
  			}
  		}
  		return res
  	}
  	
  	function stringifyObject (value) {
  		var res = '';
  		for (var key in value) {
  			if (value[key]) {
  				if (res) { res += ' '; }
  				res += key;
  			}
  		}
  		return res
  	}
  	
  	/*  */
  	
  	var namespaceMap = {
  		svg: 'http://www.w3.org/2000/svg',
  		math: 'http://www.w3.org/1998/Math/MathML'
  	};
  	
  	var 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'
  	);
  	
  	// this map is intentionally selective, only covering SVG elements that may
  	// contain child elements.
  	var 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',
  		true
  	);
  	
  	var isPreTag = function (tag) { return tag === 'pre'; };
  	
  	var isReservedTag = function (tag) {
  		return isHTMLTag(tag) || isSVG(tag)
  	};
  	
  	function getTagNamespace (tag) {
  		if (isSVG(tag)) {
  			return 'svg'
  		}
  		// basic support for MathML
  		// note it doesn't support other MathML elements being component roots
  		if (tag === 'math') {
  			return 'math'
  		}
  	}
  	
  	var unknownElementCache = Object.create(null);
  	function isUnknownElement (tag) {
  		/* istanbul ignore if */
  		if (!inBrowser) {
  			return true
  		}
  		if (isReservedTag(tag)) {
  			return false
  		}
  		tag = tag.toLowerCase();
  		/* istanbul ignore if */
  		if (unknownElementCache[tag] != null) {
  			return unknownElementCache[tag]
  		}
  		var el = document.createElement(tag);
  		if (tag.indexOf('-') > -1) {
  			// http://stackoverflow.com/a/28210364/1070244
  			return (unknownElementCache[tag] = (
  				el.constructor === window.HTMLUnknownElement ||
  				el.constructor === window.HTMLElement
  			))
  		} else {
  			return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
  		}
  	}
  	
  	var isTextInputType = makeMap('text,number,password,search,email,tel,url');
  	
  	/*  */
  	
  	/**
  	 * Query an element selector if it's not an element already.
  	 */
  	function query (el) {
  		if (typeof el === 'string') {
  			var selected = document.querySelector(el);
  			if (!selected) {
  				warn(
  					'Cannot find element: ' + el
  				);
  				return document.createElement('div')
  			}
  			return selected
  		} else {
  			return el
  		}
  	}
  	
  	/*  */
  	
  	function createElement$1 (tagName, vnode) {
  		var elm = document.createElement(tagName);
  		if (tagName !== 'select') {
  			return elm
  		}
  		// false or null will remove the attribute but undefined will not
  		if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
  			elm.setAttribute('multiple', 'multiple');
  		}
  		return elm
  	}
  	
  	function createElementNS (namespace, tagName) {
  		return document.createElementNS(namespaceMap[namespace], tagName)
  	}
  	
  	function createTextNode (text) {
  		return document.createTextNode(text)
  	}
  	
  	function createComment (text) {
  		return document.createComment(text)
  	}
  	
  	function insertBefore (parentNode, newNode, referenceNode) {
  		parentNode.insertBefore(newNode, referenceNode);
  	}
  	
  	function removeChild (node, child) {
  		node.removeChild(child);
  	}
  	
  	function appendChild (node, child) {
  		node.appendChild(child);
  	}
  	
  	function parentNode (node) {
  		return node.parentNode
  	}
  	
  	function nextSibling (node) {
  		return node.nextSibling
  	}
  	
  	function tagName (node) {
  		return node.tagName
  	}
  	
  	function setTextContent (node, text) {
  		node.textContent = text;
  	}
  	
  	function setStyleScope (node, scopeId) {
  		node.setAttribute(scopeId, '');
  	}
  	
  	var nodeOps = /*#__PURE__*/Object.freeze({
  		createElement: createElement$1,
  		createElementNS: createElementNS,
  		createTextNode: createTextNode,
  		createComment: createComment,
  		insertBefore: insertBefore,
  		removeChild: removeChild,
  		appendChild: appendChild,
  		parentNode: parentNode,
  		nextSibling: nextSibling,
  		tagName: tagName,
  		setTextContent: setTextContent,
  		setStyleScope: setStyleScope
  	});
  	
  	/*  */
  	
  	var ref = {
  		create: function create (_, vnode) {
  			registerRef(vnode);
  		},
  		update: function update (oldVnode, vnode) {
  			if (oldVnode.data.ref !== vnode.data.ref) {
  				registerRef(oldVnode, true);
  				registerRef(vnode);
  			}
  		},
  		destroy: function destroy (vnode) {
  			registerRef(vnode, true);
  		}
  	};
  	
  	function registerRef (vnode, isRemoval) {
  		var key = vnode.data.ref;
  		if (!isDef(key)) { return }
  		
  		var vm = vnode.context;
  		var ref = vnode.componentInstance || vnode.elm;
  		var refs = vm.$refs;
  		if (isRemoval) {
  			if (Array.isArray(refs[key])) {
  				remove(refs[key], ref);
  			} else if (refs[key] === ref) {
  				refs[key] = undefined;
  			}
  		} else {
  			if (vnode.data.refInFor) {
  				if (!Array.isArray(refs[key])) {
  					refs[key] = [ref];
  				} else if (refs[key].indexOf(ref) < 0) {
  					// $flow-disable-line
  					refs[key].push(ref);
  				}
  			} else {
  				refs[key] = ref;
  			}
  		}
  	}
  	
  	/**
  	 * Virtual DOM patching algorithm based on Snabbdom by
  	 * Simon Friis Vindum (@paldepind)
  	 * Licensed under the MIT License
  	 * https://github.com/paldepind/snabbdom/blob/master/LICENSE
  	 *
  	 * modified by Evan You (@yyx990803)
  	 *
  	 * Not type-checking this because this file is perf-critical and the cost
  	 * of making flow understand it is not worth it.
  	 */
  	
  	var emptyNode = new VNode('', {}, []);
  	
  	var 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) &&
  					sameInputType(a, b)
  				) || (
  					isTrue(a.isAsyncPlaceholder) &&
  					a.asyncFactory === b.asyncFactory &&
  					isUndef(b.asyncFactory.error)
  				)
  			)
  		)
  	}
  	
  	function sameInputType (a, b) {
  		if (a.tag !== 'input') { return true }
  		var i;
  		var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
  		var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
  		return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
  	}
  	
  	function createKeyToOldIdx (children, beginIdx, endIdx) {
  		var i, key;
  		var map = {};
  		for (i = beginIdx; i <= endIdx; ++i) {
  			key = children[i].key;
  			if (isDef(key)) { map[key] = i; }
  		}
  		return map
  	}
  	
  	function createPatchFunction (backend) {
  		var i, j;
  		var cbs = {};
  		
  		var modules = backend.modules;
  		var nodeOps = backend.nodeOps;
  		
  		for (i = 0; i < hooks.length; ++i) {
  			cbs[hooks[i]] = [];
  			for (j = 0; j < modules.length; ++j) {
  				if (isDef(modules[j][hooks[i]])) {
  					cbs[hooks[i]].push(modules[j][hooks[i]]);
  				}
  			}
  		}
  		
  		function emptyNodeAt (elm) {
  			return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
  		}
  		
  		function createRmCb (childElm, listeners) {
  			function remove$$1 () {
  				if (--remove$$1.listeners === 0) {
  					removeNode(childElm);
  				}
  			}
  			remove$$1.listeners = listeners;
  			return remove$$1
  		}
  		
  		function removeNode (el) {
  			var parent = nodeOps.parentNode(el);
  			// element may have already been removed due to v-html / v-text
  			if (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)) {
  				// This vnode was used in a previous render!
  				// now it's used as a new node, overwriting its elm would cause
  				// potential patch errors down the road when it's used as an insertion
  				// reference node. Instead, we clone the node on-demand before creating
  				// associated DOM element for it.
  				vnode = ownerArray[index] = cloneVNode(vnode);
  			}
  			
  			vnode.isRootInsert = !nested; // for transition enter check
  			if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
  				return
  			}
  			
  			var data = vnode.data;
  			var children = vnode.children;
  			var tag = vnode.tag;
  			if (isDef(tag)) {
  				{
  					if (data && data.pre) {
  						creatingElmInVPre++;
  					}
  					if (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);
  				
  				/* istanbul ignore if */
  				{
  					createChildren(vnode, children, insertedVnodeQueue);
  					if (isDef(data)) {
  						invokeCreateHooks(vnode, insertedVnodeQueue);
  					}
  					insert(parentElm, vnode.elm, refElm);
  				}
  				
  				if (data && data.pre) {
  					creatingElmInVPre--;
  				}
  			} else if (isTrue(vnode.isComment)) {
  				vnode.elm = nodeOps.createComment(vnode.text);
  				insert(parentElm, vnode.elm, refElm);
  			} else {
  				vnode.elm = nodeOps.createTextNode(vnode.text);
  				insert(parentElm, vnode.elm, refElm);
  			}
  		}
  		
  		function createComponent (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, false /* hydrating */);
  				}
  				// after calling the init hook, if the vnode is a child component
  				// it should've created a child instance and mounted it. the child
  				// component also has set the placeholder vnode's elm.
  				// in that case we can just return the element and be done.
  				if (isDef(vnode.componentInstance)) {
  					initComponent(vnode, insertedVnodeQueue);
  					insert(parentElm, vnode.elm, refElm);
  					if (isTrue(isReactivated)) {
  						reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
  					}
  					return true
  				}
  			}
  		}
  		
  		function initComponent (vnode, insertedVnodeQueue) {
  			if (isDef(vnode.data.pendingInsert)) {
  				insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
  				vnode.data.pendingInsert = null;
  			}
  			vnode.elm = vnode.componentInstance.$el;
  			if (isPatchable(vnode)) {
  				invokeCreateHooks(vnode, insertedVnodeQueue);
  				setScope(vnode);
  			} else {
  				// empty component root.
  				// skip all element-related modules except for ref (#3455)
  				registerRef(vnode);
  				// make sure to invoke the insert hook
  				insertedVnodeQueue.push(vnode);
  			}
  		}
  		
  		function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
  			var i;
  			// hack for #4339: a reactivated component with inner transition
  			// does not trigger because the inner node's created hooks are not called
  			// again. It's not ideal to involve module-specific logic in here but
  			// there doesn't seem to be a better way to do it.
  			var innerNode = vnode;
  			while (innerNode.componentInstance) {
  				innerNode = innerNode.componentInstance._vnode;
  				if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
  					for (i = 0; i < cbs.activate.length; ++i) {
  						cbs.activate[i](emptyNode, innerNode);
  					}
  					insertedVnodeQueue.push(innerNode);
  					break
  				}
  			}
  			// unlike a newly created component,
  			// a reactivated keep-alive component doesn't insert itself
  			insert(parentElm, vnode.elm, refElm);
  		}
  		
  		function insert (parent, elm, ref$$1) {
  			if (isDef(parent)) {
  				if (isDef(ref$$1)) {
  					if (nodeOps.parentNode(ref$$1) === parent) {
  						nodeOps.insertBefore(parent, elm, ref$$1);
  					}
  				} else {
  					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, true, children, i);
  				}
  			} else if (isPrimitive(vnode.text)) {
  				nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
  			}
  		}
  		
  		function isPatchable (vnode) {
  			while (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);
  			}
  			i = vnode.data.hook; // Reuse variable
  			if (isDef(i)) {
  				if (isDef(i.create)) { i.create(emptyNode, vnode); }
  				if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
  			}
  		}
  		
  		// set scope id attribute for scoped CSS.
  		// this is implemented as a special case to avoid the overhead
  		// of going through the normal attribute patching process.
  		function setScope (vnode) {
  			var i;
  			if (isDef(i = vnode.fnScopeId)) {
  				nodeOps.setStyleScope(vnode.elm, i);
  			} else {
  				var ancestor = vnode;
  				while (ancestor) {
  					if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
  						nodeOps.setStyleScope(vnode.elm, i);
  					}
  					ancestor = ancestor.parent;
  				}
  			}
  			// for slot content they should also get the scopeId from the host instance.
  			if (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, false, vnodes, startIdx);
  			}
  		}
  		
  		function invokeDestroyHook (vnode) {
  			var i, j;
  			var data = vnode.data;
  			if (isDef(data)) {
  				if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
  				for (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 (parentElm, vnodes, startIdx, endIdx) {
  			for (; startIdx <= endIdx; ++startIdx) {
  				var ch = vnodes[startIdx];
  				if (isDef(ch)) {
  					if (isDef(ch.tag)) {
  						removeAndInvokeRemoveHook(ch);
  						invokeDestroyHook(ch);
  					} else { // Text node
  						removeNode(ch.elm);
  					}
  				}
  			}
  		}
  		
  		function removeAndInvokeRemoveHook (vnode, rm) {
  			if (isDef(rm) || isDef(vnode.data)) {
  				var i;
  				var listeners = cbs.remove.length + 1;
  				if (isDef(rm)) {
  					// we have a recursively passed down rm callback
  					// increase the listeners count
  					rm.listeners += listeners;
  				} else {
  					// directly removing
  					rm = createRmCb(vnode.elm, listeners);
  				}
  				// recursively invoke hooks on child component root node
  				if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
  					removeAndInvokeRemoveHook(i, rm);
  				}
  				for (i = 0; i < cbs.remove.length; ++i) {
  					cbs.remove[i](vnode, rm);
  				}
  				if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
  					i(vnode, rm);
  				} else {
  					rm();
  				}
  			} else {
  				removeNode(vnode.elm);
  			}
  		}
  		
  		function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
  			var oldStartIdx = 0;
  			var newStartIdx = 0;
  			var oldEndIdx = oldCh.length - 1;
  			var oldStartVnode = oldCh[0];
  			var oldEndVnode = oldCh[oldEndIdx];
  			var newEndIdx = newCh.length - 1;
  			var newStartVnode = newCh[0];
  			var newEndVnode = newCh[newEndIdx];
  			var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
  			
  			// removeOnly is a special flag used only by <transition-group>
  			// to ensure removed elements stay in correct relative positions
  			// during leaving transitions
  			var canMove = !removeOnly;
  			
  			{
  				checkDuplicateKeys(newCh);
  			}
  			
  			while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
  				if (isUndef(oldStartVnode)) {
  					oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
  				} else if (isUndef(oldEndVnode)) {
  					oldEndVnode = oldCh[--oldEndIdx];
  				} else if (sameVnode(oldStartVnode, newStartVnode)) {
  					patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
  					oldStartVnode = oldCh[++oldStartIdx];
  					newStartVnode = newCh[++newStartIdx];
  				} else if (sameVnode(oldEndVnode, newEndVnode)) {
  					patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
  					oldEndVnode = oldCh[--oldEndIdx];
  					newEndVnode = newCh[--newEndIdx];
  				} else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
  					patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
  					canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
  					oldStartVnode = oldCh[++oldStartIdx];
  					newEndVnode = newCh[--newEndIdx];
  				} else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
  					patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
  					canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
  					oldEndVnode = oldCh[--oldEndIdx];
  					newStartVnode = newCh[++newStartIdx];
  				} else {
  					if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
  					idxInOld = isDef(newStartVnode.key)
  						? oldKeyToIdx[newStartVnode.key]
  						: findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
  					if (isUndef(idxInOld)) { // New element
  						createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
  					} else {
  						vnodeToMove = oldCh[idxInOld];
  						if (sameVnode(vnodeToMove, newStartVnode)) {
  							patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
  							oldCh[idxInOld] = undefined;
  							canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
  						} else {
  							// same key but different element. treat as new element
  							createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
  						}
  					}
  					newStartVnode = newCh[++newStartIdx];
  				}
  			}
  			if (oldStartIdx > oldEndIdx) {
  				refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
  				addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
  			} else if (newStartIdx > newEndIdx) {
  				removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
  			}
  		}
  		
  		function checkDuplicateKeys (children) {
  			var seenKeys = {};
  			for (var i = 0; i < children.length; i++) {
  				var vnode = children[i];
  				var key = vnode.key;
  				if (isDef(key)) {
  					if (seenKeys[key]) {
  						warn(
  							("Duplicate keys detected: '" + key + "'. This may cause an update error."),
  							vnode.context
  						);
  					} else {
  						seenKeys[key] = true;
  					}
  				}
  			}
  		}
  		
  		function findIdxInOld (node, oldCh, start, end) {
  			for (var i = start; i < end; i++) {
  				var c = oldCh[i];
  				if (isDef(c) && sameVnode(node, c)) { return i }
  			}
  		}
  		
  		function patchVnode (
  			oldVnode,
  			vnode,
  			insertedVnodeQueue,
  			ownerArray,
  			index,
  			removeOnly
  		) {
  			if (oldVnode === vnode) {
  				return
  			}
  			
  			if (isDef(vnode.elm) && isDef(ownerArray)) {
  				// clone reused vnode
  				vnode = ownerArray[index] = cloneVNode(vnode);
  			}
  			
  			var elm = vnode.elm = oldVnode.elm;
  			
  			if (isTrue(oldVnode.isAsyncPlaceholder)) {
  				if (isDef(vnode.asyncFactory.resolved)) {
  					hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
  				} else {
  					vnode.isAsyncPlaceholder = true;
  				}
  				return
  			}
  			
  			// reuse element for static trees.
  			// note we only do this if the vnode is cloned -
  			// if the new node is not cloned it means the render functions have been
  			// reset by the hot-reload-api and we need to do a proper re-render.
  			if (isTrue(vnode.isStatic) &&
  				isTrue(oldVnode.isStatic) &&
  				vnode.key === oldVnode.key &&
  				(isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
  			) {
  				vnode.componentInstance = oldVnode.componentInstance;
  				return
  			}
  			
  			var i;
  			var data = vnode.data;
  			if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
  				i(oldVnode, vnode);
  			}
  			
  			var oldCh = oldVnode.children;
  			var ch = vnode.children;
  			if (isDef(data) && isPatchable(vnode)) {
  				for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
  				if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
  			}
  			if (isUndef(vnode.text)) {
  				if (isDef(oldCh) && isDef(ch)) {
  					if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
  				} else if (isDef(ch)) {
  					{
  						checkDuplicateKeys(ch);
  					}
  					if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
  					addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
  				} else if (isDef(oldCh)) {
  					removeVnodes(elm, oldCh, 0, oldCh.length - 1);
  				} else if (isDef(oldVnode.text)) {
  					nodeOps.setTextContent(elm, '');
  				}
  			} else if (oldVnode.text !== vnode.text) {
  				nodeOps.setTextContent(elm, vnode.text);
  			}
  			if (isDef(data)) {
  				if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
  			}
  		}
  		
  		function invokeInsertHook (vnode, queue, initial) {
  			// delay insert hooks for component root nodes, invoke them after the
  			// element is really inserted
  			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 = false;
  		// list of modules that can skip create hook during hydration because they
  		// are already rendered on the client or has no need for initialization
  		// Note: style is excluded because it relies on initial clone for future
  		// deep updates (#7063).
  		var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
  		
  		// Note: this is a browser-only function so we can assume elms are DOM nodes.
  		function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
  			var i;
  			var tag = vnode.tag;
  			var data = vnode.data;
  			var children = vnode.children;
  			inVPre = inVPre || (data && data.pre);
  			vnode.elm = elm;
  			
  			if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
  				vnode.isAsyncPlaceholder = true;
  				return true
  			}
  			// assert node match
  			{
  				if (!assertNodeMatch(elm, vnode, inVPre)) {
  					return false
  				}
  			}
  			if (isDef(data)) {
  				if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
  				if (isDef(i = vnode.componentInstance)) {
  					// child component. it should have hydrated its own tree.
  					initComponent(vnode, insertedVnodeQueue);
  					return true
  				}
  			}
  			if (isDef(tag)) {
  				if (isDef(children)) {
  					// empty element, allow client to pick up and populate children
  					if (!elm.hasChildNodes()) {
  						createChildren(vnode, children, insertedVnodeQueue);
  					} else {
  						// v-html and domProps: innerHTML
  						if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
  							if (i !== elm.innerHTML) {
  								/* istanbul ignore if */
  								if (typeof console !== 'undefined' &&
  									!hydrationBailed
  								) {
  									hydrationBailed = true;
  									console.warn('Parent: ', elm);
  									console.warn('server innerHTML: ', i);
  									console.warn('client innerHTML: ', elm.innerHTML);
  								}
  								return false
  							}
  						} else {
  							// iterate and compare children lists
  							var childrenMatch = true;
  							var childNode = elm.firstChild;
  							for (var i$1 = 0; i$1 < children.length; i$1++) {
  								if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
  									childrenMatch = false;
  									break
  								}
  								childNode = childNode.nextSibling;
  							}
  							// if childNode is not null, it means the actual childNodes list is
  							// longer than the virtual children list.
  							if (!childrenMatch || childNode) {
  								/* istanbul ignore if */
  								if (typeof console !== 'undefined' &&
  									!hydrationBailed
  								) {
  									hydrationBailed = true;
  									console.warn('Parent: ', elm);
  									console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
  								}
  								return false
  							}
  						}
  					}
  				}
  				if (isDef(data)) {
  					var fullInvoke = false;
  					for (var key in data) {
  						if (!isRenderedModule(key)) {
  							fullInvoke = true;
  							invokeCreateHooks(vnode, insertedVnodeQueue);
  							break
  						}
  					}
  					if (!fullInvoke && data['class']) {
  						// ensure collecting deps for deep class bindings for future updates
  						traverse(data['class']);
  					}
  				}
  			} else if (elm.data !== vnode.text) {
  				elm.data = vnode.text;
  			}
  			return true
  		}
  		
  		function assertNodeMatch (node, vnode, inVPre) {
  			if (isDef(vnode.tag)) {
  				return vnode.tag.indexOf('vue-component') === 0 || (
  					!isUnknownElement$$1(vnode, inVPre) &&
  					vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
  				)
  			} else {
  				return node.nodeType === (vnode.isComment ? 8 : 3)
  			}
  		}
  		
  		return function patch (oldVnode, vnode, hydrating, removeOnly) {
  			if (isUndef(vnode)) {
  				if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
  				return
  			}
  			
  			var isInitialPatch = false;
  			var insertedVnodeQueue = [];
  			
  			if (isUndef(oldVnode)) {
  				// empty mount (likely as component), create new root element
  				isInitialPatch = true;
  				createElm(vnode, insertedVnodeQueue);
  			} else {
  				var isRealElement = isDef(oldVnode.nodeType);
  				if (!isRealElement && sameVnode(oldVnode, vnode)) {
  					// patch existing root node
  					patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
  				} else {
  					if (isRealElement) {
  						// mounting to a real element
  						// check if this is server-rendered content and if we can perform
  						// a successful hydration.
  						if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
  							oldVnode.removeAttribute(SSR_ATTR);
  							hydrating = true;
  						}
  						if (isTrue(hydrating)) {
  							if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
  								invokeInsertHook(vnode, insertedVnodeQueue, true);
  								return oldVnode
  							} else {
  								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.'
  								);
  							}
  						}
  						// either not server-rendered, or hydration failed.
  						// create an empty node and replace it
  						oldVnode = emptyNodeAt(oldVnode);
  					}
  					
  					// replacing existing element
  					var oldElm = oldVnode.elm;
  					var parentElm = nodeOps.parentNode(oldElm);
  					
  					// create new node
  					createElm(
  						vnode,
  						insertedVnodeQueue,
  						// extremely rare edge case: do not insert if old element is in a
  						// leaving transition. Only happens when combining transition +
  						// keep-alive + HOCs. (#4590)
  						oldElm._leaveCb ? null : parentElm,
  						nodeOps.nextSibling(oldElm)
  					);
  					
  					// update parent placeholder node element, recursively
  					if (isDef(vnode.parent)) {
  						var ancestor = vnode.parent;
  						var patchable = isPatchable(vnode);
  						while (ancestor) {
  							for (var i = 0; i < cbs.destroy.length; ++i) {
  								cbs.destroy[i](ancestor);
  							}
  							ancestor.elm = vnode.elm;
  							if (patchable) {
  								for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
  									cbs.create[i$1](emptyNode, ancestor);
  								}
  								// #6513
  								// invoke insert hooks that may have been merged by create hooks.
  								// e.g. for directives that uses the "inserted" hook.
  								var insert = ancestor.data.hook.insert;
  								if (insert.merged) {
  									// start at index 1 to avoid re-invoking component mounted hook
  									for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
  										insert.fns[i$2]();
  									}
  								}
  							} else {
  								registerRef(ancestor);
  							}
  							ancestor = ancestor.parent;
  						}
  					}
  					
  					// destroy old node
  					if (isDef(parentElm)) {
  						removeVnodes(parentElm, [oldVnode], 0, 0);
  					} else if (isDef(oldVnode.tag)) {
  						invokeDestroyHook(oldVnode);
  					}
  				}
  			}
  			
  			invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
  			return vnode.elm
  		}
  	}
  	
  	/*  */
  	
  	var directives = {
  		create: updateDirectives,
  		update: updateDirectives,
  		destroy: function unbindDirectives (vnode) {
  			updateDirectives(vnode, emptyNode);
  		}
  	};
  	
  	function updateDirectives (oldVnode, vnode) {
  		if (oldVnode.data.directives || vnode.data.directives) {
  			_update(oldVnode, vnode);
  		}
  	}
  	
  	function _update (oldVnode, vnode) {
  		var isCreate = oldVnode === emptyNode;
  		var isDestroy = vnode === emptyNode;
  		var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
  		var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
  		
  		var dirsWithInsert = [];
  		var dirsWithPostpatch = [];
  		
  		var key, oldDir, dir;
  		for (key in newDirs) {
  			oldDir = oldDirs[key];
  			dir = newDirs[key];
  			if (!oldDir) {
  				// new directive, bind
  				callHook$1(dir, 'bind', vnode, oldVnode);
  				if (dir.def && dir.def.inserted) {
  					dirsWithInsert.push(dir);
  				}
  			} else {
  				// existing directive, update
  				dir.oldValue = oldDir.value;
  				dir.oldArg = oldDir.arg;
  				callHook$1(dir, 'update', vnode, oldVnode);
  				if (dir.def && dir.def.componentUpdated) {
  					dirsWithPostpatch.push(dir);
  				}
  			}
  		}
  		
  		if (dirsWithInsert.length) {
  			var callInsert = function () {
  				for (var i = 0; i < dirsWithInsert.length; i++) {
  					callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
  				}
  			};
  			if (isCreate) {
  				mergeVNodeHook(vnode, 'insert', callInsert);
  			} else {
  				callInsert();
  			}
  		}
  		
  		if (dirsWithPostpatch.length) {
  			mergeVNodeHook(vnode, 'postpatch', function () {
  				for (var i = 0; i < dirsWithPostpatch.length; i++) {
  					callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
  				}
  			});
  		}
  		
  		if (!isCreate) {
  			for (key in oldDirs) {
  				if (!newDirs[key]) {
  					// no longer present, unbind
  					callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
  				}
  			}
  		}
  	}
  	
  	var emptyModifiers = Object.create(null);
  	
  	function normalizeDirectives$1 (
  		dirs,
  		vm
  	) {
  		var res = Object.create(null);
  		if (!dirs) {
  			// $flow-disable-line
  			return res
  		}
  		var i, dir;
  		for (i = 0; i < dirs.length; i++) {
  			dir = dirs[i];
  			if (!dir.modifiers) {
  				// $flow-disable-line
  				dir.modifiers = emptyModifiers;
  			}
  			res[getRawDirName(dir)] = dir;
  			dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
  		}
  		// $flow-disable-line
  		return res
  	}
  	
  	function getRawDirName (dir) {
  		return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
  	}
  	
  	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"));
  			}
  		}
  	}
  	
  	var baseModules = [
  		ref,
  		directives
  	];
  	
  	/*  */
  	
  	function updateAttrs (oldVnode, vnode) {
  		var opts = vnode.componentOptions;
  		if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
  			return
  		}
  		if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
  			return
  		}
  		var key, cur, old;
  		var elm = vnode.elm;
  		var oldAttrs = oldVnode.data.attrs || {};
  		var attrs = vnode.data.attrs || {};
  		// clone observed objects, as the user probably wants to mutate it
  		if (isDef(attrs.__ob__)) {
  			attrs = vnode.data.attrs = extend({}, attrs);
  		}
  		
  		for (key in attrs) {
  			cur = attrs[key];
  			old = oldAttrs[key];
  			if (old !== cur) {
  				setAttr(elm, key, cur);
  			}
  		}
  		// #4391: in IE9, setting type can reset value for input[type=radio]
  		// #6666: IE/Edge forces progress value down to 1 before setting a max
  		/* istanbul ignore if */
  		if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
  			setAttr(elm, 'value', attrs.value);
  		}
  		for (key in oldAttrs) {
  			if (isUndef(attrs[key])) {
  				if (isXlink(key)) {
  					elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
  				} else if (!isEnumeratedAttr(key)) {
  					elm.removeAttribute(key);
  				}
  			}
  		}
  	}
  	
  	function setAttr (el, key, value) {
  		if (el.tagName.indexOf('-') > -1) {
  			baseSetAttr(el, key, value);
  		} else if (isBooleanAttr(key)) {
  			// set attribute for blank value
  			// e.g. <option disabled>Select one</option>
  			if (isFalsyAttrValue(value)) {
  				el.removeAttribute(key);
  			} else {
  				// technically allowfullscreen is a boolean attribute for <iframe>,
  				// but Flash expects a value of "true" when used on <embed> tag
  				value = key === 'allowfullscreen' && el.tagName === 'EMBED'
  					? 'true'
  					: key;
  				el.setAttribute(key, value);
  			}
  		} else if (isEnumeratedAttr(key)) {
  			el.setAttribute(key, convertEnumeratedValue(key, value));
  		} else if (isXlink(key)) {
  			if (isFalsyAttrValue(value)) {
  				el.removeAttributeNS(xlinkNS, getXlinkProp(key));
  			} else {
  				el.setAttributeNS(xlinkNS, key, value);
  			}
  		} else {
  			baseSetAttr(el, key, value);
  		}
  	}
  	
  	function baseSetAttr (el, key, value) {
  		if (isFalsyAttrValue(value)) {
  			el.removeAttribute(key);
  		} else {
  			// #7138: IE10 & 11 fires input event when setting placeholder on
  			// <textarea>... block the first input event and remove the blocker
  			// immediately.
  			/* istanbul ignore if */
  			if (
  				isIE && !isIE9 &&
  				el.tagName === 'TEXTAREA' &&
  				key === 'placeholder' && value !== '' && !el.__ieph
  			) {
  				var blocker = function (e) {
  					e.stopImmediatePropagation();
  					el.removeEventListener('input', blocker);
  				};
  				el.addEventListener('input', blocker);
  				// $flow-disable-line
  				el.__ieph = true; /* IE placeholder patched */
  			}
  			el.setAttribute(key, value);
  		}
  	}
  	
  	var attrs = {
  		create: updateAttrs,
  		update: updateAttrs
  	};
  	
  	/*  */
  	
  	function updateClass (oldVnode, vnode) {
  		var el = vnode.elm;
  		var data = vnode.data;
  		var oldData = oldVnode.data;
  		if (
  			isUndef(data.staticClass) &&
  			isUndef(data.class) && (
  				isUndef(oldData) || (
  					isUndef(oldData.staticClass) &&
  					isUndef(oldData.class)
  				)
  			)
  		) {
  			return
  		}
  		
  		var cls = genClassForVnode(vnode);
  		
  		// handle transition classes
  		var transitionClass = el._transitionClasses;
  		if (isDef(transitionClass)) {
  			cls = concat(cls, stringifyClass(transitionClass));
  		}
  		
  		// set the class
  		if (cls !== el._prevClass) {
  			el.setAttribute('class', cls);
  			el._prevClass = cls;
  		}
  	}
  	
  	var klass = {
  		create: updateClass,
  		update: updateClass
  	};
  	
  	/*  */
  	
  	var validDivisionCharRE = /[\w).+\-_$\]]/;
  	
  	function parseFilters (exp) {
  		var inSingle = false;
  		var inDouble = false;
  		var inTemplateString = false;
  		var inRegex = false;
  		var curly = 0;
  		var square = 0;
  		var paren = 0;
  		var lastFilterIndex = 0;
  		var c, prev, i, expression, filters;
  		
  		for (i = 0; i < exp.length; i++) {
  			prev = c;
  			c = exp.charCodeAt(i);
  			if (inSingle) {
  				if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
  			} else if (inDouble) {
  				if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
  			} else if (inTemplateString) {
  				if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
  			} else if (inRegex) {
  				if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
  			} else if (
  				c === 0x7C && // pipe
  				exp.charCodeAt(i + 1) !== 0x7C &&
  				exp.charCodeAt(i - 1) !== 0x7C &&
  				!curly && !square && !paren
  			) {
  				if (expression === undefined) {
  					// first filter, end of expression
  					lastFilterIndex = i + 1;
  					expression = exp.slice(0, i).trim();
  				} else {
  					pushFilter();
  				}
  			} else {
  				switch (c) {
  					case 0x22: inDouble = true; break         // "
  					case 0x27: inSingle = true; break         // '
  					case 0x60: inTemplateString = true; break // `
  					case 0x28: paren++; break                 // (
  					case 0x29: paren--; break                 // )
  					case 0x5B: square++; break                // [
  					case 0x5D: square--; break                // ]
  					case 0x7B: curly++; break                 // {
  					case 0x7D: curly--; break                 // }
  				}
  				if (c === 0x2f) { // /
  					var j = i - 1;
  					var p = (void 0);
  					// find first non-whitespace prev char
  					for (; j >= 0; j--) {
  						p = exp.charAt(j);
  						if (p !== ' ') { break }
  					}
  					if (!p || !validDivisionCharRE.test(p)) {
  						inRegex = true;
  					}
  				}
  			}
  		}
  		
  		if (expression === undefined) {
  			expression = exp.slice(0, i).trim();
  		} else if (lastFilterIndex !== 0) {
  			pushFilter();
  		}
  		
  		function pushFilter () {
  			(filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
  			lastFilterIndex = i + 1;
  		}
  		
  		if (filters) {
  			for (i = 0; i < filters.length; i++) {
  				expression = wrapFilter(expression, filters[i]);
  			}
  		}
  		
  		return expression
  	}
  	
  	function wrapFilter (exp, filter) {
  		var i = filter.indexOf('(');
  		if (i < 0) {
  			// _f: resolveFilter
  			return ("_f(\"" + filter + "\")(" + exp + ")")
  		} else {
  			var name = filter.slice(0, i);
  			var args = filter.slice(i + 1);
  			return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
  		}
  	}
  	
  	/*  */
  	
  	
  	
  	/* eslint-disable no-unused-vars */
  	function baseWarn (msg, range) {
  		console.error(("[Vue compiler]: " + msg));
  	}
  	/* eslint-enable no-unused-vars */
  	
  	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 = false;
  	}
  	
  	function addAttr (el, name, value, range, dynamic) {
  		var attrs = dynamic
  			? (el.dynamicAttrs || (el.dynamicAttrs = []))
  			: (el.attrs || (el.attrs = []));
  		attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
  		el.plain = false;
  	}
  	
  	// add a raw attr (use this in preTransforms)
  	function addRawAttr (el, name, value, range) {
  		el.attrsMap[name] = value;
  		el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
  	}
  	
  	function addDirective (
  		el,
  		name,
  		rawName,
  		value,
  		arg,
  		isDynamicArg,
  		modifiers,
  		range
  	) {
  		(el.directives || (el.directives = [])).push(rangeSetItem({
  			name: name,
  			rawName: rawName,
  			value: value,
  			arg: arg,
  			isDynamicArg: isDynamicArg,
  			modifiers: modifiers
  		}, range));
  		el.plain = false;
  	}
  	
  	function prependModifierMarker (symbol, name, dynamic) {
  		return dynamic
  			? ("_p(" + name + ",\"" + symbol + "\")")
  			: symbol + name // mark the event as captured
  	}
  	
  	function addHandler (
  		el,
  		name,
  		value,
  		modifiers,
  		important,
  		warn,
  		range,
  		dynamic
  	) {
  		modifiers = modifiers || emptyObject;
  		// warn prevent and passive modifier
  		/* istanbul ignore if */
  		if (
  			warn &&
  			modifiers.prevent && modifiers.passive
  		) {
  			warn(
  				'passive and prevent can\'t be used together. ' +
  				'Passive handler can\'t prevent default event.',
  				range
  			);
  		}
  		
  		// normalize click.right and click.middle since they don't actually fire
  		// this is technically browser-specific, but at least for now browsers are
  		// the only target envs that have right/middle clicks.
  		if (modifiers.right) {
  			if (dynamic) {
  				name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
  			} else if (name === 'click') {
  				name = 'contextmenu';
  				delete modifiers.right;
  			}
  		} else if (modifiers.middle) {
  			if (dynamic) {
  				name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
  			} else if (name === 'click') {
  				name = 'mouseup';
  			}
  		}
  		
  		// check capture modifier
  		if (modifiers.capture) {
  			delete modifiers.capture;
  			name = prependModifierMarker('!', name, dynamic);
  		}
  		if (modifiers.once) {
  			delete modifiers.once;
  			name = prependModifierMarker('~', name, dynamic);
  		}
  		/* istanbul ignore if */
  		if (modifiers.passive) {
  			delete modifiers.passive;
  			name = prependModifierMarker('&', name, dynamic);
  		}
  		
  		var events;
  		if (modifiers.native) {
  			delete modifiers.native;
  			events = el.nativeEvents || (el.nativeEvents = {});
  		} else {
  			events = el.events || (el.events = {});
  		}
  		
  		var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
  		if (modifiers !== emptyObject) {
  			newHandler.modifiers = modifiers;
  		}
  		
  		var handlers = events[name];
  		/* istanbul ignore if */
  		if (Array.isArray(handlers)) {
  			important ? handlers.unshift(newHandler) : handlers.push(newHandler);
  		} else if (handlers) {
  			events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
  		} else {
  			events[name] = newHandler;
  		}
  		
  		el.plain = false;
  	}
  	
  	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 (dynamicValue != null) {
  			return parseFilters(dynamicValue)
  		} else if (getStatic !== false) {
  			var staticValue = getAndRemoveAttr(el, name);
  			if (staticValue != null) {
  				return JSON.stringify(staticValue)
  			}
  		}
  	}
  	
  	// note: this only removes the attr from the Array (attrsList) so that it
  	// doesn't get processed by processAttrs.
  	// By default it does NOT remove it from the map (attrsMap) because the map is
  	// needed during codegen.
  	function getAndRemoveAttr (
  		el,
  		name,
  		removeFromMap
  	) {
  		var val;
  		if ((val = el.attrsMap[name]) != null) {
  			var list = el.attrsList;
  			for (var i = 0, l = list.length; i < l; i++) {
  				if (list[i].name === name) {
  					list.splice(i, 1);
  					break
  				}
  			}
  		}
  		if (removeFromMap) {
  			delete el.attrsMap[name];
  		}
  		return val
  	}
  	
  	function getAndRemoveAttrByRegex (
  		el,
  		name
  	) {
  		var list = el.attrsList;
  		for (var i = 0, l = list.length; i < l; i++) {
  			var attr = list[i];
  			if (name.test(attr.name)) {
  				list.splice(i, 1);
  				return attr
  			}
  		}
  	}
  	
  	function rangeSetItem (
  		item,
  		range
  	) {
  		if (range) {
  			if (range.start != null) {
  				item.start = range.start;
  			}
  			if (range.end != null) {
  				item.end = range.end;
  			}
  		}
  		return item
  	}
  	
  	/*  */
  	
  	/**
  	 * Cross-platform code generation for component v-model
  	 */
  	function genComponentModel (
  		el,
  		value,
  		modifiers
  	) {
  		var ref = modifiers || {};
  		var number = ref.number;
  		var trim = ref.trim;
  		
  		var baseValueExpression = '$$v';
  		var valueExpression = baseValueExpression;
  		if (trim) {
  			valueExpression =
  				"(typeof " + baseValueExpression + " === 'string'" +
  				"? " + baseValueExpression + ".trim()" +
  				": " + baseValueExpression + ")";
  		}
  		if (number) {
  			valueExpression = "_n(" + valueExpression + ")";
  		}
  		var assignment = genAssignmentCode(value, valueExpression);
  		
  		el.model = {
  			value: ("(" + value + ")"),
  			expression: JSON.stringify(value),
  			callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
  		};
  	}
  	
  	/**
  	 * Cross-platform codegen helper for generating v-model value assignment code.
  	 */
  	function genAssignmentCode (
  		value,
  		assignment
  	) {
  		var res = parseModel(value);
  		if (res.key === null) {
  			return (value + "=" + assignment)
  		} else {
  			return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
  		}
  	}
  	
  	/**
  	 * Parse a v-model expression into a base path and a final key segment.
  	 * Handles both dot-path and possible square brackets.
  	 *
  	 * Possible cases:
  	 *
  	 * - test
  	 * - test[key]
  	 * - test[test1[key]]
  	 * - test["a"][key]
  	 * - xxx.test[a[a].test1[key]]
  	 * - test.xxx.a["asa"][test1[key]]
  	 *
  	 */
  	
  	var len, str, chr, index$1, expressionPos, expressionEndPos;
  	
  	
  	
  	function parseModel (val) {
  		// Fix https://github.com/vuejs/vue/pull/7730
  		// allow v-model="obj.val " (trailing whitespace)
  		val = val.trim();
  		len = val.length;
  		
  		if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
  			index$1 = val.lastIndexOf('.');
  			if (index$1 > -1) {
  				return {
  					exp: val.slice(0, index$1),
  					key: '"' + val.slice(index$1 + 1) + '"'
  				}
  			} else {
  				return {
  					exp: val,
  					key: null
  				}
  			}
  		}
  		
  		str = val;
  		index$1 = expressionPos = expressionEndPos = 0;
  		
  		while (!eof()) {
  			chr = next();
  			/* istanbul ignore if */
  			if (isStringStart(chr)) {
  				parseString(chr);
  			} else if (chr === 0x5B) {
  				parseBracket(chr);
  			}
  		}
  		
  		return {
  			exp: val.slice(0, expressionPos),
  			key: val.slice(expressionPos + 1, expressionEndPos)
  		}
  	}
  	
  	function next () {
  		return str.charCodeAt(++index$1)
  	}
  	
  	function eof () {
  		return index$1 >= len
  	}
  	
  	function isStringStart (chr) {
  		return chr === 0x22 || chr === 0x27
  	}
  	
  	function parseBracket (chr) {
  		var inBracket = 1;
  		expressionPos = index$1;
  		while (!eof()) {
  			chr = next();
  			if (isStringStart(chr)) {
  				parseString(chr);
  				continue
  			}
  			if (chr === 0x5B) { inBracket++; }
  			if (chr === 0x5D) { inBracket--; }
  			if (inBracket === 0) {
  				expressionEndPos = index$1;
  				break
  			}
  		}
  	}
  	
  	function parseString (chr) {
  		var stringQuote = chr;
  		while (!eof()) {
  			chr = next();
  			if (chr === stringQuote) {
  				break
  			}
  		}
  	}
  	
  	/*  */
  	
  	var warn$1;
  	
  	// in some cases, the event used has to be determined at runtime
  	// so we used some reserved tokens during compile.
  	var RANGE_TOKEN = '__r';
  	var CHECKBOX_RADIO_TOKEN = '__c';
  	
  	function model (
  		el,
  		dir,
  		_warn
  	) {
  		warn$1 = _warn;
  		var value = dir.value;
  		var modifiers = dir.modifiers;
  		var tag = el.tag;
  		var type = el.attrsMap.type;
  		
  		{
  			// inputs with type="file" are read only and setting the input's
  			// value will throw an error.
  			if (tag === 'input' && type === 'file') {
  				warn$1(
  					"<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
  					"File inputs are read only. Use a v-on:change listener instead.",
  					el.rawAttrsMap['v-model']
  				);
  			}
  		}
  		
  		if (el.component) {
  			genComponentModel(el, value, modifiers);
  			// component v-model doesn't need extra runtime
  			return false
  		} else if (tag === 'select') {
  			genSelect(el, value, modifiers);
  		} else if (tag === 'input' && type === 'checkbox') {
  			genCheckboxModel(el, value, modifiers);
  		} else if (tag === 'input' && type === 'radio') {
  			genRadioModel(el, value, modifiers);
  		} else if (tag === 'input' || tag === 'textarea') {
  			genDefaultModel(el, value, modifiers);
  		} else if (!config.isReservedTag(tag)) {
  			genComponentModel(el, value, modifiers);
  			// component v-model doesn't need extra runtime
  			return false
  		} else {
  			warn$1(
  				"<" + (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']
  			);
  		}
  		
  		// ensure runtime directive metadata
  		return true
  	}
  	
  	function genCheckboxModel (
  		el,
  		value,
  		modifiers
  	) {
  		var number = modifiers && modifiers.number;
  		var valueBinding = getBindingAttr(el, 'value') || 'null';
  		var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
  		var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
  		addProp(el, 'checked',
  			"Array.isArray(" + value + ")" +
  			"?_i(" + value + "," + valueBinding + ")>-1" + (
  				trueValueBinding === 'true'
  					? (":(" + 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, true
  		);
  	}
  	
  	function genRadioModel (
  		el,
  		value,
  		modifiers
  	) {
  		var number = modifiers && modifiers.number;
  		var valueBinding = getBindingAttr(el, 'value') || 'null';
  		valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
  		addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
  		addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
  	}
  	
  	function genSelect (
  		el,
  		value,
  		modifiers
  	) {
  		var number = modifiers && modifiers.number;
  		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 " + (number ? '_n(val)' : 'val') + "})";
  		
  		var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
  		var code = "var $$selectedVal = " + selectedVal + ";";
  		code = code + " " + (genAssignmentCode(value, assignment));
  		addHandler(el, 'change', code, null, true);
  	}
  	
  	function genDefaultModel (
  		el,
  		value,
  		modifiers
  	) {
  		var type = el.attrsMap.type;
  		
  		// warn if v-bind:value conflicts with v-model
  		// except for inputs with v-bind:type
  		{
  			var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
  			var 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$1(
  					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 || {};
  		var lazy = ref.lazy;
  		var number = ref.number;
  		var trim = ref.trim;
  		var needCompositionGuard = !lazy && type !== 'range';
  		var event = lazy
  			? 'change'
  			: type === 'range'
  				? RANGE_TOKEN
  				: 'input';
  		
  		var valueExpression = '$event.target.value';
  		if (trim) {
  			valueExpression = "$event.target.value.trim()";
  		}
  		if (number) {
  			valueExpression = "_n(" + valueExpression + ")";
  		}
  		
  		var code = genAssignmentCode(value, valueExpression);
  		if (needCompositionGuard) {
  			code = "if($event.target.composing)return;" + code;
  		}
  		
  		addProp(el, 'value', ("(" + value + ")"));
  		addHandler(el, event, code, null, true);
  		if (trim || number) {
  			addHandler(el, 'blur', '$forceUpdate()');
  		}
  	}
  	
  	/*  */
  	
  	// normalize v-model event tokens that can only be determined at runtime.
  	// it's important to place the event as the first in the array because
  	// the whole point is ensuring the v-model callback gets called before
  	// user-attached handlers.
  	function normalizeEvents (on) {
  		/* istanbul ignore if */
  		if (isDef(on[RANGE_TOKEN])) {
  			// IE input[type=range] only supports `change` event
  			var event = isIE ? 'change' : 'input';
  			on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
  			delete on[RANGE_TOKEN];
  		}
  		// This was originally intended to fix #4521 but no longer necessary
  		// after 2.5. Keeping it for backwards compat with generated code from < 2.4
  		/* istanbul ignore if */
  		if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
  			on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
  			delete on[CHECKBOX_RADIO_TOKEN];
  		}
  	}
  	
  	var target$1;
  	
  	function createOnceHandler$1 (event, handler, capture) {
  		var _target = target$1; // save current target element in closure
  		return function onceHandler () {
  			var res = handler.apply(null, arguments);
  			if (res !== null) {
  				remove$2(event, onceHandler, capture, _target);
  			}
  		}
  	}
  	
  	// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
  	// implementation and does not fire microtasks in between event propagation, so
  	// safe to exclude.
  	var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
  	
  	function add$1 (
  		name,
  		handler,
  		capture,
  		passive
  	) {
  		// async edge case #6566: inner click event triggers patch, event handler
  		// attached to outer element during patch, and triggered again. This
  		// happens because browsers fire microtask ticks between event propagation.
  		// the solution is simple: we save the timestamp when a handler is attached,
  		// and the handler would only fire if the event passed to it was fired
  		// AFTER it was attached.
  		if (useMicrotaskFix) {
  			var attachedTimestamp = currentFlushTimestamp;
  			var original = handler;
  			handler = original._wrapper = function (e) {
  				if (
  					// no bubbling, should always fire.
  				// this is just a safety net in case event.timeStamp is unreliable in
  				// certain weird environments...
  					e.target === e.currentTarget ||
  					// event is fired after handler attachment
  					e.timeStamp >= attachedTimestamp ||
  					// bail for environments that have buggy event.timeStamp implementations
  					// #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
  					// #9681 QtWebEngine event.timeStamp is negative value
  					e.timeStamp <= 0 ||
  					// #9448 bail if event is fired in another document in a multi-page
  					// electron/nw.js app, since event.timeStamp will be using a different
  					// starting reference
  					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)) {
  			return
  		}
  		var on = vnode.data.on || {};
  		var oldOn = oldVnode.data.on || {};
  		target$1 = vnode.elm;
  		normalizeEvents(on);
  		updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
  		target$1 = undefined;
  	}
  	
  	var events = {
  		create: updateDOMListeners,
  		update: updateDOMListeners
  	};
  	
  	/*  */
  	
  	var svgContainer;
  	
  	function updateDOMProps (oldVnode, vnode) {
  		if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
  			return
  		}
  		var key, cur;
  		var elm = vnode.elm;
  		var oldProps = oldVnode.data.domProps || {};
  		var props = vnode.data.domProps || {};
  		// clone observed objects, as the user probably wants to mutate it
  		if (isDef(props.__ob__)) {
  			props = vnode.data.domProps = extend({}, props);
  		}
  		
  		for (key in oldProps) {
  			if (!(key in props)) {
  				elm[key] = '';
  			}
  		}
  		
  		for (key in props) {
  			cur = props[key];
  			// ignore children if the node has textContent or innerHTML,
  			// as these will throw away existing DOM nodes and cause removal errors
  			// on subsequent patches (#3360)
  			if (key === 'textContent' || key === 'innerHTML') {
  				if (vnode.children) { vnode.children.length = 0; }
  				if (cur === oldProps[key]) { continue }
  				// #6601 work around Chrome version <= 55 bug where single textNode
  				// replaced by innerHTML/textContent retains its parentNode property
  				if (elm.childNodes.length === 1) {
  					elm.removeChild(elm.childNodes[0]);
  				}
  			}
  			
  			if (key === 'value' && elm.tagName !== 'PROGRESS') {
  				// store value as _value as well since
  				// non-string values will be stringified
  				elm._value = cur;
  				// avoid resetting cursor position when value is the same
  				var strCur = isUndef(cur) ? '' : String(cur);
  				if (shouldUpdateValue(elm, strCur)) {
  					elm.value = strCur;
  				}
  			} else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
  				// IE doesn't support innerHTML for SVG elements
  				svgContainer = svgContainer || document.createElement('div');
  				svgContainer.innerHTML = "<svg>" + cur + "</svg>";
  				var svg = svgContainer.firstChild;
  				while (elm.firstChild) {
  					elm.removeChild(elm.firstChild);
  				}
  				while (svg.firstChild) {
  					elm.appendChild(svg.firstChild);
  				}
  			} else if (
  				// skip the update if old and new VDOM state is the same.
  			// `value` is handled separately because the DOM value may be temporarily
  			// out of sync with VDOM state due to focus, composition and modifiers.
  			// This  #4521 by skipping the unnecesarry `checked` update.
  				cur !== oldProps[key]
  			) {
  				// some property updates can throw
  				// e.g. `value` on <progress> w/ non-finite value
  				try {
  					elm[key] = cur;
  				} catch (e) {}
  			}
  		}
  	}
  	
  	// check platforms/web/util/attrs.js acceptValue
  	
  	
  	function shouldUpdateValue (elm, checkVal) {
  		return (!elm.composing && (
  			elm.tagName === 'OPTION' ||
  			isNotInFocusAndDirty(elm, checkVal) ||
  			isDirtyWithModifiers(elm, checkVal)
  		))
  	}
  	
  	function isNotInFocusAndDirty (elm, checkVal) {
  		// return true when textbox (.number and .trim) loses focus and its value is
  		// not equal to the updated value
  		var notInFocus = true;
  		// #6157
  		// work around IE bug when accessing document.activeElement in an iframe
  		try { notInFocus = document.activeElement !== elm; } catch (e) {}
  		return notInFocus && elm.value !== checkVal
  	}
  	
  	function isDirtyWithModifiers (elm, newVal) {
  		var value = elm.value;
  		var modifiers = elm._vModifiers; // injected by v-model runtime
  		if (isDef(modifiers)) {
  			if (modifiers.number) {
  				return toNumber(value) !== toNumber(newVal)
  			}
  			if (modifiers.trim) {
  				return value.trim() !== newVal.trim()
  			}
  		}
  		return value !== newVal
  	}
  	
  	var domProps = {
  		create: updateDOMProps,
  		update: updateDOMProps
  	};
  	
  	/*  */
  	
  	var parseStyleText = cached(function (cssText) {
  		var res = {};
  		var listDelimiter = /;(?![^(]*\))/g;
  		var propertyDelimiter = /:(.+)/;
  		cssText.split(listDelimiter).forEach(function (item) {
  			if (item) {
  				var tmp = item.split(propertyDelimiter);
  				tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
  			}
  		});
  		return res
  	});
  	
  	// merge static and dynamic style data on the same vnode
  	function normalizeStyleData (data) {
  		var style = normalizeStyleBinding(data.style);
  		// static style is pre-processed into an object during compilation
  		// and is always a fresh object, so it's safe to merge into it
  		return data.staticStyle
  			? extend(data.staticStyle, style)
  			: style
  	}
  	
  	// normalize possible array / string values into Object
  	function normalizeStyleBinding (bindingStyle) {
  		if (Array.isArray(bindingStyle)) {
  			return toObject(bindingStyle)
  		}
  		if (typeof bindingStyle === 'string') {
  			return parseStyleText(bindingStyle)
  		}
  		return bindingStyle
  	}
  	
  	/**
  	 * parent component style should be after child's
  	 * so that parent component's style could override it
  	 */
  	function getStyle (vnode, checkChild) {
  		var res = {};
  		var styleData;
  		
  		if (checkChild) {
  			var childNode = vnode;
  			while (childNode.componentInstance) {
  				childNode = childNode.componentInstance._vnode;
  				if (
  					childNode && childNode.data &&
  					(styleData = normalizeStyleData(childNode.data))
  				) {
  					extend(res, styleData);
  				}
  			}
  		}
  		
  		if ((styleData = normalizeStyleData(vnode.data))) {
  			extend(res, styleData);
  		}
  		
  		var parentNode = vnode;
  		while ((parentNode = parentNode.parent)) {
  			if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
  				extend(res, styleData);
  			}
  		}
  		return res
  	}
  	
  	/*  */
  	
  	var cssVarRE = /^--/;
  	var importantRE = /\s*!important$/;
  	var setProp = function (el, name, val) {
  		/* istanbul ignore if */
  		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)) {
  				// Support values array created by autoprefixer, e.g.
  				// {display: ["-webkit-box", "-ms-flexbox", "flex"]}
  				// Set them one by one, and the browser will only set those it can recognize
  				for (var i = 0, len = val.length; i < len; i++) {
  					el.style[normalizedName] = val[i];
  				}
  			} else {
  				el.style[normalizedName] = val;
  			}
  		}
  	};
  	
  	var vendorNames = ['Webkit', 'Moz', 'ms'];
  	
  	var emptyStyle;
  	var normalize = cached(function (prop) {
  		emptyStyle = emptyStyle || document.createElement('div').style;
  		prop = camelize(prop);
  		if (prop !== 'filter' && (prop in emptyStyle)) {
  			return prop
  		}
  		var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
  		for (var i = 0; i < vendorNames.length; i++) {
  			var name = vendorNames[i] + capName;
  			if (name in emptyStyle) {
  				return name
  			}
  		}
  	});
  	
  	function updateStyle (oldVnode, vnode) {
  		var data = vnode.data;
  		var oldData = oldVnode.data;
  		
  		if (isUndef(data.staticStyle) && isUndef(data.style) &&
  			isUndef(oldData.staticStyle) && isUndef(oldData.style)
  		) {
  			return
  		}
  		
  		var cur, name;
  		var el = vnode.elm;
  		var oldStaticStyle = oldData.staticStyle;
  		var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
  		
  		// if static style exists, stylebinding already merged into it when doing normalizeStyleData
  		var oldStyle = oldStaticStyle || oldStyleBinding;
  		
  		var style = normalizeStyleBinding(vnode.data.style) || {};
  		
  		// store normalized style under a different key for next diff
  		// make sure to clone it if it's reactive, since the user likely wants
  		// to mutate it.
  		vnode.data.normalizedStyle = isDef(style.__ob__)
  			? extend({}, style)
  			: style;
  		
  		var newStyle = getStyle(vnode, true);
  		
  		for (name in oldStyle) {
  			if (isUndef(newStyle[name])) {
  				setProp(el, name, '');
  			}
  		}
  		for (name in newStyle) {
  			cur = newStyle[name];
  			if (cur !== oldStyle[name]) {
  				// ie9 setting to null has no effect, must use empty string
  				setProp(el, name, cur == null ? '' : cur);
  			}
  		}
  	}
  	
  	var style = {
  		create: updateStyle,
  		update: updateStyle
  	};
  	
  	/*  */
  	
  	var whitespaceRE = /\s+/;
  	
  	/**
  	 * Add class with compatibility for SVG since classList is not supported on
  	 * SVG elements in IE
  	 */
  	function addClass (el, cls) {
  		/* istanbul ignore if */
  		if (!cls || !(cls = cls.trim())) {
  			return
  		}
  		
  		/* istanbul ignore else */
  		if (el.classList) {
  			if (cls.indexOf(' ') > -1) {
  				cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
  			} else {
  				el.classList.add(cls);
  			}
  		} else {
  			var cur = " " + (el.getAttribute('class') || '') + " ";
  			if (cur.indexOf(' ' + cls + ' ') < 0) {
  				el.setAttribute('class', (cur + cls).trim());
  			}
  		}
  	}
  	
  	/**
  	 * Remove class with compatibility for SVG since classList is not supported on
  	 * SVG elements in IE
  	 */
  	function removeClass (el, cls) {
  		/* istanbul ignore if */
  		if (!cls || !(cls = cls.trim())) {
  			return
  		}
  		
  		/* istanbul ignore else */
  		if (el.classList) {
  			if (cls.indexOf(' ') > -1) {
  				cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
  			} else {
  				el.classList.remove(cls);
  			}
  			if (!el.classList.length) {
  				el.removeAttribute('class');
  			}
  		} else {
  			var cur = " " + (el.getAttribute('class') || '') + " ";
  			var tar = ' ' + cls + ' ';
  			while (cur.indexOf(tar) >= 0) {
  				cur = cur.replace(tar, ' ');
  			}
  			cur = cur.trim();
  			if (cur) {
  				el.setAttribute('class', cur);
  			} else {
  				el.removeAttribute('class');
  			}
  		}
  	}
  	
  	/*  */
  	
  	function resolveTransition (def$$1) {
  		if (!def$$1) {
  			return
  		}
  		/* istanbul ignore else */
  		if (typeof def$$1 === 'object') {
  			var res = {};
  			if (def$$1.css !== false) {
  				extend(res, autoCssTransition(def$$1.name || 'v'));
  			}
  			extend(res, def$$1);
  			return res
  		} else if (typeof def$$1 === 'string') {
  			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")
  		}
  	});
  	
  	var hasTransition = inBrowser && !isIE9;
  	var TRANSITION = 'transition';
  	var ANIMATION = 'animation';
  	
  	// Transition property/event sniffing
  	var transitionProp = 'transition';
  	var transitionEndEvent = 'transitionend';
  	var animationProp = 'animation';
  	var animationEndEvent = 'animationend';
  	if (hasTransition) {
  		/* istanbul ignore if */
  		if (window.ontransitionend === undefined &&
  			window.onwebkittransitionend !== undefined
  		) {
  			transitionProp = 'WebkitTransition';
  			transitionEndEvent = 'webkitTransitionEnd';
  		}
  		if (window.onanimationend === undefined &&
  			window.onwebkitanimationend !== undefined
  		) {
  			animationProp = 'WebkitAnimation';
  			animationEndEvent = 'webkitAnimationEnd';
  		}
  	}
  	
  	// binding to window is necessary to make hot reload work in IE in strict mode
  	var raf = inBrowser
  		? window.requestAnimationFrame
  			? window.requestAnimationFrame.bind(window)
  			: setTimeout
  		: /* istanbul ignore next */ function (fn) { return fn(); };
  	
  	function nextFrame (fn) {
  		raf(function () {
  			raf(fn);
  		});
  	}
  	
  	function addTransitionClass (el, cls) {
  		var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
  		if (transitionClasses.indexOf(cls) < 0) {
  			transitionClasses.push(cls);
  			addClass(el, cls);
  		}
  	}
  	
  	function removeTransitionClass (el, cls) {
  		if (el._transitionClasses) {
  			remove(el._transitionClasses, cls);
  		}
  		removeClass(el, cls);
  	}
  	
  	function whenTransitionEnds (
  		el,
  		expectedType,
  		cb
  	) {
  		var ref = getTransitionInfo(el, expectedType);
  		var type = ref.type;
  		var timeout = ref.timeout;
  		var propCount = ref.propCount;
  		if (!type) { return cb() }
  		var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
  		var ended = 0;
  		var end = function () {
  			el.removeEventListener(event, onEnd);
  			cb();
  		};
  		var onEnd = function (e) {
  			if (e.target === el) {
  				if (++ended >= propCount) {
  					end();
  				}
  			}
  		};
  		setTimeout(function () {
  			if (ended < propCount) {
  				end();
  			}
  		}, timeout + 1);
  		el.addEventListener(event, onEnd);
  	}
  	
  	var transformRE = /\b(transform|all)(,|$)/;
  	
  	function getTransitionInfo (el, expectedType) {
  		var styles = window.getComputedStyle(el);
  		// JSDOM may return undefined for transition properties
  		var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
  		var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
  		var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
  		var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
  		var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
  		var animationTimeout = getTimeout(animationDelays, animationDurations);
  		
  		var type;
  		var timeout = 0;
  		var propCount = 0;
  		/* istanbul ignore if */
  		if (expectedType === TRANSITION) {
  			if (transitionTimeout > 0) {
  				type = TRANSITION;
  				timeout = transitionTimeout;
  				propCount = transitionDurations.length;
  			}
  		} else if (expectedType === ANIMATION) {
  			if (animationTimeout > 0) {
  				type = ANIMATION;
  				timeout = animationTimeout;
  				propCount = animationDurations.length;
  			}
  		} else {
  			timeout = Math.max(transitionTimeout, animationTimeout);
  			type = timeout > 0
  				? transitionTimeout > animationTimeout
  					? TRANSITION
  					: ANIMATION
  				: null;
  			propCount = type
  				? 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) {
  		/* istanbul ignore next */
  		while (delays.length < durations.length) {
  			delays = delays.concat(delays);
  		}
  		
  		return Math.max.apply(null, durations.map(function (d, i) {
  			return toMs(d) + toMs(delays[i])
  		}))
  	}
  	
  	// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
  	// in a locale-dependent way, using a comma instead of a dot.
  	// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
  	// as a floor function) causing unexpected behaviors
  	function toMs (s) {
  		return Number(s.slice(0, -1).replace(',', '.')) * 1000
  	}
  	
  	/*  */
  	
  	function enter (vnode, toggleDisplay) {
  		var el = vnode.elm;
  		
  		// call leave callback now
  		if (isDef(el._leaveCb)) {
  			el._leaveCb.cancelled = true;
  			el._leaveCb();
  		}
  		
  		var data = resolveTransition(vnode.data.transition);
  		if (isUndef(data)) {
  			return
  		}
  		
  		/* istanbul ignore if */
  		if (isDef(el._enterCb) || el.nodeType !== 1) {
  			return
  		}
  		
  		var css = data.css;
  		var type = data.type;
  		var enterClass = data.enterClass;
  		var enterToClass = data.enterToClass;
  		var enterActiveClass = data.enterActiveClass;
  		var appearClass = data.appearClass;
  		var appearToClass = data.appearToClass;
  		var appearActiveClass = data.appearActiveClass;
  		var beforeEnter = data.beforeEnter;
  		var enter = data.enter;
  		var afterEnter = data.afterEnter;
  		var enterCancelled = data.enterCancelled;
  		var beforeAppear = data.beforeAppear;
  		var appear = data.appear;
  		var afterAppear = data.afterAppear;
  		var appearCancelled = data.appearCancelled;
  		var duration = data.duration;
  		
  		// activeInstance will always be the <transition> component managing this
  		// transition. One edge case to check is when the <transition> is placed
  		// as the root node of a child component. In that case we need to check
  		// <transition>'s parent for appear check.
  		var context = activeInstance;
  		var transitionNode = activeInstance.$vnode;
  		while (transitionNode && transitionNode.parent) {
  			context = transitionNode.context;
  			transitionNode = transitionNode.parent;
  		}
  		
  		var isAppear = !context._isMounted || !vnode.isRootInsert;
  		
  		if (isAppear && !appear && appear !== '') {
  			return
  		}
  		
  		var startClass = isAppear && appearClass
  			? appearClass
  			: enterClass;
  		var activeClass = isAppear && appearActiveClass
  			? appearActiveClass
  			: enterActiveClass;
  		var toClass = isAppear && appearToClass
  			? appearToClass
  			: enterToClass;
  		
  		var beforeEnterHook = isAppear
  			? (beforeAppear || beforeEnter)
  			: beforeEnter;
  		var enterHook = isAppear
  			? (typeof appear === 'function' ? appear : enter)
  			: enter;
  		var afterEnterHook = isAppear
  			? (afterAppear || afterEnter)
  			: afterEnter;
  		var enterCancelledHook = isAppear
  			? (appearCancelled || enterCancelled)
  			: enterCancelled;
  		
  		var explicitEnterDuration = toNumber(
  			isObject(duration)
  				? duration.enter
  				: duration
  		);
  		
  		if (explicitEnterDuration != null) {
  			checkDuration(explicitEnterDuration, 'enter', vnode);
  		}
  		
  		var expectsCSS = css !== false && !isIE9;
  		var userWantsControl = getHookArgumentsLength(enterHook);
  		
  		var cb = el._enterCb = once(function () {
  			if (expectsCSS) {
  				removeTransitionClass(el, toClass);
  				removeTransitionClass(el, activeClass);
  			}
  			if (cb.cancelled) {
  				if (expectsCSS) {
  					removeTransitionClass(el, startClass);
  				}
  				enterCancelledHook && enterCancelledHook(el);
  			} else {
  				afterEnterHook && afterEnterHook(el);
  			}
  			el._enterCb = null;
  		});
  		
  		if (!vnode.data.show) {
  			// remove pending leave element on enter by injecting an insert hook
  			mergeVNodeHook(vnode, 'insert', function () {
  				var parent = el.parentNode;
  				var pendingNode = parent && parent._pending && parent._pending[vnode.key];
  				if (pendingNode &&
  					pendingNode.tag === vnode.tag &&
  					pendingNode.elm._leaveCb
  				) {
  					pendingNode.elm._leaveCb();
  				}
  				enterHook && enterHook(el, cb);
  			});
  		}
  		
  		// start enter transition
  		beforeEnterHook && beforeEnterHook(el);
  		if (expectsCSS) {
  			addTransitionClass(el, startClass);
  			addTransitionClass(el, activeClass);
  			nextFrame(function () {
  				removeTransitionClass(el, startClass);
  				if (!cb.cancelled) {
  					addTransitionClass(el, toClass);
  					if (!userWantsControl) {
  						if (isValidDuration(explicitEnterDuration)) {
  							setTimeout(cb, explicitEnterDuration);
  						} else {
  							whenTransitionEnds(el, type, cb);
  						}
  					}
  				}
  			});
  		}
  		
  		if (vnode.data.show) {
  			toggleDisplay && toggleDisplay();
  			enterHook && enterHook(el, cb);
  		}
  		
  		if (!expectsCSS && !userWantsControl) {
  			cb();
  		}
  	}
  	
  	function leave (vnode, rm) {
  		var el = vnode.elm;
  		
  		// call enter callback now
  		if (isDef(el._enterCb)) {
  			el._enterCb.cancelled = true;
  			el._enterCb();
  		}
  		
  		var data = resolveTransition(vnode.data.transition);
  		if (isUndef(data) || el.nodeType !== 1) {
  			return rm()
  		}
  		
  		/* istanbul ignore if */
  		if (isDef(el._leaveCb)) {
  			return
  		}
  		
  		var css = data.css;
  		var type = data.type;
  		var leaveClass = data.leaveClass;
  		var leaveToClass = data.leaveToClass;
  		var leaveActiveClass = data.leaveActiveClass;
  		var beforeLeave = data.beforeLeave;
  		var leave = data.leave;
  		var afterLeave = data.afterLeave;
  		var leaveCancelled = data.leaveCancelled;
  		var delayLeave = data.delayLeave;
  		var duration = data.duration;
  		
  		var expectsCSS = css !== false && !isIE9;
  		var userWantsControl = getHookArgumentsLength(leave);
  		
  		var explicitLeaveDuration = toNumber(
  			isObject(duration)
  				? duration.leave
  				: duration
  		);
  		
  		if (isDef(explicitLeaveDuration)) {
  			checkDuration(explicitLeaveDuration, 'leave', vnode);
  		}
  		
  		var cb = el._leaveCb = once(function () {
  			if (el.parentNode && el.parentNode._pending) {
  				el.parentNode._pending[vnode.key] = null;
  			}
  			if (expectsCSS) {
  				removeTransitionClass(el, leaveToClass);
  				removeTransitionClass(el, leaveActiveClass);
  			}
  			if (cb.cancelled) {
  				if (expectsCSS) {
  					removeTransitionClass(el, leaveClass);
  				}
  				leaveCancelled && leaveCancelled(el);
  			} else {
  				rm();
  				afterLeave && afterLeave(el);
  			}
  			el._leaveCb = null;
  		});
  		
  		if (delayLeave) {
  			delayLeave(performLeave);
  		} else {
  			performLeave();
  		}
  		
  		function performLeave () {
  			// the delayed leave may have already been cancelled
  			if (cb.cancelled) {
  				return
  			}
  			// record leaving element
  			if (!vnode.data.show && el.parentNode) {
  				(el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;
  			}
  			beforeLeave && beforeLeave(el);
  			if (expectsCSS) {
  				addTransitionClass(el, leaveClass);
  				addTransitionClass(el, leaveActiveClass);
  				nextFrame(function () {
  					removeTransitionClass(el, leaveClass);
  					if (!cb.cancelled) {
  						addTransitionClass(el, leaveToClass);
  						if (!userWantsControl) {
  							if (isValidDuration(explicitLeaveDuration)) {
  								setTimeout(cb, explicitLeaveDuration);
  							} else {
  								whenTransitionEnds(el, type, cb);
  							}
  						}
  					}
  				});
  			}
  			leave && leave(el, cb);
  			if (!expectsCSS && !userWantsControl) {
  				cb();
  			}
  		}
  	}
  	
  	// only used in dev mode
  	function checkDuration (val, name, vnode) {
  		if (typeof val !== 'number') {
  			warn(
  				"<transition> explicit " + name + " duration is not a valid number - " +
  				"got " + (JSON.stringify(val)) + ".",
  				vnode.context
  			);
  		} else if (isNaN(val)) {
  			warn(
  				"<transition> explicit " + name + " duration is NaN - " +
  				'the duration expression might be incorrect.',
  				vnode.context
  			);
  		}
  	}
  	
  	function isValidDuration (val) {
  		return typeof val === 'number' && !isNaN(val)
  	}
  	
  	/**
  	 * Normalize a transition hook's argument length. The hook may be:
  	 * - a merged hook (invoker) with the original in .fns
  	 * - a wrapped component method (check ._length)
  	 * - a plain function (.length)
  	 */
  	function getHookArgumentsLength (fn) {
  		if (isUndef(fn)) {
  			return false
  		}
  		var invokerFns = fn.fns;
  		if (isDef(invokerFns)) {
  			// invoker
  			return getHookArgumentsLength(
  				Array.isArray(invokerFns)
  					? invokerFns[0]
  					: invokerFns
  			)
  		} else {
  			return (fn._length || fn.length) > 1
  		}
  	}
  	
  	function _enter (_, vnode) {
  		if (vnode.data.show !== true) {
  			enter(vnode);
  		}
  	}
  	
  	var transition = inBrowser ? {
  		create: _enter,
  		activate: _enter,
  		remove: function remove$$1 (vnode, rm) {
  			/* istanbul ignore else */
  			if (vnode.data.show !== true) {
  				leave(vnode, rm);
  			} else {
  				rm();
  			}
  		}
  	} : {};
  	
  	var platformModules = [
  		attrs,
  		klass,
  		events,
  		domProps,
  		style,
  		transition
  	];
  	
  	/*  */
  	
  	// the directive module should be applied last, after all
  	// built-in modules have been applied.
  	var modules = platformModules.concat(baseModules);
  	
  	var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
  	
  	/**
  	 * Not type checking this file because flow doesn't like attaching
  	 * properties to Elements.
  	 */
  	
  	/* istanbul ignore if */
  	if (isIE9) {
  		// http://www.matts411.com/post/internet-explorer-9-oninput/
  		document.addEventListener('selectionchange', function () {
  			var el = document.activeElement;
  			if (el && el.vmodel) {
  				trigger(el, 'input');
  			}
  		});
  	}
  	
  	var directive = {
  		inserted: function inserted (el, binding, vnode, oldVnode) {
  			if (vnode.tag === 'select') {
  				// #6903
  				if (oldVnode.elm && !oldVnode.elm._vOptions) {
  					mergeVNodeHook(vnode, 'postpatch', function () {
  						directive.componentUpdated(el, binding, vnode);
  					});
  				} else {
  					setSelected(el, binding, vnode.context);
  				}
  				el._vOptions = [].map.call(el.options, getValue);
  			} else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
  				el._vModifiers = binding.modifiers;
  				if (!binding.modifiers.lazy) {
  					el.addEventListener('compositionstart', onCompositionStart);
  					el.addEventListener('compositionend', onCompositionEnd);
  					// Safari < 10.2 & UIWebView doesn't fire compositionend when
  					// switching focus before confirming composition choice
  					// this also fixes the issue where some browsers e.g. iOS Chrome
  					// fires "change" instead of "input" on autocomplete.
  					el.addEventListener('change', onCompositionEnd);
  					/* istanbul ignore if */
  					if (isIE9) {
  						el.vmodel = true;
  					}
  				}
  			}
  		},
  		
  		componentUpdated: function componentUpdated (el, binding, vnode) {
  			if (vnode.tag === 'select') {
  				setSelected(el, binding, vnode.context);
  				// in case the options rendered by v-for have changed,
  				// it's possible that the value is out-of-sync with the rendered options.
  				// detect such cases and filter out values that no longer has a matching
  				// option in the DOM.
  				var prevOptions = el._vOptions;
  				var curOptions = el._vOptions = [].map.call(el.options, getValue);
  				if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
  					// trigger change event if
  					// no matching option found for at least one value
  					var needReset = el.multiple
  						? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
  						: binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);
  					if (needReset) {
  						trigger(el, 'change');
  					}
  				}
  			}
  		}
  	};
  	
  	function setSelected (el, binding, vm) {
  		actuallySetSelected(el, binding, vm);
  		/* istanbul ignore if */
  		if (isIE || isEdge) {
  			setTimeout(function () {
  				actuallySetSelected(el, binding, vm);
  			}, 0);
  		}
  	}
  	
  	function actuallySetSelected (el, binding, vm) {
  		var value = binding.value;
  		var 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
  		}
  		var selected, option;
  		for (var i = 0, l = el.options.length; i < l; i++) {
  			option = el.options[i];
  			if (isMultiple) {
  				selected = looseIndexOf(value, getValue(option)) > -1;
  				if (option.selected !== selected) {
  					option.selected = selected;
  				}
  			} else {
  				if (looseEqual(getValue(option), value)) {
  					if (el.selectedIndex !== i) {
  						el.selectedIndex = i;
  					}
  					return
  				}
  			}
  		}
  		if (!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 = true;
  	}
  	
  	function onCompositionEnd (e) {
  		// prevent triggering an input event for no reason
  		if (!e.target.composing) { return }
  		e.target.composing = false;
  		trigger(e.target, 'input');
  	}
  	
  	function trigger (el, type) {
  		var e = document.createEvent('HTMLEvents');
  		e.initEvent(type, true, true);
  		el.dispatchEvent(e);
  	}
  	
  	/*  */
  	
  	// recursively search for possible transition defined inside the component root
  	function locateNode (vnode) {
  		return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
  			? locateNode(vnode.componentInstance._vnode)
  			: vnode
  	}
  	
  	var show = {
  		bind: function bind (el, ref, vnode) {
  			var value = ref.value;
  			
  			vnode = locateNode(vnode);
  			var transition$$1 = vnode.data && vnode.data.transition;
  			var originalDisplay = el.__vOriginalDisplay =
  				el.style.display === 'none' ? '' : el.style.display;
  			if (value && transition$$1) {
  				vnode.data.show = true;
  				enter(vnode, function () {
  					el.style.display = originalDisplay;
  				});
  			} else {
  				el.style.display = value ? originalDisplay : 'none';
  			}
  		},
  		
  		update: function update (el, ref, vnode) {
  			var value = ref.value;
  			var oldValue = ref.oldValue;
  			
  			/* istanbul ignore if */
  			if (!value === !oldValue) { return }
  			vnode = locateNode(vnode);
  			var transition$$1 = vnode.data && vnode.data.transition;
  			if (transition$$1) {
  				vnode.data.show = true;
  				if (value) {
  					enter(vnode, function () {
  						el.style.display = el.__vOriginalDisplay;
  					});
  				} else {
  					leave(vnode, function () {
  						el.style.display = 'none';
  					});
  				}
  			} else {
  				el.style.display = value ? el.__vOriginalDisplay : 'none';
  			}
  		},
  		
  		unbind: function unbind (
  			el,
  			binding,
  			vnode,
  			oldVnode,
  			isDestroy
  		) {
  			if (!isDestroy) {
  				el.style.display = el.__vOriginalDisplay;
  			}
  		}
  	};
  	
  	var platformDirectives = {
  		model: directive,
  		show: show
  	};
  	
  	/*  */
  	
  	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]
  	};
  	
  	// in case the child is also an abstract component, e.g. <keep-alive>
  	// we want to recursively retrieve the real component to be rendered
  	function getRealChild (vnode) {
  		var compOptions = vnode && vnode.componentOptions;
  		if (compOptions && compOptions.Ctor.options.abstract) {
  			return getRealChild(getFirstComponentChild(compOptions.children))
  		} else {
  			return vnode
  		}
  	}
  	
  	function extractTransitionData (comp) {
  		var data = {};
  		var options = comp.$options;
  		// props
  		for (var key in options.propsData) {
  			data[key] = comp[key];
  		}
  		// events.
  		// extract listeners and pass them directly to the transition methods
  		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
  			})
  		}
  	}
  	
  	function hasParentTransition (vnode) {
  		while ((vnode = vnode.parent)) {
  			if (vnode.data.transition) {
  				return true
  			}
  		}
  	}
  	
  	function isSameChild (child, oldChild) {
  		return oldChild.key === child.key && oldChild.tag === child.tag
  	}
  	
  	var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
  	
  	var isVShowDirective = function (d) { return d.name === 'show'; };
  	
  	var Transition = {
  		name: 'transition',
  		props: transitionProps,
  		abstract: true,
  		
  		render: function render (h) {
  			var this$1 = this;
  			
  			var children = this.$slots.default;
  			if (!children) {
  				return
  			}
  			
  			// filter out text nodes (possible whitespaces)
  			children = children.filter(isNotTextNode);
  			/* istanbul ignore if */
  			if (!children.length) {
  				return
  			}
  			
  			// warn multiple elements
  			if (children.length > 1) {
  				warn(
  					'<transition> can only be used on a single element. Use ' +
  					'<transition-group> for lists.',
  					this.$parent
  				);
  			}
  			
  			var mode = this.mode;
  			
  			// warn invalid mode
  			if (mode && mode !== 'in-out' && mode !== 'out-in'
  			) {
  				warn(
  					'invalid <transition> mode: ' + mode,
  					this.$parent
  				);
  			}
  			
  			var rawChild = children[0];
  			
  			// if this is a component root node and the component's
  			// parent container node also has transition, skip.
  			if (hasParentTransition(this.$vnode)) {
  				return rawChild
  			}
  			
  			// apply transition data to child
  			// use getRealChild() to ignore abstract components e.g. keep-alive
  			var child = getRealChild(rawChild);
  			/* istanbul ignore if */
  			if (!child) {
  				return rawChild
  			}
  			
  			if (this._leaving) {
  				return placeholder(h, rawChild)
  			}
  			
  			// ensure a key that is unique to the vnode type and to this transition
  			// component instance. This key will be used to remove pending leaving nodes
  			// during entering.
  			var id = "__transition-" + (this._uid) + "-";
  			child.key = child.key == null
  				? child.isComment
  					? id + 'comment'
  					: id + child.tag
  				: isPrimitive(child.key)
  					? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
  					: child.key;
  			
  			var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
  			var oldRawChild = this._vnode;
  			var oldChild = getRealChild(oldRawChild);
  			
  			// mark v-show
  			// so that the transition module can hand over the control to the directive
  			if (child.data.directives && child.data.directives.some(isVShowDirective)) {
  				child.data.show = true;
  			}
  			
  			if (
  				oldChild &&
  				oldChild.data &&
  				!isSameChild(child, oldChild) &&
  				!isAsyncPlaceholder(oldChild) &&
  				// #6687 component root is a comment node
  				!(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
  			) {
  				// replace old child transition data with fresh one
  				// important for dynamic transitions!
  				var oldData = oldChild.data.transition = extend({}, data);
  				// handle transition mode
  				if (mode === 'out-in') {
  					// return placeholder node and queue update when leave finishes
  					this._leaving = true;
  					mergeVNodeHook(oldData, 'afterLeave', function () {
  						this$1._leaving = false;
  						this$1.$forceUpdate();
  					});
  					return placeholder(h, rawChild)
  				} else if (mode === 'in-out') {
  					if (isAsyncPlaceholder(child)) {
  						return oldRawChild
  					}
  					var delayedLeave;
  					var performLeave = function () { delayedLeave(); };
  					mergeVNodeHook(data, 'afterEnter', performLeave);
  					mergeVNodeHook(data, 'enterCancelled', performLeave);
  					mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
  				}
  			}
  			
  			return rawChild
  		}
  	};
  	
  	/*  */
  	
  	var props = extend({
  		tag: String,
  		moveClass: String
  	}, transitionProps);
  	
  	delete props.mode;
  	
  	var TransitionGroup = {
  		props: props,
  		
  		beforeMount: function beforeMount () {
  			var this$1 = this;
  			
  			var update = this._update;
  			this._update = function (vnode, hydrating) {
  				var restoreActiveInstance = setActiveInstance(this$1);
  				// force removing pass
  				this$1.__patch__(
  					this$1._vnode,
  					this$1.kept,
  					false, // hydrating
  					true // removeOnly (!important, avoids unnecessary moves)
  				);
  				this$1._vnode = this$1.kept;
  				restoreActiveInstance();
  				update.call(this$1, vnode, hydrating);
  			};
  		},
  		
  		render: function render (h) {
  			var tag = this.tag || this.$vnode.data.tag || 'span';
  			var map = Object.create(null);
  			var prevChildren = this.prevChildren = this.children;
  			var rawChildren = this.$slots.default || [];
  			var children = this.children = [];
  			var transitionData = extractTransitionData(this);
  			
  			for (var i = 0; i < rawChildren.length; i++) {
  				var c = rawChildren[i];
  				if (c.tag) {
  					if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
  						children.push(c);
  						map[c.key] = c
  						;(c.data || (c.data = {})).transition = transitionData;
  					} else {
  						var opts = c.componentOptions;
  						var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;
  						warn(("<transition-group> children must be keyed: <" + name + ">"));
  					}
  				}
  			}
  			
  			if (prevChildren) {
  				var kept = [];
  				var removed = [];
  				for (var 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();
  					if (map[c$1.key]) {
  						kept.push(c$1);
  					} else {
  						removed.push(c$1);
  					}
  				}
  				this.kept = h(tag, null, kept);
  				this.removed = removed;
  			}
  			
  			return h(tag, null, children)
  		},
  		
  		updated: function updated () {
  			var children = this.prevChildren;
  			var moveClass = this.moveClass || ((this.name || 'v') + '-move');
  			if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
  				return
  			}
  			
  			// we divide the work into three loops to avoid mixing DOM reads and writes
  			// in each iteration - which helps prevent layout thrashing.
  			children.forEach(callPendingCbs);
  			children.forEach(recordPosition);
  			children.forEach(applyTranslation);
  			
  			// force reflow to put everything in position
  			// assign to this to avoid being removed in tree-shaking
  			// $flow-disable-line
  			this._reflow = document.body.offsetHeight;
  			
  			children.forEach(function (c) {
  				if (c.data.moved) {
  					var el = c.elm;
  					var s = el.style;
  					addTransitionClass(el, moveClass);
  					s.transform = s.WebkitTransform = s.transitionDuration = '';
  					el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
  						if (e && e.target !== el) {
  							return
  						}
  						if (!e || /transform$/.test(e.propertyName)) {
  							el.removeEventListener(transitionEndEvent, cb);
  							el._moveCb = null;
  							removeTransitionClass(el, moveClass);
  						}
  					});
  				}
  			});
  		},
  		
  		methods: {
  			hasMove: function hasMove (el, moveClass) {
  				/* istanbul ignore if */
  				if (!hasTransition) {
  					return false
  				}
  				/* istanbul ignore if */
  				if (this._hasMove) {
  					return this._hasMove
  				}
  				// Detect whether an element with the move class applied has
  				// CSS transitions. Since the element may be inside an entering
  				// transition at this very moment, we make a clone of it and remove
  				// all other transition classes applied to ensure only the move class
  				// is applied.
  				var clone = el.cloneNode();
  				if (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);
  				this.$el.removeChild(clone);
  				return (this._hasMove = info.hasTransform)
  			}
  		}
  	};
  	
  	function callPendingCbs (c) {
  		/* istanbul ignore if */
  		if (c.elm._moveCb) {
  			c.elm._moveCb();
  		}
  		/* istanbul ignore if */
  		if (c.elm._enterCb) {
  			c.elm._enterCb();
  		}
  	}
  	
  	function recordPosition (c) {
  		c.data.newPos = c.elm.getBoundingClientRect();
  	}
  	
  	function applyTranslation (c) {
  		var oldPos = c.data.pos;
  		var newPos = c.data.newPos;
  		var dx = oldPos.left - newPos.left;
  		var dy = oldPos.top - newPos.top;
  		if (dx || dy) {
  			c.data.moved = true;
  			var s = c.elm.style;
  			s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
  			s.transitionDuration = '0s';
  		}
  	}
  	
  	var platformComponents = {
  		Transition: Transition,
  		TransitionGroup: TransitionGroup
  	};
  	
  	/*  */
  	
  	// install platform specific utils
  	Vue.config.mustUseProp = mustUseProp;
  	Vue.config.isReservedTag = isReservedTag;
  	Vue.config.isReservedAttr = isReservedAttr;
  	Vue.config.getTagNamespace = getTagNamespace;
  	Vue.config.isUnknownElement = isUnknownElement;
  	
  	// install platform runtime directives & components
  	extend(Vue.options.directives, platformDirectives);
  	extend(Vue.options.components, platformComponents);
  	
  	// install platform patch function
  	Vue.prototype.__patch__ = inBrowser ? patch : noop;
  	
  	// public mount method
  	Vue.prototype.$mount = function (
  		el,
  		hydrating
  	) {
  		el = el && inBrowser ? query(el) : undefined;
  		return mountComponent(this, el, hydrating)
  	};
  	
  	// devtools global hook
  	/* istanbul ignore next */
  	if (inBrowser) {
  		setTimeout(function () {
  			if (config.devtools) {
  				if (devtools) {
  					devtools.emit('init', Vue);
  				} else {
  					console[console.info ? 'info' : 'log'](
  						'Download the Vue Devtools extension for a better development experience:\n' +
  						'https://github.com/vuejs/vue-devtools'
  					);
  				}
  			}
  			if (config.productionTip !== false &&
  				typeof console !== 'undefined'
  			) {
  				console[console.info ? 'info' : 'log'](
  					"You are running Vue in development mode.\n" +
  					"Make sure to turn on production mode when deploying for production.\n" +
  					"See more tips at https://vuejs.org/guide/deployment.html"
  				);
  			}
  		}, 0);
  	}
  	
  	/*  */
  	
  	var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
  	var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
  	
  	var buildRegex = cached(function (delimiters) {
  		var open = delimiters[0].replace(regexEscapeRE, '\\$&');
  		var close = delimiters[1].replace(regexEscapeRE, '\\$&');
  		return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
  	});
  	
  	
  	
  	function parseText (
  		text,
  		delimiters
  	) {
  		var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
  		if (!tagRE.test(text)) {
  			return
  		}
  		var tokens = [];
  		var rawTokens = [];
  		var lastIndex = tagRE.lastIndex = 0;
  		var match, index, tokenValue;
  		while ((match = tagRE.exec(text))) {
  			index = match.index;
  			// push text token
  			if (index > lastIndex) {
  				rawTokens.push(tokenValue = text.slice(lastIndex, index));
  				tokens.push(JSON.stringify(tokenValue));
  			}
  			// tag token
  			var exp = parseFilters(match[1].trim());
  			tokens.push(("_s(" + exp + ")"));
  			rawTokens.push({ '@binding': exp });
  			lastIndex = index + match[0].length;
  		}
  		if (lastIndex < text.length) {
  			rawTokens.push(tokenValue = text.slice(lastIndex));
  			tokens.push(JSON.stringify(tokenValue));
  		}
  		return {
  			expression: tokens.join('+'),
  			tokens: rawTokens
  		}
  	}
  	
  	/*  */
  	
  	function transformNode (el, options) {
  		var warn = options.warn || baseWarn;
  		var staticClass = getAndRemoveAttr(el, 'class');
  		if (staticClass) {
  			var res = parseText(staticClass, options.delimiters);
  			if (res) {
  				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']
  				);
  			}
  		}
  		if (staticClass) {
  			el.staticClass = JSON.stringify(staticClass);
  		}
  		var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
  		if (classBinding) {
  			el.classBinding = classBinding;
  		}
  	}
  	
  	function genData (el) {
  		var data = '';
  		if (el.staticClass) {
  			data += "staticClass:" + (el.staticClass) + ",";
  		}
  		if (el.classBinding) {
  			data += "class:" + (el.classBinding) + ",";
  		}
  		return data
  	}
  	
  	var klass$1 = {
  		staticKeys: ['staticClass'],
  		transformNode: transformNode,
  		genData: genData
  	};
  	
  	/*  */
  	
  	function transformNode$1 (el, options) {
  		var warn = options.warn || baseWarn;
  		var staticStyle = getAndRemoveAttr(el, 'style');
  		if (staticStyle) {
  			/* istanbul ignore if */
  			{
  				var res = parseText(staticStyle, options.delimiters);
  				if (res) {
  					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', false /* getStatic */);
  		if (styleBinding) {
  			el.styleBinding = styleBinding;
  		}
  	}
  	
  	function genData$1 (el) {
  		var data = '';
  		if (el.staticStyle) {
  			data += "staticStyle:" + (el.staticStyle) + ",";
  		}
  		if (el.styleBinding) {
  			data += "style:(" + (el.styleBinding) + "),";
  		}
  		return data
  	}
  	
  	var style$1 = {
  		staticKeys: ['staticStyle'],
  		transformNode: transformNode$1,
  		genData: genData$1
  	};
  	
  	/*  */
  	
  	var decoder;
  	
  	var he = {
  		decode: function decode (html) {
  			decoder = decoder || document.createElement('div');
  			decoder.innerHTML = html;
  			return decoder.textContent
  		}
  	};
  	
  	/*  */
  	
  	var isUnaryTag = makeMap(
  		'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
  		'link,meta,param,source,track,wbr'
  	);
  	
  	// Elements that you can, intentionally, leave open
  	// (and which close themselves)
  	var canBeLeftOpenTag = makeMap(
  		'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
  	);
  	
  	// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
  	// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
  	var 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'
  	);
  	
  	/**
  	 * Not type-checking this file because it's mostly vendor code.
  	 */
  		
  		// Regular Expressions for parsing tags and attributes
  	var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
  	var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
  	var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
  	var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
  	var startTagOpen = new RegExp(("^<" + qnameCapture));
  	var startTagClose = /^\s*(\/?)>/;
  	var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
  	var doctype = /^<!DOCTYPE [^>]+>/i;
  	// #7298: escape - to avoid being pased as HTML comment when inlined in page
  	var comment = /^<!\--/;
  	var conditionalComment = /^<!\[/;
  	
  	// Special Elements (can contain anything)
  	var isPlainTextElement = makeMap('script,style,textarea', true);
  	var reCache = {};
  	
  	var decodingMap = {
  		'&lt;': '<',
  		'&gt;': '>',
  		'&quot;': '"',
  		'&amp;': '&',
  		'&#10;': '\n',
  		'&#9;': '\t',
  		'&#39;': "'"
  	};
  	var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
  	var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
  	
  	// #5992
  	var isIgnoreNewlineTag = makeMap('pre,textarea', true);
  	var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
  	
  	function decodeAttr (value, shouldDecodeNewlines) {
  		var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
  		return value.replace(re, function (match) { return decodingMap[match]; })
  	}
  	
  	function parseHTML (html, options) {
  		var stack = [];
  		var expectHTML = options.expectHTML;
  		var isUnaryTag$$1 = options.isUnaryTag || no;
  		var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
  		var index = 0;
  		var last, lastTag;
  		while (html) {
  			last = html;
  			// Make sure we're not in a plaintext content element like script/style
  			if (!lastTag || !isPlainTextElement(lastTag)) {
  				var textEnd = html.indexOf('<');
  				if (textEnd === 0) {
  					// Comment:
  					if (comment.test(html)) {
  						var commentEnd = html.indexOf('-->');
  						
  						if (commentEnd >= 0) {
  							if (options.shouldKeepComment) {
  								options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
  							}
  							advance(commentEnd + 3);
  							continue
  						}
  					}
  					
  					// http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
  					if (conditionalComment.test(html)) {
  						var conditionalEnd = html.indexOf(']>');
  						
  						if (conditionalEnd >= 0) {
  							advance(conditionalEnd + 2);
  							continue
  						}
  					}
  					
  					// Doctype:
  					var doctypeMatch = html.match(doctype);
  					if (doctypeMatch) {
  						advance(doctypeMatch[0].length);
  						continue
  					}
  					
  					// End tag:
  					var endTagMatch = html.match(endTag);
  					if (endTagMatch) {
  						var curIndex = index;
  						advance(endTagMatch[0].length);
  						parseEndTag(endTagMatch[1], curIndex, index);
  						continue
  					}
  					
  					// Start tag:
  					var startTagMatch = parseStartTag();
  					if (startTagMatch) {
  						handleStartTag(startTagMatch);
  						if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
  							advance(1);
  						}
  						continue
  					}
  				}
  				
  				var text = (void 0), rest = (void 0), next = (void 0);
  				if (textEnd >= 0) {
  					rest = html.slice(textEnd);
  					while (
  						!endTag.test(rest) &&
  						!startTagOpen.test(rest) &&
  						!comment.test(rest) &&
  						!conditionalComment.test(rest)
  						) {
  						// < in plain text, be forgiving and treat it as text
  						next = rest.indexOf('<', 1);
  						if (next < 0) { break }
  						textEnd += next;
  						rest = html.slice(textEnd);
  					}
  					text = html.substring(0, textEnd);
  				}
  				
  				if (textEnd < 0) {
  					text = html;
  				}
  				
  				if (text) {
  					advance(text.length);
  				}
  				
  				if (options.chars && text) {
  					options.chars(text, index - text.length, index);
  				}
  			} else {
  				var endTagLength = 0;
  				var stackedTag = lastTag.toLowerCase();
  				var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
  				var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
  					endTagLength = endTag.length;
  					if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
  						text = text
  						.replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
  						.replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
  					}
  					if (shouldIgnoreFirstNewline(stackedTag, text)) {
  						text = text.slice(1);
  					}
  					if (options.chars) {
  						options.chars(text);
  					}
  					return ''
  				});
  				index += html.length - rest$1.length;
  				html = rest$1;
  				parseEndTag(stackedTag, index - endTagLength, index);
  			}
  			
  			if (html === last) {
  				options.chars && options.chars(html);
  				if (!stack.length && options.warn) {
  					options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
  				}
  				break
  			}
  		}
  		
  		// Clean up any remaining tags
  		parseEndTag();
  		
  		function advance (n) {
  			index += n;
  			html = html.substring(n);
  		}
  		
  		function parseStartTag () {
  			var start = html.match(startTagOpen);
  			if (start) {
  				var match = {
  					tagName: start[1],
  					attrs: [],
  					start: index
  				};
  				advance(start[0].length);
  				var end, attr;
  				while (!(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) {
  					match.unarySlash = end[1];
  					advance(end[0].length);
  					match.end = index;
  					return match
  				}
  			}
  		}
  		
  		function handleStartTag (match) {
  			var tagName = match.tagName;
  			var unarySlash = match.unarySlash;
  			
  			if (expectHTML) {
  				if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
  					parseEndTag(lastTag);
  				}
  				if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
  					parseEndTag(tagName);
  				}
  			}
  			
  			var unary = isUnaryTag$$1(tagName) || !!unarySlash;
  			
  			var l = match.attrs.length;
  			var attrs = new Array(l);
  			for (var i = 0; i < l; i++) {
  				var args = match.attrs[i];
  				var value = args[3] || args[4] || args[5] || '';
  				var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
  					? options.shouldDecodeNewlinesForHref
  					: options.shouldDecodeNewlines;
  				attrs[i] = {
  					name: args[1],
  					value: decodeAttr(value, shouldDecodeNewlines)
  				};
  				if (options.outputSourceRange) {
  					attrs[i].start = args.start + args[0].match(/^\s*/).length;
  					attrs[i].end = args.end;
  				}
  			}
  			
  			if (!unary) {
  				stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
  				lastTag = tagName;
  			}
  			
  			if (options.start) {
  				options.start(tagName, attrs, unary, match.start, match.end);
  			}
  		}
  		
  		function parseEndTag (tagName, start, end) {
  			var pos, lowerCasedTagName;
  			if (start == null) { start = index; }
  			if (end == null) { end = index; }
  			
  			// Find the closest opened tag of the same type
  			if (tagName) {
  				lowerCasedTagName = tagName.toLowerCase();
  				for (pos = stack.length - 1; pos >= 0; pos--) {
  					if (stack[pos].lowerCasedTag === lowerCasedTagName) {
  						break
  					}
  				}
  			} else {
  				// If no tag name is provided, clean shop
  				pos = 0;
  			}
  			
  			if (pos >= 0) {
  				// Close all the open elements, up the stack
  				for (var i = stack.length - 1; i >= pos; i--) {
  					if (i > pos || !tagName &&
  						options.warn
  					) {
  						options.warn(
  							("tag <" + (stack[i].tag) + "> has no matching end tag."),
  							{ start: stack[i].start, end: stack[i].end }
  						);
  					}
  					if (options.end) {
  						options.end(stack[i].tag, start, end);
  					}
  				}
  				
  				// Remove the open elements from the stack
  				stack.length = pos;
  				lastTag = pos && stack[pos - 1].tag;
  			} else if (lowerCasedTagName === 'br') {
  				if (options.start) {
  					options.start(tagName, [], true, start, end);
  				}
  			} else if (lowerCasedTagName === 'p') {
  				if (options.start) {
  					options.start(tagName, [], false, start, end);
  				}
  				if (options.end) {
  					options.end(tagName, start, end);
  				}
  			}
  		}
  	}
  	
  	/*  */
  	
  	var onRE = /^@|^v-on:/;
  	var dirRE = /^v-|^@|^:/;
  	var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
  	var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
  	var stripParensRE = /^\(|\)$/g;
  	var dynamicArgRE = /^\[.*\]$/;
  	
  	var argRE = /:(.*)$/;
  	var bindRE = /^:|^\.|^v-bind:/;
  	var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
  	
  	var slotRE = /^v-slot(:|$)|^#/;
  	
  	var lineBreakRE = /[\r\n]/;
  	var whitespaceRE$1 = /\s+/g;
  	
  	var invalidAttributeRE = /[\s"'<>\/=]/;
  	
  	var decodeHTMLCached = cached(he.decode);
  	
  	var emptySlotScopeToken = "_empty_";
  	
  	// configurable state
  	var warn$2;
  	var delimiters;
  	var transforms;
  	var preTransforms;
  	var postTransforms;
  	var platformIsPreTag;
  	var platformMustUseProp;
  	var platformGetTagNamespace;
  	var maybeComponent;
  	
  	function createASTElement (
  		tag,
  		attrs,
  		parent
  	) {
  		return {
  			type: 1,
  			tag: tag,
  			attrsList: attrs,
  			attrsMap: makeAttrsMap(attrs),
  			rawAttrsMap: {},
  			parent: parent,
  			children: []
  		}
  	}
  	
  	/**
  	 * Convert HTML string to AST.
  	 */
  	function parse (
  		template,
  		options
  	) {
  		warn$2 = options.warn || baseWarn;
  		
  		platformIsPreTag = options.isPreTag || no;
  		platformMustUseProp = options.mustUseProp || no;
  		platformGetTagNamespace = options.getTagNamespace || no;
  		var 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 = [];
  		var preserveWhitespace = options.preserveWhitespace !== false;
  		var whitespaceOption = options.whitespace;
  		var root;
  		var currentParent;
  		var inVPre = false;
  		var inPre = false;
  		var warned = false;
  		
  		function warnOnce (msg, range) {
  			if (!warned) {
  				warned = true;
  				warn$2(msg, range);
  			}
  		}
  		
  		function closeElement (element) {
  			trimEndingWhitespace(element);
  			if (!inVPre && !element.processed) {
  				element = processElement(element, options);
  			}
  			// tree management
  			if (!stack.length && element !== root) {
  				// allow root elements with v-if, v-else-if and v-else
  				if (root.if && (element.elseif || element.else)) {
  					{
  						checkRootConstraints(element);
  					}
  					addIfCondition(root, {
  						exp: element.elseif,
  						block: element
  					});
  				} else {
  					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 }
  					);
  				}
  			}
  			if (currentParent && !element.forbidden) {
  				if (element.elseif || element.else) {
  					processIfConditions(element, currentParent);
  				} else {
  					if (element.slotScope) {
  						// scoped slot
  						// keep it in the children list so that v-else(-if) conditions can
  						// find it as the prev node.
  						var name = element.slotTarget || '"default"'
  						;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
  					}
  					currentParent.children.push(element);
  					element.parent = currentParent;
  				}
  			}
  			
  			// final children cleanup
  			// filter out scoped slots
  			element.children = element.children.filter(function (c) { return !(c).slotScope; });
  			// remove trailing whitespace node again
  			trimEndingWhitespace(element);
  			
  			// check pre state
  			if (element.pre) {
  				inVPre = false;
  			}
  			if (platformIsPreTag(element.tag)) {
  				inPre = false;
  			}
  			// apply post-transforms
  			for (var i = 0; i < postTransforms.length; i++) {
  				postTransforms[i](element, options);
  			}
  		}
  		
  		function trimEndingWhitespace (el) {
  			// remove trailing whitespace node
  			if (!inPre) {
  				var lastNode;
  				while (
  					(lastNode = el.children[el.children.length - 1]) &&
  					lastNode.type === 3 &&
  					lastNode.text === ' '
  					) {
  					el.children.pop();
  				}
  			}
  		}
  		
  		function checkRootConstraints (el) {
  			if (el.tag === 'slot' || el.tag === 'template') {
  				warnOnce(
  					"Cannot use <" + (el.tag) + "> as component root element because it may " +
  					'contain multiple nodes.',
  					{ start: el.start }
  				);
  			}
  			if (el.attrsMap.hasOwnProperty('v-for')) {
  				warnOnce(
  					'Cannot use v-for on stateful component root element because ' +
  					'it renders multiple elements.',
  					el.rawAttrsMap['v-for']
  				);
  			}
  		}
  		
  		parseHTML(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 start (tag, attrs, unary, start$1, end) {
  				// check namespace.
  				// inherit parent ns if there is one
  				var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
  				
  				// handle IE svg bug
  				/* istanbul ignore if */
  				if (isIE && ns === 'svg') {
  					attrs = guardIESVGBug(attrs);
  				}
  				
  				var element = createASTElement(tag, attrs, currentParent);
  				if (ns) {
  					element.ns = ns;
  				}
  				
  				{
  					if (options.outputSourceRange) {
  						element.start = start$1;
  						element.end = end;
  						element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
  							cumulated[attr.name] = attr;
  							return cumulated
  						}, {});
  					}
  					attrs.forEach(function (attr) {
  						if (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
  								}
  							);
  						}
  					});
  				}
  				
  				if (isForbiddenTag(element) && !isServerRendering()) {
  					element.forbidden = true;
  					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 }
  					);
  				}
  				
  				// apply pre-transforms
  				for (var i = 0; i < preTransforms.length; i++) {
  					element = preTransforms[i](element, options) || element;
  				}
  				
  				if (!inVPre) {
  					processPre(element);
  					if (element.pre) {
  						inVPre = true;
  					}
  				}
  				if (platformIsPreTag(element.tag)) {
  					inPre = true;
  				}
  				if (inVPre) {
  					processRawAttrs(element);
  				} else if (!element.processed) {
  					// structural directives
  					processFor(element);
  					processIf(element);
  					processOnce(element);
  				}
  				
  				if (!root) {
  					root = element;
  					{
  						checkRootConstraints(root);
  					}
  				}
  				
  				if (!unary) {
  					currentParent = element;
  					stack.push(element);
  				} else {
  					closeElement(element);
  				}
  			},
  			
  			end: function end (tag, start, end$1) {
  				var element = stack[stack.length - 1];
  				// pop stack
  				stack.length -= 1;
  				currentParent = stack[stack.length - 1];
  				if (options.outputSourceRange) {
  					element.end = end$1;
  				}
  				closeElement(element);
  			},
  			
  			chars: function chars (text, start, end) {
  				if (!currentParent) {
  					{
  						if (text === template) {
  							warnOnce(
  								'Component template requires a root element, rather than just text.',
  								{ start: start }
  							);
  						} else if ((text = text.trim())) {
  							warnOnce(
  								("text \"" + text + "\" outside root element will be ignored."),
  								{ start: start }
  							);
  						}
  					}
  					return
  				}
  				// IE textarea placeholder bug
  				/* istanbul ignore if */
  				if (isIE &&
  					currentParent.tag === 'textarea' &&
  					currentParent.attrsMap.placeholder === text
  				) {
  					return
  				}
  				var children = currentParent.children;
  				if (inPre || text.trim()) {
  					text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
  				} else if (!children.length) {
  					// remove the whitespace-only node right after an opening tag
  					text = '';
  				} else if (whitespaceOption) {
  					if (whitespaceOption === 'condense') {
  						// in condense mode, remove the whitespace node if it contains
  						// line break, otherwise condense to a single space
  						text = lineBreakRE.test(text) ? '' : ' ';
  					} else {
  						text = ' ';
  					}
  				} else {
  					text = preserveWhitespace ? ' ' : '';
  				}
  				if (text) {
  					if (!inPre && whitespaceOption === 'condense') {
  						// condense consecutive whitespaces into single space
  						text = text.replace(whitespaceRE$1, ' ');
  					}
  					var res;
  					var child;
  					if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
  						child = {
  							type: 2,
  							expression: res.expression,
  							tokens: res.tokens,
  							text: text
  						};
  					} else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
  						child = {
  							type: 3,
  							text: text
  						};
  					}
  					if (child) {
  						if (options.outputSourceRange) {
  							child.start = start;
  							child.end = end;
  						}
  						children.push(child);
  					}
  				}
  			},
  			comment: function comment (text, start, end) {
  				// adding anyting as a sibling to the root node is forbidden
  				// comments should still be allowed, but ignored
  				if (currentParent) {
  					var child = {
  						type: 3,
  						text: text,
  						isComment: true
  					};
  					if (options.outputSourceRange) {
  						child.start = start;
  						child.end = end;
  					}
  					currentParent.children.push(child);
  				}
  			}
  		});
  		return root
  	}
  	
  	function processPre (el) {
  		if (getAndRemoveAttr(el, 'v-pre') != null) {
  			el.pre = true;
  		}
  	}
  	
  	function processRawAttrs (el) {
  		var list = el.attrsList;
  		var len = list.length;
  		if (len) {
  			var attrs = el.attrs = new Array(len);
  			for (var i = 0; i < len; i++) {
  				attrs[i] = {
  					name: list[i].name,
  					value: JSON.stringify(list[i].value)
  				};
  				if (list[i].start != null) {
  					attrs[i].start = list[i].start;
  					attrs[i].end = list[i].end;
  				}
  			}
  		} else if (!el.pre) {
  			// non root node in pre blocks with no attributes
  			el.plain = true;
  		}
  	}
  	
  	function processElement (
  		element,
  		options
  	) {
  		processKey(element);
  		
  		// determine whether this is a plain element after
  		// removing structural attributes
  		element.plain = (
  			!element.key &&
  			!element.scopedSlots &&
  			!element.attrsList.length
  		);
  		
  		processRef(element);
  		processSlotContent(element);
  		processSlotOutlet(element);
  		processComponent(element);
  		for (var i = 0; i < transforms.length; i++) {
  			element = transforms[i](element, options) || element;
  		}
  		processAttrs(element);
  		return element
  	}
  	
  	function processKey (el) {
  		var exp = getBindingAttr(el, 'key');
  		if (exp) {
  			{
  				if (el.tag === 'template') {
  					warn$2(
  						"<template> cannot be keyed. Place the key on real elements instead.",
  						getRawBindingAttr(el, 'key')
  					);
  				}
  				if (el.for) {
  					var iterator = el.iterator2 || el.iterator1;
  					var parent = el.parent;
  					if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
  						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'),
  							true /* tip */
  						);
  					}
  				}
  			}
  			el.key = exp;
  		}
  	}
  	
  	function processRef (el) {
  		var ref = getBindingAttr(el, 'ref');
  		if (ref) {
  			el.ref = ref;
  			el.refInFor = checkInFor(el);
  		}
  	}
  	
  	function processFor (el) {
  		var exp;
  		if ((exp = getAndRemoveAttr(el, 'v-for'))) {
  			var res = parseFor(exp);
  			if (res) {
  				extend(el, res);
  			} else {
  				warn$2(
  					("Invalid v-for expression: " + exp),
  					el.rawAttrsMap['v-for']
  				);
  			}
  		}
  	}
  	
  	
  	
  	function parseFor (exp) {
  		var inMatch = exp.match(forAliasRE);
  		if (!inMatch) { return }
  		var res = {};
  		res.for = inMatch[2].trim();
  		var alias = inMatch[1].trim().replace(stripParensRE, '');
  		var iteratorMatch = alias.match(forIteratorRE);
  		if (iteratorMatch) {
  			res.alias = alias.replace(forIteratorRE, '').trim();
  			res.iterator1 = iteratorMatch[1].trim();
  			if (iteratorMatch[2]) {
  				res.iterator2 = iteratorMatch[2].trim();
  			}
  		} else {
  			res.alias = alias;
  		}
  		return res
  	}
  	
  	function processIf (el) {
  		var exp = getAndRemoveAttr(el, 'v-if');
  		if (exp) {
  			el.if = exp;
  			addIfCondition(el, {
  				exp: exp,
  				block: el
  			});
  		} else {
  			if (getAndRemoveAttr(el, 'v-else') != null) {
  				el.else = true;
  			}
  			var elseif = getAndRemoveAttr(el, 'v-else-if');
  			if (elseif) {
  				el.elseif = elseif;
  			}
  		}
  	}
  	
  	function processIfConditions (el, parent) {
  		var prev = findPrevElement(parent.children);
  		if (prev && prev.if) {
  			addIfCondition(prev, {
  				exp: el.elseif,
  				block: el
  			});
  		} else {
  			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']
  			);
  		}
  	}
  	
  	function findPrevElement (children) {
  		var i = children.length;
  		while (i--) {
  			if (children[i].type === 1) {
  				return children[i]
  			} else {
  				if (children[i].text !== ' ') {
  					warn$2(
  						"text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
  						"will be ignored.",
  						children[i]
  					);
  				}
  				children.pop();
  			}
  		}
  	}
  	
  	function addIfCondition (el, condition) {
  		if (!el.ifConditions) {
  			el.ifConditions = [];
  		}
  		el.ifConditions.push(condition);
  	}
  	
  	function processOnce (el) {
  		var once$$1 = getAndRemoveAttr(el, 'v-once');
  		if (once$$1 != null) {
  			el.once = true;
  		}
  	}
  	
  	// handle content being passed to a component as slot,
  	// e.g. <template slot="xxx">, <div slot-scope="xxx">
  	function processSlotContent (el) {
  		var slotScope;
  		if (el.tag === 'template') {
  			slotScope = getAndRemoveAttr(el, 'scope');
  			/* istanbul ignore if */
  			if (slotScope) {
  				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'],
  					true
  				);
  			}
  			el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
  		} else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
  			/* istanbul ignore if */
  			if (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'],
  					true
  				);
  			}
  			el.slotScope = slotScope;
  		}
  		
  		// slot="xxx"
  		var slotTarget = getBindingAttr(el, 'slot');
  		if (slotTarget) {
  			el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
  			el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
  			// preserve slot as an attribute for native shadow DOM compat
  			// only for non-scoped slots.
  			if (el.tag !== 'template' && !el.slotScope) {
  				addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
  			}
  		}
  		
  		// 2.6 v-slot syntax
  		{
  			if (el.tag === 'template') {
  				// v-slot on <template>
  				var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
  				if (slotBinding) {
  					{
  						if (el.slotTarget || el.slotScope) {
  							warn$2(
  								"Unexpected mixed usage of different slot syntaxes.",
  								el
  							);
  						}
  						if (el.parent && !maybeComponent(el.parent)) {
  							warn$2(
  								"<template v-slot> can only appear at the root level inside " +
  								"the receiving the component",
  								el
  							);
  						}
  					}
  					var ref = getSlotName(slotBinding);
  					var name = ref.name;
  					var dynamic = ref.dynamic;
  					el.slotTarget = name;
  					el.slotTargetDynamic = dynamic;
  					el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
  				}
  			} else {
  				// v-slot on component, denotes default slot
  				var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
  				if (slotBinding$1) {
  					{
  						if (!maybeComponent(el)) {
  							warn$2(
  								"v-slot can only be used on components or <template>.",
  								slotBinding$1
  							);
  						}
  						if (el.slotScope || el.slotTarget) {
  							warn$2(
  								"Unexpected mixed usage of different slot syntaxes.",
  								el
  							);
  						}
  						if (el.scopedSlots) {
  							warn$2(
  								"To avoid scope ambiguity, the default slot should also use " +
  								"<template> syntax when there are other named slots.",
  								slotBinding$1
  							);
  						}
  					}
  					// add the component's children to its default slot
  					var slots = el.scopedSlots || (el.scopedSlots = {});
  					var ref$1 = getSlotName(slotBinding$1);
  					var name$1 = ref$1.name;
  					var dynamic$1 = ref$1.dynamic;
  					var 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) {
  							c.parent = slotContainer;
  							return true
  						}
  					});
  					slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
  					// remove children as they are returned from scopedSlots now
  					el.children = [];
  					// mark el non-plain so data gets generated
  					el.plain = false;
  				}
  			}
  		}
  	}
  	
  	function getSlotName (binding) {
  		var name = binding.name.replace(slotRE, '');
  		if (!name) {
  			if (binding.name[0] !== '#') {
  				name = 'default';
  			} else {
  				warn$2(
  					"v-slot shorthand syntax requires a slot name.",
  					binding
  				);
  			}
  		}
  		return dynamicArgRE.test(name)
  			// dynamic [name]
  			? { name: name.slice(1, -1), dynamic: true }
  			// static name
  			: { name: ("\"" + name + "\""), dynamic: false }
  	}
  	
  	// handle <slot/> outlets
  	function processSlotOutlet (el) {
  		if (el.tag === 'slot') {
  			el.slotName = getBindingAttr(el, 'name');
  			if (el.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(el, 'key')
  				);
  			}
  		}
  	}
  	
  	function processComponent (el) {
  		var binding;
  		if ((binding = getBindingAttr(el, 'is'))) {
  			el.component = binding;
  		}
  		if (getAndRemoveAttr(el, 'inline-template') != null) {
  			el.inlineTemplate = true;
  		}
  	}
  	
  	function processAttrs (el) {
  		var list = el.attrsList;
  		var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
  		for (i = 0, l = list.length; i < l; i++) {
  			name = rawName = list[i].name;
  			value = list[i].value;
  			if (dirRE.test(name)) {
  				// mark element as dynamic
  				el.hasBindings = true;
  				// modifiers
  				modifiers = parseModifiers(name.replace(dirRE, ''));
  				// support .foo shorthand syntax for the .prop modifier
  				if (modifiers) {
  					name = name.replace(modifierRE, '');
  				}
  				if (bindRE.test(name)) { // v-bind
  					name = name.replace(bindRE, '');
  					value = parseFilters(value);
  					isDynamic = dynamicArgRE.test(name);
  					if (isDynamic) {
  						name = name.slice(1, -1);
  					}
  					if (
  						value.trim().length === 0
  					) {
  						warn$2(
  							("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
  						);
  					}
  					if (modifiers) {
  						if (modifiers.prop && !isDynamic) {
  							name = camelize(name);
  							if (name === 'innerHtml') { name = 'innerHTML'; }
  						}
  						if (modifiers.camel && !isDynamic) {
  							name = camelize(name);
  						}
  						if (modifiers.sync) {
  							syncGen = genAssignmentCode(value, "$event");
  							if (!isDynamic) {
  								addHandler(
  									el,
  									("update:" + (camelize(name))),
  									syncGen,
  									null,
  									false,
  									warn$2,
  									list[i]
  								);
  								if (hyphenate(name) !== camelize(name)) {
  									addHandler(
  										el,
  										("update:" + (hyphenate(name))),
  										syncGen,
  										null,
  										false,
  										warn$2,
  										list[i]
  									);
  								}
  							} else {
  								// handler w/ dynamic event name
  								addHandler(
  									el,
  									("\"update:\"+(" + name + ")"),
  									syncGen,
  									null,
  									false,
  									warn$2,
  									list[i],
  									true // dynamic
  								);
  							}
  						}
  					}
  					if ((modifiers && modifiers.prop) || (
  						!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
  					)) {
  						addProp(el, name, value, list[i], isDynamic);
  					} else {
  						addAttr(el, name, value, list[i], isDynamic);
  					}
  				} else if (onRE.test(name)) { // v-on
  					name = name.replace(onRE, '');
  					isDynamic = dynamicArgRE.test(name);
  					if (isDynamic) {
  						name = name.slice(1, -1);
  					}
  					addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
  				} else { // normal directives
  					name = name.replace(dirRE, '');
  					// parse arg
  					var argMatch = name.match(argRE);
  					var arg = argMatch && argMatch[1];
  					isDynamic = false;
  					if (arg) {
  						name = name.slice(0, -(arg.length + 1));
  						if (dynamicArgRE.test(arg)) {
  							arg = arg.slice(1, -1);
  							isDynamic = true;
  						}
  					}
  					addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
  					if (name === 'model') {
  						checkForAliasModel(el, value);
  					}
  				}
  			} else {
  				// literal attribute
  				{
  					var res = parseText(value, delimiters);
  					if (res) {
  						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]);
  				// #6887 firefox doesn't update muted state if set via attribute
  				// even immediately after element creation
  				if (!el.component &&
  					name === 'muted' &&
  					platformMustUseProp(el.tag, el.attrsMap.type, name)) {
  					addProp(el, name, 'true', list[i]);
  				}
  			}
  		}
  	}
  	
  	function checkInFor (el) {
  		var parent = el;
  		while (parent) {
  			if (parent.for !== undefined) {
  				return true
  			}
  			parent = parent.parent;
  		}
  		return false
  	}
  	
  	function parseModifiers (name) {
  		var match = name.match(modifierRE);
  		if (match) {
  			var ret = {};
  			match.forEach(function (m) { ret[m.slice(1)] = true; });
  			return ret
  		}
  	}
  	
  	function makeAttrsMap (attrs) {
  		var map = {};
  		for (var i = 0, l = attrs.length; i < l; i++) {
  			if (
  				map[attrs[i].name] && !isIE && !isEdge
  			) {
  				warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
  			}
  			map[attrs[i].name] = attrs[i].value;
  		}
  		return map
  	}
  	
  	// for script (e.g. type="x/template") or style, do not decode content
  	function isTextTag (el) {
  		return el.tag === 'script' || el.tag === 'style'
  	}
  	
  	function isForbiddenTag (el) {
  		return (
  			el.tag === 'style' ||
  			(el.tag === 'script' && (
  				!el.attrsMap.type ||
  				el.attrsMap.type === 'text/javascript'
  			))
  		)
  	}
  	
  	var ieNSBug = /^xmlns:NS\d+/;
  	var ieNSPrefix = /^NS\d+:/;
  	
  	/* istanbul ignore next */
  	function guardIESVGBug (attrs) {
  		var res = [];
  		for (var i = 0; i < attrs.length; i++) {
  			var attr = attrs[i];
  			if (!ieNSBug.test(attr.name)) {
  				attr.name = attr.name.replace(ieNSPrefix, '');
  				res.push(attr);
  			}
  		}
  		return res
  	}
  	
  	function checkForAliasModel (el, value) {
  		var _el = el;
  		while (_el) {
  			if (_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;
  		}
  	}
  	
  	/*  */
  	
  	function preTransformNode (el, options) {
  		if (el.tag === 'input') {
  			var map = el.attrsMap;
  			if (!map['v-model']) {
  				return
  			}
  			
  			var typeBinding;
  			if (map[':type'] || map['v-bind:type']) {
  				typeBinding = getBindingAttr(el, 'type');
  			}
  			if (!map.type && !typeBinding && map['v-bind']) {
  				typeBinding = "(" + (map['v-bind']) + ").type";
  			}
  			
  			if (typeBinding) {
  				var ifCondition = getAndRemoveAttr(el, 'v-if', true);
  				var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
  				var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
  				var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
  				// 1. checkbox
  				var branch0 = cloneASTElement(el);
  				// process for on the main node
  				processFor(branch0);
  				addRawAttr(branch0, 'type', 'checkbox');
  				processElement(branch0, options);
  				branch0.processed = true; // prevent it from double-processed
  				branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
  				addIfCondition(branch0, {
  					exp: branch0.if,
  					block: branch0
  				});
  				// 2. add radio else-if condition
  				var branch1 = cloneASTElement(el);
  				getAndRemoveAttr(branch1, 'v-for', true);
  				addRawAttr(branch1, 'type', 'radio');
  				processElement(branch1, options);
  				addIfCondition(branch0, {
  					exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
  					block: branch1
  				});
  				// 3. other
  				var branch2 = cloneASTElement(el);
  				getAndRemoveAttr(branch2, 'v-for', true);
  				addRawAttr(branch2, ':type', typeBinding);
  				processElement(branch2, options);
  				addIfCondition(branch0, {
  					exp: ifCondition,
  					block: branch2
  				});
  				
  				if (hasElse) {
  					branch0.else = true;
  				} else if (elseIfCondition) {
  					branch0.elseif = elseIfCondition;
  				}
  				
  				return branch0
  			}
  		}
  	}
  	
  	function cloneASTElement (el) {
  		return createASTElement(el.tag, el.attrsList.slice(), el.parent)
  	}
  	
  	var model$1 = {
  		preTransformNode: preTransformNode
  	};
  	
  	var modules$1 = [
  		klass$1,
  		style$1,
  		model$1
  	];
  	
  	/*  */
  	
  	function text (el, dir) {
  		if (dir.value) {
  			addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
  		}
  	}
  	
  	/*  */
  	
  	function html (el, dir) {
  		if (dir.value) {
  			addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
  		}
  	}
  	
  	var directives$1 = {
  		model: model,
  		text: text,
  		html: html
  	};
  	
  	/*  */
  	
  	var baseOptions = {
  		expectHTML: true,
  		modules: modules$1,
  		directives: directives$1,
  		isPreTag: isPreTag,
  		isUnaryTag: isUnaryTag,
  		mustUseProp: mustUseProp,
  		canBeLeftOpenTag: canBeLeftOpenTag,
  		isReservedTag: isReservedTag,
  		getTagNamespace: getTagNamespace,
  		staticKeys: genStaticKeys(modules$1)
  	};
  	
  	/*  */
  	
  	var isStaticKey;
  	var isPlatformReservedTag;
  	
  	var genStaticKeysCached = cached(genStaticKeys$1);
  	
  	/**
  	 * Goal of the optimizer: walk the generated template AST tree
  	 * and detect sub-trees that are purely static, i.e. parts of
  	 * the DOM that never needs to change.
  	 *
  	 * Once we detect these sub-trees, we can:
  	 *
  	 * 1. Hoist them into constants, so that we no longer need to
  	 *    create fresh nodes for them on each re-render;
  	 * 2. Completely skip them in the patching process.
  	 */
  	function optimize (root, options) {
  		if (!root) { return }
  		isStaticKey = genStaticKeysCached(options.staticKeys || '');
  		isPlatformReservedTag = options.isReservedTag || no;
  		// first pass: mark all non-static nodes.
  		markStatic$1(root);
  		// second pass: mark static roots.
  		markStaticRoots(root, false);
  	}
  	
  	function genStaticKeys$1 (keys) {
  		return makeMap(
  			'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
  			(keys ? ',' + keys : '')
  		)
  	}
  	
  	function markStatic$1 (node) {
  		node.static = isStatic(node);
  		if (node.type === 1) {
  			// do not make component slot content static. this avoids
  			// 1. components not able to mutate slot nodes
  			// 2. static slot content fails for hot-reloading
  			if (
  				!isPlatformReservedTag(node.tag) &&
  				node.tag !== 'slot' &&
  				node.attrsMap['inline-template'] == null
  			) {
  				return
  			}
  			for (var i = 0, l = node.children.length; i < l; i++) {
  				var child = node.children[i];
  				markStatic$1(child);
  				if (!child.static) {
  					node.static = false;
  				}
  			}
  			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);
  					if (!block.static) {
  						node.static = false;
  					}
  				}
  			}
  		}
  	}
  	
  	function markStaticRoots (node, isInFor) {
  		if (node.type === 1) {
  			if (node.static || node.once) {
  				node.staticInFor = isInFor;
  			}
  			// For a node to qualify as a static root, it should have children that
  			// are not just static text. Otherwise the cost of hoisting out will
  			// outweigh the benefits and it's better off to just always render it fresh.
  			if (node.static && node.children.length && !(
  				node.children.length === 1 &&
  				node.children[0].type === 3
  			)) {
  				node.staticRoot = true;
  				return
  			} else {
  				node.staticRoot = false;
  			}
  			if (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);
  				}
  			}
  		}
  	}
  	
  	function isStatic (node) {
  		if (node.type === 2) { // expression
  			return false
  		}
  		if (node.type === 3) { // text
  			return true
  		}
  		return !!(node.pre || (
  			!node.hasBindings && // no dynamic bindings
  			!node.if && !node.for && // not v-if or v-for or v-else
  			!isBuiltInTag(node.tag) && // not a built-in
  			isPlatformReservedTag(node.tag) && // not a component
  			!isDirectChildOfTemplateFor(node) &&
  			Object.keys(node).every(isStaticKey)
  		))
  	}
  	
  	function isDirectChildOfTemplateFor (node) {
  		while (node.parent) {
  			node = node.parent;
  			if (node.tag !== 'template') {
  				return false
  			}
  			if (node.for) {
  				return true
  			}
  		}
  		return false
  	}
  	
  	/*  */
  	
  	var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function\s*(?:[\w$]+)?\s*\(/;
  	var fnInvokeRE = /\([^)]*?\);*$/;
  	var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
  	
  	// KeyboardEvent.keyCode aliases
  	var keyCodes = {
  		esc: 27,
  		tab: 9,
  		enter: 13,
  		space: 32,
  		up: 38,
  		left: 37,
  		right: 39,
  		down: 40,
  		'delete': [8, 46]
  	};
  	
  	// KeyboardEvent.key aliases
  	var keyNames = {
  		// #7880: IE11 and Edge use `Esc` for Escape key name.
  		esc: ['Esc', 'Escape'],
  		tab: 'Tab',
  		enter: 'Enter',
  		// #9112: IE11 uses `Spacebar` for Space key name.
  		space: [' ', 'Spacebar'],
  		// #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
  		up: ['Up', 'ArrowUp'],
  		left: ['Left', 'ArrowLeft'],
  		right: ['Right', 'ArrowRight'],
  		down: ['Down', 'ArrowDown'],
  		// #9112: IE11 uses `Del` for Delete key name.
  		'delete': ['Backspace', 'Delete', 'Del']
  	};
  	
  	// #4868: modifiers that prevent the execution of the listener
  	// need to explicitly return null so that we can determine whether to remove
  	// the listener for .once
  	var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
  	
  	var 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:';
  		var staticHandlers = "";
  		var dynamicHandlers = "";
  		for (var name in events) {
  			var handlerCode = genHandler(events[name]);
  			if (events[name] && events[name].dynamic) {
  				dynamicHandlers += name + "," + handlerCode + ",";
  			} else {
  				staticHandlers += "\"" + name + "\":" + handlerCode + ",";
  			}
  		}
  		staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
  		if (dynamicHandlers) {
  			return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
  		} else {
  			return prefix + staticHandlers
  		}
  	}
  	
  	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);
  		var isFunctionExpression = fnExpRE.test(handler.value);
  		var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
  		
  		if (!handler.modifiers) {
  			if (isMethodPath || isFunctionExpression) {
  				return handler.value
  			}
  			return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
  		} else {
  			var code = '';
  			var genModifierCode = '';
  			var keys = [];
  			for (var key in handler.modifiers) {
  				if (modifierCode[key]) {
  					genModifierCode += modifierCode[key];
  					// left/right
  					if (keyCodes[key]) {
  						keys.push(key);
  					}
  				} else if (key === 'exact') {
  					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);
  				}
  			}
  			if (keys.length) {
  				code += genKeyFilter(keys);
  			}
  			// Make sure modifiers like prevent and stop get executed after key filtering
  			if (genModifierCode) {
  				code += genModifierCode;
  			}
  			var handlerCode = isMethodPath
  				? ("return " + (handler.value) + "($event)")
  				: isFunctionExpression
  					? ("return (" + (handler.value) + ")($event)")
  					: isFunctionInvocation
  						? ("return " + (handler.value))
  						: handler.value;
  			return ("function($event){" + code + handlerCode + "}")
  		}
  	}
  	
  	function genKeyFilter (keys) {
  		return (
  			// make sure the key filters only apply to KeyboardEvents
  			// #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
  			// key events that do not have keyCode property...
  			"if(!$event.type.indexOf('key')&&" +
  			(keys.map(genFilterCode).join('&&')) + ")return null;"
  		)
  	}
  	
  	function genFilterCode (key) {
  		var keyVal = parseInt(key, 10);
  		if (keyVal) {
  			return ("$event.keyCode!==" + keyVal)
  		}
  		var keyCode = keyCodes[key];
  		var keyName = keyNames[key];
  		return (
  			"_k($event.keyCode," +
  			(JSON.stringify(key)) + "," +
  			(JSON.stringify(keyCode)) + "," +
  			"$event.key," +
  			"" + (JSON.stringify(keyName)) +
  			")"
  		)
  	}
  	
  	/*  */
  	
  	function on (el, dir) {
  		if (dir.modifiers) {
  			warn("v-on without argument does not support modifiers.");
  		}
  		el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
  	}
  	
  	/*  */
  	
  	function bind$1 (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' : '') + ")")
  		};
  	}
  	
  	/*  */
  	
  	var baseDirectives = {
  		on: on,
  		bind: bind$1,
  		cloak: noop
  	};
  	
  	/*  */
  	
  	
  	
  	
  	
  	var CodegenState = function CodegenState (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 = false;
  	};
  	
  	
  	
  	function generate (
  		ast,
  		options
  	) {
  		var state = new CodegenState(options);
  		var code = ast ? genElement(ast, state) : '_c("div")';
  		return {
  			render: ("with(this){return " + code + "}"),
  			staticRenderFns: state.staticRenderFns
  		}
  	}
  	
  	function genElement (el, state) {
  		if (el.parent) {
  			el.pre = el.pre || el.parent.pre;
  		}
  		
  		if (el.staticRoot && !el.staticProcessed) {
  			return genStatic(el, state)
  		} else if (el.once && !el.onceProcessed) {
  			return genOnce(el, state)
  		} else if (el.for && !el.forProcessed) {
  			return genFor(el, state)
  		} else if (el.if && !el.ifProcessed) {
  			return genIf(el, state)
  		} else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
  			return genChildren(el, state) || 'void 0'
  		} else if (el.tag === 'slot') {
  			return genSlot(el, state)
  		} else {
  			// component or element
  			var code;
  			if (el.component) {
  				code = genComponent(el.component, el, state);
  			} else {
  				var data;
  				if (!el.plain || (el.pre && state.maybeComponent(el))) {
  					data = genData$2(el, state);
  				}
  				
  				var children = el.inlineTemplate ? null : genChildren(el, state, true);
  				code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
  			}
  			// module transforms
  			for (var i = 0; i < state.transforms.length; i++) {
  				code = state.transforms[i](el, code);
  			}
  			return code
  		}
  	}
  	
  	// hoist static sub-trees out
  	function genStatic (el, state) {
  		el.staticProcessed = true;
  		// Some elements (templates) need to behave differently inside of a v-pre
  		// node.  All pre nodes are static roots, so we can use this as a location to
  		// wrap a state change and reset it upon exiting the pre node.
  		var originalPreState = state.pre;
  		if (el.pre) {
  			state.pre = el.pre;
  		}
  		state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
  		state.pre = originalPreState;
  		return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
  	}
  	
  	// v-once
  	function genOnce (el, state) {
  		el.onceProcessed = true;
  		if (el.if && !el.ifProcessed) {
  			return genIf(el, state)
  		} else if (el.staticInFor) {
  			var key = '';
  			var parent = el.parent;
  			while (parent) {
  				if (parent.for) {
  					key = parent.key;
  					break
  				}
  				parent = parent.parent;
  			}
  			if (!key) {
  				state.warn(
  					"v-once can only be used inside v-for that is keyed. ",
  					el.rawAttrsMap['v-once']
  				);
  				return genElement(el, state)
  			}
  			return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
  		} else {
  			return genStatic(el, state)
  		}
  	}
  	
  	function genIf (
  		el,
  		state,
  		altGen,
  		altEmpty
  	) {
  		el.ifProcessed = true; // avoid recursion
  		return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
  	}
  	
  	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)))
  		} else {
  			return ("" + (genTernaryExp(condition.block)))
  		}
  		
  		// v-if with v-once should generate code like (a)?_m(0):_m(1)
  		function genTernaryExp (el) {
  			return altGen
  				? altGen(el, state)
  				: el.once
  					? genOnce(el, state)
  					: genElement(el, state)
  		}
  	}
  	
  	function genFor (
  		el,
  		state,
  		altGen,
  		altHelper
  	) {
  		var exp = el.for;
  		var alias = el.alias;
  		var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
  		var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
  		
  		if (state.maybeComponent(el) &&
  			el.tag !== 'slot' &&
  			el.tag !== 'template' &&
  			!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'],
  				true /* tip */
  			);
  		}
  		
  		el.forProcessed = true; // avoid recursion
  		return (altHelper || '_l') + "((" + exp + ")," +
  			"function(" + alias + iterator1 + iterator2 + "){" +
  			"return " + ((altGen || genElement)(el, state)) +
  			'})'
  	}
  	
  	function genData$2 (el, state) {
  		var data = '{';
  		
  		// directives first.
  		// directives may mutate the el's other properties before they are generated.
  		var dirs = genDirectives(el, state);
  		if (dirs) { data += dirs + ','; }
  		
  		// key
  		if (el.key) {
  			data += "key:" + (el.key) + ",";
  		}
  		// ref
  		if (el.ref) {
  			data += "ref:" + (el.ref) + ",";
  		}
  		if (el.refInFor) {
  			data += "refInFor:true,";
  		}
  		// pre
  		if (el.pre) {
  			data += "pre:true,";
  		}
  		// record original tag name for components using "is" attribute
  		if (el.component) {
  			data += "tag:\"" + (el.tag) + "\",";
  		}
  		// module data generation functions
  		for (var i = 0; i < state.dataGenFns.length; i++) {
  			data += state.dataGenFns[i](el);
  		}
  		// attributes
  		if (el.attrs) {
  			data += "attrs:" + (genProps(el.attrs)) + ",";
  		}
  		// DOM props
  		if (el.props) {
  			data += "domProps:" + (genProps(el.props)) + ",";
  		}
  		// event handlers
  		if (el.events) {
  			data += (genHandlers(el.events, false)) + ",";
  		}
  		if (el.nativeEvents) {
  			data += (genHandlers(el.nativeEvents, true)) + ",";
  		}
  		// slot target
  		// only for non-scoped slots
  		if (el.slotTarget && !el.slotScope) {
  			data += "slot:" + (el.slotTarget) + ",";
  		}
  		// scoped slots
  		if (el.scopedSlots) {
  			data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
  		}
  		// component v-model
  		if (el.model) {
  			data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
  		}
  		// inline-template
  		if (el.inlineTemplate) {
  			var inlineTemplate = genInlineTemplate(el, state);
  			if (inlineTemplate) {
  				data += inlineTemplate + ",";
  			}
  		}
  		data = data.replace(/,$/, '') + '}';
  		// v-bind dynamic argument wrap
  		// v-bind with dynamic arguments must be applied using the same v-bind object
  		// merge helper so that class/style/mustUseProp attrs are handled correctly.
  		if (el.dynamicAttrs) {
  			data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
  		}
  		// v-bind data wrap
  		if (el.wrapData) {
  			data = el.wrapData(data);
  		}
  		// v-on data wrap
  		if (el.wrapListeners) {
  			data = el.wrapListeners(data);
  		}
  		return data
  	}
  	
  	function genDirectives (el, state) {
  		var dirs = el.directives;
  		if (!dirs) { return }
  		var res = 'directives:[';
  		var hasRuntime = false;
  		var i, l, dir, needRuntime;
  		for (i = 0, l = dirs.length; i < l; i++) {
  			dir = dirs[i];
  			needRuntime = true;
  			var gen = state.directives[dir.name];
  			if (gen) {
  				// compile-time directive that manipulates AST.
  				// returns true if it also needs a runtime counterpart.
  				needRuntime = !!gen(el, dir, state.warn);
  			}
  			if (needRuntime) {
  				hasRuntime = true;
  				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) + ']'
  		}
  	}
  	
  	function genInlineTemplate (el, state) {
  		var ast = el.children[0];
  		if (el.children.length !== 1 || ast.type !== 1) {
  			state.warn(
  				'Inline-template components must have exactly one child element.',
  				{ start: el.start }
  			);
  		}
  		if (ast && ast.type === 1) {
  			var inlineRenderFns = generate(ast, state.options);
  			return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
  		}
  	}
  	
  	function genScopedSlots (
  		el,
  		slots,
  		state
  	) {
  		// by default scoped slots are considered "stable", this allows child
  		// components with only scoped slots to skip forced updates from parent.
  		// but in some cases we have to bail-out of this optimization
  		// for example if the slot contains dynamic names, has v-if or v-for on them...
  		var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
  			var slot = slots[key];
  			return (
  				slot.slotTargetDynamic ||
  				slot.if ||
  				slot.for ||
  				containsSlotChild(slot) // is passing down slot from parent which may be dynamic
  			)
  		});
  		
  		// #9534: if a component with scoped slots is inside a conditional branch,
  		// it's possible for the same component to be reused but with different
  		// compiled slot content. To avoid that, we generate a unique key based on
  		// the generated code of all the slot contents.
  		var needsKey = !!el.if;
  		
  		// OR when it is inside another scoped slot or v-for (the reactivity may be
  		// disconnected due to the intermediate scope variable)
  		// #9438, #9506
  		// TODO: this can be further optimized by properly analyzing in-scope bindings
  		// and skip force updating ones that do not actually use scope variables.
  		if (!needsForceUpdate) {
  			var parent = el.parent;
  			while (parent) {
  				if (
  					(parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
  					parent.for
  				) {
  					needsForceUpdate = true;
  					break
  				}
  				if (parent.if) {
  					needsKey = true;
  				}
  				parent = parent.parent;
  			}
  		}
  		
  		var generatedSlots = Object.keys(slots)
  		.map(function (key) { return genScopedSlot(slots[key], state); })
  		.join(',');
  		
  		return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
  	}
  	
  	function hash(str) {
  		var hash = 5381;
  		var i = str.length;
  		while(i) {
  			hash = (hash * 33) ^ str.charCodeAt(--i);
  		}
  		return hash >>> 0
  	}
  	
  	function containsSlotChild (el) {
  		if (el.type === 1) {
  			if (el.tag === 'slot') {
  				return true
  			}
  			return el.children.some(containsSlotChild)
  		}
  		return false
  	}
  	
  	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);
  		var fn = "function(" + slotScope + "){" +
  			"return " + (el.tag === 'template'
  				? el.if && isLegacySyntax
  					? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
  					: genChildren(el, state) || 'undefined'
  				: genElement(el, state)) + "}";
  		// reverse proxy v-slot without scope on this.$slots
  		var reverseProxy = slotScope ? "" : ",proxy:true";
  		return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
  	}
  	
  	function genChildren (
  		el,
  		state,
  		checkSkip,
  		altGenElement,
  		altGenNode
  	) {
  		var children = el.children;
  		if (children.length) {
  			var el$1 = children[0];
  			// optimize single v-for
  			if (children.length === 1 &&
  				el$1.for &&
  				el$1.tag !== 'template' &&
  				el$1.tag !== 'slot'
  			) {
  				var normalizationType = checkSkip
  					? state.maybeComponent(el$1) ? ",1" : ",0"
  					: "";
  				return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
  			}
  			var normalizationType$1 = checkSkip
  				? getNormalizationType(children, state.maybeComponent)
  				: 0;
  			var gen = altGenNode || genNode;
  			return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
  		}
  	}
  	
  	// determine the normalization needed for the children array.
  	// 0: no normalization needed
  	// 1: simple normalization needed (possible 1-level deep nested array)
  	// 2: full normalization needed
  	function getNormalizationType (
  		children,
  		maybeComponent
  	) {
  		var res = 0;
  		for (var i = 0; i < children.length; i++) {
  			var el = children[i];
  			if (el.type !== 1) {
  				continue
  			}
  			if (needsNormalization(el) ||
  				(el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
  				res = 2;
  				break
  			}
  			if (maybeComponent(el) ||
  				(el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
  				res = 1;
  			}
  		}
  		return res
  	}
  	
  	function needsNormalization (el) {
  		return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
  	}
  	
  	function genNode (node, state) {
  		if (node.type === 1) {
  			return genElement(node, state)
  		} else if (node.type === 3 && node.isComment) {
  			return genComment(node)
  		} else {
  			return genText(node)
  		}
  	}
  	
  	function genText (text) {
  		return ("_v(" + (text.type === 2
  			? text.expression // no need for () because already wrapped in _s()
  			: transformSpecialNewlines(JSON.stringify(text.text))) + ")")
  	}
  	
  	function genComment (comment) {
  		return ("_e(" + (JSON.stringify(comment.text)) + ")")
  	}
  	
  	function genSlot (el, state) {
  		var slotName = el.slotName || '"default"';
  		var children = genChildren(el, state);
  		var res = "_t(" + slotName + (children ? ("," + children) : '');
  		var attrs = el.attrs || el.dynamicAttrs
  			? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
  				// slot props are camelized
  				name: camelize(attr.name),
  				value: attr.value,
  				dynamic: attr.dynamic
  			}); }))
  			: null;
  		var bind$$1 = el.attrsMap['v-bind'];
  		if ((attrs || bind$$1) && !children) {
  			res += ",null";
  		}
  		if (attrs) {
  			res += "," + attrs;
  		}
  		if (bind$$1) {
  			res += (attrs ? '' : ',null') + "," + bind$$1;
  		}
  		return res + ')'
  	}
  	
  	// componentName is el.component, take it as argument to shun flow's pessimistic refinement
  	function genComponent (
  		componentName,
  		el,
  		state
  	) {
  		var children = el.inlineTemplate ? null : genChildren(el, state, true);
  		return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
  	}
  	
  	function genProps (props) {
  		var staticProps = "";
  		var dynamicProps = "";
  		for (var i = 0; i < props.length; i++) {
  			var prop = props[i];
  			var value = transformSpecialNewlines(prop.value);
  			if (prop.dynamic) {
  				dynamicProps += (prop.name) + "," + value + ",";
  			} else {
  				staticProps += "\"" + (prop.name) + "\":" + value + ",";
  			}
  		}
  		staticProps = "{" + (staticProps.slice(0, -1)) + "}";
  		if (dynamicProps) {
  			return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
  		} else {
  			return staticProps
  		}
  	}
  	
  	// #3895, #4268
  	function transformSpecialNewlines (text) {
  		return text
  		.replace(/\u2028/g, '\\u2028')
  		.replace(/\u2029/g, '\\u2029')
  	}
  	
  	/*  */
  	
  	
  	
  	// these keywords should not appear inside expressions, but operators like
  	// typeof, instanceof and in are allowed
  	var prohibitedKeywordRE = new 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');
  	
  	// these unary operators should not be used as property/method names
  	var unaryOperatorsRE = new RegExp('\\b' + (
  		'delete,typeof,void'
  	).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
  	
  	// strip strings in expressions
  	var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
  	
  	// detect problematic expressions in a template
  	function detectErrors (ast, warn) {
  		if (ast) {
  			checkNode(ast, warn);
  		}
  	}
  	
  	function checkNode (node, warn) {
  		if (node.type === 1) {
  			for (var name in node.attrsMap) {
  				if (dirRE.test(name)) {
  					var value = node.attrsMap[name];
  					if (value) {
  						var range = node.rawAttrsMap[name];
  						if (name === 'v-for') {
  							checkFor(node, ("v-for=\"" + value + "\""), warn, range);
  						} else if (onRE.test(name)) {
  							checkEvent(value, (name + "=\"" + value + "\""), warn, range);
  						} else {
  							checkExpression(value, (name + "=\"" + value + "\""), warn, range);
  						}
  					}
  				}
  			}
  			if (node.children) {
  				for (var i = 0; i < node.children.length; i++) {
  					checkNode(node.children[i], warn);
  				}
  			}
  		} else if (node.type === 2) {
  			checkExpression(node.expression, node.text, warn, node);
  		}
  	}
  	
  	function checkEvent (exp, text, warn, range) {
  		var stipped = exp.replace(stripStringRE, '');
  		var keywordMatch = stipped.match(unaryOperatorsRE);
  		if (keywordMatch && stipped.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);
  	}
  	
  	function checkFor (node, text, warn, range) {
  		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);
  	}
  	
  	function checkIdentifier (
  		ident,
  		type,
  		text,
  		warn,
  		range
  	) {
  		if (typeof ident === 'string') {
  			try {
  				new Function(("var " + ident + "=_"));
  			} catch (e) {
  				warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
  			}
  		}
  	}
  	
  	function checkExpression (exp, text, warn, range) {
  		try {
  			new Function(("return " + exp));
  		} catch (e) {
  			var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
  			if (keywordMatch) {
  				warn(
  					"avoid using JavaScript keyword as property name: " +
  					"\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
  					range
  				);
  			} else {
  				warn(
  					"invalid expression: " + (e.message) + " in\n\n" +
  					"    " + exp + "\n\n" +
  					"  Raw expression: " + (text.trim()) + "\n",
  					range
  				);
  			}
  		}
  	}
  	
  	/*  */
  	
  	var range = 2;
  	
  	function generateCodeFrame (
  		source,
  		start,
  		end
  	) {
  		if ( start === void 0 ) start = 0;
  		if ( end === void 0 ) end = source.length;
  		
  		var lines = source.split(/\r?\n/);
  		var count = 0;
  		var res = [];
  		for (var i = 0; i < lines.length; i++) {
  			count += lines[i].length + 1;
  			if (count >= start) {
  				for (var j = i - range; j <= i + range || end > count; j++) {
  					if (j < 0 || j >= lines.length) { continue }
  					res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
  					var lineLength = lines[j].length;
  					if (j === i) {
  						// push underline
  						var pad = start - (count - lineLength) + 1;
  						var 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')
  	}
  	
  	function repeat$1 (str, n) {
  		var result = '';
  		if (n > 0) {
  			while (true) { // eslint-disable-line
  				if (n & 1) { result += str; }
  				n >>>= 1;
  				if (n <= 0) { break }
  				str += str;
  			}
  		}
  		return result
  	}
  	
  	/*  */
  	
  	
  	
  	function createFunction (code, errors) {
  		try {
  			return new Function(code)
  		} catch (err) {
  			errors.push({ err: err, code: code });
  			return noop
  		}
  	}
  	
  	function createCompileToFunctionFn (compile) {
  		var cache = Object.create(null);
  		
  		return function compileToFunctions (
  			template,
  			options,
  			vm
  		) {
  			options = extend({}, options);
  			var warn$$1 = options.warn || warn;
  			delete options.warn;
  			
  			/* istanbul ignore if */
  			{
  				// detect possible CSP restriction
  				try {
  					new Function('return 1');
  				} catch (e) {
  					if (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.'
  						);
  					}
  				}
  			}
  			
  			// check cache
  			var key = options.delimiters
  				? String(options.delimiters) + template
  				: template;
  			if (cache[key]) {
  				return cache[key]
  			}
  			
  			// compile
  			var compiled = compile(template, options);
  			
  			// check compilation errors/tips
  			{
  				if (compiled.errors && compiled.errors.length) {
  					if (options.outputSourceRange) {
  						compiled.errors.forEach(function (e) {
  							warn$$1(
  								"Error compiling template:\n\n" + (e.msg) + "\n\n" +
  								generateCodeFrame(template, e.start, e.end),
  								vm
  							);
  						});
  					} else {
  						warn$$1(
  							"Error compiling template:\n\n" + template + "\n\n" +
  							compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
  							vm
  						);
  					}
  				}
  				if (compiled.tips && compiled.tips.length) {
  					if (options.outputSourceRange) {
  						compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
  					} else {
  						compiled.tips.forEach(function (msg) { return tip(msg, vm); });
  					}
  				}
  			}
  			
  			// turn code into functions
  			var res = {};
  			var fnGenErrors = [];
  			res.render = createFunction(compiled.render, fnGenErrors);
  			res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
  				return createFunction(code, fnGenErrors)
  			});
  			
  			// check function generation errors.
  			// this should only happen if there is a bug in the compiler itself.
  			// mostly for codegen development use
  			/* istanbul ignore if */
  			{
  				if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
  					warn$$1(
  						"Failed to generate render function:\n\n" +
  						fnGenErrors.map(function (ref) {
  							var err = ref.err;
  							var code = ref.code;
  							
  							return ((err.toString()) + " in\n\n" + code + "\n");
  						}).join('\n'),
  						vm
  					);
  				}
  			}
  			
  			return (cache[key] = res)
  		}
  	}
  	
  	/*  */
  	
  	function createCompilerCreator (baseCompile) {
  		return function createCompiler (baseOptions) {
  			function compile (
  				template,
  				options
  			) {
  				var finalOptions = Object.create(baseOptions);
  				var errors = [];
  				var tips = [];
  				
  				var warn = function (msg, range, tip) {
  					(tip ? tips : errors).push(msg);
  				};
  				
  				if (options) {
  					if (options.outputSourceRange) {
  						// $flow-disable-line
  						var leadingSpaceLength = template.match(/^\s*/)[0].length;
  						
  						warn = function (msg, range, tip) {
  							var data = { msg: msg };
  							if (range) {
  								if (range.start != null) {
  									data.start = range.start + leadingSpaceLength;
  								}
  								if (range.end != null) {
  									data.end = range.end + leadingSpaceLength;
  								}
  							}
  							(tip ? tips : errors).push(data);
  						};
  					}
  					// merge custom modules
  					if (options.modules) {
  						finalOptions.modules =
  							(baseOptions.modules || []).concat(options.modules);
  					}
  					// merge custom directives
  					if (options.directives) {
  						finalOptions.directives = extend(
  							Object.create(baseOptions.directives || null),
  							options.directives
  						);
  					}
  					// copy other options
  					for (var key in options) {
  						if (key !== 'modules' && key !== 'directives') {
  							finalOptions[key] = options[key];
  						}
  					}
  				}
  				
  				finalOptions.warn = warn;
  				
  				var compiled = baseCompile(template.trim(), finalOptions);
  				{
  					detectErrors(compiled.ast, warn);
  				}
  				compiled.errors = errors;
  				compiled.tips = tips;
  				return compiled
  			}
  			
  			return {
  				compile: compile,
  				compileToFunctions: createCompileToFunctionFn(compile)
  			}
  		}
  	}
  	
  	/*  */
  	
  	// `createCompilerCreator` allows creating compilers that use alternative
  	// parser/optimizer/codegen, e.g the SSR optimizing compiler.
  	// Here we just export a default compiler using the default parts.
  	var createCompiler = createCompilerCreator(function baseCompile (
  		template,
  		options
  	) {
  		var ast = parse(template.trim(), options);
  		if (options.optimize !== false) {
  			optimize(ast, options);
  		}
  		var code = generate(ast, options);
  		return {
  			ast: ast,
  			render: code.render,
  			staticRenderFns: code.staticRenderFns
  		}
  	});
  	
  	/*  */
  	
  	var ref$1 = createCompiler(baseOptions);
  	var compile = ref$1.compile;
  	var compileToFunctions = ref$1.compileToFunctions;
  	
  	/*  */
  	
  	// check whether current browser encodes a char inside attribute values
  	var div;
  	function getShouldDecode (href) {
  		div = div || document.createElement('div');
  		div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
  		return div.innerHTML.indexOf('&#10;') > 0
  	}
  	
  	// #3663: IE encodes newlines inside attribute values while other browsers don't
  	var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
  	// #6828: chrome encodes content in a[href]
  	var shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false;
  	
  	/*  */
  	
  	var idToTemplate = cached(function (id) {
  		var el = query(id);
  		return el && el.innerHTML
  	});
  	
  	var mount = Vue.prototype.$mount;
  	Vue.prototype.$mount = function (
  		el,
  		hydrating
  	) {
  		el = el && query(el);
  		
  		/* istanbul ignore if */
  		if (el === document.body || el === document.documentElement) {
  			warn(
  				"Do not mount Vue to <html> or <body> - mount to normal elements instead."
  			);
  			return this
  		}
  		
  		var options = this.$options;
  		// resolve template/el and convert to render function
  		if (!options.render) {
  			var template = options.template;
  			if (template) {
  				if (typeof template === 'string') {
  					if (template.charAt(0) === '#') {
  						template = idToTemplate(template);
  						/* istanbul ignore if */
  						if (!template) {
  							warn(
  								("Template element not found or is empty: " + (options.template)),
  								this
  							);
  						}
  					}
  				} else if (template.nodeType) {
  					template = template.innerHTML;
  				} else {
  					{
  						warn('invalid template option:' + template, this);
  					}
  					return this
  				}
  			} else if (el) {
  				template = getOuterHTML(el);
  			}
  			if (template) {
  				/* istanbul ignore if */
  				if (config.performance && mark) {
  					mark('compile');
  				}
  				
  				var ref = compileToFunctions(template, {
  					outputSourceRange: "development" !== 'production',
  					shouldDecodeNewlines: shouldDecodeNewlines,
  					shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
  					delimiters: options.delimiters,
  					comments: options.comments
  				}, this);
  				var render = ref.render;
  				var staticRenderFns = ref.staticRenderFns;
  				options.render = render;
  				options.staticRenderFns = staticRenderFns;
  				
  				/* istanbul ignore if */
  				if (config.performance && mark) {
  					mark('compile end');
  					measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
  				}
  			}
  		}
  		return mount.call(this, el, hydrating)
  	};
  	
  	/**
  	 * Get outerHTML of elements, taking care
  	 * of SVG elements in IE as well.
  	 */
  	function getOuterHTML (el) {
  		if (el.outerHTML) {
  			return el.outerHTML
  		} else {
  			var container = document.createElement('div');
  			container.appendChild(el.cloneNode(true));
  			return container.innerHTML
  		}
  	}
  	
  	Vue.compile = compileToFunctions;
  	
  	return Vue;
  	
  }));
  