// file bismon/webroot/jscript/vue.js downloaded from
// https://vuejs.org (on Debian is copied from package libjs-vue
// version 2.5.17...)

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define("Vue", [], factory);
	else if(typeof exports === 'object')
		exports["Vue"] = factory();
	else
		root["Vue"] = factory();
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = "./src/platforms/web/entry-runtime-with-compiler.js");
/******/ })
/************************************************************************/
/******/ ({

/***/ "../../../usr/lib/nodejs/he/he.js":
/*!********************************!*\
  !*** /usr/lib/nodejs/he/he.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

eval("/* WEBPACK VAR INJECTION */(function(module, global) {var __WEBPACK_AMD_DEFINE_RESULT__;/*! https://mths.be/he v1.1.1 by @mathias | MIT license */\n;(function (root) {\n\n\t// Detect free variables `exports`.\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`.\n\tvar freeModule = typeof module == 'object' && module && module.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`.\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t// All astral symbols.\n\tvar regexAstralSymbols = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g;\n\t// All ASCII symbols (not just printable ASCII) except those listed in the\n\t// first column of the overrides table.\n\t// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides\n\tvar regexAsciiWhitelist = /[\\x01-\\x7F]/g;\n\t// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or\n\t// code points listed in the first column of the overrides table on\n\t// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.\n\tvar regexBmpWhitelist = /[\\x01-\\t\\x0B\\f\\x0E-\\x1F\\x7F\\x81\\x8D\\x8F\\x90\\x9D\\xA0-\\uFFFF]/g;\n\n\tvar regexEncodeNonAscii = /<\\u20D2|=\\u20E5|>\\u20D2|\\u205F\\u200A|\\u219D\\u0338|\\u2202\\u0338|\\u2220\\u20D2|\\u2229\\uFE00|\\u222A\\uFE00|\\u223C\\u20D2|\\u223D\\u0331|\\u223E\\u0333|\\u2242\\u0338|\\u224B\\u0338|\\u224D\\u20D2|\\u224E\\u0338|\\u224F\\u0338|\\u2250\\u0338|\\u2261\\u20E5|\\u2264\\u20D2|\\u2265\\u20D2|\\u2266\\u0338|\\u2267\\u0338|\\u2268\\uFE00|\\u2269\\uFE00|\\u226A\\u0338|\\u226A\\u20D2|\\u226B\\u0338|\\u226B\\u20D2|\\u227F\\u0338|\\u2282\\u20D2|\\u2283\\u20D2|\\u228A\\uFE00|\\u228B\\uFE00|\\u228F\\u0338|\\u2290\\u0338|\\u2293\\uFE00|\\u2294\\uFE00|\\u22B4\\u20D2|\\u22B5\\u20D2|\\u22D8\\u0338|\\u22D9\\u0338|\\u22DA\\uFE00|\\u22DB\\uFE00|\\u22F5\\u0338|\\u22F9\\u0338|\\u2933\\u0338|\\u29CF\\u0338|\\u29D0\\u0338|\\u2A6D\\u0338|\\u2A70\\u0338|\\u2A7D\\u0338|\\u2A7E\\u0338|\\u2AA1\\u0338|\\u2AA2\\u0338|\\u2AAC\\uFE00|\\u2AAD\\uFE00|\\u2AAF\\u0338|\\u2AB0\\u0338|\\u2AC5\\u0338|\\u2AC6\\u0338|\\u2ACB\\uFE00|\\u2ACC\\uFE00|\\u2AFD\\u20E5|[\\xA0-\\u0113\\u0116-\\u0122\\u0124-\\u012B\\u012E-\\u014D\\u0150-\\u017E\\u0192\\u01B5\\u01F5\\u0237\\u02C6\\u02C7\\u02D8-\\u02DD\\u0311\\u0391-\\u03A1\\u03A3-\\u03A9\\u03B1-\\u03C9\\u03D1\\u03D2\\u03D5\\u03D6\\u03DC\\u03DD\\u03F0\\u03F1\\u03F5\\u03F6\\u0401-\\u040C\\u040E-\\u044F\\u0451-\\u045C\\u045E\\u045F\\u2002-\\u2005\\u2007-\\u2010\\u2013-\\u2016\\u2018-\\u201A\\u201C-\\u201E\\u2020-\\u2022\\u2025\\u2026\\u2030-\\u2035\\u2039\\u203A\\u203E\\u2041\\u2043\\u2044\\u204F\\u2057\\u205F-\\u2063\\u20AC\\u20DB\\u20DC\\u2102\\u2105\\u210A-\\u2113\\u2115-\\u211E\\u2122\\u2124\\u2127-\\u2129\\u212C\\u212D\\u212F-\\u2131\\u2133-\\u2138\\u2145-\\u2148\\u2153-\\u215E\\u2190-\\u219B\\u219D-\\u21A7\\u21A9-\\u21AE\\u21B0-\\u21B3\\u21B5-\\u21B7\\u21BA-\\u21DB\\u21DD\\u21E4\\u21E5\\u21F5\\u21FD-\\u2205\\u2207-\\u2209\\u220B\\u220C\\u220F-\\u2214\\u2216-\\u2218\\u221A\\u221D-\\u2238\\u223A-\\u2257\\u2259\\u225A\\u225C\\u225F-\\u2262\\u2264-\\u228B\\u228D-\\u229B\\u229D-\\u22A5\\u22A7-\\u22B0\\u22B2-\\u22BB\\u22BD-\\u22DB\\u22DE-\\u22E3\\u22E6-\\u22F7\\u22F9-\\u22FE\\u2305\\u2306\\u2308-\\u2310\\u2312\\u2313\\u2315\\u2316\\u231C-\\u231F\\u2322\\u2323\\u232D\\u232E\\u2336\\u233D\\u233F\\u237C\\u23B0\\u23B1\\u23B4-\\u23B6\\u23DC-\\u23DF\\u23E2\\u23E7\\u2423\\u24C8\\u2500\\u2502\\u250C\\u2510\\u2514\\u2518\\u251C\\u2524\\u252C\\u2534\\u253C\\u2550-\\u256C\\u2580\\u2584\\u2588\\u2591-\\u2593\\u25A1\\u25AA\\u25AB\\u25AD\\u25AE\\u25B1\\u25B3-\\u25B5\\u25B8\\u25B9\\u25BD-\\u25BF\\u25C2\\u25C3\\u25CA\\u25CB\\u25EC\\u25EF\\u25F8-\\u25FC\\u2605\\u2606\\u260E\\u2640\\u2642\\u2660\\u2663\\u2665\\u2666\\u266A\\u266D-\\u266F\\u2713\\u2717\\u2720\\u2736\\u2758\\u2772\\u2773\\u27C8\\u27C9\\u27E6-\\u27ED\\u27F5-\\u27FA\\u27FC\\u27FF\\u2902-\\u2905\\u290C-\\u2913\\u2916\\u2919-\\u2920\\u2923-\\u292A\\u2933\\u2935-\\u2939\\u293C\\u293D\\u2945\\u2948-\\u294B\\u294E-\\u2976\\u2978\\u2979\\u297B-\\u297F\\u2985\\u2986\\u298B-\\u2996\\u299A\\u299C\\u299D\\u29A4-\\u29B7\\u29B9\\u29BB\\u29BC\\u29BE-\\u29C5\\u29C9\\u29CD-\\u29D0\\u29DC-\\u29DE\\u29E3-\\u29E5\\u29EB\\u29F4\\u29F6\\u2A00-\\u2A02\\u2A04\\u2A06\\u2A0C\\u2A0D\\u2A10-\\u2A17\\u2A22-\\u2A27\\u2A29\\u2A2A\\u2A2D-\\u2A31\\u2A33-\\u2A3C\\u2A3F\\u2A40\\u2A42-\\u2A4D\\u2A50\\u2A53-\\u2A58\\u2A5A-\\u2A5D\\u2A5F\\u2A66\\u2A6A\\u2A6D-\\u2A75\\u2A77-\\u2A9A\\u2A9D-\\u2AA2\\u2AA4-\\u2AB0\\u2AB3-\\u2AC8\\u2ACB\\u2ACC\\u2ACF-\\u2ADB\\u2AE4\\u2AE6-\\u2AE9\\u2AEB-\\u2AF3\\u2AFD\\uFB00-\\uFB04]|\\uD835[\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDCCF\\uDD04\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDD6B]/g;\n\tvar encodeMap = { '\\xAD': 'shy', '\\u200C': 'zwnj', '\\u200D': 'zwj', '\\u200E': 'lrm', '\\u2063': 'ic', '\\u2062': 'it', '\\u2061': 'af', '\\u200F': 'rlm', '\\u200B': 'ZeroWidthSpace', '\\u2060': 'NoBreak', '\\u0311': 'DownBreve', '\\u20DB': 'tdot', '\\u20DC': 'DotDot', '\\t': 'Tab', '\\n': 'NewLine', '\\u2008': 'puncsp', '\\u205F': 'MediumSpace', '\\u2009': 'thinsp', '\\u200A': 'hairsp', '\\u2004': 'emsp13', '\\u2002': 'ensp', '\\u2005': 'emsp14', '\\u2003': 'emsp', '\\u2007': 'numsp', '\\xA0': 'nbsp', '\\u205F\\u200A': 'ThickSpace', '\\u203E': 'oline', '_': 'lowbar', '\\u2010': 'dash', '\\u2013': 'ndash', '\\u2014': 'mdash', '\\u2015': 'horbar', ',': 'comma', ';': 'semi', '\\u204F': 'bsemi', ':': 'colon', '\\u2A74': 'Colone', '!': 'excl', '\\xA1': 'iexcl', '?': 'quest', '\\xBF': 'iquest', '.': 'period', '\\u2025': 'nldr', '\\u2026': 'mldr', '\\xB7': 'middot', '\\'': 'apos', '\\u2018': 'lsquo', '\\u2019': 'rsquo', '\\u201A': 'sbquo', '\\u2039': 'lsaquo', '\\u203A': 'rsaquo', '\"': 'quot', '\\u201C': 'ldquo', '\\u201D': 'rdquo', '\\u201E': 'bdquo', '\\xAB': 'laquo', '\\xBB': 'raquo', '(': 'lpar', ')': 'rpar', '[': 'lsqb', ']': 'rsqb', '{': 'lcub', '}': 'rcub', '\\u2308': 'lceil', '\\u2309': 'rceil', '\\u230A': 'lfloor', '\\u230B': 'rfloor', '\\u2985': 'lopar', '\\u2986': 'ropar', '\\u298B': 'lbrke', '\\u298C': 'rbrke', '\\u298D': 'lbrkslu', '\\u298E': 'rbrksld', '\\u298F': 'lbrksld', '\\u2990': 'rbrkslu', '\\u2991': 'langd', '\\u2992': 'rangd', '\\u2993': 'lparlt', '\\u2994': 'rpargt', '\\u2995': 'gtlPar', '\\u2996': 'ltrPar', '\\u27E6': 'lobrk', '\\u27E7': 'robrk', '\\u27E8': 'lang', '\\u27E9': 'rang', '\\u27EA': 'Lang', '\\u27EB': 'Rang', '\\u27EC': 'loang', '\\u27ED': 'roang', '\\u2772': 'lbbrk', '\\u2773': 'rbbrk', '\\u2016': 'Vert', '\\xA7': 'sect', '\\xB6': 'para', '@': 'commat', '*': 'ast', '/': 'sol', 'undefined': null, '&': 'amp', '#': 'num', '%': 'percnt', '\\u2030': 'permil', '\\u2031': 'pertenk', '\\u2020': 'dagger', '\\u2021': 'Dagger', '\\u2022': 'bull', '\\u2043': 'hybull', '\\u2032': 'prime', '\\u2033': 'Prime', '\\u2034': 'tprime', '\\u2057': 'qprime', '\\u2035': 'bprime', '\\u2041': 'caret', '`': 'grave', '\\xB4': 'acute', '\\u02DC': 'tilde', '^': 'Hat', '\\xAF': 'macr', '\\u02D8': 'breve', '\\u02D9': 'dot', '\\xA8': 'die', '\\u02DA': 'ring', '\\u02DD': 'dblac', '\\xB8': 'cedil', '\\u02DB': 'ogon', '\\u02C6': 'circ', '\\u02C7': 'caron', '\\xB0': 'deg', '\\xA9': 'copy', '\\xAE': 'reg', '\\u2117': 'copysr', '\\u2118': 'wp', '\\u211E': 'rx', '\\u2127': 'mho', '\\u2129': 'iiota', '\\u2190': 'larr', '\\u219A': 'nlarr', '\\u2192': 'rarr', '\\u219B': 'nrarr', '\\u2191': 'uarr', '\\u2193': 'darr', '\\u2194': 'harr', '\\u21AE': 'nharr', '\\u2195': 'varr', '\\u2196': 'nwarr', '\\u2197': 'nearr', '\\u2198': 'searr', '\\u2199': 'swarr', '\\u219D': 'rarrw', '\\u219D\\u0338': 'nrarrw', '\\u219E': 'Larr', '\\u219F': 'Uarr', '\\u21A0': 'Rarr', '\\u21A1': 'Darr', '\\u21A2': 'larrtl', '\\u21A3': 'rarrtl', '\\u21A4': 'mapstoleft', '\\u21A5': 'mapstoup', '\\u21A6': 'map', '\\u21A7': 'mapstodown', '\\u21A9': 'larrhk', '\\u21AA': 'rarrhk', '\\u21AB': 'larrlp', '\\u21AC': 'rarrlp', '\\u21AD': 'harrw', '\\u21B0': 'lsh', '\\u21B1': 'rsh', '\\u21B2': 'ldsh', '\\u21B3': 'rdsh', '\\u21B5': 'crarr', '\\u21B6': 'cularr', '\\u21B7': 'curarr', '\\u21BA': 'olarr', '\\u21BB': 'orarr', '\\u21BC': 'lharu', '\\u21BD': 'lhard', '\\u21BE': 'uharr', '\\u21BF': 'uharl', '\\u21C0': 'rharu', '\\u21C1': 'rhard', '\\u21C2': 'dharr', '\\u21C3': 'dharl', '\\u21C4': 'rlarr', '\\u21C5': 'udarr', '\\u21C6': 'lrarr', '\\u21C7': 'llarr', '\\u21C8': 'uuarr', '\\u21C9': 'rrarr', '\\u21CA': 'ddarr', '\\u21CB': 'lrhar', '\\u21CC': 'rlhar', '\\u21D0': 'lArr', '\\u21CD': 'nlArr', '\\u21D1': 'uArr', '\\u21D2': 'rArr', '\\u21CF': 'nrArr', '\\u21D3': 'dArr', '\\u21D4': 'iff', '\\u21CE': 'nhArr', '\\u21D5': 'vArr', '\\u21D6': 'nwArr', '\\u21D7': 'neArr', '\\u21D8': 'seArr', '\\u21D9': 'swArr', '\\u21DA': 'lAarr', '\\u21DB': 'rAarr', '\\u21DD': 'zigrarr', '\\u21E4': 'larrb', '\\u21E5': 'rarrb', '\\u21F5': 'duarr', '\\u21FD': 'loarr', '\\u21FE': 'roarr', '\\u21FF': 'hoarr', '\\u2200': 'forall', '\\u2201': 'comp', '\\u2202': 'part', '\\u2202\\u0338': 'npart', '\\u2203': 'exist', '\\u2204': 'nexist', '\\u2205': 'empty', '\\u2207': 'Del', '\\u2208': 'in', '\\u2209': 'notin', '\\u220B': 'ni', '\\u220C': 'notni', '\\u03F6': 'bepsi', '\\u220F': 'prod', '\\u2210': 'coprod', '\\u2211': 'sum', '+': 'plus', '\\xB1': 'pm', '\\xF7': 'div', '\\xD7': 'times', '<': 'lt', '\\u226E': 'nlt', '<\\u20D2': 'nvlt', '=': 'equals', '\\u2260': 'ne', '=\\u20E5': 'bne', '\\u2A75': 'Equal', '>': 'gt', '\\u226F': 'ngt', '>\\u20D2': 'nvgt', '\\xAC': 'not', '|': 'vert', '\\xA6': 'brvbar', '\\u2212': 'minus', '\\u2213': 'mp', '\\u2214': 'plusdo', '\\u2044': 'frasl', '\\u2216': 'setmn', '\\u2217': 'lowast', '\\u2218': 'compfn', '\\u221A': 'Sqrt', '\\u221D': 'prop', '\\u221E': 'infin', '\\u221F': 'angrt', '\\u2220': 'ang', '\\u2220\\u20D2': 'nang', '\\u2221': 'angmsd', '\\u2222': 'angsph', '\\u2223': 'mid', '\\u2224': 'nmid', '\\u2225': 'par', '\\u2226': 'npar', '\\u2227': 'and', '\\u2228': 'or', '\\u2229': 'cap', '\\u2229\\uFE00': 'caps', '\\u222A': 'cup', '\\u222A\\uFE00': 'cups', '\\u222B': 'int', '\\u222C': 'Int', '\\u222D': 'tint', '\\u2A0C': 'qint', '\\u222E': 'oint', '\\u222F': 'Conint', '\\u2230': 'Cconint', '\\u2231': 'cwint', '\\u2232': 'cwconint', '\\u2233': 'awconint', '\\u2234': 'there4', '\\u2235': 'becaus', '\\u2236': 'ratio', '\\u2237': 'Colon', '\\u2238': 'minusd', '\\u223A': 'mDDot', '\\u223B': 'homtht', '\\u223C': 'sim', '\\u2241': 'nsim', '\\u223C\\u20D2': 'nvsim', '\\u223D': 'bsim', '\\u223D\\u0331': 'race', '\\u223E': 'ac', '\\u223E\\u0333': 'acE', '\\u223F': 'acd', '\\u2240': 'wr', '\\u2242': 'esim', '\\u2242\\u0338': 'nesim', '\\u2243': 'sime', '\\u2244': 'nsime', '\\u2245': 'cong', '\\u2247': 'ncong', '\\u2246': 'simne', '\\u2248': 'ap', '\\u2249': 'nap', '\\u224A': 'ape', '\\u224B': 'apid', '\\u224B\\u0338': 'napid', '\\u224C': 'bcong', '\\u224D': 'CupCap', '\\u226D': 'NotCupCap', '\\u224D\\u20D2': 'nvap', '\\u224E': 'bump', '\\u224E\\u0338': 'nbump', '\\u224F': 'bumpe', '\\u224F\\u0338': 'nbumpe', '\\u2250': 'doteq', '\\u2250\\u0338': 'nedot', '\\u2251': 'eDot', '\\u2252': 'efDot', '\\u2253': 'erDot', '\\u2254': 'colone', '\\u2255': 'ecolon', '\\u2256': 'ecir', '\\u2257': 'cire', '\\u2259': 'wedgeq', '\\u225A': 'veeeq', '\\u225C': 'trie', '\\u225F': 'equest', '\\u2261': 'equiv', '\\u2262': 'nequiv', '\\u2261\\u20E5': 'bnequiv', '\\u2264': 'le', '\\u2270': 'nle', '\\u2264\\u20D2': 'nvle', '\\u2265': 'ge', '\\u2271': 'nge', '\\u2265\\u20D2': 'nvge', '\\u2266': 'lE', '\\u2266\\u0338': 'nlE', '\\u2267': 'gE', '\\u2267\\u0338': 'ngE', '\\u2268\\uFE00': 'lvnE', '\\u2268': 'lnE', '\\u2269': 'gnE', '\\u2269\\uFE00': 'gvnE', '\\u226A': 'll', '\\u226A\\u0338': 'nLtv', '\\u226A\\u20D2': 'nLt', '\\u226B': 'gg', '\\u226B\\u0338': 'nGtv', '\\u226B\\u20D2': 'nGt', '\\u226C': 'twixt', '\\u2272': 'lsim', '\\u2274': 'nlsim', '\\u2273': 'gsim', '\\u2275': 'ngsim', '\\u2276': 'lg', '\\u2278': 'ntlg', '\\u2277': 'gl', '\\u2279': 'ntgl', '\\u227A': 'pr', '\\u2280': 'npr', '\\u227B': 'sc', '\\u2281': 'nsc', '\\u227C': 'prcue', '\\u22E0': 'nprcue', '\\u227D': 'sccue', '\\u22E1': 'nsccue', '\\u227E': 'prsim', '\\u227F': 'scsim', '\\u227F\\u0338': 'NotSucceedsTilde', '\\u2282': 'sub', '\\u2284': 'nsub', '\\u2282\\u20D2': 'vnsub', '\\u2283': 'sup', '\\u2285': 'nsup', '\\u2283\\u20D2': 'vnsup', '\\u2286': 'sube', '\\u2288': 'nsube', '\\u2287': 'supe', '\\u2289': 'nsupe', '\\u228A\\uFE00': 'vsubne', '\\u228A': 'subne', '\\u228B\\uFE00': 'vsupne', '\\u228B': 'supne', '\\u228D': 'cupdot', '\\u228E': 'uplus', '\\u228F': 'sqsub', '\\u228F\\u0338': 'NotSquareSubset', '\\u2290': 'sqsup', '\\u2290\\u0338': 'NotSquareSuperset', '\\u2291': 'sqsube', '\\u22E2': 'nsqsube', '\\u2292': 'sqsupe', '\\u22E3': 'nsqsupe', '\\u2293': 'sqcap', '\\u2293\\uFE00': 'sqcaps', '\\u2294': 'sqcup', '\\u2294\\uFE00': 'sqcups', '\\u2295': 'oplus', '\\u2296': 'ominus', '\\u2297': 'otimes', '\\u2298': 'osol', '\\u2299': 'odot', '\\u229A': 'ocir', '\\u229B': 'oast', '\\u229D': 'odash', '\\u229E': 'plusb', '\\u229F': 'minusb', '\\u22A0': 'timesb', '\\u22A1': 'sdotb', '\\u22A2': 'vdash', '\\u22AC': 'nvdash', '\\u22A3': 'dashv', '\\u22A4': 'top', '\\u22A5': 'bot', '\\u22A7': 'models', '\\u22A8': 'vDash', '\\u22AD': 'nvDash', '\\u22A9': 'Vdash', '\\u22AE': 'nVdash', '\\u22AA': 'Vvdash', '\\u22AB': 'VDash', '\\u22AF': 'nVDash', '\\u22B0': 'prurel', '\\u22B2': 'vltri', '\\u22EA': 'nltri', '\\u22B3': 'vrtri', '\\u22EB': 'nrtri', '\\u22B4': 'ltrie', '\\u22EC': 'nltrie', '\\u22B4\\u20D2': 'nvltrie', '\\u22B5': 'rtrie', '\\u22ED': 'nrtrie', '\\u22B5\\u20D2': 'nvrtrie', '\\u22B6': 'origof', '\\u22B7': 'imof', '\\u22B8': 'mumap', '\\u22B9': 'hercon', '\\u22BA': 'intcal', '\\u22BB': 'veebar', '\\u22BD': 'barvee', '\\u22BE': 'angrtvb', '\\u22BF': 'lrtri', '\\u22C0': 'Wedge', '\\u22C1': 'Vee', '\\u22C2': 'xcap', '\\u22C3': 'xcup', '\\u22C4': 'diam', '\\u22C5': 'sdot', '\\u22C6': 'Star', '\\u22C7': 'divonx', '\\u22C8': 'bowtie', '\\u22C9': 'ltimes', '\\u22CA': 'rtimes', '\\u22CB': 'lthree', '\\u22CC': 'rthree', '\\u22CD': 'bsime', '\\u22CE': 'cuvee', '\\u22CF': 'cuwed', '\\u22D0': 'Sub', '\\u22D1': 'Sup', '\\u22D2': 'Cap', '\\u22D3': 'Cup', '\\u22D4': 'fork', '\\u22D5': 'epar', '\\u22D6': 'ltdot', '\\u22D7': 'gtdot', '\\u22D8': 'Ll', '\\u22D8\\u0338': 'nLl', '\\u22D9': 'Gg', '\\u22D9\\u0338': 'nGg', '\\u22DA\\uFE00': 'lesg', '\\u22DA': 'leg', '\\u22DB': 'gel', '\\u22DB\\uFE00': 'gesl', '\\u22DE': 'cuepr', '\\u22DF': 'cuesc', '\\u22E6': 'lnsim', '\\u22E7': 'gnsim', '\\u22E8': 'prnsim', '\\u22E9': 'scnsim', '\\u22EE': 'vellip', '\\u22EF': 'ctdot', '\\u22F0': 'utdot', '\\u22F1': 'dtdot', '\\u22F2': 'disin', '\\u22F3': 'isinsv', '\\u22F4': 'isins', '\\u22F5': 'isindot', '\\u22F5\\u0338': 'notindot', '\\u22F6': 'notinvc', '\\u22F7': 'notinvb', '\\u22F9': 'isinE', '\\u22F9\\u0338': 'notinE', '\\u22FA': 'nisd', '\\u22FB': 'xnis', '\\u22FC': 'nis', '\\u22FD': 'notnivc', '\\u22FE': 'notnivb', '\\u2305': 'barwed', '\\u2306': 'Barwed', '\\u230C': 'drcrop', '\\u230D': 'dlcrop', '\\u230E': 'urcrop', '\\u230F': 'ulcrop', '\\u2310': 'bnot', '\\u2312': 'profline', '\\u2313': 'profsurf', '\\u2315': 'telrec', '\\u2316': 'target', '\\u231C': 'ulcorn', '\\u231D': 'urcorn', '\\u231E': 'dlcorn', '\\u231F': 'drcorn', '\\u2322': 'frown', '\\u2323': 'smile', '\\u232D': 'cylcty', '\\u232E': 'profalar', '\\u2336': 'topbot', '\\u233D': 'ovbar', '\\u233F': 'solbar', '\\u237C': 'angzarr', '\\u23B0': 'lmoust', '\\u23B1': 'rmoust', '\\u23B4': 'tbrk', '\\u23B5': 'bbrk', '\\u23B6': 'bbrktbrk', '\\u23DC': 'OverParenthesis', '\\u23DD': 'UnderParenthesis', '\\u23DE': 'OverBrace', '\\u23DF': 'UnderBrace', '\\u23E2': 'trpezium', '\\u23E7': 'elinters', '\\u2423': 'blank', '\\u2500': 'boxh', '\\u2502': 'boxv', '\\u250C': 'boxdr', '\\u2510': 'boxdl', '\\u2514': 'boxur', '\\u2518': 'boxul', '\\u251C': 'boxvr', '\\u2524': 'boxvl', '\\u252C': 'boxhd', '\\u2534': 'boxhu', '\\u253C': 'boxvh', '\\u2550': 'boxH', '\\u2551': 'boxV', '\\u2552': 'boxdR', '\\u2553': 'boxDr', '\\u2554': 'boxDR', '\\u2555': 'boxdL', '\\u2556': 'boxDl', '\\u2557': 'boxDL', '\\u2558': 'boxuR', '\\u2559': 'boxUr', '\\u255A': 'boxUR', '\\u255B': 'boxuL', '\\u255C': 'boxUl', '\\u255D': 'boxUL', '\\u255E': 'boxvR', '\\u255F': 'boxVr', '\\u2560': 'boxVR', '\\u2561': 'boxvL', '\\u2562': 'boxVl', '\\u2563': 'boxVL', '\\u2564': 'boxHd', '\\u2565': 'boxhD', '\\u2566': 'boxHD', '\\u2567': 'boxHu', '\\u2568': 'boxhU', '\\u2569': 'boxHU', '\\u256A': 'boxvH', '\\u256B': 'boxVh', '\\u256C': 'boxVH', '\\u2580': 'uhblk', '\\u2584': 'lhblk', '\\u2588': 'block', '\\u2591': 'blk14', '\\u2592': 'blk12', '\\u2593': 'blk34', '\\u25A1': 'squ', '\\u25AA': 'squf', '\\u25AB': 'EmptyVerySmallSquare', '\\u25AD': 'rect', '\\u25AE': 'marker', '\\u25B1': 'fltns', '\\u25B3': 'xutri', '\\u25B4': 'utrif', '\\u25B5': 'utri', '\\u25B8': 'rtrif', '\\u25B9': 'rtri', '\\u25BD': 'xdtri', '\\u25BE': 'dtrif', '\\u25BF': 'dtri', '\\u25C2': 'ltrif', '\\u25C3': 'ltri', '\\u25CA': 'loz', '\\u25CB': 'cir', '\\u25EC': 'tridot', '\\u25EF': 'xcirc', '\\u25F8': 'ultri', '\\u25F9': 'urtri', '\\u25FA': 'lltri', '\\u25FB': 'EmptySmallSquare', '\\u25FC': 'FilledSmallSquare', '\\u2605': 'starf', '\\u2606': 'star', '\\u260E': 'phone', '\\u2640': 'female', '\\u2642': 'male', '\\u2660': 'spades', '\\u2663': 'clubs', '\\u2665': 'hearts', '\\u2666': 'diams', '\\u266A': 'sung', '\\u2713': 'check', '\\u2717': 'cross', '\\u2720': 'malt', '\\u2736': 'sext', '\\u2758': 'VerticalSeparator', '\\u27C8': 'bsolhsub', '\\u27C9': 'suphsol', '\\u27F5': 'xlarr', '\\u27F6': 'xrarr', '\\u27F7': 'xharr', '\\u27F8': 'xlArr', '\\u27F9': 'xrArr', '\\u27FA': 'xhArr', '\\u27FC': 'xmap', '\\u27FF': 'dzigrarr', '\\u2902': 'nvlArr', '\\u2903': 'nvrArr', '\\u2904': 'nvHarr', '\\u2905': 'Map', '\\u290C': 'lbarr', '\\u290D': 'rbarr', '\\u290E': 'lBarr', '\\u290F': 'rBarr', '\\u2910': 'RBarr', '\\u2911': 'DDotrahd', '\\u2912': 'UpArrowBar', '\\u2913': 'DownArrowBar', '\\u2916': 'Rarrtl', '\\u2919': 'latail', '\\u291A': 'ratail', '\\u291B': 'lAtail', '\\u291C': 'rAtail', '\\u291D': 'larrfs', '\\u291E': 'rarrfs', '\\u291F': 'larrbfs', '\\u2920': 'rarrbfs', '\\u2923': 'nwarhk', '\\u2924': 'nearhk', '\\u2925': 'searhk', '\\u2926': 'swarhk', '\\u2927': 'nwnear', '\\u2928': 'toea', '\\u2929': 'tosa', '\\u292A': 'swnwar', '\\u2933': 'rarrc', '\\u2933\\u0338': 'nrarrc', '\\u2935': 'cudarrr', '\\u2936': 'ldca', '\\u2937': 'rdca', '\\u2938': 'cudarrl', '\\u2939': 'larrpl', '\\u293C': 'curarrm', '\\u293D': 'cularrp', '\\u2945': 'rarrpl', '\\u2948': 'harrcir', '\\u2949': 'Uarrocir', '\\u294A': 'lurdshar', '\\u294B': 'ldrushar', '\\u294E': 'LeftRightVector', '\\u294F': 'RightUpDownVector', '\\u2950': 'DownLeftRightVector', '\\u2951': 'LeftUpDownVector', '\\u2952': 'LeftVectorBar', '\\u2953': 'RightVectorBar', '\\u2954': 'RightUpVectorBar', '\\u2955': 'RightDownVectorBar', '\\u2956': 'DownLeftVectorBar', '\\u2957': 'DownRightVectorBar', '\\u2958': 'LeftUpVectorBar', '\\u2959': 'LeftDownVectorBar', '\\u295A': 'LeftTeeVector', '\\u295B': 'RightTeeVector', '\\u295C': 'RightUpTeeVector', '\\u295D': 'RightDownTeeVector', '\\u295E': 'DownLeftTeeVector', '\\u295F': 'DownRightTeeVector', '\\u2960': 'LeftUpTeeVector', '\\u2961': 'LeftDownTeeVector', '\\u2962': 'lHar', '\\u2963': 'uHar', '\\u2964': 'rHar', '\\u2965': 'dHar', '\\u2966': 'luruhar', '\\u2967': 'ldrdhar', '\\u2968': 'ruluhar', '\\u2969': 'rdldhar', '\\u296A': 'lharul', '\\u296B': 'llhard', '\\u296C': 'rharul', '\\u296D': 'lrhard', '\\u296E': 'udhar', '\\u296F': 'duhar', '\\u2970': 'RoundImplies', '\\u2971': 'erarr', '\\u2972': 'simrarr', '\\u2973': 'larrsim', '\\u2974': 'rarrsim', '\\u2975': 'rarrap', '\\u2976': 'ltlarr', '\\u2978': 'gtrarr', '\\u2979': 'subrarr', '\\u297B': 'suplarr', '\\u297C': 'lfisht', '\\u297D': 'rfisht', '\\u297E': 'ufisht', '\\u297F': 'dfisht', '\\u299A': 'vzigzag', '\\u299C': 'vangrt', '\\u299D': 'angrtvbd', '\\u29A4': 'ange', '\\u29A5': 'range', '\\u29A6': 'dwangle', '\\u29A7': 'uwangle', '\\u29A8': 'angmsdaa', '\\u29A9': 'angmsdab', '\\u29AA': 'angmsdac', '\\u29AB': 'angmsdad', '\\u29AC': 'angmsdae', '\\u29AD': 'angmsdaf', '\\u29AE': 'angmsdag', '\\u29AF': 'angmsdah', '\\u29B0': 'bemptyv', '\\u29B1': 'demptyv', '\\u29B2': 'cemptyv', '\\u29B3': 'raemptyv', '\\u29B4': 'laemptyv', '\\u29B5': 'ohbar', '\\u29B6': 'omid', '\\u29B7': 'opar', '\\u29B9': 'operp', '\\u29BB': 'olcross', '\\u29BC': 'odsold', '\\u29BE': 'olcir', '\\u29BF': 'ofcir', '\\u29C0': 'olt', '\\u29C1': 'ogt', '\\u29C2': 'cirscir', '\\u29C3': 'cirE', '\\u29C4': 'solb', '\\u29C5': 'bsolb', '\\u29C9': 'boxbox', '\\u29CD': 'trisb', '\\u29CE': 'rtriltri', '\\u29CF': 'LeftTriangleBar', '\\u29CF\\u0338': 'NotLeftTriangleBar', '\\u29D0': 'RightTriangleBar', '\\u29D0\\u0338': 'NotRightTriangleBar', '\\u29DC': 'iinfin', '\\u29DD': 'infintie', '\\u29DE': 'nvinfin', '\\u29E3': 'eparsl', '\\u29E4': 'smeparsl', '\\u29E5': 'eqvparsl', '\\u29EB': 'lozf', '\\u29F4': 'RuleDelayed', '\\u29F6': 'dsol', '\\u2A00': 'xodot', '\\u2A01': 'xoplus', '\\u2A02': 'xotime', '\\u2A04': 'xuplus', '\\u2A06': 'xsqcup', '\\u2A0D': 'fpartint', '\\u2A10': 'cirfnint', '\\u2A11': 'awint', '\\u2A12': 'rppolint', '\\u2A13': 'scpolint', '\\u2A14': 'npolint', '\\u2A15': 'pointint', '\\u2A16': 'quatint', '\\u2A17': 'intlarhk', '\\u2A22': 'pluscir', '\\u2A23': 'plusacir', '\\u2A24': 'simplus', '\\u2A25': 'plusdu', '\\u2A26': 'plussim', '\\u2A27': 'plustwo', '\\u2A29': 'mcomma', '\\u2A2A': 'minusdu', '\\u2A2D': 'loplus', '\\u2A2E': 'roplus', '\\u2A2F': 'Cross', '\\u2A30': 'timesd', '\\u2A31': 'timesbar', '\\u2A33': 'smashp', '\\u2A34': 'lotimes', '\\u2A35': 'rotimes', '\\u2A36': 'otimesas', '\\u2A37': 'Otimes', '\\u2A38': 'odiv', '\\u2A39': 'triplus', '\\u2A3A': 'triminus', '\\u2A3B': 'tritime', '\\u2A3C': 'iprod', '\\u2A3F': 'amalg', '\\u2A40': 'capdot', '\\u2A42': 'ncup', '\\u2A43': 'ncap', '\\u2A44': 'capand', '\\u2A45': 'cupor', '\\u2A46': 'cupcap', '\\u2A47': 'capcup', '\\u2A48': 'cupbrcap', '\\u2A49': 'capbrcup', '\\u2A4A': 'cupcup', '\\u2A4B': 'capcap', '\\u2A4C': 'ccups', '\\u2A4D': 'ccaps', '\\u2A50': 'ccupssm', '\\u2A53': 'And', '\\u2A54': 'Or', '\\u2A55': 'andand', '\\u2A56': 'oror', '\\u2A57': 'orslope', '\\u2A58': 'andslope', '\\u2A5A': 'andv', '\\u2A5B': 'orv', '\\u2A5C': 'andd', '\\u2A5D': 'ord', '\\u2A5F': 'wedbar', '\\u2A66': 'sdote', '\\u2A6A': 'simdot', '\\u2A6D': 'congdot', '\\u2A6D\\u0338': 'ncongdot', '\\u2A6E': 'easter', '\\u2A6F': 'apacir', '\\u2A70': 'apE', '\\u2A70\\u0338': 'napE', '\\u2A71': 'eplus', '\\u2A72': 'pluse', '\\u2A73': 'Esim', '\\u2A77': 'eDDot', '\\u2A78': 'equivDD', '\\u2A79': 'ltcir', '\\u2A7A': 'gtcir', '\\u2A7B': 'ltquest', '\\u2A7C': 'gtquest', '\\u2A7D': 'les', '\\u2A7D\\u0338': 'nles', '\\u2A7E': 'ges', '\\u2A7E\\u0338': 'nges', '\\u2A7F': 'lesdot', '\\u2A80': 'gesdot', '\\u2A81': 'lesdoto', '\\u2A82': 'gesdoto', '\\u2A83': 'lesdotor', '\\u2A84': 'gesdotol', '\\u2A85': 'lap', '\\u2A86': 'gap', '\\u2A87': 'lne', '\\u2A88': 'gne', '\\u2A89': 'lnap', '\\u2A8A': 'gnap', '\\u2A8B': 'lEg', '\\u2A8C': 'gEl', '\\u2A8D': 'lsime', '\\u2A8E': 'gsime', '\\u2A8F': 'lsimg', '\\u2A90': 'gsiml', '\\u2A91': 'lgE', '\\u2A92': 'glE', '\\u2A93': 'lesges', '\\u2A94': 'gesles', '\\u2A95': 'els', '\\u2A96': 'egs', '\\u2A97': 'elsdot', '\\u2A98': 'egsdot', '\\u2A99': 'el', '\\u2A9A': 'eg', '\\u2A9D': 'siml', '\\u2A9E': 'simg', '\\u2A9F': 'simlE', '\\u2AA0': 'simgE', '\\u2AA1': 'LessLess', '\\u2AA1\\u0338': 'NotNestedLessLess', '\\u2AA2': 'GreaterGreater', '\\u2AA2\\u0338': 'NotNestedGreaterGreater', '\\u2AA4': 'glj', '\\u2AA5': 'gla', '\\u2AA6': 'ltcc', '\\u2AA7': 'gtcc', '\\u2AA8': 'lescc', '\\u2AA9': 'gescc', '\\u2AAA': 'smt', '\\u2AAB': 'lat', '\\u2AAC': 'smte', '\\u2AAC\\uFE00': 'smtes', '\\u2AAD': 'late', '\\u2AAD\\uFE00': 'lates', '\\u2AAE': 'bumpE', '\\u2AAF': 'pre', '\\u2AAF\\u0338': 'npre', '\\u2AB0': 'sce', '\\u2AB0\\u0338': 'nsce', '\\u2AB3': 'prE', '\\u2AB4': 'scE', '\\u2AB5': 'prnE', '\\u2AB6': 'scnE', '\\u2AB7': 'prap', '\\u2AB8': 'scap', '\\u2AB9': 'prnap', '\\u2ABA': 'scnap', '\\u2ABB': 'Pr', '\\u2ABC': 'Sc', '\\u2ABD': 'subdot', '\\u2ABE': 'supdot', '\\u2ABF': 'subplus', '\\u2AC0': 'supplus', '\\u2AC1': 'submult', '\\u2AC2': 'supmult', '\\u2AC3': 'subedot', '\\u2AC4': 'supedot', '\\u2AC5': 'subE', '\\u2AC5\\u0338': 'nsubE', '\\u2AC6': 'supE', '\\u2AC6\\u0338': 'nsupE', '\\u2AC7': 'subsim', '\\u2AC8': 'supsim', '\\u2ACB\\uFE00': 'vsubnE', '\\u2ACB': 'subnE', '\\u2ACC\\uFE00': 'vsupnE', '\\u2ACC': 'supnE', '\\u2ACF': 'csub', '\\u2AD0': 'csup', '\\u2AD1': 'csube', '\\u2AD2': 'csupe', '\\u2AD3': 'subsup', '\\u2AD4': 'supsub', '\\u2AD5': 'subsub', '\\u2AD6': 'supsup', '\\u2AD7': 'suphsub', '\\u2AD8': 'supdsub', '\\u2AD9': 'forkv', '\\u2ADA': 'topfork', '\\u2ADB': 'mlcp', '\\u2AE4': 'Dashv', '\\u2AE6': 'Vdashl', '\\u2AE7': 'Barv', '\\u2AE8': 'vBar', '\\u2AE9': 'vBarv', '\\u2AEB': 'Vbar', '\\u2AEC': 'Not', '\\u2AED': 'bNot', '\\u2AEE': 'rnmid', '\\u2AEF': 'cirmid', '\\u2AF0': 'midcir', '\\u2AF1': 'topcir', '\\u2AF2': 'nhpar', '\\u2AF3': 'parsim', '\\u2AFD': 'parsl', '\\u2AFD\\u20E5': 'nparsl', '\\u266D': 'flat', '\\u266E': 'natur', '\\u266F': 'sharp', '\\xA4': 'curren', '\\xA2': 'cent', '$': 'dollar', '\\xA3': 'pound', '\\xA5': 'yen', '\\u20AC': 'euro', '\\xB9': 'sup1', '\\xBD': 'half', '\\u2153': 'frac13', '\\xBC': 'frac14', '\\u2155': 'frac15', '\\u2159': 'frac16', '\\u215B': 'frac18', '\\xB2': 'sup2', '\\u2154': 'frac23', '\\u2156': 'frac25', '\\xB3': 'sup3', '\\xBE': 'frac34', '\\u2157': 'frac35', '\\u215C': 'frac38', '\\u2158': 'frac45', '\\u215A': 'frac56', '\\u215D': 'frac58', '\\u215E': 'frac78', '\\uD835\\uDCB6': 'ascr', '\\uD835\\uDD52': 'aopf', '\\uD835\\uDD1E': 'afr', '\\uD835\\uDD38': 'Aopf', '\\uD835\\uDD04': 'Afr', '\\uD835\\uDC9C': 'Ascr', '\\xAA': 'ordf', '\\xE1': 'aacute', '\\xC1': 'Aacute', '\\xE0': 'agrave', '\\xC0': 'Agrave', '\\u0103': 'abreve', '\\u0102': 'Abreve', '\\xE2': 'acirc', '\\xC2': 'Acirc', '\\xE5': 'aring', '\\xC5': 'angst', '\\xE4': 'auml', '\\xC4': 'Auml', '\\xE3': 'atilde', '\\xC3': 'Atilde', '\\u0105': 'aogon', '\\u0104': 'Aogon', '\\u0101': 'amacr', '\\u0100': 'Amacr', '\\xE6': 'aelig', '\\xC6': 'AElig', '\\uD835\\uDCB7': 'bscr', '\\uD835\\uDD53': 'bopf', '\\uD835\\uDD1F': 'bfr', '\\uD835\\uDD39': 'Bopf', '\\u212C': 'Bscr', '\\uD835\\uDD05': 'Bfr', '\\uD835\\uDD20': 'cfr', '\\uD835\\uDCB8': 'cscr', '\\uD835\\uDD54': 'copf', '\\u212D': 'Cfr', '\\uD835\\uDC9E': 'Cscr', '\\u2102': 'Copf', '\\u0107': 'cacute', '\\u0106': 'Cacute', '\\u0109': 'ccirc', '\\u0108': 'Ccirc', '\\u010D': 'ccaron', '\\u010C': 'Ccaron', '\\u010B': 'cdot', '\\u010A': 'Cdot', '\\xE7': 'ccedil', '\\xC7': 'Ccedil', '\\u2105': 'incare', '\\uD835\\uDD21': 'dfr', '\\u2146': 'dd', '\\uD835\\uDD55': 'dopf', '\\uD835\\uDCB9': 'dscr', '\\uD835\\uDC9F': 'Dscr', '\\uD835\\uDD07': 'Dfr', '\\u2145': 'DD', '\\uD835\\uDD3B': 'Dopf', '\\u010F': 'dcaron', '\\u010E': 'Dcaron', '\\u0111': 'dstrok', '\\u0110': 'Dstrok', '\\xF0': 'eth', '\\xD0': 'ETH', '\\u2147': 'ee', '\\u212F': 'escr', '\\uD835\\uDD22': 'efr', '\\uD835\\uDD56': 'eopf', '\\u2130': 'Escr', '\\uD835\\uDD08': 'Efr', '\\uD835\\uDD3C': 'Eopf', '\\xE9': 'eacute', '\\xC9': 'Eacute', '\\xE8': 'egrave', '\\xC8': 'Egrave', '\\xEA': 'ecirc', '\\xCA': 'Ecirc', '\\u011B': 'ecaron', '\\u011A': 'Ecaron', '\\xEB': 'euml', '\\xCB': 'Euml', '\\u0117': 'edot', '\\u0116': 'Edot', '\\u0119': 'eogon', '\\u0118': 'Eogon', '\\u0113': 'emacr', '\\u0112': 'Emacr', '\\uD835\\uDD23': 'ffr', '\\uD835\\uDD57': 'fopf', '\\uD835\\uDCBB': 'fscr', '\\uD835\\uDD09': 'Ffr', '\\uD835\\uDD3D': 'Fopf', '\\u2131': 'Fscr', '\\uFB00': 'fflig', '\\uFB03': 'ffilig', '\\uFB04': 'ffllig', '\\uFB01': 'filig', 'fj': 'fjlig', '\\uFB02': 'fllig', '\\u0192': 'fnof', '\\u210A': 'gscr', '\\uD835\\uDD58': 'gopf', '\\uD835\\uDD24': 'gfr', '\\uD835\\uDCA2': 'Gscr', '\\uD835\\uDD3E': 'Gopf', '\\uD835\\uDD0A': 'Gfr', '\\u01F5': 'gacute', '\\u011F': 'gbreve', '\\u011E': 'Gbreve', '\\u011D': 'gcirc', '\\u011C': 'Gcirc', '\\u0121': 'gdot', '\\u0120': 'Gdot', '\\u0122': 'Gcedil', '\\uD835\\uDD25': 'hfr', '\\u210E': 'planckh', '\\uD835\\uDCBD': 'hscr', '\\uD835\\uDD59': 'hopf', '\\u210B': 'Hscr', '\\u210C': 'Hfr', '\\u210D': 'Hopf', '\\u0125': 'hcirc', '\\u0124': 'Hcirc', '\\u210F': 'hbar', '\\u0127': 'hstrok', '\\u0126': 'Hstrok', '\\uD835\\uDD5A': 'iopf', '\\uD835\\uDD26': 'ifr', '\\uD835\\uDCBE': 'iscr', '\\u2148': 'ii', '\\uD835\\uDD40': 'Iopf', '\\u2110': 'Iscr', '\\u2111': 'Im', '\\xED': 'iacute', '\\xCD': 'Iacute', '\\xEC': 'igrave', '\\xCC': 'Igrave', '\\xEE': 'icirc', '\\xCE': 'Icirc', '\\xEF': 'iuml', '\\xCF': 'Iuml', '\\u0129': 'itilde', '\\u0128': 'Itilde', '\\u0130': 'Idot', '\\u012F': 'iogon', '\\u012E': 'Iogon', '\\u012B': 'imacr', '\\u012A': 'Imacr', '\\u0133': 'ijlig', '\\u0132': 'IJlig', '\\u0131': 'imath', '\\uD835\\uDCBF': 'jscr', '\\uD835\\uDD5B': 'jopf', '\\uD835\\uDD27': 'jfr', '\\uD835\\uDCA5': 'Jscr', '\\uD835\\uDD0D': 'Jfr', '\\uD835\\uDD41': 'Jopf', '\\u0135': 'jcirc', '\\u0134': 'Jcirc', '\\u0237': 'jmath', '\\uD835\\uDD5C': 'kopf', '\\uD835\\uDCC0': 'kscr', '\\uD835\\uDD28': 'kfr', '\\uD835\\uDCA6': 'Kscr', '\\uD835\\uDD42': 'Kopf', '\\uD835\\uDD0E': 'Kfr', '\\u0137': 'kcedil', '\\u0136': 'Kcedil', '\\uD835\\uDD29': 'lfr', '\\uD835\\uDCC1': 'lscr', '\\u2113': 'ell', '\\uD835\\uDD5D': 'lopf', '\\u2112': 'Lscr', '\\uD835\\uDD0F': 'Lfr', '\\uD835\\uDD43': 'Lopf', '\\u013A': 'lacute', '\\u0139': 'Lacute', '\\u013E': 'lcaron', '\\u013D': 'Lcaron', '\\u013C': 'lcedil', '\\u013B': 'Lcedil', '\\u0142': 'lstrok', '\\u0141': 'Lstrok', '\\u0140': 'lmidot', '\\u013F': 'Lmidot', '\\uD835\\uDD2A': 'mfr', '\\uD835\\uDD5E': 'mopf', '\\uD835\\uDCC2': 'mscr', '\\uD835\\uDD10': 'Mfr', '\\uD835\\uDD44': 'Mopf', '\\u2133': 'Mscr', '\\uD835\\uDD2B': 'nfr', '\\uD835\\uDD5F': 'nopf', '\\uD835\\uDCC3': 'nscr', '\\u2115': 'Nopf', '\\uD835\\uDCA9': 'Nscr', '\\uD835\\uDD11': 'Nfr', '\\u0144': 'nacute', '\\u0143': 'Nacute', '\\u0148': 'ncaron', '\\u0147': 'Ncaron', '\\xF1': 'ntilde', '\\xD1': 'Ntilde', '\\u0146': 'ncedil', '\\u0145': 'Ncedil', '\\u2116': 'numero', '\\u014B': 'eng', '\\u014A': 'ENG', '\\uD835\\uDD60': 'oopf', '\\uD835\\uDD2C': 'ofr', '\\u2134': 'oscr', '\\uD835\\uDCAA': 'Oscr', '\\uD835\\uDD12': 'Ofr', '\\uD835\\uDD46': 'Oopf', '\\xBA': 'ordm', '\\xF3': 'oacute', '\\xD3': 'Oacute', '\\xF2': 'ograve', '\\xD2': 'Ograve', '\\xF4': 'ocirc', '\\xD4': 'Ocirc', '\\xF6': 'ouml', '\\xD6': 'Ouml', '\\u0151': 'odblac', '\\u0150': 'Odblac', '\\xF5': 'otilde', '\\xD5': 'Otilde', '\\xF8': 'oslash', '\\xD8': 'Oslash', '\\u014D': 'omacr', '\\u014C': 'Omacr', '\\u0153': 'oelig', '\\u0152': 'OElig', '\\uD835\\uDD2D': 'pfr', '\\uD835\\uDCC5': 'pscr', '\\uD835\\uDD61': 'popf', '\\u2119': 'Popf', '\\uD835\\uDD13': 'Pfr', '\\uD835\\uDCAB': 'Pscr', '\\uD835\\uDD62': 'qopf', '\\uD835\\uDD2E': 'qfr', '\\uD835\\uDCC6': 'qscr', '\\uD835\\uDCAC': 'Qscr', '\\uD835\\uDD14': 'Qfr', '\\u211A': 'Qopf', '\\u0138': 'kgreen', '\\uD835\\uDD2F': 'rfr', '\\uD835\\uDD63': 'ropf', '\\uD835\\uDCC7': 'rscr', '\\u211B': 'Rscr', '\\u211C': 'Re', '\\u211D': 'Ropf', '\\u0155': 'racute', '\\u0154': 'Racute', '\\u0159': 'rcaron', '\\u0158': 'Rcaron', '\\u0157': 'rcedil', '\\u0156': 'Rcedil', '\\uD835\\uDD64': 'sopf', '\\uD835\\uDCC8': 'sscr', '\\uD835\\uDD30': 'sfr', '\\uD835\\uDD4A': 'Sopf', '\\uD835\\uDD16': 'Sfr', '\\uD835\\uDCAE': 'Sscr', '\\u24C8': 'oS', '\\u015B': 'sacute', '\\u015A': 'Sacute', '\\u015D': 'scirc', '\\u015C': 'Scirc', '\\u0161': 'scaron', '\\u0160': 'Scaron', '\\u015F': 'scedil', '\\u015E': 'Scedil', '\\xDF': 'szlig', '\\uD835\\uDD31': 'tfr', '\\uD835\\uDCC9': 'tscr', '\\uD835\\uDD65': 'topf', '\\uD835\\uDCAF': 'Tscr', '\\uD835\\uDD17': 'Tfr', '\\uD835\\uDD4B': 'Topf', '\\u0165': 'tcaron', '\\u0164': 'Tcaron', '\\u0163': 'tcedil', '\\u0162': 'Tcedil', '\\u2122': 'trade', '\\u0167': 'tstrok', '\\u0166': 'Tstrok', '\\uD835\\uDCCA': 'uscr', '\\uD835\\uDD66': 'uopf', '\\uD835\\uDD32': 'ufr', '\\uD835\\uDD4C': 'Uopf', '\\uD835\\uDD18': 'Ufr', '\\uD835\\uDCB0': 'Uscr', '\\xFA': 'uacute', '\\xDA': 'Uacute', '\\xF9': 'ugrave', '\\xD9': 'Ugrave', '\\u016D': 'ubreve', '\\u016C': 'Ubreve', '\\xFB': 'ucirc', '\\xDB': 'Ucirc', '\\u016F': 'uring', '\\u016E': 'Uring', '\\xFC': 'uuml', '\\xDC': 'Uuml', '\\u0171': 'udblac', '\\u0170': 'Udblac', '\\u0169': 'utilde', '\\u0168': 'Utilde', '\\u0173': 'uogon', '\\u0172': 'Uogon', '\\u016B': 'umacr', '\\u016A': 'Umacr', '\\uD835\\uDD33': 'vfr', '\\uD835\\uDD67': 'vopf', '\\uD835\\uDCCB': 'vscr', '\\uD835\\uDD19': 'Vfr', '\\uD835\\uDD4D': 'Vopf', '\\uD835\\uDCB1': 'Vscr', '\\uD835\\uDD68': 'wopf', '\\uD835\\uDCCC': 'wscr', '\\uD835\\uDD34': 'wfr', '\\uD835\\uDCB2': 'Wscr', '\\uD835\\uDD4E': 'Wopf', '\\uD835\\uDD1A': 'Wfr', '\\u0175': 'wcirc', '\\u0174': 'Wcirc', '\\uD835\\uDD35': 'xfr', '\\uD835\\uDCCD': 'xscr', '\\uD835\\uDD69': 'xopf', '\\uD835\\uDD4F': 'Xopf', '\\uD835\\uDD1B': 'Xfr', '\\uD835\\uDCB3': 'Xscr', '\\uD835\\uDD36': 'yfr', '\\uD835\\uDCCE': 'yscr', '\\uD835\\uDD6A': 'yopf', '\\uD835\\uDCB4': 'Yscr', '\\uD835\\uDD1C': 'Yfr', '\\uD835\\uDD50': 'Yopf', '\\xFD': 'yacute', '\\xDD': 'Yacute', '\\u0177': 'ycirc', '\\u0176': 'Ycirc', '\\xFF': 'yuml', '\\u0178': 'Yuml', '\\uD835\\uDCCF': 'zscr', '\\uD835\\uDD37': 'zfr', '\\uD835\\uDD6B': 'zopf', '\\u2128': 'Zfr', '\\u2124': 'Zopf', '\\uD835\\uDCB5': 'Zscr', '\\u017A': 'zacute', '\\u0179': 'Zacute', '\\u017E': 'zcaron', '\\u017D': 'Zcaron', '\\u017C': 'zdot', '\\u017B': 'Zdot', '\\u01B5': 'imped', '\\xFE': 'thorn', '\\xDE': 'THORN', '\\u0149': 'napos', '\\u03B1': 'alpha', '\\u0391': 'Alpha', '\\u03B2': 'beta', '\\u0392': 'Beta', '\\u03B3': 'gamma', '\\u0393': 'Gamma', '\\u03B4': 'delta', '\\u0394': 'Delta', '\\u03B5': 'epsi', '\\u03F5': 'epsiv', '\\u0395': 'Epsilon', '\\u03DD': 'gammad', '\\u03DC': 'Gammad', '\\u03B6': 'zeta', '\\u0396': 'Zeta', '\\u03B7': 'eta', '\\u0397': 'Eta', '\\u03B8': 'theta', '\\u03D1': 'thetav', '\\u0398': 'Theta', '\\u03B9': 'iota', '\\u0399': 'Iota', '\\u03BA': 'kappa', '\\u03F0': 'kappav', '\\u039A': 'Kappa', '\\u03BB': 'lambda', '\\u039B': 'Lambda', '\\u03BC': 'mu', '\\xB5': 'micro', '\\u039C': 'Mu', '\\u03BD': 'nu', '\\u039D': 'Nu', '\\u03BE': 'xi', '\\u039E': 'Xi', '\\u03BF': 'omicron', '\\u039F': 'Omicron', '\\u03C0': 'pi', '\\u03D6': 'piv', '\\u03A0': 'Pi', '\\u03C1': 'rho', '\\u03F1': 'rhov', '\\u03A1': 'Rho', '\\u03C3': 'sigma', '\\u03A3': 'Sigma', '\\u03C2': 'sigmaf', '\\u03C4': 'tau', '\\u03A4': 'Tau', '\\u03C5': 'upsi', '\\u03A5': 'Upsilon', '\\u03D2': 'Upsi', '\\u03C6': 'phi', '\\u03D5': 'phiv', '\\u03A6': 'Phi', '\\u03C7': 'chi', '\\u03A7': 'Chi', '\\u03C8': 'psi', '\\u03A8': 'Psi', '\\u03C9': 'omega', '\\u03A9': 'ohm', '\\u0430': 'acy', '\\u0410': 'Acy', '\\u0431': 'bcy', '\\u0411': 'Bcy', '\\u0432': 'vcy', '\\u0412': 'Vcy', '\\u0433': 'gcy', '\\u0413': 'Gcy', '\\u0453': 'gjcy', '\\u0403': 'GJcy', '\\u0434': 'dcy', '\\u0414': 'Dcy', '\\u0452': 'djcy', '\\u0402': 'DJcy', '\\u0435': 'iecy', '\\u0415': 'IEcy', '\\u0451': 'iocy', '\\u0401': 'IOcy', '\\u0454': 'jukcy', '\\u0404': 'Jukcy', '\\u0436': 'zhcy', '\\u0416': 'ZHcy', '\\u0437': 'zcy', '\\u0417': 'Zcy', '\\u0455': 'dscy', '\\u0405': 'DScy', '\\u0438': 'icy', '\\u0418': 'Icy', '\\u0456': 'iukcy', '\\u0406': 'Iukcy', '\\u0457': 'yicy', '\\u0407': 'YIcy', '\\u0439': 'jcy', '\\u0419': 'Jcy', '\\u0458': 'jsercy', '\\u0408': 'Jsercy', '\\u043A': 'kcy', '\\u041A': 'Kcy', '\\u045C': 'kjcy', '\\u040C': 'KJcy', '\\u043B': 'lcy', '\\u041B': 'Lcy', '\\u0459': 'ljcy', '\\u0409': 'LJcy', '\\u043C': 'mcy', '\\u041C': 'Mcy', '\\u043D': 'ncy', '\\u041D': 'Ncy', '\\u045A': 'njcy', '\\u040A': 'NJcy', '\\u043E': 'ocy', '\\u041E': 'Ocy', '\\u043F': 'pcy', '\\u041F': 'Pcy', '\\u0440': 'rcy', '\\u0420': 'Rcy', '\\u0441': 'scy', '\\u0421': 'Scy', '\\u0442': 'tcy', '\\u0422': 'Tcy', '\\u045B': 'tshcy', '\\u040B': 'TSHcy', '\\u0443': 'ucy', '\\u0423': 'Ucy', '\\u045E': 'ubrcy', '\\u040E': 'Ubrcy', '\\u0444': 'fcy', '\\u0424': 'Fcy', '\\u0445': 'khcy', '\\u0425': 'KHcy', '\\u0446': 'tscy', '\\u0426': 'TScy', '\\u0447': 'chcy', '\\u0427': 'CHcy', '\\u045F': 'dzcy', '\\u040F': 'DZcy', '\\u0448': 'shcy', '\\u0428': 'SHcy', '\\u0449': 'shchcy', '\\u0429': 'SHCHcy', '\\u044A': 'hardcy', '\\u042A': 'HARDcy', '\\u044B': 'ycy', '\\u042B': 'Ycy', '\\u044C': 'softcy', '\\u042C': 'SOFTcy', '\\u044D': 'ecy', '\\u042D': 'Ecy', '\\u044E': 'yucy', '\\u042E': 'YUcy', '\\u044F': 'yacy', '\\u042F': 'YAcy', '\\u2135': 'aleph', '\\u2136': 'beth', '\\u2137': 'gimel', '\\u2138': 'daleth' };\n\n\tvar regexEscape = /[\"&'<>`]/g;\n\tvar escapeMap = {\n\t\t'\"': '&quot;',\n\t\t'&': '&amp;',\n\t\t'\\'': '&#x27;',\n\t\t'<': '&lt;',\n\t\t// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the\n\t\t// following is not strictly necessary unless it’s part of a tag or an\n\t\t// unquoted attribute value. We’re only escaping it to support those\n\t\t// situations, and for XML support.\n\t\t'>': '&gt;',\n\t\t// In Internet Explorer ≤ 8, the backtick character can be used\n\t\t// to break out of (un)quoted attribute values or HTML comments.\n\t\t// See http://html5sec.org/#102, http://html5sec.org/#108, and\n\t\t// http://html5sec.org/#133.\n\t\t'`': '&#x60;'\n\t};\n\n\tvar regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;\n\tvar regexInvalidRawCodePoint = /[\\0-\\x08\\x0B\\x0E-\\x1F\\x7F-\\x9F\\uFDD0-\\uFDEF\\uFFFE\\uFFFF]|[\\uD83F\\uD87F\\uD8BF\\uD8FF\\uD93F\\uD97F\\uD9BF\\uD9FF\\uDA3F\\uDA7F\\uDABF\\uDAFF\\uDB3F\\uDB7F\\uDBBF\\uDBFF][\\uDFFE\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/;\n\tvar regexDecode = /&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)([=a-zA-Z0-9])?/g;\n\tvar decodeMap = { 'aacute': '\\xE1', 'Aacute': '\\xC1', 'abreve': '\\u0103', 'Abreve': '\\u0102', 'ac': '\\u223E', 'acd': '\\u223F', 'acE': '\\u223E\\u0333', 'acirc': '\\xE2', 'Acirc': '\\xC2', 'acute': '\\xB4', 'acy': '\\u0430', 'Acy': '\\u0410', 'aelig': '\\xE6', 'AElig': '\\xC6', 'af': '\\u2061', 'afr': '\\uD835\\uDD1E', 'Afr': '\\uD835\\uDD04', 'agrave': '\\xE0', 'Agrave': '\\xC0', 'alefsym': '\\u2135', 'aleph': '\\u2135', 'alpha': '\\u03B1', 'Alpha': '\\u0391', 'amacr': '\\u0101', 'Amacr': '\\u0100', 'amalg': '\\u2A3F', 'amp': '&', 'AMP': '&', 'and': '\\u2227', 'And': '\\u2A53', 'andand': '\\u2A55', 'andd': '\\u2A5C', 'andslope': '\\u2A58', 'andv': '\\u2A5A', 'ang': '\\u2220', 'ange': '\\u29A4', 'angle': '\\u2220', 'angmsd': '\\u2221', 'angmsdaa': '\\u29A8', 'angmsdab': '\\u29A9', 'angmsdac': '\\u29AA', 'angmsdad': '\\u29AB', 'angmsdae': '\\u29AC', 'angmsdaf': '\\u29AD', 'angmsdag': '\\u29AE', 'angmsdah': '\\u29AF', 'angrt': '\\u221F', 'angrtvb': '\\u22BE', 'angrtvbd': '\\u299D', 'angsph': '\\u2222', 'angst': '\\xC5', 'angzarr': '\\u237C', 'aogon': '\\u0105', 'Aogon': '\\u0104', 'aopf': '\\uD835\\uDD52', 'Aopf': '\\uD835\\uDD38', 'ap': '\\u2248', 'apacir': '\\u2A6F', 'ape': '\\u224A', 'apE': '\\u2A70', 'apid': '\\u224B', 'apos': '\\'', 'ApplyFunction': '\\u2061', 'approx': '\\u2248', 'approxeq': '\\u224A', 'aring': '\\xE5', 'Aring': '\\xC5', 'ascr': '\\uD835\\uDCB6', 'Ascr': '\\uD835\\uDC9C', 'Assign': '\\u2254', 'ast': '*', 'asymp': '\\u2248', 'asympeq': '\\u224D', 'atilde': '\\xE3', 'Atilde': '\\xC3', 'auml': '\\xE4', 'Auml': '\\xC4', 'awconint': '\\u2233', 'awint': '\\u2A11', 'backcong': '\\u224C', 'backepsilon': '\\u03F6', 'backprime': '\\u2035', 'backsim': '\\u223D', 'backsimeq': '\\u22CD', 'Backslash': '\\u2216', 'Barv': '\\u2AE7', 'barvee': '\\u22BD', 'barwed': '\\u2305', 'Barwed': '\\u2306', 'barwedge': '\\u2305', 'bbrk': '\\u23B5', 'bbrktbrk': '\\u23B6', 'bcong': '\\u224C', 'bcy': '\\u0431', 'Bcy': '\\u0411', 'bdquo': '\\u201E', 'becaus': '\\u2235', 'because': '\\u2235', 'Because': '\\u2235', 'bemptyv': '\\u29B0', 'bepsi': '\\u03F6', 'bernou': '\\u212C', 'Bernoullis': '\\u212C', 'beta': '\\u03B2', 'Beta': '\\u0392', 'beth': '\\u2136', 'between': '\\u226C', 'bfr': '\\uD835\\uDD1F', 'Bfr': '\\uD835\\uDD05', 'bigcap': '\\u22C2', 'bigcirc': '\\u25EF', 'bigcup': '\\u22C3', 'bigodot': '\\u2A00', 'bigoplus': '\\u2A01', 'bigotimes': '\\u2A02', 'bigsqcup': '\\u2A06', 'bigstar': '\\u2605', 'bigtriangledown': '\\u25BD', 'bigtriangleup': '\\u25B3', 'biguplus': '\\u2A04', 'bigvee': '\\u22C1', 'bigwedge': '\\u22C0', 'bkarow': '\\u290D', 'blacklozenge': '\\u29EB', 'blacksquare': '\\u25AA', 'blacktriangle': '\\u25B4', 'blacktriangledown': '\\u25BE', 'blacktriangleleft': '\\u25C2', 'blacktriangleright': '\\u25B8', 'blank': '\\u2423', 'blk12': '\\u2592', 'blk14': '\\u2591', 'blk34': '\\u2593', 'block': '\\u2588', 'bne': '=\\u20E5', 'bnequiv': '\\u2261\\u20E5', 'bnot': '\\u2310', 'bNot': '\\u2AED', 'bopf': '\\uD835\\uDD53', 'Bopf': '\\uD835\\uDD39', 'bot': '\\u22A5', 'bottom': '\\u22A5', 'bowtie': '\\u22C8', 'boxbox': '\\u29C9', 'boxdl': '\\u2510', 'boxdL': '\\u2555', 'boxDl': '\\u2556', 'boxDL': '\\u2557', 'boxdr': '\\u250C', 'boxdR': '\\u2552', 'boxDr': '\\u2553', 'boxDR': '\\u2554', 'boxh': '\\u2500', 'boxH': '\\u2550', 'boxhd': '\\u252C', 'boxhD': '\\u2565', 'boxHd': '\\u2564', 'boxHD': '\\u2566', 'boxhu': '\\u2534', 'boxhU': '\\u2568', 'boxHu': '\\u2567', 'boxHU': '\\u2569', 'boxminus': '\\u229F', 'boxplus': '\\u229E', 'boxtimes': '\\u22A0', 'boxul': '\\u2518', 'boxuL': '\\u255B', 'boxUl': '\\u255C', 'boxUL': '\\u255D', 'boxur': '\\u2514', 'boxuR': '\\u2558', 'boxUr': '\\u2559', 'boxUR': '\\u255A', 'boxv': '\\u2502', 'boxV': '\\u2551', 'boxvh': '\\u253C', 'boxvH': '\\u256A', 'boxVh': '\\u256B', 'boxVH': '\\u256C', 'boxvl': '\\u2524', 'boxvL': '\\u2561', 'boxVl': '\\u2562', 'boxVL': '\\u2563', 'boxvr': '\\u251C', 'boxvR': '\\u255E', 'boxVr': '\\u255F', 'boxVR': '\\u2560', 'bprime': '\\u2035', 'breve': '\\u02D8', 'Breve': '\\u02D8', 'brvbar': '\\xA6', 'bscr': '\\uD835\\uDCB7', 'Bscr': '\\u212C', 'bsemi': '\\u204F', 'bsim': '\\u223D', 'bsime': '\\u22CD', 'bsol': '\\\\', 'bsolb': '\\u29C5', 'bsolhsub': '\\u27C8', 'bull': '\\u2022', 'bullet': '\\u2022', 'bump': '\\u224E', 'bumpe': '\\u224F', 'bumpE': '\\u2AAE', 'bumpeq': '\\u224F', 'Bumpeq': '\\u224E', 'cacute': '\\u0107', 'Cacute': '\\u0106', 'cap': '\\u2229', 'Cap': '\\u22D2', 'capand': '\\u2A44', 'capbrcup': '\\u2A49', 'capcap': '\\u2A4B', 'capcup': '\\u2A47', 'capdot': '\\u2A40', 'CapitalDifferentialD': '\\u2145', 'caps': '\\u2229\\uFE00', 'caret': '\\u2041', 'caron': '\\u02C7', 'Cayleys': '\\u212D', 'ccaps': '\\u2A4D', 'ccaron': '\\u010D', 'Ccaron': '\\u010C', 'ccedil': '\\xE7', 'Ccedil': '\\xC7', 'ccirc': '\\u0109', 'Ccirc': '\\u0108', 'Cconint': '\\u2230', 'ccups': '\\u2A4C', 'ccupssm': '\\u2A50', 'cdot': '\\u010B', 'Cdot': '\\u010A', 'cedil': '\\xB8', 'Cedilla': '\\xB8', 'cemptyv': '\\u29B2', 'cent': '\\xA2', 'centerdot': '\\xB7', 'CenterDot': '\\xB7', 'cfr': '\\uD835\\uDD20', 'Cfr': '\\u212D', 'chcy': '\\u0447', 'CHcy': '\\u0427', 'check': '\\u2713', 'checkmark': '\\u2713', 'chi': '\\u03C7', 'Chi': '\\u03A7', 'cir': '\\u25CB', 'circ': '\\u02C6', 'circeq': '\\u2257', 'circlearrowleft': '\\u21BA', 'circlearrowright': '\\u21BB', 'circledast': '\\u229B', 'circledcirc': '\\u229A', 'circleddash': '\\u229D', 'CircleDot': '\\u2299', 'circledR': '\\xAE', 'circledS': '\\u24C8', 'CircleMinus': '\\u2296', 'CirclePlus': '\\u2295', 'CircleTimes': '\\u2297', 'cire': '\\u2257', 'cirE': '\\u29C3', 'cirfnint': '\\u2A10', 'cirmid': '\\u2AEF', 'cirscir': '\\u29C2', 'ClockwiseContourIntegral': '\\u2232', 'CloseCurlyDoubleQuote': '\\u201D', 'CloseCurlyQuote': '\\u2019', 'clubs': '\\u2663', 'clubsuit': '\\u2663', 'colon': ':', 'Colon': '\\u2237', 'colone': '\\u2254', 'Colone': '\\u2A74', 'coloneq': '\\u2254', 'comma': ',', 'commat': '@', 'comp': '\\u2201', 'compfn': '\\u2218', 'complement': '\\u2201', 'complexes': '\\u2102', 'cong': '\\u2245', 'congdot': '\\u2A6D', 'Congruent': '\\u2261', 'conint': '\\u222E', 'Conint': '\\u222F', 'ContourIntegral': '\\u222E', 'copf': '\\uD835\\uDD54', 'Copf': '\\u2102', 'coprod': '\\u2210', 'Coproduct': '\\u2210', 'copy': '\\xA9', 'COPY': '\\xA9', 'copysr': '\\u2117', 'CounterClockwiseContourIntegral': '\\u2233', 'crarr': '\\u21B5', 'cross': '\\u2717', 'Cross': '\\u2A2F', 'cscr': '\\uD835\\uDCB8', 'Cscr': '\\uD835\\uDC9E', 'csub': '\\u2ACF', 'csube': '\\u2AD1', 'csup': '\\u2AD0', 'csupe': '\\u2AD2', 'ctdot': '\\u22EF', 'cudarrl': '\\u2938', 'cudarrr': '\\u2935', 'cuepr': '\\u22DE', 'cuesc': '\\u22DF', 'cularr': '\\u21B6', 'cularrp': '\\u293D', 'cup': '\\u222A', 'Cup': '\\u22D3', 'cupbrcap': '\\u2A48', 'cupcap': '\\u2A46', 'CupCap': '\\u224D', 'cupcup': '\\u2A4A', 'cupdot': '\\u228D', 'cupor': '\\u2A45', 'cups': '\\u222A\\uFE00', 'curarr': '\\u21B7', 'curarrm': '\\u293C', 'curlyeqprec': '\\u22DE', 'curlyeqsucc': '\\u22DF', 'curlyvee': '\\u22CE', 'curlywedge': '\\u22CF', 'curren': '\\xA4', 'curvearrowleft': '\\u21B6', 'curvearrowright': '\\u21B7', 'cuvee': '\\u22CE', 'cuwed': '\\u22CF', 'cwconint': '\\u2232', 'cwint': '\\u2231', 'cylcty': '\\u232D', 'dagger': '\\u2020', 'Dagger': '\\u2021', 'daleth': '\\u2138', 'darr': '\\u2193', 'dArr': '\\u21D3', 'Darr': '\\u21A1', 'dash': '\\u2010', 'dashv': '\\u22A3', 'Dashv': '\\u2AE4', 'dbkarow': '\\u290F', 'dblac': '\\u02DD', 'dcaron': '\\u010F', 'Dcaron': '\\u010E', 'dcy': '\\u0434', 'Dcy': '\\u0414', 'dd': '\\u2146', 'DD': '\\u2145', 'ddagger': '\\u2021', 'ddarr': '\\u21CA', 'DDotrahd': '\\u2911', 'ddotseq': '\\u2A77', 'deg': '\\xB0', 'Del': '\\u2207', 'delta': '\\u03B4', 'Delta': '\\u0394', 'demptyv': '\\u29B1', 'dfisht': '\\u297F', 'dfr': '\\uD835\\uDD21', 'Dfr': '\\uD835\\uDD07', 'dHar': '\\u2965', 'dharl': '\\u21C3', 'dharr': '\\u21C2', 'DiacriticalAcute': '\\xB4', 'DiacriticalDot': '\\u02D9', 'DiacriticalDoubleAcute': '\\u02DD', 'DiacriticalGrave': '`', 'DiacriticalTilde': '\\u02DC', 'diam': '\\u22C4', 'diamond': '\\u22C4', 'Diamond': '\\u22C4', 'diamondsuit': '\\u2666', 'diams': '\\u2666', 'die': '\\xA8', 'DifferentialD': '\\u2146', 'digamma': '\\u03DD', 'disin': '\\u22F2', 'div': '\\xF7', 'divide': '\\xF7', 'divideontimes': '\\u22C7', 'divonx': '\\u22C7', 'djcy': '\\u0452', 'DJcy': '\\u0402', 'dlcorn': '\\u231E', 'dlcrop': '\\u230D', 'dollar': '$', 'dopf': '\\uD835\\uDD55', 'Dopf': '\\uD835\\uDD3B', 'dot': '\\u02D9', 'Dot': '\\xA8', 'DotDot': '\\u20DC', 'doteq': '\\u2250', 'doteqdot': '\\u2251', 'DotEqual': '\\u2250', 'dotminus': '\\u2238', 'dotplus': '\\u2214', 'dotsquare': '\\u22A1', 'doublebarwedge': '\\u2306', 'DoubleContourIntegral': '\\u222F', 'DoubleDot': '\\xA8', 'DoubleDownArrow': '\\u21D3', 'DoubleLeftArrow': '\\u21D0', 'DoubleLeftRightArrow': '\\u21D4', 'DoubleLeftTee': '\\u2AE4', 'DoubleLongLeftArrow': '\\u27F8', 'DoubleLongLeftRightArrow': '\\u27FA', 'DoubleLongRightArrow': '\\u27F9', 'DoubleRightArrow': '\\u21D2', 'DoubleRightTee': '\\u22A8', 'DoubleUpArrow': '\\u21D1', 'DoubleUpDownArrow': '\\u21D5', 'DoubleVerticalBar': '\\u2225', 'downarrow': '\\u2193', 'Downarrow': '\\u21D3', 'DownArrow': '\\u2193', 'DownArrowBar': '\\u2913', 'DownArrowUpArrow': '\\u21F5', 'DownBreve': '\\u0311', 'downdownarrows': '\\u21CA', 'downharpoonleft': '\\u21C3', 'downharpoonright': '\\u21C2', 'DownLeftRightVector': '\\u2950', 'DownLeftTeeVector': '\\u295E', 'DownLeftVector': '\\u21BD', 'DownLeftVectorBar': '\\u2956', 'DownRightTeeVector': '\\u295F', 'DownRightVector': '\\u21C1', 'DownRightVectorBar': '\\u2957', 'DownTee': '\\u22A4', 'DownTeeArrow': '\\u21A7', 'drbkarow': '\\u2910', 'drcorn': '\\u231F', 'drcrop': '\\u230C', 'dscr': '\\uD835\\uDCB9', 'Dscr': '\\uD835\\uDC9F', 'dscy': '\\u0455', 'DScy': '\\u0405', 'dsol': '\\u29F6', 'dstrok': '\\u0111', 'Dstrok': '\\u0110', 'dtdot': '\\u22F1', 'dtri': '\\u25BF', 'dtrif': '\\u25BE', 'duarr': '\\u21F5', 'duhar': '\\u296F', 'dwangle': '\\u29A6', 'dzcy': '\\u045F', 'DZcy': '\\u040F', 'dzigrarr': '\\u27FF', 'eacute': '\\xE9', 'Eacute': '\\xC9', 'easter': '\\u2A6E', 'ecaron': '\\u011B', 'Ecaron': '\\u011A', 'ecir': '\\u2256', 'ecirc': '\\xEA', 'Ecirc': '\\xCA', 'ecolon': '\\u2255', 'ecy': '\\u044D', 'Ecy': '\\u042D', 'eDDot': '\\u2A77', 'edot': '\\u0117', 'eDot': '\\u2251', 'Edot': '\\u0116', 'ee': '\\u2147', 'efDot': '\\u2252', 'efr': '\\uD835\\uDD22', 'Efr': '\\uD835\\uDD08', 'eg': '\\u2A9A', 'egrave': '\\xE8', 'Egrave': '\\xC8', 'egs': '\\u2A96', 'egsdot': '\\u2A98', 'el': '\\u2A99', 'Element': '\\u2208', 'elinters': '\\u23E7', 'ell': '\\u2113', 'els': '\\u2A95', 'elsdot': '\\u2A97', 'emacr': '\\u0113', 'Emacr': '\\u0112', 'empty': '\\u2205', 'emptyset': '\\u2205', 'EmptySmallSquare': '\\u25FB', 'emptyv': '\\u2205', 'EmptyVerySmallSquare': '\\u25AB', 'emsp': '\\u2003', 'emsp13': '\\u2004', 'emsp14': '\\u2005', 'eng': '\\u014B', 'ENG': '\\u014A', 'ensp': '\\u2002', 'eogon': '\\u0119', 'Eogon': '\\u0118', 'eopf': '\\uD835\\uDD56', 'Eopf': '\\uD835\\uDD3C', 'epar': '\\u22D5', 'eparsl': '\\u29E3', 'eplus': '\\u2A71', 'epsi': '\\u03B5', 'epsilon': '\\u03B5', 'Epsilon': '\\u0395', 'epsiv': '\\u03F5', 'eqcirc': '\\u2256', 'eqcolon': '\\u2255', 'eqsim': '\\u2242', 'eqslantgtr': '\\u2A96', 'eqslantless': '\\u2A95', 'Equal': '\\u2A75', 'equals': '=', 'EqualTilde': '\\u2242', 'equest': '\\u225F', 'Equilibrium': '\\u21CC', 'equiv': '\\u2261', 'equivDD': '\\u2A78', 'eqvparsl': '\\u29E5', 'erarr': '\\u2971', 'erDot': '\\u2253', 'escr': '\\u212F', 'Escr': '\\u2130', 'esdot': '\\u2250', 'esim': '\\u2242', 'Esim': '\\u2A73', 'eta': '\\u03B7', 'Eta': '\\u0397', 'eth': '\\xF0', 'ETH': '\\xD0', 'euml': '\\xEB', 'Euml': '\\xCB', 'euro': '\\u20AC', 'excl': '!', 'exist': '\\u2203', 'Exists': '\\u2203', 'expectation': '\\u2130', 'exponentiale': '\\u2147', 'ExponentialE': '\\u2147', 'fallingdotseq': '\\u2252', 'fcy': '\\u0444', 'Fcy': '\\u0424', 'female': '\\u2640', 'ffilig': '\\uFB03', 'fflig': '\\uFB00', 'ffllig': '\\uFB04', 'ffr': '\\uD835\\uDD23', 'Ffr': '\\uD835\\uDD09', 'filig': '\\uFB01', 'FilledSmallSquare': '\\u25FC', 'FilledVerySmallSquare': '\\u25AA', 'fjlig': 'fj', 'flat': '\\u266D', 'fllig': '\\uFB02', 'fltns': '\\u25B1', 'fnof': '\\u0192', 'fopf': '\\uD835\\uDD57', 'Fopf': '\\uD835\\uDD3D', 'forall': '\\u2200', 'ForAll': '\\u2200', 'fork': '\\u22D4', 'forkv': '\\u2AD9', 'Fouriertrf': '\\u2131', 'fpartint': '\\u2A0D', 'frac12': '\\xBD', 'frac13': '\\u2153', 'frac14': '\\xBC', 'frac15': '\\u2155', 'frac16': '\\u2159', 'frac18': '\\u215B', 'frac23': '\\u2154', 'frac25': '\\u2156', 'frac34': '\\xBE', 'frac35': '\\u2157', 'frac38': '\\u215C', 'frac45': '\\u2158', 'frac56': '\\u215A', 'frac58': '\\u215D', 'frac78': '\\u215E', 'frasl': '\\u2044', 'frown': '\\u2322', 'fscr': '\\uD835\\uDCBB', 'Fscr': '\\u2131', 'gacute': '\\u01F5', 'gamma': '\\u03B3', 'Gamma': '\\u0393', 'gammad': '\\u03DD', 'Gammad': '\\u03DC', 'gap': '\\u2A86', 'gbreve': '\\u011F', 'Gbreve': '\\u011E', 'Gcedil': '\\u0122', 'gcirc': '\\u011D', 'Gcirc': '\\u011C', 'gcy': '\\u0433', 'Gcy': '\\u0413', 'gdot': '\\u0121', 'Gdot': '\\u0120', 'ge': '\\u2265', 'gE': '\\u2267', 'gel': '\\u22DB', 'gEl': '\\u2A8C', 'geq': '\\u2265', 'geqq': '\\u2267', 'geqslant': '\\u2A7E', 'ges': '\\u2A7E', 'gescc': '\\u2AA9', 'gesdot': '\\u2A80', 'gesdoto': '\\u2A82', 'gesdotol': '\\u2A84', 'gesl': '\\u22DB\\uFE00', 'gesles': '\\u2A94', 'gfr': '\\uD835\\uDD24', 'Gfr': '\\uD835\\uDD0A', 'gg': '\\u226B', 'Gg': '\\u22D9', 'ggg': '\\u22D9', 'gimel': '\\u2137', 'gjcy': '\\u0453', 'GJcy': '\\u0403', 'gl': '\\u2277', 'gla': '\\u2AA5', 'glE': '\\u2A92', 'glj': '\\u2AA4', 'gnap': '\\u2A8A', 'gnapprox': '\\u2A8A', 'gne': '\\u2A88', 'gnE': '\\u2269', 'gneq': '\\u2A88', 'gneqq': '\\u2269', 'gnsim': '\\u22E7', 'gopf': '\\uD835\\uDD58', 'Gopf': '\\uD835\\uDD3E', 'grave': '`', 'GreaterEqual': '\\u2265', 'GreaterEqualLess': '\\u22DB', 'GreaterFullEqual': '\\u2267', 'GreaterGreater': '\\u2AA2', 'GreaterLess': '\\u2277', 'GreaterSlantEqual': '\\u2A7E', 'GreaterTilde': '\\u2273', 'gscr': '\\u210A', 'Gscr': '\\uD835\\uDCA2', 'gsim': '\\u2273', 'gsime': '\\u2A8E', 'gsiml': '\\u2A90', 'gt': '>', 'Gt': '\\u226B', 'GT': '>', 'gtcc': '\\u2AA7', 'gtcir': '\\u2A7A', 'gtdot': '\\u22D7', 'gtlPar': '\\u2995', 'gtquest': '\\u2A7C', 'gtrapprox': '\\u2A86', 'gtrarr': '\\u2978', 'gtrdot': '\\u22D7', 'gtreqless': '\\u22DB', 'gtreqqless': '\\u2A8C', 'gtrless': '\\u2277', 'gtrsim': '\\u2273', 'gvertneqq': '\\u2269\\uFE00', 'gvnE': '\\u2269\\uFE00', 'Hacek': '\\u02C7', 'hairsp': '\\u200A', 'half': '\\xBD', 'hamilt': '\\u210B', 'hardcy': '\\u044A', 'HARDcy': '\\u042A', 'harr': '\\u2194', 'hArr': '\\u21D4', 'harrcir': '\\u2948', 'harrw': '\\u21AD', 'Hat': '^', 'hbar': '\\u210F', 'hcirc': '\\u0125', 'Hcirc': '\\u0124', 'hearts': '\\u2665', 'heartsuit': '\\u2665', 'hellip': '\\u2026', 'hercon': '\\u22B9', 'hfr': '\\uD835\\uDD25', 'Hfr': '\\u210C', 'HilbertSpace': '\\u210B', 'hksearow': '\\u2925', 'hkswarow': '\\u2926', 'hoarr': '\\u21FF', 'homtht': '\\u223B', 'hookleftarrow': '\\u21A9', 'hookrightarrow': '\\u21AA', 'hopf': '\\uD835\\uDD59', 'Hopf': '\\u210D', 'horbar': '\\u2015', 'HorizontalLine': '\\u2500', 'hscr': '\\uD835\\uDCBD', 'Hscr': '\\u210B', 'hslash': '\\u210F', 'hstrok': '\\u0127', 'Hstrok': '\\u0126', 'HumpDownHump': '\\u224E', 'HumpEqual': '\\u224F', 'hybull': '\\u2043', 'hyphen': '\\u2010', 'iacute': '\\xED', 'Iacute': '\\xCD', 'ic': '\\u2063', 'icirc': '\\xEE', 'Icirc': '\\xCE', 'icy': '\\u0438', 'Icy': '\\u0418', 'Idot': '\\u0130', 'iecy': '\\u0435', 'IEcy': '\\u0415', 'iexcl': '\\xA1', 'iff': '\\u21D4', 'ifr': '\\uD835\\uDD26', 'Ifr': '\\u2111', 'igrave': '\\xEC', 'Igrave': '\\xCC', 'ii': '\\u2148', 'iiiint': '\\u2A0C', 'iiint': '\\u222D', 'iinfin': '\\u29DC', 'iiota': '\\u2129', 'ijlig': '\\u0133', 'IJlig': '\\u0132', 'Im': '\\u2111', 'imacr': '\\u012B', 'Imacr': '\\u012A', 'image': '\\u2111', 'ImaginaryI': '\\u2148', 'imagline': '\\u2110', 'imagpart': '\\u2111', 'imath': '\\u0131', 'imof': '\\u22B7', 'imped': '\\u01B5', 'Implies': '\\u21D2', 'in': '\\u2208', 'incare': '\\u2105', 'infin': '\\u221E', 'infintie': '\\u29DD', 'inodot': '\\u0131', 'int': '\\u222B', 'Int': '\\u222C', 'intcal': '\\u22BA', 'integers': '\\u2124', 'Integral': '\\u222B', 'intercal': '\\u22BA', 'Intersection': '\\u22C2', 'intlarhk': '\\u2A17', 'intprod': '\\u2A3C', 'InvisibleComma': '\\u2063', 'InvisibleTimes': '\\u2062', 'iocy': '\\u0451', 'IOcy': '\\u0401', 'iogon': '\\u012F', 'Iogon': '\\u012E', 'iopf': '\\uD835\\uDD5A', 'Iopf': '\\uD835\\uDD40', 'iota': '\\u03B9', 'Iota': '\\u0399', 'iprod': '\\u2A3C', 'iquest': '\\xBF', 'iscr': '\\uD835\\uDCBE', 'Iscr': '\\u2110', 'isin': '\\u2208', 'isindot': '\\u22F5', 'isinE': '\\u22F9', 'isins': '\\u22F4', 'isinsv': '\\u22F3', 'isinv': '\\u2208', 'it': '\\u2062', 'itilde': '\\u0129', 'Itilde': '\\u0128', 'iukcy': '\\u0456', 'Iukcy': '\\u0406', 'iuml': '\\xEF', 'Iuml': '\\xCF', 'jcirc': '\\u0135', 'Jcirc': '\\u0134', 'jcy': '\\u0439', 'Jcy': '\\u0419', 'jfr': '\\uD835\\uDD27', 'Jfr': '\\uD835\\uDD0D', 'jmath': '\\u0237', 'jopf': '\\uD835\\uDD5B', 'Jopf': '\\uD835\\uDD41', 'jscr': '\\uD835\\uDCBF', 'Jscr': '\\uD835\\uDCA5', 'jsercy': '\\u0458', 'Jsercy': '\\u0408', 'jukcy': '\\u0454', 'Jukcy': '\\u0404', 'kappa': '\\u03BA', 'Kappa': '\\u039A', 'kappav': '\\u03F0', 'kcedil': '\\u0137', 'Kcedil': '\\u0136', 'kcy': '\\u043A', 'Kcy': '\\u041A', 'kfr': '\\uD835\\uDD28', 'Kfr': '\\uD835\\uDD0E', 'kgreen': '\\u0138', 'khcy': '\\u0445', 'KHcy': '\\u0425', 'kjcy': '\\u045C', 'KJcy': '\\u040C', 'kopf': '\\uD835\\uDD5C', 'Kopf': '\\uD835\\uDD42', 'kscr': '\\uD835\\uDCC0', 'Kscr': '\\uD835\\uDCA6', 'lAarr': '\\u21DA', 'lacute': '\\u013A', 'Lacute': '\\u0139', 'laemptyv': '\\u29B4', 'lagran': '\\u2112', 'lambda': '\\u03BB', 'Lambda': '\\u039B', 'lang': '\\u27E8', 'Lang': '\\u27EA', 'langd': '\\u2991', 'langle': '\\u27E8', 'lap': '\\u2A85', 'Laplacetrf': '\\u2112', 'laquo': '\\xAB', 'larr': '\\u2190', 'lArr': '\\u21D0', 'Larr': '\\u219E', 'larrb': '\\u21E4', 'larrbfs': '\\u291F', 'larrfs': '\\u291D', 'larrhk': '\\u21A9', 'larrlp': '\\u21AB', 'larrpl': '\\u2939', 'larrsim': '\\u2973', 'larrtl': '\\u21A2', 'lat': '\\u2AAB', 'latail': '\\u2919', 'lAtail': '\\u291B', 'late': '\\u2AAD', 'lates': '\\u2AAD\\uFE00', 'lbarr': '\\u290C', 'lBarr': '\\u290E', 'lbbrk': '\\u2772', 'lbrace': '{', 'lbrack': '[', 'lbrke': '\\u298B', 'lbrksld': '\\u298F', 'lbrkslu': '\\u298D', 'lcaron': '\\u013E', 'Lcaron': '\\u013D', 'lcedil': '\\u013C', 'Lcedil': '\\u013B', 'lceil': '\\u2308', 'lcub': '{', 'lcy': '\\u043B', 'Lcy': '\\u041B', 'ldca': '\\u2936', 'ldquo': '\\u201C', 'ldquor': '\\u201E', 'ldrdhar': '\\u2967', 'ldrushar': '\\u294B', 'ldsh': '\\u21B2', 'le': '\\u2264', 'lE': '\\u2266', 'LeftAngleBracket': '\\u27E8', 'leftarrow': '\\u2190', 'Leftarrow': '\\u21D0', 'LeftArrow': '\\u2190', 'LeftArrowBar': '\\u21E4', 'LeftArrowRightArrow': '\\u21C6', 'leftarrowtail': '\\u21A2', 'LeftCeiling': '\\u2308', 'LeftDoubleBracket': '\\u27E6', 'LeftDownTeeVector': '\\u2961', 'LeftDownVector': '\\u21C3', 'LeftDownVectorBar': '\\u2959', 'LeftFloor': '\\u230A', 'leftharpoondown': '\\u21BD', 'leftharpoonup': '\\u21BC', 'leftleftarrows': '\\u21C7', 'leftrightarrow': '\\u2194', 'Leftrightarrow': '\\u21D4', 'LeftRightArrow': '\\u2194', 'leftrightarrows': '\\u21C6', 'leftrightharpoons': '\\u21CB', 'leftrightsquigarrow': '\\u21AD', 'LeftRightVector': '\\u294E', 'LeftTee': '\\u22A3', 'LeftTeeArrow': '\\u21A4', 'LeftTeeVector': '\\u295A', 'leftthreetimes': '\\u22CB', 'LeftTriangle': '\\u22B2', 'LeftTriangleBar': '\\u29CF', 'LeftTriangleEqual': '\\u22B4', 'LeftUpDownVector': '\\u2951', 'LeftUpTeeVector': '\\u2960', 'LeftUpVector': '\\u21BF', 'LeftUpVectorBar': '\\u2958', 'LeftVector': '\\u21BC', 'LeftVectorBar': '\\u2952', 'leg': '\\u22DA', 'lEg': '\\u2A8B', 'leq': '\\u2264', 'leqq': '\\u2266', 'leqslant': '\\u2A7D', 'les': '\\u2A7D', 'lescc': '\\u2AA8', 'lesdot': '\\u2A7F', 'lesdoto': '\\u2A81', 'lesdotor': '\\u2A83', 'lesg': '\\u22DA\\uFE00', 'lesges': '\\u2A93', 'lessapprox': '\\u2A85', 'lessdot': '\\u22D6', 'lesseqgtr': '\\u22DA', 'lesseqqgtr': '\\u2A8B', 'LessEqualGreater': '\\u22DA', 'LessFullEqual': '\\u2266', 'LessGreater': '\\u2276', 'lessgtr': '\\u2276', 'LessLess': '\\u2AA1', 'lesssim': '\\u2272', 'LessSlantEqual': '\\u2A7D', 'LessTilde': '\\u2272', 'lfisht': '\\u297C', 'lfloor': '\\u230A', 'lfr': '\\uD835\\uDD29', 'Lfr': '\\uD835\\uDD0F', 'lg': '\\u2276', 'lgE': '\\u2A91', 'lHar': '\\u2962', 'lhard': '\\u21BD', 'lharu': '\\u21BC', 'lharul': '\\u296A', 'lhblk': '\\u2584', 'ljcy': '\\u0459', 'LJcy': '\\u0409', 'll': '\\u226A', 'Ll': '\\u22D8', 'llarr': '\\u21C7', 'llcorner': '\\u231E', 'Lleftarrow': '\\u21DA', 'llhard': '\\u296B', 'lltri': '\\u25FA', 'lmidot': '\\u0140', 'Lmidot': '\\u013F', 'lmoust': '\\u23B0', 'lmoustache': '\\u23B0', 'lnap': '\\u2A89', 'lnapprox': '\\u2A89', 'lne': '\\u2A87', 'lnE': '\\u2268', 'lneq': '\\u2A87', 'lneqq': '\\u2268', 'lnsim': '\\u22E6', 'loang': '\\u27EC', 'loarr': '\\u21FD', 'lobrk': '\\u27E6', 'longleftarrow': '\\u27F5', 'Longleftarrow': '\\u27F8', 'LongLeftArrow': '\\u27F5', 'longleftrightarrow': '\\u27F7', 'Longleftrightarrow': '\\u27FA', 'LongLeftRightArrow': '\\u27F7', 'longmapsto': '\\u27FC', 'longrightarrow': '\\u27F6', 'Longrightarrow': '\\u27F9', 'LongRightArrow': '\\u27F6', 'looparrowleft': '\\u21AB', 'looparrowright': '\\u21AC', 'lopar': '\\u2985', 'lopf': '\\uD835\\uDD5D', 'Lopf': '\\uD835\\uDD43', 'loplus': '\\u2A2D', 'lotimes': '\\u2A34', 'lowast': '\\u2217', 'lowbar': '_', 'LowerLeftArrow': '\\u2199', 'LowerRightArrow': '\\u2198', 'loz': '\\u25CA', 'lozenge': '\\u25CA', 'lozf': '\\u29EB', 'lpar': '(', 'lparlt': '\\u2993', 'lrarr': '\\u21C6', 'lrcorner': '\\u231F', 'lrhar': '\\u21CB', 'lrhard': '\\u296D', 'lrm': '\\u200E', 'lrtri': '\\u22BF', 'lsaquo': '\\u2039', 'lscr': '\\uD835\\uDCC1', 'Lscr': '\\u2112', 'lsh': '\\u21B0', 'Lsh': '\\u21B0', 'lsim': '\\u2272', 'lsime': '\\u2A8D', 'lsimg': '\\u2A8F', 'lsqb': '[', 'lsquo': '\\u2018', 'lsquor': '\\u201A', 'lstrok': '\\u0142', 'Lstrok': '\\u0141', 'lt': '<', 'Lt': '\\u226A', 'LT': '<', 'ltcc': '\\u2AA6', 'ltcir': '\\u2A79', 'ltdot': '\\u22D6', 'lthree': '\\u22CB', 'ltimes': '\\u22C9', 'ltlarr': '\\u2976', 'ltquest': '\\u2A7B', 'ltri': '\\u25C3', 'ltrie': '\\u22B4', 'ltrif': '\\u25C2', 'ltrPar': '\\u2996', 'lurdshar': '\\u294A', 'luruhar': '\\u2966', 'lvertneqq': '\\u2268\\uFE00', 'lvnE': '\\u2268\\uFE00', 'macr': '\\xAF', 'male': '\\u2642', 'malt': '\\u2720', 'maltese': '\\u2720', 'map': '\\u21A6', 'Map': '\\u2905', 'mapsto': '\\u21A6', 'mapstodown': '\\u21A7', 'mapstoleft': '\\u21A4', 'mapstoup': '\\u21A5', 'marker': '\\u25AE', 'mcomma': '\\u2A29', 'mcy': '\\u043C', 'Mcy': '\\u041C', 'mdash': '\\u2014', 'mDDot': '\\u223A', 'measuredangle': '\\u2221', 'MediumSpace': '\\u205F', 'Mellintrf': '\\u2133', 'mfr': '\\uD835\\uDD2A', 'Mfr': '\\uD835\\uDD10', 'mho': '\\u2127', 'micro': '\\xB5', 'mid': '\\u2223', 'midast': '*', 'midcir': '\\u2AF0', 'middot': '\\xB7', 'minus': '\\u2212', 'minusb': '\\u229F', 'minusd': '\\u2238', 'minusdu': '\\u2A2A', 'MinusPlus': '\\u2213', 'mlcp': '\\u2ADB', 'mldr': '\\u2026', 'mnplus': '\\u2213', 'models': '\\u22A7', 'mopf': '\\uD835\\uDD5E', 'Mopf': '\\uD835\\uDD44', 'mp': '\\u2213', 'mscr': '\\uD835\\uDCC2', 'Mscr': '\\u2133', 'mstpos': '\\u223E', 'mu': '\\u03BC', 'Mu': '\\u039C', 'multimap': '\\u22B8', 'mumap': '\\u22B8', 'nabla': '\\u2207', 'nacute': '\\u0144', 'Nacute': '\\u0143', 'nang': '\\u2220\\u20D2', 'nap': '\\u2249', 'napE': '\\u2A70\\u0338', 'napid': '\\u224B\\u0338', 'napos': '\\u0149', 'napprox': '\\u2249', 'natur': '\\u266E', 'natural': '\\u266E', 'naturals': '\\u2115', 'nbsp': '\\xA0', 'nbump': '\\u224E\\u0338', 'nbumpe': '\\u224F\\u0338', 'ncap': '\\u2A43', 'ncaron': '\\u0148', 'Ncaron': '\\u0147', 'ncedil': '\\u0146', 'Ncedil': '\\u0145', 'ncong': '\\u2247', 'ncongdot': '\\u2A6D\\u0338', 'ncup': '\\u2A42', 'ncy': '\\u043D', 'Ncy': '\\u041D', 'ndash': '\\u2013', 'ne': '\\u2260', 'nearhk': '\\u2924', 'nearr': '\\u2197', 'neArr': '\\u21D7', 'nearrow': '\\u2197', 'nedot': '\\u2250\\u0338', 'NegativeMediumSpace': '\\u200B', 'NegativeThickSpace': '\\u200B', 'NegativeThinSpace': '\\u200B', 'NegativeVeryThinSpace': '\\u200B', 'nequiv': '\\u2262', 'nesear': '\\u2928', 'nesim': '\\u2242\\u0338', 'NestedGreaterGreater': '\\u226B', 'NestedLessLess': '\\u226A', 'NewLine': '\\n', 'nexist': '\\u2204', 'nexists': '\\u2204', 'nfr': '\\uD835\\uDD2B', 'Nfr': '\\uD835\\uDD11', 'nge': '\\u2271', 'ngE': '\\u2267\\u0338', 'ngeq': '\\u2271', 'ngeqq': '\\u2267\\u0338', 'ngeqslant': '\\u2A7E\\u0338', 'nges': '\\u2A7E\\u0338', 'nGg': '\\u22D9\\u0338', 'ngsim': '\\u2275', 'ngt': '\\u226F', 'nGt': '\\u226B\\u20D2', 'ngtr': '\\u226F', 'nGtv': '\\u226B\\u0338', 'nharr': '\\u21AE', 'nhArr': '\\u21CE', 'nhpar': '\\u2AF2', 'ni': '\\u220B', 'nis': '\\u22FC', 'nisd': '\\u22FA', 'niv': '\\u220B', 'njcy': '\\u045A', 'NJcy': '\\u040A', 'nlarr': '\\u219A', 'nlArr': '\\u21CD', 'nldr': '\\u2025', 'nle': '\\u2270', 'nlE': '\\u2266\\u0338', 'nleftarrow': '\\u219A', 'nLeftarrow': '\\u21CD', 'nleftrightarrow': '\\u21AE', 'nLeftrightarrow': '\\u21CE', 'nleq': '\\u2270', 'nleqq': '\\u2266\\u0338', 'nleqslant': '\\u2A7D\\u0338', 'nles': '\\u2A7D\\u0338', 'nless': '\\u226E', 'nLl': '\\u22D8\\u0338', 'nlsim': '\\u2274', 'nlt': '\\u226E', 'nLt': '\\u226A\\u20D2', 'nltri': '\\u22EA', 'nltrie': '\\u22EC', 'nLtv': '\\u226A\\u0338', 'nmid': '\\u2224', 'NoBreak': '\\u2060', 'NonBreakingSpace': '\\xA0', 'nopf': '\\uD835\\uDD5F', 'Nopf': '\\u2115', 'not': '\\xAC', 'Not': '\\u2AEC', 'NotCongruent': '\\u2262', 'NotCupCap': '\\u226D', 'NotDoubleVerticalBar': '\\u2226', 'NotElement': '\\u2209', 'NotEqual': '\\u2260', 'NotEqualTilde': '\\u2242\\u0338', 'NotExists': '\\u2204', 'NotGreater': '\\u226F', 'NotGreaterEqual': '\\u2271', 'NotGreaterFullEqual': '\\u2267\\u0338', 'NotGreaterGreater': '\\u226B\\u0338', 'NotGreaterLess': '\\u2279', 'NotGreaterSlantEqual': '\\u2A7E\\u0338', 'NotGreaterTilde': '\\u2275', 'NotHumpDownHump': '\\u224E\\u0338', 'NotHumpEqual': '\\u224F\\u0338', 'notin': '\\u2209', 'notindot': '\\u22F5\\u0338', 'notinE': '\\u22F9\\u0338', 'notinva': '\\u2209', 'notinvb': '\\u22F7', 'notinvc': '\\u22F6', 'NotLeftTriangle': '\\u22EA', 'NotLeftTriangleBar': '\\u29CF\\u0338', 'NotLeftTriangleEqual': '\\u22EC', 'NotLess': '\\u226E', 'NotLessEqual': '\\u2270', 'NotLessGreater': '\\u2278', 'NotLessLess': '\\u226A\\u0338', 'NotLessSlantEqual': '\\u2A7D\\u0338', 'NotLessTilde': '\\u2274', 'NotNestedGreaterGreater': '\\u2AA2\\u0338', 'NotNestedLessLess': '\\u2AA1\\u0338', 'notni': '\\u220C', 'notniva': '\\u220C', 'notnivb': '\\u22FE', 'notnivc': '\\u22FD', 'NotPrecedes': '\\u2280', 'NotPrecedesEqual': '\\u2AAF\\u0338', 'NotPrecedesSlantEqual': '\\u22E0', 'NotReverseElement': '\\u220C', 'NotRightTriangle': '\\u22EB', 'NotRightTriangleBar': '\\u29D0\\u0338', 'NotRightTriangleEqual': '\\u22ED', 'NotSquareSubset': '\\u228F\\u0338', 'NotSquareSubsetEqual': '\\u22E2', 'NotSquareSuperset': '\\u2290\\u0338', 'NotSquareSupersetEqual': '\\u22E3', 'NotSubset': '\\u2282\\u20D2', 'NotSubsetEqual': '\\u2288', 'NotSucceeds': '\\u2281', 'NotSucceedsEqual': '\\u2AB0\\u0338', 'NotSucceedsSlantEqual': '\\u22E1', 'NotSucceedsTilde': '\\u227F\\u0338', 'NotSuperset': '\\u2283\\u20D2', 'NotSupersetEqual': '\\u2289', 'NotTilde': '\\u2241', 'NotTildeEqual': '\\u2244', 'NotTildeFullEqual': '\\u2247', 'NotTildeTilde': '\\u2249', 'NotVerticalBar': '\\u2224', 'npar': '\\u2226', 'nparallel': '\\u2226', 'nparsl': '\\u2AFD\\u20E5', 'npart': '\\u2202\\u0338', 'npolint': '\\u2A14', 'npr': '\\u2280', 'nprcue': '\\u22E0', 'npre': '\\u2AAF\\u0338', 'nprec': '\\u2280', 'npreceq': '\\u2AAF\\u0338', 'nrarr': '\\u219B', 'nrArr': '\\u21CF', 'nrarrc': '\\u2933\\u0338', 'nrarrw': '\\u219D\\u0338', 'nrightarrow': '\\u219B', 'nRightarrow': '\\u21CF', 'nrtri': '\\u22EB', 'nrtrie': '\\u22ED', 'nsc': '\\u2281', 'nsccue': '\\u22E1', 'nsce': '\\u2AB0\\u0338', 'nscr': '\\uD835\\uDCC3', 'Nscr': '\\uD835\\uDCA9', 'nshortmid': '\\u2224', 'nshortparallel': '\\u2226', 'nsim': '\\u2241', 'nsime': '\\u2244', 'nsimeq': '\\u2244', 'nsmid': '\\u2224', 'nspar': '\\u2226', 'nsqsube': '\\u22E2', 'nsqsupe': '\\u22E3', 'nsub': '\\u2284', 'nsube': '\\u2288', 'nsubE': '\\u2AC5\\u0338', 'nsubset': '\\u2282\\u20D2', 'nsubseteq': '\\u2288', 'nsubseteqq': '\\u2AC5\\u0338', 'nsucc': '\\u2281', 'nsucceq': '\\u2AB0\\u0338', 'nsup': '\\u2285', 'nsupe': '\\u2289', 'nsupE': '\\u2AC6\\u0338', 'nsupset': '\\u2283\\u20D2', 'nsupseteq': '\\u2289', 'nsupseteqq': '\\u2AC6\\u0338', 'ntgl': '\\u2279', 'ntilde': '\\xF1', 'Ntilde': '\\xD1', 'ntlg': '\\u2278', 'ntriangleleft': '\\u22EA', 'ntrianglelefteq': '\\u22EC', 'ntriangleright': '\\u22EB', 'ntrianglerighteq': '\\u22ED', 'nu': '\\u03BD', 'Nu': '\\u039D', 'num': '#', 'numero': '\\u2116', 'numsp': '\\u2007', 'nvap': '\\u224D\\u20D2', 'nvdash': '\\u22AC', 'nvDash': '\\u22AD', 'nVdash': '\\u22AE', 'nVDash': '\\u22AF', 'nvge': '\\u2265\\u20D2', 'nvgt': '>\\u20D2', 'nvHarr': '\\u2904', 'nvinfin': '\\u29DE', 'nvlArr': '\\u2902', 'nvle': '\\u2264\\u20D2', 'nvlt': '<\\u20D2', 'nvltrie': '\\u22B4\\u20D2', 'nvrArr': '\\u2903', 'nvrtrie': '\\u22B5\\u20D2', 'nvsim': '\\u223C\\u20D2', 'nwarhk': '\\u2923', 'nwarr': '\\u2196', 'nwArr': '\\u21D6', 'nwarrow': '\\u2196', 'nwnear': '\\u2927', 'oacute': '\\xF3', 'Oacute': '\\xD3', 'oast': '\\u229B', 'ocir': '\\u229A', 'ocirc': '\\xF4', 'Ocirc': '\\xD4', 'ocy': '\\u043E', 'Ocy': '\\u041E', 'odash': '\\u229D', 'odblac': '\\u0151', 'Odblac': '\\u0150', 'odiv': '\\u2A38', 'odot': '\\u2299', 'odsold': '\\u29BC', 'oelig': '\\u0153', 'OElig': '\\u0152', 'ofcir': '\\u29BF', 'ofr': '\\uD835\\uDD2C', 'Ofr': '\\uD835\\uDD12', 'ogon': '\\u02DB', 'ograve': '\\xF2', 'Ograve': '\\xD2', 'ogt': '\\u29C1', 'ohbar': '\\u29B5', 'ohm': '\\u03A9', 'oint': '\\u222E', 'olarr': '\\u21BA', 'olcir': '\\u29BE', 'olcross': '\\u29BB', 'oline': '\\u203E', 'olt': '\\u29C0', 'omacr': '\\u014D', 'Omacr': '\\u014C', 'omega': '\\u03C9', 'Omega': '\\u03A9', 'omicron': '\\u03BF', 'Omicron': '\\u039F', 'omid': '\\u29B6', 'ominus': '\\u2296', 'oopf': '\\uD835\\uDD60', 'Oopf': '\\uD835\\uDD46', 'opar': '\\u29B7', 'OpenCurlyDoubleQuote': '\\u201C', 'OpenCurlyQuote': '\\u2018', 'operp': '\\u29B9', 'oplus': '\\u2295', 'or': '\\u2228', 'Or': '\\u2A54', 'orarr': '\\u21BB', 'ord': '\\u2A5D', 'order': '\\u2134', 'orderof': '\\u2134', 'ordf': '\\xAA', 'ordm': '\\xBA', 'origof': '\\u22B6', 'oror': '\\u2A56', 'orslope': '\\u2A57', 'orv': '\\u2A5B', 'oS': '\\u24C8', 'oscr': '\\u2134', 'Oscr': '\\uD835\\uDCAA', 'oslash': '\\xF8', 'Oslash': '\\xD8', 'osol': '\\u2298', 'otilde': '\\xF5', 'Otilde': '\\xD5', 'otimes': '\\u2297', 'Otimes': '\\u2A37', 'otimesas': '\\u2A36', 'ouml': '\\xF6', 'Ouml': '\\xD6', 'ovbar': '\\u233D', 'OverBar': '\\u203E', 'OverBrace': '\\u23DE', 'OverBracket': '\\u23B4', 'OverParenthesis': '\\u23DC', 'par': '\\u2225', 'para': '\\xB6', 'parallel': '\\u2225', 'parsim': '\\u2AF3', 'parsl': '\\u2AFD', 'part': '\\u2202', 'PartialD': '\\u2202', 'pcy': '\\u043F', 'Pcy': '\\u041F', 'percnt': '%', 'period': '.', 'permil': '\\u2030', 'perp': '\\u22A5', 'pertenk': '\\u2031', 'pfr': '\\uD835\\uDD2D', 'Pfr': '\\uD835\\uDD13', 'phi': '\\u03C6', 'Phi': '\\u03A6', 'phiv': '\\u03D5', 'phmmat': '\\u2133', 'phone': '\\u260E', 'pi': '\\u03C0', 'Pi': '\\u03A0', 'pitchfork': '\\u22D4', 'piv': '\\u03D6', 'planck': '\\u210F', 'planckh': '\\u210E', 'plankv': '\\u210F', 'plus': '+', 'plusacir': '\\u2A23', 'plusb': '\\u229E', 'pluscir': '\\u2A22', 'plusdo': '\\u2214', 'plusdu': '\\u2A25', 'pluse': '\\u2A72', 'PlusMinus': '\\xB1', 'plusmn': '\\xB1', 'plussim': '\\u2A26', 'plustwo': '\\u2A27', 'pm': '\\xB1', 'Poincareplane': '\\u210C', 'pointint': '\\u2A15', 'popf': '\\uD835\\uDD61', 'Popf': '\\u2119', 'pound': '\\xA3', 'pr': '\\u227A', 'Pr': '\\u2ABB', 'prap': '\\u2AB7', 'prcue': '\\u227C', 'pre': '\\u2AAF', 'prE': '\\u2AB3', 'prec': '\\u227A', 'precapprox': '\\u2AB7', 'preccurlyeq': '\\u227C', 'Precedes': '\\u227A', 'PrecedesEqual': '\\u2AAF', 'PrecedesSlantEqual': '\\u227C', 'PrecedesTilde': '\\u227E', 'preceq': '\\u2AAF', 'precnapprox': '\\u2AB9', 'precneqq': '\\u2AB5', 'precnsim': '\\u22E8', 'precsim': '\\u227E', 'prime': '\\u2032', 'Prime': '\\u2033', 'primes': '\\u2119', 'prnap': '\\u2AB9', 'prnE': '\\u2AB5', 'prnsim': '\\u22E8', 'prod': '\\u220F', 'Product': '\\u220F', 'profalar': '\\u232E', 'profline': '\\u2312', 'profsurf': '\\u2313', 'prop': '\\u221D', 'Proportion': '\\u2237', 'Proportional': '\\u221D', 'propto': '\\u221D', 'prsim': '\\u227E', 'prurel': '\\u22B0', 'pscr': '\\uD835\\uDCC5', 'Pscr': '\\uD835\\uDCAB', 'psi': '\\u03C8', 'Psi': '\\u03A8', 'puncsp': '\\u2008', 'qfr': '\\uD835\\uDD2E', 'Qfr': '\\uD835\\uDD14', 'qint': '\\u2A0C', 'qopf': '\\uD835\\uDD62', 'Qopf': '\\u211A', 'qprime': '\\u2057', 'qscr': '\\uD835\\uDCC6', 'Qscr': '\\uD835\\uDCAC', 'quaternions': '\\u210D', 'quatint': '\\u2A16', 'quest': '?', 'questeq': '\\u225F', 'quot': '\"', 'QUOT': '\"', 'rAarr': '\\u21DB', 'race': '\\u223D\\u0331', 'racute': '\\u0155', 'Racute': '\\u0154', 'radic': '\\u221A', 'raemptyv': '\\u29B3', 'rang': '\\u27E9', 'Rang': '\\u27EB', 'rangd': '\\u2992', 'range': '\\u29A5', 'rangle': '\\u27E9', 'raquo': '\\xBB', 'rarr': '\\u2192', 'rArr': '\\u21D2', 'Rarr': '\\u21A0', 'rarrap': '\\u2975', 'rarrb': '\\u21E5', 'rarrbfs': '\\u2920', 'rarrc': '\\u2933', 'rarrfs': '\\u291E', 'rarrhk': '\\u21AA', 'rarrlp': '\\u21AC', 'rarrpl': '\\u2945', 'rarrsim': '\\u2974', 'rarrtl': '\\u21A3', 'Rarrtl': '\\u2916', 'rarrw': '\\u219D', 'ratail': '\\u291A', 'rAtail': '\\u291C', 'ratio': '\\u2236', 'rationals': '\\u211A', 'rbarr': '\\u290D', 'rBarr': '\\u290F', 'RBarr': '\\u2910', 'rbbrk': '\\u2773', 'rbrace': '}', 'rbrack': ']', 'rbrke': '\\u298C', 'rbrksld': '\\u298E', 'rbrkslu': '\\u2990', 'rcaron': '\\u0159', 'Rcaron': '\\u0158', 'rcedil': '\\u0157', 'Rcedil': '\\u0156', 'rceil': '\\u2309', 'rcub': '}', 'rcy': '\\u0440', 'Rcy': '\\u0420', 'rdca': '\\u2937', 'rdldhar': '\\u2969', 'rdquo': '\\u201D', 'rdquor': '\\u201D', 'rdsh': '\\u21B3', 'Re': '\\u211C', 'real': '\\u211C', 'realine': '\\u211B', 'realpart': '\\u211C', 'reals': '\\u211D', 'rect': '\\u25AD', 'reg': '\\xAE', 'REG': '\\xAE', 'ReverseElement': '\\u220B', 'ReverseEquilibrium': '\\u21CB', 'ReverseUpEquilibrium': '\\u296F', 'rfisht': '\\u297D', 'rfloor': '\\u230B', 'rfr': '\\uD835\\uDD2F', 'Rfr': '\\u211C', 'rHar': '\\u2964', 'rhard': '\\u21C1', 'rharu': '\\u21C0', 'rharul': '\\u296C', 'rho': '\\u03C1', 'Rho': '\\u03A1', 'rhov': '\\u03F1', 'RightAngleBracket': '\\u27E9', 'rightarrow': '\\u2192', 'Rightarrow': '\\u21D2', 'RightArrow': '\\u2192', 'RightArrowBar': '\\u21E5', 'RightArrowLeftArrow': '\\u21C4', 'rightarrowtail': '\\u21A3', 'RightCeiling': '\\u2309', 'RightDoubleBracket': '\\u27E7', 'RightDownTeeVector': '\\u295D', 'RightDownVector': '\\u21C2', 'RightDownVectorBar': '\\u2955', 'RightFloor': '\\u230B', 'rightharpoondown': '\\u21C1', 'rightharpoonup': '\\u21C0', 'rightleftarrows': '\\u21C4', 'rightleftharpoons': '\\u21CC', 'rightrightarrows': '\\u21C9', 'rightsquigarrow': '\\u219D', 'RightTee': '\\u22A2', 'RightTeeArrow': '\\u21A6', 'RightTeeVector': '\\u295B', 'rightthreetimes': '\\u22CC', 'RightTriangle': '\\u22B3', 'RightTriangleBar': '\\u29D0', 'RightTriangleEqual': '\\u22B5', 'RightUpDownVector': '\\u294F', 'RightUpTeeVector': '\\u295C', 'RightUpVector': '\\u21BE', 'RightUpVectorBar': '\\u2954', 'RightVector': '\\u21C0', 'RightVectorBar': '\\u2953', 'ring': '\\u02DA', 'risingdotseq': '\\u2253', 'rlarr': '\\u21C4', 'rlhar': '\\u21CC', 'rlm': '\\u200F', 'rmoust': '\\u23B1', 'rmoustache': '\\u23B1', 'rnmid': '\\u2AEE', 'roang': '\\u27ED', 'roarr': '\\u21FE', 'robrk': '\\u27E7', 'ropar': '\\u2986', 'ropf': '\\uD835\\uDD63', 'Ropf': '\\u211D', 'roplus': '\\u2A2E', 'rotimes': '\\u2A35', 'RoundImplies': '\\u2970', 'rpar': ')', 'rpargt': '\\u2994', 'rppolint': '\\u2A12', 'rrarr': '\\u21C9', 'Rrightarrow': '\\u21DB', 'rsaquo': '\\u203A', 'rscr': '\\uD835\\uDCC7', 'Rscr': '\\u211B', 'rsh': '\\u21B1', 'Rsh': '\\u21B1', 'rsqb': ']', 'rsquo': '\\u2019', 'rsquor': '\\u2019', 'rthree': '\\u22CC', 'rtimes': '\\u22CA', 'rtri': '\\u25B9', 'rtrie': '\\u22B5', 'rtrif': '\\u25B8', 'rtriltri': '\\u29CE', 'RuleDelayed': '\\u29F4', 'ruluhar': '\\u2968', 'rx': '\\u211E', 'sacute': '\\u015B', 'Sacute': '\\u015A', 'sbquo': '\\u201A', 'sc': '\\u227B', 'Sc': '\\u2ABC', 'scap': '\\u2AB8', 'scaron': '\\u0161', 'Scaron': '\\u0160', 'sccue': '\\u227D', 'sce': '\\u2AB0', 'scE': '\\u2AB4', 'scedil': '\\u015F', 'Scedil': '\\u015E', 'scirc': '\\u015D', 'Scirc': '\\u015C', 'scnap': '\\u2ABA', 'scnE': '\\u2AB6', 'scnsim': '\\u22E9', 'scpolint': '\\u2A13', 'scsim': '\\u227F', 'scy': '\\u0441', 'Scy': '\\u0421', 'sdot': '\\u22C5', 'sdotb': '\\u22A1', 'sdote': '\\u2A66', 'searhk': '\\u2925', 'searr': '\\u2198', 'seArr': '\\u21D8', 'searrow': '\\u2198', 'sect': '\\xA7', 'semi': ';', 'seswar': '\\u2929', 'setminus': '\\u2216', 'setmn': '\\u2216', 'sext': '\\u2736', 'sfr': '\\uD835\\uDD30', 'Sfr': '\\uD835\\uDD16', 'sfrown': '\\u2322', 'sharp': '\\u266F', 'shchcy': '\\u0449', 'SHCHcy': '\\u0429', 'shcy': '\\u0448', 'SHcy': '\\u0428', 'ShortDownArrow': '\\u2193', 'ShortLeftArrow': '\\u2190', 'shortmid': '\\u2223', 'shortparallel': '\\u2225', 'ShortRightArrow': '\\u2192', 'ShortUpArrow': '\\u2191', 'shy': '\\xAD', 'sigma': '\\u03C3', 'Sigma': '\\u03A3', 'sigmaf': '\\u03C2', 'sigmav': '\\u03C2', 'sim': '\\u223C', 'simdot': '\\u2A6A', 'sime': '\\u2243', 'simeq': '\\u2243', 'simg': '\\u2A9E', 'simgE': '\\u2AA0', 'siml': '\\u2A9D', 'simlE': '\\u2A9F', 'simne': '\\u2246', 'simplus': '\\u2A24', 'simrarr': '\\u2972', 'slarr': '\\u2190', 'SmallCircle': '\\u2218', 'smallsetminus': '\\u2216', 'smashp': '\\u2A33', 'smeparsl': '\\u29E4', 'smid': '\\u2223', 'smile': '\\u2323', 'smt': '\\u2AAA', 'smte': '\\u2AAC', 'smtes': '\\u2AAC\\uFE00', 'softcy': '\\u044C', 'SOFTcy': '\\u042C', 'sol': '/', 'solb': '\\u29C4', 'solbar': '\\u233F', 'sopf': '\\uD835\\uDD64', 'Sopf': '\\uD835\\uDD4A', 'spades': '\\u2660', 'spadesuit': '\\u2660', 'spar': '\\u2225', 'sqcap': '\\u2293', 'sqcaps': '\\u2293\\uFE00', 'sqcup': '\\u2294', 'sqcups': '\\u2294\\uFE00', 'Sqrt': '\\u221A', 'sqsub': '\\u228F', 'sqsube': '\\u2291', 'sqsubset': '\\u228F', 'sqsubseteq': '\\u2291', 'sqsup': '\\u2290', 'sqsupe': '\\u2292', 'sqsupset': '\\u2290', 'sqsupseteq': '\\u2292', 'squ': '\\u25A1', 'square': '\\u25A1', 'Square': '\\u25A1', 'SquareIntersection': '\\u2293', 'SquareSubset': '\\u228F', 'SquareSubsetEqual': '\\u2291', 'SquareSuperset': '\\u2290', 'SquareSupersetEqual': '\\u2292', 'SquareUnion': '\\u2294', 'squarf': '\\u25AA', 'squf': '\\u25AA', 'srarr': '\\u2192', 'sscr': '\\uD835\\uDCC8', 'Sscr': '\\uD835\\uDCAE', 'ssetmn': '\\u2216', 'ssmile': '\\u2323', 'sstarf': '\\u22C6', 'star': '\\u2606', 'Star': '\\u22C6', 'starf': '\\u2605', 'straightepsilon': '\\u03F5', 'straightphi': '\\u03D5', 'strns': '\\xAF', 'sub': '\\u2282', 'Sub': '\\u22D0', 'subdot': '\\u2ABD', 'sube': '\\u2286', 'subE': '\\u2AC5', 'subedot': '\\u2AC3', 'submult': '\\u2AC1', 'subne': '\\u228A', 'subnE': '\\u2ACB', 'subplus': '\\u2ABF', 'subrarr': '\\u2979', 'subset': '\\u2282', 'Subset': '\\u22D0', 'subseteq': '\\u2286', 'subseteqq': '\\u2AC5', 'SubsetEqual': '\\u2286', 'subsetneq': '\\u228A', 'subsetneqq': '\\u2ACB', 'subsim': '\\u2AC7', 'subsub': '\\u2AD5', 'subsup': '\\u2AD3', 'succ': '\\u227B', 'succapprox': '\\u2AB8', 'succcurlyeq': '\\u227D', 'Succeeds': '\\u227B', 'SucceedsEqual': '\\u2AB0', 'SucceedsSlantEqual': '\\u227D', 'SucceedsTilde': '\\u227F', 'succeq': '\\u2AB0', 'succnapprox': '\\u2ABA', 'succneqq': '\\u2AB6', 'succnsim': '\\u22E9', 'succsim': '\\u227F', 'SuchThat': '\\u220B', 'sum': '\\u2211', 'Sum': '\\u2211', 'sung': '\\u266A', 'sup': '\\u2283', 'Sup': '\\u22D1', 'sup1': '\\xB9', 'sup2': '\\xB2', 'sup3': '\\xB3', 'supdot': '\\u2ABE', 'supdsub': '\\u2AD8', 'supe': '\\u2287', 'supE': '\\u2AC6', 'supedot': '\\u2AC4', 'Superset': '\\u2283', 'SupersetEqual': '\\u2287', 'suphsol': '\\u27C9', 'suphsub': '\\u2AD7', 'suplarr': '\\u297B', 'supmult': '\\u2AC2', 'supne': '\\u228B', 'supnE': '\\u2ACC', 'supplus': '\\u2AC0', 'supset': '\\u2283', 'Supset': '\\u22D1', 'supseteq': '\\u2287', 'supseteqq': '\\u2AC6', 'supsetneq': '\\u228B', 'supsetneqq': '\\u2ACC', 'supsim': '\\u2AC8', 'supsub': '\\u2AD4', 'supsup': '\\u2AD6', 'swarhk': '\\u2926', 'swarr': '\\u2199', 'swArr': '\\u21D9', 'swarrow': '\\u2199', 'swnwar': '\\u292A', 'szlig': '\\xDF', 'Tab': '\\t', 'target': '\\u2316', 'tau': '\\u03C4', 'Tau': '\\u03A4', 'tbrk': '\\u23B4', 'tcaron': '\\u0165', 'Tcaron': '\\u0164', 'tcedil': '\\u0163', 'Tcedil': '\\u0162', 'tcy': '\\u0442', 'Tcy': '\\u0422', 'tdot': '\\u20DB', 'telrec': '\\u2315', 'tfr': '\\uD835\\uDD31', 'Tfr': '\\uD835\\uDD17', 'there4': '\\u2234', 'therefore': '\\u2234', 'Therefore': '\\u2234', 'theta': '\\u03B8', 'Theta': '\\u0398', 'thetasym': '\\u03D1', 'thetav': '\\u03D1', 'thickapprox': '\\u2248', 'thicksim': '\\u223C', 'ThickSpace': '\\u205F\\u200A', 'thinsp': '\\u2009', 'ThinSpace': '\\u2009', 'thkap': '\\u2248', 'thksim': '\\u223C', 'thorn': '\\xFE', 'THORN': '\\xDE', 'tilde': '\\u02DC', 'Tilde': '\\u223C', 'TildeEqual': '\\u2243', 'TildeFullEqual': '\\u2245', 'TildeTilde': '\\u2248', 'times': '\\xD7', 'timesb': '\\u22A0', 'timesbar': '\\u2A31', 'timesd': '\\u2A30', 'tint': '\\u222D', 'toea': '\\u2928', 'top': '\\u22A4', 'topbot': '\\u2336', 'topcir': '\\u2AF1', 'topf': '\\uD835\\uDD65', 'Topf': '\\uD835\\uDD4B', 'topfork': '\\u2ADA', 'tosa': '\\u2929', 'tprime': '\\u2034', 'trade': '\\u2122', 'TRADE': '\\u2122', 'triangle': '\\u25B5', 'triangledown': '\\u25BF', 'triangleleft': '\\u25C3', 'trianglelefteq': '\\u22B4', 'triangleq': '\\u225C', 'triangleright': '\\u25B9', 'trianglerighteq': '\\u22B5', 'tridot': '\\u25EC', 'trie': '\\u225C', 'triminus': '\\u2A3A', 'TripleDot': '\\u20DB', 'triplus': '\\u2A39', 'trisb': '\\u29CD', 'tritime': '\\u2A3B', 'trpezium': '\\u23E2', 'tscr': '\\uD835\\uDCC9', 'Tscr': '\\uD835\\uDCAF', 'tscy': '\\u0446', 'TScy': '\\u0426', 'tshcy': '\\u045B', 'TSHcy': '\\u040B', 'tstrok': '\\u0167', 'Tstrok': '\\u0166', 'twixt': '\\u226C', 'twoheadleftarrow': '\\u219E', 'twoheadrightarrow': '\\u21A0', 'uacute': '\\xFA', 'Uacute': '\\xDA', 'uarr': '\\u2191', 'uArr': '\\u21D1', 'Uarr': '\\u219F', 'Uarrocir': '\\u2949', 'ubrcy': '\\u045E', 'Ubrcy': '\\u040E', 'ubreve': '\\u016D', 'Ubreve': '\\u016C', 'ucirc': '\\xFB', 'Ucirc': '\\xDB', 'ucy': '\\u0443', 'Ucy': '\\u0423', 'udarr': '\\u21C5', 'udblac': '\\u0171', 'Udblac': '\\u0170', 'udhar': '\\u296E', 'ufisht': '\\u297E', 'ufr': '\\uD835\\uDD32', 'Ufr': '\\uD835\\uDD18', 'ugrave': '\\xF9', 'Ugrave': '\\xD9', 'uHar': '\\u2963', 'uharl': '\\u21BF', 'uharr': '\\u21BE', 'uhblk': '\\u2580', 'ulcorn': '\\u231C', 'ulcorner': '\\u231C', 'ulcrop': '\\u230F', 'ultri': '\\u25F8', 'umacr': '\\u016B', 'Umacr': '\\u016A', 'uml': '\\xA8', 'UnderBar': '_', 'UnderBrace': '\\u23DF', 'UnderBracket': '\\u23B5', 'UnderParenthesis': '\\u23DD', 'Union': '\\u22C3', 'UnionPlus': '\\u228E', 'uogon': '\\u0173', 'Uogon': '\\u0172', 'uopf': '\\uD835\\uDD66', 'Uopf': '\\uD835\\uDD4C', 'uparrow': '\\u2191', 'Uparrow': '\\u21D1', 'UpArrow': '\\u2191', 'UpArrowBar': '\\u2912', 'UpArrowDownArrow': '\\u21C5', 'updownarrow': '\\u2195', 'Updownarrow': '\\u21D5', 'UpDownArrow': '\\u2195', 'UpEquilibrium': '\\u296E', 'upharpoonleft': '\\u21BF', 'upharpoonright': '\\u21BE', 'uplus': '\\u228E', 'UpperLeftArrow': '\\u2196', 'UpperRightArrow': '\\u2197', 'upsi': '\\u03C5', 'Upsi': '\\u03D2', 'upsih': '\\u03D2', 'upsilon': '\\u03C5', 'Upsilon': '\\u03A5', 'UpTee': '\\u22A5', 'UpTeeArrow': '\\u21A5', 'upuparrows': '\\u21C8', 'urcorn': '\\u231D', 'urcorner': '\\u231D', 'urcrop': '\\u230E', 'uring': '\\u016F', 'Uring': '\\u016E', 'urtri': '\\u25F9', 'uscr': '\\uD835\\uDCCA', 'Uscr': '\\uD835\\uDCB0', 'utdot': '\\u22F0', 'utilde': '\\u0169', 'Utilde': '\\u0168', 'utri': '\\u25B5', 'utrif': '\\u25B4', 'uuarr': '\\u21C8', 'uuml': '\\xFC', 'Uuml': '\\xDC', 'uwangle': '\\u29A7', 'vangrt': '\\u299C', 'varepsilon': '\\u03F5', 'varkappa': '\\u03F0', 'varnothing': '\\u2205', 'varphi': '\\u03D5', 'varpi': '\\u03D6', 'varpropto': '\\u221D', 'varr': '\\u2195', 'vArr': '\\u21D5', 'varrho': '\\u03F1', 'varsigma': '\\u03C2', 'varsubsetneq': '\\u228A\\uFE00', 'varsubsetneqq': '\\u2ACB\\uFE00', 'varsupsetneq': '\\u228B\\uFE00', 'varsupsetneqq': '\\u2ACC\\uFE00', 'vartheta': '\\u03D1', 'vartriangleleft': '\\u22B2', 'vartriangleright': '\\u22B3', 'vBar': '\\u2AE8', 'Vbar': '\\u2AEB', 'vBarv': '\\u2AE9', 'vcy': '\\u0432', 'Vcy': '\\u0412', 'vdash': '\\u22A2', 'vDash': '\\u22A8', 'Vdash': '\\u22A9', 'VDash': '\\u22AB', 'Vdashl': '\\u2AE6', 'vee': '\\u2228', 'Vee': '\\u22C1', 'veebar': '\\u22BB', 'veeeq': '\\u225A', 'vellip': '\\u22EE', 'verbar': '|', 'Verbar': '\\u2016', 'vert': '|', 'Vert': '\\u2016', 'VerticalBar': '\\u2223', 'VerticalLine': '|', 'VerticalSeparator': '\\u2758', 'VerticalTilde': '\\u2240', 'VeryThinSpace': '\\u200A', 'vfr': '\\uD835\\uDD33', 'Vfr': '\\uD835\\uDD19', 'vltri': '\\u22B2', 'vnsub': '\\u2282\\u20D2', 'vnsup': '\\u2283\\u20D2', 'vopf': '\\uD835\\uDD67', 'Vopf': '\\uD835\\uDD4D', 'vprop': '\\u221D', 'vrtri': '\\u22B3', 'vscr': '\\uD835\\uDCCB', 'Vscr': '\\uD835\\uDCB1', 'vsubne': '\\u228A\\uFE00', 'vsubnE': '\\u2ACB\\uFE00', 'vsupne': '\\u228B\\uFE00', 'vsupnE': '\\u2ACC\\uFE00', 'Vvdash': '\\u22AA', 'vzigzag': '\\u299A', 'wcirc': '\\u0175', 'Wcirc': '\\u0174', 'wedbar': '\\u2A5F', 'wedge': '\\u2227', 'Wedge': '\\u22C0', 'wedgeq': '\\u2259', 'weierp': '\\u2118', 'wfr': '\\uD835\\uDD34', 'Wfr': '\\uD835\\uDD1A', 'wopf': '\\uD835\\uDD68', 'Wopf': '\\uD835\\uDD4E', 'wp': '\\u2118', 'wr': '\\u2240', 'wreath': '\\u2240', 'wscr': '\\uD835\\uDCCC', 'Wscr': '\\uD835\\uDCB2', 'xcap': '\\u22C2', 'xcirc': '\\u25EF', 'xcup': '\\u22C3', 'xdtri': '\\u25BD', 'xfr': '\\uD835\\uDD35', 'Xfr': '\\uD835\\uDD1B', 'xharr': '\\u27F7', 'xhArr': '\\u27FA', 'xi': '\\u03BE', 'Xi': '\\u039E', 'xlarr': '\\u27F5', 'xlArr': '\\u27F8', 'xmap': '\\u27FC', 'xnis': '\\u22FB', 'xodot': '\\u2A00', 'xopf': '\\uD835\\uDD69', 'Xopf': '\\uD835\\uDD4F', 'xoplus': '\\u2A01', 'xotime': '\\u2A02', 'xrarr': '\\u27F6', 'xrArr': '\\u27F9', 'xscr': '\\uD835\\uDCCD', 'Xscr': '\\uD835\\uDCB3', 'xsqcup': '\\u2A06', 'xuplus': '\\u2A04', 'xutri': '\\u25B3', 'xvee': '\\u22C1', 'xwedge': '\\u22C0', 'yacute': '\\xFD', 'Yacute': '\\xDD', 'yacy': '\\u044F', 'YAcy': '\\u042F', 'ycirc': '\\u0177', 'Ycirc': '\\u0176', 'ycy': '\\u044B', 'Ycy': '\\u042B', 'yen': '\\xA5', 'yfr': '\\uD835\\uDD36', 'Yfr': '\\uD835\\uDD1C', 'yicy': '\\u0457', 'YIcy': '\\u0407', 'yopf': '\\uD835\\uDD6A', 'Yopf': '\\uD835\\uDD50', 'yscr': '\\uD835\\uDCCE', 'Yscr': '\\uD835\\uDCB4', 'yucy': '\\u044E', 'YUcy': '\\u042E', 'yuml': '\\xFF', 'Yuml': '\\u0178', 'zacute': '\\u017A', 'Zacute': '\\u0179', 'zcaron': '\\u017E', 'Zcaron': '\\u017D', 'zcy': '\\u0437', 'Zcy': '\\u0417', 'zdot': '\\u017C', 'Zdot': '\\u017B', 'zeetrf': '\\u2128', 'ZeroWidthSpace': '\\u200B', 'zeta': '\\u03B6', 'Zeta': '\\u0396', 'zfr': '\\uD835\\uDD37', 'Zfr': '\\u2128', 'zhcy': '\\u0436', 'ZHcy': '\\u0416', 'zigrarr': '\\u21DD', 'zopf': '\\uD835\\uDD6B', 'Zopf': '\\u2124', 'zscr': '\\uD835\\uDCCF', 'Zscr': '\\uD835\\uDCB5', 'zwj': '\\u200D', 'zwnj': '\\u200C' };\n\tvar decodeMapLegacy = { 'aacute': '\\xE1', 'Aacute': '\\xC1', 'acirc': '\\xE2', 'Acirc': '\\xC2', 'acute': '\\xB4', 'aelig': '\\xE6', 'AElig': '\\xC6', 'agrave': '\\xE0', 'Agrave': '\\xC0', 'amp': '&', 'AMP': '&', 'aring': '\\xE5', 'Aring': '\\xC5', 'atilde': '\\xE3', 'Atilde': '\\xC3', 'auml': '\\xE4', 'Auml': '\\xC4', 'brvbar': '\\xA6', 'ccedil': '\\xE7', 'Ccedil': '\\xC7', 'cedil': '\\xB8', 'cent': '\\xA2', 'copy': '\\xA9', 'COPY': '\\xA9', 'curren': '\\xA4', 'deg': '\\xB0', 'divide': '\\xF7', 'eacute': '\\xE9', 'Eacute': '\\xC9', 'ecirc': '\\xEA', 'Ecirc': '\\xCA', 'egrave': '\\xE8', 'Egrave': '\\xC8', 'eth': '\\xF0', 'ETH': '\\xD0', 'euml': '\\xEB', 'Euml': '\\xCB', 'frac12': '\\xBD', 'frac14': '\\xBC', 'frac34': '\\xBE', 'gt': '>', 'GT': '>', 'iacute': '\\xED', 'Iacute': '\\xCD', 'icirc': '\\xEE', 'Icirc': '\\xCE', 'iexcl': '\\xA1', 'igrave': '\\xEC', 'Igrave': '\\xCC', 'iquest': '\\xBF', 'iuml': '\\xEF', 'Iuml': '\\xCF', 'laquo': '\\xAB', 'lt': '<', 'LT': '<', 'macr': '\\xAF', 'micro': '\\xB5', 'middot': '\\xB7', 'nbsp': '\\xA0', 'not': '\\xAC', 'ntilde': '\\xF1', 'Ntilde': '\\xD1', 'oacute': '\\xF3', 'Oacute': '\\xD3', 'ocirc': '\\xF4', 'Ocirc': '\\xD4', 'ograve': '\\xF2', 'Ograve': '\\xD2', 'ordf': '\\xAA', 'ordm': '\\xBA', 'oslash': '\\xF8', 'Oslash': '\\xD8', 'otilde': '\\xF5', 'Otilde': '\\xD5', 'ouml': '\\xF6', 'Ouml': '\\xD6', 'para': '\\xB6', 'plusmn': '\\xB1', 'pound': '\\xA3', 'quot': '\"', 'QUOT': '\"', 'raquo': '\\xBB', 'reg': '\\xAE', 'REG': '\\xAE', 'sect': '\\xA7', 'shy': '\\xAD', 'sup1': '\\xB9', 'sup2': '\\xB2', 'sup3': '\\xB3', 'szlig': '\\xDF', 'thorn': '\\xFE', 'THORN': '\\xDE', 'times': '\\xD7', 'uacute': '\\xFA', 'Uacute': '\\xDA', 'ucirc': '\\xFB', 'Ucirc': '\\xDB', 'ugrave': '\\xF9', 'Ugrave': '\\xD9', 'uml': '\\xA8', 'uuml': '\\xFC', 'Uuml': '\\xDC', 'yacute': '\\xFD', 'Yacute': '\\xDD', 'yen': '\\xA5', 'yuml': '\\xFF' };\n\tvar decodeMapNumeric = { '0': '\\uFFFD', '128': '\\u20AC', '130': '\\u201A', '131': '\\u0192', '132': '\\u201E', '133': '\\u2026', '134': '\\u2020', '135': '\\u2021', '136': '\\u02C6', '137': '\\u2030', '138': '\\u0160', '139': '\\u2039', '140': '\\u0152', '142': '\\u017D', '145': '\\u2018', '146': '\\u2019', '147': '\\u201C', '148': '\\u201D', '149': '\\u2022', '150': '\\u2013', '151': '\\u2014', '152': '\\u02DC', '153': '\\u2122', '154': '\\u0161', '155': '\\u203A', '156': '\\u0153', '158': '\\u017E', '159': '\\u0178' };\n\tvar invalidReferenceCodePoints = [1, 2, 3, 4, 5, 6, 7, 8, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 64976, 64977, 64978, 64979, 64980, 64981, 64982, 64983, 64984, 64985, 64986, 64987, 64988, 64989, 64990, 64991, 64992, 64993, 64994, 64995, 64996, 64997, 64998, 64999, 65000, 65001, 65002, 65003, 65004, 65005, 65006, 65007, 65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678, 327679, 393214, 393215, 458750, 458751, 524286, 524287, 589822, 589823, 655358, 655359, 720894, 720895, 786430, 786431, 851966, 851967, 917502, 917503, 983038, 983039, 1048574, 1048575, 1114110, 1114111];\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\tvar object = {};\n\tvar hasOwnProperty = object.hasOwnProperty;\n\tvar has = function (object, propertyName) {\n\t\treturn hasOwnProperty.call(object, propertyName);\n\t};\n\n\tvar contains = function (array, value) {\n\t\tvar index = -1;\n\t\tvar length = array.length;\n\t\twhile (++index < length) {\n\t\t\tif (array[index] == value) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t};\n\n\tvar merge = function (options, defaults) {\n\t\tif (!options) {\n\t\t\treturn defaults;\n\t\t}\n\t\tvar result = {};\n\t\tvar key;\n\t\tfor (key in defaults) {\n\t\t\t// A `hasOwnProperty` check is not needed here, since only recognized\n\t\t\t// option names are used anyway. Any others are ignored.\n\t\t\tresult[key] = has(options, key) ? options[key] : defaults[key];\n\t\t}\n\t\treturn result;\n\t};\n\n\t// Modified version of `ucs2encode`; see https://mths.be/punycode.\n\tvar codePointToSymbol = function (codePoint, strict) {\n\t\tvar output = '';\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF || codePoint > 0x10FFFF) {\n\t\t\t// See issue #4:\n\t\t\t// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is\n\t\t\t// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD\n\t\t\t// REPLACEMENT CHARACTER.”\n\t\t\tif (strict) {\n\t\t\t\tparseError('character reference outside the permissible Unicode range');\n\t\t\t}\n\t\t\treturn '\\uFFFD';\n\t\t}\n\t\tif (has(decodeMapNumeric, codePoint)) {\n\t\t\tif (strict) {\n\t\t\t\tparseError('disallowed character reference');\n\t\t\t}\n\t\t\treturn decodeMapNumeric[codePoint];\n\t\t}\n\t\tif (strict && contains(invalidReferenceCodePoints, codePoint)) {\n\t\t\tparseError('disallowed character reference');\n\t\t}\n\t\tif (codePoint > 0xFFFF) {\n\t\t\tcodePoint -= 0x10000;\n\t\t\toutput += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);\n\t\t\tcodePoint = 0xDC00 | codePoint & 0x3FF;\n\t\t}\n\t\toutput += stringFromCharCode(codePoint);\n\t\treturn output;\n\t};\n\n\tvar hexEscape = function (codePoint) {\n\t\treturn '&#x' + codePoint.toString(16).toUpperCase() + ';';\n\t};\n\n\tvar decEscape = function (codePoint) {\n\t\treturn '&#' + codePoint + ';';\n\t};\n\n\tvar parseError = function (message) {\n\t\tthrow Error('Parse error: ' + message);\n\t};\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar encode = function (string, options) {\n\t\toptions = merge(options, encode.options);\n\t\tvar strict = options.strict;\n\t\tif (strict && regexInvalidRawCodePoint.test(string)) {\n\t\t\tparseError('forbidden code point');\n\t\t}\n\t\tvar encodeEverything = options.encodeEverything;\n\t\tvar useNamedReferences = options.useNamedReferences;\n\t\tvar allowUnsafeSymbols = options.allowUnsafeSymbols;\n\t\tvar escapeCodePoint = options.decimal ? decEscape : hexEscape;\n\n\t\tvar escapeBmpSymbol = function (symbol) {\n\t\t\treturn escapeCodePoint(symbol.charCodeAt(0));\n\t\t};\n\n\t\tif (encodeEverything) {\n\t\t\t// Encode ASCII symbols.\n\t\t\tstring = string.replace(regexAsciiWhitelist, function (symbol) {\n\t\t\t\t// Use named references if requested & possible.\n\t\t\t\tif (useNamedReferences && has(encodeMap, symbol)) {\n\t\t\t\t\treturn '&' + encodeMap[symbol] + ';';\n\t\t\t\t}\n\t\t\t\treturn escapeBmpSymbol(symbol);\n\t\t\t});\n\t\t\t// Shorten a few escapes that represent two symbols, of which at least one\n\t\t\t// is within the ASCII range.\n\t\t\tif (useNamedReferences) {\n\t\t\t\tstring = string.replace(/&gt;\\u20D2/g, '&nvgt;').replace(/&lt;\\u20D2/g, '&nvlt;').replace(/&#x66;&#x6A;/g, '&fjlig;');\n\t\t\t}\n\t\t\t// Encode non-ASCII symbols.\n\t\t\tif (useNamedReferences) {\n\t\t\t\t// Encode non-ASCII symbols that can be replaced with a named reference.\n\t\t\t\tstring = string.replace(regexEncodeNonAscii, function (string) {\n\t\t\t\t\t// Note: there is no need to check `has(encodeMap, string)` here.\n\t\t\t\t\treturn '&' + encodeMap[string] + ';';\n\t\t\t\t});\n\t\t\t}\n\t\t\t// Note: any remaining non-ASCII symbols are handled outside of the `if`.\n\t\t} else if (useNamedReferences) {\n\t\t\t// Apply named character references.\n\t\t\t// Encode `<>\"'&` using named character references.\n\t\t\tif (!allowUnsafeSymbols) {\n\t\t\t\tstring = string.replace(regexEscape, function (string) {\n\t\t\t\t\treturn '&' + encodeMap[string] + ';'; // no need to check `has()` here\n\t\t\t\t});\n\t\t\t}\n\t\t\t// Shorten escapes that represent two symbols, of which at least one is\n\t\t\t// `<>\"'&`.\n\t\t\tstring = string.replace(/&gt;\\u20D2/g, '&nvgt;').replace(/&lt;\\u20D2/g, '&nvlt;');\n\t\t\t// Encode non-ASCII symbols that can be replaced with a named reference.\n\t\t\tstring = string.replace(regexEncodeNonAscii, function (string) {\n\t\t\t\t// Note: there is no need to check `has(encodeMap, string)` here.\n\t\t\t\treturn '&' + encodeMap[string] + ';';\n\t\t\t});\n\t\t} else if (!allowUnsafeSymbols) {\n\t\t\t// Encode `<>\"'&` using hexadecimal escapes, now that they’re not handled\n\t\t\t// using named character references.\n\t\t\tstring = string.replace(regexEscape, escapeBmpSymbol);\n\t\t}\n\t\treturn string\n\t\t// Encode astral symbols.\n\t\t.replace(regexAstralSymbols, function ($0) {\n\t\t\t// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n\t\t\tvar high = $0.charCodeAt(0);\n\t\t\tvar low = $0.charCodeAt(1);\n\t\t\tvar codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;\n\t\t\treturn escapeCodePoint(codePoint);\n\t\t})\n\t\t// Encode any remaining BMP symbols that are not printable ASCII symbols\n\t\t// using a hexadecimal escape.\n\t\t.replace(regexBmpWhitelist, escapeBmpSymbol);\n\t};\n\t// Expose default options (so they can be overridden globally).\n\tencode.options = {\n\t\t'allowUnsafeSymbols': false,\n\t\t'encodeEverything': false,\n\t\t'strict': false,\n\t\t'useNamedReferences': false,\n\t\t'decimal': false\n\t};\n\n\tvar decode = function (html, options) {\n\t\toptions = merge(options, decode.options);\n\t\tvar strict = options.strict;\n\t\tif (strict && regexInvalidEntity.test(html)) {\n\t\t\tparseError('malformed character reference');\n\t\t}\n\t\treturn html.replace(regexDecode, function ($0, $1, $2, $3, $4, $5, $6, $7) {\n\t\t\tvar codePoint;\n\t\t\tvar semicolon;\n\t\t\tvar decDigits;\n\t\t\tvar hexDigits;\n\t\t\tvar reference;\n\t\t\tvar next;\n\t\t\tif ($1) {\n\t\t\t\t// Decode decimal escapes, e.g. `&#119558;`.\n\t\t\t\tdecDigits = $1;\n\t\t\t\tsemicolon = $2;\n\t\t\t\tif (strict && !semicolon) {\n\t\t\t\t\tparseError('character reference was not terminated by a semicolon');\n\t\t\t\t}\n\t\t\t\tcodePoint = parseInt(decDigits, 10);\n\t\t\t\treturn codePointToSymbol(codePoint, strict);\n\t\t\t}\n\t\t\tif ($3) {\n\t\t\t\t// Decode hexadecimal escapes, e.g. `&#x1D306;`.\n\t\t\t\thexDigits = $3;\n\t\t\t\tsemicolon = $4;\n\t\t\t\tif (strict && !semicolon) {\n\t\t\t\t\tparseError('character reference was not terminated by a semicolon');\n\t\t\t\t}\n\t\t\t\tcodePoint = parseInt(hexDigits, 16);\n\t\t\t\treturn codePointToSymbol(codePoint, strict);\n\t\t\t}\n\t\t\tif ($5) {\n\t\t\t\t// Decode named character references with trailing `;`, e.g. `&copy;`.\n\t\t\t\treference = $5;\n\t\t\t\tif (has(decodeMap, reference)) {\n\t\t\t\t\treturn decodeMap[reference];\n\t\t\t\t} else {\n\t\t\t\t\t// Ambiguous ampersand. https://mths.be/notes/ambiguous-ampersands\n\t\t\t\t\tif (strict) {\n\t\t\t\t\t\tparseError('named character reference was not terminated by a semicolon');\n\t\t\t\t\t}\n\t\t\t\t\treturn $0;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// If we’re still here, it’s a legacy reference for sure. No need for an\n\t\t\t// extra `if` check.\n\t\t\t// Decode named character references without trailing `;`, e.g. `&amp`\n\t\t\t// This is only a parse error if it gets converted to `&`, or if it is\n\t\t\t// followed by `=` in an attribute context.\n\t\t\treference = $6;\n\t\t\tnext = $7;\n\t\t\tif (next && options.isAttributeValue) {\n\t\t\t\tif (strict && next == '=') {\n\t\t\t\t\tparseError('`&` did not start a character reference');\n\t\t\t\t}\n\t\t\t\treturn $0;\n\t\t\t} else {\n\t\t\t\tif (strict) {\n\t\t\t\t\tparseError('named character reference was not terminated by a semicolon');\n\t\t\t\t}\n\t\t\t\t// Note: there is no need to check `has(decodeMapLegacy, reference)`.\n\t\t\t\treturn decodeMapLegacy[reference] + (next || '');\n\t\t\t}\n\t\t});\n\t};\n\t// Expose default options (so they can be overridden globally).\n\tdecode.options = {\n\t\t'isAttributeValue': false,\n\t\t'strict': false\n\t};\n\n\tvar escape = function (string) {\n\t\treturn string.replace(regexEscape, function ($0) {\n\t\t\t// Note: there is no need to check `has(escapeMap, $0)` here.\n\t\t\treturn escapeMap[$0];\n\t\t});\n\t};\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar he = {\n\t\t'version': '1.1.1',\n\t\t'encode': encode,\n\t\t'decode': decode,\n\t\t'escape': escape,\n\t\t'unescape': decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (true) {\n\t\t!(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {\n\t\t\treturn he;\n\t\t}).call(exports, __webpack_require__, exports, module),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t} else { var key; }\n})(this);\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../share/nodejs/webpack/buildin/module.js */ \"../../../usr/share/nodejs/webpack/buildin/module.js\")(module), __webpack_require__(/*! ./../../../share/nodejs/webpack/buildin/global.js */ \"../../../usr/share/nodejs/webpack/buildin/global.js\")))\n\n//# sourceURL=webpack://Vue//usr/lib/nodejs/he/he.js?");

/***/ }),

/***/ "../../../usr/lib/nodejs/process/browser.js":
/*!******************************************!*\
  !*** /usr/lib/nodejs/process/browser.js ***!
  \******************************************/
/*! no static exports found */
/***/ (function(module, exports) {

eval("// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout() {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n})();\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch (e) {\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch (e) {\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e) {\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e) {\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while (len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) {\n    return [];\n};\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () {\n    return '/';\n};\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function () {\n    return 0;\n};\n\n//# sourceURL=webpack://Vue//usr/lib/nodejs/process/browser.js?");

/***/ }),

/***/ "../../../usr/lib/nodejs/timers-browserify/main.js":
/*!*************************************************!*\
  !*** /usr/lib/nodejs/timers-browserify/main.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

eval("/* WEBPACK VAR INJECTION */(function(global) {var scope = typeof global !== \"undefined\" && global || typeof self !== \"undefined\" && self || window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function () {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function () {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout = exports.clearInterval = function (timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function () {};\nTimeout.prototype.close = function () {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function (item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function (item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function (item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout) item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\n__webpack_require__(/*! setimmediate */ \"../../../usr/share/nodejs/setimmediate/setImmediate.js\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = typeof self !== \"undefined\" && self.setImmediate || typeof global !== \"undefined\" && global.setImmediate || this && this.setImmediate;\nexports.clearImmediate = typeof self !== \"undefined\" && self.clearImmediate || typeof global !== \"undefined\" && global.clearImmediate || this && this.clearImmediate;\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../share/nodejs/webpack/buildin/global.js */ \"../../../usr/share/nodejs/webpack/buildin/global.js\")))\n\n//# sourceURL=webpack://Vue//usr/lib/nodejs/timers-browserify/main.js?");

/***/ }),

/***/ "../../../usr/share/nodejs/setimmediate/setImmediate.js":
/*!******************************************************!*\
  !*** /usr/share/nodejs/setimmediate/setImmediate.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

eval("/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate && global.clearImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n        // Callback can either be a function or a string\n        if (typeof callback !== \"function\") {\n            callback = new Function(\"\" + callback);\n        }\n        // Copy function arguments\n        var args = new Array(arguments.length - 1);\n        for (var i = 0; i < args.length; i++) {\n            args[i] = arguments[i + 1];\n        }\n        // Store and register the task\n        var task = { callback: callback, args: args };\n        tasksByHandle[nextHandle] = task;\n        registerImmediate(nextHandle);\n        return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n            case 0:\n                callback();\n                break;\n            case 1:\n                callback(args[0]);\n                break;\n            case 2:\n                callback(args[0], args[1]);\n                break;\n            case 3:\n                callback(args[0], args[1], args[2]);\n                break;\n            default:\n                callback.apply(undefined, args);\n                break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function (handle) {\n            process.nextTick(function () {\n                runIfPresent(handle);\n            });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function () {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function (event) {\n            if (event.source === global && typeof event.data === \"string\" && event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function (handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function (event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function (handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function (handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function (handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n    } else if (doc && doc.createElement && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n})(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self);\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ \"../../../usr/share/nodejs/webpack/buildin/global.js\"), __webpack_require__(/*! ./../../../lib/nodejs/process/browser.js */ \"../../../usr/lib/nodejs/process/browser.js\")))\n\n//# sourceURL=webpack://Vue//usr/share/nodejs/setimmediate/setImmediate.js?");

/***/ }),

/***/ "../../../usr/share/nodejs/webpack/buildin/global.js":
/*!***********************************!*\
  !*** (webpack)/buildin/global.js ***!
  \***********************************/
/*! no static exports found */
/***/ (function(module, exports) {

eval("var g;\n\n// This works in non-strict mode\ng = function () {\n\treturn this;\n}();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n//# sourceURL=webpack://Vue/(webpack)/buildin/global.js?");

/***/ }),

/***/ "../../../usr/share/nodejs/webpack/buildin/module.js":
/*!***********************************!*\
  !*** (webpack)/buildin/module.js ***!
  \***********************************/
/*! no static exports found */
/***/ (function(module, exports) {

eval("module.exports = function (module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function () {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function () {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function () {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n\n//# sourceURL=webpack://Vue/(webpack)/buildin/module.js?");

/***/ }),

/***/ "./src/compiler/codegen/events.js":
/*!****************************************!*\
  !*** ./src/compiler/codegen/events.js ***!
  \****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.genHandlers = genHandlers;\nvar fnExpRE = /^([\\w$_]+|\\([^)]*?\\))\\s*=>|^function\\s*\\(/;\nvar simplePathRE = /^[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['[^']*?']|\\[\"[^\"]*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*$/;\n\n// KeyboardEvent.keyCode aliases\nvar keyCodes = {\n  esc: 27,\n  tab: 9,\n  enter: 13,\n  space: 32,\n  up: 38,\n  left: 37,\n  right: 39,\n  down: 40,\n  'delete': [8, 46]\n\n  // KeyboardEvent.key aliases\n};var keyNames = {\n  esc: 'Escape',\n  tab: 'Tab',\n  enter: 'Enter',\n  space: ' ',\n  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.\n  up: ['Up', 'ArrowUp'],\n  left: ['Left', 'ArrowLeft'],\n  right: ['Right', 'ArrowRight'],\n  down: ['Down', 'ArrowDown'],\n  'delete': ['Backspace', 'Delete']\n\n  // #4868: modifiers that prevent the execution of the listener\n  // need to explicitly return null so that we can determine whether to remove\n  // the listener for .once\n};var genGuard = function genGuard(condition) {\n  return 'if(' + condition + ')return null;';\n};\n\nvar modifierCode = {\n  stop: '$event.stopPropagation();',\n  prevent: '$event.preventDefault();',\n  self: genGuard('$event.target !== $event.currentTarget'),\n  ctrl: genGuard('!$event.ctrlKey'),\n  shift: genGuard('!$event.shiftKey'),\n  alt: genGuard('!$event.altKey'),\n  meta: genGuard('!$event.metaKey'),\n  left: genGuard('\\'button\\' in $event && $event.button !== 0'),\n  middle: genGuard('\\'button\\' in $event && $event.button !== 1'),\n  right: genGuard('\\'button\\' in $event && $event.button !== 2')\n};\n\nfunction genHandlers(events, isNative, warn) {\n  var res = isNative ? 'nativeOn:{' : 'on:{';\n  for (var name in events) {\n    res += '\"' + name + '\":' + genHandler(name, events[name]) + ',';\n  }\n  return res.slice(0, -1) + '}';\n}\n\n// Generate handler code with binding params on Weex\n/* istanbul ignore next */\nfunction genWeexHandler(params, handlerCode) {\n  var innerHandlerCode = handlerCode;\n  var exps = params.filter(function (exp) {\n    return simplePathRE.test(exp) && exp !== '$event';\n  });\n  var bindings = exps.map(function (exp) {\n    return { '@binding': exp };\n  });\n  var args = exps.map(function (exp, i) {\n    var key = '$_' + (i + 1);\n    innerHandlerCode = innerHandlerCode.replace(exp, key);\n    return key;\n  });\n  args.push('$event');\n  return '{\\n' + ('handler:function(' + args.join(',') + '){' + innerHandlerCode + '},\\n') + ('params:' + JSON.stringify(bindings) + '\\n') + '}';\n}\n\nfunction genHandler(name, handler) {\n  if (!handler) {\n    return 'function(){}';\n  }\n\n  if (Array.isArray(handler)) {\n    return '[' + handler.map(function (handler) {\n      return genHandler(name, handler);\n    }).join(',') + ']';\n  }\n\n  var isMethodPath = simplePathRE.test(handler.value);\n  var isFunctionExpression = fnExpRE.test(handler.value);\n\n  if (!handler.modifiers) {\n    if (isMethodPath || isFunctionExpression) {\n      return handler.value;\n    }\n    /* istanbul ignore if */\n    var _WEEX__ = false;\n    if (_WEEX__ && handler.params) {\n      return genWeexHandler(handler.params, handler.value);\n    }\n    return 'function($event){' + handler.value + '}'; // inline statement\n  } else {\n    var code = '';\n    var genModifierCode = '';\n    var keys = [];\n    for (var _key in handler.modifiers) {\n      if (modifierCode[_key]) {\n        genModifierCode += modifierCode[_key];\n        // left/right\n        if (keyCodes[_key]) {\n          keys.push(_key);\n        }\n      } else if (_key === 'exact') {\n        (function () {\n          var modifiers = handler.modifiers;\n          genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta'].filter(function (keyModifier) {\n            return !modifiers[keyModifier];\n          }).map(function (keyModifier) {\n            return '$event.' + keyModifier + 'Key';\n          }).join('||'));\n        })();\n      } else {\n        keys.push(_key);\n      }\n    }\n    if (keys.length) {\n      code += genKeyFilter(keys);\n    }\n    // Make sure modifiers like prevent and stop get executed after key filtering\n    if (genModifierCode) {\n      code += genModifierCode;\n    }\n    var handlerCode = isMethodPath ? 'return ' + handler.value + '($event)' : isFunctionExpression ? 'return (' + handler.value + ')($event)' : handler.value;\n    /* istanbul ignore if */\n    if (__WEEX__ && handler.params) {\n      return genWeexHandler(handler.params, code + handlerCode);\n    }\n    return 'function($event){' + code + handlerCode + '}';\n  }\n}\n\nfunction genKeyFilter(keys) {\n  return 'if(!(\\'button\\' in $event)&&' + keys.map(genFilterCode).join('&&') + ')return null;';\n}\n\nfunction genFilterCode(key) {\n  var keyVal = parseInt(key, 10);\n  if (keyVal) {\n    return '$event.keyCode!==' + keyVal;\n  }\n  var keyCode = keyCodes[key];\n  var keyName = keyNames[key];\n  return '_k($event.keyCode,' + (JSON.stringify(key) + ',') + (JSON.stringify(keyCode) + ',') + '$event.key,' + ('' + JSON.stringify(keyName)) + ')';\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/codegen/events.js?");

/***/ }),

/***/ "./src/compiler/codegen/index.js":
/*!***************************************!*\
  !*** ./src/compiler/codegen/index.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.CodegenState = undefined;\nexports.generate = generate;\nexports.genElement = genElement;\nexports.genIf = genIf;\nexports.genFor = genFor;\nexports.genData = genData;\nexports.genChildren = genChildren;\nexports.genText = genText;\nexports.genComment = genComment;\n\nvar _events = __webpack_require__(/*! ./events */ \"./src/compiler/codegen/events.js\");\n\nvar _index = __webpack_require__(/*! ../directives/index */ \"./src/compiler/directives/index.js\");\n\nvar _index2 = _interopRequireDefault(_index);\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _helpers = __webpack_require__(/*! ../helpers */ \"./src/compiler/helpers.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar CodegenState = exports.CodegenState = function CodegenState(options) {\n  _classCallCheck(this, CodegenState);\n\n  this.options = options;\n  this.warn = options.warn || _helpers.baseWarn;\n  this.transforms = (0, _helpers.pluckModuleFunction)(options.modules, 'transformCode');\n  this.dataGenFns = (0, _helpers.pluckModuleFunction)(options.modules, 'genData');\n  this.directives = (0, _util.extend)((0, _util.extend)({}, _index2.default), options.directives);\n  var isReservedTag = options.isReservedTag || _util.no;\n  this.maybeComponent = function (el) {\n    return !isReservedTag(el.tag);\n  };\n  this.onceId = 0;\n  this.staticRenderFns = [];\n};\n\nfunction generate(ast, options) {\n  var state = new CodegenState(options);\n  var code = ast ? genElement(ast, state) : '_c(\"div\")';\n  return {\n    render: 'with(this){return ' + code + '}',\n    staticRenderFns: state.staticRenderFns\n  };\n}\n\nfunction genElement(el, state) {\n  if (el.staticRoot && !el.staticProcessed) {\n    return genStatic(el, state);\n  } else if (el.once && !el.onceProcessed) {\n    return genOnce(el, state);\n  } else if (el.for && !el.forProcessed) {\n    return genFor(el, state);\n  } else if (el.if && !el.ifProcessed) {\n    return genIf(el, state);\n  } else if (el.tag === 'template' && !el.slotTarget) {\n    return genChildren(el, state) || 'void 0';\n  } else if (el.tag === 'slot') {\n    return genSlot(el, state);\n  } else {\n    // component or element\n    var _code = void 0;\n    if (el.component) {\n      _code = genComponent(el.component, el, state);\n    } else {\n      var data = el.plain ? undefined : genData(el, state);\n\n      var children = el.inlineTemplate ? null : genChildren(el, state, true);\n      _code = '_c(\\'' + el.tag + '\\'' + (data ? ',' + data : '' // data\n      ) + (children ? ',' + children : '' // children\n      ) + ')';\n    }\n    // module transforms\n    for (var i = 0; i < state.transforms.length; i++) {\n      _code = state.transforms[i](el, _code);\n    }\n    return _code;\n  }\n}\n\n// hoist static sub-trees out\nfunction genStatic(el, state) {\n  el.staticProcessed = true;\n  state.staticRenderFns.push('with(this){return ' + genElement(el, state) + '}');\n  return '_m(' + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ')';\n}\n\n// v-once\nfunction genOnce(el, state) {\n  el.onceProcessed = true;\n  if (el.if && !el.ifProcessed) {\n    return genIf(el, state);\n  } else if (el.staticInFor) {\n    var _key = '';\n    var parent = el.parent;\n    while (parent) {\n      if (parent.for) {\n        _key = parent.key;\n        break;\n      }\n      parent = parent.parent;\n    }\n    if (!_key) {\n      \"development\" !== 'production' && state.warn('v-once can only be used inside v-for that is keyed. ');\n      return genElement(el, state);\n    }\n    return '_o(' + genElement(el, state) + ',' + state.onceId++ + ',' + _key + ')';\n  } else {\n    return genStatic(el, state);\n  }\n}\n\nfunction genIf(el, state, altGen, altEmpty) {\n  el.ifProcessed = true; // avoid recursion\n  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);\n}\n\nfunction genIfConditions(conditions, state, altGen, altEmpty) {\n  if (!conditions.length) {\n    return altEmpty || '_e()';\n  }\n\n  var condition = conditions.shift();\n  if (condition.exp) {\n    return '(' + condition.exp + ')?' + genTernaryExp(condition.block) + ':' + genIfConditions(conditions, state, altGen, altEmpty);\n  } else {\n    return '' + genTernaryExp(condition.block);\n  }\n\n  // v-if with v-once should generate code like (a)?_m(0):_m(1)\n  function genTernaryExp(el) {\n    return altGen ? altGen(el, state) : el.once ? genOnce(el, state) : genElement(el, state);\n  }\n}\n\nfunction genFor(el, state, altGen, altHelper) {\n  var exp = el.for;\n  var alias = el.alias;\n  var iterator1 = el.iterator1 ? ',' + el.iterator1 : '';\n  var iterator2 = el.iterator2 ? ',' + el.iterator2 : '';\n\n  if (\"development\" !== 'production' && state.maybeComponent(el) && el.tag !== 'slot' && el.tag !== 'template' && !el.key) {\n    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.', true /* tip */\n    );\n  }\n\n  el.forProcessed = true; // avoid recursion\n  return (altHelper || '_l') + '((' + exp + '),' + ('function(' + alias + iterator1 + iterator2 + '){') + ('return ' + (altGen || genElement)(el, state)) + '})';\n}\n\nfunction genData(el, state) {\n  var data = '{';\n\n  // directives first.\n  // directives may mutate the el's other properties before they are generated.\n  var dirs = genDirectives(el, state);\n  if (dirs) data += dirs + ',';\n\n  // key\n  if (el.key) {\n    data += 'key:' + el.key + ',';\n  }\n  // ref\n  if (el.ref) {\n    data += 'ref:' + el.ref + ',';\n  }\n  if (el.refInFor) {\n    data += 'refInFor:true,';\n  }\n  // pre\n  if (el.pre) {\n    data += 'pre:true,';\n  }\n  // record original tag name for components using \"is\" attribute\n  if (el.component) {\n    data += 'tag:\"' + el.tag + '\",';\n  }\n  // module data generation functions\n  for (var i = 0; i < state.dataGenFns.length; i++) {\n    data += state.dataGenFns[i](el);\n  }\n  // attributes\n  if (el.attrs) {\n    data += 'attrs:{' + genProps(el.attrs) + '},';\n  }\n  // DOM props\n  if (el.props) {\n    data += 'domProps:{' + genProps(el.props) + '},';\n  }\n  // event handlers\n  if (el.events) {\n    data += (0, _events.genHandlers)(el.events, false, state.warn) + ',';\n  }\n  if (el.nativeEvents) {\n    data += (0, _events.genHandlers)(el.nativeEvents, true, state.warn) + ',';\n  }\n  // slot target\n  // only for non-scoped slots\n  if (el.slotTarget && !el.slotScope) {\n    data += 'slot:' + el.slotTarget + ',';\n  }\n  // scoped slots\n  if (el.scopedSlots) {\n    data += genScopedSlots(el.scopedSlots, state) + ',';\n  }\n  // component v-model\n  if (el.model) {\n    data += 'model:{value:' + el.model.value + ',callback:' + el.model.callback + ',expression:' + el.model.expression + '},';\n  }\n  // inline-template\n  if (el.inlineTemplate) {\n    var inlineTemplate = genInlineTemplate(el, state);\n    if (inlineTemplate) {\n      data += inlineTemplate + ',';\n    }\n  }\n  data = data.replace(/,$/, '') + '}';\n  // v-bind data wrap\n  if (el.wrapData) {\n    data = el.wrapData(data);\n  }\n  // v-on data wrap\n  if (el.wrapListeners) {\n    data = el.wrapListeners(data);\n  }\n  return data;\n}\n\nfunction genDirectives(el, state) {\n  var dirs = el.directives;\n  if (!dirs) return;\n  var res = 'directives:[';\n  var hasRuntime = false;\n  var i = void 0,\n      l = void 0,\n      dir = void 0,\n      needRuntime = void 0;\n  for (i = 0, l = dirs.length; i < l; i++) {\n    dir = dirs[i];\n    needRuntime = true;\n    var gen = state.directives[dir.name];\n    if (gen) {\n      // compile-time directive that manipulates AST.\n      // returns true if it also needs a runtime counterpart.\n      needRuntime = !!gen(el, dir, state.warn);\n    }\n    if (needRuntime) {\n      hasRuntime = true;\n      res += '{name:\"' + dir.name + '\",rawName:\"' + dir.rawName + '\"' + (dir.value ? ',value:(' + dir.value + '),expression:' + JSON.stringify(dir.value) : '') + (dir.arg ? ',arg:\"' + dir.arg + '\"' : '') + (dir.modifiers ? ',modifiers:' + JSON.stringify(dir.modifiers) : '') + '},';\n    }\n  }\n  if (hasRuntime) {\n    return res.slice(0, -1) + ']';\n  }\n}\n\nfunction genInlineTemplate(el, state) {\n  var ast = el.children[0];\n  if (\"development\" !== 'production' && (el.children.length !== 1 || ast.type !== 1)) {\n    state.warn('Inline-template components must have exactly one child element.');\n  }\n  if (ast.type === 1) {\n    var inlineRenderFns = generate(ast, state.options);\n    return 'inlineTemplate:{render:function(){' + inlineRenderFns.render + '},staticRenderFns:[' + inlineRenderFns.staticRenderFns.map(function (code) {\n      return 'function(){' + code + '}';\n    }).join(',') + ']}';\n  }\n}\n\nfunction genScopedSlots(slots, state) {\n  return 'scopedSlots:_u([' + Object.keys(slots).map(function (key) {\n    return genScopedSlot(key, slots[key], state);\n  }).join(',') + '])';\n}\n\nfunction genScopedSlot(key, el, state) {\n  if (el.for && !el.forProcessed) {\n    return genForScopedSlot(key, el, state);\n  }\n  var fn = 'function(' + String(el.slotScope) + '){' + ('return ' + (el.tag === 'template' ? el.if ? el.if + '?' + (genChildren(el, state) || 'undefined') + ':undefined' : genChildren(el, state) || 'undefined' : genElement(el, state)) + '}');\n  return '{key:' + key + ',fn:' + fn + '}';\n}\n\nfunction genForScopedSlot(key, el, state) {\n  var exp = el.for;\n  var alias = el.alias;\n  var iterator1 = el.iterator1 ? ',' + el.iterator1 : '';\n  var iterator2 = el.iterator2 ? ',' + el.iterator2 : '';\n  el.forProcessed = true; // avoid recursion\n  return '_l((' + exp + '),' + ('function(' + alias + iterator1 + iterator2 + '){') + ('return ' + genScopedSlot(key, el, state)) + '})';\n}\n\nfunction genChildren(el, state, checkSkip, altGenElement, altGenNode) {\n  var children = el.children;\n  if (children.length) {\n    var _el = children[0];\n    // optimize single v-for\n    if (children.length === 1 && _el.for && _el.tag !== 'template' && _el.tag !== 'slot') {\n      return (altGenElement || genElement)(_el, state);\n    }\n    var normalizationType = checkSkip ? getNormalizationType(children, state.maybeComponent) : 0;\n    var gen = altGenNode || genNode;\n    return '[' + children.map(function (c) {\n      return gen(c, state);\n    }).join(',') + ']' + (normalizationType ? ',' + normalizationType : '');\n  }\n}\n\n// determine the normalization needed for the children array.\n// 0: no normalization needed\n// 1: simple normalization needed (possible 1-level deep nested array)\n// 2: full normalization needed\nfunction getNormalizationType(children, maybeComponent) {\n  var res = 0;\n  for (var i = 0; i < children.length; i++) {\n    var _el2 = children[i];\n    if (_el2.type !== 1) {\n      continue;\n    }\n    if (needsNormalization(_el2) || _el2.ifConditions && _el2.ifConditions.some(function (c) {\n      return needsNormalization(c.block);\n    })) {\n      res = 2;\n      break;\n    }\n    if (maybeComponent(_el2) || _el2.ifConditions && _el2.ifConditions.some(function (c) {\n      return maybeComponent(c.block);\n    })) {\n      res = 1;\n    }\n  }\n  return res;\n}\n\nfunction needsNormalization(el) {\n  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';\n}\n\nfunction genNode(node, state) {\n  if (node.type === 1) {\n    return genElement(node, state);\n  }if (node.type === 3 && node.isComment) {\n    return genComment(node);\n  } else {\n    return genText(node);\n  }\n}\n\nfunction genText(text) {\n  return '_v(' + (text.type === 2 ? text.expression // no need for () because already wrapped in _s()\n  : transformSpecialNewlines(JSON.stringify(text.text))) + ')';\n}\n\nfunction genComment(comment) {\n  return '_e(' + JSON.stringify(comment.text) + ')';\n}\n\nfunction genSlot(el, state) {\n  var slotName = el.slotName || '\"default\"';\n  var children = genChildren(el, state);\n  var res = '_t(' + slotName + (children ? ',' + children : '');\n  var attrs = el.attrs && '{' + el.attrs.map(function (a) {\n    return (0, _util.camelize)(a.name) + ':' + a.value;\n  }).join(',') + '}';\n  var bind = el.attrsMap['v-bind'];\n  if ((attrs || bind) && !children) {\n    res += ',null';\n  }\n  if (attrs) {\n    res += ',' + attrs;\n  }\n  if (bind) {\n    res += (attrs ? '' : ',null') + ',' + bind;\n  }\n  return res + ')';\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent(componentName, el, state) {\n  var children = el.inlineTemplate ? null : genChildren(el, state, true);\n  return '_c(' + componentName + ',' + genData(el, state) + (children ? ',' + children : '') + ')';\n}\n\nfunction genProps(props) {\n  var __WEEX__ = false;\n  var res = '';\n  for (var i = 0; i < props.length; i++) {\n    var prop = props[i];\n    /* istanbul ignore if */\n    if (__WEEX__) {\n      res += '\"' + prop.name + '\":' + generateValue(prop.value) + ',';\n    } else {\n      res += '\"' + prop.name + '\":' + transformSpecialNewlines(prop.value) + ',';\n    }\n  }\n  return res.slice(0, -1);\n}\n\n/* istanbul ignore next */\nfunction generateValue(value) {\n  if (typeof value === 'string') {\n    return transformSpecialNewlines(value);\n  }\n  return JSON.stringify(value);\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines(text) {\n  return text.replace(/\\u2028/g, '\\\\u2028').replace(/\\u2029/g, '\\\\u2029');\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/codegen/index.js?");

/***/ }),

/***/ "./src/compiler/create-compiler.js":
/*!*****************************************!*\
  !*** ./src/compiler/create-compiler.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createCompilerCreator = createCompilerCreator;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _errorDetector = __webpack_require__(/*! ./error-detector */ \"./src/compiler/error-detector.js\");\n\nvar _toFunction = __webpack_require__(/*! ./to-function */ \"./src/compiler/to-function.js\");\n\nfunction createCompilerCreator(baseCompile) {\n  return function createCompiler(baseOptions) {\n    function compile(template, options) {\n      var finalOptions = Object.create(baseOptions);\n      var errors = [];\n      var tips = [];\n      finalOptions.warn = function (msg, tip) {\n        (tip ? tips : errors).push(msg);\n      };\n\n      if (options) {\n        // merge custom modules\n        if (options.modules) {\n          finalOptions.modules = (baseOptions.modules || []).concat(options.modules);\n        }\n        // merge custom directives\n        if (options.directives) {\n          finalOptions.directives = (0, _util.extend)(Object.create(baseOptions.directives || null), options.directives);\n        }\n        // copy other options\n        for (var key in options) {\n          if (key !== 'modules' && key !== 'directives') {\n            finalOptions[key] = options[key];\n          }\n        }\n      }\n\n      var compiled = baseCompile(template, finalOptions);\n      if (true) {\n        errors.push.apply(errors, (0, _errorDetector.detectErrors)(compiled.ast));\n      }\n      compiled.errors = errors;\n      compiled.tips = tips;\n      return compiled;\n    }\n\n    return {\n      compile: compile,\n      compileToFunctions: (0, _toFunction.createCompileToFunctionFn)(compile)\n    };\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/create-compiler.js?");

/***/ }),

/***/ "./src/compiler/directives/bind.js":
/*!*****************************************!*\
  !*** ./src/compiler/directives/bind.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = bind;\nfunction bind(el, dir) {\n  el.wrapData = function (code) {\n    return '_b(' + code + ',\\'' + el.tag + '\\',' + dir.value + ',' + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ')';\n  };\n}\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/compiler/directives/bind.js?");

/***/ }),

/***/ "./src/compiler/directives/index.js":
/*!******************************************!*\
  !*** ./src/compiler/directives/index.js ***!
  \******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _on = __webpack_require__(/*! ./on */ \"./src/compiler/directives/on.js\");\n\nvar _on2 = _interopRequireDefault(_on);\n\nvar _bind = __webpack_require__(/*! ./bind */ \"./src/compiler/directives/bind.js\");\n\nvar _bind2 = _interopRequireDefault(_bind);\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = {\n  on: _on2.default,\n  bind: _bind2.default,\n  cloak: _util.noop\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/compiler/directives/index.js?");

/***/ }),

/***/ "./src/compiler/directives/model.js":
/*!******************************************!*\
  !*** ./src/compiler/directives/model.js ***!
  \******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.genComponentModel = genComponentModel;\nexports.genAssignmentCode = genAssignmentCode;\nexports.parseModel = parseModel;\n\n\n/**\n * Cross-platform code generation for component v-model\n */\nfunction genComponentModel(el, value, modifiers) {\n  var _ref = modifiers || {},\n      number = _ref.number,\n      trim = _ref.trim;\n\n  var baseValueExpression = '$$v';\n  var valueExpression = baseValueExpression;\n  if (trim) {\n    valueExpression = '(typeof ' + baseValueExpression + ' === \\'string\\'' + ('? ' + baseValueExpression + '.trim()') + (': ' + baseValueExpression + ')');\n  }\n  if (number) {\n    valueExpression = '_n(' + valueExpression + ')';\n  }\n  var assignment = genAssignmentCode(value, valueExpression);\n\n  el.model = {\n    value: '(' + value + ')',\n    expression: '\"' + value + '\"',\n    callback: 'function (' + baseValueExpression + ') {' + assignment + '}'\n  };\n}\n\n/**\n * Cross-platform codegen helper for generating v-model value assignment code.\n */\nfunction genAssignmentCode(value, assignment) {\n  var res = parseModel(value);\n  if (res.key === null) {\n    return value + '=' + assignment;\n  } else {\n    return '$set(' + res.exp + ', ' + res.key + ', ' + assignment + ')';\n  }\n}\n\n/**\n * Parse a v-model expression into a base path and a final key segment.\n * Handles both dot-path and possible square brackets.\n *\n * Possible cases:\n *\n * - test\n * - test[key]\n * - test[test1[key]]\n * - test[\"a\"][key]\n * - xxx.test[a[a].test1[key]]\n * - test.xxx.a[\"asa\"][test1[key]]\n *\n */\n\nvar len = void 0,\n    str = void 0,\n    chr = void 0,\n    index = void 0,\n    expressionPos = void 0,\n    expressionEndPos = void 0;\n\nfunction parseModel(val) {\n  // Fix https://github.com/vuejs/vue/pull/7730\n  // allow v-model=\"obj.val \" (trailing whitespace)\n  val = val.trim();\n  len = val.length;\n\n  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {\n    index = val.lastIndexOf('.');\n    if (index > -1) {\n      return {\n        exp: val.slice(0, index),\n        key: '\"' + val.slice(index + 1) + '\"'\n      };\n    } else {\n      return {\n        exp: val,\n        key: null\n      };\n    }\n  }\n\n  str = val;\n  index = expressionPos = expressionEndPos = 0;\n\n  while (!eof()) {\n    chr = next();\n    /* istanbul ignore if */\n    if (isStringStart(chr)) {\n      parseString(chr);\n    } else if (chr === 0x5B) {\n      parseBracket(chr);\n    }\n  }\n\n  return {\n    exp: val.slice(0, expressionPos),\n    key: val.slice(expressionPos + 1, expressionEndPos)\n  };\n}\n\nfunction next() {\n  return str.charCodeAt(++index);\n}\n\nfunction eof() {\n  return index >= len;\n}\n\nfunction isStringStart(chr) {\n  return chr === 0x22 || chr === 0x27;\n}\n\nfunction parseBracket(chr) {\n  var inBracket = 1;\n  expressionPos = index;\n  while (!eof()) {\n    chr = next();\n    if (isStringStart(chr)) {\n      parseString(chr);\n      continue;\n    }\n    if (chr === 0x5B) inBracket++;\n    if (chr === 0x5D) inBracket--;\n    if (inBracket === 0) {\n      expressionEndPos = index;\n      break;\n    }\n  }\n}\n\nfunction parseString(chr) {\n  var stringQuote = chr;\n  while (!eof()) {\n    chr = next();\n    if (chr === stringQuote) {\n      break;\n    }\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/directives/model.js?");

/***/ }),

/***/ "./src/compiler/directives/on.js":
/*!***************************************!*\
  !*** ./src/compiler/directives/on.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = on;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nfunction on(el, dir) {\n  if (\"development\" !== 'production' && dir.modifiers) {\n    (0, _index.warn)('v-on without argument does not support modifiers.');\n  }\n  el.wrapListeners = function (code) {\n    return '_g(' + code + ',' + dir.value + ')';\n  };\n}\n\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/compiler/directives/on.js?");

/***/ }),

/***/ "./src/compiler/error-detector.js":
/*!****************************************!*\
  !*** ./src/compiler/error-detector.js ***!
  \****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.detectErrors = detectErrors;\n\nvar _index = __webpack_require__(/*! ./parser/index */ \"./src/compiler/parser/index.js\");\n\n// these keywords should not appear inside expressions, but operators like\n// typeof, instanceof and in are allowed\nvar 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');\n\n// these unary operators should not be used as property/method names\n\n\nvar unaryOperatorsRE = new RegExp('\\\\b' + 'delete,typeof,void'.split(',').join('\\\\s*\\\\([^\\\\)]*\\\\)|\\\\b') + '\\\\s*\\\\([^\\\\)]*\\\\)');\n\n// strip strings in expressions\nvar stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n// detect problematic expressions in a template\nfunction detectErrors(ast) {\n  var errors = [];\n  if (ast) {\n    checkNode(ast, errors);\n  }\n  return errors;\n}\n\nfunction checkNode(node, errors) {\n  if (node.type === 1) {\n    for (var name in node.attrsMap) {\n      if (_index.dirRE.test(name)) {\n        var value = node.attrsMap[name];\n        if (value) {\n          if (name === 'v-for') {\n            checkFor(node, 'v-for=\"' + value + '\"', errors);\n          } else if (_index.onRE.test(name)) {\n            checkEvent(value, name + '=\"' + value + '\"', errors);\n          } else {\n            checkExpression(value, name + '=\"' + value + '\"', errors);\n          }\n        }\n      }\n    }\n    if (node.children) {\n      for (var i = 0; i < node.children.length; i++) {\n        checkNode(node.children[i], errors);\n      }\n    }\n  } else if (node.type === 2) {\n    checkExpression(node.expression, node.text, errors);\n  }\n}\n\nfunction checkEvent(exp, text, errors) {\n  var stipped = exp.replace(stripStringRE, '');\n  var keywordMatch = stipped.match(unaryOperatorsRE);\n  if (keywordMatch && stipped.charAt(keywordMatch.index - 1) !== '$') {\n    errors.push('avoid using JavaScript unary operator as property name: ' + ('\"' + keywordMatch[0] + '\" in expression ' + text.trim()));\n  }\n  checkExpression(exp, text, errors);\n}\n\nfunction checkFor(node, text, errors) {\n  checkExpression(node.for || '', text, errors);\n  checkIdentifier(node.alias, 'v-for alias', text, errors);\n  checkIdentifier(node.iterator1, 'v-for iterator', text, errors);\n  checkIdentifier(node.iterator2, 'v-for iterator', text, errors);\n}\n\nfunction checkIdentifier(ident, type, text, errors) {\n  if (typeof ident === 'string') {\n    try {\n      new Function('var ' + ident + '=_');\n    } catch (e) {\n      errors.push('invalid ' + type + ' \"' + ident + '\" in expression: ' + text.trim());\n    }\n  }\n}\n\nfunction checkExpression(exp, text, errors) {\n  try {\n    new Function('return ' + exp);\n  } catch (e) {\n    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n    if (keywordMatch) {\n      errors.push('avoid using JavaScript keyword as property name: ' + ('\"' + keywordMatch[0] + '\"\\n  Raw expression: ' + text.trim()));\n    } else {\n      errors.push('invalid expression: ' + e.message + ' in\\n\\n' + ('    ' + exp + '\\n\\n') + ('  Raw expression: ' + text.trim() + '\\n'));\n    }\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/error-detector.js?");

/***/ }),

/***/ "./src/compiler/helpers.js":
/*!*********************************!*\
  !*** ./src/compiler/helpers.js ***!
  \*********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.baseWarn = baseWarn;\nexports.pluckModuleFunction = pluckModuleFunction;\nexports.addProp = addProp;\nexports.addAttr = addAttr;\nexports.addRawAttr = addRawAttr;\nexports.addDirective = addDirective;\nexports.addHandler = addHandler;\nexports.getBindingAttr = getBindingAttr;\nexports.getAndRemoveAttr = getAndRemoveAttr;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _filterParser = __webpack_require__(/*! ./parser/filter-parser */ \"./src/compiler/parser/filter-parser.js\");\n\nfunction baseWarn(msg) {\n  console.error('[Vue compiler]: ' + msg);\n}\n\nfunction pluckModuleFunction(modules, key) {\n  return modules ? modules.map(function (m) {\n    return m[key];\n  }).filter(function (_) {\n    return _;\n  }) : [];\n}\n\nfunction addProp(el, name, value) {\n  (el.props || (el.props = [])).push({ name: name, value: value });\n  el.plain = false;\n}\n\nfunction addAttr(el, name, value) {\n  (el.attrs || (el.attrs = [])).push({ name: name, value: value });\n  el.plain = false;\n}\n\n// add a raw attr (use this in preTransforms)\nfunction addRawAttr(el, name, value) {\n  el.attrsMap[name] = value;\n  el.attrsList.push({ name: name, value: value });\n}\n\nfunction addDirective(el, name, rawName, value, arg, modifiers) {\n  (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers });\n  el.plain = false;\n}\n\nfunction addHandler(el, name, value, modifiers, important, warn) {\n  modifiers = modifiers || _util.emptyObject;\n  // warn prevent and passive modifier\n  /* istanbul ignore if */\n  if (\"development\" !== 'production' && warn && modifiers.prevent && modifiers.passive) {\n    warn('passive and prevent can\\'t be used together. ' + 'Passive handler can\\'t prevent default event.');\n  }\n\n  // check capture modifier\n  if (modifiers.capture) {\n    delete modifiers.capture;\n    name = '!' + name; // mark the event as captured\n  }\n  if (modifiers.once) {\n    delete modifiers.once;\n    name = '~' + name; // mark the event as once\n  }\n  /* istanbul ignore if */\n  if (modifiers.passive) {\n    delete modifiers.passive;\n    name = '&' + name; // mark the event as passive\n  }\n\n  // normalize click.right and click.middle since they don't actually fire\n  // this is technically browser-specific, but at least for now browsers are\n  // the only target envs that have right/middle clicks.\n  if (name === 'click') {\n    if (modifiers.right) {\n      name = 'contextmenu';\n      delete modifiers.right;\n    } else if (modifiers.middle) {\n      name = 'mouseup';\n    }\n  }\n\n  var events = void 0;\n  if (modifiers.native) {\n    delete modifiers.native;\n    events = el.nativeEvents || (el.nativeEvents = {});\n  } else {\n    events = el.events || (el.events = {});\n  }\n\n  var newHandler = {\n    value: value.trim()\n  };\n  if (modifiers !== _util.emptyObject) {\n    newHandler.modifiers = modifiers;\n  }\n\n  var handlers = events[name];\n  /* istanbul ignore if */\n  if (Array.isArray(handlers)) {\n    important ? handlers.unshift(newHandler) : handlers.push(newHandler);\n  } else if (handlers) {\n    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];\n  } else {\n    events[name] = newHandler;\n  }\n\n  el.plain = false;\n}\n\nfunction getBindingAttr(el, name, getStatic) {\n  var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);\n  if (dynamicValue != null) {\n    return (0, _filterParser.parseFilters)(dynamicValue);\n  } else if (getStatic !== false) {\n    var staticValue = getAndRemoveAttr(el, name);\n    if (staticValue != null) {\n      return JSON.stringify(staticValue);\n    }\n  }\n}\n\n// note: this only removes the attr from the Array (attrsList) so that it\n// doesn't get processed by processAttrs.\n// By default it does NOT remove it from the map (attrsMap) because the map is\n// needed during codegen.\nfunction getAndRemoveAttr(el, name, removeFromMap) {\n  var val = void 0;\n  if ((val = el.attrsMap[name]) != null) {\n    var list = el.attrsList;\n    for (var i = 0, l = list.length; i < l; i++) {\n      if (list[i].name === name) {\n        list.splice(i, 1);\n        break;\n      }\n    }\n  }\n  if (removeFromMap) {\n    delete el.attrsMap[name];\n  }\n  return val;\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/helpers.js?");

/***/ }),

/***/ "./src/compiler/index.js":
/*!*******************************!*\
  !*** ./src/compiler/index.js ***!
  \*******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createCompiler = undefined;\n\nvar _index = __webpack_require__(/*! ./parser/index */ \"./src/compiler/parser/index.js\");\n\nvar _optimizer = __webpack_require__(/*! ./optimizer */ \"./src/compiler/optimizer.js\");\n\nvar _index2 = __webpack_require__(/*! ./codegen/index */ \"./src/compiler/codegen/index.js\");\n\nvar _createCompiler = __webpack_require__(/*! ./create-compiler */ \"./src/compiler/create-compiler.js\");\n\n// `createCompilerCreator` allows creating compilers that use alternative\n// parser/optimizer/codegen, e.g the SSR optimizing compiler.\n// Here we just export a default compiler using the default parts.\nvar createCompiler = exports.createCompiler = (0, _createCompiler.createCompilerCreator)(function baseCompile(template, options) {\n  var ast = (0, _index.parse)(template.trim(), options);\n  if (options.optimize !== false) {\n    (0, _optimizer.optimize)(ast, options);\n  }\n  var code = (0, _index2.generate)(ast, options);\n  return {\n    ast: ast,\n    render: code.render,\n    staticRenderFns: code.staticRenderFns\n  };\n});\n\n//# sourceURL=webpack://Vue/./src/compiler/index.js?");

/***/ }),

/***/ "./src/compiler/optimizer.js":
/*!***********************************!*\
  !*** ./src/compiler/optimizer.js ***!
  \***********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.optimize = optimize;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar isStaticKey = void 0;\n\nvar isPlatformReservedTag = void 0;\n\nvar genStaticKeysCached = (0, _util.cached)(genStaticKeys);\n\n/**\n * Goal of the optimizer: walk the generated template AST tree\n * and detect sub-trees that are purely static, i.e. parts of\n * the DOM that never needs to change.\n *\n * Once we detect these sub-trees, we can:\n *\n * 1. Hoist them into constants, so that we no longer need to\n *    create fresh nodes for them on each re-render;\n * 2. Completely skip them in the patching process.\n */\nfunction optimize(root, options) {\n  if (!root) return;\n  isStaticKey = genStaticKeysCached(options.staticKeys || '');\n  isPlatformReservedTag = options.isReservedTag || _util.no;\n  // first pass: mark all non-static nodes.\n  markStatic(root);\n  // second pass: mark static roots.\n  markStaticRoots(root, false);\n}\n\nfunction genStaticKeys(keys) {\n  return (0, _util.makeMap)('type,tag,attrsList,attrsMap,plain,parent,children,attrs' + (keys ? ',' + keys : ''));\n}\n\nfunction markStatic(node) {\n  node.static = isStatic(node);\n  if (node.type === 1) {\n    // do not make component slot content static. this avoids\n    // 1. components not able to mutate slot nodes\n    // 2. static slot content fails for hot-reloading\n    if (!isPlatformReservedTag(node.tag) && node.tag !== 'slot' && node.attrsMap['inline-template'] == null) {\n      return;\n    }\n    for (var i = 0, l = node.children.length; i < l; i++) {\n      var child = node.children[i];\n      markStatic(child);\n      if (!child.static) {\n        node.static = false;\n      }\n    }\n    if (node.ifConditions) {\n      for (var _i = 1, _l = node.ifConditions.length; _i < _l; _i++) {\n        var block = node.ifConditions[_i].block;\n        markStatic(block);\n        if (!block.static) {\n          node.static = false;\n        }\n      }\n    }\n  }\n}\n\nfunction markStaticRoots(node, isInFor) {\n  if (node.type === 1) {\n    if (node.static || node.once) {\n      node.staticInFor = isInFor;\n    }\n    // For a node to qualify as a static root, it should have children that\n    // are not just static text. Otherwise the cost of hoisting out will\n    // outweigh the benefits and it's better off to just always render it fresh.\n    if (node.static && node.children.length && !(node.children.length === 1 && node.children[0].type === 3)) {\n      node.staticRoot = true;\n      return;\n    } else {\n      node.staticRoot = false;\n    }\n    if (node.children) {\n      for (var i = 0, l = node.children.length; i < l; i++) {\n        markStaticRoots(node.children[i], isInFor || !!node.for);\n      }\n    }\n    if (node.ifConditions) {\n      for (var _i2 = 1, _l2 = node.ifConditions.length; _i2 < _l2; _i2++) {\n        markStaticRoots(node.ifConditions[_i2].block, isInFor);\n      }\n    }\n  }\n}\n\nfunction isStatic(node) {\n  if (node.type === 2) {\n    // expression\n    return false;\n  }\n  if (node.type === 3) {\n    // text\n    return true;\n  }\n  return !!(node.pre || !node.hasBindings && // no dynamic bindings\n  !node.if && !node.for && // not v-if or v-for or v-else\n  !(0, _util.isBuiltInTag)(node.tag) && // not a built-in\n  isPlatformReservedTag(node.tag) && // not a component\n  !isDirectChildOfTemplateFor(node) && Object.keys(node).every(isStaticKey));\n}\n\nfunction isDirectChildOfTemplateFor(node) {\n  while (node.parent) {\n    node = node.parent;\n    if (node.tag !== 'template') {\n      return false;\n    }\n    if (node.for) {\n      return true;\n    }\n  }\n  return false;\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/optimizer.js?");

/***/ }),

/***/ "./src/compiler/parser/filter-parser.js":
/*!**********************************************!*\
  !*** ./src/compiler/parser/filter-parser.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.parseFilters = parseFilters;\nvar validDivisionCharRE = /[\\w).+\\-_$\\]]/;\n\nfunction parseFilters(exp) {\n  var inSingle = false;\n  var inDouble = false;\n  var inTemplateString = false;\n  var inRegex = false;\n  var curly = 0;\n  var square = 0;\n  var paren = 0;\n  var lastFilterIndex = 0;\n  var c = void 0,\n      prev = void 0,\n      i = void 0,\n      expression = void 0,\n      filters = void 0;\n\n  for (i = 0; i < exp.length; i++) {\n    prev = c;\n    c = exp.charCodeAt(i);\n    if (inSingle) {\n      if (c === 0x27 && prev !== 0x5C) inSingle = false;\n    } else if (inDouble) {\n      if (c === 0x22 && prev !== 0x5C) inDouble = false;\n    } else if (inTemplateString) {\n      if (c === 0x60 && prev !== 0x5C) inTemplateString = false;\n    } else if (inRegex) {\n      if (c === 0x2f && prev !== 0x5C) inRegex = false;\n    } else if (c === 0x7C && // pipe\n    exp.charCodeAt(i + 1) !== 0x7C && exp.charCodeAt(i - 1) !== 0x7C && !curly && !square && !paren) {\n      if (expression === undefined) {\n        // first filter, end of expression\n        lastFilterIndex = i + 1;\n        expression = exp.slice(0, i).trim();\n      } else {\n        pushFilter();\n      }\n    } else {\n      switch (c) {\n        case 0x22:\n          inDouble = true;break; // \"\n        case 0x27:\n          inSingle = true;break; // '\n        case 0x60:\n          inTemplateString = true;break; // `\n        case 0x28:\n          paren++;break; // (\n        case 0x29:\n          paren--;break; // )\n        case 0x5B:\n          square++;break; // [\n        case 0x5D:\n          square--;break; // ]\n        case 0x7B:\n          curly++;break; // {\n        case 0x7D:\n          curly--;break; // }\n      }\n      if (c === 0x2f) {\n        // /\n        var j = i - 1;\n        var p = void 0;\n        // find first non-whitespace prev char\n        for (; j >= 0; j--) {\n          p = exp.charAt(j);\n          if (p !== ' ') break;\n        }\n        if (!p || !validDivisionCharRE.test(p)) {\n          inRegex = true;\n        }\n      }\n    }\n  }\n\n  if (expression === undefined) {\n    expression = exp.slice(0, i).trim();\n  } else if (lastFilterIndex !== 0) {\n    pushFilter();\n  }\n\n  function pushFilter() {\n    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());\n    lastFilterIndex = i + 1;\n  }\n\n  if (filters) {\n    for (i = 0; i < filters.length; i++) {\n      expression = wrapFilter(expression, filters[i]);\n    }\n  }\n\n  return expression;\n}\n\nfunction wrapFilter(exp, filter) {\n  var i = filter.indexOf('(');\n  if (i < 0) {\n    // _f: resolveFilter\n    return '_f(\"' + filter + '\")(' + exp + ')';\n  } else {\n    var name = filter.slice(0, i);\n    var args = filter.slice(i + 1);\n    return '_f(\"' + name + '\")(' + exp + (args !== ')' ? ',' + args : args);\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/parser/filter-parser.js?");

/***/ }),

/***/ "./src/compiler/parser/html-parser.js":
/*!********************************************!*\
  !*** ./src/compiler/parser/html-parser.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isPlainTextElement = undefined;\nexports.parseHTML = parseHTML;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _util2 = __webpack_require__(/*! web/compiler/util */ \"./src/platforms/web/compiler/util.js\");\n\n// Regular Expressions for parsing tags and attributes\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n/*!\n * HTML Parser By John Resig (ejohn.org)\n * Modified by Juriy \"kangax\" Zaytsev\n * Original code by Erik Arvidsson, Mozilla Public License\n * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js\n */\n\nvar attribute = /^\\s*([^\\s\"'<>\\/=]+)(?:\\s*(=)\\s*(?:\"([^\"]*)\"+|'([^']*)'+|([^\\s\"'=<>`]+)))?/;\n// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName\n// but for Vue templates we can enforce a simple charset\nvar ncname = '[a-zA-Z_][\\\\w\\\\-\\\\.]*';\nvar qnameCapture = '((?:' + ncname + '\\\\:)?' + ncname + ')';\nvar startTagOpen = new RegExp('^<' + qnameCapture);\nvar startTagClose = /^\\s*(\\/?)>/;\nvar endTag = new RegExp('^<\\\\/' + qnameCapture + '[^>]*>');\nvar doctype = /^<!DOCTYPE [^>]+>/i;\n// #7298: escape - to avoid being pased as HTML comment when inlined in page\nvar comment = /^<!\\--/;\nvar conditionalComment = /^<!\\[/;\n\nvar IS_REGEX_CAPTURING_BROKEN = false;\n'x'.replace(/x(.)?/g, function (m, g) {\n  IS_REGEX_CAPTURING_BROKEN = g === '';\n});\n\n// Special Elements (can contain anything)\nvar isPlainTextElement = exports.isPlainTextElement = (0, _util.makeMap)('script,style,textarea', true);\nvar reCache = {};\n\nvar decodingMap = {\n  '&lt;': '<',\n  '&gt;': '>',\n  '&quot;': '\"',\n  '&amp;': '&',\n  '&#10;': '\\n',\n  '&#9;': '\\t'\n};\nvar encodedAttr = /&(?:lt|gt|quot|amp);/g;\nvar encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#10|#9);/g;\n\n// #5992\nvar isIgnoreNewlineTag = (0, _util.makeMap)('pre,textarea', true);\nvar shouldIgnoreFirstNewline = function shouldIgnoreFirstNewline(tag, html) {\n  return tag && isIgnoreNewlineTag(tag) && html[0] === '\\n';\n};\n\nfunction decodeAttr(value, shouldDecodeNewlines) {\n  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;\n  return value.replace(re, function (match) {\n    return decodingMap[match];\n  });\n}\n\nfunction parseHTML(html, options) {\n  var stack = [];\n  var expectHTML = options.expectHTML;\n  var isUnaryTag = options.isUnaryTag || _util.no;\n  var canBeLeftOpenTag = options.canBeLeftOpenTag || _util.no;\n  var index = 0;\n  var last = void 0,\n      lastTag = void 0;\n  while (html) {\n    last = html;\n    // Make sure we're not in a plaintext content element like script/style\n    if (!lastTag || !isPlainTextElement(lastTag)) {\n      var textEnd = html.indexOf('<');\n      if (textEnd === 0) {\n        // Comment:\n        if (comment.test(html)) {\n          var commentEnd = html.indexOf('-->');\n\n          if (commentEnd >= 0) {\n            if (options.shouldKeepComment) {\n              options.comment(html.substring(4, commentEnd));\n            }\n            advance(commentEnd + 3);\n            continue;\n          }\n        }\n\n        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n        if (conditionalComment.test(html)) {\n          var conditionalEnd = html.indexOf(']>');\n\n          if (conditionalEnd >= 0) {\n            advance(conditionalEnd + 2);\n            continue;\n          }\n        }\n\n        // Doctype:\n        var doctypeMatch = html.match(doctype);\n        if (doctypeMatch) {\n          advance(doctypeMatch[0].length);\n          continue;\n        }\n\n        // End tag:\n        var endTagMatch = html.match(endTag);\n        if (endTagMatch) {\n          var curIndex = index;\n          advance(endTagMatch[0].length);\n          parseEndTag(endTagMatch[1], curIndex, index);\n          continue;\n        }\n\n        // Start tag:\n        var startTagMatch = parseStartTag();\n        if (startTagMatch) {\n          handleStartTag(startTagMatch);\n          if (shouldIgnoreFirstNewline(lastTag, html)) {\n            advance(1);\n          }\n          continue;\n        }\n      }\n\n      var text = void 0,\n          rest = void 0,\n          next = void 0;\n      if (textEnd >= 0) {\n        rest = html.slice(textEnd);\n        while (!endTag.test(rest) && !startTagOpen.test(rest) && !comment.test(rest) && !conditionalComment.test(rest)) {\n          // < in plain text, be forgiving and treat it as text\n          next = rest.indexOf('<', 1);\n          if (next < 0) break;\n          textEnd += next;\n          rest = html.slice(textEnd);\n        }\n        text = html.substring(0, textEnd);\n        advance(textEnd);\n      }\n\n      if (textEnd < 0) {\n        text = html;\n        html = '';\n      }\n\n      if (options.chars && text) {\n        options.chars(text);\n      }\n    } else {\n      (function () {\n        var endTagLength = 0;\n        var stackedTag = lastTag.toLowerCase();\n        var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\\\s\\\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));\n        var rest = html.replace(reStackedTag, function (all, text, endTag) {\n          endTagLength = endTag.length;\n          if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {\n            text = text.replace(/<!\\--([\\s\\S]*?)-->/g, '$1') // #7298\n            .replace(/<!\\[CDATA\\[([\\s\\S]*?)]]>/g, '$1');\n          }\n          if (shouldIgnoreFirstNewline(stackedTag, text)) {\n            text = text.slice(1);\n          }\n          if (options.chars) {\n            options.chars(text);\n          }\n          return '';\n        });\n        index += html.length - rest.length;\n        html = rest;\n        parseEndTag(stackedTag, index - endTagLength, index);\n      })();\n    }\n\n    if (html === last) {\n      options.chars && options.chars(html);\n      if (\"development\" !== 'production' && !stack.length && options.warn) {\n        options.warn('Mal-formatted tag at end of template: \"' + html + '\"');\n      }\n      break;\n    }\n  }\n\n  // Clean up any remaining tags\n  parseEndTag();\n\n  function advance(n) {\n    index += n;\n    html = html.substring(n);\n  }\n\n  function parseStartTag() {\n    var start = html.match(startTagOpen);\n    if (start) {\n      var match = {\n        tagName: start[1],\n        attrs: [],\n        start: index\n      };\n      advance(start[0].length);\n      var end = void 0,\n          attr = void 0;\n      while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {\n        advance(attr[0].length);\n        match.attrs.push(attr);\n      }\n      if (end) {\n        match.unarySlash = end[1];\n        advance(end[0].length);\n        match.end = index;\n        return match;\n      }\n    }\n  }\n\n  function handleStartTag(match) {\n    var tagName = match.tagName;\n    var unarySlash = match.unarySlash;\n\n    if (expectHTML) {\n      if (lastTag === 'p' && (0, _util2.isNonPhrasingTag)(tagName)) {\n        parseEndTag(lastTag);\n      }\n      if (canBeLeftOpenTag(tagName) && lastTag === tagName) {\n        parseEndTag(tagName);\n      }\n    }\n\n    var unary = isUnaryTag(tagName) || !!unarySlash;\n\n    var l = match.attrs.length;\n    var attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      var args = match.attrs[i];\n      // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n      if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('\"\"') === -1) {\n        if (args[3] === '') {\n          delete args[3];\n        }\n        if (args[4] === '') {\n          delete args[4];\n        }\n        if (args[5] === '') {\n          delete args[5];\n        }\n      }\n      var value = args[3] || args[4] || args[5] || '';\n      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href' ? options.shouldDecodeNewlinesForHref : options.shouldDecodeNewlines;\n      attrs[i] = {\n        name: args[1],\n        value: decodeAttr(value, shouldDecodeNewlines)\n      };\n    }\n\n    if (!unary) {\n      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs });\n      lastTag = tagName;\n    }\n\n    if (options.start) {\n      options.start(tagName, attrs, unary, match.start, match.end);\n    }\n  }\n\n  function parseEndTag(tagName, start, end) {\n    var pos = void 0,\n        lowerCasedTagName = void 0;\n    if (start == null) start = index;\n    if (end == null) end = index;\n\n    if (tagName) {\n      lowerCasedTagName = tagName.toLowerCase();\n    }\n\n    // Find the closest opened tag of the same type\n    if (tagName) {\n      for (pos = stack.length - 1; pos >= 0; pos--) {\n        if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n          break;\n        }\n      }\n    } else {\n      // If no tag name is provided, clean shop\n      pos = 0;\n    }\n\n    if (pos >= 0) {\n      // Close all the open elements, up the stack\n      for (var i = stack.length - 1; i >= pos; i--) {\n        if (\"development\" !== 'production' && (i > pos || !tagName) && options.warn) {\n          options.warn('tag <' + stack[i].tag + '> has no matching end tag.');\n        }\n        if (options.end) {\n          options.end(stack[i].tag, start, end);\n        }\n      }\n\n      // Remove the open elements from the stack\n      stack.length = pos;\n      lastTag = pos && stack[pos - 1].tag;\n    } else if (lowerCasedTagName === 'br') {\n      if (options.start) {\n        options.start(tagName, [], true, start, end);\n      }\n    } else if (lowerCasedTagName === 'p') {\n      if (options.start) {\n        options.start(tagName, [], false, start, end);\n      }\n      if (options.end) {\n        options.end(tagName, start, end);\n      }\n    }\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/parser/html-parser.js?");

/***/ }),

/***/ "./src/compiler/parser/index.js":
/*!**************************************!*\
  !*** ./src/compiler/parser/index.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.warn = exports.bindRE = exports.forIteratorRE = exports.forAliasRE = exports.dirRE = exports.onRE = undefined;\nexports.createASTElement = createASTElement;\nexports.parse = parse;\nexports.processElement = processElement;\nexports.processFor = processFor;\nexports.parseFor = parseFor;\nexports.addIfCondition = addIfCondition;\n\nvar _he = __webpack_require__(/*! he */ \"../../../usr/lib/nodejs/he/he.js\");\n\nvar _he2 = _interopRequireDefault(_he);\n\nvar _htmlParser = __webpack_require__(/*! ./html-parser */ \"./src/compiler/parser/html-parser.js\");\n\nvar _textParser = __webpack_require__(/*! ./text-parser */ \"./src/compiler/parser/text-parser.js\");\n\nvar _filterParser = __webpack_require__(/*! ./filter-parser */ \"./src/compiler/parser/filter-parser.js\");\n\nvar _model = __webpack_require__(/*! ../directives/model */ \"./src/compiler/directives/model.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _env = __webpack_require__(/*! core/util/env */ \"./src/core/util/env.js\");\n\nvar _helpers = __webpack_require__(/*! ../helpers */ \"./src/compiler/helpers.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar onRE = exports.onRE = /^@|^v-on:/;\nvar dirRE = exports.dirRE = /^v-|^@|^:/;\nvar forAliasRE = exports.forAliasRE = /([^]*?)\\s+(?:in|of)\\s+([^]*)/;\nvar forIteratorRE = exports.forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/;\nvar stripParensRE = /^\\(|\\)$/g;\n\nvar argRE = /:(.*)$/;\nvar bindRE = exports.bindRE = /^:|^v-bind:/;\nvar modifierRE = /\\.[^.]+/g;\n\nvar decodeHTMLCached = (0, _util.cached)(_he2.default.decode);\n\n// configurable state\nvar warn = exports.warn = void 0;\nvar delimiters = void 0;\nvar transforms = void 0;\nvar preTransforms = void 0;\nvar postTransforms = void 0;\nvar platformIsPreTag = void 0;\nvar platformMustUseProp = void 0;\nvar platformGetTagNamespace = void 0;\n\nfunction createASTElement(tag, attrs, parent) {\n  return {\n    type: 1,\n    tag: tag,\n    attrsList: attrs,\n    attrsMap: makeAttrsMap(attrs),\n    parent: parent,\n    children: []\n  };\n}\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse(template, options) {\n  exports.warn = warn = options.warn || _helpers.baseWarn;\n\n  platformIsPreTag = options.isPreTag || _util.no;\n  platformMustUseProp = options.mustUseProp || _util.no;\n  platformGetTagNamespace = options.getTagNamespace || _util.no;\n\n  transforms = (0, _helpers.pluckModuleFunction)(options.modules, 'transformNode');\n  preTransforms = (0, _helpers.pluckModuleFunction)(options.modules, 'preTransformNode');\n  postTransforms = (0, _helpers.pluckModuleFunction)(options.modules, 'postTransformNode');\n\n  delimiters = options.delimiters;\n\n  var stack = [];\n  var preserveWhitespace = options.preserveWhitespace !== false;\n  var root = void 0;\n  var currentParent = void 0;\n  var inVPre = false;\n  var inPre = false;\n  var warned = false;\n\n  function warnOnce(msg) {\n    if (!warned) {\n      warned = true;\n      warn(msg);\n    }\n  }\n\n  function closeElement(element) {\n    // check pre state\n    if (element.pre) {\n      inVPre = false;\n    }\n    if (platformIsPreTag(element.tag)) {\n      inPre = false;\n    }\n    // apply post-transforms\n    for (var i = 0; i < postTransforms.length; i++) {\n      postTransforms[i](element, options);\n    }\n  }\n\n  (0, _htmlParser.parseHTML)(template, {\n    warn: warn,\n    expectHTML: options.expectHTML,\n    isUnaryTag: options.isUnaryTag,\n    canBeLeftOpenTag: options.canBeLeftOpenTag,\n    shouldDecodeNewlines: options.shouldDecodeNewlines,\n    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,\n    shouldKeepComment: options.comments,\n    start: function start(tag, attrs, unary) {\n      // check namespace.\n      // inherit parent ns if there is one\n      var ns = currentParent && currentParent.ns || platformGetTagNamespace(tag);\n\n      // handle IE svg bug\n      /* istanbul ignore if */\n      if (_env.isIE && ns === 'svg') {\n        attrs = guardIESVGBug(attrs);\n      }\n\n      var element = createASTElement(tag, attrs, currentParent);\n      if (ns) {\n        element.ns = ns;\n      }\n\n      if (isForbiddenTag(element) && !(0, _env.isServerRendering)()) {\n        element.forbidden = true;\n        \"development\" !== 'production' && warn('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.');\n      }\n\n      // apply pre-transforms\n      for (var i = 0; i < preTransforms.length; i++) {\n        element = preTransforms[i](element, options) || element;\n      }\n\n      if (!inVPre) {\n        processPre(element);\n        if (element.pre) {\n          inVPre = true;\n        }\n      }\n      if (platformIsPreTag(element.tag)) {\n        inPre = true;\n      }\n      if (inVPre) {\n        processRawAttrs(element);\n      } else if (!element.processed) {\n        // structural directives\n        processFor(element);\n        processIf(element);\n        processOnce(element);\n        // element-scope stuff\n        processElement(element, options);\n      }\n\n      function checkRootConstraints(el) {\n        if (true) {\n          if (el.tag === 'slot' || el.tag === 'template') {\n            warnOnce('Cannot use <' + el.tag + '> as component root element because it may ' + 'contain multiple nodes.');\n          }\n          if (el.attrsMap.hasOwnProperty('v-for')) {\n            warnOnce('Cannot use v-for on stateful component root element because ' + 'it renders multiple elements.');\n          }\n        }\n      }\n\n      // tree management\n      if (!root) {\n        root = element;\n        checkRootConstraints(root);\n      } else if (!stack.length) {\n        // allow root elements with v-if, v-else-if and v-else\n        if (root.if && (element.elseif || element.else)) {\n          checkRootConstraints(element);\n          addIfCondition(root, {\n            exp: element.elseif,\n            block: element\n          });\n        } else if (true) {\n          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.');\n        }\n      }\n      if (currentParent && !element.forbidden) {\n        if (element.elseif || element.else) {\n          processIfConditions(element, currentParent);\n        } else if (element.slotScope) {\n          // scoped slot\n          currentParent.plain = false;\n          var _name = element.slotTarget || '\"default\"';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[_name] = element;\n        } else {\n          currentParent.children.push(element);\n          element.parent = currentParent;\n        }\n      }\n      if (!unary) {\n        currentParent = element;\n        stack.push(element);\n      } else {\n        closeElement(element);\n      }\n    },\n    end: function end() {\n      // remove trailing whitespace\n      var element = stack[stack.length - 1];\n      var lastNode = element.children[element.children.length - 1];\n      if (lastNode && lastNode.type === 3 && lastNode.text === ' ' && !inPre) {\n        element.children.pop();\n      }\n      // pop stack\n      stack.length -= 1;\n      currentParent = stack[stack.length - 1];\n      closeElement(element);\n    },\n    chars: function chars(text) {\n      if (!currentParent) {\n        if (true) {\n          if (text === template) {\n            warnOnce('Component template requires a root element, rather than just text.');\n          } else if (text = text.trim()) {\n            warnOnce('text \"' + text + '\" outside root element will be ignored.');\n          }\n        }\n        return;\n      }\n      // IE textarea placeholder bug\n      /* istanbul ignore if */\n      if (_env.isIE && currentParent.tag === 'textarea' && currentParent.attrsMap.placeholder === text) {\n        return;\n      }\n      var children = currentParent.children;\n      text = inPre || text.trim() ? isTextTag(currentParent) ? text : decodeHTMLCached(text)\n      // only preserve whitespace if its not right after a starting tag\n      : preserveWhitespace && children.length ? ' ' : '';\n      if (text) {\n        var res = void 0;\n        if (!inVPre && text !== ' ' && (res = (0, _textParser.parseText)(text, delimiters))) {\n          children.push({\n            type: 2,\n            expression: res.expression,\n            tokens: res.tokens,\n            text: text\n          });\n        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {\n          children.push({\n            type: 3,\n            text: text\n          });\n        }\n      }\n    },\n    comment: function comment(text) {\n      currentParent.children.push({\n        type: 3,\n        text: text,\n        isComment: true\n      });\n    }\n  });\n  return root;\n}\n\nfunction processPre(el) {\n  if ((0, _helpers.getAndRemoveAttr)(el, 'v-pre') != null) {\n    el.pre = true;\n  }\n}\n\nfunction processRawAttrs(el) {\n  var l = el.attrsList.length;\n  if (l) {\n    var attrs = el.attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      attrs[i] = {\n        name: el.attrsList[i].name,\n        value: JSON.stringify(el.attrsList[i].value)\n      };\n    }\n  } else if (!el.pre) {\n    // non root node in pre blocks with no attributes\n    el.plain = true;\n  }\n}\n\nfunction processElement(element, options) {\n  processKey(element);\n\n  // determine whether this is a plain element after\n  // removing structural attributes\n  element.plain = !element.key && !element.attrsList.length;\n\n  processRef(element);\n  processSlot(element);\n  processComponent(element);\n  for (var i = 0; i < transforms.length; i++) {\n    element = transforms[i](element, options) || element;\n  }\n  processAttrs(element);\n}\n\nfunction processKey(el) {\n  var exp = (0, _helpers.getBindingAttr)(el, 'key');\n  if (exp) {\n    if (\"development\" !== 'production' && el.tag === 'template') {\n      warn('<template> cannot be keyed. Place the key on real elements instead.');\n    }\n    el.key = exp;\n  }\n}\n\nfunction processRef(el) {\n  var ref = (0, _helpers.getBindingAttr)(el, 'ref');\n  if (ref) {\n    el.ref = ref;\n    el.refInFor = checkInFor(el);\n  }\n}\n\nfunction processFor(el) {\n  var exp = void 0;\n  if (exp = (0, _helpers.getAndRemoveAttr)(el, 'v-for')) {\n    var res = parseFor(exp);\n    if (res) {\n      (0, _util.extend)(el, res);\n    } else if (true) {\n      warn('Invalid v-for expression: ' + exp);\n    }\n  }\n}\n\nfunction parseFor(exp) {\n  var inMatch = exp.match(forAliasRE);\n  if (!inMatch) return;\n  var res = {};\n  res.for = inMatch[2].trim();\n  var alias = inMatch[1].trim().replace(stripParensRE, '');\n  var iteratorMatch = alias.match(forIteratorRE);\n  if (iteratorMatch) {\n    res.alias = alias.replace(forIteratorRE, '');\n    res.iterator1 = iteratorMatch[1].trim();\n    if (iteratorMatch[2]) {\n      res.iterator2 = iteratorMatch[2].trim();\n    }\n  } else {\n    res.alias = alias;\n  }\n  return res;\n}\n\nfunction processIf(el) {\n  var exp = (0, _helpers.getAndRemoveAttr)(el, 'v-if');\n  if (exp) {\n    el.if = exp;\n    addIfCondition(el, {\n      exp: exp,\n      block: el\n    });\n  } else {\n    if ((0, _helpers.getAndRemoveAttr)(el, 'v-else') != null) {\n      el.else = true;\n    }\n    var elseif = (0, _helpers.getAndRemoveAttr)(el, 'v-else-if');\n    if (elseif) {\n      el.elseif = elseif;\n    }\n  }\n}\n\nfunction processIfConditions(el, parent) {\n  var prev = findPrevElement(parent.children);\n  if (prev && prev.if) {\n    addIfCondition(prev, {\n      exp: el.elseif,\n      block: el\n    });\n  } else if (true) {\n    warn('v-' + (el.elseif ? 'else-if=\"' + el.elseif + '\"' : 'else') + ' ' + ('used on element <' + el.tag + '> without corresponding v-if.'));\n  }\n}\n\nfunction findPrevElement(children) {\n  var i = children.length;\n  while (i--) {\n    if (children[i].type === 1) {\n      return children[i];\n    } else {\n      if (\"development\" !== 'production' && children[i].text !== ' ') {\n        warn('text \"' + children[i].text.trim() + '\" between v-if and v-else(-if) ' + 'will be ignored.');\n      }\n      children.pop();\n    }\n  }\n}\n\nfunction addIfCondition(el, condition) {\n  if (!el.ifConditions) {\n    el.ifConditions = [];\n  }\n  el.ifConditions.push(condition);\n}\n\nfunction processOnce(el) {\n  var once = (0, _helpers.getAndRemoveAttr)(el, 'v-once');\n  if (once != null) {\n    el.once = true;\n  }\n}\n\nfunction processSlot(el) {\n  if (el.tag === 'slot') {\n    el.slotName = (0, _helpers.getBindingAttr)(el, 'name');\n    if (\"development\" !== 'production' && el.key) {\n      warn('`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.');\n    }\n  } else {\n    var slotScope = void 0;\n    if (el.tag === 'template') {\n      slotScope = (0, _helpers.getAndRemoveAttr)(el, 'scope');\n      /* istanbul ignore if */\n      if (\"development\" !== 'production' && slotScope) {\n        warn('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.', true);\n      }\n      el.slotScope = slotScope || (0, _helpers.getAndRemoveAttr)(el, 'slot-scope');\n    } else if (slotScope = (0, _helpers.getAndRemoveAttr)(el, 'slot-scope')) {\n      /* istanbul ignore if */\n      if (\"development\" !== 'production' && el.attrsMap['v-for']) {\n        warn('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.', true);\n      }\n      el.slotScope = slotScope;\n    }\n    var slotTarget = (0, _helpers.getBindingAttr)(el, 'slot');\n    if (slotTarget) {\n      el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n      // preserve slot as an attribute for native shadow DOM compat\n      // only for non-scoped slots.\n      if (el.tag !== 'template' && !el.slotScope) {\n        (0, _helpers.addAttr)(el, 'slot', slotTarget);\n      }\n    }\n  }\n}\n\nfunction processComponent(el) {\n  var binding = void 0;\n  if (binding = (0, _helpers.getBindingAttr)(el, 'is')) {\n    el.component = binding;\n  }\n  if ((0, _helpers.getAndRemoveAttr)(el, 'inline-template') != null) {\n    el.inlineTemplate = true;\n  }\n}\n\nfunction processAttrs(el) {\n  var list = el.attrsList;\n  var i = void 0,\n      l = void 0,\n      name = void 0,\n      rawName = void 0,\n      value = void 0,\n      modifiers = void 0,\n      isProp = void 0;\n  for (i = 0, l = list.length; i < l; i++) {\n    name = rawName = list[i].name;\n    value = list[i].value;\n    if (dirRE.test(name)) {\n      // mark element as dynamic\n      el.hasBindings = true;\n      // modifiers\n      modifiers = parseModifiers(name);\n      if (modifiers) {\n        name = name.replace(modifierRE, '');\n      }\n      if (bindRE.test(name)) {\n        // v-bind\n        name = name.replace(bindRE, '');\n        value = (0, _filterParser.parseFilters)(value);\n        isProp = false;\n        if (modifiers) {\n          if (modifiers.prop) {\n            isProp = true;\n            name = (0, _util.camelize)(name);\n            if (name === 'innerHtml') name = 'innerHTML';\n          }\n          if (modifiers.camel) {\n            name = (0, _util.camelize)(name);\n          }\n          if (modifiers.sync) {\n            (0, _helpers.addHandler)(el, 'update:' + (0, _util.camelize)(name), (0, _model.genAssignmentCode)(value, '$event'));\n          }\n        }\n        if (isProp || !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n          (0, _helpers.addProp)(el, name, value);\n        } else {\n          (0, _helpers.addAttr)(el, name, value);\n        }\n      } else if (onRE.test(name)) {\n        // v-on\n        name = name.replace(onRE, '');\n        (0, _helpers.addHandler)(el, name, value, modifiers, false, warn);\n      } else {\n        // normal directives\n        name = name.replace(dirRE, '');\n        // parse arg\n        var argMatch = name.match(argRE);\n        var arg = argMatch && argMatch[1];\n        if (arg) {\n          name = name.slice(0, -(arg.length + 1));\n        }\n        (0, _helpers.addDirective)(el, name, rawName, value, arg, modifiers);\n        if (\"development\" !== 'production' && name === 'model') {\n          checkForAliasModel(el, value);\n        }\n      }\n    } else {\n      // literal attribute\n      if (true) {\n        var res = (0, _textParser.parseText)(value, delimiters);\n        if (res) {\n          warn(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\">.');\n        }\n      }\n      (0, _helpers.addAttr)(el, name, JSON.stringify(value));\n      // #6887 firefox doesn't update muted state if set via attribute\n      // even immediately after element creation\n      if (!el.component && name === 'muted' && platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n        (0, _helpers.addProp)(el, name, 'true');\n      }\n    }\n  }\n}\n\nfunction checkInFor(el) {\n  var parent = el;\n  while (parent) {\n    if (parent.for !== undefined) {\n      return true;\n    }\n    parent = parent.parent;\n  }\n  return false;\n}\n\nfunction parseModifiers(name) {\n  var match = name.match(modifierRE);\n  if (match) {\n    var ret = {};\n    match.forEach(function (m) {\n      ret[m.slice(1)] = true;\n    });\n    return ret;\n  }\n}\n\nfunction makeAttrsMap(attrs) {\n  var map = {};\n  for (var i = 0, l = attrs.length; i < l; i++) {\n    if (\"development\" !== 'production' && map[attrs[i].name] && !_env.isIE && !_env.isEdge) {\n      warn('duplicate attribute: ' + attrs[i].name);\n    }\n    map[attrs[i].name] = attrs[i].value;\n  }\n  return map;\n}\n\n// for script (e.g. type=\"x/template\") or style, do not decode content\nfunction isTextTag(el) {\n  return el.tag === 'script' || el.tag === 'style';\n}\n\nfunction isForbiddenTag(el) {\n  return el.tag === 'style' || el.tag === 'script' && (!el.attrsMap.type || el.attrsMap.type === 'text/javascript');\n}\n\nvar ieNSBug = /^xmlns:NS\\d+/;\nvar ieNSPrefix = /^NS\\d+:/;\n\n/* istanbul ignore next */\nfunction guardIESVGBug(attrs) {\n  var res = [];\n  for (var i = 0; i < attrs.length; i++) {\n    var attr = attrs[i];\n    if (!ieNSBug.test(attr.name)) {\n      attr.name = attr.name.replace(ieNSPrefix, '');\n      res.push(attr);\n    }\n  }\n  return res;\n}\n\nfunction checkForAliasModel(el, value) {\n  var _el = el;\n  while (_el) {\n    if (_el.for && _el.alias === value) {\n      warn('<' + 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.');\n    }\n    _el = _el.parent;\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/parser/index.js?");

/***/ }),

/***/ "./src/compiler/parser/text-parser.js":
/*!********************************************!*\
  !*** ./src/compiler/parser/text-parser.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.parseText = parseText;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _filterParser = __webpack_require__(/*! ./filter-parser */ \"./src/compiler/parser/filter-parser.js\");\n\nvar defaultTagRE = /\\{\\{((?:.|\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = (0, _util.cached)(function (delimiters) {\n  var open = delimiters[0].replace(regexEscapeRE, '\\\\$&');\n  var close = delimiters[1].replace(regexEscapeRE, '\\\\$&');\n  return new RegExp(open + '((?:.|\\\\n)+?)' + close, 'g');\n});\n\nfunction parseText(text, delimiters) {\n  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;\n  if (!tagRE.test(text)) {\n    return;\n  }\n  var tokens = [];\n  var rawTokens = [];\n  var lastIndex = tagRE.lastIndex = 0;\n  var match = void 0,\n      index = void 0,\n      tokenValue = void 0;\n  while (match = tagRE.exec(text)) {\n    index = match.index;\n    // push text token\n    if (index > lastIndex) {\n      rawTokens.push(tokenValue = text.slice(lastIndex, index));\n      tokens.push(JSON.stringify(tokenValue));\n    }\n    // tag token\n    var exp = (0, _filterParser.parseFilters)(match[1].trim());\n    tokens.push('_s(' + exp + ')');\n    rawTokens.push({ '@binding': exp });\n    lastIndex = index + match[0].length;\n  }\n  if (lastIndex < text.length) {\n    rawTokens.push(tokenValue = text.slice(lastIndex));\n    tokens.push(JSON.stringify(tokenValue));\n  }\n  return {\n    expression: tokens.join('+'),\n    tokens: rawTokens\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/parser/text-parser.js?");

/***/ }),

/***/ "./src/compiler/to-function.js":
/*!*************************************!*\
  !*** ./src/compiler/to-function.js ***!
  \*************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createCompileToFunctionFn = createCompileToFunctionFn;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _debug = __webpack_require__(/*! core/util/debug */ \"./src/core/util/debug.js\");\n\nfunction createFunction(code, errors) {\n  try {\n    return new Function(code);\n  } catch (err) {\n    errors.push({ err: err, code: code });\n    return _util.noop;\n  }\n}\n\nfunction createCompileToFunctionFn(compile) {\n  var cache = Object.create(null);\n\n  return function compileToFunctions(template, options, vm) {\n    options = (0, _util.extend)({}, options);\n    var warn = options.warn || _debug.warn;\n    delete options.warn;\n\n    /* istanbul ignore if */\n    if (true) {\n      // detect possible CSP restriction\n      try {\n        new Function('return 1');\n      } catch (e) {\n        if (e.toString().match(/unsafe-eval|CSP/)) {\n          warn('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.');\n        }\n      }\n    }\n\n    // check cache\n    var key = options.delimiters ? String(options.delimiters) + template : template;\n    if (cache[key]) {\n      return cache[key];\n    }\n\n    // compile\n    var compiled = compile(template, options);\n\n    // check compilation errors/tips\n    if (true) {\n      if (compiled.errors && compiled.errors.length) {\n        warn('Error compiling template:\\n\\n' + template + '\\n\\n' + compiled.errors.map(function (e) {\n          return '- ' + e;\n        }).join('\\n') + '\\n', vm);\n      }\n      if (compiled.tips && compiled.tips.length) {\n        compiled.tips.forEach(function (msg) {\n          return (0, _debug.tip)(msg, vm);\n        });\n      }\n    }\n\n    // turn code into functions\n    var res = {};\n    var fnGenErrors = [];\n    res.render = createFunction(compiled.render, fnGenErrors);\n    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {\n      return createFunction(code, fnGenErrors);\n    });\n\n    // check function generation errors.\n    // this should only happen if there is a bug in the compiler itself.\n    // mostly for codegen development use\n    /* istanbul ignore if */\n    if (true) {\n      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {\n        warn('Failed to generate render function:\\n\\n' + fnGenErrors.map(function (_ref) {\n          var err = _ref.err,\n              code = _ref.code;\n          return err.toString() + ' in\\n\\n' + code + '\\n';\n        }).join('\\n'), vm);\n      }\n    }\n\n    return cache[key] = res;\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/compiler/to-function.js?");

/***/ }),

/***/ "./src/core/components/index.js":
/*!**************************************!*\
  !*** ./src/core/components/index.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _keepAlive = __webpack_require__(/*! ./keep-alive */ \"./src/core/components/keep-alive.js\");\n\nvar _keepAlive2 = _interopRequireDefault(_keepAlive);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = {\n  KeepAlive: _keepAlive2.default\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/core/components/index.js?");

/***/ }),

/***/ "./src/core/components/keep-alive.js":
/*!*******************************************!*\
  !*** ./src/core/components/keep-alive.js ***!
  \*******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _index = __webpack_require__(/*! core/vdom/helpers/index */ \"./src/core/vdom/helpers/index.js\");\n\nfunction getComponentName(opts) {\n  return opts && (opts.Ctor.options.name || opts.tag);\n}\n\nfunction matches(pattern, name) {\n  if (Array.isArray(pattern)) {\n    return pattern.indexOf(name) > -1;\n  } else if (typeof pattern === 'string') {\n    return pattern.split(',').indexOf(name) > -1;\n  } else if ((0, _util.isRegExp)(pattern)) {\n    return pattern.test(name);\n  }\n  /* istanbul ignore next */\n  return false;\n}\n\nfunction pruneCache(keepAliveInstance, filter) {\n  var cache = keepAliveInstance.cache,\n      keys = keepAliveInstance.keys,\n      _vnode = keepAliveInstance._vnode;\n\n  for (var _key in cache) {\n    var cachedNode = cache[_key];\n    if (cachedNode) {\n      var name = getComponentName(cachedNode.componentOptions);\n      if (name && !filter(name)) {\n        pruneCacheEntry(cache, _key, keys, _vnode);\n      }\n    }\n  }\n}\n\nfunction pruneCacheEntry(cache, key, keys, current) {\n  var cached = cache[key];\n  if (cached && (!current || cached.tag !== current.tag)) {\n    cached.componentInstance.$destroy();\n  }\n  cache[key] = null;\n  (0, _util.remove)(keys, key);\n}\n\nvar patternTypes = [String, RegExp, Array];\n\nexports.default = {\n  name: 'keep-alive',\n  abstract: true,\n\n  props: {\n    include: patternTypes,\n    exclude: patternTypes,\n    max: [String, Number]\n  },\n\n  created: function created() {\n    this.cache = Object.create(null);\n    this.keys = [];\n  },\n  destroyed: function destroyed() {\n    for (var _key2 in this.cache) {\n      pruneCacheEntry(this.cache, _key2, this.keys);\n    }\n  },\n  mounted: function mounted() {\n    var _this = this;\n\n    this.$watch('include', function (val) {\n      pruneCache(_this, function (name) {\n        return matches(val, name);\n      });\n    });\n    this.$watch('exclude', function (val) {\n      pruneCache(_this, function (name) {\n        return !matches(val, name);\n      });\n    });\n  },\n  render: function render() {\n    var slot = this.$slots.default;\n    var vnode = (0, _index.getFirstComponentChild)(slot);\n    var componentOptions = vnode && vnode.componentOptions;\n    if (componentOptions) {\n      // check pattern\n      var name = getComponentName(componentOptions);\n      var include = this.include,\n          exclude = this.exclude;\n\n      if (\n      // not included\n      include && (!name || !matches(include, name)) ||\n      // excluded\n      exclude && name && matches(exclude, name)) {\n        return vnode;\n      }\n\n      var cache = this.cache,\n          keys = this.keys;\n\n      var _key3 = vnode.key == null\n      // same constructor may get registered as different local components\n      // so cid alone is not enough (#3269)\n      ? componentOptions.Ctor.cid + (componentOptions.tag ? '::' + componentOptions.tag : '') : vnode.key;\n      if (cache[_key3]) {\n        vnode.componentInstance = cache[_key3].componentInstance;\n        // make current key freshest\n        (0, _util.remove)(keys, _key3);\n        keys.push(_key3);\n      } else {\n        cache[_key3] = vnode;\n        keys.push(_key3);\n        // prune oldest entry\n        if (this.max && keys.length > parseInt(this.max)) {\n          pruneCacheEntry(cache, keys[0], keys, this._vnode);\n        }\n      }\n\n      vnode.data.keepAlive = true;\n    }\n    return vnode || slot && slot[0];\n  }\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/core/components/keep-alive.js?");

/***/ }),

/***/ "./src/core/config.js":
/*!****************************!*\
  !*** ./src/core/config.js ***!
  \****************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _constants = __webpack_require__(/*! shared/constants */ \"./src/shared/constants.js\");\n\nexports.default = {\n  /**\n   * Option merge strategies (used in core/util/options)\n   */\n  // $flow-disable-line\n  optionMergeStrategies: Object.create(null),\n\n  /**\n   * Whether to suppress warnings.\n   */\n  silent: false,\n\n  /**\n   * Show production mode tip message on boot?\n   */\n  productionTip: \"development\" !== 'production',\n\n  /**\n   * Whether to enable devtools\n   */\n  devtools: \"development\" !== 'production',\n\n  /**\n   * Whether to record perf\n   */\n  performance: false,\n\n  /**\n   * Error handler for watcher errors\n   */\n  errorHandler: null,\n\n  /**\n   * Warn handler for watcher warns\n   */\n  warnHandler: null,\n\n  /**\n   * Ignore certain custom elements\n   */\n  ignoredElements: [],\n\n  /**\n   * Custom user key aliases for v-on\n   */\n  // $flow-disable-line\n  keyCodes: Object.create(null),\n\n  /**\n   * Check if a tag is reserved so that it cannot be registered as a\n   * component. This is platform-dependent and may be overwritten.\n   */\n  isReservedTag: _util.no,\n\n  /**\n   * Check if an attribute is reserved so that it cannot be used as a component\n   * prop. This is platform-dependent and may be overwritten.\n   */\n  isReservedAttr: _util.no,\n\n  /**\n   * Check if a tag is an unknown element.\n   * Platform-dependent.\n   */\n  isUnknownElement: _util.no,\n\n  /**\n   * Get the namespace of an element\n   */\n  getTagNamespace: _util.noop,\n\n  /**\n   * Parse the real tag name for the specific platform.\n   */\n  parsePlatformTagName: _util.identity,\n\n  /**\n   * Check if an attribute must be bound using property, e.g. value\n   * Platform-dependent.\n   */\n  mustUseProp: _util.no,\n\n  /**\n   * Exposed for legacy reasons\n   */\n  _lifecycleHooks: _constants.LIFECYCLE_HOOKS\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/core/config.js?");

/***/ }),

/***/ "./src/core/global-api/assets.js":
/*!***************************************!*\
  !*** ./src/core/global-api/assets.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initAssetRegisters = initAssetRegisters;\n\nvar _constants = __webpack_require__(/*! shared/constants */ \"./src/shared/constants.js\");\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction initAssetRegisters(Vue) {\n  /**\n   * Create asset registration methods.\n   */\n  _constants.ASSET_TYPES.forEach(function (type) {\n    Vue[type] = function (id, definition) {\n      if (!definition) {\n        return this.options[type + 's'][id];\n      } else {\n        /* istanbul ignore if */\n        if (\"development\" !== 'production' && type === 'component') {\n          (0, _index.validateComponentName)(id);\n        }\n        if (type === 'component' && (0, _index.isPlainObject)(definition)) {\n          definition.name = definition.name || id;\n          definition = this.options._base.extend(definition);\n        }\n        if (type === 'directive' && typeof definition === 'function') {\n          definition = { bind: definition, update: definition };\n        }\n        this.options[type + 's'][id] = definition;\n        return definition;\n      }\n    };\n  });\n}\n\n//# sourceURL=webpack://Vue/./src/core/global-api/assets.js?");

/***/ }),

/***/ "./src/core/global-api/extend.js":
/*!***************************************!*\
  !*** ./src/core/global-api/extend.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initExtend = initExtend;\n\nvar _constants = __webpack_require__(/*! shared/constants */ \"./src/shared/constants.js\");\n\nvar _state = __webpack_require__(/*! ../instance/state */ \"./src/core/instance/state.js\");\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction initExtend(Vue) {\n  /**\n   * Each instance constructor, including Vue, has a unique\n   * cid. This enables us to create wrapped \"child\n   * constructors\" for prototypal inheritance and cache them.\n   */\n  Vue.cid = 0;\n  var cid = 1;\n\n  /**\n   * Class inheritance\n   */\n  Vue.extend = function (extendOptions) {\n    extendOptions = extendOptions || {};\n    var Super = this;\n    var SuperId = Super.cid;\n    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});\n    if (cachedCtors[SuperId]) {\n      return cachedCtors[SuperId];\n    }\n\n    var name = extendOptions.name || Super.options.name;\n    if (\"development\" !== 'production' && name) {\n      (0, _index.validateComponentName)(name);\n    }\n\n    var Sub = function VueComponent(options) {\n      this._init(options);\n    };\n    Sub.prototype = Object.create(Super.prototype);\n    Sub.prototype.constructor = Sub;\n    Sub.cid = cid++;\n    Sub.options = (0, _index.mergeOptions)(Super.options, extendOptions);\n    Sub['super'] = Super;\n\n    // For props and computed properties, we define the proxy getters on\n    // the Vue instances at extension time, on the extended prototype. This\n    // avoids Object.defineProperty calls for each instance created.\n    if (Sub.options.props) {\n      initProps(Sub);\n    }\n    if (Sub.options.computed) {\n      initComputed(Sub);\n    }\n\n    // allow further extension/mixin/plugin usage\n    Sub.extend = Super.extend;\n    Sub.mixin = Super.mixin;\n    Sub.use = Super.use;\n\n    // create asset registers, so extended classes\n    // can have their private assets too.\n    _constants.ASSET_TYPES.forEach(function (type) {\n      Sub[type] = Super[type];\n    });\n    // enable recursive self-lookup\n    if (name) {\n      Sub.options.components[name] = Sub;\n    }\n\n    // keep a reference to the super options at extension time.\n    // later at instantiation we can check if Super's options have\n    // been updated.\n    Sub.superOptions = Super.options;\n    Sub.extendOptions = extendOptions;\n    Sub.sealedOptions = (0, _index.extend)({}, Sub.options);\n\n    // cache constructor\n    cachedCtors[SuperId] = Sub;\n    return Sub;\n  };\n}\n\nfunction initProps(Comp) {\n  var props = Comp.options.props;\n  for (var key in props) {\n    (0, _state.proxy)(Comp.prototype, '_props', key);\n  }\n}\n\nfunction initComputed(Comp) {\n  var computed = Comp.options.computed;\n  for (var key in computed) {\n    (0, _state.defineComputed)(Comp.prototype, key, computed[key]);\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/global-api/extend.js?");

/***/ }),

/***/ "./src/core/global-api/index.js":
/*!**************************************!*\
  !*** ./src/core/global-api/index.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initGlobalAPI = initGlobalAPI;\n\nvar _config = __webpack_require__(/*! ../config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _use = __webpack_require__(/*! ./use */ \"./src/core/global-api/use.js\");\n\nvar _mixin = __webpack_require__(/*! ./mixin */ \"./src/core/global-api/mixin.js\");\n\nvar _extend = __webpack_require__(/*! ./extend */ \"./src/core/global-api/extend.js\");\n\nvar _assets = __webpack_require__(/*! ./assets */ \"./src/core/global-api/assets.js\");\n\nvar _index = __webpack_require__(/*! ../observer/index */ \"./src/core/observer/index.js\");\n\nvar _constants = __webpack_require__(/*! shared/constants */ \"./src/shared/constants.js\");\n\nvar _index2 = __webpack_require__(/*! ../components/index */ \"./src/core/components/index.js\");\n\nvar _index3 = _interopRequireDefault(_index2);\n\nvar _index4 = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction initGlobalAPI(Vue) {\n  // config\n  var configDef = {};\n  configDef.get = function () {\n    return _config2.default;\n  };\n  if (true) {\n    configDef.set = function () {\n      (0, _index4.warn)('Do not replace the Vue.config object, set individual fields instead.');\n    };\n  }\n  Object.defineProperty(Vue, 'config', configDef);\n\n  // exposed util methods.\n  // NOTE: these are not considered part of the public API - avoid relying on\n  // them unless you are aware of the risk.\n  Vue.util = {\n    warn: _index4.warn,\n    extend: _index4.extend,\n    mergeOptions: _index4.mergeOptions,\n    defineReactive: _index4.defineReactive\n  };\n\n  Vue.set = _index.set;\n  Vue.delete = _index.del;\n  Vue.nextTick = _index4.nextTick;\n\n  Vue.options = Object.create(null);\n  _constants.ASSET_TYPES.forEach(function (type) {\n    Vue.options[type + 's'] = Object.create(null);\n  });\n\n  // this is used to identify the \"base\" constructor to extend all plain-object\n  // components with in Weex's multi-instance scenarios.\n  Vue.options._base = Vue;\n\n  (0, _index4.extend)(Vue.options.components, _index3.default);\n\n  (0, _use.initUse)(Vue);\n  (0, _mixin.initMixin)(Vue);\n  (0, _extend.initExtend)(Vue);\n  (0, _assets.initAssetRegisters)(Vue);\n}\n\n//# sourceURL=webpack://Vue/./src/core/global-api/index.js?");

/***/ }),

/***/ "./src/core/global-api/mixin.js":
/*!**************************************!*\
  !*** ./src/core/global-api/mixin.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initMixin = initMixin;\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction initMixin(Vue) {\n  Vue.mixin = function (mixin) {\n    this.options = (0, _index.mergeOptions)(this.options, mixin);\n    return this;\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/core/global-api/mixin.js?");

/***/ }),

/***/ "./src/core/global-api/use.js":
/*!************************************!*\
  !*** ./src/core/global-api/use.js ***!
  \************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initUse = initUse;\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction initUse(Vue) {\n  Vue.use = function (plugin) {\n    var installedPlugins = this._installedPlugins || (this._installedPlugins = []);\n    if (installedPlugins.indexOf(plugin) > -1) {\n      return this;\n    }\n\n    // additional parameters\n    var args = (0, _index.toArray)(arguments, 1);\n    args.unshift(this);\n    if (typeof plugin.install === 'function') {\n      plugin.install.apply(plugin, args);\n    } else if (typeof plugin === 'function') {\n      plugin.apply(null, args);\n    }\n    installedPlugins.push(plugin);\n    return this;\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/core/global-api/use.js?");

/***/ }),

/***/ "./src/core/index.js":
/*!***************************!*\
  !*** ./src/core/index.js ***!
  \***************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _index = __webpack_require__(/*! ./instance/index */ \"./src/core/instance/index.js\");\n\nvar _index2 = _interopRequireDefault(_index);\n\nvar _index3 = __webpack_require__(/*! ./global-api/index */ \"./src/core/global-api/index.js\");\n\nvar _env = __webpack_require__(/*! core/util/env */ \"./src/core/util/env.js\");\n\nvar _createFunctionalComponent = __webpack_require__(/*! core/vdom/create-functional-component */ \"./src/core/vdom/create-functional-component.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n(0, _index3.initGlobalAPI)(_index2.default);\n\nObject.defineProperty(_index2.default.prototype, '$isServer', {\n  get: _env.isServerRendering\n});\n\nObject.defineProperty(_index2.default.prototype, '$ssrContext', {\n  get: function get() {\n    /* istanbul ignore next */\n    return this.$vnode && this.$vnode.ssrContext;\n  }\n});\n\n// expose FunctionalRenderContext for ssr runtime helper installation\nObject.defineProperty(_index2.default, 'FunctionalRenderContext', {\n  value: _createFunctionalComponent.FunctionalRenderContext\n});\n\n_index2.default.version = '__VERSION__';\n\nexports.default = _index2.default;\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/core/index.js?");

/***/ }),

/***/ "./src/core/instance/events.js":
/*!*************************************!*\
  !*** ./src/core/instance/events.js ***!
  \*************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initEvents = initEvents;\nexports.updateComponentListeners = updateComponentListeners;\nexports.eventsMixin = eventsMixin;\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nvar _index2 = __webpack_require__(/*! ../vdom/helpers/index */ \"./src/core/vdom/helpers/index.js\");\n\nfunction initEvents(vm) {\n  vm._events = Object.create(null);\n  vm._hasHookEvent = false;\n  // init parent attached events\n  var listeners = vm.$options._parentListeners;\n  if (listeners) {\n    updateComponentListeners(vm, listeners);\n  }\n}\n\nvar target = void 0;\n\nfunction add(event, fn, once) {\n  if (once) {\n    target.$once(event, fn);\n  } else {\n    target.$on(event, fn);\n  }\n}\n\nfunction remove(event, fn) {\n  target.$off(event, fn);\n}\n\nfunction updateComponentListeners(vm, listeners, oldListeners) {\n  target = vm;\n  (0, _index2.updateListeners)(listeners, oldListeners || {}, add, remove, vm);\n  target = undefined;\n}\n\nfunction eventsMixin(Vue) {\n  var hookRE = /^hook:/;\n  Vue.prototype.$on = function (event, fn) {\n    var vm = this;\n    if (Array.isArray(event)) {\n      for (var i = 0, l = event.length; i < l; i++) {\n        this.$on(event[i], fn);\n      }\n    } else {\n      (vm._events[event] || (vm._events[event] = [])).push(fn);\n      // optimize hook:event cost by using a boolean flag marked at registration\n      // instead of a hash lookup\n      if (hookRE.test(event)) {\n        vm._hasHookEvent = true;\n      }\n    }\n    return vm;\n  };\n\n  Vue.prototype.$once = function (event, fn) {\n    var vm = this;\n    function on() {\n      vm.$off(event, on);\n      fn.apply(vm, arguments);\n    }\n    on.fn = fn;\n    vm.$on(event, on);\n    return vm;\n  };\n\n  Vue.prototype.$off = function (event, fn) {\n    var vm = this;\n    // all\n    if (!arguments.length) {\n      vm._events = Object.create(null);\n      return vm;\n    }\n    // array of events\n    if (Array.isArray(event)) {\n      for (var i = 0, l = event.length; i < l; i++) {\n        this.$off(event[i], fn);\n      }\n      return vm;\n    }\n    // specific event\n    var cbs = vm._events[event];\n    if (!cbs) {\n      return vm;\n    }\n    if (!fn) {\n      vm._events[event] = null;\n      return vm;\n    }\n    if (fn) {\n      // specific handler\n      var cb = void 0;\n      var _i = cbs.length;\n      while (_i--) {\n        cb = cbs[_i];\n        if (cb === fn || cb.fn === fn) {\n          cbs.splice(_i, 1);\n          break;\n        }\n      }\n    }\n    return vm;\n  };\n\n  Vue.prototype.$emit = function (event) {\n    var vm = this;\n    if (true) {\n      var lowerCaseEvent = event.toLowerCase();\n      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {\n        (0, _index.tip)('Event \"' + lowerCaseEvent + '\" is emitted in component ' + ((0, _index.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 \"' + (0, _index.hyphenate)(event) + '\" instead of \"' + event + '\".'));\n      }\n    }\n    var cbs = vm._events[event];\n    if (cbs) {\n      cbs = cbs.length > 1 ? (0, _index.toArray)(cbs) : cbs;\n      var args = (0, _index.toArray)(arguments, 1);\n      for (var i = 0, l = cbs.length; i < l; i++) {\n        try {\n          cbs[i].apply(vm, args);\n        } catch (e) {\n          (0, _index.handleError)(e, vm, 'event handler for \"' + event + '\"');\n        }\n      }\n    }\n    return vm;\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/events.js?");

/***/ }),

/***/ "./src/core/instance/index.js":
/*!************************************!*\
  !*** ./src/core/instance/index.js ***!
  \************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _init = __webpack_require__(/*! ./init */ \"./src/core/instance/init.js\");\n\nvar _state = __webpack_require__(/*! ./state */ \"./src/core/instance/state.js\");\n\nvar _render = __webpack_require__(/*! ./render */ \"./src/core/instance/render.js\");\n\nvar _events = __webpack_require__(/*! ./events */ \"./src/core/instance/events.js\");\n\nvar _lifecycle = __webpack_require__(/*! ./lifecycle */ \"./src/core/instance/lifecycle.js\");\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction Vue(options) {\n  if (\"development\" !== 'production' && !(this instanceof Vue)) {\n    (0, _index.warn)('Vue is a constructor and should be called with the `new` keyword');\n  }\n  this._init(options);\n}\n\n(0, _init.initMixin)(Vue);\n(0, _state.stateMixin)(Vue);\n(0, _events.eventsMixin)(Vue);\n(0, _lifecycle.lifecycleMixin)(Vue);\n(0, _render.renderMixin)(Vue);\n\nexports.default = Vue;\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/core/instance/index.js?");

/***/ }),

/***/ "./src/core/instance/init.js":
/*!***********************************!*\
  !*** ./src/core/instance/init.js ***!
  \***********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initMixin = initMixin;\nexports.initInternalComponent = initInternalComponent;\nexports.resolveConstructorOptions = resolveConstructorOptions;\n\nvar _config = __webpack_require__(/*! ../config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _proxy = __webpack_require__(/*! ./proxy */ \"./src/core/instance/proxy.js\");\n\nvar _state = __webpack_require__(/*! ./state */ \"./src/core/instance/state.js\");\n\nvar _render = __webpack_require__(/*! ./render */ \"./src/core/instance/render.js\");\n\nvar _events = __webpack_require__(/*! ./events */ \"./src/core/instance/events.js\");\n\nvar _perf = __webpack_require__(/*! ../util/perf */ \"./src/core/util/perf.js\");\n\nvar _lifecycle = __webpack_require__(/*! ./lifecycle */ \"./src/core/instance/lifecycle.js\");\n\nvar _inject = __webpack_require__(/*! ./inject */ \"./src/core/instance/inject.js\");\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar uid = 0;\n\nfunction initMixin(Vue) {\n  Vue.prototype._init = function (options) {\n    var vm = this;\n    // a uid\n    vm._uid = uid++;\n\n    var startTag = void 0,\n        endTag = void 0;\n    /* istanbul ignore if */\n    if (\"development\" !== 'production' && _config2.default.performance && _perf.mark) {\n      startTag = 'vue-perf-start:' + vm._uid;\n      endTag = 'vue-perf-end:' + vm._uid;\n      (0, _perf.mark)(startTag);\n    }\n\n    // a flag to avoid this being observed\n    vm._isVue = true;\n    // merge options\n    if (options && options._isComponent) {\n      // optimize internal component instantiation\n      // since dynamic options merging is pretty slow, and none of the\n      // internal component options needs special treatment.\n      initInternalComponent(vm, options);\n    } else {\n      vm.$options = (0, _index.mergeOptions)(resolveConstructorOptions(vm.constructor), options || {}, vm);\n    }\n    /* istanbul ignore else */\n    if (true) {\n      (0, _proxy.initProxy)(vm);\n    } else {}\n    // expose real self\n    vm._self = vm;\n    (0, _lifecycle.initLifecycle)(vm);\n    (0, _events.initEvents)(vm);\n    (0, _render.initRender)(vm);\n    (0, _lifecycle.callHook)(vm, 'beforeCreate');\n    (0, _inject.initInjections)(vm); // resolve injections before data/props\n    (0, _state.initState)(vm);\n    (0, _inject.initProvide)(vm); // resolve provide after data/props\n    (0, _lifecycle.callHook)(vm, 'created');\n\n    /* istanbul ignore if */\n    if (\"development\" !== 'production' && _config2.default.performance && _perf.mark) {\n      vm._name = (0, _index.formatComponentName)(vm, false);\n      (0, _perf.mark)(endTag);\n      (0, _perf.measure)('vue ' + vm._name + ' init', startTag, endTag);\n    }\n\n    if (vm.$options.el) {\n      vm.$mount(vm.$options.el);\n    }\n  };\n}\n\nfunction initInternalComponent(vm, options) {\n  var opts = vm.$options = Object.create(vm.constructor.options);\n  // doing this because it's faster than dynamic enumeration.\n  var parentVnode = options._parentVnode;\n  opts.parent = options.parent;\n  opts._parentVnode = parentVnode;\n  opts._parentElm = options._parentElm;\n  opts._refElm = options._refElm;\n\n  var vnodeComponentOptions = parentVnode.componentOptions;\n  opts.propsData = vnodeComponentOptions.propsData;\n  opts._parentListeners = vnodeComponentOptions.listeners;\n  opts._renderChildren = vnodeComponentOptions.children;\n  opts._componentTag = vnodeComponentOptions.tag;\n\n  if (options.render) {\n    opts.render = options.render;\n    opts.staticRenderFns = options.staticRenderFns;\n  }\n}\n\nfunction resolveConstructorOptions(Ctor) {\n  var options = Ctor.options;\n  if (Ctor.super) {\n    var superOptions = resolveConstructorOptions(Ctor.super);\n    var cachedSuperOptions = Ctor.superOptions;\n    if (superOptions !== cachedSuperOptions) {\n      // super option changed,\n      // need to resolve new options.\n      Ctor.superOptions = superOptions;\n      // check if there are any late-modified/attached options (#4976)\n      var modifiedOptions = resolveModifiedOptions(Ctor);\n      // update base extend options\n      if (modifiedOptions) {\n        (0, _index.extend)(Ctor.extendOptions, modifiedOptions);\n      }\n      options = Ctor.options = (0, _index.mergeOptions)(superOptions, Ctor.extendOptions);\n      if (options.name) {\n        options.components[options.name] = Ctor;\n      }\n    }\n  }\n  return options;\n}\n\nfunction resolveModifiedOptions(Ctor) {\n  var modified = void 0;\n  var latest = Ctor.options;\n  var extended = Ctor.extendOptions;\n  var sealed = Ctor.sealedOptions;\n  for (var key in latest) {\n    if (latest[key] !== sealed[key]) {\n      if (!modified) modified = {};\n      modified[key] = dedupe(latest[key], extended[key], sealed[key]);\n    }\n  }\n  return modified;\n}\n\nfunction dedupe(latest, extended, sealed) {\n  // compare latest and sealed to ensure lifecycle hooks won't be duplicated\n  // between merges\n  if (Array.isArray(latest)) {\n    var res = [];\n    sealed = Array.isArray(sealed) ? sealed : [sealed];\n    extended = Array.isArray(extended) ? extended : [extended];\n    for (var i = 0; i < latest.length; i++) {\n      // push original options and not sealed options to exclude duplicated options\n      if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) {\n        res.push(latest[i]);\n      }\n    }\n    return res;\n  } else {\n    return latest;\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/init.js?");

/***/ }),

/***/ "./src/core/instance/inject.js":
/*!*************************************!*\
  !*** ./src/core/instance/inject.js ***!
  \*************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initProvide = initProvide;\nexports.initInjections = initInjections;\nexports.resolveInject = resolveInject;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nvar _index2 = __webpack_require__(/*! ../observer/index */ \"./src/core/observer/index.js\");\n\nfunction initProvide(vm) {\n  var provide = vm.$options.provide;\n  if (provide) {\n    vm._provided = typeof provide === 'function' ? provide.call(vm) : provide;\n  }\n}\n\nfunction initInjections(vm) {\n  var result = resolveInject(vm.$options.inject, vm);\n  if (result) {\n    (0, _index2.toggleObserving)(false);\n    Object.keys(result).forEach(function (key) {\n      /* istanbul ignore else */\n      if (true) {\n        (0, _index2.defineReactive)(vm, key, result[key], function () {\n          (0, _index.warn)('Avoid mutating an injected value directly since the changes will be ' + 'overwritten whenever the provided component re-renders. ' + ('injection being mutated: \"' + key + '\"'), vm);\n        });\n      } else {}\n    });\n    (0, _index2.toggleObserving)(true);\n  }\n}\n\nfunction resolveInject(inject, vm) {\n  if (inject) {\n    // inject is :any because flow is not smart enough to figure out cached\n    var result = Object.create(null);\n    var keys = _index.hasSymbol ? Reflect.ownKeys(inject).filter(function (key) {\n      /* istanbul ignore next */\n      return Object.getOwnPropertyDescriptor(inject, key).enumerable;\n    }) : Object.keys(inject);\n\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i];\n      var provideKey = inject[key].from;\n      var source = vm;\n      while (source) {\n        if (source._provided && (0, _util.hasOwn)(source._provided, provideKey)) {\n          result[key] = source._provided[provideKey];\n          break;\n        }\n        source = source.$parent;\n      }\n      if (!source) {\n        if ('default' in inject[key]) {\n          var provideDefault = inject[key].default;\n          result[key] = typeof provideDefault === 'function' ? provideDefault.call(vm) : provideDefault;\n        } else if (true) {\n          (0, _index.warn)('Injection \"' + key + '\" not found', vm);\n        }\n      }\n    }\n    return result;\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/inject.js?");

/***/ }),

/***/ "./src/core/instance/lifecycle.js":
/*!****************************************!*\
  !*** ./src/core/instance/lifecycle.js ***!
  \****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isUpdatingChildComponent = exports.activeInstance = undefined;\nexports.initLifecycle = initLifecycle;\nexports.lifecycleMixin = lifecycleMixin;\nexports.mountComponent = mountComponent;\nexports.updateChildComponent = updateChildComponent;\nexports.activateChildComponent = activateChildComponent;\nexports.deactivateChildComponent = deactivateChildComponent;\nexports.callHook = callHook;\n\nvar _config = __webpack_require__(/*! ../config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _watcher = __webpack_require__(/*! ../observer/watcher */ \"./src/core/observer/watcher.js\");\n\nvar _watcher2 = _interopRequireDefault(_watcher);\n\nvar _perf = __webpack_require__(/*! ../util/perf */ \"./src/core/util/perf.js\");\n\nvar _vnode = __webpack_require__(/*! ../vdom/vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _events = __webpack_require__(/*! ./events */ \"./src/core/instance/events.js\");\n\nvar _resolveSlots = __webpack_require__(/*! ./render-helpers/resolve-slots */ \"./src/core/instance/render-helpers/resolve-slots.js\");\n\nvar _index = __webpack_require__(/*! ../observer/index */ \"./src/core/observer/index.js\");\n\nvar _dep = __webpack_require__(/*! ../observer/dep */ \"./src/core/observer/dep.js\");\n\nvar _index2 = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar activeInstance = exports.activeInstance = null;\n\nvar isUpdatingChildComponent = exports.isUpdatingChildComponent = false;\n\nfunction initLifecycle(vm) {\n  var options = vm.$options;\n\n  // locate first non-abstract parent\n  var parent = options.parent;\n  if (parent && !options.abstract) {\n    while (parent.$options.abstract && parent.$parent) {\n      parent = parent.$parent;\n    }\n    parent.$children.push(vm);\n  }\n\n  vm.$parent = parent;\n  vm.$root = parent ? parent.$root : vm;\n\n  vm.$children = [];\n  vm.$refs = {};\n\n  vm._watcher = null;\n  vm._inactive = null;\n  vm._directInactive = false;\n  vm._isMounted = false;\n  vm._isDestroyed = false;\n  vm._isBeingDestroyed = false;\n}\n\nfunction lifecycleMixin(Vue) {\n  Vue.prototype._update = function (vnode, hydrating) {\n    var vm = this;\n    if (vm._isMounted) {\n      callHook(vm, 'beforeUpdate');\n    }\n    var prevEl = vm.$el;\n    var prevVnode = vm._vnode;\n    var prevActiveInstance = activeInstance;\n    exports.activeInstance = activeInstance = vm;\n    vm._vnode = vnode;\n    // Vue.prototype.__patch__ is injected in entry points\n    // based on the rendering backend used.\n    if (!prevVnode) {\n      // initial render\n      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */\n      , vm.$options._parentElm, vm.$options._refElm);\n      // no need for the ref nodes after initial patch\n      // this prevents keeping a detached DOM tree in memory (#5851)\n      vm.$options._parentElm = vm.$options._refElm = null;\n    } else {\n      // updates\n      vm.$el = vm.__patch__(prevVnode, vnode);\n    }\n    exports.activeInstance = activeInstance = prevActiveInstance;\n    // update __vue__ reference\n    if (prevEl) {\n      prevEl.__vue__ = null;\n    }\n    if (vm.$el) {\n      vm.$el.__vue__ = vm;\n    }\n    // if parent is an HOC, update its $el as well\n    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {\n      vm.$parent.$el = vm.$el;\n    }\n    // updated hook is called by the scheduler to ensure that children are\n    // updated in a parent's updated hook.\n  };\n\n  Vue.prototype.$forceUpdate = function () {\n    var vm = this;\n    if (vm._watcher) {\n      vm._watcher.update();\n    }\n  };\n\n  Vue.prototype.$destroy = function () {\n    var vm = this;\n    if (vm._isBeingDestroyed) {\n      return;\n    }\n    callHook(vm, 'beforeDestroy');\n    vm._isBeingDestroyed = true;\n    // remove self from parent\n    var parent = vm.$parent;\n    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n      (0, _index2.remove)(parent.$children, vm);\n    }\n    // teardown watchers\n    if (vm._watcher) {\n      vm._watcher.teardown();\n    }\n    var i = vm._watchers.length;\n    while (i--) {\n      vm._watchers[i].teardown();\n    }\n    // remove reference from data ob\n    // frozen object may not have observer.\n    if (vm._data.__ob__) {\n      vm._data.__ob__.vmCount--;\n    }\n    // call the last hook...\n    vm._isDestroyed = true;\n    // invoke destroy hooks on current rendered tree\n    vm.__patch__(vm._vnode, null);\n    // fire destroyed hook\n    callHook(vm, 'destroyed');\n    // turn off all instance listeners.\n    vm.$off();\n    // remove __vue__ reference\n    if (vm.$el) {\n      vm.$el.__vue__ = null;\n    }\n    // release circular reference (#6759)\n    if (vm.$vnode) {\n      vm.$vnode.parent = null;\n    }\n  };\n}\n\nfunction mountComponent(vm, el, hydrating) {\n  vm.$el = el;\n  if (!vm.$options.render) {\n    vm.$options.render = _vnode.createEmptyVNode;\n    if (true) {\n      /* istanbul ignore if */\n      if (vm.$options.template && vm.$options.template.charAt(0) !== '#' || vm.$options.el || el) {\n        (0, _index2.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);\n      } else {\n        (0, _index2.warn)('Failed to mount component: template or render function not defined.', vm);\n      }\n    }\n  }\n  callHook(vm, 'beforeMount');\n\n  var updateComponent = void 0;\n  /* istanbul ignore if */\n  if (\"development\" !== 'production' && _config2.default.performance && _perf.mark) {\n    updateComponent = function updateComponent() {\n      var name = vm._name;\n      var id = vm._uid;\n      var startTag = 'vue-perf-start:' + id;\n      var endTag = 'vue-perf-end:' + id;\n\n      (0, _perf.mark)(startTag);\n      var vnode = vm._render();\n      (0, _perf.mark)(endTag);\n      (0, _perf.measure)('vue ' + name + ' render', startTag, endTag);\n\n      (0, _perf.mark)(startTag);\n      vm._update(vnode, hydrating);\n      (0, _perf.mark)(endTag);\n      (0, _perf.measure)('vue ' + name + ' patch', startTag, endTag);\n    };\n  } else {\n    updateComponent = function updateComponent() {\n      vm._update(vm._render(), hydrating);\n    };\n  }\n\n  // we set this to vm._watcher inside the watcher's constructor\n  // since the watcher's initial patch may call $forceUpdate (e.g. inside child\n  // component's mounted hook), which relies on vm._watcher being already defined\n  new _watcher2.default(vm, updateComponent, _index2.noop, null, true /* isRenderWatcher */);\n  hydrating = false;\n\n  // manually mounted instance, call mounted on self\n  // mounted is called for render-created child components in its inserted hook\n  if (vm.$vnode == null) {\n    vm._isMounted = true;\n    callHook(vm, 'mounted');\n  }\n  return vm;\n}\n\nfunction updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {\n  if (true) {\n    exports.isUpdatingChildComponent = isUpdatingChildComponent = true;\n  }\n\n  // determine whether component has slot children\n  // we need to do this before overwriting $options._renderChildren\n  var hasChildren = !!(renderChildren || // has new static slots\n  vm.$options._renderChildren || // has old static slots\n  parentVnode.data.scopedSlots || // has new scoped slots\n  vm.$scopedSlots !== _index2.emptyObject // has old scoped slots\n  );\n\n  vm.$options._parentVnode = parentVnode;\n  vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n\n  if (vm._vnode) {\n    // update child tree's parent\n    vm._vnode.parent = parentVnode;\n  }\n  vm.$options._renderChildren = renderChildren;\n\n  // update $attrs and $listeners hash\n  // these are also reactive so they may trigger child update if the child\n  // used them during render\n  vm.$attrs = parentVnode.data.attrs || _index2.emptyObject;\n  vm.$listeners = listeners || _index2.emptyObject;\n\n  // update props\n  if (propsData && vm.$options.props) {\n    (0, _index.toggleObserving)(false);\n    var props = vm._props;\n    var propKeys = vm.$options._propKeys || [];\n    for (var i = 0; i < propKeys.length; i++) {\n      var key = propKeys[i];\n      var propOptions = vm.$options.props; // wtf flow?\n      props[key] = (0, _index2.validateProp)(key, propOptions, propsData, vm);\n    }\n    (0, _index.toggleObserving)(true);\n    // keep a copy of raw propsData\n    vm.$options.propsData = propsData;\n  }\n\n  // update listeners\n  listeners = listeners || _index2.emptyObject;\n  var oldListeners = vm.$options._parentListeners;\n  vm.$options._parentListeners = listeners;\n  (0, _events.updateComponentListeners)(vm, listeners, oldListeners);\n\n  // resolve slots + force update if has children\n  if (hasChildren) {\n    vm.$slots = (0, _resolveSlots.resolveSlots)(renderChildren, parentVnode.context);\n    vm.$forceUpdate();\n  }\n\n  if (true) {\n    exports.isUpdatingChildComponent = isUpdatingChildComponent = false;\n  }\n}\n\nfunction isInInactiveTree(vm) {\n  while (vm && (vm = vm.$parent)) {\n    if (vm._inactive) return true;\n  }\n  return false;\n}\n\nfunction activateChildComponent(vm, direct) {\n  if (direct) {\n    vm._directInactive = false;\n    if (isInInactiveTree(vm)) {\n      return;\n    }\n  } else if (vm._directInactive) {\n    return;\n  }\n  if (vm._inactive || vm._inactive === null) {\n    vm._inactive = false;\n    for (var i = 0; i < vm.$children.length; i++) {\n      activateChildComponent(vm.$children[i]);\n    }\n    callHook(vm, 'activated');\n  }\n}\n\nfunction deactivateChildComponent(vm, direct) {\n  if (direct) {\n    vm._directInactive = true;\n    if (isInInactiveTree(vm)) {\n      return;\n    }\n  }\n  if (!vm._inactive) {\n    vm._inactive = true;\n    for (var i = 0; i < vm.$children.length; i++) {\n      deactivateChildComponent(vm.$children[i]);\n    }\n    callHook(vm, 'deactivated');\n  }\n}\n\nfunction callHook(vm, hook) {\n  // #7573 disable dep collection when invoking lifecycle hooks\n  (0, _dep.pushTarget)();\n  var handlers = vm.$options[hook];\n  if (handlers) {\n    for (var i = 0, j = handlers.length; i < j; i++) {\n      try {\n        handlers[i].call(vm);\n      } catch (e) {\n        (0, _index2.handleError)(e, vm, hook + ' hook');\n      }\n    }\n  }\n  if (vm._hasHookEvent) {\n    vm.$emit('hook:' + hook);\n  }\n  (0, _dep.popTarget)();\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/lifecycle.js?");

/***/ }),

/***/ "./src/core/instance/proxy.js":
/*!************************************!*\
  !*** ./src/core/instance/proxy.js ***!
  \************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initProxy = undefined;\n\nvar _config = __webpack_require__(/*! core/config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy = void 0;\n\nif (true) {\n  var allowedGlobals = (0, _index.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\n  );\n\n  var warnNonPresent = function warnNonPresent(target, key) {\n    (0, _index.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);\n  };\n\n  var hasProxy = typeof Proxy !== 'undefined' && (0, _index.isNative)(Proxy);\n\n  if (hasProxy) {\n    var isBuiltInModifier = (0, _index.makeMap)('stop,prevent,self,ctrl,shift,alt,meta,exact');\n    _config2.default.keyCodes = new Proxy(_config2.default.keyCodes, {\n      set: function set(target, key, value) {\n        if (isBuiltInModifier(key)) {\n          (0, _index.warn)('Avoid overwriting built-in modifier in config.keyCodes: .' + key);\n          return false;\n        } else {\n          target[key] = value;\n          return true;\n        }\n      }\n    });\n  }\n\n  var hasHandler = {\n    has: function has(target, key) {\n      var has = key in target;\n      var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';\n      if (!has && !isAllowed) {\n        warnNonPresent(target, key);\n      }\n      return has || !isAllowed;\n    }\n  };\n\n  var getHandler = {\n    get: function get(target, key) {\n      if (typeof key === 'string' && !(key in target)) {\n        warnNonPresent(target, key);\n      }\n      return target[key];\n    }\n  };\n\n  exports.initProxy = initProxy = function initProxy(vm) {\n    if (hasProxy) {\n      // determine which proxy handler to use\n      var options = vm.$options;\n      var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;\n      vm._renderProxy = new Proxy(vm, handlers);\n    } else {\n      vm._renderProxy = vm;\n    }\n  };\n}\n\nexports.initProxy = initProxy;\n\n//# sourceURL=webpack://Vue/./src/core/instance/proxy.js?");

/***/ }),

/***/ "./src/core/instance/render-helpers/bind-object-listeners.js":
/*!*******************************************************************!*\
  !*** ./src/core/instance/render-helpers/bind-object-listeners.js ***!
  \*******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.bindObjectListeners = bindObjectListeners;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nfunction bindObjectListeners(data, value) {\n  if (value) {\n    if (!(0, _index.isPlainObject)(value)) {\n      \"development\" !== 'production' && (0, _index.warn)('v-on without argument expects an Object value', this);\n    } else {\n      var on = data.on = data.on ? (0, _index.extend)({}, data.on) : {};\n      for (var key in value) {\n        var existing = on[key];\n        var ours = value[key];\n        on[key] = existing ? [].concat(existing, ours) : ours;\n      }\n    }\n  }\n  return data;\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/render-helpers/bind-object-listeners.js?");

/***/ }),

/***/ "./src/core/instance/render-helpers/bind-object-props.js":
/*!***************************************************************!*\
  !*** ./src/core/instance/render-helpers/bind-object-props.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.bindObjectProps = bindObjectProps;\n\nvar _config = __webpack_require__(/*! core/config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Runtime helper for merging v-bind=\"object\" into a VNode's data.\n */\nfunction bindObjectProps(data, tag, value, asProp, isSync) {\n  if (value) {\n    if (!(0, _index.isObject)(value)) {\n      \"development\" !== 'production' && (0, _index.warn)('v-bind without argument expects an Object or Array value', this);\n    } else {\n      if (Array.isArray(value)) {\n        value = (0, _index.toObject)(value);\n      }\n      var hash = void 0;\n\n      var _loop = function _loop(key) {\n        if (key === 'class' || key === 'style' || (0, _index.isReservedAttribute)(key)) {\n          hash = data;\n        } else {\n          var type = data.attrs && data.attrs.type;\n          hash = asProp || _config2.default.mustUseProp(tag, type, key) ? data.domProps || (data.domProps = {}) : data.attrs || (data.attrs = {});\n        }\n        if (!(key in hash)) {\n          hash[key] = value[key];\n\n          if (isSync) {\n            var on = data.on || (data.on = {});\n            on['update:' + key] = function ($event) {\n              value[key] = $event;\n            };\n          }\n        }\n      };\n\n      for (var key in value) {\n        _loop(key);\n      }\n    }\n  }\n  return data;\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/render-helpers/bind-object-props.js?");

/***/ }),

/***/ "./src/core/instance/render-helpers/check-keycodes.js":
/*!************************************************************!*\
  !*** ./src/core/instance/render-helpers/check-keycodes.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.checkKeyCodes = checkKeyCodes;\n\nvar _config = __webpack_require__(/*! core/config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction isKeyNotMatch(expect, actual) {\n  if (Array.isArray(expect)) {\n    return expect.indexOf(actual) === -1;\n  } else {\n    return expect !== actual;\n  }\n}\n\n/**\n * Runtime helper for checking keyCodes from config.\n * exposed as Vue.prototype._k\n * passing in eventKeyName as last argument separately for backwards compat\n */\nfunction checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {\n  var mappedKeyCode = _config2.default.keyCodes[key] || builtInKeyCode;\n  if (builtInKeyName && eventKeyName && !_config2.default.keyCodes[key]) {\n    return isKeyNotMatch(builtInKeyName, eventKeyName);\n  } else if (mappedKeyCode) {\n    return isKeyNotMatch(mappedKeyCode, eventKeyCode);\n  } else if (eventKeyName) {\n    return (0, _util.hyphenate)(eventKeyName) !== key;\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/render-helpers/check-keycodes.js?");

/***/ }),

/***/ "./src/core/instance/render-helpers/index.js":
/*!***************************************************!*\
  !*** ./src/core/instance/render-helpers/index.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.installRenderHelpers = installRenderHelpers;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _vnode = __webpack_require__(/*! core/vdom/vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _renderList = __webpack_require__(/*! ./render-list */ \"./src/core/instance/render-helpers/render-list.js\");\n\nvar _renderSlot = __webpack_require__(/*! ./render-slot */ \"./src/core/instance/render-helpers/render-slot.js\");\n\nvar _resolveFilter = __webpack_require__(/*! ./resolve-filter */ \"./src/core/instance/render-helpers/resolve-filter.js\");\n\nvar _checkKeycodes = __webpack_require__(/*! ./check-keycodes */ \"./src/core/instance/render-helpers/check-keycodes.js\");\n\nvar _bindObjectProps = __webpack_require__(/*! ./bind-object-props */ \"./src/core/instance/render-helpers/bind-object-props.js\");\n\nvar _renderStatic = __webpack_require__(/*! ./render-static */ \"./src/core/instance/render-helpers/render-static.js\");\n\nvar _bindObjectListeners = __webpack_require__(/*! ./bind-object-listeners */ \"./src/core/instance/render-helpers/bind-object-listeners.js\");\n\nvar _resolveSlots = __webpack_require__(/*! ./resolve-slots */ \"./src/core/instance/render-helpers/resolve-slots.js\");\n\nfunction installRenderHelpers(target) {\n  target._o = _renderStatic.markOnce;\n  target._n = _util.toNumber;\n  target._s = _util.toString;\n  target._l = _renderList.renderList;\n  target._t = _renderSlot.renderSlot;\n  target._q = _util.looseEqual;\n  target._i = _util.looseIndexOf;\n  target._m = _renderStatic.renderStatic;\n  target._f = _resolveFilter.resolveFilter;\n  target._k = _checkKeycodes.checkKeyCodes;\n  target._b = _bindObjectProps.bindObjectProps;\n  target._v = _vnode.createTextVNode;\n  target._e = _vnode.createEmptyVNode;\n  target._u = _resolveSlots.resolveScopedSlots;\n  target._g = _bindObjectListeners.bindObjectListeners;\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/render-helpers/index.js?");

/***/ }),

/***/ "./src/core/instance/render-helpers/render-list.js":
/*!*********************************************************!*\
  !*** ./src/core/instance/render-helpers/render-list.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.renderList = renderList;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\n/**\n * Runtime helper for rendering v-for lists.\n */\nfunction renderList(val, render) {\n  var ret = void 0,\n      i = void 0,\n      l = void 0,\n      keys = void 0,\n      key = void 0;\n  if (Array.isArray(val) || typeof val === 'string') {\n    ret = new Array(val.length);\n    for (i = 0, l = val.length; i < l; i++) {\n      ret[i] = render(val[i], i);\n    }\n  } else if (typeof val === 'number') {\n    ret = new Array(val);\n    for (i = 0; i < val; i++) {\n      ret[i] = render(i + 1, i);\n    }\n  } else if ((0, _index.isObject)(val)) {\n    keys = Object.keys(val);\n    ret = new Array(keys.length);\n    for (i = 0, l = keys.length; i < l; i++) {\n      key = keys[i];\n      ret[i] = render(val[key], key, i);\n    }\n  }\n  if ((0, _index.isDef)(ret)) {\n    ret._isVList = true;\n  }\n  return ret;\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/render-helpers/render-list.js?");

/***/ }),

/***/ "./src/core/instance/render-helpers/render-slot.js":
/*!*********************************************************!*\
  !*** ./src/core/instance/render-helpers/render-slot.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.renderSlot = renderSlot;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\n/**\n * Runtime helper for rendering <slot>\n */\nfunction renderSlot(name, fallback, props, bindObject) {\n  var scopedSlotFn = this.$scopedSlots[name];\n  var nodes = void 0;\n  if (scopedSlotFn) {\n    // scoped slot\n    props = props || {};\n    if (bindObject) {\n      if (\"development\" !== 'production' && !(0, _index.isObject)(bindObject)) {\n        (0, _index.warn)('slot v-bind without argument expects an Object', this);\n      }\n      props = (0, _index.extend)((0, _index.extend)({}, bindObject), props);\n    }\n    nodes = scopedSlotFn(props) || fallback;\n  } else {\n    var slotNodes = this.$slots[name];\n    // warn duplicate slot usage\n    if (slotNodes) {\n      if (\"development\" !== 'production' && slotNodes._rendered) {\n        (0, _index.warn)('Duplicate presence of slot \"' + name + '\" found in the same render tree ' + '- this will likely cause render errors.', this);\n      }\n      slotNodes._rendered = true;\n    }\n    nodes = slotNodes || fallback;\n  }\n\n  var target = props && props.slot;\n  if (target) {\n    return this.$createElement('template', { slot: target }, nodes);\n  } else {\n    return nodes;\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/render-helpers/render-slot.js?");

/***/ }),

/***/ "./src/core/instance/render-helpers/render-static.js":
/*!***********************************************************!*\
  !*** ./src/core/instance/render-helpers/render-static.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.renderStatic = renderStatic;\nexports.markOnce = markOnce;\n\n\n/**\n * Runtime helper for rendering static trees.\n */\nfunction renderStatic(index, isInFor) {\n  var cached = this._staticTrees || (this._staticTrees = []);\n  var tree = cached[index];\n  // if has already-rendered static tree and not inside v-for,\n  // we can reuse the same tree.\n  if (tree && !isInFor) {\n    return tree;\n  }\n  // otherwise, render a fresh tree.\n  tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates\n  );\n  markStatic(tree, '__static__' + index, false);\n  return tree;\n}\n\n/**\n * Runtime helper for v-once.\n * Effectively it means marking the node as static with a unique key.\n */\nfunction markOnce(tree, index, key) {\n  markStatic(tree, '__once__' + index + (key ? '_' + key : ''), true);\n  return tree;\n}\n\nfunction markStatic(tree, key, isOnce) {\n  if (Array.isArray(tree)) {\n    for (var i = 0; i < tree.length; i++) {\n      if (tree[i] && typeof tree[i] !== 'string') {\n        markStaticNode(tree[i], key + '_' + i, isOnce);\n      }\n    }\n  } else {\n    markStaticNode(tree, key, isOnce);\n  }\n}\n\nfunction markStaticNode(node, key, isOnce) {\n  node.isStatic = true;\n  node.key = key;\n  node.isOnce = isOnce;\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/render-helpers/render-static.js?");

/***/ }),

/***/ "./src/core/instance/render-helpers/resolve-filter.js":
/*!************************************************************!*\
  !*** ./src/core/instance/render-helpers/resolve-filter.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.resolveFilter = resolveFilter;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\n/**\n * Runtime helper for resolving filters\n */\nfunction resolveFilter(id) {\n  return (0, _index.resolveAsset)(this.$options, 'filters', id, true) || _index.identity;\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/render-helpers/resolve-filter.js?");

/***/ }),

/***/ "./src/core/instance/render-helpers/resolve-slots.js":
/*!***********************************************************!*\
  !*** ./src/core/instance/render-helpers/resolve-slots.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.resolveSlots = resolveSlots;\nexports.resolveScopedSlots = resolveScopedSlots;\n\n\n/**\n * Runtime helper for resolving raw children VNodes into a slot object.\n */\nfunction resolveSlots(children, context) {\n  var slots = {};\n  if (!children) {\n    return slots;\n  }\n  for (var i = 0, l = children.length; i < l; i++) {\n    var child = children[i];\n    var data = child.data;\n    // remove slot attribute if the node is resolved as a Vue slot node\n    if (data && data.attrs && data.attrs.slot) {\n      delete data.attrs.slot;\n    }\n    // named slots should only be respected if the vnode was rendered in the\n    // same context.\n    if ((child.context === context || child.fnContext === context) && data && data.slot != null) {\n      var name = data.slot;\n      var slot = slots[name] || (slots[name] = []);\n      if (child.tag === 'template') {\n        slot.push.apply(slot, child.children || []);\n      } else {\n        slot.push(child);\n      }\n    } else {\n      (slots.default || (slots.default = [])).push(child);\n    }\n  }\n  // ignore slots that contains only whitespace\n  for (var _name in slots) {\n    if (slots[_name].every(isWhitespace)) {\n      delete slots[_name];\n    }\n  }\n  return slots;\n}\n\nfunction isWhitespace(node) {\n  return node.isComment && !node.asyncFactory || node.text === ' ';\n}\n\nfunction resolveScopedSlots(fns, // see flow/vnode\nres) {\n  res = res || {};\n  for (var i = 0; i < fns.length; i++) {\n    if (Array.isArray(fns[i])) {\n      resolveScopedSlots(fns[i], res);\n    } else {\n      res[fns[i].key] = fns[i].fn;\n    }\n  }\n  return res;\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/render-helpers/resolve-slots.js?");

/***/ }),

/***/ "./src/core/instance/render.js":
/*!*************************************!*\
  !*** ./src/core/instance/render.js ***!
  \*************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initRender = initRender;\nexports.renderMixin = renderMixin;\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nvar _createElement = __webpack_require__(/*! ../vdom/create-element */ \"./src/core/vdom/create-element.js\");\n\nvar _index2 = __webpack_require__(/*! ./render-helpers/index */ \"./src/core/instance/render-helpers/index.js\");\n\nvar _resolveSlots = __webpack_require__(/*! ./render-helpers/resolve-slots */ \"./src/core/instance/render-helpers/resolve-slots.js\");\n\nvar _vnode = __webpack_require__(/*! ../vdom/vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _vnode2 = _interopRequireDefault(_vnode);\n\nvar _lifecycle = __webpack_require__(/*! ./lifecycle */ \"./src/core/instance/lifecycle.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction initRender(vm) {\n  vm._vnode = null; // the root of the child tree\n  vm._staticTrees = null; // v-once cached trees\n  var options = vm.$options;\n  var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree\n  var renderContext = parentVnode && parentVnode.context;\n  vm.$slots = (0, _resolveSlots.resolveSlots)(options._renderChildren, renderContext);\n  vm.$scopedSlots = _index.emptyObject;\n  // bind the createElement fn to this instance\n  // so that we get proper render context inside it.\n  // args order: tag, data, children, normalizationType, alwaysNormalize\n  // internal version is used by render functions compiled from templates\n  vm._c = function (a, b, c, d) {\n    return (0, _createElement.createElement)(vm, a, b, c, d, false);\n  };\n  // normalization is always applied for the public version, used in\n  // user-written render functions.\n  vm.$createElement = function (a, b, c, d) {\n    return (0, _createElement.createElement)(vm, a, b, c, d, true);\n  };\n\n  // $attrs & $listeners are exposed for easier HOC creation.\n  // they need to be reactive so that HOCs using them are always updated\n  var parentData = parentVnode && parentVnode.data;\n\n  /* istanbul ignore else */\n  if (true) {\n    (0, _index.defineReactive)(vm, '$attrs', parentData && parentData.attrs || _index.emptyObject, function () {\n      !_lifecycle.isUpdatingChildComponent && (0, _index.warn)('$attrs is readonly.', vm);\n    }, true);\n    (0, _index.defineReactive)(vm, '$listeners', options._parentListeners || _index.emptyObject, function () {\n      !_lifecycle.isUpdatingChildComponent && (0, _index.warn)('$listeners is readonly.', vm);\n    }, true);\n  } else {}\n}\n\nfunction renderMixin(Vue) {\n  // install runtime convenience helpers\n  (0, _index2.installRenderHelpers)(Vue.prototype);\n\n  Vue.prototype.$nextTick = function (fn) {\n    return (0, _index.nextTick)(fn, this);\n  };\n\n  Vue.prototype._render = function () {\n    var vm = this;\n    var _vm$$options = vm.$options,\n        render = _vm$$options.render,\n        _parentVnode = _vm$$options._parentVnode;\n\n    // reset _rendered flag on slots for duplicate slot check\n\n    if (true) {\n      for (var key in vm.$slots) {\n        // $flow-disable-line\n        vm.$slots[key]._rendered = false;\n      }\n    }\n\n    if (_parentVnode) {\n      vm.$scopedSlots = _parentVnode.data.scopedSlots || _index.emptyObject;\n    }\n\n    // set parent vnode. this allows render functions to have access\n    // to the data on the placeholder node.\n    vm.$vnode = _parentVnode;\n    // render self\n    var vnode = void 0;\n    try {\n      vnode = render.call(vm._renderProxy, vm.$createElement);\n    } catch (e) {\n      (0, _index.handleError)(e, vm, 'render');\n      // return error render result,\n      // or previous vnode to prevent render error causing blank component\n      /* istanbul ignore else */\n      if (true) {\n        if (vm.$options.renderError) {\n          try {\n            vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);\n          } catch (e) {\n            (0, _index.handleError)(e, vm, 'renderError');\n            vnode = vm._vnode;\n          }\n        } else {\n          vnode = vm._vnode;\n        }\n      } else {}\n    }\n    // return empty vnode in case the render function errored out\n    if (!(vnode instanceof _vnode2.default)) {\n      if (\"development\" !== 'production' && Array.isArray(vnode)) {\n        (0, _index.warn)('Multiple root nodes returned from render function. Render function ' + 'should return a single root node.', vm);\n      }\n      vnode = (0, _vnode.createEmptyVNode)();\n    }\n    // set parent\n    vnode.parent = _parentVnode;\n    return vnode;\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/render.js?");

/***/ }),

/***/ "./src/core/instance/state.js":
/*!************************************!*\
  !*** ./src/core/instance/state.js ***!
  \************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.proxy = proxy;\nexports.initState = initState;\nexports.getData = getData;\nexports.defineComputed = defineComputed;\nexports.stateMixin = stateMixin;\n\nvar _config = __webpack_require__(/*! ../config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _watcher = __webpack_require__(/*! ../observer/watcher */ \"./src/core/observer/watcher.js\");\n\nvar _watcher2 = _interopRequireDefault(_watcher);\n\nvar _dep = __webpack_require__(/*! ../observer/dep */ \"./src/core/observer/dep.js\");\n\nvar _dep2 = _interopRequireDefault(_dep);\n\nvar _lifecycle = __webpack_require__(/*! ./lifecycle */ \"./src/core/instance/lifecycle.js\");\n\nvar _index = __webpack_require__(/*! ../observer/index */ \"./src/core/observer/index.js\");\n\nvar _index2 = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar sharedPropertyDefinition = {\n  enumerable: true,\n  configurable: true,\n  get: _index2.noop,\n  set: _index2.noop\n};\n\nfunction proxy(target, sourceKey, key) {\n  sharedPropertyDefinition.get = function proxyGetter() {\n    return this[sourceKey][key];\n  };\n  sharedPropertyDefinition.set = function proxySetter(val) {\n    this[sourceKey][key] = val;\n  };\n  Object.defineProperty(target, key, sharedPropertyDefinition);\n}\n\nfunction initState(vm) {\n  vm._watchers = [];\n  var opts = vm.$options;\n  if (opts.props) initProps(vm, opts.props);\n  if (opts.methods) initMethods(vm, opts.methods);\n  if (opts.data) {\n    initData(vm);\n  } else {\n    (0, _index.observe)(vm._data = {}, true /* asRootData */);\n  }\n  if (opts.computed) initComputed(vm, opts.computed);\n  if (opts.watch && opts.watch !== _index2.nativeWatch) {\n    initWatch(vm, opts.watch);\n  }\n}\n\nfunction initProps(vm, propsOptions) {\n  var propsData = vm.$options.propsData || {};\n  var props = vm._props = {};\n  // cache prop keys so that future props updates can iterate using Array\n  // instead of dynamic object key enumeration.\n  var keys = vm.$options._propKeys = [];\n  var isRoot = !vm.$parent;\n  // root instance props should be converted\n  if (!isRoot) {\n    (0, _index.toggleObserving)(false);\n  }\n\n  var _loop = function _loop(key) {\n    keys.push(key);\n    var value = (0, _index2.validateProp)(key, propsOptions, propsData, vm);\n    /* istanbul ignore else */\n    if (true) {\n      var hyphenatedKey = (0, _index2.hyphenate)(key);\n      if ((0, _index2.isReservedAttribute)(hyphenatedKey) || _config2.default.isReservedAttr(hyphenatedKey)) {\n        (0, _index2.warn)('\"' + hyphenatedKey + '\" is a reserved attribute and cannot be used as component prop.', vm);\n      }\n      (0, _index.defineReactive)(props, key, value, function () {\n        if (vm.$parent && !_lifecycle.isUpdatingChildComponent) {\n          (0, _index2.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);\n        }\n      });\n    } else {}\n    // static props are already proxied on the component's prototype\n    // during Vue.extend(). We only need to proxy props defined at\n    // instantiation here.\n    if (!(key in vm)) {\n      proxy(vm, '_props', key);\n    }\n  };\n\n  for (var key in propsOptions) {\n    _loop(key);\n  }\n  (0, _index.toggleObserving)(true);\n}\n\nfunction initData(vm) {\n  var data = vm.$options.data;\n  data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};\n  if (!(0, _index2.isPlainObject)(data)) {\n    data = {};\n    \"development\" !== 'production' && (0, _index2.warn)('data functions should return an object:\\n' + 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);\n  }\n  // proxy data on instance\n  var keys = Object.keys(data);\n  var props = vm.$options.props;\n  var methods = vm.$options.methods;\n  var i = keys.length;\n  while (i--) {\n    var key = keys[i];\n    if (true) {\n      if (methods && (0, _index2.hasOwn)(methods, key)) {\n        (0, _index2.warn)('Method \"' + key + '\" has already been defined as a data property.', vm);\n      }\n    }\n    if (props && (0, _index2.hasOwn)(props, key)) {\n      \"development\" !== 'production' && (0, _index2.warn)('The data property \"' + key + '\" is already declared as a prop. ' + 'Use prop default value instead.', vm);\n    } else if (!(0, _index2.isReserved)(key)) {\n      proxy(vm, '_data', key);\n    }\n  }\n  // observe data\n  (0, _index.observe)(data, true /* asRootData */);\n}\n\nfunction getData(data, vm) {\n  // #7573 disable dep collection when invoking data getters\n  (0, _dep.pushTarget)();\n  try {\n    return data.call(vm, vm);\n  } catch (e) {\n    (0, _index2.handleError)(e, vm, 'data()');\n    return {};\n  } finally {\n    (0, _dep.popTarget)();\n  }\n}\n\nvar computedWatcherOptions = { lazy: true };\n\nfunction initComputed(vm, computed) {\n  // $flow-disable-line\n  var watchers = vm._computedWatchers = Object.create(null);\n  // computed properties are just getters during SSR\n  var isSSR = (0, _index2.isServerRendering)();\n\n  for (var key in computed) {\n    var userDef = computed[key];\n    var getter = typeof userDef === 'function' ? userDef : userDef.get;\n    if (\"development\" !== 'production' && getter == null) {\n      (0, _index2.warn)('Getter is missing for computed property \"' + key + '\".', vm);\n    }\n\n    if (!isSSR) {\n      // create internal watcher for the computed property.\n      watchers[key] = new _watcher2.default(vm, getter || _index2.noop, _index2.noop, computedWatcherOptions);\n    }\n\n    // component-defined computed properties are already defined on the\n    // component prototype. We only need to define computed properties defined\n    // at instantiation here.\n    if (!(key in vm)) {\n      defineComputed(vm, key, userDef);\n    } else if (true) {\n      if (key in vm.$data) {\n        (0, _index2.warn)('The computed property \"' + key + '\" is already defined in data.', vm);\n      } else if (vm.$options.props && key in vm.$options.props) {\n        (0, _index2.warn)('The computed property \"' + key + '\" is already defined as a prop.', vm);\n      }\n    }\n  }\n}\n\nfunction defineComputed(target, key, userDef) {\n  var shouldCache = !(0, _index2.isServerRendering)();\n  if (typeof userDef === 'function') {\n    sharedPropertyDefinition.get = shouldCache ? createComputedGetter(key) : userDef;\n    sharedPropertyDefinition.set = _index2.noop;\n  } else {\n    sharedPropertyDefinition.get = userDef.get ? shouldCache && userDef.cache !== false ? createComputedGetter(key) : userDef.get : _index2.noop;\n    sharedPropertyDefinition.set = userDef.set ? userDef.set : _index2.noop;\n  }\n  if (\"development\" !== 'production' && sharedPropertyDefinition.set === _index2.noop) {\n    sharedPropertyDefinition.set = function () {\n      (0, _index2.warn)('Computed property \"' + key + '\" was assigned to but it has no setter.', this);\n    };\n  }\n  Object.defineProperty(target, key, sharedPropertyDefinition);\n}\n\nfunction createComputedGetter(key) {\n  return function computedGetter() {\n    var watcher = this._computedWatchers && this._computedWatchers[key];\n    if (watcher) {\n      if (watcher.dirty) {\n        watcher.evaluate();\n      }\n      if (_dep2.default.target) {\n        watcher.depend();\n      }\n      return watcher.value;\n    }\n  };\n}\n\nfunction initMethods(vm, methods) {\n  var props = vm.$options.props;\n  for (var key in methods) {\n    if (true) {\n      if (methods[key] == null) {\n        (0, _index2.warn)('Method \"' + key + '\" has an undefined value in the component definition. ' + 'Did you reference the function correctly?', vm);\n      }\n      if (props && (0, _index2.hasOwn)(props, key)) {\n        (0, _index2.warn)('Method \"' + key + '\" has already been defined as a prop.', vm);\n      }\n      if (key in vm && (0, _index2.isReserved)(key)) {\n        (0, _index2.warn)('Method \"' + key + '\" conflicts with an existing Vue instance method. ' + 'Avoid defining component methods that start with _ or $.');\n      }\n    }\n    vm[key] = methods[key] == null ? _index2.noop : (0, _index2.bind)(methods[key], vm);\n  }\n}\n\nfunction initWatch(vm, watch) {\n  for (var key in watch) {\n    var handler = watch[key];\n    if (Array.isArray(handler)) {\n      for (var i = 0; i < handler.length; i++) {\n        createWatcher(vm, key, handler[i]);\n      }\n    } else {\n      createWatcher(vm, key, handler);\n    }\n  }\n}\n\nfunction createWatcher(vm, expOrFn, handler, options) {\n  if ((0, _index2.isPlainObject)(handler)) {\n    options = handler;\n    handler = handler.handler;\n  }\n  if (typeof handler === 'string') {\n    handler = vm[handler];\n  }\n  return vm.$watch(expOrFn, handler, options);\n}\n\nfunction stateMixin(Vue) {\n  // flow somehow has problems with directly declared definition object\n  // when using Object.defineProperty, so we have to procedurally build up\n  // the object here.\n  var dataDef = {};\n  dataDef.get = function () {\n    return this._data;\n  };\n  var propsDef = {};\n  propsDef.get = function () {\n    return this._props;\n  };\n  if (true) {\n    dataDef.set = function (newData) {\n      (0, _index2.warn)('Avoid replacing instance root $data. ' + 'Use nested data properties instead.', this);\n    };\n    propsDef.set = function () {\n      (0, _index2.warn)('$props is readonly.', this);\n    };\n  }\n  Object.defineProperty(Vue.prototype, '$data', dataDef);\n  Object.defineProperty(Vue.prototype, '$props', propsDef);\n\n  Vue.prototype.$set = _index.set;\n  Vue.prototype.$delete = _index.del;\n\n  Vue.prototype.$watch = function (expOrFn, cb, options) {\n    var vm = this;\n    if ((0, _index2.isPlainObject)(cb)) {\n      return createWatcher(vm, expOrFn, cb, options);\n    }\n    options = options || {};\n    options.user = true;\n    var watcher = new _watcher2.default(vm, expOrFn, cb, options);\n    if (options.immediate) {\n      cb.call(vm, watcher.value);\n    }\n    return function unwatchFn() {\n      watcher.teardown();\n    };\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/core/instance/state.js?");

/***/ }),

/***/ "./src/core/observer/array.js":
/*!************************************!*\
  !*** ./src/core/observer/array.js ***!
  \************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.arrayMethods = undefined;\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nvar arrayProto = Array.prototype; /*\n                                   * not type checking this file because flow doesn't play well with\n                                   * dynamically accessing methods on Array prototype\n                                   */\n\nvar arrayMethods = exports.arrayMethods = Object.create(arrayProto);\n\nvar methodsToPatch = ['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'];\n\n/**\n * Intercept mutating methods and emit events\n */\nmethodsToPatch.forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  (0, _index.def)(arrayMethods, method, function mutator() {\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    var result = original.apply(this, args);\n    var ob = this.__ob__;\n    var inserted = void 0;\n    switch (method) {\n      case 'push':\n      case 'unshift':\n        inserted = args;\n        break;\n      case 'splice':\n        inserted = args.slice(2);\n        break;\n    }\n    if (inserted) ob.observeArray(inserted);\n    // notify change\n    ob.dep.notify();\n    return result;\n  });\n});\n\n//# sourceURL=webpack://Vue/./src/core/observer/array.js?");

/***/ }),

/***/ "./src/core/observer/dep.js":
/*!**********************************!*\
  !*** ./src/core/observer/dep.js ***!
  \**********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nexports.pushTarget = pushTarget;\nexports.popTarget = popTarget;\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar uid = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\n\nvar Dep = function () {\n  function Dep() {\n    _classCallCheck(this, Dep);\n\n    this.id = uid++;\n    this.subs = [];\n  }\n\n  _createClass(Dep, [{\n    key: 'addSub',\n    value: function addSub(sub) {\n      this.subs.push(sub);\n    }\n  }, {\n    key: 'removeSub',\n    value: function removeSub(sub) {\n      (0, _index.remove)(this.subs, sub);\n    }\n  }, {\n    key: 'depend',\n    value: function depend() {\n      if (Dep.target) {\n        Dep.target.addDep(this);\n      }\n    }\n  }, {\n    key: 'notify',\n    value: function notify() {\n      // stabilize the subscriber list first\n      var subs = this.subs.slice();\n      for (var i = 0, l = subs.length; i < l; i++) {\n        subs[i].update();\n      }\n    }\n  }]);\n\n  return Dep;\n}();\n\n// the current target watcher being evaluated.\n// this is globally unique because there could be only one\n// watcher being evaluated at any time.\n\n\nexports.default = Dep;\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget(_target) {\n  if (Dep.target) targetStack.push(Dep.target);\n  Dep.target = _target;\n}\n\nfunction popTarget() {\n  Dep.target = targetStack.pop();\n}\n\n//# sourceURL=webpack://Vue/./src/core/observer/dep.js?");

/***/ }),

/***/ "./src/core/observer/index.js":
/*!************************************!*\
  !*** ./src/core/observer/index.js ***!
  \************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.Observer = exports.shouldObserve = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nexports.toggleObserving = toggleObserving;\nexports.observe = observe;\nexports.defineReactive = defineReactive;\nexports.set = set;\nexports.del = del;\n\nvar _dep = __webpack_require__(/*! ./dep */ \"./src/core/observer/dep.js\");\n\nvar _dep2 = _interopRequireDefault(_dep);\n\nvar _vnode = __webpack_require__(/*! ../vdom/vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _vnode2 = _interopRequireDefault(_vnode);\n\nvar _array = __webpack_require__(/*! ./array */ \"./src/core/observer/array.js\");\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar arrayKeys = Object.getOwnPropertyNames(_array.arrayMethods);\n\n/**\n * In some cases we may want to disable observation inside a component's\n * update computation.\n */\nvar shouldObserve = exports.shouldObserve = true;\n\nfunction toggleObserving(value) {\n  exports.shouldObserve = shouldObserve = value;\n}\n\n/**\n * Observer class that is attached to each observed\n * object. Once attached, the observer converts the target\n * object's property keys into getter/setters that\n * collect dependencies and dispatch updates.\n */\n\nvar Observer = exports.Observer = function () {\n  // number of vms that has this object as root $data\n\n  function Observer(value) {\n    _classCallCheck(this, Observer);\n\n    this.value = value;\n    this.dep = new _dep2.default();\n    this.vmCount = 0;\n    (0, _index.def)(value, '__ob__', this);\n    if (Array.isArray(value)) {\n      var augment = _index.hasProto ? protoAugment : copyAugment;\n      augment(value, _array.arrayMethods, arrayKeys);\n      this.observeArray(value);\n    } else {\n      this.walk(value);\n    }\n  }\n\n  /**\n   * Walk through each property and convert them into\n   * getter/setters. This method should only be called when\n   * value type is Object.\n   */\n\n\n  _createClass(Observer, [{\n    key: 'walk',\n    value: function walk(obj) {\n      var keys = Object.keys(obj);\n      for (var i = 0; i < keys.length; i++) {\n        defineReactive(obj, keys[i]);\n      }\n    }\n\n    /**\n     * Observe a list of Array items.\n     */\n\n  }, {\n    key: 'observeArray',\n    value: function observeArray(items) {\n      for (var i = 0, l = items.length; i < l; i++) {\n        observe(items[i]);\n      }\n    }\n  }]);\n\n  return Observer;\n}();\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\n\n\nfunction protoAugment(target, src, keys) {\n  /* eslint-disable no-proto */\n  target.__proto__ = src;\n  /* eslint-enable no-proto */\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n */\n/* istanbul ignore next */\nfunction copyAugment(target, src, keys) {\n  for (var i = 0, l = keys.length; i < l; i++) {\n    var key = keys[i];\n    (0, _index.def)(target, key, src[key]);\n  }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n */\nfunction observe(value, asRootData) {\n  if (!(0, _index.isObject)(value) || value instanceof _vnode2.default) {\n    return;\n  }\n  var ob = void 0;\n  if ((0, _index.hasOwn)(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if (shouldObserve && !(0, _index.isServerRendering)() && (Array.isArray(value) || (0, _index.isPlainObject)(value)) && Object.isExtensible(value) && !value._isVue) {\n    ob = new Observer(value);\n  }\n  if (asRootData && ob) {\n    ob.vmCount++;\n  }\n  return ob;\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive(obj, key, val, customSetter, shallow) {\n  var dep = new _dep2.default();\n\n  var property = Object.getOwnPropertyDescriptor(obj, key);\n  if (property && property.configurable === false) {\n    return;\n  }\n\n  // cater for pre-defined getter/setters\n  var getter = property && property.get;\n  if (!getter && arguments.length === 2) {\n    val = obj[key];\n  }\n  var setter = property && property.set;\n\n  var childOb = !shallow && observe(val);\n  Object.defineProperty(obj, key, {\n    enumerable: true,\n    configurable: true,\n    get: function reactiveGetter() {\n      var value = getter ? getter.call(obj) : val;\n      if (_dep2.default.target) {\n        dep.depend();\n        if (childOb) {\n          childOb.dep.depend();\n          if (Array.isArray(value)) {\n            dependArray(value);\n          }\n        }\n      }\n      return value;\n    },\n    set: function reactiveSetter(newVal) {\n      var value = getter ? getter.call(obj) : val;\n      /* eslint-disable no-self-compare */\n      if (newVal === value || newVal !== newVal && value !== value) {\n        return;\n      }\n      /* eslint-enable no-self-compare */\n      if (\"development\" !== 'production' && customSetter) {\n        customSetter();\n      }\n      if (setter) {\n        setter.call(obj, newVal);\n      } else {\n        val = newVal;\n      }\n      childOb = !shallow && observe(newVal);\n      dep.notify();\n    }\n  });\n}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n */\nfunction set(target, key, val) {\n  if (\"development\" !== 'production' && ((0, _index.isUndef)(target) || (0, _index.isPrimitive)(target))) {\n    (0, _index.warn)('Cannot set reactive property on undefined, null, or primitive value: ' + target);\n  }\n  if (Array.isArray(target) && (0, _index.isValidArrayIndex)(key)) {\n    target.length = Math.max(target.length, key);\n    target.splice(key, 1, val);\n    return val;\n  }\n  if (key in target && !(key in Object.prototype)) {\n    target[key] = val;\n    return val;\n  }\n  var ob = target.__ob__;\n  if (target._isVue || ob && ob.vmCount) {\n    \"development\" !== 'production' && (0, _index.warn)('Avoid adding reactive properties to a Vue instance or its root $data ' + 'at runtime - declare it upfront in the data option.');\n    return val;\n  }\n  if (!ob) {\n    target[key] = val;\n    return val;\n  }\n  defineReactive(ob.value, key, val);\n  ob.dep.notify();\n  return val;\n}\n\n/**\n * Delete a property and trigger change if necessary.\n */\nfunction del(target, key) {\n  if (\"development\" !== 'production' && ((0, _index.isUndef)(target) || (0, _index.isPrimitive)(target))) {\n    (0, _index.warn)('Cannot delete reactive property on undefined, null, or primitive value: ' + target);\n  }\n  if (Array.isArray(target) && (0, _index.isValidArrayIndex)(key)) {\n    target.splice(key, 1);\n    return;\n  }\n  var ob = target.__ob__;\n  if (target._isVue || ob && ob.vmCount) {\n    \"development\" !== 'production' && (0, _index.warn)('Avoid deleting properties on a Vue instance or its root $data ' + '- just set it to null.');\n    return;\n  }\n  if (!(0, _index.hasOwn)(target, key)) {\n    return;\n  }\n  delete target[key];\n  if (!ob) {\n    return;\n  }\n  ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n */\nfunction dependArray(value) {\n  for (var e, i = 0, l = value.length; i < l; i++) {\n    e = value[i];\n    e && e.__ob__ && e.__ob__.dep.depend();\n    if (Array.isArray(e)) {\n      dependArray(e);\n    }\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/observer/index.js?");

/***/ }),

/***/ "./src/core/observer/scheduler.js":
/*!****************************************!*\
  !*** ./src/core/observer/scheduler.js ***!
  \****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.MAX_UPDATE_COUNT = undefined;\nexports.queueActivatedComponent = queueActivatedComponent;\nexports.queueWatcher = queueWatcher;\n\nvar _config = __webpack_require__(/*! ../config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _lifecycle = __webpack_require__(/*! ../instance/lifecycle */ \"./src/core/instance/lifecycle.js\");\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar MAX_UPDATE_COUNT = exports.MAX_UPDATE_COUNT = 100;\n\nvar queue = [];\nvar activatedChildren = [];\nvar has = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\n * Reset the scheduler's state.\n */\nfunction resetSchedulerState() {\n  index = queue.length = activatedChildren.length = 0;\n  has = {};\n  if (true) {\n    circular = {};\n  }\n  waiting = flushing = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue() {\n  flushing = true;\n  var watcher = void 0,\n      id = void 0;\n\n  // Sort queue before flush.\n  // This ensures that:\n  // 1. Components are updated from parent to child. (because parent is always\n  //    created before the child)\n  // 2. A component's user watchers are run before its render watcher (because\n  //    user watchers are created before the render watcher)\n  // 3. If a component is destroyed during a parent component's watcher run,\n  //    its watchers can be skipped.\n  queue.sort(function (a, b) {\n    return a.id - b.id;\n  });\n\n  // do not cache length because more watchers might be pushed\n  // as we run existing watchers\n  for (index = 0; index < queue.length; index++) {\n    watcher = queue[index];\n    id = watcher.id;\n    has[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if (\"development\" !== 'production' && has[id] != null) {\n      circular[id] = (circular[id] || 0) + 1;\n      if (circular[id] > MAX_UPDATE_COUNT) {\n        (0, _index.warn)('You may have an infinite update loop ' + (watcher.user ? 'in watcher with expression \"' + watcher.expression + '\"' : 'in a component render function.'), watcher.vm);\n        break;\n      }\n    }\n  }\n\n  // keep copies of post queues before resetting state\n  var activatedQueue = activatedChildren.slice();\n  var updatedQueue = queue.slice();\n\n  resetSchedulerState();\n\n  // call component updated and activated hooks\n  callActivatedHooks(activatedQueue);\n  callUpdatedHooks(updatedQueue);\n\n  // devtool hook\n  /* istanbul ignore if */\n  if (_index.devtools && _config2.default.devtools) {\n    _index.devtools.emit('flush');\n  }\n}\n\nfunction callUpdatedHooks(queue) {\n  var i = queue.length;\n  while (i--) {\n    var watcher = queue[i];\n    var vm = watcher.vm;\n    if (vm._watcher === watcher && vm._isMounted) {\n      (0, _lifecycle.callHook)(vm, 'updated');\n    }\n  }\n}\n\n/**\n * Queue a kept-alive component that was activated during patch.\n * The queue will be processed after the entire tree has been patched.\n */\nfunction queueActivatedComponent(vm) {\n  // setting _inactive to false here so that a render function can\n  // rely on checking whether it's in an inactive tree (e.g. router-view)\n  vm._inactive = false;\n  activatedChildren.push(vm);\n}\n\nfunction callActivatedHooks(queue) {\n  for (var i = 0; i < queue.length; i++) {\n    queue[i]._inactive = true;\n    (0, _lifecycle.activateChildComponent)(queue[i], true /* true */);\n  }\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher(watcher) {\n  var id = watcher.id;\n  if (has[id] == null) {\n    has[id] = true;\n    if (!flushing) {\n      queue.push(watcher);\n    } else {\n      // if already flushing, splice the watcher based on its id\n      // if already past its id, it will be run next immediately.\n      var i = queue.length - 1;\n      while (i > index && queue[i].id > watcher.id) {\n        i--;\n      }\n      queue.splice(i + 1, 0, watcher);\n    }\n    // queue the flush\n    if (!waiting) {\n      waiting = true;\n      (0, _index.nextTick)(flushSchedulerQueue);\n    }\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/observer/scheduler.js?");

/***/ }),

/***/ "./src/core/observer/traverse.js":
/*!***************************************!*\
  !*** ./src/core/observer/traverse.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.traverse = traverse;\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nvar _vnode = __webpack_require__(/*! ../vdom/vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _vnode2 = _interopRequireDefault(_vnode);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar seenObjects = new _index._Set();\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nfunction traverse(val) {\n  _traverse(val, seenObjects);\n  seenObjects.clear();\n}\n\nfunction _traverse(val, seen) {\n  var i = void 0,\n      keys = void 0;\n  var isA = Array.isArray(val);\n  if (!isA && !(0, _index.isObject)(val) || Object.isFrozen(val) || val instanceof _vnode2.default) {\n    return;\n  }\n  if (val.__ob__) {\n    var depId = val.__ob__.dep.id;\n    if (seen.has(depId)) {\n      return;\n    }\n    seen.add(depId);\n  }\n  if (isA) {\n    i = val.length;\n    while (i--) {\n      _traverse(val[i], seen);\n    }\n  } else {\n    keys = Object.keys(val);\n    i = keys.length;\n    while (i--) {\n      _traverse(val[keys[i]], seen);\n    }\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/observer/traverse.js?");

/***/ }),

/***/ "./src/core/observer/watcher.js":
/*!**************************************!*\
  !*** ./src/core/observer/watcher.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nvar _traverse = __webpack_require__(/*! ./traverse */ \"./src/core/observer/traverse.js\");\n\nvar _scheduler = __webpack_require__(/*! ./scheduler */ \"./src/core/observer/scheduler.js\");\n\nvar _dep = __webpack_require__(/*! ./dep */ \"./src/core/observer/dep.js\");\n\nvar _dep2 = _interopRequireDefault(_dep);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar uid = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n */\n\nvar Watcher = function () {\n  function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {\n    _classCallCheck(this, Watcher);\n\n    this.vm = vm;\n    if (isRenderWatcher) {\n      vm._watcher = this;\n    }\n    vm._watchers.push(this);\n    // options\n    if (options) {\n      this.deep = !!options.deep;\n      this.user = !!options.user;\n      this.lazy = !!options.lazy;\n      this.sync = !!options.sync;\n    } else {\n      this.deep = this.user = this.lazy = this.sync = false;\n    }\n    this.cb = cb;\n    this.id = ++uid; // uid for batching\n    this.active = true;\n    this.dirty = this.lazy; // for lazy watchers\n    this.deps = [];\n    this.newDeps = [];\n    this.depIds = new _index._Set();\n    this.newDepIds = new _index._Set();\n    this.expression =  true ? expOrFn.toString() : undefined;\n    // parse expression for getter\n    if (typeof expOrFn === 'function') {\n      this.getter = expOrFn;\n    } else {\n      this.getter = (0, _index.parsePath)(expOrFn);\n      if (!this.getter) {\n        this.getter = function () {};\n        \"development\" !== 'production' && (0, _index.warn)('Failed watching path: \"' + expOrFn + '\" ' + 'Watcher only accepts simple dot-delimited paths. ' + 'For full control, use a function instead.', vm);\n      }\n    }\n    this.value = this.lazy ? undefined : this.get();\n  }\n\n  /**\n   * Evaluate the getter, and re-collect dependencies.\n   */\n\n\n  _createClass(Watcher, [{\n    key: 'get',\n    value: function get() {\n      (0, _dep.pushTarget)(this);\n      var value = void 0;\n      var vm = this.vm;\n      try {\n        value = this.getter.call(vm, vm);\n      } catch (e) {\n        if (this.user) {\n          (0, _index.handleError)(e, vm, 'getter for watcher \"' + this.expression + '\"');\n        } else {\n          throw e;\n        }\n      } finally {\n        // \"touch\" every property so they are all tracked as\n        // dependencies for deep watching\n        if (this.deep) {\n          (0, _traverse.traverse)(value);\n        }\n        (0, _dep.popTarget)();\n        this.cleanupDeps();\n      }\n      return value;\n    }\n\n    /**\n     * Add a dependency to this directive.\n     */\n\n  }, {\n    key: 'addDep',\n    value: function addDep(dep) {\n      var id = dep.id;\n      if (!this.newDepIds.has(id)) {\n        this.newDepIds.add(id);\n        this.newDeps.push(dep);\n        if (!this.depIds.has(id)) {\n          dep.addSub(this);\n        }\n      }\n    }\n\n    /**\n     * Clean up for dependency collection.\n     */\n\n  }, {\n    key: 'cleanupDeps',\n    value: function cleanupDeps() {\n      var i = this.deps.length;\n      while (i--) {\n        var dep = this.deps[i];\n        if (!this.newDepIds.has(dep.id)) {\n          dep.removeSub(this);\n        }\n      }\n      var tmp = this.depIds;\n      this.depIds = this.newDepIds;\n      this.newDepIds = tmp;\n      this.newDepIds.clear();\n      tmp = this.deps;\n      this.deps = this.newDeps;\n      this.newDeps = tmp;\n      this.newDeps.length = 0;\n    }\n\n    /**\n     * Subscriber interface.\n     * Will be called when a dependency changes.\n     */\n\n  }, {\n    key: 'update',\n    value: function update() {\n      /* istanbul ignore else */\n      if (this.lazy) {\n        this.dirty = true;\n      } else if (this.sync) {\n        this.run();\n      } else {\n        (0, _scheduler.queueWatcher)(this);\n      }\n    }\n\n    /**\n     * Scheduler job interface.\n     * Will be called by the scheduler.\n     */\n\n  }, {\n    key: 'run',\n    value: function run() {\n      if (this.active) {\n        var value = this.get();\n        if (value !== this.value ||\n        // Deep watchers and watchers on Object/Arrays should fire even\n        // when the value is the same, because the value may\n        // have mutated.\n        (0, _index.isObject)(value) || this.deep) {\n          // set new value\n          var oldValue = this.value;\n          this.value = value;\n          if (this.user) {\n            try {\n              this.cb.call(this.vm, value, oldValue);\n            } catch (e) {\n              (0, _index.handleError)(e, this.vm, 'callback for watcher \"' + this.expression + '\"');\n            }\n          } else {\n            this.cb.call(this.vm, value, oldValue);\n          }\n        }\n      }\n    }\n\n    /**\n     * Evaluate the value of the watcher.\n     * This only gets called for lazy watchers.\n     */\n\n  }, {\n    key: 'evaluate',\n    value: function evaluate() {\n      this.value = this.get();\n      this.dirty = false;\n    }\n\n    /**\n     * Depend on all deps collected by this watcher.\n     */\n\n  }, {\n    key: 'depend',\n    value: function depend() {\n      var i = this.deps.length;\n      while (i--) {\n        this.deps[i].depend();\n      }\n    }\n\n    /**\n     * Remove self from all dependencies' subscriber list.\n     */\n\n  }, {\n    key: 'teardown',\n    value: function teardown() {\n      if (this.active) {\n        // remove self from vm's watcher list\n        // this is a somewhat expensive operation so we skip it\n        // if the vm is being destroyed.\n        if (!this.vm._isBeingDestroyed) {\n          (0, _index.remove)(this.vm._watchers, this);\n        }\n        var i = this.deps.length;\n        while (i--) {\n          this.deps[i].removeSub(this);\n        }\n        this.active = false;\n      }\n    }\n  }]);\n\n  return Watcher;\n}();\n\nexports.default = Watcher;\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/core/observer/watcher.js?");

/***/ }),

/***/ "./src/core/util/debug.js":
/*!********************************!*\
  !*** ./src/core/util/debug.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.formatComponentName = exports.generateComponentTrace = exports.tip = exports.warn = undefined;\n\nvar _config = __webpack_require__(/*! ../config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar warn = exports.warn = _util.noop;\nvar tip = exports.tip = _util.noop;\nvar generateComponentTrace = exports.generateComponentTrace = _util.noop; // work around flow check\nvar formatComponentName = exports.formatComponentName = _util.noop;\n\nif (true) {\n  var hasConsole = typeof console !== 'undefined';\n  var classifyRE = /(?:^|[-_])(\\w)/g;\n  var classify = function classify(str) {\n    return str.replace(classifyRE, function (c) {\n      return c.toUpperCase();\n    }).replace(/[-_]/g, '');\n  };\n\n  exports.warn = warn = function warn(msg, vm) {\n    var trace = vm ? generateComponentTrace(vm) : '';\n\n    if (_config2.default.warnHandler) {\n      _config2.default.warnHandler.call(null, msg, vm, trace);\n    } else if (hasConsole && !_config2.default.silent) {\n      console.error('[Vue warn]: ' + msg + trace);\n    }\n  };\n\n  exports.tip = tip = function tip(msg, vm) {\n    if (hasConsole && !_config2.default.silent) {\n      console.warn('[Vue tip]: ' + msg + (vm ? generateComponentTrace(vm) : ''));\n    }\n  };\n\n  exports.formatComponentName = formatComponentName = function formatComponentName(vm, includeFile) {\n    if (vm.$root === vm) {\n      return '<Root>';\n    }\n    var options = typeof vm === 'function' && vm.cid != null ? vm.options : vm._isVue ? vm.$options || vm.constructor.options : vm || {};\n    var name = options.name || options._componentTag;\n    var file = options.__file;\n    if (!name && file) {\n      var match = file.match(/([^/\\\\]+)\\.vue$/);\n      name = match && match[1];\n    }\n\n    return (name ? '<' + classify(name) + '>' : '<Anonymous>') + (file && includeFile !== false ? ' at ' + file : '');\n  };\n\n  var repeat = function repeat(str, n) {\n    var res = '';\n    while (n) {\n      if (n % 2 === 1) res += str;\n      if (n > 1) str += str;\n      n >>= 1;\n    }\n    return res;\n  };\n\n  exports.generateComponentTrace = generateComponentTrace = function generateComponentTrace(vm) {\n    if (vm._isVue && vm.$parent) {\n      var tree = [];\n      var currentRecursiveSequence = 0;\n      while (vm) {\n        if (tree.length > 0) {\n          var last = tree[tree.length - 1];\n          if (last.constructor === vm.constructor) {\n            currentRecursiveSequence++;\n            vm = vm.$parent;\n            continue;\n          } else if (currentRecursiveSequence > 0) {\n            tree[tree.length - 1] = [last, currentRecursiveSequence];\n            currentRecursiveSequence = 0;\n          }\n        }\n        tree.push(vm);\n        vm = vm.$parent;\n      }\n      return '\\n\\nfound in\\n\\n' + tree.map(function (vm, i) {\n        return '' + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm) ? formatComponentName(vm[0]) + '... (' + vm[1] + ' recursive calls)' : formatComponentName(vm));\n      }).join('\\n');\n    } else {\n      return '\\n\\n(found in ' + formatComponentName(vm) + ')';\n    }\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/core/util/debug.js?");

/***/ }),

/***/ "./src/core/util/env.js":
/*!******************************!*\
  !*** ./src/core/util/env.js ***!
  \******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("/* WEBPACK VAR INJECTION */(function(global) {\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nexports.isNative = isNative;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n// can we use __proto__?\nvar hasProto = exports.hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = exports.inBrowser = typeof window !== 'undefined';\nvar inWeex = exports.inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;\nvar weexPlatform = exports.weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();\nvar UA = exports.UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = exports.isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = exports.isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = exports.isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = exports.isAndroid = UA && UA.indexOf('android') > 0 || weexPlatform === 'android';\nvar isIOS = exports.isIOS = UA && /iphone|ipad|ipod|ios/.test(UA) || weexPlatform === 'ios';\nvar isChrome = exports.isChrome = UA && /chrome\\/\\d+/.test(UA) && !isEdge;\n\n// Firefox has a \"watch\" function on Object.prototype...\nvar nativeWatch = exports.nativeWatch = {}.watch;\n\nvar supportsPassive = exports.supportsPassive = false;\nif (inBrowser) {\n  try {\n    var opts = {};\n    Object.defineProperty(opts, 'passive', {\n      get: function get() {\n        /* istanbul ignore next */\n        exports.supportsPassive = supportsPassive = true;\n      }\n    }); // https://github.com/facebook/flow/issues/285\n    window.addEventListener('test-passive', null, opts);\n  } catch (e) {}\n}\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _isServer = void 0;\nvar isServerRendering = exports.isServerRendering = function isServerRendering() {\n  if (_isServer === undefined) {\n    /* istanbul ignore if */\n    if (!inBrowser && !inWeex && typeof global !== 'undefined') {\n      // detect presence of vue-server-renderer and avoid\n      // Webpack shimming the process\n      _isServer = global['process'].env.VUE_ENV === 'server';\n    } else {\n      _isServer = false;\n    }\n  }\n  return _isServer;\n};\n\n// detect devtools\nvar devtools = exports.devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative(Ctor) {\n  return typeof Ctor === 'function' && /native code/.test(Ctor.toString());\n}\n\nvar hasSymbol = exports.hasSymbol = typeof Symbol !== 'undefined' && isNative(Symbol) && typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);\n\nvar _Set = void 0;\n/* istanbul ignore if */ // $flow-disable-line\nif (typeof Set !== 'undefined' && isNative(Set)) {\n  // use native Set when available.\n  exports._Set = _Set = Set;\n} else {\n  // a non-standard Set polyfill that only works with primitive keys.\n  exports._Set = _Set = function () {\n    function Set() {\n      _classCallCheck(this, Set);\n\n      this.set = Object.create(null);\n    }\n\n    _createClass(Set, [{\n      key: 'has',\n      value: function has(key) {\n        return this.set[key] === true;\n      }\n    }, {\n      key: 'add',\n      value: function add(key) {\n        this.set[key] = true;\n      }\n    }, {\n      key: 'clear',\n      value: function clear() {\n        this.set = Object.create(null);\n      }\n    }]);\n\n    return Set;\n  }();\n}\n\nexports._Set = _Set;\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../../../../usr/share/nodejs/webpack/buildin/global.js */ \"../../../usr/share/nodejs/webpack/buildin/global.js\")))\n\n//# sourceURL=webpack://Vue/./src/core/util/env.js?");

/***/ }),

/***/ "./src/core/util/error.js":
/*!********************************!*\
  !*** ./src/core/util/error.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.handleError = handleError;\n\nvar _config = __webpack_require__(/*! ../config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _debug = __webpack_require__(/*! ./debug */ \"./src/core/util/debug.js\");\n\nvar _env = __webpack_require__(/*! ./env */ \"./src/core/util/env.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction handleError(err, vm, info) {\n  if (vm) {\n    var cur = vm;\n    while (cur = cur.$parent) {\n      var hooks = cur.$options.errorCaptured;\n      if (hooks) {\n        for (var i = 0; i < hooks.length; i++) {\n          try {\n            var capture = hooks[i].call(cur, err, vm, info) === false;\n            if (capture) return;\n          } catch (e) {\n            globalHandleError(e, cur, 'errorCaptured hook');\n          }\n        }\n      }\n    }\n  }\n  globalHandleError(err, vm, info);\n}\n\nfunction globalHandleError(err, vm, info) {\n  if (_config2.default.errorHandler) {\n    try {\n      return _config2.default.errorHandler.call(null, err, vm, info);\n    } catch (e) {\n      logError(e, null, 'config.errorHandler');\n    }\n  }\n  logError(err, vm, info);\n}\n\nfunction logError(err, vm, info) {\n  if (true) {\n    (0, _debug.warn)('Error in ' + info + ': \"' + err.toString() + '\"', vm);\n  }\n  /* istanbul ignore else */\n  if ((_env.inBrowser || _env.inWeex) && typeof console !== 'undefined') {\n    console.error(err);\n  } else {\n    throw err;\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/util/error.js?");

/***/ }),

/***/ "./src/core/util/index.js":
/*!********************************!*\
  !*** ./src/core/util/index.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nObject.keys(_util).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _util[key];\n    }\n  });\n});\n\nvar _lang = __webpack_require__(/*! ./lang */ \"./src/core/util/lang.js\");\n\nObject.keys(_lang).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _lang[key];\n    }\n  });\n});\n\nvar _env = __webpack_require__(/*! ./env */ \"./src/core/util/env.js\");\n\nObject.keys(_env).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _env[key];\n    }\n  });\n});\n\nvar _options = __webpack_require__(/*! ./options */ \"./src/core/util/options.js\");\n\nObject.keys(_options).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _options[key];\n    }\n  });\n});\n\nvar _debug = __webpack_require__(/*! ./debug */ \"./src/core/util/debug.js\");\n\nObject.keys(_debug).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _debug[key];\n    }\n  });\n});\n\nvar _props = __webpack_require__(/*! ./props */ \"./src/core/util/props.js\");\n\nObject.keys(_props).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _props[key];\n    }\n  });\n});\n\nvar _error = __webpack_require__(/*! ./error */ \"./src/core/util/error.js\");\n\nObject.keys(_error).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _error[key];\n    }\n  });\n});\n\nvar _nextTick = __webpack_require__(/*! ./next-tick */ \"./src/core/util/next-tick.js\");\n\nObject.keys(_nextTick).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _nextTick[key];\n    }\n  });\n});\n\nvar _index = __webpack_require__(/*! ../observer/index */ \"./src/core/observer/index.js\");\n\nObject.defineProperty(exports, 'defineReactive', {\n  enumerable: true,\n  get: function get() {\n    return _index.defineReactive;\n  }\n});\n\n//# sourceURL=webpack://Vue/./src/core/util/index.js?");

/***/ }),

/***/ "./src/core/util/lang.js":
/*!*******************************!*\
  !*** ./src/core/util/lang.js ***!
  \*******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isReserved = isReserved;\nexports.def = def;\nexports.parsePath = parsePath;\n\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved(str) {\n  var c = (str + '').charCodeAt(0);\n  return c === 0x24 || c === 0x5F;\n}\n\n/**\n * Define a property.\n */\nfunction def(obj, key, val, enumerable) {\n  Object.defineProperty(obj, key, {\n    value: val,\n    enumerable: !!enumerable,\n    writable: true,\n    configurable: true\n  });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = /[^\\w.$]/;\nfunction parsePath(path) {\n  if (bailRE.test(path)) {\n    return;\n  }\n  var segments = path.split('.');\n  return function (obj) {\n    for (var i = 0; i < segments.length; i++) {\n      if (!obj) return;\n      obj = obj[segments[i]];\n    }\n    return obj;\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/core/util/lang.js?");

/***/ }),

/***/ "./src/core/util/next-tick.js":
/*!************************************!*\
  !*** ./src/core/util/next-tick.js ***!
  \************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("/* WEBPACK VAR INJECTION */(function(setImmediate) {\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.withMacroTask = withMacroTask;\nexports.nextTick = nextTick;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _error = __webpack_require__(/*! ./error */ \"./src/core/util/error.js\");\n\nvar _env = __webpack_require__(/*! ./env */ \"./src/core/util/env.js\");\n\nvar callbacks = [];\n/* globals MessageChannel */\n\nvar pending = false;\n\nfunction flushCallbacks() {\n  pending = false;\n  var copies = callbacks.slice(0);\n  callbacks.length = 0;\n  for (var i = 0; i < copies.length; i++) {\n    copies[i]();\n  }\n}\n\n// Here we have async deferring wrappers using both microtasks and (macro) tasks.\n// In < 2.4 we used microtasks everywhere, but there are some scenarios where\n// microtasks have too high a priority and fire in between supposedly\n// sequential events (e.g. #4521, #6690) or even between bubbling of the same\n// event (#6566). However, using (macro) tasks everywhere also has subtle problems\n// when state is changed right before repaint (e.g. #6813, out-in transitions).\n// Here we use microtask by default, but expose a way to force (macro) task when\n// needed (e.g. in event handlers attached by v-on).\nvar microTimerFunc = void 0;\nvar macroTimerFunc = void 0;\nvar useMacroTask = false;\n\n// Determine (macro) task defer implementation.\n// Technically setImmediate should be the ideal choice, but it's only available\n// in IE. The only polyfill that consistently queues the callback after all DOM\n// events triggered in the same loop is by using MessageChannel.\n/* istanbul ignore if */\nif (typeof setImmediate !== 'undefined' && (0, _env.isNative)(setImmediate)) {\n  macroTimerFunc = function macroTimerFunc() {\n    setImmediate(flushCallbacks);\n  };\n} else if (typeof MessageChannel !== 'undefined' && ((0, _env.isNative)(MessageChannel) ||\n// PhantomJS\nMessageChannel.toString() === '[object MessageChannelConstructor]')) {\n  var channel = new MessageChannel();\n  var port = channel.port2;\n  channel.port1.onmessage = flushCallbacks;\n  macroTimerFunc = function macroTimerFunc() {\n    port.postMessage(1);\n  };\n} else {\n  /* istanbul ignore next */\n  macroTimerFunc = function macroTimerFunc() {\n    setTimeout(flushCallbacks, 0);\n  };\n}\n\n// Determine microtask defer implementation.\n/* istanbul ignore next, $flow-disable-line */\nif (typeof Promise !== 'undefined' && (0, _env.isNative)(Promise)) {\n  var p = Promise.resolve();\n  microTimerFunc = function microTimerFunc() {\n    p.then(flushCallbacks);\n    // in problematic UIWebViews, Promise.then doesn't completely break, but\n    // it can get stuck in a weird state where callbacks are pushed into the\n    // microtask queue but the queue isn't being flushed, until the browser\n    // needs to do some other work, e.g. handle a timer. Therefore we can\n    // \"force\" the microtask queue to be flushed by adding an empty timer.\n    if (_env.isIOS) setTimeout(_util.noop);\n  };\n} else {\n  // fallback to macro\n  microTimerFunc = macroTimerFunc;\n}\n\n/**\n * Wrap a function so that if any code inside triggers state change,\n * the changes are queued using a (macro) task instead of a microtask.\n */\nfunction withMacroTask(fn) {\n  return fn._withTask || (fn._withTask = function () {\n    useMacroTask = true;\n    var res = fn.apply(null, arguments);\n    useMacroTask = false;\n    return res;\n  });\n}\n\nfunction nextTick(cb, ctx) {\n  var _resolve = void 0;\n  callbacks.push(function () {\n    if (cb) {\n      try {\n        cb.call(ctx);\n      } catch (e) {\n        (0, _error.handleError)(e, ctx, 'nextTick');\n      }\n    } else if (_resolve) {\n      _resolve(ctx);\n    }\n  });\n  if (!pending) {\n    pending = true;\n    if (useMacroTask) {\n      macroTimerFunc();\n    } else {\n      microTimerFunc();\n    }\n  }\n  // $flow-disable-line\n  if (!cb && typeof Promise !== 'undefined') {\n    return new Promise(function (resolve) {\n      _resolve = resolve;\n    });\n  }\n}\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../../../../usr/lib/nodejs/timers-browserify/main.js */ \"../../../usr/lib/nodejs/timers-browserify/main.js\").setImmediate))\n\n//# sourceURL=webpack://Vue/./src/core/util/next-tick.js?");

/***/ }),

/***/ "./src/core/util/options.js":
/*!**********************************!*\
  !*** ./src/core/util/options.js ***!
  \**********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.mergeDataOrFn = mergeDataOrFn;\nexports.validateComponentName = validateComponentName;\nexports.mergeOptions = mergeOptions;\nexports.resolveAsset = resolveAsset;\n\nvar _config = __webpack_require__(/*! ../config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _debug = __webpack_require__(/*! ./debug */ \"./src/core/util/debug.js\");\n\nvar _env = __webpack_require__(/*! ./env */ \"./src/core/util/env.js\");\n\nvar _index = __webpack_require__(/*! ../observer/index */ \"./src/core/observer/index.js\");\n\nvar _constants = __webpack_require__(/*! shared/constants */ \"./src/shared/constants.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = _config2.default.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (true) {\n  strats.el = strats.propsData = function (parent, child, vm, key) {\n    if (!vm) {\n      (0, _debug.warn)('option \"' + key + '\" can only be used during instance ' + 'creation with the `new` keyword.');\n    }\n    return defaultStrat(parent, child);\n  };\n}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData(to, from) {\n  if (!from) return to;\n  var key = void 0,\n      toVal = void 0,\n      fromVal = void 0;\n  var keys = Object.keys(from);\n  for (var i = 0; i < keys.length; i++) {\n    key = keys[i];\n    toVal = to[key];\n    fromVal = from[key];\n    if (!(0, _util.hasOwn)(to, key)) {\n      (0, _index.set)(to, key, fromVal);\n    } else if ((0, _util.isPlainObject)(toVal) && (0, _util.isPlainObject)(fromVal)) {\n      mergeData(toVal, fromVal);\n    }\n  }\n  return to;\n}\n\n/**\n * Data\n */\nfunction mergeDataOrFn(parentVal, childVal, vm) {\n  if (!vm) {\n    // in a Vue.extend merge, both should be functions\n    if (!childVal) {\n      return parentVal;\n    }\n    if (!parentVal) {\n      return childVal;\n    }\n    // when parentVal & childVal are both present,\n    // we need to return a function that returns the\n    // merged result of both functions... no need to\n    // check if parentVal is a function here because\n    // it has to be a function to pass previous merges.\n    return function mergedDataFn() {\n      return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);\n    };\n  } else {\n    return function mergedInstanceDataFn() {\n      // instance merge\n      var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;\n      var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;\n      if (instanceData) {\n        return mergeData(instanceData, defaultData);\n      } else {\n        return defaultData;\n      }\n    };\n  }\n}\n\nstrats.data = function (parentVal, childVal, vm) {\n  if (!vm) {\n    if (childVal && typeof childVal !== 'function') {\n      \"development\" !== 'production' && (0, _debug.warn)('The \"data\" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm);\n\n      return parentVal;\n    }\n    return mergeDataOrFn(parentVal, childVal);\n  }\n\n  return mergeDataOrFn(parentVal, childVal, vm);\n};\n\n/**\n * Hooks and props are merged as arrays.\n */\nfunction mergeHook(parentVal, childVal) {\n  return childVal ? parentVal ? parentVal.concat(childVal) : Array.isArray(childVal) ? childVal : [childVal] : parentVal;\n}\n\n_constants.LIFECYCLE_HOOKS.forEach(function (hook) {\n  strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets(parentVal, childVal, vm, key) {\n  var res = Object.create(parentVal || null);\n  if (childVal) {\n    \"development\" !== 'production' && assertObjectType(key, childVal, vm);\n    return (0, _util.extend)(res, childVal);\n  } else {\n    return res;\n  }\n}\n\n_constants.ASSET_TYPES.forEach(function (type) {\n  strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (parentVal, childVal, vm, key) {\n  // work around Firefox's Object.prototype.watch...\n  if (parentVal === _env.nativeWatch) parentVal = undefined;\n  if (childVal === _env.nativeWatch) childVal = undefined;\n  /* istanbul ignore if */\n  if (!childVal) return Object.create(parentVal || null);\n  if (true) {\n    assertObjectType(key, childVal, vm);\n  }\n  if (!parentVal) return childVal;\n  var ret = {};\n  (0, _util.extend)(ret, parentVal);\n  for (var _key in childVal) {\n    var parent = ret[_key];\n    var child = childVal[_key];\n    if (parent && !Array.isArray(parent)) {\n      parent = [parent];\n    }\n    ret[_key] = parent ? parent.concat(child) : Array.isArray(child) ? child : [child];\n  }\n  return ret;\n};\n\n/**\n * Other object hashes.\n */\nstrats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {\n  if (childVal && \"development\" !== 'production') {\n    assertObjectType(key, childVal, vm);\n  }\n  if (!parentVal) return childVal;\n  var ret = Object.create(null);\n  (0, _util.extend)(ret, parentVal);\n  if (childVal) (0, _util.extend)(ret, childVal);\n  return ret;\n};\nstrats.provide = mergeDataOrFn;\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function defaultStrat(parentVal, childVal) {\n  return childVal === undefined ? parentVal : childVal;\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents(options) {\n  for (var key in options.components) {\n    validateComponentName(key);\n  }\n}\n\nfunction validateComponentName(name) {\n  if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n    (0, _debug.warn)('Invalid component name: \"' + name + '\". Component names ' + 'can only contain alphanumeric characters and the hyphen, ' + 'and must start with a letter.');\n  }\n  if ((0, _util.isBuiltInTag)(name) || _config2.default.isReservedTag(name)) {\n    (0, _debug.warn)('Do not use built-in or reserved HTML elements as component ' + 'id: ' + name);\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps(options, vm) {\n  var props = options.props;\n  if (!props) return;\n  var res = {};\n  var i = void 0,\n      val = void 0,\n      name = void 0;\n  if (Array.isArray(props)) {\n    i = props.length;\n    while (i--) {\n      val = props[i];\n      if (typeof val === 'string') {\n        name = (0, _util.camelize)(val);\n        res[name] = { type: null };\n      } else if (true) {\n        (0, _debug.warn)('props must be strings when using array syntax.');\n      }\n    }\n  } else if ((0, _util.isPlainObject)(props)) {\n    for (var key in props) {\n      val = props[key];\n      name = (0, _util.camelize)(key);\n      res[name] = (0, _util.isPlainObject)(val) ? val : { type: val };\n    }\n  } else if (true) {\n    (0, _debug.warn)('Invalid value for option \"props\": expected an Array or an Object, ' + ('but got ' + (0, _util.toRawType)(props) + '.'), vm);\n  }\n  options.props = res;\n}\n\n/**\n * Normalize all injections into Object-based format\n */\nfunction normalizeInject(options, vm) {\n  var inject = options.inject;\n  if (!inject) return;\n  var normalized = options.inject = {};\n  if (Array.isArray(inject)) {\n    for (var i = 0; i < inject.length; i++) {\n      normalized[inject[i]] = { from: inject[i] };\n    }\n  } else if ((0, _util.isPlainObject)(inject)) {\n    for (var key in inject) {\n      var val = inject[key];\n      normalized[key] = (0, _util.isPlainObject)(val) ? (0, _util.extend)({ from: key }, val) : { from: val };\n    }\n  } else if (true) {\n    (0, _debug.warn)('Invalid value for option \"inject\": expected an Array or an Object, ' + ('but got ' + (0, _util.toRawType)(inject) + '.'), vm);\n  }\n}\n\n/**\n * Normalize raw function directives into object format.\n */\nfunction normalizeDirectives(options) {\n  var dirs = options.directives;\n  if (dirs) {\n    for (var key in dirs) {\n      var def = dirs[key];\n      if (typeof def === 'function') {\n        dirs[key] = { bind: def, update: def };\n      }\n    }\n  }\n}\n\nfunction assertObjectType(name, value, vm) {\n  if (!(0, _util.isPlainObject)(value)) {\n    (0, _debug.warn)('Invalid value for option \"' + name + '\": expected an Object, ' + ('but got ' + (0, _util.toRawType)(value) + '.'), vm);\n  }\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n */\nfunction mergeOptions(parent, child, vm) {\n  if (true) {\n    checkComponents(child);\n  }\n\n  if (typeof child === 'function') {\n    child = child.options;\n  }\n\n  normalizeProps(child, vm);\n  normalizeInject(child, vm);\n  normalizeDirectives(child);\n  var extendsFrom = child.extends;\n  if (extendsFrom) {\n    parent = mergeOptions(parent, extendsFrom, vm);\n  }\n  if (child.mixins) {\n    for (var i = 0, l = child.mixins.length; i < l; i++) {\n      parent = mergeOptions(parent, child.mixins[i], vm);\n    }\n  }\n  var options = {};\n  var key = void 0;\n  for (key in parent) {\n    mergeField(key);\n  }\n  for (key in child) {\n    if (!(0, _util.hasOwn)(parent, key)) {\n      mergeField(key);\n    }\n  }\n  function mergeField(key) {\n    var strat = strats[key] || defaultStrat;\n    options[key] = strat(parent[key], child[key], vm, key);\n  }\n  return options;\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset(options, type, id, warnMissing) {\n  /* istanbul ignore if */\n  if (typeof id !== 'string') {\n    return;\n  }\n  var assets = options[type];\n  // check local registration variations first\n  if ((0, _util.hasOwn)(assets, id)) return assets[id];\n  var camelizedId = (0, _util.camelize)(id);\n  if ((0, _util.hasOwn)(assets, camelizedId)) return assets[camelizedId];\n  var PascalCaseId = (0, _util.capitalize)(camelizedId);\n  if ((0, _util.hasOwn)(assets, PascalCaseId)) return assets[PascalCaseId];\n  // fallback to prototype chain\n  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n  if (\"development\" !== 'production' && warnMissing && !res) {\n    (0, _debug.warn)('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);\n  }\n  return res;\n}\n\n//# sourceURL=webpack://Vue/./src/core/util/options.js?");

/***/ }),

/***/ "./src/core/util/perf.js":
/*!*******************************!*\
  !*** ./src/core/util/perf.js ***!
  \*******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.measure = exports.mark = undefined;\n\nvar _env = __webpack_require__(/*! ./env */ \"./src/core/util/env.js\");\n\nvar mark = exports.mark = void 0;\nvar measure = exports.measure = void 0;\n\nif (true) {\n  var perf = _env.inBrowser && window.performance;\n  /* istanbul ignore if */\n  if (perf && perf.mark && perf.measure && perf.clearMarks && perf.clearMeasures) {\n    exports.mark = mark = function mark(tag) {\n      return perf.mark(tag);\n    };\n    exports.measure = measure = function measure(name, startTag, endTag) {\n      perf.measure(name, startTag, endTag);\n      perf.clearMarks(startTag);\n      perf.clearMarks(endTag);\n      perf.clearMeasures(name);\n    };\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/util/perf.js?");

/***/ }),

/***/ "./src/core/util/props.js":
/*!********************************!*\
  !*** ./src/core/util/props.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.validateProp = validateProp;\n\nvar _debug = __webpack_require__(/*! ./debug */ \"./src/core/util/debug.js\");\n\nvar _index = __webpack_require__(/*! ../observer/index */ \"./src/core/observer/index.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nfunction validateProp(key, propOptions, propsData, vm) {\n  var prop = propOptions[key];\n  var absent = !(0, _util.hasOwn)(propsData, key);\n  var value = propsData[key];\n  // boolean casting\n  var booleanIndex = getTypeIndex(Boolean, prop.type);\n  if (booleanIndex > -1) {\n    if (absent && !(0, _util.hasOwn)(prop, 'default')) {\n      value = false;\n    } else if (value === '' || value === (0, _util.hyphenate)(key)) {\n      // only cast empty string / same name to boolean if\n      // boolean has higher priority\n      var stringIndex = getTypeIndex(String, prop.type);\n      if (stringIndex < 0 || booleanIndex < stringIndex) {\n        value = true;\n      }\n    }\n  }\n  // check default value\n  if (value === undefined) {\n    value = getPropDefaultValue(vm, prop, key);\n    // since the default value is a fresh copy,\n    // make sure to observe it.\n    var prevShouldObserve = _index.shouldObserve;\n    (0, _index.toggleObserving)(true);\n    (0, _index.observe)(value);\n    (0, _index.toggleObserving)(prevShouldObserve);\n  }\n  var __WEEX__ = false;\n  if (\"development\" !== 'production' &&\n  // skip validation for weex recycle-list child component props\n  !(__WEEX__ && (0, _util.isObject)(value) && '@binding' in value)) {\n    assertProp(prop, key, value, vm, absent);\n  }\n  return value;\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue(vm, prop, key) {\n  // no default, return undefined\n  if (!(0, _util.hasOwn)(prop, 'default')) {\n    return undefined;\n  }\n  var def = prop.default;\n  // warn against non-factory defaults for Object & Array\n  if (\"development\" !== 'production' && (0, _util.isObject)(def)) {\n    (0, _debug.warn)('Invalid default value for prop \"' + key + '\": ' + 'Props with type Object/Array must use a factory function ' + 'to return the default value.', vm);\n  }\n  // the raw prop value was also undefined from previous render,\n  // return previous default value to avoid unnecessary watcher trigger\n  if (vm && vm.$options.propsData && vm.$options.propsData[key] === undefined && vm._props[key] !== undefined) {\n    return vm._props[key];\n  }\n  // call factory function for non-Function types\n  // a value is Function if its prototype is function even across different execution context\n  return typeof def === 'function' && getType(prop.type) !== 'Function' ? def.call(vm) : def;\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp(prop, name, value, vm, absent) {\n  if (prop.required && absent) {\n    (0, _debug.warn)('Missing required prop: \"' + name + '\"', vm);\n    return;\n  }\n  if (value == null && !prop.required) {\n    return;\n  }\n  var type = prop.type;\n  var valid = !type || type === true;\n  var expectedTypes = [];\n  if (type) {\n    if (!Array.isArray(type)) {\n      type = [type];\n    }\n    for (var i = 0; i < type.length && !valid; i++) {\n      var assertedType = assertType(value, type[i]);\n      expectedTypes.push(assertedType.expectedType || '');\n      valid = assertedType.valid;\n    }\n  }\n  if (!valid) {\n    (0, _debug.warn)('Invalid prop: type check failed for prop \"' + name + '\".' + (' Expected ' + expectedTypes.map(_util.capitalize).join(', ')) + (', got ' + (0, _util.toRawType)(value) + '.'), vm);\n    return;\n  }\n  var validator = prop.validator;\n  if (validator) {\n    if (!validator(value)) {\n      (0, _debug.warn)('Invalid prop: custom validator check failed for prop \"' + name + '\".', vm);\n    }\n  }\n}\n\nvar simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;\n\nfunction assertType(value, type) {\n  var valid = void 0;\n  var expectedType = getType(type);\n  if (simpleCheckRE.test(expectedType)) {\n    var t = typeof value === 'undefined' ? 'undefined' : _typeof(value);\n    valid = t === expectedType.toLowerCase();\n    // for primitive wrapper objects\n    if (!valid && t === 'object') {\n      valid = value instanceof type;\n    }\n  } else if (expectedType === 'Object') {\n    valid = (0, _util.isPlainObject)(value);\n  } else if (expectedType === 'Array') {\n    valid = Array.isArray(value);\n  } else {\n    valid = value instanceof type;\n  }\n  return {\n    valid: valid,\n    expectedType: expectedType\n  };\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType(fn) {\n  var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n  return match ? match[1] : '';\n}\n\nfunction isSameType(a, b) {\n  return getType(a) === getType(b);\n}\n\nfunction getTypeIndex(type, expectedTypes) {\n  if (!Array.isArray(expectedTypes)) {\n    return isSameType(expectedTypes, type) ? 0 : -1;\n  }\n  for (var i = 0, len = expectedTypes.length; i < len; i++) {\n    if (isSameType(expectedTypes[i], type)) {\n      return i;\n    }\n  }\n  return -1;\n}\n\n//# sourceURL=webpack://Vue/./src/core/util/props.js?");

/***/ }),

/***/ "./src/core/vdom/create-component.js":
/*!*******************************************!*\
  !*** ./src/core/vdom/create-component.js ***!
  \*******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createComponent = createComponent;\nexports.createComponentInstanceForVnode = createComponentInstanceForVnode;\n\nvar _vnode = __webpack_require__(/*! ./vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _vnode2 = _interopRequireDefault(_vnode);\n\nvar _init = __webpack_require__(/*! core/instance/init */ \"./src/core/instance/init.js\");\n\nvar _scheduler = __webpack_require__(/*! core/observer/scheduler */ \"./src/core/observer/scheduler.js\");\n\nvar _createFunctionalComponent = __webpack_require__(/*! ./create-functional-component */ \"./src/core/vdom/create-functional-component.js\");\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nvar _index2 = __webpack_require__(/*! ./helpers/index */ \"./src/core/vdom/helpers/index.js\");\n\nvar _lifecycle = __webpack_require__(/*! ../instance/lifecycle */ \"./src/core/instance/lifecycle.js\");\n\nvar _renderComponentTemplate = __webpack_require__(/*! weex/runtime/recycle-list/render-component-template */ \"./src/platforms/weex/runtime/recycle-list/render-component-template.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// inline hooks to be invoked on component VNodes during patch\nvar componentVNodeHooks = {\n  init: function init(vnode, hydrating, parentElm, refElm) {\n    if (vnode.componentInstance && !vnode.componentInstance._isDestroyed && vnode.data.keepAlive) {\n      // kept-alive components, treat as a patch\n      var mountedNode = vnode; // work around flow\n      componentVNodeHooks.prepatch(mountedNode, mountedNode);\n    } else {\n      var child = vnode.componentInstance = createComponentInstanceForVnode(vnode, _lifecycle.activeInstance, parentElm, refElm);\n      child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n    }\n  },\n  prepatch: function prepatch(oldVnode, vnode) {\n    var options = vnode.componentOptions;\n    var child = vnode.componentInstance = oldVnode.componentInstance;\n    (0, _lifecycle.updateChildComponent)(child, options.propsData, // updated props\n    options.listeners, // updated listeners\n    vnode, // new parent vnode\n    options.children // new children\n    );\n  },\n  insert: function insert(vnode) {\n    var context = vnode.context,\n        componentInstance = vnode.componentInstance;\n\n    if (!componentInstance._isMounted) {\n      componentInstance._isMounted = true;\n      (0, _lifecycle.callHook)(componentInstance, 'mounted');\n    }\n    if (vnode.data.keepAlive) {\n      if (context._isMounted) {\n        // vue-router#1212\n        // During updates, a kept-alive component's child components may\n        // change, so directly walking the tree here may call activated hooks\n        // on incorrect children. Instead we push them into a queue which will\n        // be processed after the whole patch process ended.\n        (0, _scheduler.queueActivatedComponent)(componentInstance);\n      } else {\n        (0, _lifecycle.activateChildComponent)(componentInstance, true /* direct */);\n      }\n    }\n  },\n  destroy: function destroy(vnode) {\n    var componentInstance = vnode.componentInstance;\n\n    if (!componentInstance._isDestroyed) {\n      if (!vnode.data.keepAlive) {\n        componentInstance.$destroy();\n      } else {\n        (0, _lifecycle.deactivateChildComponent)(componentInstance, true /* direct */);\n      }\n    }\n  }\n};\n\nvar hooksToMerge = Object.keys(componentVNodeHooks);\n\nfunction createComponent(Ctor, data, context, children, tag) {\n  if ((0, _index.isUndef)(Ctor)) {\n    return;\n  }\n\n  var baseCtor = context.$options._base;\n\n  // plain options object: turn it into a constructor\n  if ((0, _index.isObject)(Ctor)) {\n    Ctor = baseCtor.extend(Ctor);\n  }\n\n  // if at this stage it's not a constructor or an async component factory,\n  // reject.\n  if (typeof Ctor !== 'function') {\n    if (true) {\n      (0, _index.warn)('Invalid Component definition: ' + String(Ctor), context);\n    }\n    return;\n  }\n\n  // async component\n  var asyncFactory = void 0;\n  if ((0, _index.isUndef)(Ctor.cid)) {\n    asyncFactory = Ctor;\n    Ctor = (0, _index2.resolveAsyncComponent)(asyncFactory, baseCtor, context);\n    if (Ctor === undefined) {\n      // return a placeholder node for async component, which is rendered\n      // as a comment node but preserves all the raw information for the node.\n      // the information will be used for async server-rendering and hydration.\n      return (0, _index2.createAsyncPlaceholder)(asyncFactory, data, context, children, tag);\n    }\n  }\n\n  data = data || {};\n\n  // resolve constructor options in case global mixins are applied after\n  // component constructor creation\n  (0, _init.resolveConstructorOptions)(Ctor);\n\n  // transform component v-model data into props & events\n  if ((0, _index.isDef)(data.model)) {\n    transformModel(Ctor.options, data);\n  }\n\n  // extract props\n  var propsData = (0, _index2.extractPropsFromVNodeData)(data, Ctor, tag);\n\n  // functional component\n  if ((0, _index.isTrue)(Ctor.options.functional)) {\n    return (0, _createFunctionalComponent.createFunctionalComponent)(Ctor, propsData, data, context, children);\n  }\n\n  // extract listeners, since these needs to be treated as\n  // child component listeners instead of DOM listeners\n  var listeners = data.on;\n  // replace with listeners with .native modifier\n  // so it gets processed during parent component patch.\n  data.on = data.nativeOn;\n\n  if ((0, _index.isTrue)(Ctor.options.abstract)) {\n    // abstract components do not keep anything\n    // other than props & listeners & slot\n\n    // work around flow\n    var slot = data.slot;\n    data = {};\n    if (slot) {\n      data.slot = slot;\n    }\n  }\n\n  // install component management hooks onto the placeholder node\n  installComponentHooks(data);\n\n  // return a placeholder vnode\n  var name = Ctor.options.name || tag;\n  var vnode = new _vnode2.default('vue-component-' + Ctor.cid + (name ? '-' + name : ''), data, undefined, undefined, undefined, context, { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);\n\n  // Weex specific: invoke recycle-list optimized @render function for\n  // extracting cell-slot template.\n  // https://github.com/Hanks10100/weex-native-directive/tree/master/component\n  /* istanbul ignore if */\n  var __WEEX__ = false;\n  if (__WEEX__ && (0, _renderComponentTemplate.isRecyclableComponent)(vnode)) {\n    return (0, _renderComponentTemplate.renderRecyclableComponentTemplate)(vnode);\n  }\n\n  return vnode;\n}\n\nfunction createComponentInstanceForVnode(vnode, // we know it's MountedComponentVNode but flow doesn't\nparent, // activeInstance in lifecycle state\nparentElm, refElm) {\n  var options = {\n    _isComponent: true,\n    parent: parent,\n    _parentVnode: vnode,\n    _parentElm: parentElm || null,\n    _refElm: refElm || null\n    // check inline-template render functions\n  };var inlineTemplate = vnode.data.inlineTemplate;\n  if ((0, _index.isDef)(inlineTemplate)) {\n    options.render = inlineTemplate.render;\n    options.staticRenderFns = inlineTemplate.staticRenderFns;\n  }\n  return new vnode.componentOptions.Ctor(options);\n}\n\nfunction installComponentHooks(data) {\n  var hooks = data.hook || (data.hook = {});\n  for (var i = 0; i < hooksToMerge.length; i++) {\n    var key = hooksToMerge[i];\n    hooks[key] = componentVNodeHooks[key];\n  }\n}\n\n// transform component v-model info (value and callback) into\n// prop and event handler respectively.\nfunction transformModel(options, data) {\n  var prop = options.model && options.model.prop || 'value';\n  var event = options.model && options.model.event || 'input';(data.props || (data.props = {}))[prop] = data.model.value;\n  var on = data.on || (data.on = {});\n  if ((0, _index.isDef)(on[event])) {\n    on[event] = [data.model.callback].concat(on[event]);\n  } else {\n    on[event] = data.model.callback;\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/create-component.js?");

/***/ }),

/***/ "./src/core/vdom/create-element.js":
/*!*****************************************!*\
  !*** ./src/core/vdom/create-element.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createElement = createElement;\nexports._createElement = _createElement;\n\nvar _config = __webpack_require__(/*! ../config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _vnode = __webpack_require__(/*! ./vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _vnode2 = _interopRequireDefault(_vnode);\n\nvar _createComponent = __webpack_require__(/*! ./create-component */ \"./src/core/vdom/create-component.js\");\n\nvar _traverse = __webpack_require__(/*! ../observer/traverse */ \"./src/core/observer/traverse.js\");\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nvar _index2 = __webpack_require__(/*! ./helpers/index */ \"./src/core/vdom/helpers/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement(context, tag, data, children, normalizationType, alwaysNormalize) {\n  if (Array.isArray(data) || (0, _index.isPrimitive)(data)) {\n    normalizationType = children;\n    children = data;\n    data = undefined;\n  }\n  if ((0, _index.isTrue)(alwaysNormalize)) {\n    normalizationType = ALWAYS_NORMALIZE;\n  }\n  return _createElement(context, tag, data, children, normalizationType);\n}\n\nfunction _createElement(context, tag, data, children, normalizationType) {\n  if ((0, _index.isDef)(data) && (0, _index.isDef)(data.__ob__)) {\n    \"development\" !== 'production' && (0, _index.warn)('Avoid using observed data object as vnode data: ' + JSON.stringify(data) + '\\n' + 'Always create fresh vnode data objects in each render!', context);\n    return (0, _vnode.createEmptyVNode)();\n  }\n  // object syntax in v-bind\n  if ((0, _index.isDef)(data) && (0, _index.isDef)(data.is)) {\n    tag = data.is;\n  }\n  if (!tag) {\n    // in case of component :is set to falsy value\n    return (0, _vnode.createEmptyVNode)();\n  }\n  // warn against non-primitive key\n  if (\"development\" !== 'production' && (0, _index.isDef)(data) && (0, _index.isDef)(data.key) && !(0, _index.isPrimitive)(data.key)) {\n    var __WEEX__ = false;\n    if (!__WEEX__ || !('@binding' in data.key)) {\n      (0, _index.warn)('Avoid using non-primitive value as key, ' + 'use string/number value instead.', context);\n    }\n  }\n  // support single function children as default scoped slot\n  if (Array.isArray(children) && typeof children[0] === 'function') {\n    data = data || {};\n    data.scopedSlots = { default: children[0] };\n    children.length = 0;\n  }\n  if (normalizationType === ALWAYS_NORMALIZE) {\n    children = (0, _index2.normalizeChildren)(children);\n  } else if (normalizationType === SIMPLE_NORMALIZE) {\n    children = (0, _index2.simpleNormalizeChildren)(children);\n  }\n  var vnode = void 0,\n      ns = void 0;\n  if (typeof tag === 'string') {\n    var Ctor = void 0;\n    ns = context.$vnode && context.$vnode.ns || _config2.default.getTagNamespace(tag);\n    if (_config2.default.isReservedTag(tag)) {\n      // platform built-in elements\n      vnode = new _vnode2.default(_config2.default.parsePlatformTagName(tag), data, children, undefined, undefined, context);\n    } else if ((0, _index.isDef)(Ctor = (0, _index.resolveAsset)(context.$options, 'components', tag))) {\n      // component\n      vnode = (0, _createComponent.createComponent)(Ctor, data, context, children, tag);\n    } else {\n      // unknown or unlisted namespaced elements\n      // check at runtime because it may get assigned a namespace when its\n      // parent normalizes children\n      vnode = new _vnode2.default(tag, data, children, undefined, undefined, context);\n    }\n  } else {\n    // direct component options / constructor\n    vnode = (0, _createComponent.createComponent)(tag, data, context, children);\n  }\n  if (Array.isArray(vnode)) {\n    return vnode;\n  } else if ((0, _index.isDef)(vnode)) {\n    if ((0, _index.isDef)(ns)) applyNS(vnode, ns);\n    if ((0, _index.isDef)(data)) registerDeepBindings(data);\n    return vnode;\n  } else {\n    return (0, _vnode.createEmptyVNode)();\n  }\n}\n\nfunction applyNS(vnode, ns, force) {\n  vnode.ns = ns;\n  if (vnode.tag === 'foreignObject') {\n    // use default namespace inside foreignObject\n    ns = undefined;\n    force = true;\n  }\n  if ((0, _index.isDef)(vnode.children)) {\n    for (var i = 0, l = vnode.children.length; i < l; i++) {\n      var child = vnode.children[i];\n      if ((0, _index.isDef)(child.tag) && ((0, _index.isUndef)(child.ns) || (0, _index.isTrue)(force) && child.tag !== 'svg')) {\n        applyNS(child, ns, force);\n      }\n    }\n  }\n}\n\n// ref #5318\n// necessary to ensure parent re-render when deep bindings like :style and\n// :class are used on slot nodes\nfunction registerDeepBindings(data) {\n  if ((0, _index.isObject)(data.style)) {\n    (0, _traverse.traverse)(data.style);\n  }\n  if ((0, _index.isObject)(data.class)) {\n    (0, _traverse.traverse)(data.class);\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/create-element.js?");

/***/ }),

/***/ "./src/core/vdom/create-functional-component.js":
/*!******************************************************!*\
  !*** ./src/core/vdom/create-functional-component.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.FunctionalRenderContext = FunctionalRenderContext;\nexports.createFunctionalComponent = createFunctionalComponent;\n\nvar _vnode = __webpack_require__(/*! ./vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _vnode2 = _interopRequireDefault(_vnode);\n\nvar _createElement = __webpack_require__(/*! ./create-element */ \"./src/core/vdom/create-element.js\");\n\nvar _inject = __webpack_require__(/*! ../instance/inject */ \"./src/core/instance/inject.js\");\n\nvar _normalizeChildren = __webpack_require__(/*! ../vdom/helpers/normalize-children */ \"./src/core/vdom/helpers/normalize-children.js\");\n\nvar _resolveSlots = __webpack_require__(/*! ../instance/render-helpers/resolve-slots */ \"./src/core/instance/render-helpers/resolve-slots.js\");\n\nvar _index = __webpack_require__(/*! ../instance/render-helpers/index */ \"./src/core/instance/render-helpers/index.js\");\n\nvar _index2 = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction FunctionalRenderContext(data, props, children, parent, Ctor) {\n  var options = Ctor.options;\n  // ensure the createElement function in functional components\n  // gets a unique context - this is necessary for correct named slot check\n  var contextVm = void 0;\n  if ((0, _index2.hasOwn)(parent, '_uid')) {\n    contextVm = Object.create(parent);\n    // $flow-disable-line\n    contextVm._original = parent;\n  } else {\n    // the context vm passed in is a functional context as well.\n    // in this case we want to make sure we are able to get a hold to the\n    // real context instance.\n    contextVm = parent;\n    // $flow-disable-line\n    parent = parent._original;\n  }\n  var isCompiled = (0, _index2.isTrue)(options._compiled);\n  var needNormalization = !isCompiled;\n\n  this.data = data;\n  this.props = props;\n  this.children = children;\n  this.parent = parent;\n  this.listeners = data.on || _index2.emptyObject;\n  this.injections = (0, _inject.resolveInject)(options.inject, parent);\n  this.slots = function () {\n    return (0, _resolveSlots.resolveSlots)(children, parent);\n  };\n\n  // support for compiled functional template\n  if (isCompiled) {\n    // exposing $options for renderStatic()\n    this.$options = options;\n    // pre-resolve slots for renderSlot()\n    this.$slots = this.slots();\n    this.$scopedSlots = data.scopedSlots || _index2.emptyObject;\n  }\n\n  if (options._scopeId) {\n    this._c = function (a, b, c, d) {\n      var vnode = (0, _createElement.createElement)(contextVm, a, b, c, d, needNormalization);\n      if (vnode && !Array.isArray(vnode)) {\n        vnode.fnScopeId = options._scopeId;\n        vnode.fnContext = parent;\n      }\n      return vnode;\n    };\n  } else {\n    this._c = function (a, b, c, d) {\n      return (0, _createElement.createElement)(contextVm, a, b, c, d, needNormalization);\n    };\n  }\n}\n\n(0, _index.installRenderHelpers)(FunctionalRenderContext.prototype);\n\nfunction createFunctionalComponent(Ctor, propsData, data, contextVm, children) {\n  var options = Ctor.options;\n  var props = {};\n  var propOptions = options.props;\n  if ((0, _index2.isDef)(propOptions)) {\n    for (var key in propOptions) {\n      props[key] = (0, _index2.validateProp)(key, propOptions, propsData || _index2.emptyObject);\n    }\n  } else {\n    if ((0, _index2.isDef)(data.attrs)) mergeProps(props, data.attrs);\n    if ((0, _index2.isDef)(data.props)) mergeProps(props, data.props);\n  }\n\n  var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);\n\n  var vnode = options.render.call(null, renderContext._c, renderContext);\n\n  if (vnode instanceof _vnode2.default) {\n    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options);\n  } else if (Array.isArray(vnode)) {\n    var vnodes = (0, _normalizeChildren.normalizeChildren)(vnode) || [];\n    var res = new Array(vnodes.length);\n    for (var i = 0; i < vnodes.length; i++) {\n      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options);\n    }\n    return res;\n  }\n}\n\nfunction cloneAndMarkFunctionalResult(vnode, data, contextVm, options) {\n  // #7817 clone node before setting fnContext, otherwise if the node is reused\n  // (e.g. it was from a cached normal slot) the fnContext causes named slots\n  // that should not be matched to match.\n  var clone = (0, _vnode.cloneVNode)(vnode);\n  clone.fnContext = contextVm;\n  clone.fnOptions = options;\n  if (data.slot) {\n    (clone.data || (clone.data = {})).slot = data.slot;\n  }\n  return clone;\n}\n\nfunction mergeProps(to, from) {\n  for (var key in from) {\n    to[(0, _index2.camelize)(key)] = from[key];\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/create-functional-component.js?");

/***/ }),

/***/ "./src/core/vdom/helpers/extract-props.js":
/*!************************************************!*\
  !*** ./src/core/vdom/helpers/extract-props.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.extractPropsFromVNodeData = extractPropsFromVNodeData;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nfunction extractPropsFromVNodeData(data, Ctor, tag) {\n  // we are only extracting raw values here.\n  // validation and default values are handled in the child\n  // component itself.\n  var propOptions = Ctor.options.props;\n  if ((0, _index.isUndef)(propOptions)) {\n    return;\n  }\n  var res = {};\n  var attrs = data.attrs,\n      props = data.props;\n\n  if ((0, _index.isDef)(attrs) || (0, _index.isDef)(props)) {\n    for (var key in propOptions) {\n      var altKey = (0, _index.hyphenate)(key);\n      if (true) {\n        var keyInLowerCase = key.toLowerCase();\n        if (key !== keyInLowerCase && attrs && (0, _index.hasOwn)(attrs, keyInLowerCase)) {\n          (0, _index.tip)('Prop \"' + keyInLowerCase + '\" is passed to component ' + ((0, _index.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 + '\".'));\n        }\n      }\n      checkProp(res, props, key, altKey, true) || checkProp(res, attrs, key, altKey, false);\n    }\n  }\n  return res;\n}\n\nfunction checkProp(res, hash, key, altKey, preserve) {\n  if ((0, _index.isDef)(hash)) {\n    if ((0, _index.hasOwn)(hash, key)) {\n      res[key] = hash[key];\n      if (!preserve) {\n        delete hash[key];\n      }\n      return true;\n    } else if ((0, _index.hasOwn)(hash, altKey)) {\n      res[key] = hash[altKey];\n      if (!preserve) {\n        delete hash[altKey];\n      }\n      return true;\n    }\n  }\n  return false;\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/helpers/extract-props.js?");

/***/ }),

/***/ "./src/core/vdom/helpers/get-first-component-child.js":
/*!************************************************************!*\
  !*** ./src/core/vdom/helpers/get-first-component-child.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getFirstComponentChild = getFirstComponentChild;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _isAsyncPlaceholder = __webpack_require__(/*! ./is-async-placeholder */ \"./src/core/vdom/helpers/is-async-placeholder.js\");\n\nfunction getFirstComponentChild(children) {\n  if (Array.isArray(children)) {\n    for (var i = 0; i < children.length; i++) {\n      var c = children[i];\n      if ((0, _util.isDef)(c) && ((0, _util.isDef)(c.componentOptions) || (0, _isAsyncPlaceholder.isAsyncPlaceholder)(c))) {\n        return c;\n      }\n    }\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/helpers/get-first-component-child.js?");

/***/ }),

/***/ "./src/core/vdom/helpers/index.js":
/*!****************************************!*\
  !*** ./src/core/vdom/helpers/index.js ***!
  \****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _mergeHook = __webpack_require__(/*! ./merge-hook */ \"./src/core/vdom/helpers/merge-hook.js\");\n\nObject.keys(_mergeHook).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _mergeHook[key];\n    }\n  });\n});\n\nvar _extractProps = __webpack_require__(/*! ./extract-props */ \"./src/core/vdom/helpers/extract-props.js\");\n\nObject.keys(_extractProps).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _extractProps[key];\n    }\n  });\n});\n\nvar _updateListeners = __webpack_require__(/*! ./update-listeners */ \"./src/core/vdom/helpers/update-listeners.js\");\n\nObject.keys(_updateListeners).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _updateListeners[key];\n    }\n  });\n});\n\nvar _normalizeChildren = __webpack_require__(/*! ./normalize-children */ \"./src/core/vdom/helpers/normalize-children.js\");\n\nObject.keys(_normalizeChildren).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _normalizeChildren[key];\n    }\n  });\n});\n\nvar _resolveAsyncComponent = __webpack_require__(/*! ./resolve-async-component */ \"./src/core/vdom/helpers/resolve-async-component.js\");\n\nObject.keys(_resolveAsyncComponent).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _resolveAsyncComponent[key];\n    }\n  });\n});\n\nvar _getFirstComponentChild = __webpack_require__(/*! ./get-first-component-child */ \"./src/core/vdom/helpers/get-first-component-child.js\");\n\nObject.keys(_getFirstComponentChild).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _getFirstComponentChild[key];\n    }\n  });\n});\n\nvar _isAsyncPlaceholder = __webpack_require__(/*! ./is-async-placeholder */ \"./src/core/vdom/helpers/is-async-placeholder.js\");\n\nObject.keys(_isAsyncPlaceholder).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _isAsyncPlaceholder[key];\n    }\n  });\n});\n\n//# sourceURL=webpack://Vue/./src/core/vdom/helpers/index.js?");

/***/ }),

/***/ "./src/core/vdom/helpers/is-async-placeholder.js":
/*!*******************************************************!*\
  !*** ./src/core/vdom/helpers/is-async-placeholder.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isAsyncPlaceholder = isAsyncPlaceholder;\nfunction isAsyncPlaceholder(node) {\n  return node.isComment && node.asyncFactory;\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/helpers/is-async-placeholder.js?");

/***/ }),

/***/ "./src/core/vdom/helpers/merge-hook.js":
/*!*********************************************!*\
  !*** ./src/core/vdom/helpers/merge-hook.js ***!
  \*********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.mergeVNodeHook = mergeVNodeHook;\n\nvar _vnode = __webpack_require__(/*! ../vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _vnode2 = _interopRequireDefault(_vnode);\n\nvar _updateListeners = __webpack_require__(/*! ./update-listeners */ \"./src/core/vdom/helpers/update-listeners.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction mergeVNodeHook(def, hookKey, hook) {\n  if (def instanceof _vnode2.default) {\n    def = def.data.hook || (def.data.hook = {});\n  }\n  var invoker = void 0;\n  var oldHook = def[hookKey];\n\n  function wrappedHook() {\n    hook.apply(this, arguments);\n    // important: remove merged hook to ensure it's called only once\n    // and prevent memory leak\n    (0, _util.remove)(invoker.fns, wrappedHook);\n  }\n\n  if ((0, _util.isUndef)(oldHook)) {\n    // no existing hook\n    invoker = (0, _updateListeners.createFnInvoker)([wrappedHook]);\n  } else {\n    /* istanbul ignore if */\n    if ((0, _util.isDef)(oldHook.fns) && (0, _util.isTrue)(oldHook.merged)) {\n      // already a merged invoker\n      invoker = oldHook;\n      invoker.fns.push(wrappedHook);\n    } else {\n      // existing plain hook\n      invoker = (0, _updateListeners.createFnInvoker)([oldHook, wrappedHook]);\n    }\n  }\n\n  invoker.merged = true;\n  def[hookKey] = invoker;\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/helpers/merge-hook.js?");

/***/ }),

/***/ "./src/core/vdom/helpers/normalize-children.js":
/*!*****************************************************!*\
  !*** ./src/core/vdom/helpers/normalize-children.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.simpleNormalizeChildren = simpleNormalizeChildren;\nexports.normalizeChildren = normalizeChildren;\n\nvar _vnode = __webpack_require__(/*! core/vdom/vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _vnode2 = _interopRequireDefault(_vnode);\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// normalization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// because functional components already normalize their own children.\nfunction simpleNormalizeChildren(children) {\n  for (var i = 0; i < children.length; i++) {\n    if (Array.isArray(children[i])) {\n      return Array.prototype.concat.apply([], children);\n    }\n  }\n  return children;\n}\n\n// 2. When the children contains constructs that always generated nested Arrays,\n// e.g. <template>, <slot>, v-for, or when the children is provided by user\n// with hand-written render functions / JSX. In such cases a full normalization\n// is needed to cater to all possible types of children values.\nfunction normalizeChildren(children) {\n  return (0, _util.isPrimitive)(children) ? [(0, _vnode.createTextVNode)(children)] : Array.isArray(children) ? normalizeArrayChildren(children) : undefined;\n}\n\nfunction isTextNode(node) {\n  return (0, _util.isDef)(node) && (0, _util.isDef)(node.text) && (0, _util.isFalse)(node.isComment);\n}\n\nfunction normalizeArrayChildren(children, nestedIndex) {\n  var res = [];\n  var i = void 0,\n      c = void 0,\n      lastIndex = void 0,\n      last = void 0;\n  for (i = 0; i < children.length; i++) {\n    c = children[i];\n    if ((0, _util.isUndef)(c) || typeof c === 'boolean') continue;\n    lastIndex = res.length - 1;\n    last = res[lastIndex];\n    //  nested\n    if (Array.isArray(c)) {\n      if (c.length > 0) {\n        c = normalizeArrayChildren(c, (nestedIndex || '') + '_' + i);\n        // merge adjacent text nodes\n        if (isTextNode(c[0]) && isTextNode(last)) {\n          res[lastIndex] = (0, _vnode.createTextVNode)(last.text + c[0].text);\n          c.shift();\n        }\n        res.push.apply(res, c);\n      }\n    } else if ((0, _util.isPrimitive)(c)) {\n      if (isTextNode(last)) {\n        // merge adjacent text nodes\n        // this is necessary for SSR hydration because text nodes are\n        // essentially merged when rendered to HTML strings\n        res[lastIndex] = (0, _vnode.createTextVNode)(last.text + c);\n      } else if (c !== '') {\n        // convert primitive to vnode\n        res.push((0, _vnode.createTextVNode)(c));\n      }\n    } else {\n      if (isTextNode(c) && isTextNode(last)) {\n        // merge adjacent text nodes\n        res[lastIndex] = (0, _vnode.createTextVNode)(last.text + c.text);\n      } else {\n        // default key for nested array children (likely generated by v-for)\n        if ((0, _util.isTrue)(children._isVList) && (0, _util.isDef)(c.tag) && (0, _util.isUndef)(c.key) && (0, _util.isDef)(nestedIndex)) {\n          c.key = '__vlist' + nestedIndex + '_' + i + '__';\n        }\n        res.push(c);\n      }\n    }\n  }\n  return res;\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/helpers/normalize-children.js?");

/***/ }),

/***/ "./src/core/vdom/helpers/resolve-async-component.js":
/*!**********************************************************!*\
  !*** ./src/core/vdom/helpers/resolve-async-component.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createAsyncPlaceholder = createAsyncPlaceholder;\nexports.resolveAsyncComponent = resolveAsyncComponent;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _vnode = __webpack_require__(/*! core/vdom/vnode */ \"./src/core/vdom/vnode.js\");\n\nfunction ensureCtor(comp, base) {\n  if (comp.__esModule || _index.hasSymbol && comp[Symbol.toStringTag] === 'Module') {\n    comp = comp.default;\n  }\n  return (0, _index.isObject)(comp) ? base.extend(comp) : comp;\n}\n\nfunction createAsyncPlaceholder(factory, data, context, children, tag) {\n  var node = (0, _vnode.createEmptyVNode)();\n  node.asyncFactory = factory;\n  node.asyncMeta = { data: data, context: context, children: children, tag: tag };\n  return node;\n}\n\nfunction resolveAsyncComponent(factory, baseCtor, context) {\n  if ((0, _index.isTrue)(factory.error) && (0, _index.isDef)(factory.errorComp)) {\n    return factory.errorComp;\n  }\n\n  if ((0, _index.isDef)(factory.resolved)) {\n    return factory.resolved;\n  }\n\n  if ((0, _index.isTrue)(factory.loading) && (0, _index.isDef)(factory.loadingComp)) {\n    return factory.loadingComp;\n  }\n\n  if ((0, _index.isDef)(factory.contexts)) {\n    // already pending\n    factory.contexts.push(context);\n  } else {\n    var contexts = factory.contexts = [context];\n    var sync = true;\n\n    var forceRender = function forceRender() {\n      for (var i = 0, l = contexts.length; i < l; i++) {\n        contexts[i].$forceUpdate();\n      }\n    };\n\n    var resolve = (0, _index.once)(function (res) {\n      // cache resolved\n      factory.resolved = ensureCtor(res, baseCtor);\n      // invoke callbacks only if this is not a synchronous resolve\n      // (async resolves are shimmed as synchronous during SSR)\n      if (!sync) {\n        forceRender();\n      }\n    });\n\n    var reject = (0, _index.once)(function (reason) {\n      \"development\" !== 'production' && (0, _index.warn)('Failed to resolve async component: ' + String(factory) + (reason ? '\\nReason: ' + reason : ''));\n      if ((0, _index.isDef)(factory.errorComp)) {\n        factory.error = true;\n        forceRender();\n      }\n    });\n\n    var res = factory(resolve, reject);\n\n    if ((0, _index.isObject)(res)) {\n      if (typeof res.then === 'function') {\n        // () => Promise\n        if ((0, _index.isUndef)(factory.resolved)) {\n          res.then(resolve, reject);\n        }\n      } else if ((0, _index.isDef)(res.component) && typeof res.component.then === 'function') {\n        res.component.then(resolve, reject);\n\n        if ((0, _index.isDef)(res.error)) {\n          factory.errorComp = ensureCtor(res.error, baseCtor);\n        }\n\n        if ((0, _index.isDef)(res.loading)) {\n          factory.loadingComp = ensureCtor(res.loading, baseCtor);\n          if (res.delay === 0) {\n            factory.loading = true;\n          } else {\n            setTimeout(function () {\n              if ((0, _index.isUndef)(factory.resolved) && (0, _index.isUndef)(factory.error)) {\n                factory.loading = true;\n                forceRender();\n              }\n            }, res.delay || 200);\n          }\n        }\n\n        if ((0, _index.isDef)(res.timeout)) {\n          setTimeout(function () {\n            if ((0, _index.isUndef)(factory.resolved)) {\n              reject( true ? 'timeout (' + res.timeout + 'ms)' : undefined);\n            }\n          }, res.timeout);\n        }\n      }\n    }\n\n    sync = false;\n    // return in case resolved synchronously\n    return factory.loading ? factory.loadingComp : factory.resolved;\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/helpers/resolve-async-component.js?");

/***/ }),

/***/ "./src/core/vdom/helpers/update-listeners.js":
/*!***************************************************!*\
  !*** ./src/core/vdom/helpers/update-listeners.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createFnInvoker = createFnInvoker;\nexports.updateListeners = updateListeners;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar normalizeEvent = (0, _util.cached)(function (name) {\n  var passive = name.charAt(0) === '&';\n  name = passive ? name.slice(1) : name;\n  var once = name.charAt(0) === '~'; // Prefixed last, checked first\n  name = once ? name.slice(1) : name;\n  var capture = name.charAt(0) === '!';\n  name = capture ? name.slice(1) : name;\n  return {\n    name: name,\n    once: once,\n    capture: capture,\n    passive: passive\n  };\n});\n\nfunction createFnInvoker(fns) {\n  function invoker() {\n    var fns = invoker.fns;\n    if (Array.isArray(fns)) {\n      var cloned = fns.slice();\n      for (var i = 0; i < cloned.length; i++) {\n        cloned[i].apply(null, arguments);\n      }\n    } else {\n      // return handler return value for single handlers\n      return fns.apply(null, arguments);\n    }\n  }\n  invoker.fns = fns;\n  return invoker;\n}\n\nfunction updateListeners(on, oldOn, add, remove, vm) {\n  var name = void 0,\n      def = void 0,\n      cur = void 0,\n      old = void 0,\n      event = void 0;\n  for (name in on) {\n    def = cur = on[name];\n    old = oldOn[name];\n    event = normalizeEvent(name);\n    /* istanbul ignore if */\n    var __WEEX__ = false;\n    if (__WEEX__ && (0, _util.isPlainObject)(def)) {\n      cur = def.handler;\n      event.params = def.params;\n    }\n    if ((0, _util.isUndef)(cur)) {\n      \"development\" !== 'production' && (0, _index.warn)('Invalid handler for event \"' + event.name + '\": got ' + String(cur), vm);\n    } else if ((0, _util.isUndef)(old)) {\n      if ((0, _util.isUndef)(cur.fns)) {\n        cur = on[name] = createFnInvoker(cur);\n      }\n      add(event.name, cur, event.once, event.capture, event.passive, event.params);\n    } else if (cur !== old) {\n      old.fns = cur;\n      on[name] = old;\n    }\n  }\n  for (name in oldOn) {\n    if ((0, _util.isUndef)(on[name])) {\n      event = normalizeEvent(name);\n      remove(event.name, oldOn[name], event.capture);\n    }\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/helpers/update-listeners.js?");

/***/ }),

/***/ "./src/core/vdom/modules/directives.js":
/*!*********************************************!*\
  !*** ./src/core/vdom/modules/directives.js ***!
  \*********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _patch = __webpack_require__(/*! core/vdom/patch */ \"./src/core/vdom/patch.js\");\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _index2 = __webpack_require__(/*! core/vdom/helpers/index */ \"./src/core/vdom/helpers/index.js\");\n\nexports.default = {\n  create: updateDirectives,\n  update: updateDirectives,\n  destroy: function unbindDirectives(vnode) {\n    updateDirectives(vnode, _patch.emptyNode);\n  }\n};\n\n\nfunction updateDirectives(oldVnode, vnode) {\n  if (oldVnode.data.directives || vnode.data.directives) {\n    _update(oldVnode, vnode);\n  }\n}\n\nfunction _update(oldVnode, vnode) {\n  var isCreate = oldVnode === _patch.emptyNode;\n  var isDestroy = vnode === _patch.emptyNode;\n  var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);\n  var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);\n\n  var dirsWithInsert = [];\n  var dirsWithPostpatch = [];\n\n  var key = void 0,\n      oldDir = void 0,\n      dir = void 0;\n  for (key in newDirs) {\n    oldDir = oldDirs[key];\n    dir = newDirs[key];\n    if (!oldDir) {\n      // new directive, bind\n      callHook(dir, 'bind', vnode, oldVnode);\n      if (dir.def && dir.def.inserted) {\n        dirsWithInsert.push(dir);\n      }\n    } else {\n      // existing directive, update\n      dir.oldValue = oldDir.value;\n      callHook(dir, 'update', vnode, oldVnode);\n      if (dir.def && dir.def.componentUpdated) {\n        dirsWithPostpatch.push(dir);\n      }\n    }\n  }\n\n  if (dirsWithInsert.length) {\n    var callInsert = function callInsert() {\n      for (var i = 0; i < dirsWithInsert.length; i++) {\n        callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n      }\n    };\n    if (isCreate) {\n      (0, _index2.mergeVNodeHook)(vnode, 'insert', callInsert);\n    } else {\n      callInsert();\n    }\n  }\n\n  if (dirsWithPostpatch.length) {\n    (0, _index2.mergeVNodeHook)(vnode, 'postpatch', function () {\n      for (var i = 0; i < dirsWithPostpatch.length; i++) {\n        callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n      }\n    });\n  }\n\n  if (!isCreate) {\n    for (key in oldDirs) {\n      if (!newDirs[key]) {\n        // no longer present, unbind\n        callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n      }\n    }\n  }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives(dirs, vm) {\n  var res = Object.create(null);\n  if (!dirs) {\n    // $flow-disable-line\n    return res;\n  }\n  var i = void 0,\n      dir = void 0;\n  for (i = 0; i < dirs.length; i++) {\n    dir = dirs[i];\n    if (!dir.modifiers) {\n      // $flow-disable-line\n      dir.modifiers = emptyModifiers;\n    }\n    res[getRawDirName(dir)] = dir;\n    dir.def = (0, _index.resolveAsset)(vm.$options, 'directives', dir.name, true);\n  }\n  // $flow-disable-line\n  return res;\n}\n\nfunction getRawDirName(dir) {\n  return dir.rawName || dir.name + '.' + Object.keys(dir.modifiers || {}).join('.');\n}\n\nfunction callHook(dir, hook, vnode, oldVnode, isDestroy) {\n  var fn = dir.def && dir.def[hook];\n  if (fn) {\n    try {\n      fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n    } catch (e) {\n      (0, _index.handleError)(e, vnode.context, 'directive ' + dir.name + ' ' + hook + ' hook');\n    }\n  }\n}\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/core/vdom/modules/directives.js?");

/***/ }),

/***/ "./src/core/vdom/modules/index.js":
/*!****************************************!*\
  !*** ./src/core/vdom/modules/index.js ***!
  \****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _directives = __webpack_require__(/*! ./directives */ \"./src/core/vdom/modules/directives.js\");\n\nvar _directives2 = _interopRequireDefault(_directives);\n\nvar _ref = __webpack_require__(/*! ./ref */ \"./src/core/vdom/modules/ref.js\");\n\nvar _ref2 = _interopRequireDefault(_ref);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = [_ref2.default, _directives2.default];\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/core/vdom/modules/index.js?");

/***/ }),

/***/ "./src/core/vdom/modules/ref.js":
/*!**************************************!*\
  !*** ./src/core/vdom/modules/ref.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.registerRef = registerRef;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nexports.default = {\n  create: function create(_, vnode) {\n    registerRef(vnode);\n  },\n  update: function update(oldVnode, vnode) {\n    if (oldVnode.data.ref !== vnode.data.ref) {\n      registerRef(oldVnode, true);\n      registerRef(vnode);\n    }\n  },\n  destroy: function destroy(vnode) {\n    registerRef(vnode, true);\n  }\n};\nfunction registerRef(vnode, isRemoval) {\n  var key = vnode.data.ref;\n  if (!(0, _util.isDef)(key)) return;\n\n  var vm = vnode.context;\n  var ref = vnode.componentInstance || vnode.elm;\n  var refs = vm.$refs;\n  if (isRemoval) {\n    if (Array.isArray(refs[key])) {\n      (0, _util.remove)(refs[key], ref);\n    } else if (refs[key] === ref) {\n      refs[key] = undefined;\n    }\n  } else {\n    if (vnode.data.refInFor) {\n      if (!Array.isArray(refs[key])) {\n        refs[key] = [ref];\n      } else if (refs[key].indexOf(ref) < 0) {\n        // $flow-disable-line\n        refs[key].push(ref);\n      }\n    } else {\n      refs[key] = ref;\n    }\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/modules/ref.js?");

/***/ }),

/***/ "./src/core/vdom/patch.js":
/*!********************************!*\
  !*** ./src/core/vdom/patch.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.emptyNode = undefined;\nexports.createPatchFunction = createPatchFunction;\n\nvar _vnode = __webpack_require__(/*! ./vnode */ \"./src/core/vdom/vnode.js\");\n\nvar _vnode2 = _interopRequireDefault(_vnode);\n\nvar _config = __webpack_require__(/*! ../config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _constants = __webpack_require__(/*! shared/constants */ \"./src/shared/constants.js\");\n\nvar _ref = __webpack_require__(/*! ./modules/ref */ \"./src/core/vdom/modules/ref.js\");\n\nvar _traverse = __webpack_require__(/*! ../observer/traverse */ \"./src/core/observer/traverse.js\");\n\nvar _lifecycle = __webpack_require__(/*! ../instance/lifecycle */ \"./src/core/instance/lifecycle.js\");\n\nvar _element = __webpack_require__(/*! web/util/element */ \"./src/platforms/web/util/element.js\");\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/core/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = exports.emptyNode = new _vnode2.default('', {}, []);\n\nvar hooks = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction sameVnode(a, b) {\n  return a.key === b.key && (a.tag === b.tag && a.isComment === b.isComment && (0, _index.isDef)(a.data) === (0, _index.isDef)(b.data) && sameInputType(a, b) || (0, _index.isTrue)(a.isAsyncPlaceholder) && a.asyncFactory === b.asyncFactory && (0, _index.isUndef)(b.asyncFactory.error));\n}\n\nfunction sameInputType(a, b) {\n  if (a.tag !== 'input') return true;\n  var i = void 0;\n  var typeA = (0, _index.isDef)(i = a.data) && (0, _index.isDef)(i = i.attrs) && i.type;\n  var typeB = (0, _index.isDef)(i = b.data) && (0, _index.isDef)(i = i.attrs) && i.type;\n  return typeA === typeB || (0, _element.isTextInputType)(typeA) && (0, _element.isTextInputType)(typeB);\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i = void 0,\n      key = void 0;\n  var map = {};\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if ((0, _index.isDef)(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createPatchFunction(backend) {\n  var i = void 0,\n      j = void 0;\n  var cbs = {};\n\n  var modules = backend.modules,\n      nodeOps = backend.nodeOps;\n\n\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if ((0, _index.isDef)(modules[j][hooks[i]])) {\n        cbs[hooks[i]].push(modules[j][hooks[i]]);\n      }\n    }\n  }\n\n  function emptyNodeAt(elm) {\n    return new _vnode2.default(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);\n  }\n\n  function createRmCb(childElm, listeners) {\n    function remove() {\n      if (--remove.listeners === 0) {\n        removeNode(childElm);\n      }\n    }\n    remove.listeners = listeners;\n    return remove;\n  }\n\n  function removeNode(el) {\n    var parent = nodeOps.parentNode(el);\n    // element may have already been removed due to v-html / v-text\n    if ((0, _index.isDef)(parent)) {\n      nodeOps.removeChild(parent, el);\n    }\n  }\n\n  function isUnknownElement(vnode, inVPre) {\n    return !inVPre && !vnode.ns && !(_config2.default.ignoredElements.length && _config2.default.ignoredElements.some(function (ignore) {\n      return (0, _index.isRegExp)(ignore) ? ignore.test(vnode.tag) : ignore === vnode.tag;\n    })) && _config2.default.isUnknownElement(vnode.tag);\n  }\n\n  var creatingElmInVPre = 0;\n\n  function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {\n    if ((0, _index.isDef)(vnode.elm) && (0, _index.isDef)(ownerArray)) {\n      // This vnode was used in a previous render!\n      // now it's used as a new node, overwriting its elm would cause\n      // potential patch errors down the road when it's used as an insertion\n      // reference node. Instead, we clone the node on-demand before creating\n      // associated DOM element for it.\n      vnode = ownerArray[index] = (0, _vnode.cloneVNode)(vnode);\n    }\n\n    vnode.isRootInsert = !nested; // for transition enter check\n    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n      return;\n    }\n\n    var data = vnode.data;\n    var children = vnode.children;\n    var tag = vnode.tag;\n    if ((0, _index.isDef)(tag)) {\n      if (true) {\n        if (data && data.pre) {\n          creatingElmInVPre++;\n        }\n        if (isUnknownElement(vnode, creatingElmInVPre)) {\n          (0, _index.warn)('Unknown custom element: <' + tag + '> - did you ' + 'register the component correctly? For recursive components, ' + 'make sure to provide the \"name\" option.', vnode.context);\n        }\n      }\n\n      vnode.elm = vnode.ns ? nodeOps.createElementNS(vnode.ns, tag) : nodeOps.createElement(tag, vnode);\n      setScope(vnode);\n\n      /* istanbul ignore if */\n      var __WEEX__ = false;\n      if (__WEEX__) {\n        // in Weex, the default insertion order is parent-first.\n        // List items can be optimized to use children-first insertion\n        // with append=\"tree\".\n        var appendAsTree = (0, _index.isDef)(data) && (0, _index.isTrue)(data.appendAsTree);\n        if (!appendAsTree) {\n          if ((0, _index.isDef)(data)) {\n            invokeCreateHooks(vnode, insertedVnodeQueue);\n          }\n          insert(parentElm, vnode.elm, refElm);\n        }\n        createChildren(vnode, children, insertedVnodeQueue);\n        if (appendAsTree) {\n          if ((0, _index.isDef)(data)) {\n            invokeCreateHooks(vnode, insertedVnodeQueue);\n          }\n          insert(parentElm, vnode.elm, refElm);\n        }\n      } else {\n        createChildren(vnode, children, insertedVnodeQueue);\n        if ((0, _index.isDef)(data)) {\n          invokeCreateHooks(vnode, insertedVnodeQueue);\n        }\n        insert(parentElm, vnode.elm, refElm);\n      }\n\n      if (\"development\" !== 'production' && data && data.pre) {\n        creatingElmInVPre--;\n      }\n    } else if ((0, _index.isTrue)(vnode.isComment)) {\n      vnode.elm = nodeOps.createComment(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    } else {\n      vnode.elm = nodeOps.createTextNode(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    }\n  }\n\n  function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i = vnode.data;\n    if ((0, _index.isDef)(i)) {\n      var isReactivated = (0, _index.isDef)(vnode.componentInstance) && i.keepAlive;\n      if ((0, _index.isDef)(i = i.hook) && (0, _index.isDef)(i = i.init)) {\n        i(vnode, false /* hydrating */, parentElm, refElm);\n      }\n      // after calling the init hook, if the vnode is a child component\n      // it should've created a child instance and mounted it. the child\n      // component also has set the placeholder vnode's elm.\n      // in that case we can just return the element and be done.\n      if ((0, _index.isDef)(vnode.componentInstance)) {\n        initComponent(vnode, insertedVnodeQueue);\n        if ((0, _index.isTrue)(isReactivated)) {\n          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n        }\n        return true;\n      }\n    }\n  }\n\n  function initComponent(vnode, insertedVnodeQueue) {\n    if ((0, _index.isDef)(vnode.data.pendingInsert)) {\n      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);\n      vnode.data.pendingInsert = null;\n    }\n    vnode.elm = vnode.componentInstance.$el;\n    if (isPatchable(vnode)) {\n      invokeCreateHooks(vnode, insertedVnodeQueue);\n      setScope(vnode);\n    } else {\n      // empty component root.\n      // skip all element-related modules except for ref (#3455)\n      (0, _ref.registerRef)(vnode);\n      // make sure to invoke the insert hook\n      insertedVnodeQueue.push(vnode);\n    }\n  }\n\n  function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i = void 0;\n    // hack for #4339: a reactivated component with inner transition\n    // does not trigger because the inner node's created hooks are not called\n    // again. It's not ideal to involve module-specific logic in here but\n    // there doesn't seem to be a better way to do it.\n    var innerNode = vnode;\n    while (innerNode.componentInstance) {\n      innerNode = innerNode.componentInstance._vnode;\n      if ((0, _index.isDef)(i = innerNode.data) && (0, _index.isDef)(i = i.transition)) {\n        for (i = 0; i < cbs.activate.length; ++i) {\n          cbs.activate[i](emptyNode, innerNode);\n        }\n        insertedVnodeQueue.push(innerNode);\n        break;\n      }\n    }\n    // unlike a newly created component,\n    // a reactivated keep-alive component doesn't insert itself\n    insert(parentElm, vnode.elm, refElm);\n  }\n\n  function insert(parent, elm, ref) {\n    if ((0, _index.isDef)(parent)) {\n      if ((0, _index.isDef)(ref)) {\n        if (ref.parentNode === parent) {\n          nodeOps.insertBefore(parent, elm, ref);\n        }\n      } else {\n        nodeOps.appendChild(parent, elm);\n      }\n    }\n  }\n\n  function createChildren(vnode, children, insertedVnodeQueue) {\n    if (Array.isArray(children)) {\n      if (true) {\n        checkDuplicateKeys(children);\n      }\n      for (var _i = 0; _i < children.length; ++_i) {\n        createElm(children[_i], insertedVnodeQueue, vnode.elm, null, true, children, _i);\n      }\n    } else if ((0, _index.isPrimitive)(vnode.text)) {\n      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));\n    }\n  }\n\n  function isPatchable(vnode) {\n    while (vnode.componentInstance) {\n      vnode = vnode.componentInstance._vnode;\n    }\n    return (0, _index.isDef)(vnode.tag);\n  }\n\n  function invokeCreateHooks(vnode, insertedVnodeQueue) {\n    for (var _i2 = 0; _i2 < cbs.create.length; ++_i2) {\n      cbs.create[_i2](emptyNode, vnode);\n    }\n    i = vnode.data.hook; // Reuse variable\n    if ((0, _index.isDef)(i)) {\n      if ((0, _index.isDef)(i.create)) i.create(emptyNode, vnode);\n      if ((0, _index.isDef)(i.insert)) insertedVnodeQueue.push(vnode);\n    }\n  }\n\n  // set scope id attribute for scoped CSS.\n  // this is implemented as a special case to avoid the overhead\n  // of going through the normal attribute patching process.\n  function setScope(vnode) {\n    var i = void 0;\n    if ((0, _index.isDef)(i = vnode.fnScopeId)) {\n      nodeOps.setStyleScope(vnode.elm, i);\n    } else {\n      var ancestor = vnode;\n      while (ancestor) {\n        if ((0, _index.isDef)(i = ancestor.context) && (0, _index.isDef)(i = i.$options._scopeId)) {\n          nodeOps.setStyleScope(vnode.elm, i);\n        }\n        ancestor = ancestor.parent;\n      }\n    }\n    // for slot content they should also get the scopeId from the host instance.\n    if ((0, _index.isDef)(i = _lifecycle.activeInstance) && i !== vnode.context && i !== vnode.fnContext && (0, _index.isDef)(i = i.$options._scopeId)) {\n      nodeOps.setStyleScope(vnode.elm, i);\n    }\n  }\n\n  function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = void 0,\n        j = void 0;\n    var data = vnode.data;\n    if ((0, _index.isDef)(data)) {\n      if ((0, _index.isDef)(i = data.hook) && (0, _index.isDef)(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) {\n        cbs.destroy[i](vnode);\n      }\n    }\n    if ((0, _index.isDef)(i = vnode.children)) {\n      for (j = 0; j < vnode.children.length; ++j) {\n        invokeDestroyHook(vnode.children[j]);\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var ch = vnodes[startIdx];\n      if ((0, _index.isDef)(ch)) {\n        if ((0, _index.isDef)(ch.tag)) {\n          removeAndInvokeRemoveHook(ch);\n          invokeDestroyHook(ch);\n        } else {\n          // Text node\n          removeNode(ch.elm);\n        }\n      }\n    }\n  }\n\n  function removeAndInvokeRemoveHook(vnode, rm) {\n    if ((0, _index.isDef)(rm) || (0, _index.isDef)(vnode.data)) {\n      var _i3 = void 0;\n      var listeners = cbs.remove.length + 1;\n      if ((0, _index.isDef)(rm)) {\n        // we have a recursively passed down rm callback\n        // increase the listeners count\n        rm.listeners += listeners;\n      } else {\n        // directly removing\n        rm = createRmCb(vnode.elm, listeners);\n      }\n      // recursively invoke hooks on child component root node\n      if ((0, _index.isDef)(_i3 = vnode.componentInstance) && (0, _index.isDef)(_i3 = _i3._vnode) && (0, _index.isDef)(_i3.data)) {\n        removeAndInvokeRemoveHook(_i3, rm);\n      }\n      for (_i3 = 0; _i3 < cbs.remove.length; ++_i3) {\n        cbs.remove[_i3](vnode, rm);\n      }\n      if ((0, _index.isDef)(_i3 = vnode.data.hook) && (0, _index.isDef)(_i3 = _i3.remove)) {\n        _i3(vnode, rm);\n      } else {\n        rm();\n      }\n    } else {\n      removeNode(vnode.elm);\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {\n    var oldStartIdx = 0;\n    var newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx = void 0,\n        idxInOld = void 0,\n        vnodeToMove = void 0,\n        refElm = void 0;\n\n    // removeOnly is a special flag used only by <transition-group>\n    // to ensure removed elements stay in correct relative positions\n    // during leaving transitions\n    var canMove = !removeOnly;\n\n    if (true) {\n      checkDuplicateKeys(newCh);\n    }\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if ((0, _index.isUndef)(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if ((0, _index.isUndef)(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) {\n        // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) {\n        // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if ((0, _index.isUndef)(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = (0, _index.isDef)(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);\n        if ((0, _index.isUndef)(idxInOld)) {\n          // New element\n          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);\n        } else {\n          vnodeToMove = oldCh[idxInOld];\n          if (sameVnode(vnodeToMove, newStartVnode)) {\n            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue);\n            oldCh[idxInOld] = undefined;\n            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);\n          } else {\n            // same key but different element. treat as new element\n            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);\n          }\n        }\n        newStartVnode = newCh[++newStartIdx];\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      refElm = (0, _index.isUndef)(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function checkDuplicateKeys(children) {\n    var seenKeys = {};\n    for (var _i4 = 0; _i4 < children.length; _i4++) {\n      var vnode = children[_i4];\n      var key = vnode.key;\n      if ((0, _index.isDef)(key)) {\n        if (seenKeys[key]) {\n          (0, _index.warn)('Duplicate keys detected: \\'' + key + '\\'. This may cause an update error.', vnode.context);\n        } else {\n          seenKeys[key] = true;\n        }\n      }\n    }\n  }\n\n  function findIdxInOld(node, oldCh, start, end) {\n    for (var _i5 = start; _i5 < end; _i5++) {\n      var c = oldCh[_i5];\n      if ((0, _index.isDef)(c) && sameVnode(node, c)) return _i5;\n    }\n  }\n\n  function patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n    if (oldVnode === vnode) {\n      return;\n    }\n\n    var elm = vnode.elm = oldVnode.elm;\n\n    if ((0, _index.isTrue)(oldVnode.isAsyncPlaceholder)) {\n      if ((0, _index.isDef)(vnode.asyncFactory.resolved)) {\n        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);\n      } else {\n        vnode.isAsyncPlaceholder = true;\n      }\n      return;\n    }\n\n    // reuse element for static trees.\n    // note we only do this if the vnode is cloned -\n    // if the new node is not cloned it means the render functions have been\n    // reset by the hot-reload-api and we need to do a proper re-render.\n    if ((0, _index.isTrue)(vnode.isStatic) && (0, _index.isTrue)(oldVnode.isStatic) && vnode.key === oldVnode.key && ((0, _index.isTrue)(vnode.isCloned) || (0, _index.isTrue)(vnode.isOnce))) {\n      vnode.componentInstance = oldVnode.componentInstance;\n      return;\n    }\n\n    var i = void 0;\n    var data = vnode.data;\n    if ((0, _index.isDef)(data) && (0, _index.isDef)(i = data.hook) && (0, _index.isDef)(i = i.prepatch)) {\n      i(oldVnode, vnode);\n    }\n\n    var oldCh = oldVnode.children;\n    var ch = vnode.children;\n    if ((0, _index.isDef)(data) && isPatchable(vnode)) {\n      for (i = 0; i < cbs.update.length; ++i) {\n        cbs.update[i](oldVnode, vnode);\n      }if ((0, _index.isDef)(i = data.hook) && (0, _index.isDef)(i = i.update)) i(oldVnode, vnode);\n    }\n    if ((0, _index.isUndef)(vnode.text)) {\n      if ((0, _index.isDef)(oldCh) && (0, _index.isDef)(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);\n      } else if ((0, _index.isDef)(ch)) {\n        if ((0, _index.isDef)(oldVnode.text)) nodeOps.setTextContent(elm, '');\n        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n      } else if ((0, _index.isDef)(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      } else if ((0, _index.isDef)(oldVnode.text)) {\n        nodeOps.setTextContent(elm, '');\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      nodeOps.setTextContent(elm, vnode.text);\n    }\n    if ((0, _index.isDef)(data)) {\n      if ((0, _index.isDef)(i = data.hook) && (0, _index.isDef)(i = i.postpatch)) i(oldVnode, vnode);\n    }\n  }\n\n  function invokeInsertHook(vnode, queue, initial) {\n    // delay insert hooks for component root nodes, invoke them after the\n    // element is really inserted\n    if ((0, _index.isTrue)(initial) && (0, _index.isDef)(vnode.parent)) {\n      vnode.parent.data.pendingInsert = queue;\n    } else {\n      for (var _i6 = 0; _i6 < queue.length; ++_i6) {\n        queue[_i6].data.hook.insert(queue[_i6]);\n      }\n    }\n  }\n\n  var hydrationBailed = false;\n  // list of modules that can skip create hook during hydration because they\n  // are already rendered on the client or has no need for initialization\n  // Note: style is excluded because it relies on initial clone for future\n  // deep updates (#7063).\n  var isRenderedModule = (0, _index.makeMap)('attrs,class,staticClass,staticStyle,key');\n\n  // Note: this is a browser-only function so we can assume elms are DOM nodes.\n  function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {\n    var i = void 0;\n    var tag = vnode.tag,\n        data = vnode.data,\n        children = vnode.children;\n\n    inVPre = inVPre || data && data.pre;\n    vnode.elm = elm;\n\n    if ((0, _index.isTrue)(vnode.isComment) && (0, _index.isDef)(vnode.asyncFactory)) {\n      vnode.isAsyncPlaceholder = true;\n      return true;\n    }\n    // assert node match\n    if (true) {\n      if (!assertNodeMatch(elm, vnode, inVPre)) {\n        return false;\n      }\n    }\n    if ((0, _index.isDef)(data)) {\n      if ((0, _index.isDef)(i = data.hook) && (0, _index.isDef)(i = i.init)) i(vnode, true /* hydrating */);\n      if ((0, _index.isDef)(i = vnode.componentInstance)) {\n        // child component. it should have hydrated its own tree.\n        initComponent(vnode, insertedVnodeQueue);\n        return true;\n      }\n    }\n    if ((0, _index.isDef)(tag)) {\n      if ((0, _index.isDef)(children)) {\n        // empty element, allow client to pick up and populate children\n        if (!elm.hasChildNodes()) {\n          createChildren(vnode, children, insertedVnodeQueue);\n        } else {\n          // v-html and domProps: innerHTML\n          if ((0, _index.isDef)(i = data) && (0, _index.isDef)(i = i.domProps) && (0, _index.isDef)(i = i.innerHTML)) {\n            if (i !== elm.innerHTML) {\n              /* istanbul ignore if */\n              if (\"development\" !== 'production' && typeof console !== 'undefined' && !hydrationBailed) {\n                hydrationBailed = true;\n                console.warn('Parent: ', elm);\n                console.warn('server innerHTML: ', i);\n                console.warn('client innerHTML: ', elm.innerHTML);\n              }\n              return false;\n            }\n          } else {\n            // iterate and compare children lists\n            var childrenMatch = true;\n            var childNode = elm.firstChild;\n            for (var _i7 = 0; _i7 < children.length; _i7++) {\n              if (!childNode || !hydrate(childNode, children[_i7], insertedVnodeQueue, inVPre)) {\n                childrenMatch = false;\n                break;\n              }\n              childNode = childNode.nextSibling;\n            }\n            // if childNode is not null, it means the actual childNodes list is\n            // longer than the virtual children list.\n            if (!childrenMatch || childNode) {\n              /* istanbul ignore if */\n              if (\"development\" !== 'production' && typeof console !== 'undefined' && !hydrationBailed) {\n                hydrationBailed = true;\n                console.warn('Parent: ', elm);\n                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n              }\n              return false;\n            }\n          }\n        }\n      }\n      if ((0, _index.isDef)(data)) {\n        var fullInvoke = false;\n        for (var key in data) {\n          if (!isRenderedModule(key)) {\n            fullInvoke = true;\n            invokeCreateHooks(vnode, insertedVnodeQueue);\n            break;\n          }\n        }\n        if (!fullInvoke && data['class']) {\n          // ensure collecting deps for deep class bindings for future updates\n          (0, _traverse.traverse)(data['class']);\n        }\n      }\n    } else if (elm.data !== vnode.text) {\n      elm.data = vnode.text;\n    }\n    return true;\n  }\n\n  function assertNodeMatch(node, vnode, inVPre) {\n    if ((0, _index.isDef)(vnode.tag)) {\n      return vnode.tag.indexOf('vue-component') === 0 || !isUnknownElement(vnode, inVPre) && vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase());\n    } else {\n      return node.nodeType === (vnode.isComment ? 8 : 3);\n    }\n  }\n\n  return function patch(oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {\n    if ((0, _index.isUndef)(vnode)) {\n      if ((0, _index.isDef)(oldVnode)) invokeDestroyHook(oldVnode);\n      return;\n    }\n\n    var isInitialPatch = false;\n    var insertedVnodeQueue = [];\n\n    if ((0, _index.isUndef)(oldVnode)) {\n      // empty mount (likely as component), create new root element\n      isInitialPatch = true;\n      createElm(vnode, insertedVnodeQueue, parentElm, refElm);\n    } else {\n      var isRealElement = (0, _index.isDef)(oldVnode.nodeType);\n      if (!isRealElement && sameVnode(oldVnode, vnode)) {\n        // patch existing root node\n        patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);\n      } else {\n        if (isRealElement) {\n          // mounting to a real element\n          // check if this is server-rendered content and if we can perform\n          // a successful hydration.\n          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(_constants.SSR_ATTR)) {\n            oldVnode.removeAttribute(_constants.SSR_ATTR);\n            hydrating = true;\n          }\n          if ((0, _index.isTrue)(hydrating)) {\n            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n              invokeInsertHook(vnode, insertedVnodeQueue, true);\n              return oldVnode;\n            } else if (true) {\n              (0, _index.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.');\n            }\n          }\n          // either not server-rendered, or hydration failed.\n          // create an empty node and replace it\n          oldVnode = emptyNodeAt(oldVnode);\n        }\n\n        // replacing existing element\n        var oldElm = oldVnode.elm;\n        var _parentElm = nodeOps.parentNode(oldElm);\n\n        // create new node\n        createElm(vnode, insertedVnodeQueue,\n        // extremely rare edge case: do not insert if old element is in a\n        // leaving transition. Only happens when combining transition +\n        // keep-alive + HOCs. (#4590)\n        oldElm._leaveCb ? null : _parentElm, nodeOps.nextSibling(oldElm));\n\n        // update parent placeholder node element, recursively\n        if ((0, _index.isDef)(vnode.parent)) {\n          var ancestor = vnode.parent;\n          var patchable = isPatchable(vnode);\n          while (ancestor) {\n            for (var _i8 = 0; _i8 < cbs.destroy.length; ++_i8) {\n              cbs.destroy[_i8](ancestor);\n            }\n            ancestor.elm = vnode.elm;\n            if (patchable) {\n              for (var _i9 = 0; _i9 < cbs.create.length; ++_i9) {\n                cbs.create[_i9](emptyNode, ancestor);\n              }\n              // #6513\n              // invoke insert hooks that may have been merged by create hooks.\n              // e.g. for directives that uses the \"inserted\" hook.\n              var _insert = ancestor.data.hook.insert;\n              if (_insert.merged) {\n                // start at index 1 to avoid re-invoking component mounted hook\n                for (var _i10 = 1; _i10 < _insert.fns.length; _i10++) {\n                  _insert.fns[_i10]();\n                }\n              }\n            } else {\n              (0, _ref.registerRef)(ancestor);\n            }\n            ancestor = ancestor.parent;\n          }\n        }\n\n        // destroy old node\n        if ((0, _index.isDef)(_parentElm)) {\n          removeVnodes(_parentElm, [oldVnode], 0, 0);\n        } else if ((0, _index.isDef)(oldVnode.tag)) {\n          invokeDestroyHook(oldVnode);\n        }\n      }\n    }\n\n    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n    return vnode.elm;\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/patch.js?");

/***/ }),

/***/ "./src/core/vdom/vnode.js":
/*!********************************!*\
  !*** ./src/core/vdom/vnode.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nexports.createTextVNode = createTextVNode;\nexports.cloneVNode = cloneVNode;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar VNode = function () {\n  // functional scope id support\n\n  // real context vm for functional nodes\n  // async component factory function\n  // is a cloned node?\n  // necessary for enter transition check\n  // contains raw HTML? (server only)\n  // component instance\n  function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {\n    _classCallCheck(this, VNode);\n\n    this.tag = tag;\n    this.data = data;\n    this.children = children;\n    this.text = text;\n    this.elm = elm;\n    this.ns = undefined;\n    this.context = context;\n    this.fnContext = undefined;\n    this.fnOptions = undefined;\n    this.fnScopeId = undefined;\n    this.key = data && data.key;\n    this.componentOptions = componentOptions;\n    this.componentInstance = undefined;\n    this.parent = undefined;\n    this.raw = false;\n    this.isStatic = false;\n    this.isRootInsert = true;\n    this.isComment = false;\n    this.isCloned = false;\n    this.isOnce = false;\n    this.asyncFactory = asyncFactory;\n    this.asyncMeta = undefined;\n    this.isAsyncPlaceholder = false;\n  }\n\n  // DEPRECATED: alias for componentInstance for backwards compat.\n  /* istanbul ignore next */\n  // for SSR caching\n  // is a v-once node?\n  // empty comment placeholder?\n  // hoisted static node\n  // component placeholder node\n\n  // strictly internal\n  // rendered in this component's scope\n\n\n  _createClass(VNode, [{\n    key: 'child',\n    get: function get() {\n      return this.componentInstance;\n    }\n  }]);\n\n  return VNode;\n}();\n\nexports.default = VNode;\nvar createEmptyVNode = exports.createEmptyVNode = function createEmptyVNode() {\n  var text = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n\n  var node = new VNode();\n  node.text = text;\n  node.isComment = true;\n  return node;\n};\n\nfunction createTextVNode(val) {\n  return new VNode(undefined, undefined, undefined, String(val));\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode(vnode) {\n  var cloned = new VNode(vnode.tag, vnode.data, vnode.children, vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);\n  cloned.ns = vnode.ns;\n  cloned.isStatic = vnode.isStatic;\n  cloned.key = vnode.key;\n  cloned.isComment = vnode.isComment;\n  cloned.fnContext = vnode.fnContext;\n  cloned.fnOptions = vnode.fnOptions;\n  cloned.fnScopeId = vnode.fnScopeId;\n  cloned.isCloned = true;\n  return cloned;\n}\n\n//# sourceURL=webpack://Vue/./src/core/vdom/vnode.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/directives/html.js":
/*!*******************************************************!*\
  !*** ./src/platforms/web/compiler/directives/html.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = html;\n\nvar _helpers = __webpack_require__(/*! compiler/helpers */ \"./src/compiler/helpers.js\");\n\nfunction html(el, dir) {\n  if (dir.value) {\n    (0, _helpers.addProp)(el, 'innerHTML', '_s(' + dir.value + ')');\n  }\n}\n\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/directives/html.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/directives/index.js":
/*!********************************************************!*\
  !*** ./src/platforms/web/compiler/directives/index.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _model = __webpack_require__(/*! ./model */ \"./src/platforms/web/compiler/directives/model.js\");\n\nvar _model2 = _interopRequireDefault(_model);\n\nvar _text = __webpack_require__(/*! ./text */ \"./src/platforms/web/compiler/directives/text.js\");\n\nvar _text2 = _interopRequireDefault(_text);\n\nvar _html = __webpack_require__(/*! ./html */ \"./src/platforms/web/compiler/directives/html.js\");\n\nvar _html2 = _interopRequireDefault(_html);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = {\n  model: _model2.default,\n  text: _text2.default,\n  html: _html2.default\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/directives/index.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/directives/model.js":
/*!********************************************************!*\
  !*** ./src/platforms/web/compiler/directives/model.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.CHECKBOX_RADIO_TOKEN = exports.RANGE_TOKEN = undefined;\nexports.default = model;\n\nvar _config = __webpack_require__(/*! core/config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _helpers = __webpack_require__(/*! compiler/helpers */ \"./src/compiler/helpers.js\");\n\nvar _model = __webpack_require__(/*! compiler/directives/model */ \"./src/compiler/directives/model.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar warn = void 0;\n\n// in some cases, the event used has to be determined at runtime\n// so we used some reserved tokens during compile.\n\n\nvar RANGE_TOKEN = exports.RANGE_TOKEN = '__r';\nvar CHECKBOX_RADIO_TOKEN = exports.CHECKBOX_RADIO_TOKEN = '__c';\n\nfunction model(el, dir, _warn) {\n  warn = _warn;\n  var value = dir.value;\n  var modifiers = dir.modifiers;\n  var tag = el.tag;\n  var type = el.attrsMap.type;\n\n  if (true) {\n    // inputs with type=\"file\" are read only and setting the input's\n    // value will throw an error.\n    if (tag === 'input' && type === 'file') {\n      warn('<' + el.tag + ' v-model=\"' + value + '\" type=\"file\">:\\n' + 'File inputs are read only. Use a v-on:change listener instead.');\n    }\n  }\n\n  if (el.component) {\n    (0, _model.genComponentModel)(el, value, modifiers);\n    // component v-model doesn't need extra runtime\n    return false;\n  } else if (tag === 'select') {\n    genSelect(el, value, modifiers);\n  } else if (tag === 'input' && type === 'checkbox') {\n    genCheckboxModel(el, value, modifiers);\n  } else if (tag === 'input' && type === 'radio') {\n    genRadioModel(el, value, modifiers);\n  } else if (tag === 'input' || tag === 'textarea') {\n    genDefaultModel(el, value, modifiers);\n  } else if (!_config2.default.isReservedTag(tag)) {\n    (0, _model.genComponentModel)(el, value, modifiers);\n    // component v-model doesn't need extra runtime\n    return false;\n  } else if (true) {\n    warn('<' + el.tag + ' v-model=\"' + value + '\">: ' + 'v-model is not supported on this element type. ' + 'If you are working with contenteditable, it\\'s recommended to ' + 'wrap a library dedicated for that purpose inside a custom component.');\n  }\n\n  // ensure runtime directive metadata\n  return true;\n}\n\nfunction genCheckboxModel(el, value, modifiers) {\n  var number = modifiers && modifiers.number;\n  var valueBinding = (0, _helpers.getBindingAttr)(el, 'value') || 'null';\n  var trueValueBinding = (0, _helpers.getBindingAttr)(el, 'true-value') || 'true';\n  var falseValueBinding = (0, _helpers.getBindingAttr)(el, 'false-value') || 'false';\n  (0, _helpers.addProp)(el, 'checked', 'Array.isArray(' + value + ')' + ('?_i(' + value + ',' + valueBinding + ')>-1') + (trueValueBinding === 'true' ? ':(' + value + ')' : ':_q(' + value + ',' + trueValueBinding + ')'));\n  (0, _helpers.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&&(' + (0, _model.genAssignmentCode)(value, '$$a.concat([$$v])') + ')}') + ('else{$$i>-1&&(' + (0, _model.genAssignmentCode)(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ')}') + ('}else{' + (0, _model.genAssignmentCode)(value, '$$c') + '}'), null, true);\n}\n\nfunction genRadioModel(el, value, modifiers) {\n  var number = modifiers && modifiers.number;\n  var valueBinding = (0, _helpers.getBindingAttr)(el, 'value') || 'null';\n  valueBinding = number ? '_n(' + valueBinding + ')' : valueBinding;\n  (0, _helpers.addProp)(el, 'checked', '_q(' + value + ',' + valueBinding + ')');\n  (0, _helpers.addHandler)(el, 'change', (0, _model.genAssignmentCode)(value, valueBinding), null, true);\n}\n\nfunction genSelect(el, value, modifiers) {\n  var number = modifiers && modifiers.number;\n  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') + '})');\n\n  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';\n  var code = 'var $$selectedVal = ' + selectedVal + ';';\n  code = code + ' ' + (0, _model.genAssignmentCode)(value, assignment);\n  (0, _helpers.addHandler)(el, 'change', code, null, true);\n}\n\nfunction genDefaultModel(el, value, modifiers) {\n  var type = el.attrsMap.type;\n\n  // warn if v-bind:value conflicts with v-model\n  // except for inputs with v-bind:type\n  if (true) {\n    var _value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];\n    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n    if (_value && !typeBinding) {\n      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';\n      warn(binding + '=\"' + _value + '\" conflicts with v-model on the same element ' + 'because the latter already expands to a value binding internally');\n    }\n  }\n\n  var _ref = modifiers || {},\n      lazy = _ref.lazy,\n      number = _ref.number,\n      trim = _ref.trim;\n\n  var needCompositionGuard = !lazy && type !== 'range';\n  var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';\n\n  var valueExpression = '$event.target.value';\n  if (trim) {\n    valueExpression = '$event.target.value.trim()';\n  }\n  if (number) {\n    valueExpression = '_n(' + valueExpression + ')';\n  }\n\n  var code = (0, _model.genAssignmentCode)(value, valueExpression);\n  if (needCompositionGuard) {\n    code = 'if($event.target.composing)return;' + code;\n  }\n\n  (0, _helpers.addProp)(el, 'value', '(' + value + ')');\n  (0, _helpers.addHandler)(el, event, code, null, true);\n  if (trim || number) {\n    (0, _helpers.addHandler)(el, 'blur', '$forceUpdate()');\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/directives/model.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/directives/text.js":
/*!*******************************************************!*\
  !*** ./src/platforms/web/compiler/directives/text.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = text;\n\nvar _helpers = __webpack_require__(/*! compiler/helpers */ \"./src/compiler/helpers.js\");\n\nfunction text(el, dir) {\n  if (dir.value) {\n    (0, _helpers.addProp)(el, 'textContent', '_s(' + dir.value + ')');\n  }\n}\n\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/directives/text.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/index.js":
/*!*********************************************!*\
  !*** ./src/platforms/web/compiler/index.js ***!
  \*********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.compileToFunctions = exports.compile = undefined;\n\nvar _options = __webpack_require__(/*! ./options */ \"./src/platforms/web/compiler/options.js\");\n\nvar _index = __webpack_require__(/*! compiler/index */ \"./src/compiler/index.js\");\n\nvar _createCompiler = (0, _index.createCompiler)(_options.baseOptions),\n    compile = _createCompiler.compile,\n    compileToFunctions = _createCompiler.compileToFunctions;\n\nexports.compile = compile;\nexports.compileToFunctions = compileToFunctions;\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/index.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/modules/class.js":
/*!*****************************************************!*\
  !*** ./src/platforms/web/compiler/modules/class.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _textParser = __webpack_require__(/*! compiler/parser/text-parser */ \"./src/compiler/parser/text-parser.js\");\n\nvar _helpers = __webpack_require__(/*! compiler/helpers */ \"./src/compiler/helpers.js\");\n\nfunction transformNode(el, options) {\n  var warn = options.warn || _helpers.baseWarn;\n  var staticClass = (0, _helpers.getAndRemoveAttr)(el, 'class');\n  if (\"development\" !== 'production' && staticClass) {\n    var res = (0, _textParser.parseText)(staticClass, options.delimiters);\n    if (res) {\n      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\">.');\n    }\n  }\n  if (staticClass) {\n    el.staticClass = JSON.stringify(staticClass);\n  }\n  var classBinding = (0, _helpers.getBindingAttr)(el, 'class', false /* getStatic */);\n  if (classBinding) {\n    el.classBinding = classBinding;\n  }\n}\n\nfunction genData(el) {\n  var data = '';\n  if (el.staticClass) {\n    data += 'staticClass:' + el.staticClass + ',';\n  }\n  if (el.classBinding) {\n    data += 'class:' + el.classBinding + ',';\n  }\n  return data;\n}\n\nexports.default = {\n  staticKeys: ['staticClass'],\n  transformNode: transformNode,\n  genData: genData\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/modules/class.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/modules/index.js":
/*!*****************************************************!*\
  !*** ./src/platforms/web/compiler/modules/index.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _class = __webpack_require__(/*! ./class */ \"./src/platforms/web/compiler/modules/class.js\");\n\nvar _class2 = _interopRequireDefault(_class);\n\nvar _style = __webpack_require__(/*! ./style */ \"./src/platforms/web/compiler/modules/style.js\");\n\nvar _style2 = _interopRequireDefault(_style);\n\nvar _model = __webpack_require__(/*! ./model */ \"./src/platforms/web/compiler/modules/model.js\");\n\nvar _model2 = _interopRequireDefault(_model);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = [_class2.default, _style2.default, _model2.default];\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/modules/index.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/modules/model.js":
/*!*****************************************************!*\
  !*** ./src/platforms/web/compiler/modules/model.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _helpers = __webpack_require__(/*! compiler/helpers */ \"./src/compiler/helpers.js\");\n\nvar _index = __webpack_require__(/*! compiler/parser/index */ \"./src/compiler/parser/index.js\");\n\n/**\n * Expand input[v-model] with dyanmic type bindings into v-if-else chains\n * Turn this:\n *   <input v-model=\"data[type]\" :type=\"type\">\n * into this:\n *   <input v-if=\"type === 'checkbox'\" type=\"checkbox\" v-model=\"data[type]\">\n *   <input v-else-if=\"type === 'radio'\" type=\"radio\" v-model=\"data[type]\">\n *   <input v-else :type=\"type\" v-model=\"data[type]\">\n */\n\nfunction preTransformNode(el, options) {\n  if (el.tag === 'input') {\n    var map = el.attrsMap;\n    if (!map['v-model']) {\n      return;\n    }\n\n    var typeBinding = void 0;\n    if (map[':type'] || map['v-bind:type']) {\n      typeBinding = (0, _helpers.getBindingAttr)(el, 'type');\n    }\n    if (!map.type && !typeBinding && map['v-bind']) {\n      typeBinding = '(' + map['v-bind'] + ').type';\n    }\n\n    if (typeBinding) {\n      var ifCondition = (0, _helpers.getAndRemoveAttr)(el, 'v-if', true);\n      var ifConditionExtra = ifCondition ? '&&(' + ifCondition + ')' : '';\n      var hasElse = (0, _helpers.getAndRemoveAttr)(el, 'v-else', true) != null;\n      var elseIfCondition = (0, _helpers.getAndRemoveAttr)(el, 'v-else-if', true);\n      // 1. checkbox\n      var branch0 = cloneASTElement(el);\n      // process for on the main node\n      (0, _index.processFor)(branch0);\n      (0, _helpers.addRawAttr)(branch0, 'type', 'checkbox');\n      (0, _index.processElement)(branch0, options);\n      branch0.processed = true; // prevent it from double-processed\n      branch0.if = '(' + typeBinding + ')===\\'checkbox\\'' + ifConditionExtra;\n      (0, _index.addIfCondition)(branch0, {\n        exp: branch0.if,\n        block: branch0\n      });\n      // 2. add radio else-if condition\n      var branch1 = cloneASTElement(el);\n      (0, _helpers.getAndRemoveAttr)(branch1, 'v-for', true);\n      (0, _helpers.addRawAttr)(branch1, 'type', 'radio');\n      (0, _index.processElement)(branch1, options);\n      (0, _index.addIfCondition)(branch0, {\n        exp: '(' + typeBinding + ')===\\'radio\\'' + ifConditionExtra,\n        block: branch1\n      });\n      // 3. other\n      var branch2 = cloneASTElement(el);\n      (0, _helpers.getAndRemoveAttr)(branch2, 'v-for', true);\n      (0, _helpers.addRawAttr)(branch2, ':type', typeBinding);\n      (0, _index.processElement)(branch2, options);\n      (0, _index.addIfCondition)(branch0, {\n        exp: ifCondition,\n        block: branch2\n      });\n\n      if (hasElse) {\n        branch0.else = true;\n      } else if (elseIfCondition) {\n        branch0.elseif = elseIfCondition;\n      }\n\n      return branch0;\n    }\n  }\n}\n\nfunction cloneASTElement(el) {\n  return (0, _index.createASTElement)(el.tag, el.attrsList.slice(), el.parent);\n}\n\nexports.default = {\n  preTransformNode: preTransformNode\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/modules/model.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/modules/style.js":
/*!*****************************************************!*\
  !*** ./src/platforms/web/compiler/modules/style.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _textParser = __webpack_require__(/*! compiler/parser/text-parser */ \"./src/compiler/parser/text-parser.js\");\n\nvar _style = __webpack_require__(/*! web/util/style */ \"./src/platforms/web/util/style.js\");\n\nvar _helpers = __webpack_require__(/*! compiler/helpers */ \"./src/compiler/helpers.js\");\n\nfunction transformNode(el, options) {\n  var warn = options.warn || _helpers.baseWarn;\n  var staticStyle = (0, _helpers.getAndRemoveAttr)(el, 'style');\n  if (staticStyle) {\n    /* istanbul ignore if */\n    if (true) {\n      var res = (0, _textParser.parseText)(staticStyle, options.delimiters);\n      if (res) {\n        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\">.');\n      }\n    }\n    el.staticStyle = JSON.stringify((0, _style.parseStyleText)(staticStyle));\n  }\n\n  var styleBinding = (0, _helpers.getBindingAttr)(el, 'style', false /* getStatic */);\n  if (styleBinding) {\n    el.styleBinding = styleBinding;\n  }\n}\n\nfunction genData(el) {\n  var data = '';\n  if (el.staticStyle) {\n    data += 'staticStyle:' + el.staticStyle + ',';\n  }\n  if (el.styleBinding) {\n    data += 'style:(' + el.styleBinding + '),';\n  }\n  return data;\n}\n\nexports.default = {\n  staticKeys: ['staticStyle'],\n  transformNode: transformNode,\n  genData: genData\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/modules/style.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/options.js":
/*!***********************************************!*\
  !*** ./src/platforms/web/compiler/options.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.baseOptions = undefined;\n\nvar _index = __webpack_require__(/*! ../util/index */ \"./src/platforms/web/util/index.js\");\n\nvar _index2 = __webpack_require__(/*! ./modules/index */ \"./src/platforms/web/compiler/modules/index.js\");\n\nvar _index3 = _interopRequireDefault(_index2);\n\nvar _index4 = __webpack_require__(/*! ./directives/index */ \"./src/platforms/web/compiler/directives/index.js\");\n\nvar _index5 = _interopRequireDefault(_index4);\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _util2 = __webpack_require__(/*! ./util */ \"./src/platforms/web/compiler/util.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar baseOptions = exports.baseOptions = {\n  expectHTML: true,\n  modules: _index3.default,\n  directives: _index5.default,\n  isPreTag: _index.isPreTag,\n  isUnaryTag: _util2.isUnaryTag,\n  mustUseProp: _index.mustUseProp,\n  canBeLeftOpenTag: _util2.canBeLeftOpenTag,\n  isReservedTag: _index.isReservedTag,\n  getTagNamespace: _index.getTagNamespace,\n  staticKeys: (0, _util.genStaticKeys)(_index3.default)\n};\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/options.js?");

/***/ }),

/***/ "./src/platforms/web/compiler/util.js":
/*!********************************************!*\
  !*** ./src/platforms/web/compiler/util.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isNonPhrasingTag = exports.canBeLeftOpenTag = exports.isUnaryTag = undefined;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar isUnaryTag = exports.isUnaryTag = (0, _util.makeMap)('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' + 'link,meta,param,source,track,wbr');\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\n\n\nvar canBeLeftOpenTag = exports.canBeLeftOpenTag = (0, _util.makeMap)('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');\n\n// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3\n// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content\nvar isNonPhrasingTag = exports.isNonPhrasingTag = (0, _util.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');\n\n//# sourceURL=webpack://Vue/./src/platforms/web/compiler/util.js?");

/***/ }),

/***/ "./src/platforms/web/entry-runtime-with-compiler.js":
/*!**********************************************************!*\
  !*** ./src/platforms/web/entry-runtime-with-compiler.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _config = __webpack_require__(/*! core/config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _perf = __webpack_require__(/*! core/util/perf */ \"./src/core/util/perf.js\");\n\nvar _index2 = __webpack_require__(/*! ./runtime/index */ \"./src/platforms/web/runtime/index.js\");\n\nvar _index3 = _interopRequireDefault(_index2);\n\nvar _index4 = __webpack_require__(/*! ./util/index */ \"./src/platforms/web/util/index.js\");\n\nvar _index5 = __webpack_require__(/*! ./compiler/index */ \"./src/platforms/web/compiler/index.js\");\n\nvar _compat = __webpack_require__(/*! ./util/compat */ \"./src/platforms/web/util/compat.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar idToTemplate = (0, _index.cached)(function (id) {\n  var el = (0, _index4.query)(id);\n  return el && el.innerHTML;\n});\n\nvar mount = _index3.default.prototype.$mount;\n_index3.default.prototype.$mount = function (el, hydrating) {\n  el = el && (0, _index4.query)(el);\n\n  /* istanbul ignore if */\n  if (el === document.body || el === document.documentElement) {\n    \"development\" !== 'production' && (0, _index.warn)('Do not mount Vue to <html> or <body> - mount to normal elements instead.');\n    return this;\n  }\n\n  var options = this.$options;\n  // resolve template/el and convert to render function\n  if (!options.render) {\n    var template = options.template;\n    if (template) {\n      if (typeof template === 'string') {\n        if (template.charAt(0) === '#') {\n          template = idToTemplate(template);\n          /* istanbul ignore if */\n          if (\"development\" !== 'production' && !template) {\n            (0, _index.warn)('Template element not found or is empty: ' + options.template, this);\n          }\n        }\n      } else if (template.nodeType) {\n        template = template.innerHTML;\n      } else {\n        if (true) {\n          (0, _index.warn)('invalid template option:' + template, this);\n        }\n        return this;\n      }\n    } else if (el) {\n      template = getOuterHTML(el);\n    }\n    if (template) {\n      /* istanbul ignore if */\n      if (\"development\" !== 'production' && _config2.default.performance && _perf.mark) {\n        (0, _perf.mark)('compile');\n      }\n\n      var _compileToFunctions = (0, _index5.compileToFunctions)(template, {\n        shouldDecodeNewlines: _compat.shouldDecodeNewlines,\n        shouldDecodeNewlinesForHref: _compat.shouldDecodeNewlinesForHref,\n        delimiters: options.delimiters,\n        comments: options.comments\n      }, this),\n          render = _compileToFunctions.render,\n          staticRenderFns = _compileToFunctions.staticRenderFns;\n\n      options.render = render;\n      options.staticRenderFns = staticRenderFns;\n\n      /* istanbul ignore if */\n      if (\"development\" !== 'production' && _config2.default.performance && _perf.mark) {\n        (0, _perf.mark)('compile end');\n        (0, _perf.measure)('vue ' + this._name + ' compile', 'compile', 'compile end');\n      }\n    }\n  }\n  return mount.call(this, el, hydrating);\n};\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n */\nfunction getOuterHTML(el) {\n  if (el.outerHTML) {\n    return el.outerHTML;\n  } else {\n    var container = document.createElement('div');\n    container.appendChild(el.cloneNode(true));\n    return container.innerHTML;\n  }\n}\n\n_index3.default.compile = _index5.compileToFunctions;\n\nexports.default = _index3.default;\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/entry-runtime-with-compiler.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/class-util.js":
/*!*************************************************!*\
  !*** ./src/platforms/web/runtime/class-util.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.addClass = addClass;\nexports.removeClass = removeClass;\n\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass(el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !(cls = cls.trim())) {\n    return;\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(/\\s+/).forEach(function (c) {\n        return el.classList.add(c);\n      });\n    } else {\n      el.classList.add(cls);\n    }\n  } else {\n    var cur = ' ' + (el.getAttribute('class') || '') + ' ';\n    if (cur.indexOf(' ' + cls + ' ') < 0) {\n      el.setAttribute('class', (cur + cls).trim());\n    }\n  }\n}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass(el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !(cls = cls.trim())) {\n    return;\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(/\\s+/).forEach(function (c) {\n        return el.classList.remove(c);\n      });\n    } else {\n      el.classList.remove(cls);\n    }\n    if (!el.classList.length) {\n      el.removeAttribute('class');\n    }\n  } else {\n    var cur = ' ' + (el.getAttribute('class') || '') + ' ';\n    var tar = ' ' + cls + ' ';\n    while (cur.indexOf(tar) >= 0) {\n      cur = cur.replace(tar, ' ');\n    }\n    cur = cur.trim();\n    if (cur) {\n      el.setAttribute('class', cur);\n    } else {\n      el.removeAttribute('class');\n    }\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/class-util.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/components/index.js":
/*!*******************************************************!*\
  !*** ./src/platforms/web/runtime/components/index.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _transition = __webpack_require__(/*! ./transition */ \"./src/platforms/web/runtime/components/transition.js\");\n\nvar _transition2 = _interopRequireDefault(_transition);\n\nvar _transitionGroup = __webpack_require__(/*! ./transition-group */ \"./src/platforms/web/runtime/components/transition-group.js\");\n\nvar _transitionGroup2 = _interopRequireDefault(_transitionGroup);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = {\n  Transition: _transition2.default,\n  TransitionGroup: _transitionGroup2.default\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/components/index.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/components/transition-group.js":
/*!******************************************************************!*\
  !*** ./src/platforms/web/runtime/components/transition-group.js ***!
  \******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _classUtil = __webpack_require__(/*! ../class-util */ \"./src/platforms/web/runtime/class-util.js\");\n\nvar _transition = __webpack_require__(/*! ./transition */ \"./src/platforms/web/runtime/components/transition.js\");\n\nvar _transitionUtil = __webpack_require__(/*! ../transition-util */ \"./src/platforms/web/runtime/transition-util.js\");\n\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final desired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = (0, _index.extend)({\n  tag: String,\n  moveClass: String\n}, _transition.transitionProps);\n\ndelete props.mode;\n\nexports.default = {\n  props: props,\n\n  render: function render(h) {\n    var tag = this.tag || this.$vnode.data.tag || 'span';\n    var map = Object.create(null);\n    var prevChildren = this.prevChildren = this.children;\n    var rawChildren = this.$slots.default || [];\n    var children = this.children = [];\n    var transitionData = (0, _transition.extractTransitionData)(this);\n\n    for (var i = 0; i < rawChildren.length; i++) {\n      var c = rawChildren[i];\n      if (c.tag) {\n        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n          children.push(c);\n          map[c.key] = c;(c.data || (c.data = {})).transition = transitionData;\n        } else if (true) {\n          var opts = c.componentOptions;\n          var name = opts ? opts.Ctor.options.name || opts.tag || '' : c.tag;\n          (0, _index.warn)('<transition-group> children must be keyed: <' + name + '>');\n        }\n      }\n    }\n\n    if (prevChildren) {\n      var kept = [];\n      var removed = [];\n      for (var _i = 0; _i < prevChildren.length; _i++) {\n        var _c = prevChildren[_i];\n        _c.data.transition = transitionData;\n        _c.data.pos = _c.elm.getBoundingClientRect();\n        if (map[_c.key]) {\n          kept.push(_c);\n        } else {\n          removed.push(_c);\n        }\n      }\n      this.kept = h(tag, null, kept);\n      this.removed = removed;\n    }\n\n    return h(tag, null, children);\n  },\n  beforeUpdate: function beforeUpdate() {\n    // force removing pass\n    this.__patch__(this._vnode, this.kept, false, // hydrating\n    true // removeOnly (!important, avoids unnecessary moves)\n    );\n    this._vnode = this.kept;\n  },\n  updated: function updated() {\n    var children = this.prevChildren;\n    var moveClass = this.moveClass || (this.name || 'v') + '-move';\n    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n      return;\n    }\n\n    // we divide the work into three loops to avoid mixing DOM reads and writes\n    // in each iteration - which helps prevent layout thrashing.\n    children.forEach(callPendingCbs);\n    children.forEach(recordPosition);\n    children.forEach(applyTranslation);\n\n    // force reflow to put everything in position\n    // assign to this to avoid being removed in tree-shaking\n    // $flow-disable-line\n    this._reflow = document.body.offsetHeight;\n\n    children.forEach(function (c) {\n      if (c.data.moved) {\n        var el = c.elm;\n        var s = el.style;\n        (0, _transitionUtil.addTransitionClass)(el, moveClass);\n        s.transform = s.WebkitTransform = s.transitionDuration = '';\n        el.addEventListener(_transitionUtil.transitionEndEvent, el._moveCb = function cb(e) {\n          if (!e || /transform$/.test(e.propertyName)) {\n            el.removeEventListener(_transitionUtil.transitionEndEvent, cb);\n            el._moveCb = null;\n            (0, _transitionUtil.removeTransitionClass)(el, moveClass);\n          }\n        });\n      }\n    });\n  },\n\n\n  methods: {\n    hasMove: function hasMove(el, moveClass) {\n      /* istanbul ignore if */\n      if (!_transitionUtil.hasTransition) {\n        return false;\n      }\n      /* istanbul ignore if */\n      if (this._hasMove) {\n        return this._hasMove;\n      }\n      // Detect whether an element with the move class applied has\n      // CSS transitions. Since the element may be inside an entering\n      // transition at this very moment, we make a clone of it and remove\n      // all other transition classes applied to ensure only the move class\n      // is applied.\n      var clone = el.cloneNode();\n      if (el._transitionClasses) {\n        el._transitionClasses.forEach(function (cls) {\n          (0, _classUtil.removeClass)(clone, cls);\n        });\n      }\n      (0, _classUtil.addClass)(clone, moveClass);\n      clone.style.display = 'none';\n      this.$el.appendChild(clone);\n      var info = (0, _transitionUtil.getTransitionInfo)(clone);\n      this.$el.removeChild(clone);\n      return this._hasMove = info.hasTransform;\n    }\n  }\n};\n\n\nfunction callPendingCbs(c) {\n  /* istanbul ignore if */\n  if (c.elm._moveCb) {\n    c.elm._moveCb();\n  }\n  /* istanbul ignore if */\n  if (c.elm._enterCb) {\n    c.elm._enterCb();\n  }\n}\n\nfunction recordPosition(c) {\n  c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation(c) {\n  var oldPos = c.data.pos;\n  var newPos = c.data.newPos;\n  var dx = oldPos.left - newPos.left;\n  var dy = oldPos.top - newPos.top;\n  if (dx || dy) {\n    c.data.moved = true;\n    var s = c.elm.style;\n    s.transform = s.WebkitTransform = 'translate(' + dx + 'px,' + dy + 'px)';\n    s.transitionDuration = '0s';\n  }\n}\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/components/transition-group.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/components/transition.js":
/*!************************************************************!*\
  !*** ./src/platforms/web/runtime/components/transition.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.transitionProps = undefined;\nexports.extractTransitionData = extractTransitionData;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _index2 = __webpack_require__(/*! core/vdom/helpers/index */ \"./src/core/vdom/helpers/index.js\");\n\nvar transitionProps = exports.transitionProps = {\n  name: String,\n  appear: Boolean,\n  css: Boolean,\n  mode: String,\n  type: String,\n  enterClass: String,\n  leaveClass: String,\n  enterToClass: String,\n  leaveToClass: String,\n  enterActiveClass: String,\n  leaveActiveClass: String,\n  appearClass: String,\n  appearActiveClass: String,\n  appearToClass: String,\n  duration: [Number, String, Object]\n\n  // in case the child is also an abstract component, e.g. <keep-alive>\n  // we want to recursively retrieve the real component to be rendered\n};\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\n\nfunction getRealChild(vnode) {\n  var compOptions = vnode && vnode.componentOptions;\n  if (compOptions && compOptions.Ctor.options.abstract) {\n    return getRealChild((0, _index2.getFirstComponentChild)(compOptions.children));\n  } else {\n    return vnode;\n  }\n}\n\nfunction extractTransitionData(comp) {\n  var data = {};\n  var options = comp.$options;\n  // props\n  for (var key in options.propsData) {\n    data[key] = comp[key];\n  }\n  // events.\n  // extract listeners and pass them directly to the transition methods\n  var listeners = options._parentListeners;\n  for (var _key in listeners) {\n    data[(0, _util.camelize)(_key)] = listeners[_key];\n  }\n  return data;\n}\n\nfunction placeholder(h, rawChild) {\n  if (/\\d-keep-alive$/.test(rawChild.tag)) {\n    return h('keep-alive', {\n      props: rawChild.componentOptions.propsData\n    });\n  }\n}\n\nfunction hasParentTransition(vnode) {\n  while (vnode = vnode.parent) {\n    if (vnode.data.transition) {\n      return true;\n    }\n  }\n}\n\nfunction isSameChild(child, oldChild) {\n  return oldChild.key === child.key && oldChild.tag === child.tag;\n}\n\nexports.default = {\n  name: 'transition',\n  props: transitionProps,\n  abstract: true,\n\n  render: function render(h) {\n    var _this = this;\n\n    var children = this.$slots.default;\n    if (!children) {\n      return;\n    }\n\n    // filter out text nodes (possible whitespaces)\n    children = children.filter(function (c) {\n      return c.tag || (0, _index2.isAsyncPlaceholder)(c);\n    });\n    /* istanbul ignore if */\n    if (!children.length) {\n      return;\n    }\n\n    // warn multiple elements\n    if (\"development\" !== 'production' && children.length > 1) {\n      (0, _index.warn)('<transition> can only be used on a single element. Use ' + '<transition-group> for lists.', this.$parent);\n    }\n\n    var mode = this.mode;\n\n    // warn invalid mode\n    if (\"development\" !== 'production' && mode && mode !== 'in-out' && mode !== 'out-in') {\n      (0, _index.warn)('invalid <transition> mode: ' + mode, this.$parent);\n    }\n\n    var rawChild = children[0];\n\n    // if this is a component root node and the component's\n    // parent container node also has transition, skip.\n    if (hasParentTransition(this.$vnode)) {\n      return rawChild;\n    }\n\n    // apply transition data to child\n    // use getRealChild() to ignore abstract components e.g. keep-alive\n    var child = getRealChild(rawChild);\n    /* istanbul ignore if */\n    if (!child) {\n      return rawChild;\n    }\n\n    if (this._leaving) {\n      return placeholder(h, rawChild);\n    }\n\n    // ensure a key that is unique to the vnode type and to this transition\n    // component instance. This key will be used to remove pending leaving nodes\n    // during entering.\n    var id = '__transition-' + this._uid + '-';\n    child.key = child.key == null ? child.isComment ? id + 'comment' : id + child.tag : (0, _util.isPrimitive)(child.key) ? String(child.key).indexOf(id) === 0 ? child.key : id + child.key : child.key;\n\n    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n    var oldRawChild = this._vnode;\n    var oldChild = getRealChild(oldRawChild);\n\n    // mark v-show\n    // so that the transition module can hand over the control to the directive\n    if (child.data.directives && child.data.directives.some(function (d) {\n      return d.name === 'show';\n    })) {\n      child.data.show = true;\n    }\n\n    if (oldChild && oldChild.data && !isSameChild(child, oldChild) && !(0, _index2.isAsyncPlaceholder)(oldChild) &&\n    // #6687 component root is a comment node\n    !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)) {\n      // replace old child transition data with fresh one\n      var oldData = oldChild.data.transition = (0, _util.extend)({}, data);\n      // handle transition mode\n      if (mode === 'out-in') {\n        // return placeholder node and queue update when leave finishes\n        this._leaving = true;\n        (0, _index2.mergeVNodeHook)(oldData, 'afterLeave', function () {\n          _this._leaving = false;\n          _this.$forceUpdate();\n        });\n        return placeholder(h, rawChild);\n      } else if (mode === 'in-out') {\n        if ((0, _index2.isAsyncPlaceholder)(child)) {\n          return oldRawChild;\n        }\n        var delayedLeave = void 0;\n        var performLeave = function performLeave() {\n          delayedLeave();\n        };\n        (0, _index2.mergeVNodeHook)(data, 'afterEnter', performLeave);\n        (0, _index2.mergeVNodeHook)(data, 'enterCancelled', performLeave);\n        (0, _index2.mergeVNodeHook)(oldData, 'delayLeave', function (leave) {\n          delayedLeave = leave;\n        });\n      }\n    }\n\n    return rawChild;\n  }\n};\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/components/transition.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/directives/index.js":
/*!*******************************************************!*\
  !*** ./src/platforms/web/runtime/directives/index.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _model = __webpack_require__(/*! ./model */ \"./src/platforms/web/runtime/directives/model.js\");\n\nvar _model2 = _interopRequireDefault(_model);\n\nvar _show = __webpack_require__(/*! ./show */ \"./src/platforms/web/runtime/directives/show.js\");\n\nvar _show2 = _interopRequireDefault(_show);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = {\n  model: _model2.default,\n  show: _show2.default\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/directives/index.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/directives/model.js":
/*!*******************************************************!*\
  !*** ./src/platforms/web/runtime/directives/model.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _element = __webpack_require__(/*! web/util/element */ \"./src/platforms/web/util/element.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _index = __webpack_require__(/*! core/vdom/helpers/index */ \"./src/core/vdom/helpers/index.js\");\n\nvar _index2 = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\n/* istanbul ignore if */\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\nif (_index2.isIE9) {\n  // http://www.matts411.com/post/internet-explorer-9-oninput/\n  document.addEventListener('selectionchange', function () {\n    var el = document.activeElement;\n    if (el && el.vmodel) {\n      trigger(el, 'input');\n    }\n  });\n}\n\nvar directive = {\n  inserted: function inserted(el, binding, vnode, oldVnode) {\n    if (vnode.tag === 'select') {\n      // #6903\n      if (oldVnode.elm && !oldVnode.elm._vOptions) {\n        (0, _index.mergeVNodeHook)(vnode, 'postpatch', function () {\n          directive.componentUpdated(el, binding, vnode);\n        });\n      } else {\n        setSelected(el, binding, vnode.context);\n      }\n      el._vOptions = [].map.call(el.options, getValue);\n    } else if (vnode.tag === 'textarea' || (0, _element.isTextInputType)(el.type)) {\n      el._vModifiers = binding.modifiers;\n      if (!binding.modifiers.lazy) {\n        el.addEventListener('compositionstart', onCompositionStart);\n        el.addEventListener('compositionend', onCompositionEnd);\n        // Safari < 10.2 & UIWebView doesn't fire compositionend when\n        // switching focus before confirming composition choice\n        // this also fixes the issue where some browsers e.g. iOS Chrome\n        // fires \"change\" instead of \"input\" on autocomplete.\n        el.addEventListener('change', onCompositionEnd);\n        /* istanbul ignore if */\n        if (_index2.isIE9) {\n          el.vmodel = true;\n        }\n      }\n    }\n  },\n  componentUpdated: function componentUpdated(el, binding, vnode) {\n    if (vnode.tag === 'select') {\n      setSelected(el, binding, vnode.context);\n      // in case the options rendered by v-for have changed,\n      // it's possible that the value is out-of-sync with the rendered options.\n      // detect such cases and filter out values that no longer has a matching\n      // option in the DOM.\n      var prevOptions = el._vOptions;\n      var curOptions = el._vOptions = [].map.call(el.options, getValue);\n      if (curOptions.some(function (o, i) {\n        return !(0, _util.looseEqual)(o, prevOptions[i]);\n      })) {\n        // trigger change event if\n        // no matching option found for at least one value\n        var needReset = el.multiple ? binding.value.some(function (v) {\n          return hasNoMatchingOption(v, curOptions);\n        }) : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);\n        if (needReset) {\n          trigger(el, 'change');\n        }\n      }\n    }\n  }\n};\n\nfunction setSelected(el, binding, vm) {\n  actuallySetSelected(el, binding, vm);\n  /* istanbul ignore if */\n  if (_index2.isIE || _index2.isEdge) {\n    setTimeout(function () {\n      actuallySetSelected(el, binding, vm);\n    }, 0);\n  }\n}\n\nfunction actuallySetSelected(el, binding, vm) {\n  var value = binding.value;\n  var isMultiple = el.multiple;\n  if (isMultiple && !Array.isArray(value)) {\n    \"development\" !== 'production' && (0, _index2.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);\n    return;\n  }\n  var selected = void 0,\n      option = void 0;\n  for (var i = 0, l = el.options.length; i < l; i++) {\n    option = el.options[i];\n    if (isMultiple) {\n      selected = (0, _util.looseIndexOf)(value, getValue(option)) > -1;\n      if (option.selected !== selected) {\n        option.selected = selected;\n      }\n    } else {\n      if ((0, _util.looseEqual)(getValue(option), value)) {\n        if (el.selectedIndex !== i) {\n          el.selectedIndex = i;\n        }\n        return;\n      }\n    }\n  }\n  if (!isMultiple) {\n    el.selectedIndex = -1;\n  }\n}\n\nfunction hasNoMatchingOption(value, options) {\n  return options.every(function (o) {\n    return !(0, _util.looseEqual)(o, value);\n  });\n}\n\nfunction getValue(option) {\n  return '_value' in option ? option._value : option.value;\n}\n\nfunction onCompositionStart(e) {\n  e.target.composing = true;\n}\n\nfunction onCompositionEnd(e) {\n  // prevent triggering an input event for no reason\n  if (!e.target.composing) return;\n  e.target.composing = false;\n  trigger(e.target, 'input');\n}\n\nfunction trigger(el, type) {\n  var e = document.createEvent('HTMLEvents');\n  e.initEvent(type, true, true);\n  el.dispatchEvent(e);\n}\n\nexports.default = directive;\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/directives/model.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/directives/show.js":
/*!******************************************************!*\
  !*** ./src/platforms/web/runtime/directives/show.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _transition = __webpack_require__(/*! ../modules/transition */ \"./src/platforms/web/runtime/modules/transition.js\");\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode(vnode) {\n  return vnode.componentInstance && (!vnode.data || !vnode.data.transition) ? locateNode(vnode.componentInstance._vnode) : vnode;\n}\n\nexports.default = {\n  bind: function bind(el, _ref, vnode) {\n    var value = _ref.value;\n\n    vnode = locateNode(vnode);\n    var transition = vnode.data && vnode.data.transition;\n    var originalDisplay = el.__vOriginalDisplay = el.style.display === 'none' ? '' : el.style.display;\n    if (value && transition) {\n      vnode.data.show = true;\n      (0, _transition.enter)(vnode, function () {\n        el.style.display = originalDisplay;\n      });\n    } else {\n      el.style.display = value ? originalDisplay : 'none';\n    }\n  },\n  update: function update(el, _ref2, vnode) {\n    var value = _ref2.value,\n        oldValue = _ref2.oldValue;\n\n    /* istanbul ignore if */\n    if (!value === !oldValue) return;\n    vnode = locateNode(vnode);\n    var transition = vnode.data && vnode.data.transition;\n    if (transition) {\n      vnode.data.show = true;\n      if (value) {\n        (0, _transition.enter)(vnode, function () {\n          el.style.display = el.__vOriginalDisplay;\n        });\n      } else {\n        (0, _transition.leave)(vnode, function () {\n          el.style.display = 'none';\n        });\n      }\n    } else {\n      el.style.display = value ? el.__vOriginalDisplay : 'none';\n    }\n  },\n  unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {\n    if (!isDestroy) {\n      el.style.display = el.__vOriginalDisplay;\n    }\n  }\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/directives/show.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/index.js":
/*!********************************************!*\
  !*** ./src/platforms/web/runtime/index.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _index = __webpack_require__(/*! core/index */ \"./src/core/index.js\");\n\nvar _index2 = _interopRequireDefault(_index);\n\nvar _config = __webpack_require__(/*! core/config */ \"./src/core/config.js\");\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _lifecycle = __webpack_require__(/*! core/instance/lifecycle */ \"./src/core/instance/lifecycle.js\");\n\nvar _index3 = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _index4 = __webpack_require__(/*! web/util/index */ \"./src/platforms/web/util/index.js\");\n\nvar _patch = __webpack_require__(/*! ./patch */ \"./src/platforms/web/runtime/patch.js\");\n\nvar _index5 = __webpack_require__(/*! ./directives/index */ \"./src/platforms/web/runtime/directives/index.js\");\n\nvar _index6 = _interopRequireDefault(_index5);\n\nvar _index7 = __webpack_require__(/*! ./components/index */ \"./src/platforms/web/runtime/components/index.js\");\n\nvar _index8 = _interopRequireDefault(_index7);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// install platform specific utils\n_index2.default.config.mustUseProp = _index4.mustUseProp;\n\n_index2.default.config.isReservedTag = _index4.isReservedTag;\n_index2.default.config.isReservedAttr = _index4.isReservedAttr;\n_index2.default.config.getTagNamespace = _index4.getTagNamespace;\n_index2.default.config.isUnknownElement = _index4.isUnknownElement;\n\n// install platform runtime directives & components\n(0, _util.extend)(_index2.default.options.directives, _index6.default);\n(0, _util.extend)(_index2.default.options.components, _index8.default);\n\n// install platform patch function\n_index2.default.prototype.__patch__ = _index3.inBrowser ? _patch.patch : _util.noop;\n\n// public mount method\n_index2.default.prototype.$mount = function (el, hydrating) {\n  el = el && _index3.inBrowser ? (0, _index4.query)(el) : undefined;\n  return (0, _lifecycle.mountComponent)(this, el, hydrating);\n};\n\n// devtools global hook\n/* istanbul ignore next */\nif (_index3.inBrowser) {\n  setTimeout(function () {\n    if (_config2.default.devtools) {\n      if (_index3.devtools) {\n        _index3.devtools.emit('init', _index2.default);\n      } else if (\"development\" !== 'production' && \"development\" !== 'test' && _index3.isChrome) {\n        console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\\n' + 'https://github.com/vuejs/vue-devtools');\n      }\n    }\n    if (\"development\" !== 'production' && \"development\" !== 'test' && _config2.default.productionTip !== false && typeof console !== 'undefined') {\n      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');\n    }\n  }, 0);\n}\n\nexports.default = _index2.default;\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/index.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/modules/attrs.js":
/*!****************************************************!*\
  !*** ./src/platforms/web/runtime/modules/attrs.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _env = __webpack_require__(/*! core/util/env */ \"./src/core/util/env.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _index = __webpack_require__(/*! web/util/index */ \"./src/platforms/web/util/index.js\");\n\nfunction updateAttrs(oldVnode, vnode) {\n  var opts = vnode.componentOptions;\n  if ((0, _util.isDef)(opts) && opts.Ctor.options.inheritAttrs === false) {\n    return;\n  }\n  if ((0, _util.isUndef)(oldVnode.data.attrs) && (0, _util.isUndef)(vnode.data.attrs)) {\n    return;\n  }\n  var key = void 0,\n      cur = void 0,\n      old = void 0;\n  var elm = vnode.elm;\n  var oldAttrs = oldVnode.data.attrs || {};\n  var attrs = vnode.data.attrs || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if ((0, _util.isDef)(attrs.__ob__)) {\n    attrs = vnode.data.attrs = (0, _util.extend)({}, attrs);\n  }\n\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      setAttr(elm, key, cur);\n    }\n  }\n  // #4391: in IE9, setting type can reset value for input[type=radio]\n  // #6666: IE/Edge forces progress value down to 1 before setting a max\n  /* istanbul ignore if */\n  if ((_env.isIE || _env.isEdge) && attrs.value !== oldAttrs.value) {\n    setAttr(elm, 'value', attrs.value);\n  }\n  for (key in oldAttrs) {\n    if ((0, _util.isUndef)(attrs[key])) {\n      if ((0, _index.isXlink)(key)) {\n        elm.removeAttributeNS(_index.xlinkNS, (0, _index.getXlinkProp)(key));\n      } else if (!(0, _index.isEnumeratedAttr)(key)) {\n        elm.removeAttribute(key);\n      }\n    }\n  }\n}\n\nfunction setAttr(el, key, value) {\n  if (el.tagName.indexOf('-') > -1) {\n    baseSetAttr(el, key, value);\n  } else if ((0, _index.isBooleanAttr)(key)) {\n    // set attribute for blank value\n    // e.g. <option disabled>Select one</option>\n    if ((0, _index.isFalsyAttrValue)(value)) {\n      el.removeAttribute(key);\n    } else {\n      // technically allowfullscreen is a boolean attribute for <iframe>,\n      // but Flash expects a value of \"true\" when used on <embed> tag\n      value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;\n      el.setAttribute(key, value);\n    }\n  } else if ((0, _index.isEnumeratedAttr)(key)) {\n    el.setAttribute(key, (0, _index.isFalsyAttrValue)(value) || value === 'false' ? 'false' : 'true');\n  } else if ((0, _index.isXlink)(key)) {\n    if ((0, _index.isFalsyAttrValue)(value)) {\n      el.removeAttributeNS(_index.xlinkNS, (0, _index.getXlinkProp)(key));\n    } else {\n      el.setAttributeNS(_index.xlinkNS, key, value);\n    }\n  } else {\n    baseSetAttr(el, key, value);\n  }\n}\n\nfunction baseSetAttr(el, key, value) {\n  if ((0, _index.isFalsyAttrValue)(value)) {\n    el.removeAttribute(key);\n  } else {\n    // #7138: IE10 & 11 fires input event when setting placeholder on\n    // <textarea>... block the first input event and remove the blocker\n    // immediately.\n    /* istanbul ignore if */\n    if (_env.isIE && !_env.isIE9 && el.tagName === 'TEXTAREA' && key === 'placeholder' && !el.__ieph) {\n      var blocker = function blocker(e) {\n        e.stopImmediatePropagation();\n        el.removeEventListener('input', blocker);\n      };\n      el.addEventListener('input', blocker);\n      // $flow-disable-line\n      el.__ieph = true; /* IE placeholder patched */\n    }\n    el.setAttribute(key, value);\n  }\n}\n\nexports.default = {\n  create: updateAttrs,\n  update: updateAttrs\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/modules/attrs.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/modules/class.js":
/*!****************************************************!*\
  !*** ./src/platforms/web/runtime/modules/class.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _index = __webpack_require__(/*! web/util/index */ \"./src/platforms/web/util/index.js\");\n\nfunction updateClass(oldVnode, vnode) {\n  var el = vnode.elm;\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n  if ((0, _util.isUndef)(data.staticClass) && (0, _util.isUndef)(data.class) && ((0, _util.isUndef)(oldData) || (0, _util.isUndef)(oldData.staticClass) && (0, _util.isUndef)(oldData.class))) {\n    return;\n  }\n\n  var cls = (0, _index.genClassForVnode)(vnode);\n\n  // handle transition classes\n  var transitionClass = el._transitionClasses;\n  if ((0, _util.isDef)(transitionClass)) {\n    cls = (0, _index.concat)(cls, (0, _index.stringifyClass)(transitionClass));\n  }\n\n  // set the class\n  if (cls !== el._prevClass) {\n    el.setAttribute('class', cls);\n    el._prevClass = cls;\n  }\n}\n\nexports.default = {\n  create: updateClass,\n  update: updateClass\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/modules/class.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/modules/dom-props.js":
/*!********************************************************!*\
  !*** ./src/platforms/web/runtime/modules/dom-props.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nfunction updateDOMProps(oldVnode, vnode) {\n  if ((0, _util.isUndef)(oldVnode.data.domProps) && (0, _util.isUndef)(vnode.data.domProps)) {\n    return;\n  }\n  var key = void 0,\n      cur = void 0;\n  var elm = vnode.elm;\n  var oldProps = oldVnode.data.domProps || {};\n  var props = vnode.data.domProps || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if ((0, _util.isDef)(props.__ob__)) {\n    props = vnode.data.domProps = (0, _util.extend)({}, props);\n  }\n\n  for (key in oldProps) {\n    if ((0, _util.isUndef)(props[key])) {\n      elm[key] = '';\n    }\n  }\n  for (key in props) {\n    cur = props[key];\n    // ignore children if the node has textContent or innerHTML,\n    // as these will throw away existing DOM nodes and cause removal errors\n    // on subsequent patches (#3360)\n    if (key === 'textContent' || key === 'innerHTML') {\n      if (vnode.children) vnode.children.length = 0;\n      if (cur === oldProps[key]) continue;\n      // #6601 work around Chrome version <= 55 bug where single textNode\n      // replaced by innerHTML/textContent retains its parentNode property\n      if (elm.childNodes.length === 1) {\n        elm.removeChild(elm.childNodes[0]);\n      }\n    }\n\n    if (key === 'value') {\n      // store value as _value as well since\n      // non-string values will be stringified\n      elm._value = cur;\n      // avoid resetting cursor position when value is the same\n      var strCur = (0, _util.isUndef)(cur) ? '' : String(cur);\n      if (shouldUpdateValue(elm, strCur)) {\n        elm.value = strCur;\n      }\n    } else {\n      elm[key] = cur;\n    }\n  }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue(elm, checkVal) {\n  return !elm.composing && (elm.tagName === 'OPTION' || isNotInFocusAndDirty(elm, checkVal) || isDirtyWithModifiers(elm, checkVal));\n}\n\nfunction isNotInFocusAndDirty(elm, checkVal) {\n  // return true when textbox (.number and .trim) loses focus and its value is\n  // not equal to the updated value\n  var notInFocus = true;\n  // #6157\n  // work around IE bug when accessing document.activeElement in an iframe\n  try {\n    notInFocus = document.activeElement !== elm;\n  } catch (e) {}\n  return notInFocus && elm.value !== checkVal;\n}\n\nfunction isDirtyWithModifiers(elm, newVal) {\n  var value = elm.value;\n  var modifiers = elm._vModifiers; // injected by v-model runtime\n  if ((0, _util.isDef)(modifiers)) {\n    if (modifiers.lazy) {\n      // inputs with lazy should only be updated when not in focus\n      return false;\n    }\n    if (modifiers.number) {\n      return (0, _util.toNumber)(value) !== (0, _util.toNumber)(newVal);\n    }\n    if (modifiers.trim) {\n      return value.trim() !== newVal.trim();\n    }\n  }\n  return value !== newVal;\n}\n\nexports.default = {\n  create: updateDOMProps,\n  update: updateDOMProps\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/modules/dom-props.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/modules/events.js":
/*!*****************************************************!*\
  !*** ./src/platforms/web/runtime/modules/events.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _index = __webpack_require__(/*! core/vdom/helpers/index */ \"./src/core/vdom/helpers/index.js\");\n\nvar _index2 = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _model = __webpack_require__(/*! web/compiler/directives/model */ \"./src/platforms/web/compiler/directives/model.js\");\n\n// normalize v-model event tokens that can only be determined at runtime.\n// it's important to place the event as the first in the array because\n// the whole point is ensuring the v-model callback gets called before\n// user-attached handlers.\nfunction normalizeEvents(on) {\n  /* istanbul ignore if */\n  if ((0, _util.isDef)(on[_model.RANGE_TOKEN])) {\n    // IE input[type=range] only supports `change` event\n    var event = _index2.isIE ? 'change' : 'input';\n    on[event] = [].concat(on[_model.RANGE_TOKEN], on[event] || []);\n    delete on[_model.RANGE_TOKEN];\n  }\n  // This was originally intended to fix #4521 but no longer necessary\n  // after 2.5. Keeping it for backwards compat with generated code from < 2.4\n  /* istanbul ignore if */\n  if ((0, _util.isDef)(on[_model.CHECKBOX_RADIO_TOKEN])) {\n    on.change = [].concat(on[_model.CHECKBOX_RADIO_TOKEN], on.change || []);\n    delete on[_model.CHECKBOX_RADIO_TOKEN];\n  }\n}\n\nvar target = void 0;\n\nfunction createOnceHandler(handler, event, capture) {\n  var _target = target; // save current target element in closure\n  return function onceHandler() {\n    var res = handler.apply(null, arguments);\n    if (res !== null) {\n      remove(event, onceHandler, capture, _target);\n    }\n  };\n}\n\nfunction add(event, handler, once, capture, passive) {\n  handler = (0, _index2.withMacroTask)(handler);\n  if (once) handler = createOnceHandler(handler, event, capture);\n  target.addEventListener(event, handler, _index2.supportsPassive ? { capture: capture, passive: passive } : capture);\n}\n\nfunction remove(event, handler, capture, _target) {\n  (_target || target).removeEventListener(event, handler._withTask || handler, capture);\n}\n\nfunction updateDOMListeners(oldVnode, vnode) {\n  if ((0, _util.isUndef)(oldVnode.data.on) && (0, _util.isUndef)(vnode.data.on)) {\n    return;\n  }\n  var on = vnode.data.on || {};\n  var oldOn = oldVnode.data.on || {};\n  target = vnode.elm;\n  normalizeEvents(on);\n  (0, _index.updateListeners)(on, oldOn, add, remove, vnode.context);\n  target = undefined;\n}\n\nexports.default = {\n  create: updateDOMListeners,\n  update: updateDOMListeners\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/modules/events.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/modules/index.js":
/*!****************************************************!*\
  !*** ./src/platforms/web/runtime/modules/index.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _attrs = __webpack_require__(/*! ./attrs */ \"./src/platforms/web/runtime/modules/attrs.js\");\n\nvar _attrs2 = _interopRequireDefault(_attrs);\n\nvar _class = __webpack_require__(/*! ./class */ \"./src/platforms/web/runtime/modules/class.js\");\n\nvar _class2 = _interopRequireDefault(_class);\n\nvar _events = __webpack_require__(/*! ./events */ \"./src/platforms/web/runtime/modules/events.js\");\n\nvar _events2 = _interopRequireDefault(_events);\n\nvar _domProps = __webpack_require__(/*! ./dom-props */ \"./src/platforms/web/runtime/modules/dom-props.js\");\n\nvar _domProps2 = _interopRequireDefault(_domProps);\n\nvar _style = __webpack_require__(/*! ./style */ \"./src/platforms/web/runtime/modules/style.js\");\n\nvar _style2 = _interopRequireDefault(_style);\n\nvar _transition = __webpack_require__(/*! ./transition */ \"./src/platforms/web/runtime/modules/transition.js\");\n\nvar _transition2 = _interopRequireDefault(_transition);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = [_attrs2.default, _class2.default, _events2.default, _domProps2.default, _style2.default, _transition2.default];\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/modules/index.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/modules/style.js":
/*!****************************************************!*\
  !*** ./src/platforms/web/runtime/modules/style.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _style = __webpack_require__(/*! web/util/style */ \"./src/platforms/web/util/style.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function setProp(el, name, val) {\n  /* istanbul ignore if */\n  if (cssVarRE.test(name)) {\n    el.style.setProperty(name, val);\n  } else if (importantRE.test(val)) {\n    el.style.setProperty(name, val.replace(importantRE, ''), 'important');\n  } else {\n    var normalizedName = normalize(name);\n    if (Array.isArray(val)) {\n      // Support values array created by autoprefixer, e.g.\n      // {display: [\"-webkit-box\", \"-ms-flexbox\", \"flex\"]}\n      // Set them one by one, and the browser will only set those it can recognize\n      for (var i = 0, len = val.length; i < len; i++) {\n        el.style[normalizedName] = val[i];\n      }\n    } else {\n      el.style[normalizedName] = val;\n    }\n  }\n};\n\nvar vendorNames = ['Webkit', 'Moz', 'ms'];\n\nvar emptyStyle = void 0;\nvar normalize = (0, _util.cached)(function (prop) {\n  emptyStyle = emptyStyle || document.createElement('div').style;\n  prop = (0, _util.camelize)(prop);\n  if (prop !== 'filter' && prop in emptyStyle) {\n    return prop;\n  }\n  var capName = prop.charAt(0).toUpperCase() + prop.slice(1);\n  for (var i = 0; i < vendorNames.length; i++) {\n    var name = vendorNames[i] + capName;\n    if (name in emptyStyle) {\n      return name;\n    }\n  }\n});\n\nfunction updateStyle(oldVnode, vnode) {\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n\n  if ((0, _util.isUndef)(data.staticStyle) && (0, _util.isUndef)(data.style) && (0, _util.isUndef)(oldData.staticStyle) && (0, _util.isUndef)(oldData.style)) {\n    return;\n  }\n\n  var cur = void 0,\n      name = void 0;\n  var el = vnode.elm;\n  var oldStaticStyle = oldData.staticStyle;\n  var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};\n\n  // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n  var oldStyle = oldStaticStyle || oldStyleBinding;\n\n  var style = (0, _style.normalizeStyleBinding)(vnode.data.style) || {};\n\n  // store normalized style under a different key for next diff\n  // make sure to clone it if it's reactive, since the user likely wants\n  // to mutate it.\n  vnode.data.normalizedStyle = (0, _util.isDef)(style.__ob__) ? (0, _util.extend)({}, style) : style;\n\n  var newStyle = (0, _style.getStyle)(vnode, true);\n\n  for (name in oldStyle) {\n    if ((0, _util.isUndef)(newStyle[name])) {\n      setProp(el, name, '');\n    }\n  }\n  for (name in newStyle) {\n    cur = newStyle[name];\n    if (cur !== oldStyle[name]) {\n      // ie9 setting to null has no effect, must use empty string\n      setProp(el, name, cur == null ? '' : cur);\n    }\n  }\n}\n\nexports.default = {\n  create: updateStyle,\n  update: updateStyle\n};\nmodule.exports = exports['default'];\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/modules/style.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/modules/transition.js":
/*!*********************************************************!*\
  !*** ./src/platforms/web/runtime/modules/transition.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.enter = enter;\nexports.leave = leave;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _index2 = __webpack_require__(/*! core/vdom/helpers/index */ \"./src/core/vdom/helpers/index.js\");\n\nvar _lifecycle = __webpack_require__(/*! core/instance/lifecycle */ \"./src/core/instance/lifecycle.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar _transitionUtil = __webpack_require__(/*! ../transition-util */ \"./src/platforms/web/runtime/transition-util.js\");\n\nfunction enter(vnode, toggleDisplay) {\n  var el = vnode.elm;\n\n  // call leave callback now\n  if ((0, _util.isDef)(el._leaveCb)) {\n    el._leaveCb.cancelled = true;\n    el._leaveCb();\n  }\n\n  var data = (0, _transitionUtil.resolveTransition)(vnode.data.transition);\n  if ((0, _util.isUndef)(data)) {\n    return;\n  }\n\n  /* istanbul ignore if */\n  if ((0, _util.isDef)(el._enterCb) || el.nodeType !== 1) {\n    return;\n  }\n\n  var css = data.css,\n      type = data.type,\n      enterClass = data.enterClass,\n      enterToClass = data.enterToClass,\n      enterActiveClass = data.enterActiveClass,\n      appearClass = data.appearClass,\n      appearToClass = data.appearToClass,\n      appearActiveClass = data.appearActiveClass,\n      beforeEnter = data.beforeEnter,\n      enter = data.enter,\n      afterEnter = data.afterEnter,\n      enterCancelled = data.enterCancelled,\n      beforeAppear = data.beforeAppear,\n      appear = data.appear,\n      afterAppear = data.afterAppear,\n      appearCancelled = data.appearCancelled,\n      duration = data.duration;\n\n  // activeInstance will always be the <transition> component managing this\n  // transition. One edge case to check is when the <transition> is placed\n  // as the root node of a child component. In that case we need to check\n  // <transition>'s parent for appear check.\n\n  var context = _lifecycle.activeInstance;\n  var transitionNode = _lifecycle.activeInstance.$vnode;\n  while (transitionNode && transitionNode.parent) {\n    transitionNode = transitionNode.parent;\n    context = transitionNode.context;\n  }\n\n  var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n  if (isAppear && !appear && appear !== '') {\n    return;\n  }\n\n  var startClass = isAppear && appearClass ? appearClass : enterClass;\n  var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;\n  var toClass = isAppear && appearToClass ? appearToClass : enterToClass;\n\n  var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;\n  var enterHook = isAppear ? typeof appear === 'function' ? appear : enter : enter;\n  var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;\n  var enterCancelledHook = isAppear ? appearCancelled || enterCancelled : enterCancelled;\n\n  var explicitEnterDuration = (0, _util.toNumber)((0, _util.isObject)(duration) ? duration.enter : duration);\n\n  if (\"development\" !== 'production' && explicitEnterDuration != null) {\n    checkDuration(explicitEnterDuration, 'enter', vnode);\n  }\n\n  var expectsCSS = css !== false && !_index.isIE9;\n  var userWantsControl = getHookArgumentsLength(enterHook);\n\n  var cb = el._enterCb = (0, _util.once)(function () {\n    if (expectsCSS) {\n      (0, _transitionUtil.removeTransitionClass)(el, toClass);\n      (0, _transitionUtil.removeTransitionClass)(el, activeClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        (0, _transitionUtil.removeTransitionClass)(el, startClass);\n      }\n      enterCancelledHook && enterCancelledHook(el);\n    } else {\n      afterEnterHook && afterEnterHook(el);\n    }\n    el._enterCb = null;\n  });\n\n  if (!vnode.data.show) {\n    // remove pending leave element on enter by injecting an insert hook\n    (0, _index2.mergeVNodeHook)(vnode, 'insert', function () {\n      var parent = el.parentNode;\n      var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n      if (pendingNode && pendingNode.tag === vnode.tag && pendingNode.elm._leaveCb) {\n        pendingNode.elm._leaveCb();\n      }\n      enterHook && enterHook(el, cb);\n    });\n  }\n\n  // start enter transition\n  beforeEnterHook && beforeEnterHook(el);\n  if (expectsCSS) {\n    (0, _transitionUtil.addTransitionClass)(el, startClass);\n    (0, _transitionUtil.addTransitionClass)(el, activeClass);\n    (0, _transitionUtil.nextFrame)(function () {\n      (0, _transitionUtil.removeTransitionClass)(el, startClass);\n      if (!cb.cancelled) {\n        (0, _transitionUtil.addTransitionClass)(el, toClass);\n        if (!userWantsControl) {\n          if (isValidDuration(explicitEnterDuration)) {\n            setTimeout(cb, explicitEnterDuration);\n          } else {\n            (0, _transitionUtil.whenTransitionEnds)(el, type, cb);\n          }\n        }\n      }\n    });\n  }\n\n  if (vnode.data.show) {\n    toggleDisplay && toggleDisplay();\n    enterHook && enterHook(el, cb);\n  }\n\n  if (!expectsCSS && !userWantsControl) {\n    cb();\n  }\n}\n\nfunction leave(vnode, rm) {\n  var el = vnode.elm;\n\n  // call enter callback now\n  if ((0, _util.isDef)(el._enterCb)) {\n    el._enterCb.cancelled = true;\n    el._enterCb();\n  }\n\n  var data = (0, _transitionUtil.resolveTransition)(vnode.data.transition);\n  if ((0, _util.isUndef)(data) || el.nodeType !== 1) {\n    return rm();\n  }\n\n  /* istanbul ignore if */\n  if ((0, _util.isDef)(el._leaveCb)) {\n    return;\n  }\n\n  var css = data.css,\n      type = data.type,\n      leaveClass = data.leaveClass,\n      leaveToClass = data.leaveToClass,\n      leaveActiveClass = data.leaveActiveClass,\n      beforeLeave = data.beforeLeave,\n      leave = data.leave,\n      afterLeave = data.afterLeave,\n      leaveCancelled = data.leaveCancelled,\n      delayLeave = data.delayLeave,\n      duration = data.duration;\n\n\n  var expectsCSS = css !== false && !_index.isIE9;\n  var userWantsControl = getHookArgumentsLength(leave);\n\n  var explicitLeaveDuration = (0, _util.toNumber)((0, _util.isObject)(duration) ? duration.leave : duration);\n\n  if (\"development\" !== 'production' && (0, _util.isDef)(explicitLeaveDuration)) {\n    checkDuration(explicitLeaveDuration, 'leave', vnode);\n  }\n\n  var cb = el._leaveCb = (0, _util.once)(function () {\n    if (el.parentNode && el.parentNode._pending) {\n      el.parentNode._pending[vnode.key] = null;\n    }\n    if (expectsCSS) {\n      (0, _transitionUtil.removeTransitionClass)(el, leaveToClass);\n      (0, _transitionUtil.removeTransitionClass)(el, leaveActiveClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        (0, _transitionUtil.removeTransitionClass)(el, leaveClass);\n      }\n      leaveCancelled && leaveCancelled(el);\n    } else {\n      rm();\n      afterLeave && afterLeave(el);\n    }\n    el._leaveCb = null;\n  });\n\n  if (delayLeave) {\n    delayLeave(performLeave);\n  } else {\n    performLeave();\n  }\n\n  function performLeave() {\n    // the delayed leave may have already been cancelled\n    if (cb.cancelled) {\n      return;\n    }\n    // record leaving element\n    if (!vnode.data.show) {\n      (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;\n    }\n    beforeLeave && beforeLeave(el);\n    if (expectsCSS) {\n      (0, _transitionUtil.addTransitionClass)(el, leaveClass);\n      (0, _transitionUtil.addTransitionClass)(el, leaveActiveClass);\n      (0, _transitionUtil.nextFrame)(function () {\n        (0, _transitionUtil.removeTransitionClass)(el, leaveClass);\n        if (!cb.cancelled) {\n          (0, _transitionUtil.addTransitionClass)(el, leaveToClass);\n          if (!userWantsControl) {\n            if (isValidDuration(explicitLeaveDuration)) {\n              setTimeout(cb, explicitLeaveDuration);\n            } else {\n              (0, _transitionUtil.whenTransitionEnds)(el, type, cb);\n            }\n          }\n        }\n      });\n    }\n    leave && leave(el, cb);\n    if (!expectsCSS && !userWantsControl) {\n      cb();\n    }\n  }\n}\n\n// only used in dev mode\nfunction checkDuration(val, name, vnode) {\n  if (typeof val !== 'number') {\n    (0, _index.warn)('<transition> explicit ' + name + ' duration is not a valid number - ' + ('got ' + JSON.stringify(val) + '.'), vnode.context);\n  } else if (isNaN(val)) {\n    (0, _index.warn)('<transition> explicit ' + name + ' duration is NaN - ' + 'the duration expression might be incorrect.', vnode.context);\n  }\n}\n\nfunction isValidDuration(val) {\n  return typeof val === 'number' && !isNaN(val);\n}\n\n/**\n * Normalize a transition hook's argument length. The hook may be:\n * - a merged hook (invoker) with the original in .fns\n * - a wrapped component method (check ._length)\n * - a plain function (.length)\n */\nfunction getHookArgumentsLength(fn) {\n  if ((0, _util.isUndef)(fn)) {\n    return false;\n  }\n  var invokerFns = fn.fns;\n  if ((0, _util.isDef)(invokerFns)) {\n    // invoker\n    return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);\n  } else {\n    return (fn._length || fn.length) > 1;\n  }\n}\n\nfunction _enter(_, vnode) {\n  if (vnode.data.show !== true) {\n    enter(vnode);\n  }\n}\n\nexports.default = _index.inBrowser ? {\n  create: _enter,\n  activate: _enter,\n  remove: function remove(vnode, rm) {\n    /* istanbul ignore else */\n    if (vnode.data.show !== true) {\n      leave(vnode, rm);\n    } else {\n      rm();\n    }\n  }\n} : {};\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/modules/transition.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/node-ops.js":
/*!***********************************************!*\
  !*** ./src/platforms/web/runtime/node-ops.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createElement = createElement;\nexports.createElementNS = createElementNS;\nexports.createTextNode = createTextNode;\nexports.createComment = createComment;\nexports.insertBefore = insertBefore;\nexports.removeChild = removeChild;\nexports.appendChild = appendChild;\nexports.parentNode = parentNode;\nexports.nextSibling = nextSibling;\nexports.tagName = tagName;\nexports.setTextContent = setTextContent;\nexports.setStyleScope = setStyleScope;\n\nvar _index = __webpack_require__(/*! web/util/index */ \"./src/platforms/web/util/index.js\");\n\nfunction createElement(tagName, vnode) {\n  var elm = document.createElement(tagName);\n  if (tagName !== 'select') {\n    return elm;\n  }\n  // false or null will remove the attribute but undefined will not\n  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {\n    elm.setAttribute('multiple', 'multiple');\n  }\n  return elm;\n}\n\nfunction createElementNS(namespace, tagName) {\n  return document.createElementNS(_index.namespaceMap[namespace], tagName);\n}\n\nfunction createTextNode(text) {\n  return document.createTextNode(text);\n}\n\nfunction createComment(text) {\n  return document.createComment(text);\n}\n\nfunction insertBefore(parentNode, newNode, referenceNode) {\n  parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild(node, child) {\n  node.removeChild(child);\n}\n\nfunction appendChild(node, child) {\n  node.appendChild(child);\n}\n\nfunction parentNode(node) {\n  return node.parentNode;\n}\n\nfunction nextSibling(node) {\n  return node.nextSibling;\n}\n\nfunction tagName(node) {\n  return node.tagName;\n}\n\nfunction setTextContent(node, text) {\n  node.textContent = text;\n}\n\nfunction setStyleScope(node, scopeId) {\n  node.setAttribute(scopeId, '');\n}\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/node-ops.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/patch.js":
/*!********************************************!*\
  !*** ./src/platforms/web/runtime/patch.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.patch = undefined;\n\nvar _nodeOps = __webpack_require__(/*! web/runtime/node-ops */ \"./src/platforms/web/runtime/node-ops.js\");\n\nvar nodeOps = _interopRequireWildcard(_nodeOps);\n\nvar _patch = __webpack_require__(/*! core/vdom/patch */ \"./src/core/vdom/patch.js\");\n\nvar _index = __webpack_require__(/*! core/vdom/modules/index */ \"./src/core/vdom/modules/index.js\");\n\nvar _index2 = _interopRequireDefault(_index);\n\nvar _index3 = __webpack_require__(/*! web/runtime/modules/index */ \"./src/platforms/web/runtime/modules/index.js\");\n\nvar _index4 = _interopRequireDefault(_index3);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = _index4.default.concat(_index2.default);\n\nvar patch = exports.patch = (0, _patch.createPatchFunction)({ nodeOps: nodeOps, modules: modules });\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/patch.js?");

/***/ }),

/***/ "./src/platforms/web/runtime/transition-util.js":
/*!******************************************************!*\
  !*** ./src/platforms/web/runtime/transition-util.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.animationEndEvent = exports.animationProp = exports.transitionEndEvent = exports.transitionProp = exports.hasTransition = undefined;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.resolveTransition = resolveTransition;\nexports.nextFrame = nextFrame;\nexports.addTransitionClass = addTransitionClass;\nexports.removeTransitionClass = removeTransitionClass;\nexports.whenTransitionEnds = whenTransitionEnds;\nexports.getTransitionInfo = getTransitionInfo;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _classUtil = __webpack_require__(/*! ./class-util */ \"./src/platforms/web/runtime/class-util.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nfunction resolveTransition(def) {\n  if (!def) {\n    return;\n  }\n  /* istanbul ignore else */\n  if ((typeof def === 'undefined' ? 'undefined' : _typeof(def)) === 'object') {\n    var res = {};\n    if (def.css !== false) {\n      (0, _util.extend)(res, autoCssTransition(def.name || 'v'));\n    }\n    (0, _util.extend)(res, def);\n    return res;\n  } else if (typeof def === 'string') {\n    return autoCssTransition(def);\n  }\n}\n\nvar autoCssTransition = (0, _util.cached)(function (name) {\n  return {\n    enterClass: name + '-enter',\n    enterToClass: name + '-enter-to',\n    enterActiveClass: name + '-enter-active',\n    leaveClass: name + '-leave',\n    leaveToClass: name + '-leave-to',\n    leaveActiveClass: name + '-leave-active'\n  };\n});\n\nvar hasTransition = exports.hasTransition = _index.inBrowser && !_index.isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = exports.transitionProp = 'transition';\nvar transitionEndEvent = exports.transitionEndEvent = 'transitionend';\nvar animationProp = exports.animationProp = 'animation';\nvar animationEndEvent = exports.animationEndEvent = 'animationend';\nif (hasTransition) {\n  /* istanbul ignore if */\n  if (window.ontransitionend === undefined && window.onwebkittransitionend !== undefined) {\n    exports.transitionProp = transitionProp = 'WebkitTransition';\n    exports.transitionEndEvent = transitionEndEvent = 'webkitTransitionEnd';\n  }\n  if (window.onanimationend === undefined && window.onwebkitanimationend !== undefined) {\n    exports.animationProp = animationProp = 'WebkitAnimation';\n    exports.animationEndEvent = animationEndEvent = 'webkitAnimationEnd';\n  }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = _index.inBrowser ? window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : setTimeout : /* istanbul ignore next */function (fn) {\n  return fn();\n};\n\nfunction nextFrame(fn) {\n  raf(function () {\n    raf(fn);\n  });\n}\n\nfunction addTransitionClass(el, cls) {\n  var transitionClasses = el._transitionClasses || (el._transitionClasses = []);\n  if (transitionClasses.indexOf(cls) < 0) {\n    transitionClasses.push(cls);\n    (0, _classUtil.addClass)(el, cls);\n  }\n}\n\nfunction removeTransitionClass(el, cls) {\n  if (el._transitionClasses) {\n    (0, _util.remove)(el._transitionClasses, cls);\n  }\n  (0, _classUtil.removeClass)(el, cls);\n}\n\nfunction whenTransitionEnds(el, expectedType, cb) {\n  var _getTransitionInfo = getTransitionInfo(el, expectedType),\n      type = _getTransitionInfo.type,\n      timeout = _getTransitionInfo.timeout,\n      propCount = _getTransitionInfo.propCount;\n\n  if (!type) return cb();\n  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n  var ended = 0;\n  var end = function end() {\n    el.removeEventListener(event, onEnd);\n    cb();\n  };\n  var onEnd = function onEnd(e) {\n    if (e.target === el) {\n      if (++ended >= propCount) {\n        end();\n      }\n    }\n  };\n  setTimeout(function () {\n    if (ended < propCount) {\n      end();\n    }\n  }, timeout + 1);\n  el.addEventListener(event, onEnd);\n}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo(el, expectedType) {\n  var styles = window.getComputedStyle(el);\n  var transitionDelays = styles[transitionProp + 'Delay'].split(', ');\n  var transitionDurations = styles[transitionProp + 'Duration'].split(', ');\n  var transitionTimeout = getTimeout(transitionDelays, transitionDurations);\n  var animationDelays = styles[animationProp + 'Delay'].split(', ');\n  var animationDurations = styles[animationProp + 'Duration'].split(', ');\n  var animationTimeout = getTimeout(animationDelays, animationDurations);\n\n  var type = void 0;\n  var timeout = 0;\n  var propCount = 0;\n  /* istanbul ignore if */\n  if (expectedType === TRANSITION) {\n    if (transitionTimeout > 0) {\n      type = TRANSITION;\n      timeout = transitionTimeout;\n      propCount = transitionDurations.length;\n    }\n  } else if (expectedType === ANIMATION) {\n    if (animationTimeout > 0) {\n      type = ANIMATION;\n      timeout = animationTimeout;\n      propCount = animationDurations.length;\n    }\n  } else {\n    timeout = Math.max(transitionTimeout, animationTimeout);\n    type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;\n    propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;\n  }\n  var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);\n  return {\n    type: type,\n    timeout: timeout,\n    propCount: propCount,\n    hasTransform: hasTransform\n  };\n}\n\nfunction getTimeout(delays, durations) {\n  /* istanbul ignore next */\n  while (delays.length < durations.length) {\n    delays = delays.concat(delays);\n  }\n\n  return Math.max.apply(null, durations.map(function (d, i) {\n    return toMs(d) + toMs(delays[i]);\n  }));\n}\n\nfunction toMs(s) {\n  return Number(s.slice(0, -1)) * 1000;\n}\n\n//# sourceURL=webpack://Vue/./src/platforms/web/runtime/transition-util.js?");

/***/ }),

/***/ "./src/platforms/web/util/attrs.js":
/*!*****************************************!*\
  !*** ./src/platforms/web/util/attrs.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isFalsyAttrValue = exports.getXlinkProp = exports.isXlink = exports.xlinkNS = exports.isBooleanAttr = exports.isEnumeratedAttr = exports.mustUseProp = exports.isReservedAttr = undefined;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\n// these are reserved for web because they are directly compiled away\n// during template compilation\nvar isReservedAttr = exports.isReservedAttr = (0, _util.makeMap)('style,class');\n\n// attributes that should be using props for binding\n\n\nvar acceptValue = (0, _util.makeMap)('input,textarea,option,select,progress');\nvar mustUseProp = exports.mustUseProp = function mustUseProp(tag, type, attr) {\n  return attr === 'value' && acceptValue(tag) && type !== 'button' || attr === 'selected' && tag === 'option' || attr === 'checked' && tag === 'input' || attr === 'muted' && tag === 'video';\n};\n\nvar isEnumeratedAttr = exports.isEnumeratedAttr = (0, _util.makeMap)('contenteditable,draggable,spellcheck');\n\nvar isBooleanAttr = exports.isBooleanAttr = (0, _util.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');\n\nvar xlinkNS = exports.xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = exports.isXlink = function isXlink(name) {\n  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';\n};\n\nvar getXlinkProp = exports.getXlinkProp = function getXlinkProp(name) {\n  return isXlink(name) ? name.slice(6, name.length) : '';\n};\n\nvar isFalsyAttrValue = exports.isFalsyAttrValue = function isFalsyAttrValue(val) {\n  return val == null || val === false;\n};\n\n//# sourceURL=webpack://Vue/./src/platforms/web/util/attrs.js?");

/***/ }),

/***/ "./src/platforms/web/util/class.js":
/*!*****************************************!*\
  !*** ./src/platforms/web/util/class.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.genClassForVnode = genClassForVnode;\nexports.renderClass = renderClass;\nexports.concat = concat;\nexports.stringifyClass = stringifyClass;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nfunction genClassForVnode(vnode) {\n  var data = vnode.data;\n  var parentNode = vnode;\n  var childNode = vnode;\n  while ((0, _util.isDef)(childNode.componentInstance)) {\n    childNode = childNode.componentInstance._vnode;\n    if (childNode && childNode.data) {\n      data = mergeClassData(childNode.data, data);\n    }\n  }\n  while ((0, _util.isDef)(parentNode = parentNode.parent)) {\n    if (parentNode && parentNode.data) {\n      data = mergeClassData(data, parentNode.data);\n    }\n  }\n  return renderClass(data.staticClass, data.class);\n}\n\nfunction mergeClassData(child, parent) {\n  return {\n    staticClass: concat(child.staticClass, parent.staticClass),\n    class: (0, _util.isDef)(child.class) ? [child.class, parent.class] : parent.class\n  };\n}\n\nfunction renderClass(staticClass, dynamicClass) {\n  if ((0, _util.isDef)(staticClass) || (0, _util.isDef)(dynamicClass)) {\n    return concat(staticClass, stringifyClass(dynamicClass));\n  }\n  /* istanbul ignore next */\n  return '';\n}\n\nfunction concat(a, b) {\n  return a ? b ? a + ' ' + b : a : b || '';\n}\n\nfunction stringifyClass(value) {\n  if (Array.isArray(value)) {\n    return stringifyArray(value);\n  }\n  if ((0, _util.isObject)(value)) {\n    return stringifyObject(value);\n  }\n  if (typeof value === 'string') {\n    return value;\n  }\n  /* istanbul ignore next */\n  return '';\n}\n\nfunction stringifyArray(value) {\n  var res = '';\n  var stringified = void 0;\n  for (var i = 0, l = value.length; i < l; i++) {\n    if ((0, _util.isDef)(stringified = stringifyClass(value[i])) && stringified !== '') {\n      if (res) res += ' ';\n      res += stringified;\n    }\n  }\n  return res;\n}\n\nfunction stringifyObject(value) {\n  var res = '';\n  for (var key in value) {\n    if (value[key]) {\n      if (res) res += ' ';\n      res += key;\n    }\n  }\n  return res;\n}\n\n//# sourceURL=webpack://Vue/./src/platforms/web/util/class.js?");

/***/ }),

/***/ "./src/platforms/web/util/compat.js":
/*!******************************************!*\
  !*** ./src/platforms/web/util/compat.js ***!
  \******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.shouldDecodeNewlinesForHref = exports.shouldDecodeNewlines = undefined;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\n// check whether current browser encodes a char inside attribute values\nvar div = void 0;\n\nfunction getShouldDecode(href) {\n  div = div || document.createElement('div');\n  div.innerHTML = href ? '<a href=\"\\n\"/>' : '<div a=\"\\n\"/>';\n  return div.innerHTML.indexOf('&#10;') > 0;\n}\n\n// #3663: IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = exports.shouldDecodeNewlines = _index.inBrowser ? getShouldDecode(false) : false;\n// #6828: chrome encodes content in a[href]\nvar shouldDecodeNewlinesForHref = exports.shouldDecodeNewlinesForHref = _index.inBrowser ? getShouldDecode(true) : false;\n\n//# sourceURL=webpack://Vue/./src/platforms/web/util/compat.js?");

/***/ }),

/***/ "./src/platforms/web/util/element.js":
/*!*******************************************!*\
  !*** ./src/platforms/web/util/element.js ***!
  \*******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isTextInputType = exports.isReservedTag = exports.isPreTag = exports.isSVG = exports.isHTMLTag = exports.namespaceMap = undefined;\nexports.getTagNamespace = getTagNamespace;\nexports.isUnknownElement = isUnknownElement;\n\nvar _env = __webpack_require__(/*! core/util/env */ \"./src/core/util/env.js\");\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar namespaceMap = exports.namespaceMap = {\n  svg: 'http://www.w3.org/2000/svg',\n  math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = exports.isHTMLTag = (0, _util.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');\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = exports.isSVG = (0, _util.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);\n\nvar isPreTag = exports.isPreTag = function isPreTag(tag) {\n  return tag === 'pre';\n};\n\nvar isReservedTag = exports.isReservedTag = function isReservedTag(tag) {\n  return isHTMLTag(tag) || isSVG(tag);\n};\n\nfunction getTagNamespace(tag) {\n  if (isSVG(tag)) {\n    return 'svg';\n  }\n  // basic support for MathML\n  // note it doesn't support other MathML elements being component roots\n  if (tag === 'math') {\n    return 'math';\n  }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement(tag) {\n  /* istanbul ignore if */\n  if (!_env.inBrowser) {\n    return true;\n  }\n  if (isReservedTag(tag)) {\n    return false;\n  }\n  tag = tag.toLowerCase();\n  /* istanbul ignore if */\n  if (unknownElementCache[tag] != null) {\n    return unknownElementCache[tag];\n  }\n  var el = document.createElement(tag);\n  if (tag.indexOf('-') > -1) {\n    // http://stackoverflow.com/a/28210364/1070244\n    return unknownElementCache[tag] = el.constructor === window.HTMLUnknownElement || el.constructor === window.HTMLElement;\n  } else {\n    return unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString());\n  }\n}\n\nvar isTextInputType = exports.isTextInputType = (0, _util.makeMap)('text,number,password,search,email,tel,url');\n\n//# sourceURL=webpack://Vue/./src/platforms/web/util/element.js?");

/***/ }),

/***/ "./src/platforms/web/util/index.js":
/*!*****************************************!*\
  !*** ./src/platforms/web/util/index.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _attrs = __webpack_require__(/*! ./attrs */ \"./src/platforms/web/util/attrs.js\");\n\nObject.keys(_attrs).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _attrs[key];\n    }\n  });\n});\n\nvar _class = __webpack_require__(/*! ./class */ \"./src/platforms/web/util/class.js\");\n\nObject.keys(_class).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _class[key];\n    }\n  });\n});\n\nvar _element = __webpack_require__(/*! ./element */ \"./src/platforms/web/util/element.js\");\n\nObject.keys(_element).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _element[key];\n    }\n  });\n});\nexports.query = query;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\n/**\n * Query an element selector if it's not an element already.\n */\nfunction query(el) {\n  if (typeof el === 'string') {\n    var selected = document.querySelector(el);\n    if (!selected) {\n      \"development\" !== 'production' && (0, _index.warn)('Cannot find element: ' + el);\n      return document.createElement('div');\n    }\n    return selected;\n  } else {\n    return el;\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/platforms/web/util/index.js?");

/***/ }),

/***/ "./src/platforms/web/util/style.js":
/*!*****************************************!*\
  !*** ./src/platforms/web/util/style.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.parseStyleText = undefined;\nexports.normalizeStyleBinding = normalizeStyleBinding;\nexports.getStyle = getStyle;\n\nvar _util = __webpack_require__(/*! shared/util */ \"./src/shared/util.js\");\n\nvar parseStyleText = exports.parseStyleText = (0, _util.cached)(function (cssText) {\n  var res = {};\n  var listDelimiter = /;(?![^(]*\\))/g;\n  var propertyDelimiter = /:(.+)/;\n  cssText.split(listDelimiter).forEach(function (item) {\n    if (item) {\n      var tmp = item.split(propertyDelimiter);\n      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());\n    }\n  });\n  return res;\n});\n\n// merge static and dynamic style data on the same vnode\n\n\nfunction normalizeStyleData(data) {\n  var style = normalizeStyleBinding(data.style);\n  // static style is pre-processed into an object during compilation\n  // and is always a fresh object, so it's safe to merge into it\n  return data.staticStyle ? (0, _util.extend)(data.staticStyle, style) : style;\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding(bindingStyle) {\n  if (Array.isArray(bindingStyle)) {\n    return (0, _util.toObject)(bindingStyle);\n  }\n  if (typeof bindingStyle === 'string') {\n    return parseStyleText(bindingStyle);\n  }\n  return bindingStyle;\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle(vnode, checkChild) {\n  var res = {};\n  var styleData = void 0;\n\n  if (checkChild) {\n    var childNode = vnode;\n    while (childNode.componentInstance) {\n      childNode = childNode.componentInstance._vnode;\n      if (childNode && childNode.data && (styleData = normalizeStyleData(childNode.data))) {\n        (0, _util.extend)(res, styleData);\n      }\n    }\n  }\n\n  if (styleData = normalizeStyleData(vnode.data)) {\n    (0, _util.extend)(res, styleData);\n  }\n\n  var parentNode = vnode;\n  while (parentNode = parentNode.parent) {\n    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n      (0, _util.extend)(res, styleData);\n    }\n  }\n  return res;\n}\n\n//# sourceURL=webpack://Vue/./src/platforms/web/util/style.js?");

/***/ }),

/***/ "./src/platforms/weex/runtime/recycle-list/render-component-template.js":
/*!******************************************************************************!*\
  !*** ./src/platforms/weex/runtime/recycle-list/render-component-template.js ***!
  \******************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isRecyclableComponent = isRecyclableComponent;\nexports.renderRecyclableComponentTemplate = renderRecyclableComponentTemplate;\n\nvar _debug = __webpack_require__(/*! core/util/debug */ \"./src/core/util/debug.js\");\n\nvar _error = __webpack_require__(/*! core/util/error */ \"./src/core/util/error.js\");\n\nvar _index = __webpack_require__(/*! weex/util/index */ \"./src/platforms/weex/util/index.js\");\n\nvar _createComponent = __webpack_require__(/*! core/vdom/create-component */ \"./src/core/vdom/create-component.js\");\n\nvar _virtualComponent = __webpack_require__(/*! ./virtual-component */ \"./src/platforms/weex/runtime/recycle-list/virtual-component.js\");\n\nfunction isRecyclableComponent(vnode) {\n  return vnode.data.attrs ? _index.RECYCLE_LIST_MARKER in vnode.data.attrs : false;\n}\n\nfunction renderRecyclableComponentTemplate(vnode) {\n  // $flow-disable-line\n  delete vnode.data.attrs[_index.RECYCLE_LIST_MARKER];\n  (0, _virtualComponent.resolveVirtualComponent)(vnode);\n  var vm = (0, _createComponent.createComponentInstanceForVnode)(vnode);\n  var render = vm.$options['@render'];\n  if (render) {\n    try {\n      return render.call(vm);\n    } catch (err) {\n      (0, _error.handleError)(err, vm, '@render');\n    }\n  } else {\n    (0, _debug.warn)('@render function not defined on component used in <recycle-list>. ' + 'Make sure to declare `recyclable=\"true\"` on the component\\'s template.', vm);\n  }\n}\n\n//# sourceURL=webpack://Vue/./src/platforms/weex/runtime/recycle-list/render-component-template.js?");

/***/ }),

/***/ "./src/platforms/weex/runtime/recycle-list/virtual-component.js":
/*!**********************************************************************!*\
  !*** ./src/platforms/weex/runtime/recycle-list/virtual-component.js ***!
  \**********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.resolveVirtualComponent = resolveVirtualComponent;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar _watcher = __webpack_require__(/*! core/observer/watcher */ \"./src/core/observer/watcher.js\");\n\nvar _watcher2 = _interopRequireDefault(_watcher);\n\nvar _proxy = __webpack_require__(/*! core/instance/proxy */ \"./src/core/instance/proxy.js\");\n\nvar _state = __webpack_require__(/*! core/instance/state */ \"./src/core/instance/state.js\");\n\nvar _render = __webpack_require__(/*! core/instance/render */ \"./src/core/instance/render.js\");\n\nvar _events = __webpack_require__(/*! core/instance/events */ \"./src/core/instance/events.js\");\n\nvar _inject = __webpack_require__(/*! core/instance/inject */ \"./src/core/instance/inject.js\");\n\nvar _lifecycle = __webpack_require__(/*! core/instance/lifecycle */ \"./src/core/instance/lifecycle.js\");\n\nvar _init = __webpack_require__(/*! core/instance/init */ \"./src/core/instance/init.js\");\n\nvar _index2 = __webpack_require__(/*! ../../util/index */ \"./src/platforms/weex/util/index.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// https://github.com/Hanks10100/weex-native-directive/tree/master/component\n\nvar uid = 0;\n\n// override Vue.prototype._init\nfunction initVirtualComponent() {\n  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n  var vm = this;\n  var componentId = options.componentId;\n\n  // virtual component uid\n  vm._uid = 'virtual-component-' + uid++;\n\n  // a flag to avoid this being observed\n  vm._isVue = true;\n  // merge options\n  if (options && options._isComponent) {\n    // optimize internal component instantiation\n    // since dynamic options merging is pretty slow, and none of the\n    // internal component options needs special treatment.\n    (0, _init.initInternalComponent)(vm, options);\n  } else {\n    vm.$options = (0, _index.mergeOptions)((0, _init.resolveConstructorOptions)(vm.constructor), options || {}, vm);\n  }\n\n  /* istanbul ignore else */\n  if (true) {\n    (0, _proxy.initProxy)(vm);\n  } else {}\n\n  vm._self = vm;\n  (0, _lifecycle.initLifecycle)(vm);\n  (0, _events.initEvents)(vm);\n  (0, _render.initRender)(vm);\n  (0, _lifecycle.callHook)(vm, 'beforeCreate');\n  (0, _inject.initInjections)(vm); // resolve injections before data/props\n  (0, _state.initState)(vm);\n  (0, _inject.initProvide)(vm); // resolve provide after data/props\n  (0, _lifecycle.callHook)(vm, 'created');\n\n  // send initial data to native\n  var data = vm.$options.data;\n  var params = typeof data === 'function' ? (0, _state.getData)(data, vm) : data || {};\n  if ((0, _index.isPlainObject)(params)) {\n    (0, _index2.updateComponentData)(componentId, params);\n  }\n\n  (0, _index2.registerComponentHook)(componentId, 'lifecycle', 'attach', function () {\n    (0, _lifecycle.callHook)(vm, 'beforeMount');\n\n    var updateComponent = function updateComponent() {\n      vm._update(vm._vnode, false);\n    };\n    new _watcher2.default(vm, updateComponent, _index.noop, null, true);\n\n    vm._isMounted = true;\n    (0, _lifecycle.callHook)(vm, 'mounted');\n  });\n\n  (0, _index2.registerComponentHook)(componentId, 'lifecycle', 'detach', function () {\n    vm.$destroy();\n  });\n}\n\n// override Vue.prototype._update\nfunction updateVirtualComponent(vnode) {\n  var vm = this;\n  var componentId = vm.$options.componentId;\n  if (vm._isMounted) {\n    (0, _lifecycle.callHook)(vm, 'beforeUpdate');\n  }\n  vm._vnode = vnode;\n  if (vm._isMounted && componentId) {\n    // TODO: data should be filtered and without bindings\n    var data = Object.assign({}, vm._data);\n    (0, _index2.updateComponentData)(componentId, data, function () {\n      (0, _lifecycle.callHook)(vm, 'updated');\n    });\n  }\n}\n\n// listening on native callback\nfunction resolveVirtualComponent(vnode) {\n  var BaseCtor = vnode.componentOptions.Ctor;\n  var VirtualComponent = BaseCtor.extend({});\n  var cid = VirtualComponent.cid;\n  VirtualComponent.prototype._init = initVirtualComponent;\n  VirtualComponent.prototype._update = updateVirtualComponent;\n\n  vnode.componentOptions.Ctor = BaseCtor.extend({\n    beforeCreate: function beforeCreate() {\n      // const vm: Component = this\n\n      // TODO: listen on all events and dispatch them to the\n      // corresponding virtual components according to the componentId.\n      // vm._virtualComponents = {}\n      var createVirtualComponent = function createVirtualComponent(componentId, propsData) {\n        // create virtual component\n        // const subVm =\n        new VirtualComponent({\n          componentId: componentId,\n          propsData: propsData\n        });\n        // if (vm._virtualComponents) {\n        //   vm._virtualComponents[componentId] = subVm\n        // }\n      };\n\n      (0, _index2.registerComponentHook)(cid, 'lifecycle', 'create', createVirtualComponent);\n    },\n    beforeDestroy: function beforeDestroy() {\n      delete this._virtualComponents;\n    }\n  });\n}\n\n//# sourceURL=webpack://Vue/./src/platforms/weex/runtime/recycle-list/virtual-component.js?");

/***/ }),

/***/ "./src/platforms/weex/util/index.js":
/*!******************************************!*\
  !*** ./src/platforms/weex/util/index.js ***!
  \******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.RECYCLE_LIST_MARKER = undefined;\nexports.registerComponentHook = registerComponentHook;\nexports.updateComponentData = updateComponentData;\n\nvar _index = __webpack_require__(/*! core/util/index */ \"./src/core/util/index.js\");\n\nvar RECYCLE_LIST_MARKER = exports.RECYCLE_LIST_MARKER = '@inRecycleList';\n\n// Register the component hook to weex native render engine.\n// The hook will be triggered by native, not javascript.\nfunction registerComponentHook(componentId, type, // hook type, could be \"lifecycle\" or \"instance\"\nhook, // hook name\nfn) {\n  if (!document || !document.taskCenter) {\n    (0, _index.warn)('Can\\'t find available \"document\" or \"taskCenter\".');\n    return;\n  }\n  if (typeof document.taskCenter.registerHook === 'function') {\n    return document.taskCenter.registerHook(componentId, type, hook, fn);\n  }\n  (0, _index.warn)('Failed to register component hook \"' + type + '@' + hook + '#' + componentId + '\".');\n}\n\n// Updates the state of the component to weex native render engine.\nfunction updateComponentData(componentId, newData, callback) {\n  if (!document || !document.taskCenter) {\n    (0, _index.warn)('Can\\'t find available \"document\" or \"taskCenter\".');\n    return;\n  }\n  if (typeof document.taskCenter.updateData === 'function') {\n    return document.taskCenter.updateData(componentId, newData, callback);\n  }\n  (0, _index.warn)('Failed to update component data (' + componentId + ').');\n}\n\n//# sourceURL=webpack://Vue/./src/platforms/weex/util/index.js?");

/***/ }),

/***/ "./src/shared/constants.js":
/*!*********************************!*\
  !*** ./src/shared/constants.js ***!
  \*********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nvar SSR_ATTR = exports.SSR_ATTR = 'data-server-rendered';\n\nvar ASSET_TYPES = exports.ASSET_TYPES = ['component', 'directive', 'filter'];\n\nvar LIFECYCLE_HOOKS = exports.LIFECYCLE_HOOKS = ['beforeCreate', 'created', 'beforeMount', 'mounted', 'beforeUpdate', 'updated', 'beforeDestroy', 'destroyed', 'activated', 'deactivated', 'errorCaptured'];\n\n//# sourceURL=webpack://Vue/./src/shared/constants.js?");

/***/ }),

/***/ "./src/shared/util.js":
/*!****************************!*\
  !*** ./src/shared/util.js ***!
  \****************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
eval("\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.isUndef = isUndef;\nexports.isDef = isDef;\nexports.isTrue = isTrue;\nexports.isFalse = isFalse;\nexports.isPrimitive = isPrimitive;\nexports.isObject = isObject;\nexports.toRawType = toRawType;\nexports.isPlainObject = isPlainObject;\nexports.isRegExp = isRegExp;\nexports.isValidArrayIndex = isValidArrayIndex;\nexports.toString = toString;\nexports.toNumber = toNumber;\nexports.makeMap = makeMap;\nexports.remove = remove;\nexports.hasOwn = hasOwn;\nexports.cached = cached;\nexports.toArray = toArray;\nexports.extend = extend;\nexports.toObject = toObject;\nexports.noop = noop;\nexports.genStaticKeys = genStaticKeys;\nexports.looseEqual = looseEqual;\nexports.looseIndexOf = looseIndexOf;\nexports.once = once;\nvar emptyObject = exports.emptyObject = Object.freeze({});\n\n// these helpers produces better vm code in JS engines due to their\n// explicitness and function inlining\nfunction isUndef(v) {\n  return v === undefined || v === null;\n}\n\nfunction isDef(v) {\n  return v !== undefined && v !== null;\n}\n\nfunction isTrue(v) {\n  return v === true;\n}\n\nfunction isFalse(v) {\n  return v === false;\n}\n\n/**\n * Check if value is primitive\n */\nfunction isPrimitive(value) {\n  return typeof value === 'string' || typeof value === 'number' ||\n  // $flow-disable-line\n  (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'symbol' || typeof value === 'boolean';\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject(obj) {\n  return obj !== null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object';\n}\n\n/**\n * Get the raw type string of a value e.g. [object Object]\n */\nvar _toString = Object.prototype.toString;\n\nfunction toRawType(value) {\n  return _toString.call(value).slice(8, -1);\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nfunction isPlainObject(obj) {\n  return _toString.call(obj) === '[object Object]';\n}\n\nfunction isRegExp(v) {\n  return _toString.call(v) === '[object RegExp]';\n}\n\n/**\n * Check if val is a valid array index.\n */\nfunction isValidArrayIndex(val) {\n  var n = parseFloat(String(val));\n  return n >= 0 && Math.floor(n) === n && isFinite(val);\n}\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction toString(val) {\n  return val == null ? '' : (typeof val === 'undefined' ? 'undefined' : _typeof(val)) === 'object' ? JSON.stringify(val, null, 2) : String(val);\n}\n\n/**\n * Convert a input value to a number for persistence.\n * If the conversion fails, return original string.\n */\nfunction toNumber(val) {\n  var n = parseFloat(val);\n  return isNaN(n) ? val : n;\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap(str, expectsLowerCase) {\n  var map = Object.create(null);\n  var list = str.split(',');\n  for (var i = 0; i < list.length; i++) {\n    map[list[i]] = true;\n  }\n  return expectsLowerCase ? function (val) {\n    return map[val.toLowerCase()];\n  } : function (val) {\n    return map[val];\n  };\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = exports.isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Check if a attribute is a reserved attribute.\n */\nvar isReservedAttribute = exports.isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');\n\n/**\n * Remove an item from an array\n */\nfunction remove(arr, item) {\n  if (arr.length) {\n    var index = arr.indexOf(item);\n    if (index > -1) {\n      return arr.splice(index, 1);\n    }\n  }\n}\n\n/**\n * Check whether the object has the property.\n */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwn(obj, key) {\n  return hasOwnProperty.call(obj, key);\n}\n\n/**\n * Create a cached version of a pure function.\n */\nfunction cached(fn) {\n  var cache = Object.create(null);\n  return function cachedFn(str) {\n    var hit = cache[str];\n    return hit || (cache[str] = fn(str));\n  };\n}\n\n/**\n * Camelize a hyphen-delimited string.\n */\nvar camelizeRE = /-(\\w)/g;\nvar camelize = exports.camelize = cached(function (str) {\n  return str.replace(camelizeRE, function (_, c) {\n    return c ? c.toUpperCase() : '';\n  });\n});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = exports.capitalize = cached(function (str) {\n  return str.charAt(0).toUpperCase() + str.slice(1);\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /\\B([A-Z])/g;\nvar hyphenate = exports.hyphenate = cached(function (str) {\n  return str.replace(hyphenateRE, '-$1').toLowerCase();\n});\n\n/**\n * Simple bind polyfill for environments that do not support it... e.g.\n * PhantomJS 1.x. Technically we don't need this anymore since native bind is\n * now more performant in most browsers, but removing it would be breaking for\n * code that was able to run in PhantomJS 1.x, so this must be kept for\n * backwards compatibility.\n */\n\n/* istanbul ignore next */\nfunction polyfillBind(fn, ctx) {\n  function boundFn(a) {\n    var l = arguments.length;\n    return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx);\n  }\n\n  boundFn._length = fn.length;\n  return boundFn;\n}\n\nfunction nativeBind(fn, ctx) {\n  return fn.bind(ctx);\n}\n\nvar bind = exports.bind = Function.prototype.bind ? nativeBind : polyfillBind;\n\n/**\n * Convert an Array-like object to a real Array.\n */\nfunction toArray(list, start) {\n  start = start || 0;\n  var i = list.length - start;\n  var ret = new Array(i);\n  while (i--) {\n    ret[i] = list[i + start];\n  }\n  return ret;\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend(to, _from) {\n  for (var _key in _from) {\n    to[_key] = _from[_key];\n  }\n  return to;\n}\n\n/**\n * Merge an Array of Objects into a single Object.\n */\nfunction toObject(arr) {\n  var res = {};\n  for (var i = 0; i < arr.length; i++) {\n    if (arr[i]) {\n      extend(res, arr[i]);\n    }\n  }\n  return res;\n}\n\n/**\n * Perform no operation.\n * Stubbing args to make Flow happy without leaving useless transpiled code\n * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)\n */\nfunction noop(a, b, c) {}\n\n/**\n * Always return false.\n */\nvar no = exports.no = function no(a, b, c) {\n  return false;\n};\n\n/**\n * Return same value\n */\nvar identity = exports.identity = function identity(_) {\n  return _;\n};\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys(modules) {\n  return modules.reduce(function (keys, m) {\n    return keys.concat(m.staticKeys || []);\n  }, []).join(',');\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n */\nfunction looseEqual(a, b) {\n  if (a === b) return true;\n  var isObjectA = isObject(a);\n  var isObjectB = isObject(b);\n  if (isObjectA && isObjectB) {\n    try {\n      var isArrayA = Array.isArray(a);\n      var isArrayB = Array.isArray(b);\n      if (isArrayA && isArrayB) {\n        return a.length === b.length && a.every(function (e, i) {\n          return looseEqual(e, b[i]);\n        });\n      } else if (!isArrayA && !isArrayB) {\n        var keysA = Object.keys(a);\n        var keysB = Object.keys(b);\n        return keysA.length === keysB.length && keysA.every(function (key) {\n          return looseEqual(a[key], b[key]);\n        });\n      } else {\n        /* istanbul ignore next */\n        return false;\n      }\n    } catch (e) {\n      /* istanbul ignore next */\n      return false;\n    }\n  } else if (!isObjectA && !isObjectB) {\n    return String(a) === String(b);\n  } else {\n    return false;\n  }\n}\n\nfunction looseIndexOf(arr, val) {\n  for (var i = 0; i < arr.length; i++) {\n    if (looseEqual(arr[i], val)) return i;\n  }\n  return -1;\n}\n\n/**\n * Ensure a function is called only once.\n */\nfunction once(fn) {\n  var called = false;\n  return function () {\n    if (!called) {\n      called = true;\n      fn.apply(this, arguments);\n    }\n  };\n}\n\n//# sourceURL=webpack://Vue/./src/shared/util.js?");

/***/ })

/******/ });
});
