{"version":3,"file":"js/6179-2df6364e02c19ed0b147.js","mappings":"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","sources":["webpack://slaask/./node_modules/vue-loader/lib/runtime/componentNormalizer.js","webpack://slaask/./node_modules/vue-router/dist/vue-router.esm.js","webpack://slaask/./node_modules/vue/dist/vue.esm.js"],"sourcesContent":["/* globals __VUE_SSR_CONTEXT__ */\n\n// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).\n// This module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle.\n\nexport default function normalizeComponent(\n  scriptExports,\n  render,\n  staticRenderFns,\n  functionalTemplate,\n  injectStyles,\n  scopeId,\n  moduleIdentifier /* server only */,\n  shadowMode /* vue-cli only */\n) {\n  // Vue.extend constructor export interop\n  var options =\n    typeof scriptExports === 'function' ? scriptExports.options : scriptExports\n\n  // render functions\n  if (render) {\n    options.render = render\n    options.staticRenderFns = staticRenderFns\n    options._compiled = true\n  }\n\n  // functional template\n  if (functionalTemplate) {\n    options.functional = true\n  }\n\n  // scopedId\n  if (scopeId) {\n    options._scopeId = 'data-v-' + scopeId\n  }\n\n  var hook\n  if (moduleIdentifier) {\n    // server build\n    hook = function (context) {\n      // 2.3 injection\n      context =\n        context || // cached call\n        (this.$vnode && this.$vnode.ssrContext) || // stateful\n        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n      // 2.2 with runInNewContext: true\n      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n        context = __VUE_SSR_CONTEXT__\n      }\n      // inject component styles\n      if (injectStyles) {\n        injectStyles.call(this, context)\n      }\n      // register component module identifier for async chunk inferrence\n      if (context && context._registeredComponents) {\n        context._registeredComponents.add(moduleIdentifier)\n      }\n    }\n    // used by ssr in case component is cached and beforeCreate\n    // never gets called\n    options._ssrRegister = hook\n  } else if (injectStyles) {\n    hook = shadowMode\n      ? function () {\n          injectStyles.call(\n            this,\n            (options.functional ? this.parent : this).$root.$options.shadowRoot\n          )\n        }\n      : injectStyles\n  }\n\n  if (hook) {\n    if (options.functional) {\n      // for template-only hot-reload because in that case the render fn doesn't\n      // go through the normalizer\n      options._injectStyles = hook\n      // register for functional component in vue file\n      var originalRender = options.render\n      options.render = function renderWithStyleInjection(h, context) {\n        hook.call(context)\n        return originalRender(h, context)\n      }\n    } else {\n      // inject component registration as beforeCreate hook\n      var existing = options.beforeCreate\n      options.beforeCreate = existing ? [].concat(existing, hook) : [hook]\n    }\n  }\n\n  return {\n    exports: scriptExports,\n    options: options\n  }\n}\n","/*!\n  * vue-router v3.6.5\n  * (c) 2022 Evan You\n  * @license MIT\n  */\n/*  */\n\nfunction assert (condition, message) {\n  if (!condition) {\n    throw new Error((\"[vue-router] \" + message))\n  }\n}\n\nfunction warn (condition, message) {\n  if (!condition) {\n    typeof console !== 'undefined' && console.warn((\"[vue-router] \" + message));\n  }\n}\n\nfunction extend (a, b) {\n  for (var key in b) {\n    a[key] = b[key];\n  }\n  return a\n}\n\n/*  */\n\nvar encodeReserveRE = /[!'()*]/g;\nvar encodeReserveReplacer = function (c) { return '%' + c.charCodeAt(0).toString(16); };\nvar commaRE = /%2C/g;\n\n// fixed encodeURIComponent which is more conformant to RFC3986:\n// - escapes [!'()*]\n// - preserve commas\nvar encode = function (str) { return encodeURIComponent(str)\n    .replace(encodeReserveRE, encodeReserveReplacer)\n    .replace(commaRE, ','); };\n\nfunction decode (str) {\n  try {\n    return decodeURIComponent(str)\n  } catch (err) {\n    if (process.env.NODE_ENV !== 'production') {\n      warn(false, (\"Error decoding \\\"\" + str + \"\\\". Leaving it intact.\"));\n    }\n  }\n  return str\n}\n\nfunction resolveQuery (\n  query,\n  extraQuery,\n  _parseQuery\n) {\n  if ( extraQuery === void 0 ) extraQuery = {};\n\n  var parse = _parseQuery || parseQuery;\n  var parsedQuery;\n  try {\n    parsedQuery = parse(query || '');\n  } catch (e) {\n    process.env.NODE_ENV !== 'production' && warn(false, e.message);\n    parsedQuery = {};\n  }\n  for (var key in extraQuery) {\n    var value = extraQuery[key];\n    parsedQuery[key] = Array.isArray(value)\n      ? value.map(castQueryParamValue)\n      : castQueryParamValue(value);\n  }\n  return parsedQuery\n}\n\nvar castQueryParamValue = function (value) { return (value == null || typeof value === 'object' ? value : String(value)); };\n\nfunction parseQuery (query) {\n  var res = {};\n\n  query = query.trim().replace(/^(\\?|#|&)/, '');\n\n  if (!query) {\n    return res\n  }\n\n  query.split('&').forEach(function (param) {\n    var parts = param.replace(/\\+/g, ' ').split('=');\n    var key = decode(parts.shift());\n    var val = parts.length > 0 ? decode(parts.join('=')) : null;\n\n    if (res[key] === undefined) {\n      res[key] = val;\n    } else if (Array.isArray(res[key])) {\n      res[key].push(val);\n    } else {\n      res[key] = [res[key], val];\n    }\n  });\n\n  return res\n}\n\nfunction stringifyQuery (obj) {\n  var res = obj\n    ? Object.keys(obj)\n      .map(function (key) {\n        var val = obj[key];\n\n        if (val === undefined) {\n          return ''\n        }\n\n        if (val === null) {\n          return encode(key)\n        }\n\n        if (Array.isArray(val)) {\n          var result = [];\n          val.forEach(function (val2) {\n            if (val2 === undefined) {\n              return\n            }\n            if (val2 === null) {\n              result.push(encode(key));\n            } else {\n              result.push(encode(key) + '=' + encode(val2));\n            }\n          });\n          return result.join('&')\n        }\n\n        return encode(key) + '=' + encode(val)\n      })\n      .filter(function (x) { return x.length > 0; })\n      .join('&')\n    : null;\n  return res ? (\"?\" + res) : ''\n}\n\n/*  */\n\nvar trailingSlashRE = /\\/?$/;\n\nfunction createRoute (\n  record,\n  location,\n  redirectedFrom,\n  router\n) {\n  var stringifyQuery = router && router.options.stringifyQuery;\n\n  var query = location.query || {};\n  try {\n    query = clone(query);\n  } catch (e) {}\n\n  var route = {\n    name: location.name || (record && record.name),\n    meta: (record && record.meta) || {},\n    path: location.path || '/',\n    hash: location.hash || '',\n    query: query,\n    params: location.params || {},\n    fullPath: getFullPath(location, stringifyQuery),\n    matched: record ? formatMatch(record) : []\n  };\n  if (redirectedFrom) {\n    route.redirectedFrom = getFullPath(redirectedFrom, stringifyQuery);\n  }\n  return Object.freeze(route)\n}\n\nfunction clone (value) {\n  if (Array.isArray(value)) {\n    return value.map(clone)\n  } else if (value && typeof value === 'object') {\n    var res = {};\n    for (var key in value) {\n      res[key] = clone(value[key]);\n    }\n    return res\n  } else {\n    return value\n  }\n}\n\n// the starting route that represents the initial state\nvar START = createRoute(null, {\n  path: '/'\n});\n\nfunction formatMatch (record) {\n  var res = [];\n  while (record) {\n    res.unshift(record);\n    record = record.parent;\n  }\n  return res\n}\n\nfunction getFullPath (\n  ref,\n  _stringifyQuery\n) {\n  var path = ref.path;\n  var query = ref.query; if ( query === void 0 ) query = {};\n  var hash = ref.hash; if ( hash === void 0 ) hash = '';\n\n  var stringify = _stringifyQuery || stringifyQuery;\n  return (path || '/') + stringify(query) + hash\n}\n\nfunction isSameRoute (a, b, onlyPath) {\n  if (b === START) {\n    return a === b\n  } else if (!b) {\n    return false\n  } else if (a.path && b.path) {\n    return a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') && (onlyPath ||\n      a.hash === b.hash &&\n      isObjectEqual(a.query, b.query))\n  } else if (a.name && b.name) {\n    return (\n      a.name === b.name &&\n      (onlyPath || (\n        a.hash === b.hash &&\n      isObjectEqual(a.query, b.query) &&\n      isObjectEqual(a.params, b.params))\n      )\n    )\n  } else {\n    return false\n  }\n}\n\nfunction isObjectEqual (a, b) {\n  if ( a === void 0 ) a = {};\n  if ( b === void 0 ) b = {};\n\n  // handle null value #1566\n  if (!a || !b) { return a === b }\n  var aKeys = Object.keys(a).sort();\n  var bKeys = Object.keys(b).sort();\n  if (aKeys.length !== bKeys.length) {\n    return false\n  }\n  return aKeys.every(function (key, i) {\n    var aVal = a[key];\n    var bKey = bKeys[i];\n    if (bKey !== key) { return false }\n    var bVal = b[key];\n    // query values can be null and undefined\n    if (aVal == null || bVal == null) { return aVal === bVal }\n    // check nested equality\n    if (typeof aVal === 'object' && typeof bVal === 'object') {\n      return isObjectEqual(aVal, bVal)\n    }\n    return String(aVal) === String(bVal)\n  })\n}\n\nfunction isIncludedRoute (current, target) {\n  return (\n    current.path.replace(trailingSlashRE, '/').indexOf(\n      target.path.replace(trailingSlashRE, '/')\n    ) === 0 &&\n    (!target.hash || current.hash === target.hash) &&\n    queryIncludes(current.query, target.query)\n  )\n}\n\nfunction queryIncludes (current, target) {\n  for (var key in target) {\n    if (!(key in current)) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction handleRouteEntered (route) {\n  for (var i = 0; i < route.matched.length; i++) {\n    var record = route.matched[i];\n    for (var name in record.instances) {\n      var instance = record.instances[name];\n      var cbs = record.enteredCbs[name];\n      if (!instance || !cbs) { continue }\n      delete record.enteredCbs[name];\n      for (var i$1 = 0; i$1 < cbs.length; i$1++) {\n        if (!instance._isBeingDestroyed) { cbs[i$1](instance); }\n      }\n    }\n  }\n}\n\nvar View = {\n  name: 'RouterView',\n  functional: true,\n  props: {\n    name: {\n      type: String,\n      default: 'default'\n    }\n  },\n  render: function render (_, ref) {\n    var props = ref.props;\n    var children = ref.children;\n    var parent = ref.parent;\n    var data = ref.data;\n\n    // used by devtools to display a router-view badge\n    data.routerView = true;\n\n    // directly use parent context's createElement() function\n    // so that components rendered by router-view can resolve named slots\n    var h = parent.$createElement;\n    var name = props.name;\n    var route = parent.$route;\n    var cache = parent._routerViewCache || (parent._routerViewCache = {});\n\n    // determine current view depth, also check to see if the tree\n    // has been toggled inactive but kept-alive.\n    var depth = 0;\n    var inactive = false;\n    while (parent && parent._routerRoot !== parent) {\n      var vnodeData = parent.$vnode ? parent.$vnode.data : {};\n      if (vnodeData.routerView) {\n        depth++;\n      }\n      if (vnodeData.keepAlive && parent._directInactive && parent._inactive) {\n        inactive = true;\n      }\n      parent = parent.$parent;\n    }\n    data.routerViewDepth = depth;\n\n    // render previous view if the tree is inactive and kept-alive\n    if (inactive) {\n      var cachedData = cache[name];\n      var cachedComponent = cachedData && cachedData.component;\n      if (cachedComponent) {\n        // #2301\n        // pass props\n        if (cachedData.configProps) {\n          fillPropsinData(cachedComponent, data, cachedData.route, cachedData.configProps);\n        }\n        return h(cachedComponent, data, children)\n      } else {\n        // render previous empty view\n        return h()\n      }\n    }\n\n    var matched = route.matched[depth];\n    var component = matched && matched.components[name];\n\n    // render empty node if no matched route or no config component\n    if (!matched || !component) {\n      cache[name] = null;\n      return h()\n    }\n\n    // cache component\n    cache[name] = { component: component };\n\n    // attach instance registration hook\n    // this will be called in the instance's injected lifecycle hooks\n    data.registerRouteInstance = function (vm, val) {\n      // val could be undefined for unregistration\n      var current = matched.instances[name];\n      if (\n        (val && current !== vm) ||\n        (!val && current === vm)\n      ) {\n        matched.instances[name] = val;\n      }\n    }\n\n    // also register instance in prepatch hook\n    // in case the same component instance is reused across different routes\n    ;(data.hook || (data.hook = {})).prepatch = function (_, vnode) {\n      matched.instances[name] = vnode.componentInstance;\n    };\n\n    // register instance in init hook\n    // in case kept-alive component be actived when routes changed\n    data.hook.init = function (vnode) {\n      if (vnode.data.keepAlive &&\n        vnode.componentInstance &&\n        vnode.componentInstance !== matched.instances[name]\n      ) {\n        matched.instances[name] = vnode.componentInstance;\n      }\n\n      // if the route transition has already been confirmed then we weren't\n      // able to call the cbs during confirmation as the component was not\n      // registered yet, so we call it here.\n      handleRouteEntered(route);\n    };\n\n    var configProps = matched.props && matched.props[name];\n    // save route and configProps in cache\n    if (configProps) {\n      extend(cache[name], {\n        route: route,\n        configProps: configProps\n      });\n      fillPropsinData(component, data, route, configProps);\n    }\n\n    return h(component, data, children)\n  }\n};\n\nfunction fillPropsinData (component, data, route, configProps) {\n  // resolve props\n  var propsToPass = data.props = resolveProps(route, configProps);\n  if (propsToPass) {\n    // clone to prevent mutation\n    propsToPass = data.props = extend({}, propsToPass);\n    // pass non-declared props as attrs\n    var attrs = data.attrs = data.attrs || {};\n    for (var key in propsToPass) {\n      if (!component.props || !(key in component.props)) {\n        attrs[key] = propsToPass[key];\n        delete propsToPass[key];\n      }\n    }\n  }\n}\n\nfunction resolveProps (route, config) {\n  switch (typeof config) {\n    case 'undefined':\n      return\n    case 'object':\n      return config\n    case 'function':\n      return config(route)\n    case 'boolean':\n      return config ? route.params : undefined\n    default:\n      if (process.env.NODE_ENV !== 'production') {\n        warn(\n          false,\n          \"props in \\\"\" + (route.path) + \"\\\" is a \" + (typeof config) + \", \" +\n          \"expecting an object, function or boolean.\"\n        );\n      }\n  }\n}\n\n/*  */\n\nfunction resolvePath (\n  relative,\n  base,\n  append\n) {\n  var firstChar = relative.charAt(0);\n  if (firstChar === '/') {\n    return relative\n  }\n\n  if (firstChar === '?' || firstChar === '#') {\n    return base + relative\n  }\n\n  var stack = base.split('/');\n\n  // remove trailing segment if:\n  // - not appending\n  // - appending to trailing slash (last segment is empty)\n  if (!append || !stack[stack.length - 1]) {\n    stack.pop();\n  }\n\n  // resolve relative path\n  var segments = relative.replace(/^\\//, '').split('/');\n  for (var i = 0; i < segments.length; i++) {\n    var segment = segments[i];\n    if (segment === '..') {\n      stack.pop();\n    } else if (segment !== '.') {\n      stack.push(segment);\n    }\n  }\n\n  // ensure leading slash\n  if (stack[0] !== '') {\n    stack.unshift('');\n  }\n\n  return stack.join('/')\n}\n\nfunction parsePath (path) {\n  var hash = '';\n  var query = '';\n\n  var hashIndex = path.indexOf('#');\n  if (hashIndex >= 0) {\n    hash = path.slice(hashIndex);\n    path = path.slice(0, hashIndex);\n  }\n\n  var queryIndex = path.indexOf('?');\n  if (queryIndex >= 0) {\n    query = path.slice(queryIndex + 1);\n    path = path.slice(0, queryIndex);\n  }\n\n  return {\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\nfunction cleanPath (path) {\n  return path.replace(/\\/(?:\\s*\\/)+/g, '/')\n}\n\nvar isarray = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\n/**\n * Expose `pathToRegexp`.\n */\nvar pathToRegexp_1 = pathToRegexp;\nvar parse_1 = parse;\nvar compile_1 = compile;\nvar tokensToFunction_1 = tokensToFunction;\nvar tokensToRegExp_1 = tokensToRegExp;\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n  // \"/route(\\\\d+)\"  => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n  // \"/*\"            => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n  '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g');\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = [];\n  var key = 0;\n  var index = 0;\n  var path = '';\n  var defaultDelimiter = options && options.delimiter || '/';\n  var res;\n\n  while ((res = PATH_REGEXP.exec(str)) != null) {\n    var m = res[0];\n    var escaped = res[1];\n    var offset = res.index;\n    path += str.slice(index, offset);\n    index = offset + m.length;\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1];\n      continue\n    }\n\n    var next = str[index];\n    var prefix = res[2];\n    var name = res[3];\n    var capture = res[4];\n    var group = res[5];\n    var modifier = res[6];\n    var asterisk = res[7];\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path);\n      path = '';\n    }\n\n    var partial = prefix != null && next != null && next !== prefix;\n    var repeat = modifier === '+' || modifier === '*';\n    var optional = modifier === '?' || modifier === '*';\n    var delimiter = res[2] || defaultDelimiter;\n    var pattern = capture || group;\n\n    tokens.push({\n      name: name || key++,\n      prefix: prefix || '',\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      asterisk: !!asterisk,\n      pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n    });\n  }\n\n  // Match any characters still remaining.\n  if (index < str.length) {\n    path += str.substr(index);\n  }\n\n  // If the path exists, push it onto the end.\n  if (path) {\n    tokens.push(path);\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options), options)\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n  return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n  return encodeURI(str).replace(/[?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens, options) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length);\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$', flags(options));\n    }\n  }\n\n  return function (obj, opts) {\n    var path = '';\n    var data = obj || {};\n    var options = opts || {};\n    var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i];\n\n      if (typeof token === 'string') {\n        path += token;\n\n        continue\n      }\n\n      var value = data[token.name];\n      var segment;\n\n      if (value == null) {\n        if (token.optional) {\n          // Prepend partial segment prefixes.\n          if (token.partial) {\n            path += token.prefix;\n          }\n\n          continue\n        } else {\n          throw new TypeError('Expected \"' + token.name + '\" to be defined')\n        }\n      }\n\n      if (isarray(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) {\n            continue\n          } else {\n            throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n          }\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j]);\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment;\n        }\n\n        continue\n      }\n\n      segment = token.asterisk ? encodeAsterisk(value) : encode(value);\n\n      if (!matches[i].test(segment)) {\n        throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n      }\n\n      path += token.prefix + segment;\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param  {!RegExp} re\n * @param  {Array}   keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n  re.keys = keys;\n  return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options && options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {!Array}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g);\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        asterisk: false,\n        pattern: null\n      });\n    }\n  }\n\n  return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array}   keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = [];\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp(path[i], keys, options).source);\n  }\n\n  var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));\n\n  return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {!Array}  keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}          tokens\n * @param  {(Array|Object)=} keys\n * @param  {Object=}         options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  var strict = options.strict;\n  var end = options.end !== false;\n  var route = '';\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i];\n\n    if (typeof token === 'string') {\n      route += escapeString(token);\n    } else {\n      var prefix = escapeString(token.prefix);\n      var capture = '(?:' + token.pattern + ')';\n\n      keys.push(token);\n\n      if (token.repeat) {\n        capture += '(?:' + prefix + capture + ')*';\n      }\n\n      if (token.optional) {\n        if (!token.partial) {\n          capture = '(?:' + prefix + '(' + capture + '))?';\n        } else {\n          capture = prefix + '(' + capture + ')?';\n        }\n      } else {\n        capture = prefix + '(' + capture + ')';\n      }\n\n      route += capture;\n    }\n  }\n\n  var delimiter = escapeString(options.delimiter || '/');\n  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;\n\n  // In non-strict mode we allow a slash at the end of match. If the path to\n  // match already ends with a slash, we remove it for consistency. The slash\n  // is valid at the end of a path match, not in the middle. This is important\n  // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n  if (!strict) {\n    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';\n  }\n\n  if (end) {\n    route += '$';\n  } else {\n    // In non-ending mode, we need the capturing groups to match as much as\n    // possible by using a positive lookahead to the end or next path segment.\n    route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';\n  }\n\n  return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {(Array|Object)=}       keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, /** @type {!Array} */ (keys))\n  }\n\n  if (isarray(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\npathToRegexp_1.parse = parse_1;\npathToRegexp_1.compile = compile_1;\npathToRegexp_1.tokensToFunction = tokensToFunction_1;\npathToRegexp_1.tokensToRegExp = tokensToRegExp_1;\n\n/*  */\n\n// $flow-disable-line\nvar regexpCompileCache = Object.create(null);\n\nfunction fillParams (\n  path,\n  params,\n  routeMsg\n) {\n  params = params || {};\n  try {\n    var filler =\n      regexpCompileCache[path] ||\n      (regexpCompileCache[path] = pathToRegexp_1.compile(path));\n\n    // Fix #2505 resolving asterisk routes { name: 'not-found', params: { pathMatch: '/not-found' }}\n    // and fix #3106 so that you can work with location descriptor object having params.pathMatch equal to empty string\n    if (typeof params.pathMatch === 'string') { params[0] = params.pathMatch; }\n\n    return filler(params, { pretty: true })\n  } catch (e) {\n    if (process.env.NODE_ENV !== 'production') {\n      // Fix #3072 no warn if `pathMatch` is string\n      warn(typeof params.pathMatch === 'string', (\"missing param for \" + routeMsg + \": \" + (e.message)));\n    }\n    return ''\n  } finally {\n    // delete the 0 if it was added\n    delete params[0];\n  }\n}\n\n/*  */\n\nfunction normalizeLocation (\n  raw,\n  current,\n  append,\n  router\n) {\n  var next = typeof raw === 'string' ? { path: raw } : raw;\n  // named target\n  if (next._normalized) {\n    return next\n  } else if (next.name) {\n    next = extend({}, raw);\n    var params = next.params;\n    if (params && typeof params === 'object') {\n      next.params = extend({}, params);\n    }\n    return next\n  }\n\n  // relative params\n  if (!next.path && next.params && current) {\n    next = extend({}, next);\n    next._normalized = true;\n    var params$1 = extend(extend({}, current.params), next.params);\n    if (current.name) {\n      next.name = current.name;\n      next.params = params$1;\n    } else if (current.matched.length) {\n      var rawPath = current.matched[current.matched.length - 1].path;\n      next.path = fillParams(rawPath, params$1, (\"path \" + (current.path)));\n    } else if (process.env.NODE_ENV !== 'production') {\n      warn(false, \"relative params navigation requires a current route.\");\n    }\n    return next\n  }\n\n  var parsedPath = parsePath(next.path || '');\n  var basePath = (current && current.path) || '/';\n  var path = parsedPath.path\n    ? resolvePath(parsedPath.path, basePath, append || next.append)\n    : basePath;\n\n  var query = resolveQuery(\n    parsedPath.query,\n    next.query,\n    router && router.options.parseQuery\n  );\n\n  var hash = next.hash || parsedPath.hash;\n  if (hash && hash.charAt(0) !== '#') {\n    hash = \"#\" + hash;\n  }\n\n  return {\n    _normalized: true,\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\n/*  */\n\n// work around weird flow bug\nvar toTypes = [String, Object];\nvar eventTypes = [String, Array];\n\nvar noop = function () {};\n\nvar warnedCustomSlot;\nvar warnedTagProp;\nvar warnedEventProp;\n\nvar Link = {\n  name: 'RouterLink',\n  props: {\n    to: {\n      type: toTypes,\n      required: true\n    },\n    tag: {\n      type: String,\n      default: 'a'\n    },\n    custom: Boolean,\n    exact: Boolean,\n    exactPath: Boolean,\n    append: Boolean,\n    replace: Boolean,\n    activeClass: String,\n    exactActiveClass: String,\n    ariaCurrentValue: {\n      type: String,\n      default: 'page'\n    },\n    event: {\n      type: eventTypes,\n      default: 'click'\n    }\n  },\n  render: function render (h) {\n    var this$1$1 = this;\n\n    var router = this.$router;\n    var current = this.$route;\n    var ref = router.resolve(\n      this.to,\n      current,\n      this.append\n    );\n    var location = ref.location;\n    var route = ref.route;\n    var href = ref.href;\n\n    var classes = {};\n    var globalActiveClass = router.options.linkActiveClass;\n    var globalExactActiveClass = router.options.linkExactActiveClass;\n    // Support global empty active class\n    var activeClassFallback =\n      globalActiveClass == null ? 'router-link-active' : globalActiveClass;\n    var exactActiveClassFallback =\n      globalExactActiveClass == null\n        ? 'router-link-exact-active'\n        : globalExactActiveClass;\n    var activeClass =\n      this.activeClass == null ? activeClassFallback : this.activeClass;\n    var exactActiveClass =\n      this.exactActiveClass == null\n        ? exactActiveClassFallback\n        : this.exactActiveClass;\n\n    var compareTarget = route.redirectedFrom\n      ? createRoute(null, normalizeLocation(route.redirectedFrom), null, router)\n      : route;\n\n    classes[exactActiveClass] = isSameRoute(current, compareTarget, this.exactPath);\n    classes[activeClass] = this.exact || this.exactPath\n      ? classes[exactActiveClass]\n      : isIncludedRoute(current, compareTarget);\n\n    var ariaCurrentValue = classes[exactActiveClass] ? this.ariaCurrentValue : null;\n\n    var handler = function (e) {\n      if (guardEvent(e)) {\n        if (this$1$1.replace) {\n          router.replace(location, noop);\n        } else {\n          router.push(location, noop);\n        }\n      }\n    };\n\n    var on = { click: guardEvent };\n    if (Array.isArray(this.event)) {\n      this.event.forEach(function (e) {\n        on[e] = handler;\n      });\n    } else {\n      on[this.event] = handler;\n    }\n\n    var data = { class: classes };\n\n    var scopedSlot =\n      !this.$scopedSlots.$hasNormal &&\n      this.$scopedSlots.default &&\n      this.$scopedSlots.default({\n        href: href,\n        route: route,\n        navigate: handler,\n        isActive: classes[activeClass],\n        isExactActive: classes[exactActiveClass]\n      });\n\n    if (scopedSlot) {\n      if (process.env.NODE_ENV !== 'production' && !this.custom) {\n        !warnedCustomSlot && warn(false, 'In Vue Router 4, the v-slot API will by default wrap its content with an <a> element. Use the custom prop to remove this warning:\\n<router-link v-slot=\"{ navigate, href }\" custom></router-link>\\n');\n        warnedCustomSlot = true;\n      }\n      if (scopedSlot.length === 1) {\n        return scopedSlot[0]\n      } else if (scopedSlot.length > 1 || !scopedSlot.length) {\n        if (process.env.NODE_ENV !== 'production') {\n          warn(\n            false,\n            (\"<router-link> with to=\\\"\" + (this.to) + \"\\\" is trying to use a scoped slot but it didn't provide exactly one child. Wrapping the content with a span element.\")\n          );\n        }\n        return scopedSlot.length === 0 ? h() : h('span', {}, scopedSlot)\n      }\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      if ('tag' in this.$options.propsData && !warnedTagProp) {\n        warn(\n          false,\n          \"<router-link>'s tag prop is deprecated and has been removed in Vue Router 4. Use the v-slot API to remove this warning: https://next.router.vuejs.org/guide/migration/#removal-of-event-and-tag-props-in-router-link.\"\n        );\n        warnedTagProp = true;\n      }\n      if ('event' in this.$options.propsData && !warnedEventProp) {\n        warn(\n          false,\n          \"<router-link>'s event prop is deprecated and has been removed in Vue Router 4. Use the v-slot API to remove this warning: https://next.router.vuejs.org/guide/migration/#removal-of-event-and-tag-props-in-router-link.\"\n        );\n        warnedEventProp = true;\n      }\n    }\n\n    if (this.tag === 'a') {\n      data.on = on;\n      data.attrs = { href: href, 'aria-current': ariaCurrentValue };\n    } else {\n      // find the first <a> child and apply listener and href\n      var a = findAnchor(this.$slots.default);\n      if (a) {\n        // in case the <a> is a static node\n        a.isStatic = false;\n        var aData = (a.data = extend({}, a.data));\n        aData.on = aData.on || {};\n        // transform existing events in both objects into arrays so we can push later\n        for (var event in aData.on) {\n          var handler$1 = aData.on[event];\n          if (event in on) {\n            aData.on[event] = Array.isArray(handler$1) ? handler$1 : [handler$1];\n          }\n        }\n        // append new listeners for router-link\n        for (var event$1 in on) {\n          if (event$1 in aData.on) {\n            // on[event] is always a function\n            aData.on[event$1].push(on[event$1]);\n          } else {\n            aData.on[event$1] = handler;\n          }\n        }\n\n        var aAttrs = (a.data.attrs = extend({}, a.data.attrs));\n        aAttrs.href = href;\n        aAttrs['aria-current'] = ariaCurrentValue;\n      } else {\n        // doesn't have <a> child, apply listener to self\n        data.on = on;\n      }\n    }\n\n    return h(this.tag, data, this.$slots.default)\n  }\n};\n\nfunction guardEvent (e) {\n  // don't redirect with control keys\n  if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) { return }\n  // don't redirect when preventDefault called\n  if (e.defaultPrevented) { return }\n  // don't redirect on right click\n  if (e.button !== undefined && e.button !== 0) { return }\n  // don't redirect if `target=\"_blank\"`\n  if (e.currentTarget && e.currentTarget.getAttribute) {\n    var target = e.currentTarget.getAttribute('target');\n    if (/\\b_blank\\b/i.test(target)) { return }\n  }\n  // this may be a Weex event which doesn't have this method\n  if (e.preventDefault) {\n    e.preventDefault();\n  }\n  return true\n}\n\nfunction findAnchor (children) {\n  if (children) {\n    var child;\n    for (var i = 0; i < children.length; i++) {\n      child = children[i];\n      if (child.tag === 'a') {\n        return child\n      }\n      if (child.children && (child = findAnchor(child.children))) {\n        return child\n      }\n    }\n  }\n}\n\nvar _Vue;\n\nfunction install (Vue) {\n  if (install.installed && _Vue === Vue) { return }\n  install.installed = true;\n\n  _Vue = Vue;\n\n  var isDef = function (v) { return v !== undefined; };\n\n  var registerInstance = function (vm, callVal) {\n    var i = vm.$options._parentVnode;\n    if (isDef(i) && isDef(i = i.data) && isDef(i = i.registerRouteInstance)) {\n      i(vm, callVal);\n    }\n  };\n\n  Vue.mixin({\n    beforeCreate: function beforeCreate () {\n      if (isDef(this.$options.router)) {\n        this._routerRoot = this;\n        this._router = this.$options.router;\n        this._router.init(this);\n        Vue.util.defineReactive(this, '_route', this._router.history.current);\n      } else {\n        this._routerRoot = (this.$parent && this.$parent._routerRoot) || this;\n      }\n      registerInstance(this, this);\n    },\n    destroyed: function destroyed () {\n      registerInstance(this);\n    }\n  });\n\n  Object.defineProperty(Vue.prototype, '$router', {\n    get: function get () { return this._routerRoot._router }\n  });\n\n  Object.defineProperty(Vue.prototype, '$route', {\n    get: function get () { return this._routerRoot._route }\n  });\n\n  Vue.component('RouterView', View);\n  Vue.component('RouterLink', Link);\n\n  var strats = Vue.config.optionMergeStrategies;\n  // use the same hook merging strategy for route hooks\n  strats.beforeRouteEnter = strats.beforeRouteLeave = strats.beforeRouteUpdate = strats.created;\n}\n\n/*  */\n\nvar inBrowser = typeof window !== 'undefined';\n\n/*  */\n\nfunction createRouteMap (\n  routes,\n  oldPathList,\n  oldPathMap,\n  oldNameMap,\n  parentRoute\n) {\n  // the path list is used to control path matching priority\n  var pathList = oldPathList || [];\n  // $flow-disable-line\n  var pathMap = oldPathMap || Object.create(null);\n  // $flow-disable-line\n  var nameMap = oldNameMap || Object.create(null);\n\n  routes.forEach(function (route) {\n    addRouteRecord(pathList, pathMap, nameMap, route, parentRoute);\n  });\n\n  // ensure wildcard routes are always at the end\n  for (var i = 0, l = pathList.length; i < l; i++) {\n    if (pathList[i] === '*') {\n      pathList.push(pathList.splice(i, 1)[0]);\n      l--;\n      i--;\n    }\n  }\n\n  if (process.env.NODE_ENV === 'development') {\n    // warn if routes do not include leading slashes\n    var found = pathList\n    // check for missing leading slash\n      .filter(function (path) { return path && path.charAt(0) !== '*' && path.charAt(0) !== '/'; });\n\n    if (found.length > 0) {\n      var pathNames = found.map(function (path) { return (\"- \" + path); }).join('\\n');\n      warn(false, (\"Non-nested routes must include a leading slash character. Fix the following routes: \\n\" + pathNames));\n    }\n  }\n\n  return {\n    pathList: pathList,\n    pathMap: pathMap,\n    nameMap: nameMap\n  }\n}\n\nfunction addRouteRecord (\n  pathList,\n  pathMap,\n  nameMap,\n  route,\n  parent,\n  matchAs\n) {\n  var path = route.path;\n  var name = route.name;\n  if (process.env.NODE_ENV !== 'production') {\n    assert(path != null, \"\\\"path\\\" is required in a route configuration.\");\n    assert(\n      typeof route.component !== 'string',\n      \"route config \\\"component\\\" for path: \" + (String(\n        path || name\n      )) + \" cannot be a \" + \"string id. Use an actual component instead.\"\n    );\n\n    warn(\n      // eslint-disable-next-line no-control-regex\n      !/[^\\u0000-\\u007F]+/.test(path),\n      \"Route with path \\\"\" + path + \"\\\" contains unencoded characters, make sure \" +\n        \"your path is correctly encoded before passing it to the router. Use \" +\n        \"encodeURI to encode static segments of your path.\"\n    );\n  }\n\n  var pathToRegexpOptions =\n    route.pathToRegexpOptions || {};\n  var normalizedPath = normalizePath(path, parent, pathToRegexpOptions.strict);\n\n  if (typeof route.caseSensitive === 'boolean') {\n    pathToRegexpOptions.sensitive = route.caseSensitive;\n  }\n\n  var record = {\n    path: normalizedPath,\n    regex: compileRouteRegex(normalizedPath, pathToRegexpOptions),\n    components: route.components || { default: route.component },\n    alias: route.alias\n      ? typeof route.alias === 'string'\n        ? [route.alias]\n        : route.alias\n      : [],\n    instances: {},\n    enteredCbs: {},\n    name: name,\n    parent: parent,\n    matchAs: matchAs,\n    redirect: route.redirect,\n    beforeEnter: route.beforeEnter,\n    meta: route.meta || {},\n    props:\n      route.props == null\n        ? {}\n        : route.components\n          ? route.props\n          : { default: route.props }\n  };\n\n  if (route.children) {\n    // Warn if route is named, does not redirect and has a default child route.\n    // If users navigate to this route by name, the default child will\n    // not be rendered (GH Issue #629)\n    if (process.env.NODE_ENV !== 'production') {\n      if (\n        route.name &&\n        !route.redirect &&\n        route.children.some(function (child) { return /^\\/?$/.test(child.path); })\n      ) {\n        warn(\n          false,\n          \"Named Route '\" + (route.name) + \"' has a default child route. \" +\n            \"When navigating to this named route (:to=\\\"{name: '\" + (route.name) + \"'}\\\"), \" +\n            \"the default child route will not be rendered. Remove the name from \" +\n            \"this route and use the name of the default child route for named \" +\n            \"links instead.\"\n        );\n      }\n    }\n    route.children.forEach(function (child) {\n      var childMatchAs = matchAs\n        ? cleanPath((matchAs + \"/\" + (child.path)))\n        : undefined;\n      addRouteRecord(pathList, pathMap, nameMap, child, record, childMatchAs);\n    });\n  }\n\n  if (!pathMap[record.path]) {\n    pathList.push(record.path);\n    pathMap[record.path] = record;\n  }\n\n  if (route.alias !== undefined) {\n    var aliases = Array.isArray(route.alias) ? route.alias : [route.alias];\n    for (var i = 0; i < aliases.length; ++i) {\n      var alias = aliases[i];\n      if (process.env.NODE_ENV !== 'production' && alias === path) {\n        warn(\n          false,\n          (\"Found an alias with the same value as the path: \\\"\" + path + \"\\\". You have to remove that alias. It will be ignored in development.\")\n        );\n        // skip in dev to make it work\n        continue\n      }\n\n      var aliasRoute = {\n        path: alias,\n        children: route.children\n      };\n      addRouteRecord(\n        pathList,\n        pathMap,\n        nameMap,\n        aliasRoute,\n        parent,\n        record.path || '/' // matchAs\n      );\n    }\n  }\n\n  if (name) {\n    if (!nameMap[name]) {\n      nameMap[name] = record;\n    } else if (process.env.NODE_ENV !== 'production' && !matchAs) {\n      warn(\n        false,\n        \"Duplicate named routes definition: \" +\n          \"{ name: \\\"\" + name + \"\\\", path: \\\"\" + (record.path) + \"\\\" }\"\n      );\n    }\n  }\n}\n\nfunction compileRouteRegex (\n  path,\n  pathToRegexpOptions\n) {\n  var regex = pathToRegexp_1(path, [], pathToRegexpOptions);\n  if (process.env.NODE_ENV !== 'production') {\n    var keys = Object.create(null);\n    regex.keys.forEach(function (key) {\n      warn(\n        !keys[key.name],\n        (\"Duplicate param keys in route with path: \\\"\" + path + \"\\\"\")\n      );\n      keys[key.name] = true;\n    });\n  }\n  return regex\n}\n\nfunction normalizePath (\n  path,\n  parent,\n  strict\n) {\n  if (!strict) { path = path.replace(/\\/$/, ''); }\n  if (path[0] === '/') { return path }\n  if (parent == null) { return path }\n  return cleanPath(((parent.path) + \"/\" + path))\n}\n\n/*  */\n\n\n\nfunction createMatcher (\n  routes,\n  router\n) {\n  var ref = createRouteMap(routes);\n  var pathList = ref.pathList;\n  var pathMap = ref.pathMap;\n  var nameMap = ref.nameMap;\n\n  function addRoutes (routes) {\n    createRouteMap(routes, pathList, pathMap, nameMap);\n  }\n\n  function addRoute (parentOrRoute, route) {\n    var parent = (typeof parentOrRoute !== 'object') ? nameMap[parentOrRoute] : undefined;\n    // $flow-disable-line\n    createRouteMap([route || parentOrRoute], pathList, pathMap, nameMap, parent);\n\n    // add aliases of parent\n    if (parent && parent.alias.length) {\n      createRouteMap(\n        // $flow-disable-line route is defined if parent is\n        parent.alias.map(function (alias) { return ({ path: alias, children: [route] }); }),\n        pathList,\n        pathMap,\n        nameMap,\n        parent\n      );\n    }\n  }\n\n  function getRoutes () {\n    return pathList.map(function (path) { return pathMap[path]; })\n  }\n\n  function match (\n    raw,\n    currentRoute,\n    redirectedFrom\n  ) {\n    var location = normalizeLocation(raw, currentRoute, false, router);\n    var name = location.name;\n\n    if (name) {\n      var record = nameMap[name];\n      if (process.env.NODE_ENV !== 'production') {\n        warn(record, (\"Route with name '\" + name + \"' does not exist\"));\n      }\n      if (!record) { return _createRoute(null, location) }\n      var paramNames = record.regex.keys\n        .filter(function (key) { return !key.optional; })\n        .map(function (key) { return key.name; });\n\n      if (typeof location.params !== 'object') {\n        location.params = {};\n      }\n\n      if (currentRoute && typeof currentRoute.params === 'object') {\n        for (var key in currentRoute.params) {\n          if (!(key in location.params) && paramNames.indexOf(key) > -1) {\n            location.params[key] = currentRoute.params[key];\n          }\n        }\n      }\n\n      location.path = fillParams(record.path, location.params, (\"named route \\\"\" + name + \"\\\"\"));\n      return _createRoute(record, location, redirectedFrom)\n    } else if (location.path) {\n      location.params = {};\n      for (var i = 0; i < pathList.length; i++) {\n        var path = pathList[i];\n        var record$1 = pathMap[path];\n        if (matchRoute(record$1.regex, location.path, location.params)) {\n          return _createRoute(record$1, location, redirectedFrom)\n        }\n      }\n    }\n    // no match\n    return _createRoute(null, location)\n  }\n\n  function redirect (\n    record,\n    location\n  ) {\n    var originalRedirect = record.redirect;\n    var redirect = typeof originalRedirect === 'function'\n      ? originalRedirect(createRoute(record, location, null, router))\n      : originalRedirect;\n\n    if (typeof redirect === 'string') {\n      redirect = { path: redirect };\n    }\n\n    if (!redirect || typeof redirect !== 'object') {\n      if (process.env.NODE_ENV !== 'production') {\n        warn(\n          false, (\"invalid redirect option: \" + (JSON.stringify(redirect)))\n        );\n      }\n      return _createRoute(null, location)\n    }\n\n    var re = redirect;\n    var name = re.name;\n    var path = re.path;\n    var query = location.query;\n    var hash = location.hash;\n    var params = location.params;\n    query = re.hasOwnProperty('query') ? re.query : query;\n    hash = re.hasOwnProperty('hash') ? re.hash : hash;\n    params = re.hasOwnProperty('params') ? re.params : params;\n\n    if (name) {\n      // resolved named direct\n      var targetRecord = nameMap[name];\n      if (process.env.NODE_ENV !== 'production') {\n        assert(targetRecord, (\"redirect failed: named route \\\"\" + name + \"\\\" not found.\"));\n      }\n      return match({\n        _normalized: true,\n        name: name,\n        query: query,\n        hash: hash,\n        params: params\n      }, undefined, location)\n    } else if (path) {\n      // 1. resolve relative redirect\n      var rawPath = resolveRecordPath(path, record);\n      // 2. resolve params\n      var resolvedPath = fillParams(rawPath, params, (\"redirect route with path \\\"\" + rawPath + \"\\\"\"));\n      // 3. rematch with existing query and hash\n      return match({\n        _normalized: true,\n        path: resolvedPath,\n        query: query,\n        hash: hash\n      }, undefined, location)\n    } else {\n      if (process.env.NODE_ENV !== 'production') {\n        warn(false, (\"invalid redirect option: \" + (JSON.stringify(redirect))));\n      }\n      return _createRoute(null, location)\n    }\n  }\n\n  function alias (\n    record,\n    location,\n    matchAs\n  ) {\n    var aliasedPath = fillParams(matchAs, location.params, (\"aliased route with path \\\"\" + matchAs + \"\\\"\"));\n    var aliasedMatch = match({\n      _normalized: true,\n      path: aliasedPath\n    });\n    if (aliasedMatch) {\n      var matched = aliasedMatch.matched;\n      var aliasedRecord = matched[matched.length - 1];\n      location.params = aliasedMatch.params;\n      return _createRoute(aliasedRecord, location)\n    }\n    return _createRoute(null, location)\n  }\n\n  function _createRoute (\n    record,\n    location,\n    redirectedFrom\n  ) {\n    if (record && record.redirect) {\n      return redirect(record, redirectedFrom || location)\n    }\n    if (record && record.matchAs) {\n      return alias(record, location, record.matchAs)\n    }\n    return createRoute(record, location, redirectedFrom, router)\n  }\n\n  return {\n    match: match,\n    addRoute: addRoute,\n    getRoutes: getRoutes,\n    addRoutes: addRoutes\n  }\n}\n\nfunction matchRoute (\n  regex,\n  path,\n  params\n) {\n  var m = path.match(regex);\n\n  if (!m) {\n    return false\n  } else if (!params) {\n    return true\n  }\n\n  for (var i = 1, len = m.length; i < len; ++i) {\n    var key = regex.keys[i - 1];\n    if (key) {\n      // Fix #1994: using * with props: true generates a param named 0\n      params[key.name || 'pathMatch'] = typeof m[i] === 'string' ? decode(m[i]) : m[i];\n    }\n  }\n\n  return true\n}\n\nfunction resolveRecordPath (path, record) {\n  return resolvePath(path, record.parent ? record.parent.path : '/', true)\n}\n\n/*  */\n\n// use User Timing api (if present) for more accurate key precision\nvar Time =\n  inBrowser && window.performance && window.performance.now\n    ? window.performance\n    : Date;\n\nfunction genStateKey () {\n  return Time.now().toFixed(3)\n}\n\nvar _key = genStateKey();\n\nfunction getStateKey () {\n  return _key\n}\n\nfunction setStateKey (key) {\n  return (_key = key)\n}\n\n/*  */\n\nvar positionStore = Object.create(null);\n\nfunction setupScroll () {\n  // Prevent browser scroll behavior on History popstate\n  if ('scrollRestoration' in window.history) {\n    window.history.scrollRestoration = 'manual';\n  }\n  // Fix for #1585 for Firefox\n  // Fix for #2195 Add optional third attribute to workaround a bug in safari https://bugs.webkit.org/show_bug.cgi?id=182678\n  // Fix for #2774 Support for apps loaded from Windows file shares not mapped to network drives: replaced location.origin with\n  // window.location.protocol + '//' + window.location.host\n  // location.host contains the port and location.hostname doesn't\n  var protocolAndPath = window.location.protocol + '//' + window.location.host;\n  var absolutePath = window.location.href.replace(protocolAndPath, '');\n  // preserve existing history state as it could be overriden by the user\n  var stateCopy = extend({}, window.history.state);\n  stateCopy.key = getStateKey();\n  window.history.replaceState(stateCopy, '', absolutePath);\n  window.addEventListener('popstate', handlePopState);\n  return function () {\n    window.removeEventListener('popstate', handlePopState);\n  }\n}\n\nfunction handleScroll (\n  router,\n  to,\n  from,\n  isPop\n) {\n  if (!router.app) {\n    return\n  }\n\n  var behavior = router.options.scrollBehavior;\n  if (!behavior) {\n    return\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    assert(typeof behavior === 'function', \"scrollBehavior must be a function\");\n  }\n\n  // wait until re-render finishes before scrolling\n  router.app.$nextTick(function () {\n    var position = getScrollPosition();\n    var shouldScroll = behavior.call(\n      router,\n      to,\n      from,\n      isPop ? position : null\n    );\n\n    if (!shouldScroll) {\n      return\n    }\n\n    if (typeof shouldScroll.then === 'function') {\n      shouldScroll\n        .then(function (shouldScroll) {\n          scrollToPosition((shouldScroll), position);\n        })\n        .catch(function (err) {\n          if (process.env.NODE_ENV !== 'production') {\n            assert(false, err.toString());\n          }\n        });\n    } else {\n      scrollToPosition(shouldScroll, position);\n    }\n  });\n}\n\nfunction saveScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    positionStore[key] = {\n      x: window.pageXOffset,\n      y: window.pageYOffset\n    };\n  }\n}\n\nfunction handlePopState (e) {\n  saveScrollPosition();\n  if (e.state && e.state.key) {\n    setStateKey(e.state.key);\n  }\n}\n\nfunction getScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    return positionStore[key]\n  }\n}\n\nfunction getElementPosition (el, offset) {\n  var docEl = document.documentElement;\n  var docRect = docEl.getBoundingClientRect();\n  var elRect = el.getBoundingClientRect();\n  return {\n    x: elRect.left - docRect.left - offset.x,\n    y: elRect.top - docRect.top - offset.y\n  }\n}\n\nfunction isValidPosition (obj) {\n  return isNumber(obj.x) || isNumber(obj.y)\n}\n\nfunction normalizePosition (obj) {\n  return {\n    x: isNumber(obj.x) ? obj.x : window.pageXOffset,\n    y: isNumber(obj.y) ? obj.y : window.pageYOffset\n  }\n}\n\nfunction normalizeOffset (obj) {\n  return {\n    x: isNumber(obj.x) ? obj.x : 0,\n    y: isNumber(obj.y) ? obj.y : 0\n  }\n}\n\nfunction isNumber (v) {\n  return typeof v === 'number'\n}\n\nvar hashStartsWithNumberRE = /^#\\d/;\n\nfunction scrollToPosition (shouldScroll, position) {\n  var isObject = typeof shouldScroll === 'object';\n  if (isObject && typeof shouldScroll.selector === 'string') {\n    // getElementById would still fail if the selector contains a more complicated query like #main[data-attr]\n    // but at the same time, it doesn't make much sense to select an element with an id and an extra selector\n    var el = hashStartsWithNumberRE.test(shouldScroll.selector) // $flow-disable-line\n      ? document.getElementById(shouldScroll.selector.slice(1)) // $flow-disable-line\n      : document.querySelector(shouldScroll.selector);\n\n    if (el) {\n      var offset =\n        shouldScroll.offset && typeof shouldScroll.offset === 'object'\n          ? shouldScroll.offset\n          : {};\n      offset = normalizeOffset(offset);\n      position = getElementPosition(el, offset);\n    } else if (isValidPosition(shouldScroll)) {\n      position = normalizePosition(shouldScroll);\n    }\n  } else if (isObject && isValidPosition(shouldScroll)) {\n    position = normalizePosition(shouldScroll);\n  }\n\n  if (position) {\n    // $flow-disable-line\n    if ('scrollBehavior' in document.documentElement.style) {\n      window.scrollTo({\n        left: position.x,\n        top: position.y,\n        // $flow-disable-line\n        behavior: shouldScroll.behavior\n      });\n    } else {\n      window.scrollTo(position.x, position.y);\n    }\n  }\n}\n\n/*  */\n\nvar supportsPushState =\n  inBrowser &&\n  (function () {\n    var ua = window.navigator.userAgent;\n\n    if (\n      (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&\n      ua.indexOf('Mobile Safari') !== -1 &&\n      ua.indexOf('Chrome') === -1 &&\n      ua.indexOf('Windows Phone') === -1\n    ) {\n      return false\n    }\n\n    return window.history && typeof window.history.pushState === 'function'\n  })();\n\nfunction pushState (url, replace) {\n  saveScrollPosition();\n  // try...catch the pushState call to get around Safari\n  // DOM Exception 18 where it limits to 100 pushState calls\n  var history = window.history;\n  try {\n    if (replace) {\n      // preserve existing history state as it could be overriden by the user\n      var stateCopy = extend({}, history.state);\n      stateCopy.key = getStateKey();\n      history.replaceState(stateCopy, '', url);\n    } else {\n      history.pushState({ key: setStateKey(genStateKey()) }, '', url);\n    }\n  } catch (e) {\n    window.location[replace ? 'replace' : 'assign'](url);\n  }\n}\n\nfunction replaceState (url) {\n  pushState(url, true);\n}\n\n// When changing thing, also edit router.d.ts\nvar NavigationFailureType = {\n  redirected: 2,\n  aborted: 4,\n  cancelled: 8,\n  duplicated: 16\n};\n\nfunction createNavigationRedirectedError (from, to) {\n  return createRouterError(\n    from,\n    to,\n    NavigationFailureType.redirected,\n    (\"Redirected when going from \\\"\" + (from.fullPath) + \"\\\" to \\\"\" + (stringifyRoute(\n      to\n    )) + \"\\\" via a navigation guard.\")\n  )\n}\n\nfunction createNavigationDuplicatedError (from, to) {\n  var error = createRouterError(\n    from,\n    to,\n    NavigationFailureType.duplicated,\n    (\"Avoided redundant navigation to current location: \\\"\" + (from.fullPath) + \"\\\".\")\n  );\n  // backwards compatible with the first introduction of Errors\n  error.name = 'NavigationDuplicated';\n  return error\n}\n\nfunction createNavigationCancelledError (from, to) {\n  return createRouterError(\n    from,\n    to,\n    NavigationFailureType.cancelled,\n    (\"Navigation cancelled from \\\"\" + (from.fullPath) + \"\\\" to \\\"\" + (to.fullPath) + \"\\\" with a new navigation.\")\n  )\n}\n\nfunction createNavigationAbortedError (from, to) {\n  return createRouterError(\n    from,\n    to,\n    NavigationFailureType.aborted,\n    (\"Navigation aborted from \\\"\" + (from.fullPath) + \"\\\" to \\\"\" + (to.fullPath) + \"\\\" via a navigation guard.\")\n  )\n}\n\nfunction createRouterError (from, to, type, message) {\n  var error = new Error(message);\n  error._isRouter = true;\n  error.from = from;\n  error.to = to;\n  error.type = type;\n\n  return error\n}\n\nvar propertiesToLog = ['params', 'query', 'hash'];\n\nfunction stringifyRoute (to) {\n  if (typeof to === 'string') { return to }\n  if ('path' in to) { return to.path }\n  var location = {};\n  propertiesToLog.forEach(function (key) {\n    if (key in to) { location[key] = to[key]; }\n  });\n  return JSON.stringify(location, null, 2)\n}\n\nfunction isError (err) {\n  return Object.prototype.toString.call(err).indexOf('Error') > -1\n}\n\nfunction isNavigationFailure (err, errorType) {\n  return (\n    isError(err) &&\n    err._isRouter &&\n    (errorType == null || err.type === errorType)\n  )\n}\n\n/*  */\n\nfunction runQueue (queue, fn, cb) {\n  var step = function (index) {\n    if (index >= queue.length) {\n      cb();\n    } else {\n      if (queue[index]) {\n        fn(queue[index], function () {\n          step(index + 1);\n        });\n      } else {\n        step(index + 1);\n      }\n    }\n  };\n  step(0);\n}\n\n/*  */\n\nfunction resolveAsyncComponents (matched) {\n  return function (to, from, next) {\n    var hasAsync = false;\n    var pending = 0;\n    var error = null;\n\n    flatMapComponents(matched, function (def, _, match, key) {\n      // if it's a function and doesn't have cid attached,\n      // assume it's an async component resolve function.\n      // we are not using Vue's default async resolving mechanism because\n      // we want to halt the navigation until the incoming component has been\n      // resolved.\n      if (typeof def === 'function' && def.cid === undefined) {\n        hasAsync = true;\n        pending++;\n\n        var resolve = once(function (resolvedDef) {\n          if (isESModule(resolvedDef)) {\n            resolvedDef = resolvedDef.default;\n          }\n          // save resolved on async factory in case it's used elsewhere\n          def.resolved = typeof resolvedDef === 'function'\n            ? resolvedDef\n            : _Vue.extend(resolvedDef);\n          match.components[key] = resolvedDef;\n          pending--;\n          if (pending <= 0) {\n            next();\n          }\n        });\n\n        var reject = once(function (reason) {\n          var msg = \"Failed to resolve async component \" + key + \": \" + reason;\n          process.env.NODE_ENV !== 'production' && warn(false, msg);\n          if (!error) {\n            error = isError(reason)\n              ? reason\n              : new Error(msg);\n            next(error);\n          }\n        });\n\n        var res;\n        try {\n          res = def(resolve, reject);\n        } catch (e) {\n          reject(e);\n        }\n        if (res) {\n          if (typeof res.then === 'function') {\n            res.then(resolve, reject);\n          } else {\n            // new syntax in Vue 2.3\n            var comp = res.component;\n            if (comp && typeof comp.then === 'function') {\n              comp.then(resolve, reject);\n            }\n          }\n        }\n      }\n    });\n\n    if (!hasAsync) { next(); }\n  }\n}\n\nfunction flatMapComponents (\n  matched,\n  fn\n) {\n  return flatten(matched.map(function (m) {\n    return Object.keys(m.components).map(function (key) { return fn(\n      m.components[key],\n      m.instances[key],\n      m, key\n    ); })\n  }))\n}\n\nfunction flatten (arr) {\n  return Array.prototype.concat.apply([], arr)\n}\n\nvar hasSymbol =\n  typeof Symbol === 'function' &&\n  typeof Symbol.toStringTag === 'symbol';\n\nfunction isESModule (obj) {\n  return obj.__esModule || (hasSymbol && obj[Symbol.toStringTag] === 'Module')\n}\n\n// in Webpack 2, require.ensure now also returns a Promise\n// so the resolve/reject functions may get called an extra time\n// if the user uses an arrow function shorthand that happens to\n// return that Promise.\nfunction once (fn) {\n  var called = false;\n  return function () {\n    var args = [], len = arguments.length;\n    while ( len-- ) args[ len ] = arguments[ len ];\n\n    if (called) { return }\n    called = true;\n    return fn.apply(this, args)\n  }\n}\n\n/*  */\n\nvar History = function History (router, base) {\n  this.router = router;\n  this.base = normalizeBase(base);\n  // start with a route object that stands for \"nowhere\"\n  this.current = START;\n  this.pending = null;\n  this.ready = false;\n  this.readyCbs = [];\n  this.readyErrorCbs = [];\n  this.errorCbs = [];\n  this.listeners = [];\n};\n\nHistory.prototype.listen = function listen (cb) {\n  this.cb = cb;\n};\n\nHistory.prototype.onReady = function onReady (cb, errorCb) {\n  if (this.ready) {\n    cb();\n  } else {\n    this.readyCbs.push(cb);\n    if (errorCb) {\n      this.readyErrorCbs.push(errorCb);\n    }\n  }\n};\n\nHistory.prototype.onError = function onError (errorCb) {\n  this.errorCbs.push(errorCb);\n};\n\nHistory.prototype.transitionTo = function transitionTo (\n  location,\n  onComplete,\n  onAbort\n) {\n    var this$1$1 = this;\n\n  var route;\n  // catch redirect option https://github.com/vuejs/vue-router/issues/3201\n  try {\n    route = this.router.match(location, this.current);\n  } catch (e) {\n    this.errorCbs.forEach(function (cb) {\n      cb(e);\n    });\n    // Exception should still be thrown\n    throw e\n  }\n  var prev = this.current;\n  this.confirmTransition(\n    route,\n    function () {\n      this$1$1.updateRoute(route);\n      onComplete && onComplete(route);\n      this$1$1.ensureURL();\n      this$1$1.router.afterHooks.forEach(function (hook) {\n        hook && hook(route, prev);\n      });\n\n      // fire ready cbs once\n      if (!this$1$1.ready) {\n        this$1$1.ready = true;\n        this$1$1.readyCbs.forEach(function (cb) {\n          cb(route);\n        });\n      }\n    },\n    function (err) {\n      if (onAbort) {\n        onAbort(err);\n      }\n      if (err && !this$1$1.ready) {\n        // Initial redirection should not mark the history as ready yet\n        // because it's triggered by the redirection instead\n        // https://github.com/vuejs/vue-router/issues/3225\n        // https://github.com/vuejs/vue-router/issues/3331\n        if (!isNavigationFailure(err, NavigationFailureType.redirected) || prev !== START) {\n          this$1$1.ready = true;\n          this$1$1.readyErrorCbs.forEach(function (cb) {\n            cb(err);\n          });\n        }\n      }\n    }\n  );\n};\n\nHistory.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {\n    var this$1$1 = this;\n\n  var current = this.current;\n  this.pending = route;\n  var abort = function (err) {\n    // changed after adding errors with\n    // https://github.com/vuejs/vue-router/pull/3047 before that change,\n    // redirect and aborted navigation would produce an err == null\n    if (!isNavigationFailure(err) && isError(err)) {\n      if (this$1$1.errorCbs.length) {\n        this$1$1.errorCbs.forEach(function (cb) {\n          cb(err);\n        });\n      } else {\n        if (process.env.NODE_ENV !== 'production') {\n          warn(false, 'uncaught error during route navigation:');\n        }\n        console.error(err);\n      }\n    }\n    onAbort && onAbort(err);\n  };\n  var lastRouteIndex = route.matched.length - 1;\n  var lastCurrentIndex = current.matched.length - 1;\n  if (\n    isSameRoute(route, current) &&\n    // in the case the route map has been dynamically appended to\n    lastRouteIndex === lastCurrentIndex &&\n    route.matched[lastRouteIndex] === current.matched[lastCurrentIndex]\n  ) {\n    this.ensureURL();\n    if (route.hash) {\n      handleScroll(this.router, current, route, false);\n    }\n    return abort(createNavigationDuplicatedError(current, route))\n  }\n\n  var ref = resolveQueue(\n    this.current.matched,\n    route.matched\n  );\n    var updated = ref.updated;\n    var deactivated = ref.deactivated;\n    var activated = ref.activated;\n\n  var queue = [].concat(\n    // in-component leave guards\n    extractLeaveGuards(deactivated),\n    // global before hooks\n    this.router.beforeHooks,\n    // in-component update hooks\n    extractUpdateHooks(updated),\n    // in-config enter guards\n    activated.map(function (m) { return m.beforeEnter; }),\n    // async components\n    resolveAsyncComponents(activated)\n  );\n\n  var iterator = function (hook, next) {\n    if (this$1$1.pending !== route) {\n      return abort(createNavigationCancelledError(current, route))\n    }\n    try {\n      hook(route, current, function (to) {\n        if (to === false) {\n          // next(false) -> abort navigation, ensure current URL\n          this$1$1.ensureURL(true);\n          abort(createNavigationAbortedError(current, route));\n        } else if (isError(to)) {\n          this$1$1.ensureURL(true);\n          abort(to);\n        } else if (\n          typeof to === 'string' ||\n          (typeof to === 'object' &&\n            (typeof to.path === 'string' || typeof to.name === 'string'))\n        ) {\n          // next('/') or next({ path: '/' }) -> redirect\n          abort(createNavigationRedirectedError(current, route));\n          if (typeof to === 'object' && to.replace) {\n            this$1$1.replace(to);\n          } else {\n            this$1$1.push(to);\n          }\n        } else {\n          // confirm transition and pass on the value\n          next(to);\n        }\n      });\n    } catch (e) {\n      abort(e);\n    }\n  };\n\n  runQueue(queue, iterator, function () {\n    // wait until async components are resolved before\n    // extracting in-component enter guards\n    var enterGuards = extractEnterGuards(activated);\n    var queue = enterGuards.concat(this$1$1.router.resolveHooks);\n    runQueue(queue, iterator, function () {\n      if (this$1$1.pending !== route) {\n        return abort(createNavigationCancelledError(current, route))\n      }\n      this$1$1.pending = null;\n      onComplete(route);\n      if (this$1$1.router.app) {\n        this$1$1.router.app.$nextTick(function () {\n          handleRouteEntered(route);\n        });\n      }\n    });\n  });\n};\n\nHistory.prototype.updateRoute = function updateRoute (route) {\n  this.current = route;\n  this.cb && this.cb(route);\n};\n\nHistory.prototype.setupListeners = function setupListeners () {\n  // Default implementation is empty\n};\n\nHistory.prototype.teardown = function teardown () {\n  // clean up event listeners\n  // https://github.com/vuejs/vue-router/issues/2341\n  this.listeners.forEach(function (cleanupListener) {\n    cleanupListener();\n  });\n  this.listeners = [];\n\n  // reset current history route\n  // https://github.com/vuejs/vue-router/issues/3294\n  this.current = START;\n  this.pending = null;\n};\n\nfunction normalizeBase (base) {\n  if (!base) {\n    if (inBrowser) {\n      // respect <base> tag\n      var baseEl = document.querySelector('base');\n      base = (baseEl && baseEl.getAttribute('href')) || '/';\n      // strip full URL origin\n      base = base.replace(/^https?:\\/\\/[^\\/]+/, '');\n    } else {\n      base = '/';\n    }\n  }\n  // make sure there's the starting slash\n  if (base.charAt(0) !== '/') {\n    base = '/' + base;\n  }\n  // remove trailing slash\n  return base.replace(/\\/$/, '')\n}\n\nfunction resolveQueue (\n  current,\n  next\n) {\n  var i;\n  var max = Math.max(current.length, next.length);\n  for (i = 0; i < max; i++) {\n    if (current[i] !== next[i]) {\n      break\n    }\n  }\n  return {\n    updated: next.slice(0, i),\n    activated: next.slice(i),\n    deactivated: current.slice(i)\n  }\n}\n\nfunction extractGuards (\n  records,\n  name,\n  bind,\n  reverse\n) {\n  var guards = flatMapComponents(records, function (def, instance, match, key) {\n    var guard = extractGuard(def, name);\n    if (guard) {\n      return Array.isArray(guard)\n        ? guard.map(function (guard) { return bind(guard, instance, match, key); })\n        : bind(guard, instance, match, key)\n    }\n  });\n  return flatten(reverse ? guards.reverse() : guards)\n}\n\nfunction extractGuard (\n  def,\n  key\n) {\n  if (typeof def !== 'function') {\n    // extend now so that global mixins are applied.\n    def = _Vue.extend(def);\n  }\n  return def.options[key]\n}\n\nfunction extractLeaveGuards (deactivated) {\n  return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)\n}\n\nfunction extractUpdateHooks (updated) {\n  return extractGuards(updated, 'beforeRouteUpdate', bindGuard)\n}\n\nfunction bindGuard (guard, instance) {\n  if (instance) {\n    return function boundRouteGuard () {\n      return guard.apply(instance, arguments)\n    }\n  }\n}\n\nfunction extractEnterGuards (\n  activated\n) {\n  return extractGuards(\n    activated,\n    'beforeRouteEnter',\n    function (guard, _, match, key) {\n      return bindEnterGuard(guard, match, key)\n    }\n  )\n}\n\nfunction bindEnterGuard (\n  guard,\n  match,\n  key\n) {\n  return function routeEnterGuard (to, from, next) {\n    return guard(to, from, function (cb) {\n      if (typeof cb === 'function') {\n        if (!match.enteredCbs[key]) {\n          match.enteredCbs[key] = [];\n        }\n        match.enteredCbs[key].push(cb);\n      }\n      next(cb);\n    })\n  }\n}\n\n/*  */\n\nvar HTML5History = /*@__PURE__*/(function (History) {\n  function HTML5History (router, base) {\n    History.call(this, router, base);\n\n    this._startLocation = getLocation(this.base);\n  }\n\n  if ( History ) HTML5History.__proto__ = History;\n  HTML5History.prototype = Object.create( History && History.prototype );\n  HTML5History.prototype.constructor = HTML5History;\n\n  HTML5History.prototype.setupListeners = function setupListeners () {\n    var this$1$1 = this;\n\n    if (this.listeners.length > 0) {\n      return\n    }\n\n    var router = this.router;\n    var expectScroll = router.options.scrollBehavior;\n    var supportsScroll = supportsPushState && expectScroll;\n\n    if (supportsScroll) {\n      this.listeners.push(setupScroll());\n    }\n\n    var handleRoutingEvent = function () {\n      var current = this$1$1.current;\n\n      // Avoiding first `popstate` event dispatched in some browsers but first\n      // history route not updated since async guard at the same time.\n      var location = getLocation(this$1$1.base);\n      if (this$1$1.current === START && location === this$1$1._startLocation) {\n        return\n      }\n\n      this$1$1.transitionTo(location, function (route) {\n        if (supportsScroll) {\n          handleScroll(router, route, current, true);\n        }\n      });\n    };\n    window.addEventListener('popstate', handleRoutingEvent);\n    this.listeners.push(function () {\n      window.removeEventListener('popstate', handleRoutingEvent);\n    });\n  };\n\n  HTML5History.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HTML5History.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(location, function (route) {\n      pushState(cleanPath(this$1$1.base + route.fullPath));\n      handleScroll(this$1$1.router, route, fromRoute, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(location, function (route) {\n      replaceState(cleanPath(this$1$1.base + route.fullPath));\n      handleScroll(this$1$1.router, route, fromRoute, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.ensureURL = function ensureURL (push) {\n    if (getLocation(this.base) !== this.current.fullPath) {\n      var current = cleanPath(this.base + this.current.fullPath);\n      push ? pushState(current) : replaceState(current);\n    }\n  };\n\n  HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getLocation(this.base)\n  };\n\n  return HTML5History;\n}(History));\n\nfunction getLocation (base) {\n  var path = window.location.pathname;\n  var pathLowerCase = path.toLowerCase();\n  var baseLowerCase = base.toLowerCase();\n  // base=\"/a\" shouldn't turn path=\"/app\" into \"/a/pp\"\n  // https://github.com/vuejs/vue-router/issues/3555\n  // so we ensure the trailing slash in the base\n  if (base && ((pathLowerCase === baseLowerCase) ||\n    (pathLowerCase.indexOf(cleanPath(baseLowerCase + '/')) === 0))) {\n    path = path.slice(base.length);\n  }\n  return (path || '/') + window.location.search + window.location.hash\n}\n\n/*  */\n\nvar HashHistory = /*@__PURE__*/(function (History) {\n  function HashHistory (router, base, fallback) {\n    History.call(this, router, base);\n    // check history fallback deeplinking\n    if (fallback && checkFallback(this.base)) {\n      return\n    }\n    ensureSlash();\n  }\n\n  if ( History ) HashHistory.__proto__ = History;\n  HashHistory.prototype = Object.create( History && History.prototype );\n  HashHistory.prototype.constructor = HashHistory;\n\n  // this is delayed until the app mounts\n  // to avoid the hashchange listener being fired too early\n  HashHistory.prototype.setupListeners = function setupListeners () {\n    var this$1$1 = this;\n\n    if (this.listeners.length > 0) {\n      return\n    }\n\n    var router = this.router;\n    var expectScroll = router.options.scrollBehavior;\n    var supportsScroll = supportsPushState && expectScroll;\n\n    if (supportsScroll) {\n      this.listeners.push(setupScroll());\n    }\n\n    var handleRoutingEvent = function () {\n      var current = this$1$1.current;\n      if (!ensureSlash()) {\n        return\n      }\n      this$1$1.transitionTo(getHash(), function (route) {\n        if (supportsScroll) {\n          handleScroll(this$1$1.router, route, current, true);\n        }\n        if (!supportsPushState) {\n          replaceHash(route.fullPath);\n        }\n      });\n    };\n    var eventType = supportsPushState ? 'popstate' : 'hashchange';\n    window.addEventListener(\n      eventType,\n      handleRoutingEvent\n    );\n    this.listeners.push(function () {\n      window.removeEventListener(eventType, handleRoutingEvent);\n    });\n  };\n\n  HashHistory.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(\n      location,\n      function (route) {\n        pushHash(route.fullPath);\n        handleScroll(this$1$1.router, route, fromRoute, false);\n        onComplete && onComplete(route);\n      },\n      onAbort\n    );\n  };\n\n  HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(\n      location,\n      function (route) {\n        replaceHash(route.fullPath);\n        handleScroll(this$1$1.router, route, fromRoute, false);\n        onComplete && onComplete(route);\n      },\n      onAbort\n    );\n  };\n\n  HashHistory.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HashHistory.prototype.ensureURL = function ensureURL (push) {\n    var current = this.current.fullPath;\n    if (getHash() !== current) {\n      push ? pushHash(current) : replaceHash(current);\n    }\n  };\n\n  HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getHash()\n  };\n\n  return HashHistory;\n}(History));\n\nfunction checkFallback (base) {\n  var location = getLocation(base);\n  if (!/^\\/#/.test(location)) {\n    window.location.replace(cleanPath(base + '/#' + location));\n    return true\n  }\n}\n\nfunction ensureSlash () {\n  var path = getHash();\n  if (path.charAt(0) === '/') {\n    return true\n  }\n  replaceHash('/' + path);\n  return false\n}\n\nfunction getHash () {\n  // We can't use window.location.hash here because it's not\n  // consistent across browsers - Firefox will pre-decode it!\n  var href = window.location.href;\n  var index = href.indexOf('#');\n  // empty path\n  if (index < 0) { return '' }\n\n  href = href.slice(index + 1);\n\n  return href\n}\n\nfunction getUrl (path) {\n  var href = window.location.href;\n  var i = href.indexOf('#');\n  var base = i >= 0 ? href.slice(0, i) : href;\n  return (base + \"#\" + path)\n}\n\nfunction pushHash (path) {\n  if (supportsPushState) {\n    pushState(getUrl(path));\n  } else {\n    window.location.hash = path;\n  }\n}\n\nfunction replaceHash (path) {\n  if (supportsPushState) {\n    replaceState(getUrl(path));\n  } else {\n    window.location.replace(getUrl(path));\n  }\n}\n\n/*  */\n\nvar AbstractHistory = /*@__PURE__*/(function (History) {\n  function AbstractHistory (router, base) {\n    History.call(this, router, base);\n    this.stack = [];\n    this.index = -1;\n  }\n\n  if ( History ) AbstractHistory.__proto__ = History;\n  AbstractHistory.prototype = Object.create( History && History.prototype );\n  AbstractHistory.prototype.constructor = AbstractHistory;\n\n  AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    this.transitionTo(\n      location,\n      function (route) {\n        this$1$1.stack = this$1$1.stack.slice(0, this$1$1.index + 1).concat(route);\n        this$1$1.index++;\n        onComplete && onComplete(route);\n      },\n      onAbort\n    );\n  };\n\n  AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    this.transitionTo(\n      location,\n      function (route) {\n        this$1$1.stack = this$1$1.stack.slice(0, this$1$1.index).concat(route);\n        onComplete && onComplete(route);\n      },\n      onAbort\n    );\n  };\n\n  AbstractHistory.prototype.go = function go (n) {\n    var this$1$1 = this;\n\n    var targetIndex = this.index + n;\n    if (targetIndex < 0 || targetIndex >= this.stack.length) {\n      return\n    }\n    var route = this.stack[targetIndex];\n    this.confirmTransition(\n      route,\n      function () {\n        var prev = this$1$1.current;\n        this$1$1.index = targetIndex;\n        this$1$1.updateRoute(route);\n        this$1$1.router.afterHooks.forEach(function (hook) {\n          hook && hook(route, prev);\n        });\n      },\n      function (err) {\n        if (isNavigationFailure(err, NavigationFailureType.duplicated)) {\n          this$1$1.index = targetIndex;\n        }\n      }\n    );\n  };\n\n  AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    var current = this.stack[this.stack.length - 1];\n    return current ? current.fullPath : '/'\n  };\n\n  AbstractHistory.prototype.ensureURL = function ensureURL () {\n    // noop\n  };\n\n  return AbstractHistory;\n}(History));\n\n/*  */\n\n\n\nvar VueRouter = function VueRouter (options) {\n  if ( options === void 0 ) options = {};\n\n  if (process.env.NODE_ENV !== 'production') {\n    warn(this instanceof VueRouter, \"Router must be called with the new operator.\");\n  }\n  this.app = null;\n  this.apps = [];\n  this.options = options;\n  this.beforeHooks = [];\n  this.resolveHooks = [];\n  this.afterHooks = [];\n  this.matcher = createMatcher(options.routes || [], this);\n\n  var mode = options.mode || 'hash';\n  this.fallback =\n    mode === 'history' && !supportsPushState && options.fallback !== false;\n  if (this.fallback) {\n    mode = 'hash';\n  }\n  if (!inBrowser) {\n    mode = 'abstract';\n  }\n  this.mode = mode;\n\n  switch (mode) {\n    case 'history':\n      this.history = new HTML5History(this, options.base);\n      break\n    case 'hash':\n      this.history = new HashHistory(this, options.base, this.fallback);\n      break\n    case 'abstract':\n      this.history = new AbstractHistory(this, options.base);\n      break\n    default:\n      if (process.env.NODE_ENV !== 'production') {\n        assert(false, (\"invalid mode: \" + mode));\n      }\n  }\n};\n\nvar prototypeAccessors = { currentRoute: { configurable: true } };\n\nVueRouter.prototype.match = function match (raw, current, redirectedFrom) {\n  return this.matcher.match(raw, current, redirectedFrom)\n};\n\nprototypeAccessors.currentRoute.get = function () {\n  return this.history && this.history.current\n};\n\nVueRouter.prototype.init = function init (app /* Vue component instance */) {\n    var this$1$1 = this;\n\n  process.env.NODE_ENV !== 'production' &&\n    assert(\n      install.installed,\n      \"not installed. Make sure to call `Vue.use(VueRouter)` \" +\n        \"before creating root instance.\"\n    );\n\n  this.apps.push(app);\n\n  // set up app destroyed handler\n  // https://github.com/vuejs/vue-router/issues/2639\n  app.$once('hook:destroyed', function () {\n    // clean out app from this.apps array once destroyed\n    var index = this$1$1.apps.indexOf(app);\n    if (index > -1) { this$1$1.apps.splice(index, 1); }\n    // ensure we still have a main app or null if no apps\n    // we do not release the router so it can be reused\n    if (this$1$1.app === app) { this$1$1.app = this$1$1.apps[0] || null; }\n\n    if (!this$1$1.app) { this$1$1.history.teardown(); }\n  });\n\n  // main app previously initialized\n  // return as we don't need to set up new history listener\n  if (this.app) {\n    return\n  }\n\n  this.app = app;\n\n  var history = this.history;\n\n  if (history instanceof HTML5History || history instanceof HashHistory) {\n    var handleInitialScroll = function (routeOrError) {\n      var from = history.current;\n      var expectScroll = this$1$1.options.scrollBehavior;\n      var supportsScroll = supportsPushState && expectScroll;\n\n      if (supportsScroll && 'fullPath' in routeOrError) {\n        handleScroll(this$1$1, routeOrError, from, false);\n      }\n    };\n    var setupListeners = function (routeOrError) {\n      history.setupListeners();\n      handleInitialScroll(routeOrError);\n    };\n    history.transitionTo(\n      history.getCurrentLocation(),\n      setupListeners,\n      setupListeners\n    );\n  }\n\n  history.listen(function (route) {\n    this$1$1.apps.forEach(function (app) {\n      app._route = route;\n    });\n  });\n};\n\nVueRouter.prototype.beforeEach = function beforeEach (fn) {\n  return registerHook(this.beforeHooks, fn)\n};\n\nVueRouter.prototype.beforeResolve = function beforeResolve (fn) {\n  return registerHook(this.resolveHooks, fn)\n};\n\nVueRouter.prototype.afterEach = function afterEach (fn) {\n  return registerHook(this.afterHooks, fn)\n};\n\nVueRouter.prototype.onReady = function onReady (cb, errorCb) {\n  this.history.onReady(cb, errorCb);\n};\n\nVueRouter.prototype.onError = function onError (errorCb) {\n  this.history.onError(errorCb);\n};\n\nVueRouter.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n  // $flow-disable-line\n  if (!onComplete && !onAbort && typeof Promise !== 'undefined') {\n    return new Promise(function (resolve, reject) {\n      this$1$1.history.push(location, resolve, reject);\n    })\n  } else {\n    this.history.push(location, onComplete, onAbort);\n  }\n};\n\nVueRouter.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n  // $flow-disable-line\n  if (!onComplete && !onAbort && typeof Promise !== 'undefined') {\n    return new Promise(function (resolve, reject) {\n      this$1$1.history.replace(location, resolve, reject);\n    })\n  } else {\n    this.history.replace(location, onComplete, onAbort);\n  }\n};\n\nVueRouter.prototype.go = function go (n) {\n  this.history.go(n);\n};\n\nVueRouter.prototype.back = function back () {\n  this.go(-1);\n};\n\nVueRouter.prototype.forward = function forward () {\n  this.go(1);\n};\n\nVueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {\n  var route = to\n    ? to.matched\n      ? to\n      : this.resolve(to).route\n    : this.currentRoute;\n  if (!route) {\n    return []\n  }\n  return [].concat.apply(\n    [],\n    route.matched.map(function (m) {\n      return Object.keys(m.components).map(function (key) {\n        return m.components[key]\n      })\n    })\n  )\n};\n\nVueRouter.prototype.resolve = function resolve (\n  to,\n  current,\n  append\n) {\n  current = current || this.history.current;\n  var location = normalizeLocation(to, current, append, this);\n  var route = this.match(location, current);\n  var fullPath = route.redirectedFrom || route.fullPath;\n  var base = this.history.base;\n  var href = createHref(base, fullPath, this.mode);\n  return {\n    location: location,\n    route: route,\n    href: href,\n    // for backwards compat\n    normalizedTo: location,\n    resolved: route\n  }\n};\n\nVueRouter.prototype.getRoutes = function getRoutes () {\n  return this.matcher.getRoutes()\n};\n\nVueRouter.prototype.addRoute = function addRoute (parentOrRoute, route) {\n  this.matcher.addRoute(parentOrRoute, route);\n  if (this.history.current !== START) {\n    this.history.transitionTo(this.history.getCurrentLocation());\n  }\n};\n\nVueRouter.prototype.addRoutes = function addRoutes (routes) {\n  if (process.env.NODE_ENV !== 'production') {\n    warn(false, 'router.addRoutes() is deprecated and has been removed in Vue Router 4. Use router.addRoute() instead.');\n  }\n  this.matcher.addRoutes(routes);\n  if (this.history.current !== START) {\n    this.history.transitionTo(this.history.getCurrentLocation());\n  }\n};\n\nObject.defineProperties( VueRouter.prototype, prototypeAccessors );\n\nvar VueRouter$1 = VueRouter;\n\nfunction registerHook (list, fn) {\n  list.push(fn);\n  return function () {\n    var i = list.indexOf(fn);\n    if (i > -1) { list.splice(i, 1); }\n  }\n}\n\nfunction createHref (base, fullPath, mode) {\n  var path = mode === 'hash' ? '#' + fullPath : fullPath;\n  return base ? cleanPath(base + '/' + path) : path\n}\n\n// We cannot remove this as it would be a breaking change\nVueRouter.install = install;\nVueRouter.version = '3.6.5';\nVueRouter.isNavigationFailure = isNavigationFailure;\nVueRouter.NavigationFailureType = NavigationFailureType;\nVueRouter.START_LOCATION = START;\n\nif (inBrowser && window.Vue) {\n  window.Vue.use(VueRouter);\n}\n\nvar version = '3.6.5';\n\nexport { NavigationFailureType, Link as RouterLink, View as RouterView, START as START_LOCATION, VueRouter$1 as default, isNavigationFailure, version };\n","/*!\n * Vue.js v2.6.11\n * (c) 2014-2019 Evan You\n * Released under the MIT License.\n */\n/*  */\n\nvar emptyObject = Object.freeze({});\n\n// These helpers produce 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 (\n    typeof value === 'string' ||\n    typeof value === 'number' ||\n    // $flow-disable-line\n    typeof value === 'symbol' ||\n    typeof value === 'boolean'\n  )\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 === '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\nfunction isPromise (val) {\n  return (\n    isDef(val) &&\n    typeof val.then === 'function' &&\n    typeof val.catch === 'function'\n  )\n}\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction toString (val) {\n  return val == null\n    ? ''\n    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)\n      ? JSON.stringify(val, null, 2)\n      : String(val)\n}\n\n/**\n * Convert an 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 (\n  str,\n  expectsLowerCase\n) {\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\n    ? function (val) { return map[val.toLowerCase()]; }\n    : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Check if an attribute is a reserved attribute.\n */\nvar 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 an 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 = cached(function (str) {\n  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n});\n\n/**\n * Capitalize a string.\n */\nvar 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 = cached(function (str) {\n  return str.replace(hyphenateRE, '-$1').toLowerCase()\n});\n\n/**\n * Simple bind polyfill for environments that do not support it,\n * e.g., PhantomJS 1.x. Technically, we don't need this anymore\n * since native bind is now performant enough in most browsers.\n * But removing it would mean breaking code that was able to run in\n * PhantomJS 1.x, so this must be kept for backward compatibility.\n */\n\n/* istanbul ignore next */\nfunction polyfillBind (fn, ctx) {\n  function boundFn (a) {\n    var l = arguments.length;\n    return l\n      ? l > 1\n        ? fn.apply(ctx, arguments)\n        : fn.call(ctx, a)\n      : 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 = Function.prototype.bind\n  ? nativeBind\n  : 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/* eslint-disable no-unused-vars */\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 = function (a, b, c) { return false; };\n\n/* eslint-enable no-unused-vars */\n\n/**\n * Return the same value.\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a string containing static keys 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 (a instanceof Date && b instanceof Date) {\n        return a.getTime() === b.getTime()\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\n/**\n * Return the first index at which a loosely equal value can be\n * found in the array (if value is a plain object, the array must\n * contain an object of the same shape), or -1 if it is not present.\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\nvar SSR_ATTR = 'data-server-rendered';\n\nvar ASSET_TYPES = [\n  'component',\n  'directive',\n  'filter'\n];\n\nvar LIFECYCLE_HOOKS = [\n  'beforeCreate',\n  'created',\n  'beforeMount',\n  'mounted',\n  'beforeUpdate',\n  'updated',\n  'beforeDestroy',\n  'destroyed',\n  'activated',\n  'deactivated',\n  'errorCaptured',\n  'serverPrefetch'\n];\n\n/*  */\n\n\n\nvar config = ({\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: process.env.NODE_ENV !== 'production',\n\n  /**\n   * Whether to enable devtools\n   */\n  devtools: process.env.NODE_ENV !== '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: 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: no,\n\n  /**\n   * Check if a tag is an unknown element.\n   * Platform-dependent.\n   */\n  isUnknownElement: no,\n\n  /**\n   * Get the namespace of an element\n   */\n  getTagNamespace: noop,\n\n  /**\n   * Parse the real tag name for the specific platform.\n   */\n  parsePlatformTagName: identity,\n\n  /**\n   * Check if an attribute must be bound using property, e.g. value\n   * Platform-dependent.\n   */\n  mustUseProp: no,\n\n  /**\n   * Perform updates asynchronously. Intended to be used by Vue Test Utils\n   * This will significantly reduce performance if set to false.\n   */\n  async: true,\n\n  /**\n   * Exposed for legacy reasons\n   */\n  _lifecycleHooks: LIFECYCLE_HOOKS\n});\n\n/*  */\n\n/**\n * unicode letters used for parsing html tags, component names and property paths.\n * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname\n * skipping \\u10000-\\uEFFFF due to it freezing up PhantomJS\n */\nvar unicodeRegExp = /a-zA-Z\\u00B7\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u203F-\\u2040\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD/;\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 = new RegExp((\"[^\" + (unicodeRegExp.source) + \".$_\\\\d]\"));\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/*  */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\nvar inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;\nvar weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');\nvar isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');\nvar isChrome = UA && /chrome\\/\\d+/.test(UA) && !isEdge;\nvar isPhantomJS = UA && /phantomjs/.test(UA);\nvar isFF = UA && UA.match(/firefox\\/(\\d+)/);\n\n// Firefox has a \"watch\" function on Object.prototype...\nvar nativeWatch = ({}).watch;\n\nvar supportsPassive = false;\nif (inBrowser) {\n  try {\n    var opts = {};\n    Object.defineProperty(opts, 'passive', ({\n      get: function get () {\n        /* istanbul ignore next */\n        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;\nvar isServerRendering = function () {\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'] && global['process'].env.VUE_ENV === 'server';\n    } else {\n      _isServer = false;\n    }\n  }\n  return _isServer\n};\n\n// detect devtools\nvar 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 =\n  typeof Symbol !== 'undefined' && isNative(Symbol) &&\n  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);\n\nvar _Set;\n/* istanbul ignore if */ // $flow-disable-line\nif (typeof Set !== 'undefined' && isNative(Set)) {\n  // use native Set when available.\n  _Set = Set;\n} else {\n  // a non-standard Set polyfill that only works with primitive keys.\n  _Set = /*@__PURE__*/(function () {\n    function Set () {\n      this.set = Object.create(null);\n    }\n    Set.prototype.has = function has (key) {\n      return this.set[key] === true\n    };\n    Set.prototype.add = function add (key) {\n      this.set[key] = true;\n    };\n    Set.prototype.clear = function clear () {\n      this.set = Object.create(null);\n    };\n\n    return Set;\n  }());\n}\n\n/*  */\n\nvar warn = noop;\nvar tip = noop;\nvar generateComponentTrace = (noop); // work around flow check\nvar formatComponentName = (noop);\n\nif (process.env.NODE_ENV !== 'production') {\n  var hasConsole = typeof console !== 'undefined';\n  var classifyRE = /(?:^|[-_])(\\w)/g;\n  var classify = function (str) { return str\n    .replace(classifyRE, function (c) { return c.toUpperCase(); })\n    .replace(/[-_]/g, ''); };\n\n  warn = function (msg, vm) {\n    var trace = vm ? generateComponentTrace(vm) : '';\n\n    if (config.warnHandler) {\n      config.warnHandler.call(null, msg, vm, trace);\n    } else if (hasConsole && (!config.silent)) {\n      console.error((\"[Vue warn]: \" + msg + trace));\n    }\n  };\n\n  tip = function (msg, vm) {\n    if (hasConsole && (!config.silent)) {\n      console.warn(\"[Vue tip]: \" + msg + (\n        vm ? generateComponentTrace(vm) : ''\n      ));\n    }\n  };\n\n  formatComponentName = function (vm, includeFile) {\n    if (vm.$root === vm) {\n      return '<Root>'\n    }\n    var options = typeof vm === 'function' && vm.cid != null\n      ? vm.options\n      : vm._isVue\n        ? vm.$options || vm.constructor.options\n        : 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 (\n      (name ? (\"<\" + (classify(name)) + \">\") : \"<Anonymous>\") +\n      (file && includeFile !== false ? (\" at \" + file) : '')\n    )\n  };\n\n  var repeat = function (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  generateComponentTrace = function (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\n        .map(function (vm, i) { return (\"\" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)\n            ? ((formatComponentName(vm[0])) + \"... (\" + (vm[1]) + \" recursive calls)\")\n            : formatComponentName(vm))); })\n        .join('\\n')\n    } else {\n      return (\"\\n\\n(found in \" + (formatComponentName(vm)) + \")\")\n    }\n  };\n}\n\n/*  */\n\nvar uid = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n  this.id = uid++;\n  this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n  this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n  remove(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n  if (Dep.target) {\n    Dep.target.addDep(this);\n  }\n};\n\nDep.prototype.notify = function notify () {\n  // stabilize the subscriber list first\n  var subs = this.subs.slice();\n  if (process.env.NODE_ENV !== 'production' && !config.async) {\n    // subs aren't sorted in scheduler if not running async\n    // we need to sort them now to make sure they fire in correct\n    // order\n    subs.sort(function (a, b) { return a.id - b.id; });\n  }\n  for (var i = 0, l = subs.length; i < l; i++) {\n    subs[i].update();\n  }\n};\n\n// The current target watcher being evaluated.\n// This is globally unique because only one watcher\n// can be evaluated at a time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (target) {\n  targetStack.push(target);\n  Dep.target = target;\n}\n\nfunction popTarget () {\n  targetStack.pop();\n  Dep.target = targetStack[targetStack.length - 1];\n}\n\n/*  */\n\nvar VNode = function VNode (\n  tag,\n  data,\n  children,\n  text,\n  elm,\n  context,\n  componentOptions,\n  asyncFactory\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\nvar prototypeAccessors = { child: { configurable: true } };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n  return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function (text) {\n  if ( text === void 0 ) text = '';\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(\n    vnode.tag,\n    vnode.data,\n    // #7975\n    // clone children array to avoid mutating original in case of cloning\n    // a child.\n    vnode.children && vnode.children.slice(),\n    vnode.text,\n    vnode.elm,\n    vnode.context,\n    vnode.componentOptions,\n    vnode.asyncFactory\n  );\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.asyncMeta = vnode.asyncMeta;\n  cloned.isCloned = true;\n  return cloned\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);\n\nvar methodsToPatch = [\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse'\n];\n\n/**\n * Intercept mutating methods and emit events\n */\nmethodsToPatch.forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  def(arrayMethods, method, function mutator () {\n    var args = [], len = arguments.length;\n    while ( len-- ) args[ len ] = arguments[ len ];\n\n    var result = original.apply(this, args);\n    var ob = this.__ob__;\n    var inserted;\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/*  */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * In some cases we may want to disable observation inside a component's\n * update computation.\n */\nvar shouldObserve = true;\n\nfunction toggleObserving (value) {\n  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 */\nvar Observer = function Observer (value) {\n  this.value = value;\n  this.dep = new Dep();\n  this.vmCount = 0;\n  def(value, '__ob__', this);\n  if (Array.isArray(value)) {\n    if (hasProto) {\n      protoAugment(value, arrayMethods);\n    } else {\n      copyAugment(value, arrayMethods, arrayKeys);\n    }\n    this.observeArray(value);\n  } else {\n    this.walk(value);\n  }\n};\n\n/**\n * Walk through all properties and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n */\nObserver.prototype.walk = function walk (obj) {\n  var keys = Object.keys(obj);\n  for (var i = 0; i < keys.length; i++) {\n    defineReactive$$1(obj, keys[i]);\n  }\n};\n\n/**\n * Observe a list of Array items.\n */\nObserver.prototype.observeArray = function observeArray (items) {\n  for (var i = 0, l = items.length; i < l; i++) {\n    observe(items[i]);\n  }\n};\n\n// helpers\n\n/**\n * Augment a target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src) {\n  /* eslint-disable no-proto */\n  target.__proto__ = src;\n  /* eslint-enable no-proto */\n}\n\n/**\n * Augment a 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    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 (!isObject(value) || value instanceof VNode) {\n    return\n  }\n  var ob;\n  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if (\n    shouldObserve &&\n    !isServerRendering() &&\n    (Array.isArray(value) || isPlainObject(value)) &&\n    Object.isExtensible(value) &&\n    !value._isVue\n  ) {\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$$1 (\n  obj,\n  key,\n  val,\n  customSetter,\n  shallow\n) {\n  var dep = new Dep();\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  var setter = property && property.set;\n  if ((!getter || setter) && arguments.length === 2) {\n    val = obj[key];\n  }\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 (Dep.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 (process.env.NODE_ENV !== 'production' && customSetter) {\n        customSetter();\n      }\n      // #7981: for accessor properties without setter\n      if (getter && !setter) { return }\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 (process.env.NODE_ENV !== 'production' &&\n    (isUndef(target) || isPrimitive(target))\n  ) {\n    warn((\"Cannot set reactive property on undefined, null, or primitive value: \" + ((target))));\n  }\n  if (Array.isArray(target) && 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    process.env.NODE_ENV !== 'production' && warn(\n      'Avoid adding reactive properties to a Vue instance or its root $data ' +\n      'at runtime - declare it upfront in the data option.'\n    );\n    return val\n  }\n  if (!ob) {\n    target[key] = val;\n    return val\n  }\n  defineReactive$$1(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 (process.env.NODE_ENV !== 'production' &&\n    (isUndef(target) || isPrimitive(target))\n  ) {\n    warn((\"Cannot delete reactive property on undefined, null, or primitive value: \" + ((target))));\n  }\n  if (Array.isArray(target) && isValidArrayIndex(key)) {\n    target.splice(key, 1);\n    return\n  }\n  var ob = (target).__ob__;\n  if (target._isVue || (ob && ob.vmCount)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      'Avoid deleting properties on a Vue instance or its root $data ' +\n      '- just set it to null.'\n    );\n    return\n  }\n  if (!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 = (void 0), 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/*  */\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 = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (process.env.NODE_ENV !== 'production') {\n  strats.el = strats.propsData = function (parent, child, vm, key) {\n    if (!vm) {\n      warn(\n        \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n        'creation with the `new` keyword.'\n      );\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, toVal, fromVal;\n\n  var keys = hasSymbol\n    ? Reflect.ownKeys(from)\n    : Object.keys(from);\n\n  for (var i = 0; i < keys.length; i++) {\n    key = keys[i];\n    // in case the object is already observed...\n    if (key === '__ob__') { continue }\n    toVal = to[key];\n    fromVal = from[key];\n    if (!hasOwn(to, key)) {\n      set(to, key, fromVal);\n    } else if (\n      toVal !== fromVal &&\n      isPlainObject(toVal) &&\n      isPlainObject(fromVal)\n    ) {\n      mergeData(toVal, fromVal);\n    }\n  }\n  return to\n}\n\n/**\n * Data\n */\nfunction mergeDataOrFn (\n  parentVal,\n  childVal,\n  vm\n) {\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(\n        typeof childVal === 'function' ? childVal.call(this, this) : childVal,\n        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal\n      )\n    }\n  } else {\n    return function mergedInstanceDataFn () {\n      // instance merge\n      var instanceData = typeof childVal === 'function'\n        ? childVal.call(vm, vm)\n        : childVal;\n      var defaultData = typeof parentVal === 'function'\n        ? parentVal.call(vm, vm)\n        : parentVal;\n      if (instanceData) {\n        return mergeData(instanceData, defaultData)\n      } else {\n        return defaultData\n      }\n    }\n  }\n}\n\nstrats.data = function (\n  parentVal,\n  childVal,\n  vm\n) {\n  if (!vm) {\n    if (childVal && typeof childVal !== 'function') {\n      process.env.NODE_ENV !== 'production' && warn(\n        'The \"data\" option should be a function ' +\n        'that returns a per-instance value in component ' +\n        'definitions.',\n        vm\n      );\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 (\n  parentVal,\n  childVal\n) {\n  var res = childVal\n    ? parentVal\n      ? parentVal.concat(childVal)\n      : Array.isArray(childVal)\n        ? childVal\n        : [childVal]\n    : parentVal;\n  return res\n    ? dedupeHooks(res)\n    : res\n}\n\nfunction dedupeHooks (hooks) {\n  var res = [];\n  for (var i = 0; i < hooks.length; i++) {\n    if (res.indexOf(hooks[i]) === -1) {\n      res.push(hooks[i]);\n    }\n  }\n  return res\n}\n\nLIFECYCLE_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 (\n  parentVal,\n  childVal,\n  vm,\n  key\n) {\n  var res = Object.create(parentVal || null);\n  if (childVal) {\n    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);\n    return extend(res, childVal)\n  } else {\n    return res\n  }\n}\n\nASSET_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 (\n  parentVal,\n  childVal,\n  vm,\n  key\n) {\n  // work around Firefox's Object.prototype.watch...\n  if (parentVal === nativeWatch) { parentVal = undefined; }\n  if (childVal === nativeWatch) { childVal = undefined; }\n  /* istanbul ignore if */\n  if (!childVal) { return Object.create(parentVal || null) }\n  if (process.env.NODE_ENV !== 'production') {\n    assertObjectType(key, childVal, vm);\n  }\n  if (!parentVal) { return childVal }\n  var ret = {};\n  extend(ret, parentVal);\n  for (var key$1 in childVal) {\n    var parent = ret[key$1];\n    var child = childVal[key$1];\n    if (parent && !Array.isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key$1] = parent\n      ? parent.concat(child)\n      : Array.isArray(child) ? child : [child];\n  }\n  return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.inject =\nstrats.computed = function (\n  parentVal,\n  childVal,\n  vm,\n  key\n) {\n  if (childVal && process.env.NODE_ENV !== 'production') {\n    assertObjectType(key, childVal, vm);\n  }\n  if (!parentVal) { return childVal }\n  var ret = Object.create(null);\n  extend(ret, parentVal);\n  if (childVal) { extend(ret, childVal); }\n  return ret\n};\nstrats.provide = mergeDataOrFn;\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n  return childVal === undefined\n    ? parentVal\n    : 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 (!new RegExp((\"^[a-zA-Z][\\\\-\\\\.0-9_\" + (unicodeRegExp.source) + \"]*$\")).test(name)) {\n    warn(\n      'Invalid component name: \"' + name + '\". Component names ' +\n      'should conform to valid custom element name in html5 specification.'\n    );\n  }\n  if (isBuiltInTag(name) || config.isReservedTag(name)) {\n    warn(\n      'Do not use built-in or reserved HTML elements as component ' +\n      'id: ' + name\n    );\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, val, name;\n  if (Array.isArray(props)) {\n    i = props.length;\n    while (i--) {\n      val = props[i];\n      if (typeof val === 'string') {\n        name = camelize(val);\n        res[name] = { type: null };\n      } else if (process.env.NODE_ENV !== 'production') {\n        warn('props must be strings when using array syntax.');\n      }\n    }\n  } else if (isPlainObject(props)) {\n    for (var key in props) {\n      val = props[key];\n      name = camelize(key);\n      res[name] = isPlainObject(val)\n        ? val\n        : { type: val };\n    }\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn(\n      \"Invalid value for option \\\"props\\\": expected an Array or an Object, \" +\n      \"but got \" + (toRawType(props)) + \".\",\n      vm\n    );\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 (isPlainObject(inject)) {\n    for (var key in inject) {\n      var val = inject[key];\n      normalized[key] = isPlainObject(val)\n        ? extend({ from: key }, val)\n        : { from: val };\n    }\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn(\n      \"Invalid value for option \\\"inject\\\": expected an Array or an Object, \" +\n      \"but got \" + (toRawType(inject)) + \".\",\n      vm\n    );\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$$1 = dirs[key];\n      if (typeof def$$1 === 'function') {\n        dirs[key] = { bind: def$$1, update: def$$1 };\n      }\n    }\n  }\n}\n\nfunction assertObjectType (name, value, vm) {\n  if (!isPlainObject(value)) {\n    warn(\n      \"Invalid value for option \\\"\" + name + \"\\\": expected an Object, \" +\n      \"but got \" + (toRawType(value)) + \".\",\n      vm\n    );\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 (\n  parent,\n  child,\n  vm\n) {\n  if (process.env.NODE_ENV !== 'production') {\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\n  // Apply extends and mixins on the child options,\n  // but only if it is a raw options object that isn't\n  // the result of another mergeOptions call.\n  // Only merged options has the _base property.\n  if (!child._base) {\n    if (child.extends) {\n      parent = mergeOptions(parent, child.extends, 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  }\n\n  var options = {};\n  var key;\n  for (key in parent) {\n    mergeField(key);\n  }\n  for (key in child) {\n    if (!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 (\n  options,\n  type,\n  id,\n  warnMissing\n) {\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 (hasOwn(assets, id)) { return assets[id] }\n  var camelizedId = camelize(id);\n  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n  var PascalCaseId = capitalize(camelizedId);\n  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n  // fallback to prototype chain\n  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {\n    warn(\n      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n      options\n    );\n  }\n  return res\n}\n\n/*  */\n\n\n\nfunction validateProp (\n  key,\n  propOptions,\n  propsData,\n  vm\n) {\n  var prop = propOptions[key];\n  var absent = !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 && !hasOwn(prop, 'default')) {\n      value = false;\n    } else if (value === '' || value === 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 = shouldObserve;\n    toggleObserving(true);\n    observe(value);\n    toggleObserving(prevShouldObserve);\n  }\n  if (\n    process.env.NODE_ENV !== 'production' &&\n    // skip validation for weex recycle-list child component props\n    !(false)\n  ) {\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 (!hasOwn(prop, 'default')) {\n    return undefined\n  }\n  var def = prop.default;\n  // warn against non-factory defaults for Object & Array\n  if (process.env.NODE_ENV !== 'production' && isObject(def)) {\n    warn(\n      'Invalid default value for prop \"' + key + '\": ' +\n      'Props with type Object/Array must use a factory function ' +\n      'to return the default value.',\n      vm\n    );\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 &&\n    vm.$options.propsData[key] === undefined &&\n    vm._props[key] !== undefined\n  ) {\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'\n    ? def.call(vm)\n    : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n  prop,\n  name,\n  value,\n  vm,\n  absent\n) {\n  if (prop.required && absent) {\n    warn(\n      'Missing required prop: \"' + name + '\"',\n      vm\n    );\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\n  if (!valid) {\n    warn(\n      getInvalidTypeMessage(name, value, expectedTypes),\n      vm\n    );\n    return\n  }\n  var validator = prop.validator;\n  if (validator) {\n    if (!validator(value)) {\n      warn(\n        'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n        vm\n      );\n    }\n  }\n}\n\nvar simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;\n\nfunction assertType (value, type) {\n  var valid;\n  var expectedType = getType(type);\n  if (simpleCheckRE.test(expectedType)) {\n    var t = 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 = 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\nfunction getInvalidTypeMessage (name, value, expectedTypes) {\n  var message = \"Invalid prop: type check failed for prop \\\"\" + name + \"\\\".\" +\n    \" Expected \" + (expectedTypes.map(capitalize).join(', '));\n  var expectedType = expectedTypes[0];\n  var receivedType = toRawType(value);\n  var expectedValue = styleValue(value, expectedType);\n  var receivedValue = styleValue(value, receivedType);\n  // check if we need to specify expected value\n  if (expectedTypes.length === 1 &&\n      isExplicable(expectedType) &&\n      !isBoolean(expectedType, receivedType)) {\n    message += \" with value \" + expectedValue;\n  }\n  message += \", got \" + receivedType + \" \";\n  // check if we need to specify received value\n  if (isExplicable(receivedType)) {\n    message += \"with value \" + receivedValue + \".\";\n  }\n  return message\n}\n\nfunction styleValue (value, type) {\n  if (type === 'String') {\n    return (\"\\\"\" + value + \"\\\"\")\n  } else if (type === 'Number') {\n    return (\"\" + (Number(value)))\n  } else {\n    return (\"\" + value)\n  }\n}\n\nfunction isExplicable (value) {\n  var explicitTypes = ['string', 'number', 'boolean'];\n  return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })\n}\n\nfunction isBoolean () {\n  var args = [], len = arguments.length;\n  while ( len-- ) args[ len ] = arguments[ len ];\n\n  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })\n}\n\n/*  */\n\nfunction handleError (err, vm, info) {\n  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.\n  // See: https://github.com/vuejs/vuex/issues/1505\n  pushTarget();\n  try {\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  } finally {\n    popTarget();\n  }\n}\n\nfunction invokeWithErrorHandling (\n  handler,\n  context,\n  args,\n  vm,\n  info\n) {\n  var res;\n  try {\n    res = args ? handler.apply(context, args) : handler.call(context);\n    if (res && !res._isVue && isPromise(res) && !res._handled) {\n      res.catch(function (e) { return handleError(e, vm, info + \" (Promise/async)\"); });\n      // issue #9511\n      // avoid catch triggering multiple times when nested calls\n      res._handled = true;\n    }\n  } catch (e) {\n    handleError(e, vm, info);\n  }\n  return res\n}\n\nfunction globalHandleError (err, vm, info) {\n  if (config.errorHandler) {\n    try {\n      return config.errorHandler.call(null, err, vm, info)\n    } catch (e) {\n      // if the user intentionally throws the original error in the handler,\n      // do not log it twice\n      if (e !== err) {\n        logError(e, null, 'config.errorHandler');\n      }\n    }\n  }\n  logError(err, vm, info);\n}\n\nfunction logError (err, vm, info) {\n  if (process.env.NODE_ENV !== 'production') {\n    warn((\"Error in \" + info + \": \\\"\" + (err.toString()) + \"\\\"\"), vm);\n  }\n  /* istanbul ignore else */\n  if ((inBrowser || inWeex) && typeof console !== 'undefined') {\n    console.error(err);\n  } else {\n    throw err\n  }\n}\n\n/*  */\n\nvar isUsingMicroTask = false;\n\nvar callbacks = [];\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 microtasks.\n// In 2.5 we used (macro) tasks (in combination with microtasks).\n// However, it has subtle problems when state is changed right before repaint\n// (e.g. #6813, out-in transitions).\n// Also, using (macro) tasks in event handler would cause some weird behaviors\n// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).\n// So we now use microtasks everywhere, again.\n// A major drawback of this tradeoff is that there are some scenarios\n// where microtasks have too high a priority and fire in between supposedly\n// sequential events (e.g. #4521, #6690, which have workarounds)\n// or even between bubbling of the same event (#6566).\nvar timerFunc;\n\n// The nextTick behavior leverages the microtask queue, which can be accessed\n// via either native Promise.then or MutationObserver.\n// MutationObserver has wider support, however it is seriously bugged in\n// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n// completely stops working after triggering a few times... so, if native\n// Promise is available, we will use it:\n/* istanbul ignore next, $flow-disable-line */\nif (typeof Promise !== 'undefined' && isNative(Promise)) {\n  var p = Promise.resolve();\n  timerFunc = function () {\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 (isIOS) { setTimeout(noop); }\n  };\n  isUsingMicroTask = true;\n} else if (!isIE && typeof MutationObserver !== 'undefined' && (\n  isNative(MutationObserver) ||\n  // PhantomJS and iOS 7.x\n  MutationObserver.toString() === '[object MutationObserverConstructor]'\n)) {\n  // Use MutationObserver where native Promise is not available,\n  // e.g. PhantomJS, iOS7, Android 4.4\n  // (#6466 MutationObserver is unreliable in IE11)\n  var counter = 1;\n  var observer = new MutationObserver(flushCallbacks);\n  var textNode = document.createTextNode(String(counter));\n  observer.observe(textNode, {\n    characterData: true\n  });\n  timerFunc = function () {\n    counter = (counter + 1) % 2;\n    textNode.data = String(counter);\n  };\n  isUsingMicroTask = true;\n} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {\n  // Fallback to setImmediate.\n  // Technically it leverages the (macro) task queue,\n  // but it is still a better choice than setTimeout.\n  timerFunc = function () {\n    setImmediate(flushCallbacks);\n  };\n} else {\n  // Fallback to setTimeout.\n  timerFunc = function () {\n    setTimeout(flushCallbacks, 0);\n  };\n}\n\nfunction nextTick (cb, ctx) {\n  var _resolve;\n  callbacks.push(function () {\n    if (cb) {\n      try {\n        cb.call(ctx);\n      } catch (e) {\n        handleError(e, ctx, 'nextTick');\n      }\n    } else if (_resolve) {\n      _resolve(ctx);\n    }\n  });\n  if (!pending) {\n    pending = true;\n    timerFunc();\n  }\n  // $flow-disable-line\n  if (!cb && typeof Promise !== 'undefined') {\n    return new Promise(function (resolve) {\n      _resolve = resolve;\n    })\n  }\n}\n\n/*  */\n\nvar mark;\nvar measure;\n\nif (process.env.NODE_ENV !== 'production') {\n  var perf = inBrowser && window.performance;\n  /* istanbul ignore if */\n  if (\n    perf &&\n    perf.mark &&\n    perf.measure &&\n    perf.clearMarks &&\n    perf.clearMeasures\n  ) {\n    mark = function (tag) { return perf.mark(tag); };\n    measure = function (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/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (process.env.NODE_ENV !== 'production') {\n  var allowedGlobals = makeMap(\n    'Infinity,undefined,NaN,isFinite,isNaN,' +\n    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n    'require' // for Webpack/Browserify\n  );\n\n  var warnNonPresent = function (target, key) {\n    warn(\n      \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n      'referenced during render. Make sure that this property is reactive, ' +\n      'either in the data option, or for class-based components, by ' +\n      'initializing the property. ' +\n      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',\n      target\n    );\n  };\n\n  var warnReservedPrefix = function (target, key) {\n    warn(\n      \"Property \\\"\" + key + \"\\\" must be accessed with \\\"$data.\" + key + \"\\\" because \" +\n      'properties starting with \"$\" or \"_\" are not proxied in the Vue instance to ' +\n      'prevent conflicts with Vue internals. ' +\n      'See: https://vuejs.org/v2/api/#data',\n      target\n    );\n  };\n\n  var hasProxy =\n    typeof Proxy !== 'undefined' && isNative(Proxy);\n\n  if (hasProxy) {\n    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');\n    config.keyCodes = new Proxy(config.keyCodes, {\n      set: function set (target, key, value) {\n        if (isBuiltInModifier(key)) {\n          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) ||\n        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));\n      if (!has && !isAllowed) {\n        if (key in target.$data) { warnReservedPrefix(target, key); }\n        else { 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        if (key in target.$data) { warnReservedPrefix(target, key); }\n        else { warnNonPresent(target, key); }\n      }\n      return target[key]\n    }\n  };\n\n  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\n        ? getHandler\n        : hasHandler;\n      vm._renderProxy = new Proxy(vm, handlers);\n    } else {\n      vm._renderProxy = vm;\n    }\n  };\n}\n\n/*  */\n\nvar seenObjects = new _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, keys;\n  var isA = Array.isArray(val);\n  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {\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--) { _traverse(val[i], seen); }\n  } else {\n    keys = Object.keys(val);\n    i = keys.length;\n    while (i--) { _traverse(val[keys[i]], seen); }\n  }\n}\n\n/*  */\n\nvar normalizeEvent = cached(function (name) {\n  var passive = name.charAt(0) === '&';\n  name = passive ? name.slice(1) : name;\n  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first\n  name = once$$1 ? 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$$1,\n    capture: capture,\n    passive: passive\n  }\n});\n\nfunction createFnInvoker (fns, vm) {\n  function invoker () {\n    var arguments$1 = arguments;\n\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        invokeWithErrorHandling(cloned[i], null, arguments$1, vm, \"v-on handler\");\n      }\n    } else {\n      // return handler return value for single handlers\n      return invokeWithErrorHandling(fns, null, arguments, vm, \"v-on handler\")\n    }\n  }\n  invoker.fns = fns;\n  return invoker\n}\n\nfunction updateListeners (\n  on,\n  oldOn,\n  add,\n  remove$$1,\n  createOnceHandler,\n  vm\n) {\n  var name, def$$1, cur, old, event;\n  for (name in on) {\n    def$$1 = cur = on[name];\n    old = oldOn[name];\n    event = normalizeEvent(name);\n    if (isUndef(cur)) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n        vm\n      );\n    } else if (isUndef(old)) {\n      if (isUndef(cur.fns)) {\n        cur = on[name] = createFnInvoker(cur, vm);\n      }\n      if (isTrue(event.once)) {\n        cur = on[name] = createOnceHandler(event.name, cur, event.capture);\n      }\n      add(event.name, cur, 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 (isUndef(on[name])) {\n      event = normalizeEvent(name);\n      remove$$1(event.name, oldOn[name], event.capture);\n    }\n  }\n}\n\n/*  */\n\nfunction mergeVNodeHook (def, hookKey, hook) {\n  if (def instanceof VNode) {\n    def = def.data.hook || (def.data.hook = {});\n  }\n  var invoker;\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    remove(invoker.fns, wrappedHook);\n  }\n\n  if (isUndef(oldHook)) {\n    // no existing hook\n    invoker = createFnInvoker([wrappedHook]);\n  } else {\n    /* istanbul ignore if */\n    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {\n      // already a merged invoker\n      invoker = oldHook;\n      invoker.fns.push(wrappedHook);\n    } else {\n      // existing plain hook\n      invoker = createFnInvoker([oldHook, wrappedHook]);\n    }\n  }\n\n  invoker.merged = true;\n  def[hookKey] = invoker;\n}\n\n/*  */\n\nfunction extractPropsFromVNodeData (\n  data,\n  Ctor,\n  tag\n) {\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 (isUndef(propOptions)) {\n    return\n  }\n  var res = {};\n  var attrs = data.attrs;\n  var props = data.props;\n  if (isDef(attrs) || isDef(props)) {\n    for (var key in propOptions) {\n      var altKey = hyphenate(key);\n      if (process.env.NODE_ENV !== 'production') {\n        var keyInLowerCase = key.toLowerCase();\n        if (\n          key !== keyInLowerCase &&\n          attrs && hasOwn(attrs, keyInLowerCase)\n        ) {\n          tip(\n            \"Prop \\\"\" + keyInLowerCase + \"\\\" is passed to component \" +\n            (formatComponentName(tag || Ctor)) + \", but the declared prop name is\" +\n            \" \\\"\" + key + \"\\\". \" +\n            \"Note that HTML attributes are case-insensitive and camelCased \" +\n            \"props need to use their kebab-case equivalents when using in-DOM \" +\n            \"templates. You should probably use \\\"\" + altKey + \"\\\" instead of \\\"\" + key + \"\\\".\"\n          );\n        }\n      }\n      checkProp(res, props, key, altKey, true) ||\n      checkProp(res, attrs, key, altKey, false);\n    }\n  }\n  return res\n}\n\nfunction checkProp (\n  res,\n  hash,\n  key,\n  altKey,\n  preserve\n) {\n  if (isDef(hash)) {\n    if (hasOwn(hash, key)) {\n      res[key] = hash[key];\n      if (!preserve) {\n        delete hash[key];\n      }\n      return true\n    } else if (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/*  */\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 isPrimitive(children)\n    ? [createTextVNode(children)]\n    : Array.isArray(children)\n      ? normalizeArrayChildren(children)\n      : undefined\n}\n\nfunction isTextNode (node) {\n  return isDef(node) && isDef(node.text) && isFalse(node.isComment)\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n  var res = [];\n  var i, c, lastIndex, last;\n  for (i = 0; i < children.length; i++) {\n    c = children[i];\n    if (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] = createTextVNode(last.text + (c[0]).text);\n          c.shift();\n        }\n        res.push.apply(res, c);\n      }\n    } else if (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] = createTextVNode(last.text + c);\n      } else if (c !== '') {\n        // convert primitive to vnode\n        res.push(createTextVNode(c));\n      }\n    } else {\n      if (isTextNode(c) && isTextNode(last)) {\n        // merge adjacent text nodes\n        res[lastIndex] = createTextVNode(last.text + c.text);\n      } else {\n        // default key for nested array children (likely generated by v-for)\n        if (isTrue(children._isVList) &&\n          isDef(c.tag) &&\n          isUndef(c.key) &&\n          isDef(nestedIndex)) {\n          c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n        }\n        res.push(c);\n      }\n    }\n  }\n  return res\n}\n\n/*  */\n\nfunction initProvide (vm) {\n  var provide = vm.$options.provide;\n  if (provide) {\n    vm._provided = typeof provide === 'function'\n      ? provide.call(vm)\n      : provide;\n  }\n}\n\nfunction initInjections (vm) {\n  var result = resolveInject(vm.$options.inject, vm);\n  if (result) {\n    toggleObserving(false);\n    Object.keys(result).forEach(function (key) {\n      /* istanbul ignore else */\n      if (process.env.NODE_ENV !== 'production') {\n        defineReactive$$1(vm, key, result[key], function () {\n          warn(\n            \"Avoid mutating an injected value directly since the changes will be \" +\n            \"overwritten whenever the provided component re-renders. \" +\n            \"injection being mutated: \\\"\" + key + \"\\\"\",\n            vm\n          );\n        });\n      } else {\n        defineReactive$$1(vm, key, result[key]);\n      }\n    });\n    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 = hasSymbol\n      ? Reflect.ownKeys(inject)\n      : Object.keys(inject);\n\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i];\n      // #6574 in case the inject object is observed...\n      if (key === '__ob__') { continue }\n      var provideKey = inject[key].from;\n      var source = vm;\n      while (source) {\n        if (source._provided && 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'\n            ? provideDefault.call(vm)\n            : provideDefault;\n        } else if (process.env.NODE_ENV !== 'production') {\n          warn((\"Injection \\\"\" + key + \"\\\" not found\"), vm);\n        }\n      }\n    }\n    return result\n  }\n}\n\n/*  */\n\n\n\n/**\n * Runtime helper for resolving raw children VNodes into a slot object.\n */\nfunction resolveSlots (\n  children,\n  context\n) {\n  if (!children || !children.length) {\n    return {}\n  }\n  var slots = {};\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) &&\n      data && data.slot != null\n    ) {\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$1 in slots) {\n    if (slots[name$1].every(isWhitespace)) {\n      delete slots[name$1];\n    }\n  }\n  return slots\n}\n\nfunction isWhitespace (node) {\n  return (node.isComment && !node.asyncFactory) || node.text === ' '\n}\n\n/*  */\n\nfunction normalizeScopedSlots (\n  slots,\n  normalSlots,\n  prevSlots\n) {\n  var res;\n  var hasNormalSlots = Object.keys(normalSlots).length > 0;\n  var isStable = slots ? !!slots.$stable : !hasNormalSlots;\n  var key = slots && slots.$key;\n  if (!slots) {\n    res = {};\n  } else if (slots._normalized) {\n    // fast path 1: child component re-render only, parent did not change\n    return slots._normalized\n  } else if (\n    isStable &&\n    prevSlots &&\n    prevSlots !== emptyObject &&\n    key === prevSlots.$key &&\n    !hasNormalSlots &&\n    !prevSlots.$hasNormal\n  ) {\n    // fast path 2: stable scoped slots w/ no normal slots to proxy,\n    // only need to normalize once\n    return prevSlots\n  } else {\n    res = {};\n    for (var key$1 in slots) {\n      if (slots[key$1] && key$1[0] !== '$') {\n        res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);\n      }\n    }\n  }\n  // expose normal slots on scopedSlots\n  for (var key$2 in normalSlots) {\n    if (!(key$2 in res)) {\n      res[key$2] = proxyNormalSlot(normalSlots, key$2);\n    }\n  }\n  // avoriaz seems to mock a non-extensible $scopedSlots object\n  // and when that is passed down this would cause an error\n  if (slots && Object.isExtensible(slots)) {\n    (slots)._normalized = res;\n  }\n  def(res, '$stable', isStable);\n  def(res, '$key', key);\n  def(res, '$hasNormal', hasNormalSlots);\n  return res\n}\n\nfunction normalizeScopedSlot(normalSlots, key, fn) {\n  var normalized = function () {\n    var res = arguments.length ? fn.apply(null, arguments) : fn({});\n    res = res && typeof res === 'object' && !Array.isArray(res)\n      ? [res] // single vnode\n      : normalizeChildren(res);\n    return res && (\n      res.length === 0 ||\n      (res.length === 1 && res[0].isComment) // #9658\n    ) ? undefined\n      : res\n  };\n  // this is a slot using the new v-slot syntax without scope. although it is\n  // compiled as a scoped slot, render fn users would expect it to be present\n  // on this.$slots because the usage is semantically a normal slot.\n  if (fn.proxy) {\n    Object.defineProperty(normalSlots, key, {\n      get: normalized,\n      enumerable: true,\n      configurable: true\n    });\n  }\n  return normalized\n}\n\nfunction proxyNormalSlot(slots, key) {\n  return function () { return slots[key]; }\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering v-for lists.\n */\nfunction renderList (\n  val,\n  render\n) {\n  var ret, i, l, keys, key;\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 (isObject(val)) {\n    if (hasSymbol && val[Symbol.iterator]) {\n      ret = [];\n      var iterator = val[Symbol.iterator]();\n      var result = iterator.next();\n      while (!result.done) {\n        ret.push(render(result.value, ret.length));\n        result = iterator.next();\n      }\n    } else {\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  }\n  if (!isDef(ret)) {\n    ret = [];\n  }\n  (ret)._isVList = true;\n  return ret\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering <slot>\n */\nfunction renderSlot (\n  name,\n  fallback,\n  props,\n  bindObject\n) {\n  var scopedSlotFn = this.$scopedSlots[name];\n  var nodes;\n  if (scopedSlotFn) { // scoped slot\n    props = props || {};\n    if (bindObject) {\n      if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {\n        warn(\n          'slot v-bind without argument expects an Object',\n          this\n        );\n      }\n      props = extend(extend({}, bindObject), props);\n    }\n    nodes = scopedSlotFn(props) || fallback;\n  } else {\n    nodes = this.$slots[name] || 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/*  */\n\n/**\n * Runtime helper for resolving filters\n */\nfunction resolveFilter (id) {\n  return resolveAsset(this.$options, 'filters', id, true) || identity\n}\n\n/*  */\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 (\n  eventKeyCode,\n  key,\n  builtInKeyCode,\n  eventKeyName,\n  builtInKeyName\n) {\n  var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;\n  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {\n    return isKeyNotMatch(builtInKeyName, eventKeyName)\n  } else if (mappedKeyCode) {\n    return isKeyNotMatch(mappedKeyCode, eventKeyCode)\n  } else if (eventKeyName) {\n    return hyphenate(eventKeyName) !== key\n  }\n}\n\n/*  */\n\n/**\n * Runtime helper for merging v-bind=\"object\" into a VNode's data.\n */\nfunction bindObjectProps (\n  data,\n  tag,\n  value,\n  asProp,\n  isSync\n) {\n  if (value) {\n    if (!isObject(value)) {\n      process.env.NODE_ENV !== 'production' && warn(\n        'v-bind without argument expects an Object or Array value',\n        this\n      );\n    } else {\n      if (Array.isArray(value)) {\n        value = toObject(value);\n      }\n      var hash;\n      var loop = function ( key ) {\n        if (\n          key === 'class' ||\n          key === 'style' ||\n          isReservedAttribute(key)\n        ) {\n          hash = data;\n        } else {\n          var type = data.attrs && data.attrs.type;\n          hash = asProp || config.mustUseProp(tag, type, key)\n            ? data.domProps || (data.domProps = {})\n            : data.attrs || (data.attrs = {});\n        }\n        var camelizedKey = camelize(key);\n        var hyphenatedKey = hyphenate(key);\n        if (!(camelizedKey in hash) && !(hyphenatedKey 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) loop( key );\n    }\n  }\n  return data\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering static trees.\n */\nfunction renderStatic (\n  index,\n  isInFor\n) {\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(\n    this._renderProxy,\n    null,\n    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 (\n  tree,\n  index,\n  key\n) {\n  markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n  return tree\n}\n\nfunction markStatic (\n  tree,\n  key,\n  isOnce\n) {\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/*  */\n\nfunction bindObjectListeners (data, value) {\n  if (value) {\n    if (!isPlainObject(value)) {\n      process.env.NODE_ENV !== 'production' && warn(\n        'v-on without argument expects an Object value',\n        this\n      );\n    } else {\n      var on = data.on = data.on ? 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/*  */\n\nfunction resolveScopedSlots (\n  fns, // see flow/vnode\n  res,\n  // the following are added in 2.6\n  hasDynamicKeys,\n  contentHashKey\n) {\n  res = res || { $stable: !hasDynamicKeys };\n  for (var i = 0; i < fns.length; i++) {\n    var slot = fns[i];\n    if (Array.isArray(slot)) {\n      resolveScopedSlots(slot, res, hasDynamicKeys);\n    } else if (slot) {\n      // marker for reverse proxying v-slot without scope on this.$slots\n      if (slot.proxy) {\n        slot.fn.proxy = true;\n      }\n      res[slot.key] = slot.fn;\n    }\n  }\n  if (contentHashKey) {\n    (res).$key = contentHashKey;\n  }\n  return res\n}\n\n/*  */\n\nfunction bindDynamicKeys (baseObj, values) {\n  for (var i = 0; i < values.length; i += 2) {\n    var key = values[i];\n    if (typeof key === 'string' && key) {\n      baseObj[values[i]] = values[i + 1];\n    } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) {\n      // null is a special value for explicitly removing a binding\n      warn(\n        (\"Invalid value for dynamic directive argument (expected string or null): \" + key),\n        this\n      );\n    }\n  }\n  return baseObj\n}\n\n// helper to dynamically append modifier runtime markers to event names.\n// ensure only append when value is already string, otherwise it will be cast\n// to string and cause the type check to miss.\nfunction prependModifier (value, symbol) {\n  return typeof value === 'string' ? symbol + value : value\n}\n\n/*  */\n\nfunction installRenderHelpers (target) {\n  target._o = markOnce;\n  target._n = toNumber;\n  target._s = toString;\n  target._l = renderList;\n  target._t = renderSlot;\n  target._q = looseEqual;\n  target._i = looseIndexOf;\n  target._m = renderStatic;\n  target._f = resolveFilter;\n  target._k = checkKeyCodes;\n  target._b = bindObjectProps;\n  target._v = createTextVNode;\n  target._e = createEmptyVNode;\n  target._u = resolveScopedSlots;\n  target._g = bindObjectListeners;\n  target._d = bindDynamicKeys;\n  target._p = prependModifier;\n}\n\n/*  */\n\nfunction FunctionalRenderContext (\n  data,\n  props,\n  children,\n  parent,\n  Ctor\n) {\n  var this$1 = this;\n\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;\n  if (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 = 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 || emptyObject;\n  this.injections = resolveInject(options.inject, parent);\n  this.slots = function () {\n    if (!this$1.$slots) {\n      normalizeScopedSlots(\n        data.scopedSlots,\n        this$1.$slots = resolveSlots(children, parent)\n      );\n    }\n    return this$1.$slots\n  };\n\n  Object.defineProperty(this, 'scopedSlots', ({\n    enumerable: true,\n    get: function get () {\n      return normalizeScopedSlots(data.scopedSlots, this.slots())\n    }\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 = normalizeScopedSlots(data.scopedSlots, this.$slots);\n  }\n\n  if (options._scopeId) {\n    this._c = function (a, b, c, d) {\n      var vnode = 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) { return createElement(contextVm, a, b, c, d, needNormalization); };\n  }\n}\n\ninstallRenderHelpers(FunctionalRenderContext.prototype);\n\nfunction createFunctionalComponent (\n  Ctor,\n  propsData,\n  data,\n  contextVm,\n  children\n) {\n  var options = Ctor.options;\n  var props = {};\n  var propOptions = options.props;\n  if (isDef(propOptions)) {\n    for (var key in propOptions) {\n      props[key] = validateProp(key, propOptions, propsData || emptyObject);\n    }\n  } else {\n    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }\n    if (isDef(data.props)) { mergeProps(props, data.props); }\n  }\n\n  var renderContext = new FunctionalRenderContext(\n    data,\n    props,\n    children,\n    contextVm,\n    Ctor\n  );\n\n  var vnode = options.render.call(null, renderContext._c, renderContext);\n\n  if (vnode instanceof VNode) {\n    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)\n  } else if (Array.isArray(vnode)) {\n    var vnodes = 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, renderContext);\n    }\n    return res\n  }\n}\n\nfunction cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {\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 = cloneVNode(vnode);\n  clone.fnContext = contextVm;\n  clone.fnOptions = options;\n  if (process.env.NODE_ENV !== 'production') {\n    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;\n  }\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[camelize(key)] = from[key];\n  }\n}\n\n/*  */\n\n/*  */\n\n/*  */\n\n/*  */\n\n// inline hooks to be invoked on component VNodes during patch\nvar componentVNodeHooks = {\n  init: function init (vnode, hydrating) {\n    if (\n      vnode.componentInstance &&\n      !vnode.componentInstance._isDestroyed &&\n      vnode.data.keepAlive\n    ) {\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(\n        vnode,\n        activeInstance\n      );\n      child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n    }\n  },\n\n  prepatch: function prepatch (oldVnode, vnode) {\n    var options = vnode.componentOptions;\n    var child = vnode.componentInstance = oldVnode.componentInstance;\n    updateChildComponent(\n      child,\n      options.propsData, // updated props\n      options.listeners, // updated listeners\n      vnode, // new parent vnode\n      options.children // new children\n    );\n  },\n\n  insert: function insert (vnode) {\n    var context = vnode.context;\n    var componentInstance = vnode.componentInstance;\n    if (!componentInstance._isMounted) {\n      componentInstance._isMounted = true;\n      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        queueActivatedComponent(componentInstance);\n      } else {\n        activateChildComponent(componentInstance, true /* direct */);\n      }\n    }\n  },\n\n  destroy: function destroy (vnode) {\n    var componentInstance = vnode.componentInstance;\n    if (!componentInstance._isDestroyed) {\n      if (!vnode.data.keepAlive) {\n        componentInstance.$destroy();\n      } else {\n        deactivateChildComponent(componentInstance, true /* direct */);\n      }\n    }\n  }\n};\n\nvar hooksToMerge = Object.keys(componentVNodeHooks);\n\nfunction createComponent (\n  Ctor,\n  data,\n  context,\n  children,\n  tag\n) {\n  if (isUndef(Ctor)) {\n    return\n  }\n\n  var baseCtor = context.$options._base;\n\n  // plain options object: turn it into a constructor\n  if (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 (process.env.NODE_ENV !== 'production') {\n      warn((\"Invalid Component definition: \" + (String(Ctor))), context);\n    }\n    return\n  }\n\n  // async component\n  var asyncFactory;\n  if (isUndef(Ctor.cid)) {\n    asyncFactory = Ctor;\n    Ctor = resolveAsyncComponent(asyncFactory, baseCtor);\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 createAsyncPlaceholder(\n        asyncFactory,\n        data,\n        context,\n        children,\n        tag\n      )\n    }\n  }\n\n  data = data || {};\n\n  // resolve constructor options in case global mixins are applied after\n  // component constructor creation\n  resolveConstructorOptions(Ctor);\n\n  // transform component v-model data into props & events\n  if (isDef(data.model)) {\n    transformModel(Ctor.options, data);\n  }\n\n  // extract props\n  var propsData = extractPropsFromVNodeData(data, Ctor, tag);\n\n  // functional component\n  if (isTrue(Ctor.options.functional)) {\n    return 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 (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 VNode(\n    (\"vue-component-\" + (Ctor.cid) + (name ? (\"-\" + name) : '')),\n    data, undefined, undefined, undefined, context,\n    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },\n    asyncFactory\n  );\n\n  return vnode\n}\n\nfunction createComponentInstanceForVnode (\n  vnode, // we know it's MountedComponentVNode but flow doesn't\n  parent // activeInstance in lifecycle state\n) {\n  var options = {\n    _isComponent: true,\n    _parentVnode: vnode,\n    parent: parent\n  };\n  // check inline-template render functions\n  var inlineTemplate = vnode.data.inlineTemplate;\n  if (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    var existing = hooks[key];\n    var toMerge = componentVNodeHooks[key];\n    if (existing !== toMerge && !(existing && existing._merged)) {\n      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;\n    }\n  }\n}\n\nfunction mergeHook$1 (f1, f2) {\n  var merged = function (a, b) {\n    // flow complains about extra args which is why we use any\n    f1(a, b);\n    f2(a, b);\n  };\n  merged._merged = true;\n  return merged\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'\n  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;\n  var on = data.on || (data.on = {});\n  var existing = on[event];\n  var callback = data.model.callback;\n  if (isDef(existing)) {\n    if (\n      Array.isArray(existing)\n        ? existing.indexOf(callback) === -1\n        : existing !== callback\n    ) {\n      on[event] = [callback].concat(existing);\n    }\n  } else {\n    on[event] = callback;\n  }\n}\n\n/*  */\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 (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType,\n  alwaysNormalize\n) {\n  if (Array.isArray(data) || isPrimitive(data)) {\n    normalizationType = children;\n    children = data;\n    data = undefined;\n  }\n  if (isTrue(alwaysNormalize)) {\n    normalizationType = ALWAYS_NORMALIZE;\n  }\n  return _createElement(context, tag, data, children, normalizationType)\n}\n\nfunction _createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType\n) {\n  if (isDef(data) && isDef((data).__ob__)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"Avoid using observed data object as vnode data: \" + (JSON.stringify(data)) + \"\\n\" +\n      'Always create fresh vnode data objects in each render!',\n      context\n    );\n    return createEmptyVNode()\n  }\n  // object syntax in v-bind\n  if (isDef(data) && isDef(data.is)) {\n    tag = data.is;\n  }\n  if (!tag) {\n    // in case of component :is set to falsy value\n    return createEmptyVNode()\n  }\n  // warn against non-primitive key\n  if (process.env.NODE_ENV !== 'production' &&\n    isDef(data) && isDef(data.key) && !isPrimitive(data.key)\n  ) {\n    {\n      warn(\n        'Avoid using non-primitive value as key, ' +\n        'use string/number value instead.',\n        context\n      );\n    }\n  }\n  // support single function children as default scoped slot\n  if (Array.isArray(children) &&\n    typeof children[0] === 'function'\n  ) {\n    data = data || {};\n    data.scopedSlots = { default: children[0] };\n    children.length = 0;\n  }\n  if (normalizationType === ALWAYS_NORMALIZE) {\n    children = normalizeChildren(children);\n  } else if (normalizationType === SIMPLE_NORMALIZE) {\n    children = simpleNormalizeChildren(children);\n  }\n  var vnode, ns;\n  if (typeof tag === 'string') {\n    var Ctor;\n    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);\n    if (config.isReservedTag(tag)) {\n      // platform built-in elements\n      if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.nativeOn)) {\n        warn(\n          (\"The .native modifier for v-on is only valid on components but it was used on <\" + tag + \">.\"),\n          context\n        );\n      }\n      vnode = new VNode(\n        config.parsePlatformTagName(tag), data, children,\n        undefined, undefined, context\n      );\n    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {\n      // component\n      vnode = 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 VNode(\n        tag, data, children,\n        undefined, undefined, context\n      );\n    }\n  } else {\n    // direct component options / constructor\n    vnode = createComponent(tag, data, context, children);\n  }\n  if (Array.isArray(vnode)) {\n    return vnode\n  } else if (isDef(vnode)) {\n    if (isDef(ns)) { applyNS(vnode, ns); }\n    if (isDef(data)) { registerDeepBindings(data); }\n    return vnode\n  } else {\n    return 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 (isDef(vnode.children)) {\n    for (var i = 0, l = vnode.children.length; i < l; i++) {\n      var child = vnode.children[i];\n      if (isDef(child.tag) && (\n        isUndef(child.ns) || (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 (isObject(data.style)) {\n    traverse(data.style);\n  }\n  if (isObject(data.class)) {\n    traverse(data.class);\n  }\n}\n\n/*  */\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 = resolveSlots(options._renderChildren, renderContext);\n  vm.$scopedSlots = 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) { return createElement(vm, a, b, c, d, false); };\n  // normalization is always applied for the public version, used in\n  // user-written render functions.\n  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\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 (process.env.NODE_ENV !== 'production') {\n    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {\n      !isUpdatingChildComponent && warn(\"$attrs is readonly.\", vm);\n    }, true);\n    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {\n      !isUpdatingChildComponent && warn(\"$listeners is readonly.\", vm);\n    }, true);\n  } else {\n    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, null, true);\n    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, null, true);\n  }\n}\n\nvar currentRenderingInstance = null;\n\nfunction renderMixin (Vue) {\n  // install runtime convenience helpers\n  installRenderHelpers(Vue.prototype);\n\n  Vue.prototype.$nextTick = function (fn) {\n    return nextTick(fn, this)\n  };\n\n  Vue.prototype._render = function () {\n    var vm = this;\n    var ref = vm.$options;\n    var render = ref.render;\n    var _parentVnode = ref._parentVnode;\n\n    if (_parentVnode) {\n      vm.$scopedSlots = normalizeScopedSlots(\n        _parentVnode.data.scopedSlots,\n        vm.$slots,\n        vm.$scopedSlots\n      );\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;\n    try {\n      // There's no need to maintain a stack because all render fns are called\n      // separately from one another. Nested component's render fns are called\n      // when parent component is patched.\n      currentRenderingInstance = vm;\n      vnode = render.call(vm._renderProxy, vm.$createElement);\n    } catch (e) {\n      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 (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {\n        try {\n          vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);\n        } catch (e) {\n          handleError(e, vm, \"renderError\");\n          vnode = vm._vnode;\n        }\n      } else {\n        vnode = vm._vnode;\n      }\n    } finally {\n      currentRenderingInstance = null;\n    }\n    // if the returned array contains only a single node, allow it\n    if (Array.isArray(vnode) && vnode.length === 1) {\n      vnode = vnode[0];\n    }\n    // return empty vnode in case the render function errored out\n    if (!(vnode instanceof VNode)) {\n      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {\n        warn(\n          'Multiple root nodes returned from render function. Render function ' +\n          'should return a single root node.',\n          vm\n        );\n      }\n      vnode = createEmptyVNode();\n    }\n    // set parent\n    vnode.parent = _parentVnode;\n    return vnode\n  };\n}\n\n/*  */\n\nfunction ensureCtor (comp, base) {\n  if (\n    comp.__esModule ||\n    (hasSymbol && comp[Symbol.toStringTag] === 'Module')\n  ) {\n    comp = comp.default;\n  }\n  return isObject(comp)\n    ? base.extend(comp)\n    : comp\n}\n\nfunction createAsyncPlaceholder (\n  factory,\n  data,\n  context,\n  children,\n  tag\n) {\n  var node = createEmptyVNode();\n  node.asyncFactory = factory;\n  node.asyncMeta = { data: data, context: context, children: children, tag: tag };\n  return node\n}\n\nfunction resolveAsyncComponent (\n  factory,\n  baseCtor\n) {\n  if (isTrue(factory.error) && isDef(factory.errorComp)) {\n    return factory.errorComp\n  }\n\n  if (isDef(factory.resolved)) {\n    return factory.resolved\n  }\n\n  var owner = currentRenderingInstance;\n  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {\n    // already pending\n    factory.owners.push(owner);\n  }\n\n  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {\n    return factory.loadingComp\n  }\n\n  if (owner && !isDef(factory.owners)) {\n    var owners = factory.owners = [owner];\n    var sync = true;\n    var timerLoading = null;\n    var timerTimeout = null\n\n    ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });\n\n    var forceRender = function (renderCompleted) {\n      for (var i = 0, l = owners.length; i < l; i++) {\n        (owners[i]).$forceUpdate();\n      }\n\n      if (renderCompleted) {\n        owners.length = 0;\n        if (timerLoading !== null) {\n          clearTimeout(timerLoading);\n          timerLoading = null;\n        }\n        if (timerTimeout !== null) {\n          clearTimeout(timerTimeout);\n          timerTimeout = null;\n        }\n      }\n    };\n\n    var resolve = 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(true);\n      } else {\n        owners.length = 0;\n      }\n    });\n\n    var reject = once(function (reason) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Failed to resolve async component: \" + (String(factory)) +\n        (reason ? (\"\\nReason: \" + reason) : '')\n      );\n      if (isDef(factory.errorComp)) {\n        factory.error = true;\n        forceRender(true);\n      }\n    });\n\n    var res = factory(resolve, reject);\n\n    if (isObject(res)) {\n      if (isPromise(res)) {\n        // () => Promise\n        if (isUndef(factory.resolved)) {\n          res.then(resolve, reject);\n        }\n      } else if (isPromise(res.component)) {\n        res.component.then(resolve, reject);\n\n        if (isDef(res.error)) {\n          factory.errorComp = ensureCtor(res.error, baseCtor);\n        }\n\n        if (isDef(res.loading)) {\n          factory.loadingComp = ensureCtor(res.loading, baseCtor);\n          if (res.delay === 0) {\n            factory.loading = true;\n          } else {\n            timerLoading = setTimeout(function () {\n              timerLoading = null;\n              if (isUndef(factory.resolved) && isUndef(factory.error)) {\n                factory.loading = true;\n                forceRender(false);\n              }\n            }, res.delay || 200);\n          }\n        }\n\n        if (isDef(res.timeout)) {\n          timerTimeout = setTimeout(function () {\n            timerTimeout = null;\n            if (isUndef(factory.resolved)) {\n              reject(\n                process.env.NODE_ENV !== 'production'\n                  ? (\"timeout (\" + (res.timeout) + \"ms)\")\n                  : null\n              );\n            }\n          }, res.timeout);\n        }\n      }\n    }\n\n    sync = false;\n    // return in case resolved synchronously\n    return factory.loading\n      ? factory.loadingComp\n      : factory.resolved\n  }\n}\n\n/*  */\n\nfunction isAsyncPlaceholder (node) {\n  return node.isComment && node.asyncFactory\n}\n\n/*  */\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 (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {\n        return c\n      }\n    }\n  }\n}\n\n/*  */\n\n/*  */\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;\n\nfunction add (event, fn) {\n  target.$on(event, fn);\n}\n\nfunction remove$1 (event, fn) {\n  target.$off(event, fn);\n}\n\nfunction createOnceHandler (event, fn) {\n  var _target = target;\n  return function onceHandler () {\n    var res = fn.apply(null, arguments);\n    if (res !== null) {\n      _target.$off(event, onceHandler);\n    }\n  }\n}\n\nfunction updateComponentListeners (\n  vm,\n  listeners,\n  oldListeners\n) {\n  target = vm;\n  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, 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        vm.$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$1 = 0, l = event.length; i$1 < l; i$1++) {\n        vm.$off(event[i$1], 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    // specific handler\n    var cb;\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    return vm\n  };\n\n  Vue.prototype.$emit = function (event) {\n    var vm = this;\n    if (process.env.NODE_ENV !== 'production') {\n      var lowerCaseEvent = event.toLowerCase();\n      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {\n        tip(\n          \"Event \\\"\" + lowerCaseEvent + \"\\\" is emitted in component \" +\n          (formatComponentName(vm)) + \" but the handler is registered for \\\"\" + event + \"\\\". \" +\n          \"Note that HTML attributes are case-insensitive and you cannot use \" +\n          \"v-on to listen to camelCase events when using in-DOM templates. \" +\n          \"You should probably use \\\"\" + (hyphenate(event)) + \"\\\" instead of \\\"\" + event + \"\\\".\"\n        );\n      }\n    }\n    var cbs = vm._events[event];\n    if (cbs) {\n      cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n      var args = toArray(arguments, 1);\n      var info = \"event handler for \\\"\" + event + \"\\\"\";\n      for (var i = 0, l = cbs.length; i < l; i++) {\n        invokeWithErrorHandling(cbs[i], vm, args, vm, info);\n      }\n    }\n    return vm\n  };\n}\n\n/*  */\n\nvar activeInstance = null;\nvar isUpdatingChildComponent = false;\n\nfunction setActiveInstance(vm) {\n  var prevActiveInstance = activeInstance;\n  activeInstance = vm;\n  return function () {\n    activeInstance = prevActiveInstance;\n  }\n}\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    var prevEl = vm.$el;\n    var prevVnode = vm._vnode;\n    var restoreActiveInstance = setActiveInstance(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    } else {\n      // updates\n      vm.$el = vm.__patch__(prevVnode, vnode);\n    }\n    restoreActiveInstance();\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      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 (\n  vm,\n  el,\n  hydrating\n) {\n  vm.$el = el;\n  if (!vm.$options.render) {\n    vm.$options.render = createEmptyVNode;\n    if (process.env.NODE_ENV !== 'production') {\n      /* istanbul ignore if */\n      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||\n        vm.$options.el || el) {\n        warn(\n          'You are using the runtime-only build of Vue where the template ' +\n          'compiler is not available. Either pre-compile the templates into ' +\n          'render functions, or use the compiler-included build.',\n          vm\n        );\n      } else {\n        warn(\n          'Failed to mount component: template or render function not defined.',\n          vm\n        );\n      }\n    }\n  }\n  callHook(vm, 'beforeMount');\n\n  var updateComponent;\n  /* istanbul ignore if */\n  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n    updateComponent = function () {\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      mark(startTag);\n      var vnode = vm._render();\n      mark(endTag);\n      measure((\"vue \" + name + \" render\"), startTag, endTag);\n\n      mark(startTag);\n      vm._update(vnode, hydrating);\n      mark(endTag);\n      measure((\"vue \" + name + \" patch\"), startTag, endTag);\n    };\n  } else {\n    updateComponent = function () {\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 Watcher(vm, updateComponent, noop, {\n    before: function before () {\n      if (vm._isMounted && !vm._isDestroyed) {\n        callHook(vm, 'beforeUpdate');\n      }\n    }\n  }, 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 (\n  vm,\n  propsData,\n  listeners,\n  parentVnode,\n  renderChildren\n) {\n  if (process.env.NODE_ENV !== 'production') {\n    isUpdatingChildComponent = true;\n  }\n\n  // determine whether component has slot children\n  // we need to do this before overwriting $options._renderChildren.\n\n  // check if there are dynamic scopedSlots (hand-written or compiled but with\n  // dynamic slot names). Static scoped slots compiled from template has the\n  // \"$stable\" marker.\n  var newScopedSlots = parentVnode.data.scopedSlots;\n  var oldScopedSlots = vm.$scopedSlots;\n  var hasDynamicScopedSlot = !!(\n    (newScopedSlots && !newScopedSlots.$stable) ||\n    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||\n    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)\n  );\n\n  // Any static slot children from the parent may have changed during parent's\n  // update. Dynamic scoped slots may also have changed. In such cases, a forced\n  // update is necessary to ensure correctness.\n  var needsForceUpdate = !!(\n    renderChildren ||               // has new static slots\n    vm.$options._renderChildren ||  // has old static slots\n    hasDynamicScopedSlot\n  );\n\n  vm.$options._parentVnode = parentVnode;\n  vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n\n  if (vm._vnode) { // 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 || emptyObject;\n  vm.$listeners = listeners || emptyObject;\n\n  // update props\n  if (propsData && vm.$options.props) {\n    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] = validateProp(key, propOptions, propsData, vm);\n    }\n    toggleObserving(true);\n    // keep a copy of raw propsData\n    vm.$options.propsData = propsData;\n  }\n\n  // update listeners\n  listeners = listeners || emptyObject;\n  var oldListeners = vm.$options._parentListeners;\n  vm.$options._parentListeners = listeners;\n  updateComponentListeners(vm, listeners, oldListeners);\n\n  // resolve slots + force update if has children\n  if (needsForceUpdate) {\n    vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n    vm.$forceUpdate();\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    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  pushTarget();\n  var handlers = vm.$options[hook];\n  var info = hook + \" hook\";\n  if (handlers) {\n    for (var i = 0, j = handlers.length; i < j; i++) {\n      invokeWithErrorHandling(handlers[i], vm, null, vm, info);\n    }\n  }\n  if (vm._hasHookEvent) {\n    vm.$emit('hook:' + hook);\n  }\n  popTarget();\n}\n\n/*  */\n\nvar 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 (process.env.NODE_ENV !== 'production') {\n    circular = {};\n  }\n  waiting = flushing = false;\n}\n\n// Async edge case #6566 requires saving the timestamp when event listeners are\n// attached. However, calling performance.now() has a perf overhead especially\n// if the page has thousands of event listeners. Instead, we take a timestamp\n// every time the scheduler flushes and use that for all event listeners\n// attached during that flush.\nvar currentFlushTimestamp = 0;\n\n// Async edge case fix requires storing an event listener's attach timestamp.\nvar getNow = Date.now;\n\n// Determine what event timestamp the browser is using. Annoyingly, the\n// timestamp can either be hi-res (relative to page load) or low-res\n// (relative to UNIX epoch), so in order to compare time we have to use the\n// same timestamp type when saving the flush timestamp.\n// All IE versions use low-res event timestamps, and have problematic clock\n// implementations (#9632)\nif (inBrowser && !isIE) {\n  var performance = window.performance;\n  if (\n    performance &&\n    typeof performance.now === 'function' &&\n    getNow() > document.createEvent('Event').timeStamp\n  ) {\n    // if the event timestamp, although evaluated AFTER the Date.now(), is\n    // smaller than it, it means the event is using a hi-res timestamp,\n    // and we need to use the hi-res version for event listener timestamps as\n    // well.\n    getNow = function () { return performance.now(); };\n  }\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n  currentFlushTimestamp = getNow();\n  flushing = true;\n  var watcher, id;\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) { return a.id - b.id; });\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    if (watcher.before) {\n      watcher.before();\n    }\n    id = watcher.id;\n    has[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if (process.env.NODE_ENV !== 'production' && has[id] != null) {\n      circular[id] = (circular[id] || 0) + 1;\n      if (circular[id] > MAX_UPDATE_COUNT) {\n        warn(\n          'You may have an infinite update loop ' + (\n            watcher.user\n              ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n              : \"in a component render function.\"\n          ),\n          watcher.vm\n        );\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 (devtools && config.devtools) {\n    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 && !vm._isDestroyed) {\n      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    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\n      if (process.env.NODE_ENV !== 'production' && !config.async) {\n        flushSchedulerQueue();\n        return\n      }\n      nextTick(flushSchedulerQueue);\n    }\n  }\n}\n\n/*  */\n\n\n\nvar uid$2 = 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 */\nvar Watcher = function Watcher (\n  vm,\n  expOrFn,\n  cb,\n  options,\n  isRenderWatcher\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    this.before = options.before;\n  } else {\n    this.deep = this.user = this.lazy = this.sync = false;\n  }\n  this.cb = cb;\n  this.id = ++uid$2; // 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 _Set();\n  this.newDepIds = new _Set();\n  this.expression = process.env.NODE_ENV !== 'production'\n    ? expOrFn.toString()\n    : '';\n  // parse expression for getter\n  if (typeof expOrFn === 'function') {\n    this.getter = expOrFn;\n  } else {\n    this.getter = parsePath(expOrFn);\n    if (!this.getter) {\n      this.getter = noop;\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n        'Watcher only accepts simple dot-delimited paths. ' +\n        'For full control, use a function instead.',\n        vm\n      );\n    }\n  }\n  this.value = this.lazy\n    ? undefined\n    : this.get();\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\nWatcher.prototype.get = function get () {\n  pushTarget(this);\n  var value;\n  var vm = this.vm;\n  try {\n    value = this.getter.call(vm, vm);\n  } catch (e) {\n    if (this.user) {\n      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      traverse(value);\n    }\n    popTarget();\n    this.cleanupDeps();\n  }\n  return value\n};\n\n/**\n * Add a dependency to this directive.\n */\nWatcher.prototype.addDep = 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 */\nWatcher.prototype.cleanupDeps = 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 */\nWatcher.prototype.update = 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    queueWatcher(this);\n  }\n};\n\n/**\n * Scheduler job interface.\n * Will be called by the scheduler.\n */\nWatcher.prototype.run = function run () {\n  if (this.active) {\n    var value = this.get();\n    if (\n      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      isObject(value) ||\n      this.deep\n    ) {\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          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 */\nWatcher.prototype.evaluate = function evaluate () {\n  this.value = this.get();\n  this.dirty = false;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\nWatcher.prototype.depend = 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 */\nWatcher.prototype.teardown = 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      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\nvar sharedPropertyDefinition = {\n  enumerable: true,\n  configurable: true,\n  get: noop,\n  set: 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    observe(vm._data = {}, true /* asRootData */);\n  }\n  if (opts.computed) { initComputed(vm, opts.computed); }\n  if (opts.watch && opts.watch !== 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    toggleObserving(false);\n  }\n  var loop = function ( key ) {\n    keys.push(key);\n    var value = validateProp(key, propsOptions, propsData, vm);\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== 'production') {\n      var hyphenatedKey = hyphenate(key);\n      if (isReservedAttribute(hyphenatedKey) ||\n          config.isReservedAttr(hyphenatedKey)) {\n        warn(\n          (\"\\\"\" + hyphenatedKey + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n          vm\n        );\n      }\n      defineReactive$$1(props, key, value, function () {\n        if (!isRoot && !isUpdatingChildComponent) {\n          warn(\n            \"Avoid mutating a prop directly since the value will be \" +\n            \"overwritten whenever the parent component re-renders. \" +\n            \"Instead, use a data or computed property based on the prop's \" +\n            \"value. Prop being mutated: \\\"\" + key + \"\\\"\",\n            vm\n          );\n        }\n      });\n    } else {\n      defineReactive$$1(props, key, value);\n    }\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) loop( key );\n  toggleObserving(true);\n}\n\nfunction initData (vm) {\n  var data = vm.$options.data;\n  data = vm._data = typeof data === 'function'\n    ? getData(data, vm)\n    : data || {};\n  if (!isPlainObject(data)) {\n    data = {};\n    process.env.NODE_ENV !== 'production' && warn(\n      'data functions should return an object:\\n' +\n      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n      vm\n    );\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 (process.env.NODE_ENV !== 'production') {\n      if (methods && hasOwn(methods, key)) {\n        warn(\n          (\"Method \\\"\" + key + \"\\\" has already been defined as a data property.\"),\n          vm\n        );\n      }\n    }\n    if (props && hasOwn(props, key)) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"The data property \\\"\" + key + \"\\\" is already declared as a prop. \" +\n        \"Use prop default value instead.\",\n        vm\n      );\n    } else if (!isReserved(key)) {\n      proxy(vm, \"_data\", key);\n    }\n  }\n  // observe data\n  observe(data, true /* asRootData */);\n}\n\nfunction getData (data, vm) {\n  // #7573 disable dep collection when invoking data getters\n  pushTarget();\n  try {\n    return data.call(vm, vm)\n  } catch (e) {\n    handleError(e, vm, \"data()\");\n    return {}\n  } finally {\n    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 = isServerRendering();\n\n  for (var key in computed) {\n    var userDef = computed[key];\n    var getter = typeof userDef === 'function' ? userDef : userDef.get;\n    if (process.env.NODE_ENV !== 'production' && getter == null) {\n      warn(\n        (\"Getter is missing for computed property \\\"\" + key + \"\\\".\"),\n        vm\n      );\n    }\n\n    if (!isSSR) {\n      // create internal watcher for the computed property.\n      watchers[key] = new Watcher(\n        vm,\n        getter || noop,\n        noop,\n        computedWatcherOptions\n      );\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 (process.env.NODE_ENV !== 'production') {\n      if (key in vm.$data) {\n        warn((\"The computed property \\\"\" + key + \"\\\" is already defined in data.\"), vm);\n      } else if (vm.$options.props && key in vm.$options.props) {\n        warn((\"The computed property \\\"\" + key + \"\\\" is already defined as a prop.\"), vm);\n      }\n    }\n  }\n}\n\nfunction defineComputed (\n  target,\n  key,\n  userDef\n) {\n  var shouldCache = !isServerRendering();\n  if (typeof userDef === 'function') {\n    sharedPropertyDefinition.get = shouldCache\n      ? createComputedGetter(key)\n      : createGetterInvoker(userDef);\n    sharedPropertyDefinition.set = noop;\n  } else {\n    sharedPropertyDefinition.get = userDef.get\n      ? shouldCache && userDef.cache !== false\n        ? createComputedGetter(key)\n        : createGetterInvoker(userDef.get)\n      : noop;\n    sharedPropertyDefinition.set = userDef.set || noop;\n  }\n  if (process.env.NODE_ENV !== 'production' &&\n      sharedPropertyDefinition.set === noop) {\n    sharedPropertyDefinition.set = function () {\n      warn(\n        (\"Computed property \\\"\" + key + \"\\\" was assigned to but it has no setter.\"),\n        this\n      );\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 (Dep.target) {\n        watcher.depend();\n      }\n      return watcher.value\n    }\n  }\n}\n\nfunction createGetterInvoker(fn) {\n  return function computedGetter () {\n    return fn.call(this, this)\n  }\n}\n\nfunction initMethods (vm, methods) {\n  var props = vm.$options.props;\n  for (var key in methods) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof methods[key] !== 'function') {\n        warn(\n          \"Method \\\"\" + key + \"\\\" has type \\\"\" + (typeof methods[key]) + \"\\\" in the component definition. \" +\n          \"Did you reference the function correctly?\",\n          vm\n        );\n      }\n      if (props && hasOwn(props, key)) {\n        warn(\n          (\"Method \\\"\" + key + \"\\\" has already been defined as a prop.\"),\n          vm\n        );\n      }\n      if ((key in vm) && isReserved(key)) {\n        warn(\n          \"Method \\\"\" + key + \"\\\" conflicts with an existing Vue instance method. \" +\n          \"Avoid defining component methods that start with _ or $.\"\n        );\n      }\n    }\n    vm[key] = typeof methods[key] !== 'function' ? noop : 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 (\n  vm,\n  expOrFn,\n  handler,\n  options\n) {\n  if (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 () { return this._data };\n  var propsDef = {};\n  propsDef.get = function () { return this._props };\n  if (process.env.NODE_ENV !== 'production') {\n    dataDef.set = function () {\n      warn(\n        'Avoid replacing instance root $data. ' +\n        'Use nested data properties instead.',\n        this\n      );\n    };\n    propsDef.set = function () {\n      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 = set;\n  Vue.prototype.$delete = del;\n\n  Vue.prototype.$watch = function (\n    expOrFn,\n    cb,\n    options\n  ) {\n    var vm = this;\n    if (isPlainObject(cb)) {\n      return createWatcher(vm, expOrFn, cb, options)\n    }\n    options = options || {};\n    options.user = true;\n    var watcher = new Watcher(vm, expOrFn, cb, options);\n    if (options.immediate) {\n      try {\n        cb.call(vm, watcher.value);\n      } catch (error) {\n        handleError(error, vm, (\"callback for immediate watcher \\\"\" + (watcher.expression) + \"\\\"\"));\n      }\n    }\n    return function unwatchFn () {\n      watcher.teardown();\n    }\n  };\n}\n\n/*  */\n\nvar uid$3 = 0;\n\nfunction initMixin (Vue) {\n  Vue.prototype._init = function (options) {\n    var vm = this;\n    // a uid\n    vm._uid = uid$3++;\n\n    var startTag, endTag;\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n      startTag = \"vue-perf-start:\" + (vm._uid);\n      endTag = \"vue-perf-end:\" + (vm._uid);\n      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 = mergeOptions(\n        resolveConstructorOptions(vm.constructor),\n        options || {},\n        vm\n      );\n    }\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== 'production') {\n      initProxy(vm);\n    } else {\n      vm._renderProxy = vm;\n    }\n    // expose real self\n    vm._self = vm;\n    initLifecycle(vm);\n    initEvents(vm);\n    initRender(vm);\n    callHook(vm, 'beforeCreate');\n    initInjections(vm); // resolve injections before data/props\n    initState(vm);\n    initProvide(vm); // resolve provide after data/props\n    callHook(vm, 'created');\n\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n      vm._name = formatComponentName(vm, false);\n      mark(endTag);\n      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\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        extend(Ctor.extendOptions, modifiedOptions);\n      }\n      options = Ctor.options = 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;\n  var latest = Ctor.options;\n  var sealed = Ctor.sealedOptions;\n  for (var key in latest) {\n    if (latest[key] !== sealed[key]) {\n      if (!modified) { modified = {}; }\n      modified[key] = latest[key];\n    }\n  }\n  return modified\n}\n\nfunction Vue (options) {\n  if (process.env.NODE_ENV !== 'production' &&\n    !(this instanceof Vue)\n  ) {\n    warn('Vue is a constructor and should be called with the `new` keyword');\n  }\n  this._init(options);\n}\n\ninitMixin(Vue);\nstateMixin(Vue);\neventsMixin(Vue);\nlifecycleMixin(Vue);\nrenderMixin(Vue);\n\n/*  */\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 = 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/*  */\n\nfunction initMixin$1 (Vue) {\n  Vue.mixin = function (mixin) {\n    this.options = mergeOptions(this.options, mixin);\n    return this\n  };\n}\n\n/*  */\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 (process.env.NODE_ENV !== 'production' && name) {\n      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 = mergeOptions(\n      Super.options,\n      extendOptions\n    );\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$1(Sub);\n    }\n    if (Sub.options.computed) {\n      initComputed$1(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    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 = extend({}, Sub.options);\n\n    // cache constructor\n    cachedCtors[SuperId] = Sub;\n    return Sub\n  };\n}\n\nfunction initProps$1 (Comp) {\n  var props = Comp.options.props;\n  for (var key in props) {\n    proxy(Comp.prototype, \"_props\", key);\n  }\n}\n\nfunction initComputed$1 (Comp) {\n  var computed = Comp.options.computed;\n  for (var key in computed) {\n    defineComputed(Comp.prototype, key, computed[key]);\n  }\n}\n\n/*  */\n\nfunction initAssetRegisters (Vue) {\n  /**\n   * Create asset registration methods.\n   */\n  ASSET_TYPES.forEach(function (type) {\n    Vue[type] = function (\n      id,\n      definition\n    ) {\n      if (!definition) {\n        return this.options[type + 's'][id]\n      } else {\n        /* istanbul ignore if */\n        if (process.env.NODE_ENV !== 'production' && type === 'component') {\n          validateComponentName(id);\n        }\n        if (type === 'component' && 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/*  */\n\n\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 (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  var keys = keepAliveInstance.keys;\n  var _vnode = keepAliveInstance._vnode;\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 (\n  cache,\n  key,\n  keys,\n  current\n) {\n  var cached$$1 = cache[key];\n  if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {\n    cached$$1.componentInstance.$destroy();\n  }\n  cache[key] = null;\n  remove(keys, key);\n}\n\nvar patternTypes = [String, RegExp, Array];\n\nvar KeepAlive = {\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\n  destroyed: function destroyed () {\n    for (var key in this.cache) {\n      pruneCacheEntry(this.cache, key, this.keys);\n    }\n  },\n\n  mounted: function mounted () {\n    var this$1 = this;\n\n    this.$watch('include', function (val) {\n      pruneCache(this$1, function (name) { return matches(val, name); });\n    });\n    this.$watch('exclude', function (val) {\n      pruneCache(this$1, function (name) { return !matches(val, name); });\n    });\n  },\n\n  render: function render () {\n    var slot = this.$slots.default;\n    var vnode = getFirstComponentChild(slot);\n    var componentOptions = vnode && vnode.componentOptions;\n    if (componentOptions) {\n      // check pattern\n      var name = getComponentName(componentOptions);\n      var ref = this;\n      var include = ref.include;\n      var exclude = ref.exclude;\n      if (\n        // not included\n        (include && (!name || !matches(include, name))) ||\n        // excluded\n        (exclude && name && matches(exclude, name))\n      ) {\n        return vnode\n      }\n\n      var ref$1 = this;\n      var cache = ref$1.cache;\n      var keys = ref$1.keys;\n      var key = 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)) : '')\n        : vnode.key;\n      if (cache[key]) {\n        vnode.componentInstance = cache[key].componentInstance;\n        // make current key freshest\n        remove(keys, key);\n        keys.push(key);\n      } else {\n        cache[key] = vnode;\n        keys.push(key);\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};\n\nvar builtInComponents = {\n  KeepAlive: KeepAlive\n};\n\n/*  */\n\nfunction initGlobalAPI (Vue) {\n  // config\n  var configDef = {};\n  configDef.get = function () { return config; };\n  if (process.env.NODE_ENV !== 'production') {\n    configDef.set = function () {\n      warn(\n        'Do not replace the Vue.config object, set individual fields instead.'\n      );\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: warn,\n    extend: extend,\n    mergeOptions: mergeOptions,\n    defineReactive: defineReactive$$1\n  };\n\n  Vue.set = set;\n  Vue.delete = del;\n  Vue.nextTick = nextTick;\n\n  // 2.6 explicit observable API\n  Vue.observable = function (obj) {\n    observe(obj);\n    return obj\n  };\n\n  Vue.options = Object.create(null);\n  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  extend(Vue.options.components, builtInComponents);\n\n  initUse(Vue);\n  initMixin$1(Vue);\n  initExtend(Vue);\n  initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue);\n\nObject.defineProperty(Vue.prototype, '$isServer', {\n  get: isServerRendering\n});\n\nObject.defineProperty(Vue.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(Vue, 'FunctionalRenderContext', {\n  value: FunctionalRenderContext\n});\n\nVue.version = '2.6.11';\n\n/*  */\n\n// these are reserved for web because they are directly compiled away\n// during template compilation\nvar isReservedAttr = makeMap('style,class');\n\n// attributes that should be using props for binding\nvar acceptValue = makeMap('input,textarea,option,select,progress');\nvar mustUseProp = function (tag, type, attr) {\n  return (\n    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||\n    (attr === 'selected' && tag === 'option') ||\n    (attr === 'checked' && tag === 'input') ||\n    (attr === 'muted' && tag === 'video')\n  )\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');\n\nvar convertEnumeratedValue = function (key, value) {\n  return isFalsyAttrValue(value) || value === 'false'\n    ? 'false'\n    // allow arbitrary string value for contenteditable\n    : key === 'contenteditable' && isValidContentEditableValue(value)\n      ? value\n      : 'true'\n};\n\nvar isBooleanAttr = makeMap(\n  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +\n  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +\n  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +\n  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +\n  'required,reversed,scoped,seamless,selected,sortable,translate,' +\n  'truespeed,typemustmatch,visible'\n);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n  return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n  return val == null || val === false\n};\n\n/*  */\n\nfunction genClassForVnode (vnode) {\n  var data = vnode.data;\n  var parentNode = vnode;\n  var childNode = vnode;\n  while (isDef(childNode.componentInstance)) {\n    childNode = childNode.componentInstance._vnode;\n    if (childNode && childNode.data) {\n      data = mergeClassData(childNode.data, data);\n    }\n  }\n  while (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: isDef(child.class)\n      ? [child.class, parent.class]\n      : parent.class\n  }\n}\n\nfunction renderClass (\n  staticClass,\n  dynamicClass\n) {\n  if (isDef(staticClass) || 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 (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;\n  for (var i = 0, l = value.length; i < l; i++) {\n    if (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/*  */\n\nvar namespaceMap = {\n  svg: 'http://www.w3.org/2000/svg',\n  math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = makeMap(\n  'html,body,base,head,link,meta,style,title,' +\n  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +\n  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +\n  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +\n  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +\n  'embed,object,param,source,canvas,script,noscript,del,ins,' +\n  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +\n  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +\n  'output,progress,select,textarea,' +\n  'details,dialog,menu,menuitem,summary,' +\n  'content,element,shadow,template,blockquote,iframe,tfoot'\n);\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap(\n  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +\n  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +\n  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',\n  true\n);\n\nvar isPreTag = function (tag) { return tag === 'pre'; };\n\nvar isReservedTag = function (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 (!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] = (\n      el.constructor === window.HTMLUnknownElement ||\n      el.constructor === window.HTMLElement\n    ))\n  } else {\n    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n  }\n}\n\nvar isTextInputType = makeMap('text,number,password,search,email,tel,url');\n\n/*  */\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      process.env.NODE_ENV !== 'production' && warn(\n        'Cannot find element: ' + el\n      );\n      return document.createElement('div')\n    }\n    return selected\n  } else {\n    return el\n  }\n}\n\n/*  */\n\nfunction createElement$1 (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(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\nvar nodeOps = /*#__PURE__*/Object.freeze({\n  createElement: createElement$1,\n  createElementNS: createElementNS,\n  createTextNode: createTextNode,\n  createComment: createComment,\n  insertBefore: insertBefore,\n  removeChild: removeChild,\n  appendChild: appendChild,\n  parentNode: parentNode,\n  nextSibling: nextSibling,\n  tagName: tagName,\n  setTextContent: setTextContent,\n  setStyleScope: setStyleScope\n});\n\n/*  */\n\nvar ref = {\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};\n\nfunction registerRef (vnode, isRemoval) {\n  var key = vnode.data.ref;\n  if (!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      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/**\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 = new VNode('', {}, []);\n\nvar hooks = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction sameVnode (a, b) {\n  return (\n    a.key === b.key && (\n      (\n        a.tag === b.tag &&\n        a.isComment === b.isComment &&\n        isDef(a.data) === isDef(b.data) &&\n        sameInputType(a, b)\n      ) || (\n        isTrue(a.isAsyncPlaceholder) &&\n        a.asyncFactory === b.asyncFactory &&\n        isUndef(b.asyncFactory.error)\n      )\n    )\n  )\n}\n\nfunction sameInputType (a, b) {\n  if (a.tag !== 'input') { return true }\n  var i;\n  var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;\n  var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;\n  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)\n}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n  var i, key;\n  var map = {};\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) { map[key] = i; }\n  }\n  return map\n}\n\nfunction createPatchFunction (backend) {\n  var i, j;\n  var cbs = {};\n\n  var modules = backend.modules;\n  var nodeOps = backend.nodeOps;\n\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (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 VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n  }\n\n  function createRmCb (childElm, listeners) {\n    function remove$$1 () {\n      if (--remove$$1.listeners === 0) {\n        removeNode(childElm);\n      }\n    }\n    remove$$1.listeners = listeners;\n    return remove$$1\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 (isDef(parent)) {\n      nodeOps.removeChild(parent, el);\n    }\n  }\n\n  function isUnknownElement$$1 (vnode, inVPre) {\n    return (\n      !inVPre &&\n      !vnode.ns &&\n      !(\n        config.ignoredElements.length &&\n        config.ignoredElements.some(function (ignore) {\n          return isRegExp(ignore)\n            ? ignore.test(vnode.tag)\n            : ignore === vnode.tag\n        })\n      ) &&\n      config.isUnknownElement(vnode.tag)\n    )\n  }\n\n  var creatingElmInVPre = 0;\n\n  function createElm (\n    vnode,\n    insertedVnodeQueue,\n    parentElm,\n    refElm,\n    nested,\n    ownerArray,\n    index\n  ) {\n    if (isDef(vnode.elm) && 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] = 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 (isDef(tag)) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (data && data.pre) {\n          creatingElmInVPre++;\n        }\n        if (isUnknownElement$$1(vnode, creatingElmInVPre)) {\n          warn(\n            'Unknown custom element: <' + tag + '> - did you ' +\n            'register the component correctly? For recursive components, ' +\n            'make sure to provide the \"name\" option.',\n            vnode.context\n          );\n        }\n      }\n\n      vnode.elm = vnode.ns\n        ? nodeOps.createElementNS(vnode.ns, tag)\n        : nodeOps.createElement(tag, vnode);\n      setScope(vnode);\n\n      /* istanbul ignore if */\n      {\n        createChildren(vnode, children, insertedVnodeQueue);\n        if (isDef(data)) {\n          invokeCreateHooks(vnode, insertedVnodeQueue);\n        }\n        insert(parentElm, vnode.elm, refElm);\n      }\n\n      if (process.env.NODE_ENV !== 'production' && data && data.pre) {\n        creatingElmInVPre--;\n      }\n    } else if (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 (isDef(i)) {\n      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;\n      if (isDef(i = i.hook) && isDef(i = i.init)) {\n        i(vnode, false /* hydrating */);\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 (isDef(vnode.componentInstance)) {\n        initComponent(vnode, insertedVnodeQueue);\n        insert(parentElm, vnode.elm, refElm);\n        if (isTrue(isReactivated)) {\n          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n        }\n        return true\n      }\n    }\n  }\n\n  function initComponent (vnode, insertedVnodeQueue) {\n    if (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      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;\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 (isDef(i = innerNode.data) && 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$$1) {\n    if (isDef(parent)) {\n      if (isDef(ref$$1)) {\n        if (nodeOps.parentNode(ref$$1) === parent) {\n          nodeOps.insertBefore(parent, elm, ref$$1);\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 (process.env.NODE_ENV !== 'production') {\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 (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 isDef(vnode.tag)\n  }\n\n  function invokeCreateHooks (vnode, insertedVnodeQueue) {\n    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n      cbs.create[i$1](emptyNode, vnode);\n    }\n    i = vnode.data.hook; // Reuse variable\n    if (isDef(i)) {\n      if (isDef(i.create)) { i.create(emptyNode, vnode); }\n      if (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;\n    if (isDef(i = vnode.fnScopeId)) {\n      nodeOps.setStyleScope(vnode.elm, i);\n    } else {\n      var ancestor = vnode;\n      while (ancestor) {\n        if (isDef(i = ancestor.context) && 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 (isDef(i = activeInstance) &&\n      i !== vnode.context &&\n      i !== vnode.fnContext &&\n      isDef(i = i.$options._scopeId)\n    ) {\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, j;\n    var data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }\n      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }\n    }\n    if (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 (vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.tag)) {\n          removeAndInvokeRemoveHook(ch);\n          invokeDestroyHook(ch);\n        } else { // Text node\n          removeNode(ch.elm);\n        }\n      }\n    }\n  }\n\n  function removeAndInvokeRemoveHook (vnode, rm) {\n    if (isDef(rm) || isDef(vnode.data)) {\n      var i;\n      var listeners = cbs.remove.length + 1;\n      if (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 (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {\n        removeAndInvokeRemoveHook(i, rm);\n      }\n      for (i = 0; i < cbs.remove.length; ++i) {\n        cbs.remove[i](vnode, rm);\n      }\n      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {\n        i(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, idxInOld, vnodeToMove, refElm;\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 (process.env.NODE_ENV !== 'production') {\n      checkDuplicateKeys(newCh);\n    }\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);\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)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);\n        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n        idxInOld = isDef(newStartVnode.key)\n          ? oldKeyToIdx[newStartVnode.key]\n          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);\n        if (isUndef(idxInOld)) { // 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, newCh, newStartIdx);\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 = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function checkDuplicateKeys (children) {\n    var seenKeys = {};\n    for (var i = 0; i < children.length; i++) {\n      var vnode = children[i];\n      var key = vnode.key;\n      if (isDef(key)) {\n        if (seenKeys[key]) {\n          warn(\n            (\"Duplicate keys detected: '\" + key + \"'. This may cause an update error.\"),\n            vnode.context\n          );\n        } else {\n          seenKeys[key] = true;\n        }\n      }\n    }\n  }\n\n  function findIdxInOld (node, oldCh, start, end) {\n    for (var i = start; i < end; i++) {\n      var c = oldCh[i];\n      if (isDef(c) && sameVnode(node, c)) { return i }\n    }\n  }\n\n  function patchVnode (\n    oldVnode,\n    vnode,\n    insertedVnodeQueue,\n    ownerArray,\n    index,\n    removeOnly\n  ) {\n    if (oldVnode === vnode) {\n      return\n    }\n\n    if (isDef(vnode.elm) && isDef(ownerArray)) {\n      // clone reused vnode\n      vnode = ownerArray[index] = cloneVNode(vnode);\n    }\n\n    var elm = vnode.elm = oldVnode.elm;\n\n    if (isTrue(oldVnode.isAsyncPlaceholder)) {\n      if (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 (isTrue(vnode.isStatic) &&\n      isTrue(oldVnode.isStatic) &&\n      vnode.key === oldVnode.key &&\n      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))\n    ) {\n      vnode.componentInstance = oldVnode.componentInstance;\n      return\n    }\n\n    var i;\n    var data = vnode.data;\n    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n      i(oldVnode, vnode);\n    }\n\n    var oldCh = oldVnode.children;\n    var ch = vnode.children;\n    if (isDef(data) && isPatchable(vnode)) {\n      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }\n      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }\n      } else if (isDef(ch)) {\n        if (process.env.NODE_ENV !== 'production') {\n          checkDuplicateKeys(ch);\n        }\n        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }\n        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n      } else if (isDef(oldCh)) {\n        removeVnodes(oldCh, 0, oldCh.length - 1);\n      } else if (isDef(oldVnode.text)) {\n        nodeOps.setTextContent(elm, '');\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      nodeOps.setTextContent(elm, vnode.text);\n    }\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && 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 (isTrue(initial) && isDef(vnode.parent)) {\n      vnode.parent.data.pendingInsert = queue;\n    } else {\n      for (var i = 0; i < queue.length; ++i) {\n        queue[i].data.hook.insert(queue[i]);\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 = 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;\n    var tag = vnode.tag;\n    var data = vnode.data;\n    var children = vnode.children;\n    inVPre = inVPre || (data && data.pre);\n    vnode.elm = elm;\n\n    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {\n      vnode.isAsyncPlaceholder = true;\n      return true\n    }\n    // assert node match\n    if (process.env.NODE_ENV !== 'production') {\n      if (!assertNodeMatch(elm, vnode, inVPre)) {\n        return false\n      }\n    }\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }\n      if (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 (isDef(tag)) {\n      if (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 (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {\n            if (i !== elm.innerHTML) {\n              /* istanbul ignore if */\n              if (process.env.NODE_ENV !== 'production' &&\n                typeof console !== 'undefined' &&\n                !hydrationBailed\n              ) {\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 i$1 = 0; i$1 < children.length; i$1++) {\n              if (!childNode || !hydrate(childNode, children[i$1], 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 (process.env.NODE_ENV !== 'production' &&\n                typeof console !== 'undefined' &&\n                !hydrationBailed\n              ) {\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 (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          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 (isDef(vnode.tag)) {\n      return vnode.tag.indexOf('vue-component') === 0 || (\n        !isUnknownElement$$1(vnode, inVPre) &&\n        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())\n      )\n    } else {\n      return node.nodeType === (vnode.isComment ? 8 : 3)\n    }\n  }\n\n  return function patch (oldVnode, vnode, hydrating, removeOnly) {\n    if (isUndef(vnode)) {\n      if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }\n      return\n    }\n\n    var isInitialPatch = false;\n    var insertedVnodeQueue = [];\n\n    if (isUndef(oldVnode)) {\n      // empty mount (likely as component), create new root element\n      isInitialPatch = true;\n      createElm(vnode, insertedVnodeQueue);\n    } else {\n      var isRealElement = isDef(oldVnode.nodeType);\n      if (!isRealElement && sameVnode(oldVnode, vnode)) {\n        // patch existing root node\n        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, 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(SSR_ATTR)) {\n            oldVnode.removeAttribute(SSR_ATTR);\n            hydrating = true;\n          }\n          if (isTrue(hydrating)) {\n            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n              invokeInsertHook(vnode, insertedVnodeQueue, true);\n              return oldVnode\n            } else if (process.env.NODE_ENV !== 'production') {\n              warn(\n                'The client-side rendered virtual DOM tree is not matching ' +\n                'server-rendered content. This is likely caused by incorrect ' +\n                'HTML markup, for example nesting block-level elements inside ' +\n                '<p>, or missing <tbody>. Bailing hydration and performing ' +\n                'full client-side render.'\n              );\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(\n          vnode,\n          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,\n          nodeOps.nextSibling(oldElm)\n        );\n\n        // update parent placeholder node element, recursively\n        if (isDef(vnode.parent)) {\n          var ancestor = vnode.parent;\n          var patchable = isPatchable(vnode);\n          while (ancestor) {\n            for (var i = 0; i < cbs.destroy.length; ++i) {\n              cbs.destroy[i](ancestor);\n            }\n            ancestor.elm = vnode.elm;\n            if (patchable) {\n              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n                cbs.create[i$1](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 i$2 = 1; i$2 < insert.fns.length; i$2++) {\n                  insert.fns[i$2]();\n                }\n              }\n            } else {\n              registerRef(ancestor);\n            }\n            ancestor = ancestor.parent;\n          }\n        }\n\n        // destroy old node\n        if (isDef(parentElm)) {\n          removeVnodes([oldVnode], 0, 0);\n        } else if (isDef(oldVnode.tag)) {\n          invokeDestroyHook(oldVnode);\n        }\n      }\n    }\n\n    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n    return vnode.elm\n  }\n}\n\n/*  */\n\nvar directives = {\n  create: updateDirectives,\n  update: updateDirectives,\n  destroy: function unbindDirectives (vnode) {\n    updateDirectives(vnode, emptyNode);\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 === emptyNode;\n  var isDestroy = vnode === emptyNode;\n  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n  var dirsWithInsert = [];\n  var dirsWithPostpatch = [];\n\n  var key, oldDir, dir;\n  for (key in newDirs) {\n    oldDir = oldDirs[key];\n    dir = newDirs[key];\n    if (!oldDir) {\n      // new directive, bind\n      callHook$1(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      dir.oldArg = oldDir.arg;\n      callHook$1(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 () {\n      for (var i = 0; i < dirsWithInsert.length; i++) {\n        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n      }\n    };\n    if (isCreate) {\n      mergeVNodeHook(vnode, 'insert', callInsert);\n    } else {\n      callInsert();\n    }\n  }\n\n  if (dirsWithPostpatch.length) {\n    mergeVNodeHook(vnode, 'postpatch', function () {\n      for (var i = 0; i < dirsWithPostpatch.length; i++) {\n        callHook$1(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$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n      }\n    }\n  }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n  dirs,\n  vm\n) {\n  var res = Object.create(null);\n  if (!dirs) {\n    // $flow-disable-line\n    return res\n  }\n  var i, dir;\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 = 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$1 (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      handleError(e, vnode.context, (\"directive \" + (dir.name) + \" \" + hook + \" hook\"));\n    }\n  }\n}\n\nvar baseModules = [\n  ref,\n  directives\n];\n\n/*  */\n\nfunction updateAttrs (oldVnode, vnode) {\n  var opts = vnode.componentOptions;\n  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {\n    return\n  }\n  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {\n    return\n  }\n  var key, cur, old;\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 (isDef(attrs.__ob__)) {\n    attrs = vnode.data.attrs = 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 ((isIE || isEdge) && attrs.value !== oldAttrs.value) {\n    setAttr(elm, 'value', attrs.value);\n  }\n  for (key in oldAttrs) {\n    if (isUndef(attrs[key])) {\n      if (isXlink(key)) {\n        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n      } else if (!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 (isBooleanAttr(key)) {\n    // set attribute for blank value\n    // e.g. <option disabled>Select one</option>\n    if (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'\n        ? 'true'\n        : key;\n      el.setAttribute(key, value);\n    }\n  } else if (isEnumeratedAttr(key)) {\n    el.setAttribute(key, convertEnumeratedValue(key, value));\n  } else if (isXlink(key)) {\n    if (isFalsyAttrValue(value)) {\n      el.removeAttributeNS(xlinkNS, getXlinkProp(key));\n    } else {\n      el.setAttributeNS(xlinkNS, key, value);\n    }\n  } else {\n    baseSetAttr(el, key, value);\n  }\n}\n\nfunction baseSetAttr (el, key, value) {\n  if (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 (\n      isIE && !isIE9 &&\n      el.tagName === 'TEXTAREA' &&\n      key === 'placeholder' && value !== '' && !el.__ieph\n    ) {\n      var blocker = function (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\nvar attrs = {\n  create: updateAttrs,\n  update: updateAttrs\n};\n\n/*  */\n\nfunction updateClass (oldVnode, vnode) {\n  var el = vnode.elm;\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n  if (\n    isUndef(data.staticClass) &&\n    isUndef(data.class) && (\n      isUndef(oldData) || (\n        isUndef(oldData.staticClass) &&\n        isUndef(oldData.class)\n      )\n    )\n  ) {\n    return\n  }\n\n  var cls = genClassForVnode(vnode);\n\n  // handle transition classes\n  var transitionClass = el._transitionClasses;\n  if (isDef(transitionClass)) {\n    cls = concat(cls, 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\nvar klass = {\n  create: updateClass,\n  update: updateClass\n};\n\n/*  */\n\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, prev, i, expression, filters;\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 (\n      c === 0x7C && // pipe\n      exp.charCodeAt(i + 1) !== 0x7C &&\n      exp.charCodeAt(i - 1) !== 0x7C &&\n      !curly && !square && !paren\n    ) {\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: inDouble = true; break         // \"\n        case 0x27: inSingle = true; break         // '\n        case 0x60: inTemplateString = true; break // `\n        case 0x28: paren++; break                 // (\n        case 0x29: paren--; break                 // )\n        case 0x5B: square++; break                // [\n        case 0x5D: square--; break                // ]\n        case 0x7B: curly++; break                 // {\n        case 0x7D: curly--; break                 // }\n      }\n      if (c === 0x2f) { // /\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/*  */\n\n\n\n/* eslint-disable no-unused-vars */\nfunction baseWarn (msg, range) {\n  console.error((\"[Vue compiler]: \" + msg));\n}\n/* eslint-enable no-unused-vars */\n\nfunction pluckModuleFunction (\n  modules,\n  key\n) {\n  return modules\n    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })\n    : []\n}\n\nfunction addProp (el, name, value, range, dynamic) {\n  (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));\n  el.plain = false;\n}\n\nfunction addAttr (el, name, value, range, dynamic) {\n  var attrs = dynamic\n    ? (el.dynamicAttrs || (el.dynamicAttrs = []))\n    : (el.attrs || (el.attrs = []));\n  attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));\n  el.plain = false;\n}\n\n// add a raw attr (use this in preTransforms)\nfunction addRawAttr (el, name, value, range) {\n  el.attrsMap[name] = value;\n  el.attrsList.push(rangeSetItem({ name: name, value: value }, range));\n}\n\nfunction addDirective (\n  el,\n  name,\n  rawName,\n  value,\n  arg,\n  isDynamicArg,\n  modifiers,\n  range\n) {\n  (el.directives || (el.directives = [])).push(rangeSetItem({\n    name: name,\n    rawName: rawName,\n    value: value,\n    arg: arg,\n    isDynamicArg: isDynamicArg,\n    modifiers: modifiers\n  }, range));\n  el.plain = false;\n}\n\nfunction prependModifierMarker (symbol, name, dynamic) {\n  return dynamic\n    ? (\"_p(\" + name + \",\\\"\" + symbol + \"\\\")\")\n    : symbol + name // mark the event as captured\n}\n\nfunction addHandler (\n  el,\n  name,\n  value,\n  modifiers,\n  important,\n  warn,\n  range,\n  dynamic\n) {\n  modifiers = modifiers || emptyObject;\n  // warn prevent and passive modifier\n  /* istanbul ignore if */\n  if (\n    process.env.NODE_ENV !== 'production' && warn &&\n    modifiers.prevent && modifiers.passive\n  ) {\n    warn(\n      'passive and prevent can\\'t be used together. ' +\n      'Passive handler can\\'t prevent default event.',\n      range\n    );\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 (modifiers.right) {\n    if (dynamic) {\n      name = \"(\" + name + \")==='click'?'contextmenu':(\" + name + \")\";\n    } else if (name === 'click') {\n      name = 'contextmenu';\n      delete modifiers.right;\n    }\n  } else if (modifiers.middle) {\n    if (dynamic) {\n      name = \"(\" + name + \")==='click'?'mouseup':(\" + name + \")\";\n    } else if (name === 'click') {\n      name = 'mouseup';\n    }\n  }\n\n  // check capture modifier\n  if (modifiers.capture) {\n    delete modifiers.capture;\n    name = prependModifierMarker('!', name, dynamic);\n  }\n  if (modifiers.once) {\n    delete modifiers.once;\n    name = prependModifierMarker('~', name, dynamic);\n  }\n  /* istanbul ignore if */\n  if (modifiers.passive) {\n    delete modifiers.passive;\n    name = prependModifierMarker('&', name, dynamic);\n  }\n\n  var events;\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 = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);\n  if (modifiers !== 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 getRawBindingAttr (\n  el,\n  name\n) {\n  return el.rawAttrsMap[':' + name] ||\n    el.rawAttrsMap['v-bind:' + name] ||\n    el.rawAttrsMap[name]\n}\n\nfunction getBindingAttr (\n  el,\n  name,\n  getStatic\n) {\n  var dynamicValue =\n    getAndRemoveAttr(el, ':' + name) ||\n    getAndRemoveAttr(el, 'v-bind:' + name);\n  if (dynamicValue != null) {\n    return 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 (\n  el,\n  name,\n  removeFromMap\n) {\n  var val;\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\nfunction getAndRemoveAttrByRegex (\n  el,\n  name\n) {\n  var list = el.attrsList;\n  for (var i = 0, l = list.length; i < l; i++) {\n    var attr = list[i];\n    if (name.test(attr.name)) {\n      list.splice(i, 1);\n      return attr\n    }\n  }\n}\n\nfunction rangeSetItem (\n  item,\n  range\n) {\n  if (range) {\n    if (range.start != null) {\n      item.start = range.start;\n    }\n    if (range.end != null) {\n      item.end = range.end;\n    }\n  }\n  return item\n}\n\n/*  */\n\n/**\n * Cross-platform code generation for component v-model\n */\nfunction genComponentModel (\n  el,\n  value,\n  modifiers\n) {\n  var ref = modifiers || {};\n  var number = ref.number;\n  var trim = ref.trim;\n\n  var baseValueExpression = '$$v';\n  var valueExpression = baseValueExpression;\n  if (trim) {\n    valueExpression =\n      \"(typeof \" + baseValueExpression + \" === 'string'\" +\n      \"? \" + baseValueExpression + \".trim()\" +\n      \": \" + 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: JSON.stringify(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 (\n  value,\n  assignment\n) {\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, str, chr, index$1, expressionPos, expressionEndPos;\n\n\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$1 = val.lastIndexOf('.');\n    if (index$1 > -1) {\n      return {\n        exp: val.slice(0, index$1),\n        key: '\"' + val.slice(index$1 + 1) + '\"'\n      }\n    } else {\n      return {\n        exp: val,\n        key: null\n      }\n    }\n  }\n\n  str = val;\n  index$1 = 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$1)\n}\n\nfunction eof () {\n  return index$1 >= len\n}\n\nfunction isStringStart (chr) {\n  return chr === 0x22 || chr === 0x27\n}\n\nfunction parseBracket (chr) {\n  var inBracket = 1;\n  expressionPos = index$1;\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$1;\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/*  */\n\nvar warn$1;\n\n// in some cases, the event used has to be determined at runtime\n// so we used some reserved tokens during compile.\nvar RANGE_TOKEN = '__r';\nvar CHECKBOX_RADIO_TOKEN = '__c';\n\nfunction model (\n  el,\n  dir,\n  _warn\n) {\n  warn$1 = _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 (process.env.NODE_ENV !== 'production') {\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$1(\n        \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" type=\\\"file\\\">:\\n\" +\n        \"File inputs are read only. Use a v-on:change listener instead.\",\n        el.rawAttrsMap['v-model']\n      );\n    }\n  }\n\n  if (el.component) {\n    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 (!config.isReservedTag(tag)) {\n    genComponentModel(el, value, modifiers);\n    // component v-model doesn't need extra runtime\n    return false\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn$1(\n      \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n      \"v-model is not supported on this element type. \" +\n      'If you are working with contenteditable, it\\'s recommended to ' +\n      'wrap a library dedicated for that purpose inside a custom component.',\n      el.rawAttrsMap['v-model']\n    );\n  }\n\n  // ensure runtime directive metadata\n  return true\n}\n\nfunction genCheckboxModel (\n  el,\n  value,\n  modifiers\n) {\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';\n  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';\n  addProp(el, 'checked',\n    \"Array.isArray(\" + value + \")\" +\n    \"?_i(\" + value + \",\" + valueBinding + \")>-1\" + (\n      trueValueBinding === 'true'\n        ? (\":(\" + value + \")\")\n        : (\":_q(\" + value + \",\" + trueValueBinding + \")\")\n    )\n  );\n  addHandler(el, 'change',\n    \"var $$a=\" + value + \",\" +\n        '$$el=$event.target,' +\n        \"$$c=$$el.checked?(\" + trueValueBinding + \"):(\" + falseValueBinding + \");\" +\n    'if(Array.isArray($$a)){' +\n      \"var $$v=\" + (number ? '_n(' + valueBinding + ')' : valueBinding) + \",\" +\n          '$$i=_i($$a,$$v);' +\n      \"if($$el.checked){$$i<0&&(\" + (genAssignmentCode(value, '$$a.concat([$$v])')) + \")}\" +\n      \"else{$$i>-1&&(\" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + \")}\" +\n    \"}else{\" + (genAssignmentCode(value, '$$c')) + \"}\",\n    null, true\n  );\n}\n\nfunction genRadioModel (\n  el,\n  value,\n  modifiers\n) {\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  valueBinding = number ? (\"_n(\" + valueBinding + \")\") : valueBinding;\n  addProp(el, 'checked', (\"_q(\" + value + \",\" + valueBinding + \")\"));\n  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);\n}\n\nfunction genSelect (\n  el,\n  value,\n  modifiers\n) {\n  var number = modifiers && modifiers.number;\n  var selectedVal = \"Array.prototype.filter\" +\n    \".call($event.target.options,function(o){return o.selected})\" +\n    \".map(function(o){var val = \\\"_value\\\" in o ? o._value : o.value;\" +\n    \"return \" + (number ? '_n(val)' : 'val') + \"})\";\n\n  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';\n  var code = \"var $$selectedVal = \" + selectedVal + \";\";\n  code = code + \" \" + (genAssignmentCode(value, assignment));\n  addHandler(el, 'change', code, null, true);\n}\n\nfunction genDefaultModel (\n  el,\n  value,\n  modifiers\n) {\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 (process.env.NODE_ENV !== 'production') {\n    var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];\n    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n    if (value$1 && !typeBinding) {\n      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';\n      warn$1(\n        binding + \"=\\\"\" + value$1 + \"\\\" conflicts with v-model on the same element \" +\n        'because the latter already expands to a value binding internally',\n        el.rawAttrsMap[binding]\n      );\n    }\n  }\n\n  var ref = modifiers || {};\n  var lazy = ref.lazy;\n  var number = ref.number;\n  var trim = ref.trim;\n  var needCompositionGuard = !lazy && type !== 'range';\n  var event = lazy\n    ? 'change'\n    : type === 'range'\n      ? RANGE_TOKEN\n      : '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 = genAssignmentCode(value, valueExpression);\n  if (needCompositionGuard) {\n    code = \"if($event.target.composing)return;\" + code;\n  }\n\n  addProp(el, 'value', (\"(\" + value + \")\"));\n  addHandler(el, event, code, null, true);\n  if (trim || number) {\n    addHandler(el, 'blur', '$forceUpdate()');\n  }\n}\n\n/*  */\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 (isDef(on[RANGE_TOKEN])) {\n    // IE input[type=range] only supports `change` event\n    var event = isIE ? 'change' : 'input';\n    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);\n    delete on[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 (isDef(on[CHECKBOX_RADIO_TOKEN])) {\n    on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);\n    delete on[CHECKBOX_RADIO_TOKEN];\n  }\n}\n\nvar target$1;\n\nfunction createOnceHandler$1 (event, handler, capture) {\n  var _target = target$1; // save current target element in closure\n  return function onceHandler () {\n    var res = handler.apply(null, arguments);\n    if (res !== null) {\n      remove$2(event, onceHandler, capture, _target);\n    }\n  }\n}\n\n// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp\n// implementation and does not fire microtasks in between event propagation, so\n// safe to exclude.\nvar useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);\n\nfunction add$1 (\n  name,\n  handler,\n  capture,\n  passive\n) {\n  // async edge case #6566: inner click event triggers patch, event handler\n  // attached to outer element during patch, and triggered again. This\n  // happens because browsers fire microtask ticks between event propagation.\n  // the solution is simple: we save the timestamp when a handler is attached,\n  // and the handler would only fire if the event passed to it was fired\n  // AFTER it was attached.\n  if (useMicrotaskFix) {\n    var attachedTimestamp = currentFlushTimestamp;\n    var original = handler;\n    handler = original._wrapper = function (e) {\n      if (\n        // no bubbling, should always fire.\n        // this is just a safety net in case event.timeStamp is unreliable in\n        // certain weird environments...\n        e.target === e.currentTarget ||\n        // event is fired after handler attachment\n        e.timeStamp >= attachedTimestamp ||\n        // bail for environments that have buggy event.timeStamp implementations\n        // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState\n        // #9681 QtWebEngine event.timeStamp is negative value\n        e.timeStamp <= 0 ||\n        // #9448 bail if event is fired in another document in a multi-page\n        // electron/nw.js app, since event.timeStamp will be using a different\n        // starting reference\n        e.target.ownerDocument !== document\n      ) {\n        return original.apply(this, arguments)\n      }\n    };\n  }\n  target$1.addEventListener(\n    name,\n    handler,\n    supportsPassive\n      ? { capture: capture, passive: passive }\n      : capture\n  );\n}\n\nfunction remove$2 (\n  name,\n  handler,\n  capture,\n  _target\n) {\n  (_target || target$1).removeEventListener(\n    name,\n    handler._wrapper || handler,\n    capture\n  );\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {\n    return\n  }\n  var on = vnode.data.on || {};\n  var oldOn = oldVnode.data.on || {};\n  target$1 = vnode.elm;\n  normalizeEvents(on);\n  updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);\n  target$1 = undefined;\n}\n\nvar events = {\n  create: updateDOMListeners,\n  update: updateDOMListeners\n};\n\n/*  */\n\nvar svgContainer;\n\nfunction updateDOMProps (oldVnode, vnode) {\n  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {\n    return\n  }\n  var key, cur;\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 (isDef(props.__ob__)) {\n    props = vnode.data.domProps = extend({}, props);\n  }\n\n  for (key in oldProps) {\n    if (!(key in props)) {\n      elm[key] = '';\n    }\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' && elm.tagName !== 'PROGRESS') {\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 = isUndef(cur) ? '' : String(cur);\n      if (shouldUpdateValue(elm, strCur)) {\n        elm.value = strCur;\n      }\n    } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {\n      // IE doesn't support innerHTML for SVG elements\n      svgContainer = svgContainer || document.createElement('div');\n      svgContainer.innerHTML = \"<svg>\" + cur + \"</svg>\";\n      var svg = svgContainer.firstChild;\n      while (elm.firstChild) {\n        elm.removeChild(elm.firstChild);\n      }\n      while (svg.firstChild) {\n        elm.appendChild(svg.firstChild);\n      }\n    } else if (\n      // skip the update if old and new VDOM state is the same.\n      // `value` is handled separately because the DOM value may be temporarily\n      // out of sync with VDOM state due to focus, composition and modifiers.\n      // This  #4521 by skipping the unnecesarry `checked` update.\n      cur !== oldProps[key]\n    ) {\n      // some property updates can throw\n      // e.g. `value` on <progress> w/ non-finite value\n      try {\n        elm[key] = cur;\n      } catch (e) {}\n    }\n  }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (elm, checkVal) {\n  return (!elm.composing && (\n    elm.tagName === 'OPTION' ||\n    isNotInFocusAndDirty(elm, checkVal) ||\n    isDirtyWithModifiers(elm, checkVal)\n  ))\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 { notInFocus = document.activeElement !== elm; } 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 (isDef(modifiers)) {\n    if (modifiers.number) {\n      return toNumber(value) !== toNumber(newVal)\n    }\n    if (modifiers.trim) {\n      return value.trim() !== newVal.trim()\n    }\n  }\n  return value !== newVal\n}\n\nvar domProps = {\n  create: updateDOMProps,\n  update: updateDOMProps\n};\n\n/*  */\n\nvar parseStyleText = 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\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\n    ? extend(data.staticStyle, style)\n    : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n  if (Array.isArray(bindingStyle)) {\n    return 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;\n\n  if (checkChild) {\n    var childNode = vnode;\n    while (childNode.componentInstance) {\n      childNode = childNode.componentInstance._vnode;\n      if (\n        childNode && childNode.data &&\n        (styleData = normalizeStyleData(childNode.data))\n      ) {\n        extend(res, styleData);\n      }\n    }\n  }\n\n  if ((styleData = normalizeStyleData(vnode.data))) {\n    extend(res, styleData);\n  }\n\n  var parentNode = vnode;\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n      extend(res, styleData);\n    }\n  }\n  return res\n}\n\n/*  */\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function (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(hyphenate(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;\nvar normalize = cached(function (prop) {\n  emptyStyle = emptyStyle || document.createElement('div').style;\n  prop = 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 (isUndef(data.staticStyle) && isUndef(data.style) &&\n    isUndef(oldData.staticStyle) && isUndef(oldData.style)\n  ) {\n    return\n  }\n\n  var cur, name;\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 = 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 = isDef(style.__ob__)\n    ? extend({}, style)\n    : style;\n\n  var newStyle = getStyle(vnode, true);\n\n  for (name in oldStyle) {\n    if (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\nvar style = {\n  create: updateStyle,\n  update: updateStyle\n};\n\n/*  */\n\nvar whitespaceRE = /\\s+/;\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(whitespaceRE).forEach(function (c) { return el.classList.add(c); });\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(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });\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/*  */\n\nfunction resolveTransition (def$$1) {\n  if (!def$$1) {\n    return\n  }\n  /* istanbul ignore else */\n  if (typeof def$$1 === 'object') {\n    var res = {};\n    if (def$$1.css !== false) {\n      extend(res, autoCssTransition(def$$1.name || 'v'));\n    }\n    extend(res, def$$1);\n    return res\n  } else if (typeof def$$1 === 'string') {\n    return autoCssTransition(def$$1)\n  }\n}\n\nvar autoCssTransition = 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 = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = 'transition';\nvar transitionEndEvent = 'transitionend';\nvar animationProp = 'animation';\nvar animationEndEvent = 'animationend';\nif (hasTransition) {\n  /* istanbul ignore if */\n  if (window.ontransitionend === undefined &&\n    window.onwebkittransitionend !== undefined\n  ) {\n    transitionProp = 'WebkitTransition';\n    transitionEndEvent = 'webkitTransitionEnd';\n  }\n  if (window.onanimationend === undefined &&\n    window.onwebkitanimationend !== undefined\n  ) {\n    animationProp = 'WebkitAnimation';\n    animationEndEvent = 'webkitAnimationEnd';\n  }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser\n  ? window.requestAnimationFrame\n    ? window.requestAnimationFrame.bind(window)\n    : setTimeout\n  : /* istanbul ignore next */ function (fn) { return fn(); };\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    addClass(el, cls);\n  }\n}\n\nfunction removeTransitionClass (el, cls) {\n  if (el._transitionClasses) {\n    remove(el._transitionClasses, cls);\n  }\n  removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n  el,\n  expectedType,\n  cb\n) {\n  var ref = getTransitionInfo(el, expectedType);\n  var type = ref.type;\n  var timeout = ref.timeout;\n  var propCount = ref.propCount;\n  if (!type) { return cb() }\n  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n  var ended = 0;\n  var end = function () {\n    el.removeEventListener(event, onEnd);\n    cb();\n  };\n  var onEnd = function (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  // JSDOM may return undefined for transition properties\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;\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\n      ? transitionTimeout > animationTimeout\n        ? TRANSITION\n        : ANIMATION\n      : null;\n    propCount = type\n      ? type === TRANSITION\n        ? transitionDurations.length\n        : animationDurations.length\n      : 0;\n  }\n  var hasTransform =\n    type === TRANSITION &&\n    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\n// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers\n// in a locale-dependent way, using a comma instead of a dot.\n// If comma is not replaced with a dot, the input will be rounded down (i.e. acting\n// as a floor function) causing unexpected behaviors\nfunction toMs (s) {\n  return Number(s.slice(0, -1).replace(',', '.')) * 1000\n}\n\n/*  */\n\nfunction enter (vnode, toggleDisplay) {\n  var el = vnode.elm;\n\n  // call leave callback now\n  if (isDef(el._leaveCb)) {\n    el._leaveCb.cancelled = true;\n    el._leaveCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (isUndef(data)) {\n    return\n  }\n\n  /* istanbul ignore if */\n  if (isDef(el._enterCb) || el.nodeType !== 1) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var enterClass = data.enterClass;\n  var enterToClass = data.enterToClass;\n  var enterActiveClass = data.enterActiveClass;\n  var appearClass = data.appearClass;\n  var appearToClass = data.appearToClass;\n  var appearActiveClass = data.appearActiveClass;\n  var beforeEnter = data.beforeEnter;\n  var enter = data.enter;\n  var afterEnter = data.afterEnter;\n  var enterCancelled = data.enterCancelled;\n  var beforeAppear = data.beforeAppear;\n  var appear = data.appear;\n  var afterAppear = data.afterAppear;\n  var appearCancelled = data.appearCancelled;\n  var 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  var context = activeInstance;\n  var transitionNode = activeInstance.$vnode;\n  while (transitionNode && transitionNode.parent) {\n    context = transitionNode.context;\n    transitionNode = transitionNode.parent;\n  }\n\n  var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n  if (isAppear && !appear && appear !== '') {\n    return\n  }\n\n  var startClass = isAppear && appearClass\n    ? appearClass\n    : enterClass;\n  var activeClass = isAppear && appearActiveClass\n    ? appearActiveClass\n    : enterActiveClass;\n  var toClass = isAppear && appearToClass\n    ? appearToClass\n    : enterToClass;\n\n  var beforeEnterHook = isAppear\n    ? (beforeAppear || beforeEnter)\n    : beforeEnter;\n  var enterHook = isAppear\n    ? (typeof appear === 'function' ? appear : enter)\n    : enter;\n  var afterEnterHook = isAppear\n    ? (afterAppear || afterEnter)\n    : afterEnter;\n  var enterCancelledHook = isAppear\n    ? (appearCancelled || enterCancelled)\n    : enterCancelled;\n\n  var explicitEnterDuration = toNumber(\n    isObject(duration)\n      ? duration.enter\n      : duration\n  );\n\n  if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {\n    checkDuration(explicitEnterDuration, 'enter', vnode);\n  }\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl = getHookArgumentsLength(enterHook);\n\n  var cb = el._enterCb = once(function () {\n    if (expectsCSS) {\n      removeTransitionClass(el, toClass);\n      removeTransitionClass(el, activeClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        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    mergeVNodeHook(vnode, 'insert', function () {\n      var parent = el.parentNode;\n      var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n      if (pendingNode &&\n        pendingNode.tag === vnode.tag &&\n        pendingNode.elm._leaveCb\n      ) {\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    addTransitionClass(el, startClass);\n    addTransitionClass(el, activeClass);\n    nextFrame(function () {\n      removeTransitionClass(el, startClass);\n      if (!cb.cancelled) {\n        addTransitionClass(el, toClass);\n        if (!userWantsControl) {\n          if (isValidDuration(explicitEnterDuration)) {\n            setTimeout(cb, explicitEnterDuration);\n          } else {\n            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 (isDef(el._enterCb)) {\n    el._enterCb.cancelled = true;\n    el._enterCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (isUndef(data) || el.nodeType !== 1) {\n    return rm()\n  }\n\n  /* istanbul ignore if */\n  if (isDef(el._leaveCb)) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var leaveClass = data.leaveClass;\n  var leaveToClass = data.leaveToClass;\n  var leaveActiveClass = data.leaveActiveClass;\n  var beforeLeave = data.beforeLeave;\n  var leave = data.leave;\n  var afterLeave = data.afterLeave;\n  var leaveCancelled = data.leaveCancelled;\n  var delayLeave = data.delayLeave;\n  var duration = data.duration;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl = getHookArgumentsLength(leave);\n\n  var explicitLeaveDuration = toNumber(\n    isObject(duration)\n      ? duration.leave\n      : duration\n  );\n\n  if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {\n    checkDuration(explicitLeaveDuration, 'leave', vnode);\n  }\n\n  var cb = el._leaveCb = once(function () {\n    if (el.parentNode && el.parentNode._pending) {\n      el.parentNode._pending[vnode.key] = null;\n    }\n    if (expectsCSS) {\n      removeTransitionClass(el, leaveToClass);\n      removeTransitionClass(el, leaveActiveClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        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 && el.parentNode) {\n      (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;\n    }\n    beforeLeave && beforeLeave(el);\n    if (expectsCSS) {\n      addTransitionClass(el, leaveClass);\n      addTransitionClass(el, leaveActiveClass);\n      nextFrame(function () {\n        removeTransitionClass(el, leaveClass);\n        if (!cb.cancelled) {\n          addTransitionClass(el, leaveToClass);\n          if (!userWantsControl) {\n            if (isValidDuration(explicitLeaveDuration)) {\n              setTimeout(cb, explicitLeaveDuration);\n            } else {\n              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    warn(\n      \"<transition> explicit \" + name + \" duration is not a valid number - \" +\n      \"got \" + (JSON.stringify(val)) + \".\",\n      vnode.context\n    );\n  } else if (isNaN(val)) {\n    warn(\n      \"<transition> explicit \" + name + \" duration is NaN - \" +\n      'the duration expression might be incorrect.',\n      vnode.context\n    );\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 (isUndef(fn)) {\n    return false\n  }\n  var invokerFns = fn.fns;\n  if (isDef(invokerFns)) {\n    // invoker\n    return getHookArgumentsLength(\n      Array.isArray(invokerFns)\n        ? invokerFns[0]\n        : invokerFns\n    )\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\nvar transition = inBrowser ? {\n  create: _enter,\n  activate: _enter,\n  remove: function remove$$1 (vnode, rm) {\n    /* istanbul ignore else */\n    if (vnode.data.show !== true) {\n      leave(vnode, rm);\n    } else {\n      rm();\n    }\n  }\n} : {};\n\nvar platformModules = [\n  attrs,\n  klass,\n  events,\n  domProps,\n  style,\n  transition\n];\n\n/*  */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\n/* istanbul ignore if */\nif (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        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' || 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 (isIE9) {\n          el.vmodel = true;\n        }\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) { return !looseEqual(o, prevOptions[i]); })) {\n        // trigger change event if\n        // no matching option found for at least one value\n        var needReset = el.multiple\n          ? binding.value.some(function (v) { 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 (isIE || 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    process.env.NODE_ENV !== 'production' && warn(\n      \"<select multiple v-model=\\\"\" + (binding.expression) + \"\\\"> \" +\n      \"expects an Array value for its binding, but got \" + (Object.prototype.toString.call(value).slice(8, -1)),\n      vm\n    );\n    return\n  }\n  var selected, option;\n  for (var i = 0, l = el.options.length; i < l; i++) {\n    option = el.options[i];\n    if (isMultiple) {\n      selected = looseIndexOf(value, getValue(option)) > -1;\n      if (option.selected !== selected) {\n        option.selected = selected;\n      }\n    } else {\n      if (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) { return !looseEqual(o, value); })\n}\n\nfunction getValue (option) {\n  return '_value' in option\n    ? option._value\n    : 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\n/*  */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n    ? locateNode(vnode.componentInstance._vnode)\n    : vnode\n}\n\nvar show = {\n  bind: function bind (el, ref, vnode) {\n    var value = ref.value;\n\n    vnode = locateNode(vnode);\n    var transition$$1 = vnode.data && vnode.data.transition;\n    var originalDisplay = el.__vOriginalDisplay =\n      el.style.display === 'none' ? '' : el.style.display;\n    if (value && transition$$1) {\n      vnode.data.show = true;\n      enter(vnode, function () {\n        el.style.display = originalDisplay;\n      });\n    } else {\n      el.style.display = value ? originalDisplay : 'none';\n    }\n  },\n\n  update: function update (el, ref, vnode) {\n    var value = ref.value;\n    var oldValue = ref.oldValue;\n\n    /* istanbul ignore if */\n    if (!value === !oldValue) { return }\n    vnode = locateNode(vnode);\n    var transition$$1 = vnode.data && vnode.data.transition;\n    if (transition$$1) {\n      vnode.data.show = true;\n      if (value) {\n        enter(vnode, function () {\n          el.style.display = el.__vOriginalDisplay;\n        });\n      } else {\n        leave(vnode, function () {\n          el.style.display = 'none';\n        });\n      }\n    } else {\n      el.style.display = value ? el.__vOriginalDisplay : 'none';\n    }\n  },\n\n  unbind: function unbind (\n    el,\n    binding,\n    vnode,\n    oldVnode,\n    isDestroy\n  ) {\n    if (!isDestroy) {\n      el.style.display = el.__vOriginalDisplay;\n    }\n  }\n};\n\nvar platformDirectives = {\n  model: directive,\n  show: show\n};\n\n/*  */\n\nvar 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\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\nfunction getRealChild (vnode) {\n  var compOptions = vnode && vnode.componentOptions;\n  if (compOptions && compOptions.Ctor.options.abstract) {\n    return getRealChild(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$1 in listeners) {\n    data[camelize(key$1)] = listeners[key$1];\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\nvar isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };\n\nvar isVShowDirective = function (d) { return d.name === 'show'; };\n\nvar Transition = {\n  name: 'transition',\n  props: transitionProps,\n  abstract: true,\n\n  render: function render (h) {\n    var this$1 = 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(isNotTextNode);\n    /* istanbul ignore if */\n    if (!children.length) {\n      return\n    }\n\n    // warn multiple elements\n    if (process.env.NODE_ENV !== 'production' && children.length > 1) {\n      warn(\n        '<transition> can only be used on a single element. Use ' +\n        '<transition-group> for lists.',\n        this.$parent\n      );\n    }\n\n    var mode = this.mode;\n\n    // warn invalid mode\n    if (process.env.NODE_ENV !== 'production' &&\n      mode && mode !== 'in-out' && mode !== 'out-in'\n    ) {\n      warn(\n        'invalid <transition> mode: ' + mode,\n        this.$parent\n      );\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\n      ? child.isComment\n        ? id + 'comment'\n        : id + child.tag\n      : isPrimitive(child.key)\n        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n        : 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(isVShowDirective)) {\n      child.data.show = true;\n    }\n\n    if (\n      oldChild &&\n      oldChild.data &&\n      !isSameChild(child, oldChild) &&\n      !isAsyncPlaceholder(oldChild) &&\n      // #6687 component root is a comment node\n      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)\n    ) {\n      // replace old child transition data with fresh one\n      // important for dynamic transitions!\n      var oldData = oldChild.data.transition = 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        mergeVNodeHook(oldData, 'afterLeave', function () {\n          this$1._leaving = false;\n          this$1.$forceUpdate();\n        });\n        return placeholder(h, rawChild)\n      } else if (mode === 'in-out') {\n        if (isAsyncPlaceholder(child)) {\n          return oldRawChild\n        }\n        var delayedLeave;\n        var performLeave = function () { delayedLeave(); };\n        mergeVNodeHook(data, 'afterEnter', performLeave);\n        mergeVNodeHook(data, 'enterCancelled', performLeave);\n        mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });\n      }\n    }\n\n    return rawChild\n  }\n};\n\n/*  */\n\nvar props = extend({\n  tag: String,\n  moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n  props: props,\n\n  beforeMount: function beforeMount () {\n    var this$1 = this;\n\n    var update = this._update;\n    this._update = function (vnode, hydrating) {\n      var restoreActiveInstance = setActiveInstance(this$1);\n      // force removing pass\n      this$1.__patch__(\n        this$1._vnode,\n        this$1.kept,\n        false, // hydrating\n        true // removeOnly (!important, avoids unnecessary moves)\n      );\n      this$1._vnode = this$1.kept;\n      restoreActiveInstance();\n      update.call(this$1, vnode, hydrating);\n    };\n  },\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 = 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\n          ;(c.data || (c.data = {})).transition = transitionData;\n        } else if (process.env.NODE_ENV !== 'production') {\n          var opts = c.componentOptions;\n          var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;\n          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$1 = 0; i$1 < prevChildren.length; i$1++) {\n        var c$1 = prevChildren[i$1];\n        c$1.data.transition = transitionData;\n        c$1.data.pos = c$1.elm.getBoundingClientRect();\n        if (map[c$1.key]) {\n          kept.push(c$1);\n        } else {\n          removed.push(c$1);\n        }\n      }\n      this.kept = h(tag, null, kept);\n      this.removed = removed;\n    }\n\n    return h(tag, null, children)\n  },\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        addTransitionClass(el, moveClass);\n        s.transform = s.WebkitTransform = s.transitionDuration = '';\n        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {\n          if (e && e.target !== el) {\n            return\n          }\n          if (!e || /transform$/.test(e.propertyName)) {\n            el.removeEventListener(transitionEndEvent, cb);\n            el._moveCb = null;\n            removeTransitionClass(el, moveClass);\n          }\n        });\n      }\n    });\n  },\n\n  methods: {\n    hasMove: function hasMove (el, moveClass) {\n      /* istanbul ignore if */\n      if (!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) { removeClass(clone, cls); });\n      }\n      addClass(clone, moveClass);\n      clone.style.display = 'none';\n      this.$el.appendChild(clone);\n      var info = getTransitionInfo(clone);\n      this.$el.removeChild(clone);\n      return (this._hasMove = info.hasTransform)\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}\n\nvar platformComponents = {\n  Transition: Transition,\n  TransitionGroup: TransitionGroup\n};\n\n/*  */\n\n// install platform specific utils\nVue.config.mustUseProp = mustUseProp;\nVue.config.isReservedTag = isReservedTag;\nVue.config.isReservedAttr = isReservedAttr;\nVue.config.getTagNamespace = getTagNamespace;\nVue.config.isUnknownElement = isUnknownElement;\n\n// install platform runtime directives & components\nextend(Vue.options.directives, platformDirectives);\nextend(Vue.options.components, platformComponents);\n\n// install platform patch function\nVue.prototype.__patch__ = inBrowser ? patch : noop;\n\n// public mount method\nVue.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && inBrowser ? query(el) : undefined;\n  return mountComponent(this, el, hydrating)\n};\n\n// devtools global hook\n/* istanbul ignore next */\nif (inBrowser) {\n  setTimeout(function () {\n    if (config.devtools) {\n      if (devtools) {\n        devtools.emit('init', Vue);\n      } else if (\n        process.env.NODE_ENV !== 'production' &&\n        process.env.NODE_ENV !== 'test'\n      ) {\n        console[console.info ? 'info' : 'log'](\n          'Download the Vue Devtools extension for a better development experience:\\n' +\n          'https://github.com/vuejs/vue-devtools'\n        );\n      }\n    }\n    if (process.env.NODE_ENV !== 'production' &&\n      process.env.NODE_ENV !== 'test' &&\n      config.productionTip !== false &&\n      typeof console !== 'undefined'\n    ) {\n      console[console.info ? 'info' : 'log'](\n        \"You are running Vue in development mode.\\n\" +\n        \"Make sure to turn on production mode when deploying for production.\\n\" +\n        \"See more tips at https://vuejs.org/guide/deployment.html\"\n      );\n    }\n  }, 0);\n}\n\n/*  */\n\nvar defaultTagRE = /\\{\\{((?:.|\\r?\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = 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\n\n\nfunction parseText (\n  text,\n  delimiters\n) {\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, index, tokenValue;\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 = 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/*  */\n\nfunction transformNode (el, options) {\n  var warn = options.warn || baseWarn;\n  var staticClass = getAndRemoveAttr(el, 'class');\n  if (process.env.NODE_ENV !== 'production' && staticClass) {\n    var res = parseText(staticClass, options.delimiters);\n    if (res) {\n      warn(\n        \"class=\\\"\" + staticClass + \"\\\": \" +\n        'Interpolation inside attributes has been removed. ' +\n        'Use v-bind or the colon shorthand instead. For example, ' +\n        'instead of <div class=\"{{ val }}\">, use <div :class=\"val\">.',\n        el.rawAttrsMap['class']\n      );\n    }\n  }\n  if (staticClass) {\n    el.staticClass = JSON.stringify(staticClass);\n  }\n  var classBinding = 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\nvar klass$1 = {\n  staticKeys: ['staticClass'],\n  transformNode: transformNode,\n  genData: genData\n};\n\n/*  */\n\nfunction transformNode$1 (el, options) {\n  var warn = options.warn || baseWarn;\n  var staticStyle = getAndRemoveAttr(el, 'style');\n  if (staticStyle) {\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production') {\n      var res = parseText(staticStyle, options.delimiters);\n      if (res) {\n        warn(\n          \"style=\\\"\" + staticStyle + \"\\\": \" +\n          'Interpolation inside attributes has been removed. ' +\n          'Use v-bind or the colon shorthand instead. For example, ' +\n          'instead of <div style=\"{{ val }}\">, use <div :style=\"val\">.',\n          el.rawAttrsMap['style']\n        );\n      }\n    }\n    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));\n  }\n\n  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);\n  if (styleBinding) {\n    el.styleBinding = styleBinding;\n  }\n}\n\nfunction genData$1 (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\nvar style$1 = {\n  staticKeys: ['staticStyle'],\n  transformNode: transformNode$1,\n  genData: genData$1\n};\n\n/*  */\n\nvar decoder;\n\nvar he = {\n  decode: function decode (html) {\n    decoder = decoder || document.createElement('div');\n    decoder.innerHTML = html;\n    return decoder.textContent\n  }\n};\n\n/*  */\n\nvar isUnaryTag = makeMap(\n  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +\n  'link,meta,param,source,track,wbr'\n);\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\nvar canBeLeftOpenTag = makeMap(\n  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'\n);\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 = makeMap(\n  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n  'title,tr,track'\n);\n\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n// Regular Expressions for parsing tags and attributes\nvar attribute = /^\\s*([^\\s\"'<>\\/=]+)(?:\\s*(=)\\s*(?:\"([^\"]*)\"+|'([^']*)'+|([^\\s\"'=<>`]+)))?/;\nvar dynamicArgAttribute = /^\\s*((?:v-[\\w-]+:|@|:|#)\\[[^=]+\\][^\\s\"'<>\\/=]*)(?:\\s*(=)\\s*(?:\"([^\"]*)\"+|'([^']*)'+|([^\\s\"'=<>`]+)))?/;\nvar ncname = \"[a-zA-Z_][\\\\-\\\\.0-9_a-zA-Z\" + (unicodeRegExp.source) + \"]*\";\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 passed as HTML comment when inlined in page\nvar comment = /^<!\\--/;\nvar conditionalComment = /^<!\\[/;\n\n// Special Elements (can contain anything)\nvar isPlainTextElement = 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  '&#39;': \"'\"\n};\nvar encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;\nvar encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;\n\n// #5992\nvar isIgnoreNewlineTag = makeMap('pre,textarea', true);\nvar shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\\n'; };\n\nfunction decodeAttr (value, shouldDecodeNewlines) {\n  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;\n  return value.replace(re, function (match) { return decodingMap[match]; })\n}\n\nfunction parseHTML (html, options) {\n  var stack = [];\n  var expectHTML = options.expectHTML;\n  var isUnaryTag$$1 = options.isUnaryTag || no;\n  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;\n  var index = 0;\n  var last, lastTag;\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), index, index + commentEnd + 3);\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(startTagMatch.tagName, html)) {\n            advance(1);\n          }\n          continue\n        }\n      }\n\n      var text = (void 0), rest = (void 0), next = (void 0);\n      if (textEnd >= 0) {\n        rest = html.slice(textEnd);\n        while (\n          !endTag.test(rest) &&\n          !startTagOpen.test(rest) &&\n          !comment.test(rest) &&\n          !conditionalComment.test(rest)\n        ) {\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      }\n\n      if (textEnd < 0) {\n        text = html;\n      }\n\n      if (text) {\n        advance(text.length);\n      }\n\n      if (options.chars && text) {\n        options.chars(text, index - text.length, index);\n      }\n    } else {\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$1 = html.replace(reStackedTag, function (all, text, endTag) {\n        endTagLength = endTag.length;\n        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {\n          text = text\n            .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$1.length;\n      html = rest$1;\n      parseEndTag(stackedTag, index - endTagLength, index);\n    }\n\n    if (html === last) {\n      options.chars && options.chars(html);\n      if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {\n        options.warn((\"Mal-formatted tag at end of template: \\\"\" + html + \"\\\"\"), { start: index + html.length });\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, attr;\n      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {\n        attr.start = index;\n        advance(attr[0].length);\n        attr.end = index;\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' && isNonPhrasingTag(tagName)) {\n        parseEndTag(lastTag);\n      }\n      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {\n        parseEndTag(tagName);\n      }\n    }\n\n    var unary = isUnaryTag$$1(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      var value = args[3] || args[4] || args[5] || '';\n      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'\n        ? options.shouldDecodeNewlinesForHref\n        : options.shouldDecodeNewlines;\n      attrs[i] = {\n        name: args[1],\n        value: decodeAttr(value, shouldDecodeNewlines)\n      };\n      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {\n        attrs[i].start = args.start + args[0].match(/^\\s*/).length;\n        attrs[i].end = args.end;\n      }\n    }\n\n    if (!unary) {\n      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });\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, lowerCasedTagName;\n    if (start == null) { start = index; }\n    if (end == null) { end = index; }\n\n    // Find the closest opened tag of the same type\n    if (tagName) {\n      lowerCasedTagName = tagName.toLowerCase();\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 (process.env.NODE_ENV !== 'production' &&\n          (i > pos || !tagName) &&\n          options.warn\n        ) {\n          options.warn(\n            (\"tag <\" + (stack[i].tag) + \"> has no matching end tag.\"),\n            { start: stack[i].start, end: stack[i].end }\n          );\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/*  */\n\nvar onRE = /^@|^v-on:/;\nvar dirRE = /^v-|^@|^:|^#/;\nvar forAliasRE = /([\\s\\S]*?)\\s+(?:in|of)\\s+([\\s\\S]*)/;\nvar forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/;\nvar stripParensRE = /^\\(|\\)$/g;\nvar dynamicArgRE = /^\\[.*\\]$/;\n\nvar argRE = /:(.*)$/;\nvar bindRE = /^:|^\\.|^v-bind:/;\nvar modifierRE = /\\.[^.\\]]+(?=[^\\]]*$)/g;\n\nvar slotRE = /^v-slot(:|$)|^#/;\n\nvar lineBreakRE = /[\\r\\n]/;\nvar whitespaceRE$1 = /\\s+/g;\n\nvar invalidAttributeRE = /[\\s\"'<>\\/=]/;\n\nvar decodeHTMLCached = cached(he.decode);\n\nvar emptySlotScopeToken = \"_empty_\";\n\n// configurable state\nvar warn$2;\nvar delimiters;\nvar transforms;\nvar preTransforms;\nvar postTransforms;\nvar platformIsPreTag;\nvar platformMustUseProp;\nvar platformGetTagNamespace;\nvar maybeComponent;\n\nfunction createASTElement (\n  tag,\n  attrs,\n  parent\n) {\n  return {\n    type: 1,\n    tag: tag,\n    attrsList: attrs,\n    attrsMap: makeAttrsMap(attrs),\n    rawAttrsMap: {},\n    parent: parent,\n    children: []\n  }\n}\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse (\n  template,\n  options\n) {\n  warn$2 = options.warn || baseWarn;\n\n  platformIsPreTag = options.isPreTag || no;\n  platformMustUseProp = options.mustUseProp || no;\n  platformGetTagNamespace = options.getTagNamespace || no;\n  var isReservedTag = options.isReservedTag || no;\n  maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };\n\n  transforms = pluckModuleFunction(options.modules, 'transformNode');\n  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');\n  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');\n\n  delimiters = options.delimiters;\n\n  var stack = [];\n  var preserveWhitespace = options.preserveWhitespace !== false;\n  var whitespaceOption = options.whitespace;\n  var root;\n  var currentParent;\n  var inVPre = false;\n  var inPre = false;\n  var warned = false;\n\n  function warnOnce (msg, range) {\n    if (!warned) {\n      warned = true;\n      warn$2(msg, range);\n    }\n  }\n\n  function closeElement (element) {\n    trimEndingWhitespace(element);\n    if (!inVPre && !element.processed) {\n      element = processElement(element, options);\n    }\n    // tree management\n    if (!stack.length && element !== root) {\n      // allow root elements with v-if, v-else-if and v-else\n      if (root.if && (element.elseif || element.else)) {\n        if (process.env.NODE_ENV !== 'production') {\n          checkRootConstraints(element);\n        }\n        addIfCondition(root, {\n          exp: element.elseif,\n          block: element\n        });\n      } else if (process.env.NODE_ENV !== 'production') {\n        warnOnce(\n          \"Component template should contain exactly one root element. \" +\n          \"If you are using v-if on multiple elements, \" +\n          \"use v-else-if to chain them instead.\",\n          { start: element.start }\n        );\n      }\n    }\n    if (currentParent && !element.forbidden) {\n      if (element.elseif || element.else) {\n        processIfConditions(element, currentParent);\n      } else {\n        if (element.slotScope) {\n          // scoped slot\n          // keep it in the children list so that v-else(-if) conditions can\n          // find it as the prev node.\n          var name = element.slotTarget || '\"default\"'\n          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;\n        }\n        currentParent.children.push(element);\n        element.parent = currentParent;\n      }\n    }\n\n    // final children cleanup\n    // filter out scoped slots\n    element.children = element.children.filter(function (c) { return !(c).slotScope; });\n    // remove trailing whitespace node again\n    trimEndingWhitespace(element);\n\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  function trimEndingWhitespace (el) {\n    // remove trailing whitespace node\n    if (!inPre) {\n      var lastNode;\n      while (\n        (lastNode = el.children[el.children.length - 1]) &&\n        lastNode.type === 3 &&\n        lastNode.text === ' '\n      ) {\n        el.children.pop();\n      }\n    }\n  }\n\n  function checkRootConstraints (el) {\n    if (el.tag === 'slot' || el.tag === 'template') {\n      warnOnce(\n        \"Cannot use <\" + (el.tag) + \"> as component root element because it may \" +\n        'contain multiple nodes.',\n        { start: el.start }\n      );\n    }\n    if (el.attrsMap.hasOwnProperty('v-for')) {\n      warnOnce(\n        'Cannot use v-for on stateful component root element because ' +\n        'it renders multiple elements.',\n        el.rawAttrsMap['v-for']\n      );\n    }\n  }\n\n  parseHTML(template, {\n    warn: warn$2,\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    outputSourceRange: options.outputSourceRange,\n    start: function start (tag, attrs, unary, start$1, end) {\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 (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 (process.env.NODE_ENV !== 'production') {\n        if (options.outputSourceRange) {\n          element.start = start$1;\n          element.end = end;\n          element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {\n            cumulated[attr.name] = attr;\n            return cumulated\n          }, {});\n        }\n        attrs.forEach(function (attr) {\n          if (invalidAttributeRE.test(attr.name)) {\n            warn$2(\n              \"Invalid dynamic argument expression: attribute names cannot contain \" +\n              \"spaces, quotes, <, >, / or =.\",\n              {\n                start: attr.start + attr.name.indexOf(\"[\"),\n                end: attr.start + attr.name.length\n              }\n            );\n          }\n        });\n      }\n\n      if (isForbiddenTag(element) && !isServerRendering()) {\n        element.forbidden = true;\n        process.env.NODE_ENV !== 'production' && warn$2(\n          'Templates should only be responsible for mapping the state to the ' +\n          'UI. Avoid placing tags with side-effects in your templates, such as ' +\n          \"<\" + tag + \">\" + ', as they will not be parsed.',\n          { start: element.start }\n        );\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      }\n\n      if (!root) {\n        root = element;\n        if (process.env.NODE_ENV !== 'production') {\n          checkRootConstraints(root);\n        }\n      }\n\n      if (!unary) {\n        currentParent = element;\n        stack.push(element);\n      } else {\n        closeElement(element);\n      }\n    },\n\n    end: function end (tag, start, end$1) {\n      var element = stack[stack.length - 1];\n      // pop stack\n      stack.length -= 1;\n      currentParent = stack[stack.length - 1];\n      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {\n        element.end = end$1;\n      }\n      closeElement(element);\n    },\n\n    chars: function chars (text, start, end) {\n      if (!currentParent) {\n        if (process.env.NODE_ENV !== 'production') {\n          if (text === template) {\n            warnOnce(\n              'Component template requires a root element, rather than just text.',\n              { start: start }\n            );\n          } else if ((text = text.trim())) {\n            warnOnce(\n              (\"text \\\"\" + text + \"\\\" outside root element will be ignored.\"),\n              { start: start }\n            );\n          }\n        }\n        return\n      }\n      // IE textarea placeholder bug\n      /* istanbul ignore if */\n      if (isIE &&\n        currentParent.tag === 'textarea' &&\n        currentParent.attrsMap.placeholder === text\n      ) {\n        return\n      }\n      var children = currentParent.children;\n      if (inPre || text.trim()) {\n        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);\n      } else if (!children.length) {\n        // remove the whitespace-only node right after an opening tag\n        text = '';\n      } else if (whitespaceOption) {\n        if (whitespaceOption === 'condense') {\n          // in condense mode, remove the whitespace node if it contains\n          // line break, otherwise condense to a single space\n          text = lineBreakRE.test(text) ? '' : ' ';\n        } else {\n          text = ' ';\n        }\n      } else {\n        text = preserveWhitespace ? ' ' : '';\n      }\n      if (text) {\n        if (!inPre && whitespaceOption === 'condense') {\n          // condense consecutive whitespaces into single space\n          text = text.replace(whitespaceRE$1, ' ');\n        }\n        var res;\n        var child;\n        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {\n          child = {\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          child = {\n            type: 3,\n            text: text\n          };\n        }\n        if (child) {\n          if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {\n            child.start = start;\n            child.end = end;\n          }\n          children.push(child);\n        }\n      }\n    },\n    comment: function comment (text, start, end) {\n      // adding anyting as a sibling to the root node is forbidden\n      // comments should still be allowed, but ignored\n      if (currentParent) {\n        var child = {\n          type: 3,\n          text: text,\n          isComment: true\n        };\n        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {\n          child.start = start;\n          child.end = end;\n        }\n        currentParent.children.push(child);\n      }\n    }\n  });\n  return root\n}\n\nfunction processPre (el) {\n  if (getAndRemoveAttr(el, 'v-pre') != null) {\n    el.pre = true;\n  }\n}\n\nfunction processRawAttrs (el) {\n  var list = el.attrsList;\n  var len = list.length;\n  if (len) {\n    var attrs = el.attrs = new Array(len);\n    for (var i = 0; i < len; i++) {\n      attrs[i] = {\n        name: list[i].name,\n        value: JSON.stringify(list[i].value)\n      };\n      if (list[i].start != null) {\n        attrs[i].start = list[i].start;\n        attrs[i].end = list[i].end;\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 (\n  element,\n  options\n) {\n  processKey(element);\n\n  // determine whether this is a plain element after\n  // removing structural attributes\n  element.plain = (\n    !element.key &&\n    !element.scopedSlots &&\n    !element.attrsList.length\n  );\n\n  processRef(element);\n  processSlotContent(element);\n  processSlotOutlet(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  return element\n}\n\nfunction processKey (el) {\n  var exp = getBindingAttr(el, 'key');\n  if (exp) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (el.tag === 'template') {\n        warn$2(\n          \"<template> cannot be keyed. Place the key on real elements instead.\",\n          getRawBindingAttr(el, 'key')\n        );\n      }\n      if (el.for) {\n        var iterator = el.iterator2 || el.iterator1;\n        var parent = el.parent;\n        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {\n          warn$2(\n            \"Do not use v-for index as key on <transition-group> children, \" +\n            \"this is the same as not using keys.\",\n            getRawBindingAttr(el, 'key'),\n            true /* tip */\n          );\n        }\n      }\n    }\n    el.key = exp;\n  }\n}\n\nfunction processRef (el) {\n  var ref = getBindingAttr(el, 'ref');\n  if (ref) {\n    el.ref = ref;\n    el.refInFor = checkInFor(el);\n  }\n}\n\nfunction processFor (el) {\n  var exp;\n  if ((exp = getAndRemoveAttr(el, 'v-for'))) {\n    var res = parseFor(exp);\n    if (res) {\n      extend(el, res);\n    } else if (process.env.NODE_ENV !== 'production') {\n      warn$2(\n        (\"Invalid v-for expression: \" + exp),\n        el.rawAttrsMap['v-for']\n      );\n    }\n  }\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, '').trim();\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 = 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 (getAndRemoveAttr(el, 'v-else') != null) {\n      el.else = true;\n    }\n    var elseif = 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 (process.env.NODE_ENV !== 'production') {\n    warn$2(\n      \"v-\" + (el.elseif ? ('else-if=\"' + el.elseif + '\"') : 'else') + \" \" +\n      \"used on element <\" + (el.tag) + \"> without corresponding v-if.\",\n      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']\n    );\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 (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {\n        warn$2(\n          \"text \\\"\" + (children[i].text.trim()) + \"\\\" between v-if and v-else(-if) \" +\n          \"will be ignored.\",\n          children[i]\n        );\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$$1 = getAndRemoveAttr(el, 'v-once');\n  if (once$$1 != null) {\n    el.once = true;\n  }\n}\n\n// handle content being passed to a component as slot,\n// e.g. <template slot=\"xxx\">, <div slot-scope=\"xxx\">\nfunction processSlotContent (el) {\n  var slotScope;\n  if (el.tag === 'template') {\n    slotScope = getAndRemoveAttr(el, 'scope');\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && slotScope) {\n      warn$2(\n        \"the \\\"scope\\\" attribute for scoped slots have been deprecated and \" +\n        \"replaced by \\\"slot-scope\\\" since 2.5. The new \\\"slot-scope\\\" attribute \" +\n        \"can also be used on plain elements in addition to <template> to \" +\n        \"denote scoped slots.\",\n        el.rawAttrsMap['scope'],\n        true\n      );\n    }\n    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');\n  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {\n      warn$2(\n        \"Ambiguous combined usage of slot-scope and v-for on <\" + (el.tag) + \"> \" +\n        \"(v-for takes higher priority). Use a wrapper <template> for the \" +\n        \"scoped slot to make it clearer.\",\n        el.rawAttrsMap['slot-scope'],\n        true\n      );\n    }\n    el.slotScope = slotScope;\n  }\n\n  // slot=\"xxx\"\n  var slotTarget = getBindingAttr(el, 'slot');\n  if (slotTarget) {\n    el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);\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      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));\n    }\n  }\n\n  // 2.6 v-slot syntax\n  {\n    if (el.tag === 'template') {\n      // v-slot on <template>\n      var slotBinding = getAndRemoveAttrByRegex(el, slotRE);\n      if (slotBinding) {\n        if (process.env.NODE_ENV !== 'production') {\n          if (el.slotTarget || el.slotScope) {\n            warn$2(\n              \"Unexpected mixed usage of different slot syntaxes.\",\n              el\n            );\n          }\n          if (el.parent && !maybeComponent(el.parent)) {\n            warn$2(\n              \"<template v-slot> can only appear at the root level inside \" +\n              \"the receiving component\",\n              el\n            );\n          }\n        }\n        var ref = getSlotName(slotBinding);\n        var name = ref.name;\n        var dynamic = ref.dynamic;\n        el.slotTarget = name;\n        el.slotTargetDynamic = dynamic;\n        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf\n      }\n    } else {\n      // v-slot on component, denotes default slot\n      var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);\n      if (slotBinding$1) {\n        if (process.env.NODE_ENV !== 'production') {\n          if (!maybeComponent(el)) {\n            warn$2(\n              \"v-slot can only be used on components or <template>.\",\n              slotBinding$1\n            );\n          }\n          if (el.slotScope || el.slotTarget) {\n            warn$2(\n              \"Unexpected mixed usage of different slot syntaxes.\",\n              el\n            );\n          }\n          if (el.scopedSlots) {\n            warn$2(\n              \"To avoid scope ambiguity, the default slot should also use \" +\n              \"<template> syntax when there are other named slots.\",\n              slotBinding$1\n            );\n          }\n        }\n        // add the component's children to its default slot\n        var slots = el.scopedSlots || (el.scopedSlots = {});\n        var ref$1 = getSlotName(slotBinding$1);\n        var name$1 = ref$1.name;\n        var dynamic$1 = ref$1.dynamic;\n        var slotContainer = slots[name$1] = createASTElement('template', [], el);\n        slotContainer.slotTarget = name$1;\n        slotContainer.slotTargetDynamic = dynamic$1;\n        slotContainer.children = el.children.filter(function (c) {\n          if (!c.slotScope) {\n            c.parent = slotContainer;\n            return true\n          }\n        });\n        slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;\n        // remove children as they are returned from scopedSlots now\n        el.children = [];\n        // mark el non-plain so data gets generated\n        el.plain = false;\n      }\n    }\n  }\n}\n\nfunction getSlotName (binding) {\n  var name = binding.name.replace(slotRE, '');\n  if (!name) {\n    if (binding.name[0] !== '#') {\n      name = 'default';\n    } else if (process.env.NODE_ENV !== 'production') {\n      warn$2(\n        \"v-slot shorthand syntax requires a slot name.\",\n        binding\n      );\n    }\n  }\n  return dynamicArgRE.test(name)\n    // dynamic [name]\n    ? { name: name.slice(1, -1), dynamic: true }\n    // static name\n    : { name: (\"\\\"\" + name + \"\\\"\"), dynamic: false }\n}\n\n// handle <slot/> outlets\nfunction processSlotOutlet (el) {\n  if (el.tag === 'slot') {\n    el.slotName = getBindingAttr(el, 'name');\n    if (process.env.NODE_ENV !== 'production' && el.key) {\n      warn$2(\n        \"`key` does not work on <slot> because slots are abstract outlets \" +\n        \"and can possibly expand into multiple elements. \" +\n        \"Use the key on a wrapping element instead.\",\n        getRawBindingAttr(el, 'key')\n      );\n    }\n  }\n}\n\nfunction processComponent (el) {\n  var binding;\n  if ((binding = getBindingAttr(el, 'is'))) {\n    el.component = binding;\n  }\n  if (getAndRemoveAttr(el, 'inline-template') != null) {\n    el.inlineTemplate = true;\n  }\n}\n\nfunction processAttrs (el) {\n  var list = el.attrsList;\n  var i, l, name, rawName, value, modifiers, syncGen, isDynamic;\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.replace(dirRE, ''));\n      // support .foo shorthand syntax for the .prop modifier\n      if (modifiers) {\n        name = name.replace(modifierRE, '');\n      }\n      if (bindRE.test(name)) { // v-bind\n        name = name.replace(bindRE, '');\n        value = parseFilters(value);\n        isDynamic = dynamicArgRE.test(name);\n        if (isDynamic) {\n          name = name.slice(1, -1);\n        }\n        if (\n          process.env.NODE_ENV !== 'production' &&\n          value.trim().length === 0\n        ) {\n          warn$2(\n            (\"The value for a v-bind expression cannot be empty. Found in \\\"v-bind:\" + name + \"\\\"\")\n          );\n        }\n        if (modifiers) {\n          if (modifiers.prop && !isDynamic) {\n            name = camelize(name);\n            if (name === 'innerHtml') { name = 'innerHTML'; }\n          }\n          if (modifiers.camel && !isDynamic) {\n            name = camelize(name);\n          }\n          if (modifiers.sync) {\n            syncGen = genAssignmentCode(value, \"$event\");\n            if (!isDynamic) {\n              addHandler(\n                el,\n                (\"update:\" + (camelize(name))),\n                syncGen,\n                null,\n                false,\n                warn$2,\n                list[i]\n              );\n              if (hyphenate(name) !== camelize(name)) {\n                addHandler(\n                  el,\n                  (\"update:\" + (hyphenate(name))),\n                  syncGen,\n                  null,\n                  false,\n                  warn$2,\n                  list[i]\n                );\n              }\n            } else {\n              // handler w/ dynamic event name\n              addHandler(\n                el,\n                (\"\\\"update:\\\"+(\" + name + \")\"),\n                syncGen,\n                null,\n                false,\n                warn$2,\n                list[i],\n                true // dynamic\n              );\n            }\n          }\n        }\n        if ((modifiers && modifiers.prop) || (\n          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)\n        )) {\n          addProp(el, name, value, list[i], isDynamic);\n        } else {\n          addAttr(el, name, value, list[i], isDynamic);\n        }\n      } else if (onRE.test(name)) { // v-on\n        name = name.replace(onRE, '');\n        isDynamic = dynamicArgRE.test(name);\n        if (isDynamic) {\n          name = name.slice(1, -1);\n        }\n        addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);\n      } else { // normal directives\n        name = name.replace(dirRE, '');\n        // parse arg\n        var argMatch = name.match(argRE);\n        var arg = argMatch && argMatch[1];\n        isDynamic = false;\n        if (arg) {\n          name = name.slice(0, -(arg.length + 1));\n          if (dynamicArgRE.test(arg)) {\n            arg = arg.slice(1, -1);\n            isDynamic = true;\n          }\n        }\n        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);\n        if (process.env.NODE_ENV !== 'production' && name === 'model') {\n          checkForAliasModel(el, value);\n        }\n      }\n    } else {\n      // literal attribute\n      if (process.env.NODE_ENV !== 'production') {\n        var res = parseText(value, delimiters);\n        if (res) {\n          warn$2(\n            name + \"=\\\"\" + value + \"\\\": \" +\n            'Interpolation inside attributes has been removed. ' +\n            'Use v-bind or the colon shorthand instead. For example, ' +\n            'instead of <div id=\"{{ val }}\">, use <div :id=\"val\">.',\n            list[i]\n          );\n        }\n      }\n      addAttr(el, name, JSON.stringify(value), list[i]);\n      // #6887 firefox doesn't update muted state if set via attribute\n      // even immediately after element creation\n      if (!el.component &&\n          name === 'muted' &&\n          platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n        addProp(el, name, 'true', list[i]);\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) { ret[m.slice(1)] = true; });\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 (\n      process.env.NODE_ENV !== 'production' &&\n      map[attrs[i].name] && !isIE && !isEdge\n    ) {\n      warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);\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 (\n    el.tag === 'style' ||\n    (el.tag === 'script' && (\n      !el.attrsMap.type ||\n      el.attrsMap.type === 'text/javascript'\n    ))\n  )\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$2(\n        \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n        \"You are binding v-model directly to a v-for iteration alias. \" +\n        \"This will not be able to modify the v-for source array because \" +\n        \"writing to the alias is like modifying a function local variable. \" +\n        \"Consider using an array of objects and use v-model on an object property instead.\",\n        el.rawAttrsMap['v-model']\n      );\n    }\n    _el = _el.parent;\n  }\n}\n\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;\n    if (map[':type'] || map['v-bind:type']) {\n      typeBinding = 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 = getAndRemoveAttr(el, 'v-if', true);\n      var ifConditionExtra = ifCondition ? (\"&&(\" + ifCondition + \")\") : \"\";\n      var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;\n      var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);\n      // 1. checkbox\n      var branch0 = cloneASTElement(el);\n      // process for on the main node\n      processFor(branch0);\n      addRawAttr(branch0, 'type', 'checkbox');\n      processElement(branch0, options);\n      branch0.processed = true; // prevent it from double-processed\n      branch0.if = \"(\" + typeBinding + \")==='checkbox'\" + ifConditionExtra;\n      addIfCondition(branch0, {\n        exp: branch0.if,\n        block: branch0\n      });\n      // 2. add radio else-if condition\n      var branch1 = cloneASTElement(el);\n      getAndRemoveAttr(branch1, 'v-for', true);\n      addRawAttr(branch1, 'type', 'radio');\n      processElement(branch1, options);\n      addIfCondition(branch0, {\n        exp: \"(\" + typeBinding + \")==='radio'\" + ifConditionExtra,\n        block: branch1\n      });\n      // 3. other\n      var branch2 = cloneASTElement(el);\n      getAndRemoveAttr(branch2, 'v-for', true);\n      addRawAttr(branch2, ':type', typeBinding);\n      processElement(branch2, options);\n      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 createASTElement(el.tag, el.attrsList.slice(), el.parent)\n}\n\nvar model$1 = {\n  preTransformNode: preTransformNode\n};\n\nvar modules$1 = [\n  klass$1,\n  style$1,\n  model$1\n];\n\n/*  */\n\nfunction text (el, dir) {\n  if (dir.value) {\n    addProp(el, 'textContent', (\"_s(\" + (dir.value) + \")\"), dir);\n  }\n}\n\n/*  */\n\nfunction html (el, dir) {\n  if (dir.value) {\n    addProp(el, 'innerHTML', (\"_s(\" + (dir.value) + \")\"), dir);\n  }\n}\n\nvar directives$1 = {\n  model: model,\n  text: text,\n  html: html\n};\n\n/*  */\n\nvar baseOptions = {\n  expectHTML: true,\n  modules: modules$1,\n  directives: directives$1,\n  isPreTag: isPreTag,\n  isUnaryTag: isUnaryTag,\n  mustUseProp: mustUseProp,\n  canBeLeftOpenTag: canBeLeftOpenTag,\n  isReservedTag: isReservedTag,\n  getTagNamespace: getTagNamespace,\n  staticKeys: genStaticKeys(modules$1)\n};\n\n/*  */\n\nvar isStaticKey;\nvar isPlatformReservedTag;\n\nvar genStaticKeysCached = cached(genStaticKeys$1);\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 || no;\n  // first pass: mark all non-static nodes.\n  markStatic$1(root);\n  // second pass: mark static roots.\n  markStaticRoots(root, false);\n}\n\nfunction genStaticKeys$1 (keys) {\n  return makeMap(\n    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +\n    (keys ? ',' + keys : '')\n  )\n}\n\nfunction markStatic$1 (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 (\n      !isPlatformReservedTag(node.tag) &&\n      node.tag !== 'slot' &&\n      node.attrsMap['inline-template'] == null\n    ) {\n      return\n    }\n    for (var i = 0, l = node.children.length; i < l; i++) {\n      var child = node.children[i];\n      markStatic$1(child);\n      if (!child.static) {\n        node.static = false;\n      }\n    }\n    if (node.ifConditions) {\n      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {\n        var block = node.ifConditions[i$1].block;\n        markStatic$1(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 && !(\n      node.children.length === 1 &&\n      node.children[0].type === 3\n    )) {\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 i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {\n        markStaticRoots(node.ifConditions[i$1].block, isInFor);\n      }\n    }\n  }\n}\n\nfunction isStatic (node) {\n  if (node.type === 2) { // expression\n    return false\n  }\n  if (node.type === 3) { // text\n    return true\n  }\n  return !!(node.pre || (\n    !node.hasBindings && // no dynamic bindings\n    !node.if && !node.for && // not v-if or v-for or v-else\n    !isBuiltInTag(node.tag) && // not a built-in\n    isPlatformReservedTag(node.tag) && // not a component\n    !isDirectChildOfTemplateFor(node) &&\n    Object.keys(node).every(isStaticKey)\n  ))\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/*  */\n\nvar fnExpRE = /^([\\w$_]+|\\([^)]*?\\))\\s*=>|^function(?:\\s+[\\w$]+)?\\s*\\(/;\nvar fnInvokeRE = /\\([^)]*?\\);*$/;\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\n// KeyboardEvent.key aliases\nvar keyNames = {\n  // #7880: IE11 and Edge use `Esc` for Escape key name.\n  esc: ['Esc', 'Escape'],\n  tab: 'Tab',\n  enter: 'Enter',\n  // #9112: IE11 uses `Spacebar` for Space key name.\n  space: [' ', 'Spacebar'],\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  // #9112: IE11 uses `Del` for Delete key name.\n  'delete': ['Backspace', 'Delete', 'Del']\n};\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\nvar genGuard = function (condition) { return (\"if(\" + condition + \")return null;\"); };\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 (\n  events,\n  isNative\n) {\n  var prefix = isNative ? 'nativeOn:' : 'on:';\n  var staticHandlers = \"\";\n  var dynamicHandlers = \"\";\n  for (var name in events) {\n    var handlerCode = genHandler(events[name]);\n    if (events[name] && events[name].dynamic) {\n      dynamicHandlers += name + \",\" + handlerCode + \",\";\n    } else {\n      staticHandlers += \"\\\"\" + name + \"\\\":\" + handlerCode + \",\";\n    }\n  }\n  staticHandlers = \"{\" + (staticHandlers.slice(0, -1)) + \"}\";\n  if (dynamicHandlers) {\n    return prefix + \"_d(\" + staticHandlers + \",[\" + (dynamicHandlers.slice(0, -1)) + \"])\"\n  } else {\n    return prefix + staticHandlers\n  }\n}\n\nfunction genHandler (handler) {\n  if (!handler) {\n    return 'function(){}'\n  }\n\n  if (Array.isArray(handler)) {\n    return (\"[\" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + \"]\")\n  }\n\n  var isMethodPath = simplePathRE.test(handler.value);\n  var isFunctionExpression = fnExpRE.test(handler.value);\n  var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));\n\n  if (!handler.modifiers) {\n    if (isMethodPath || isFunctionExpression) {\n      return handler.value\n    }\n    return (\"function($event){\" + (isFunctionInvocation ? (\"return \" + (handler.value)) : 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        var modifiers = (handler.modifiers);\n        genModifierCode += genGuard(\n          ['ctrl', 'shift', 'alt', 'meta']\n            .filter(function (keyModifier) { return !modifiers[keyModifier]; })\n            .map(function (keyModifier) { 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\n      ? (\"return \" + (handler.value) + \"($event)\")\n      : isFunctionExpression\n        ? (\"return (\" + (handler.value) + \")($event)\")\n        : isFunctionInvocation\n          ? (\"return \" + (handler.value))\n          : handler.value;\n    return (\"function($event){\" + code + handlerCode + \"}\")\n  }\n}\n\nfunction genKeyFilter (keys) {\n  return (\n    // make sure the key filters only apply to KeyboardEvents\n    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake\n    // key events that do not have keyCode property...\n    \"if(!$event.type.indexOf('key')&&\" +\n    (keys.map(genFilterCode).join('&&')) + \")return null;\"\n  )\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 (\n    \"_k($event.keyCode,\" +\n    (JSON.stringify(key)) + \",\" +\n    (JSON.stringify(keyCode)) + \",\" +\n    \"$event.key,\" +\n    \"\" + (JSON.stringify(keyName)) +\n    \")\"\n  )\n}\n\n/*  */\n\nfunction on (el, dir) {\n  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {\n    warn(\"v-on without argument does not support modifiers.\");\n  }\n  el.wrapListeners = function (code) { return (\"_g(\" + code + \",\" + (dir.value) + \")\"); };\n}\n\n/*  */\n\nfunction bind$1 (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}\n\n/*  */\n\nvar baseDirectives = {\n  on: on,\n  bind: bind$1,\n  cloak: noop\n};\n\n/*  */\n\n\n\n\n\nvar CodegenState = function CodegenState (options) {\n  this.options = options;\n  this.warn = options.warn || baseWarn;\n  this.transforms = pluckModuleFunction(options.modules, 'transformCode');\n  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');\n  this.directives = extend(extend({}, baseDirectives), options.directives);\n  var isReservedTag = options.isReservedTag || no;\n  this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };\n  this.onceId = 0;\n  this.staticRenderFns = [];\n  this.pre = false;\n};\n\n\n\nfunction generate (\n  ast,\n  options\n) {\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.parent) {\n    el.pre = el.pre || el.parent.pre;\n  }\n\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 && !state.pre) {\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;\n    if (el.component) {\n      code = genComponent(el.component, el, state);\n    } else {\n      var data;\n      if (!el.plain || (el.pre && state.maybeComponent(el))) {\n        data = genData$2(el, state);\n      }\n\n      var children = el.inlineTemplate ? null : genChildren(el, state, true);\n      code = \"_c('\" + (el.tag) + \"'\" + (data ? (\",\" + data) : '') + (children ? (\",\" + children) : '') + \")\";\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  // Some elements (templates) need to behave differently inside of a v-pre\n  // node.  All pre nodes are static roots, so we can use this as a location to\n  // wrap a state change and reset it upon exiting the pre node.\n  var originalPreState = state.pre;\n  if (el.pre) {\n    state.pre = el.pre;\n  }\n  state.staticRenderFns.push((\"with(this){return \" + (genElement(el, state)) + \"}\"));\n  state.pre = originalPreState;\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      process.env.NODE_ENV !== 'production' && state.warn(\n        \"v-once can only be used inside v-for that is keyed. \",\n        el.rawAttrsMap['v-once']\n      );\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 (\n  el,\n  state,\n  altGen,\n  altEmpty\n) {\n  el.ifProcessed = true; // avoid recursion\n  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)\n}\n\nfunction genIfConditions (\n  conditions,\n  state,\n  altGen,\n  altEmpty\n) {\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\n      ? altGen(el, state)\n      : el.once\n        ? genOnce(el, state)\n        : genElement(el, state)\n  }\n}\n\nfunction genFor (\n  el,\n  state,\n  altGen,\n  altHelper\n) {\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 (process.env.NODE_ENV !== 'production' &&\n    state.maybeComponent(el) &&\n    el.tag !== 'slot' &&\n    el.tag !== 'template' &&\n    !el.key\n  ) {\n    state.warn(\n      \"<\" + (el.tag) + \" v-for=\\\"\" + alias + \" in \" + exp + \"\\\">: component lists rendered with \" +\n      \"v-for should have explicit keys. \" +\n      \"See https://vuejs.org/guide/list.html#key for more info.\",\n      el.rawAttrsMap['v-for'],\n      true /* tip */\n    );\n  }\n\n  el.forProcessed = true; // avoid recursion\n  return (altHelper || '_l') + \"((\" + exp + \"),\" +\n    \"function(\" + alias + iterator1 + iterator2 + \"){\" +\n      \"return \" + ((altGen || genElement)(el, state)) +\n    '})'\n}\n\nfunction genData$2 (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 += (genHandlers(el.events, false)) + \",\";\n  }\n  if (el.nativeEvents) {\n    data += (genHandlers(el.nativeEvents, true)) + \",\";\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, 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 dynamic argument wrap\n  // v-bind with dynamic arguments must be applied using the same v-bind object\n  // merge helper so that class/style/mustUseProp attrs are handled correctly.\n  if (el.dynamicAttrs) {\n    data = \"_b(\" + data + \",\\\"\" + (el.tag) + \"\\\",\" + (genProps(el.dynamicAttrs)) + \")\";\n  }\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, l, dir, needRuntime;\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.isDynamicArg ? dir.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 (process.env.NODE_ENV !== 'production' && (\n    el.children.length !== 1 || ast.type !== 1\n  )) {\n    state.warn(\n      'Inline-template components must have exactly one child element.',\n      { start: el.start }\n    );\n  }\n  if (ast && ast.type === 1) {\n    var inlineRenderFns = generate(ast, state.options);\n    return (\"inlineTemplate:{render:function(){\" + (inlineRenderFns.render) + \"},staticRenderFns:[\" + (inlineRenderFns.staticRenderFns.map(function (code) { return (\"function(){\" + code + \"}\"); }).join(',')) + \"]}\")\n  }\n}\n\nfunction genScopedSlots (\n  el,\n  slots,\n  state\n) {\n  // by default scoped slots are considered \"stable\", this allows child\n  // components with only scoped slots to skip forced updates from parent.\n  // but in some cases we have to bail-out of this optimization\n  // for example if the slot contains dynamic names, has v-if or v-for on them...\n  var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {\n    var slot = slots[key];\n    return (\n      slot.slotTargetDynamic ||\n      slot.if ||\n      slot.for ||\n      containsSlotChild(slot) // is passing down slot from parent which may be dynamic\n    )\n  });\n\n  // #9534: if a component with scoped slots is inside a conditional branch,\n  // it's possible for the same component to be reused but with different\n  // compiled slot content. To avoid that, we generate a unique key based on\n  // the generated code of all the slot contents.\n  var needsKey = !!el.if;\n\n  // OR when it is inside another scoped slot or v-for (the reactivity may be\n  // disconnected due to the intermediate scope variable)\n  // #9438, #9506\n  // TODO: this can be further optimized by properly analyzing in-scope bindings\n  // and skip force updating ones that do not actually use scope variables.\n  if (!needsForceUpdate) {\n    var parent = el.parent;\n    while (parent) {\n      if (\n        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||\n        parent.for\n      ) {\n        needsForceUpdate = true;\n        break\n      }\n      if (parent.if) {\n        needsKey = true;\n      }\n      parent = parent.parent;\n    }\n  }\n\n  var generatedSlots = Object.keys(slots)\n    .map(function (key) { return genScopedSlot(slots[key], state); })\n    .join(',');\n\n  return (\"scopedSlots:_u([\" + generatedSlots + \"]\" + (needsForceUpdate ? \",null,true\" : \"\") + (!needsForceUpdate && needsKey ? (\",null,false,\" + (hash(generatedSlots))) : \"\") + \")\")\n}\n\nfunction hash(str) {\n  var hash = 5381;\n  var i = str.length;\n  while(i) {\n    hash = (hash * 33) ^ str.charCodeAt(--i);\n  }\n  return hash >>> 0\n}\n\nfunction containsSlotChild (el) {\n  if (el.type === 1) {\n    if (el.tag === 'slot') {\n      return true\n    }\n    return el.children.some(containsSlotChild)\n  }\n  return false\n}\n\nfunction genScopedSlot (\n  el,\n  state\n) {\n  var isLegacySyntax = el.attrsMap['slot-scope'];\n  if (el.if && !el.ifProcessed && !isLegacySyntax) {\n    return genIf(el, state, genScopedSlot, \"null\")\n  }\n  if (el.for && !el.forProcessed) {\n    return genFor(el, state, genScopedSlot)\n  }\n  var slotScope = el.slotScope === emptySlotScopeToken\n    ? \"\"\n    : String(el.slotScope);\n  var fn = \"function(\" + slotScope + \"){\" +\n    \"return \" + (el.tag === 'template'\n      ? el.if && isLegacySyntax\n        ? (\"(\" + (el.if) + \")?\" + (genChildren(el, state) || 'undefined') + \":undefined\")\n        : genChildren(el, state) || 'undefined'\n      : genElement(el, state)) + \"}\";\n  // reverse proxy v-slot without scope on this.$slots\n  var reverseProxy = slotScope ? \"\" : \",proxy:true\";\n  return (\"{key:\" + (el.slotTarget || \"\\\"default\\\"\") + \",fn:\" + fn + reverseProxy + \"}\")\n}\n\nfunction genChildren (\n  el,\n  state,\n  checkSkip,\n  altGenElement,\n  altGenNode\n) {\n  var children = el.children;\n  if (children.length) {\n    var el$1 = children[0];\n    // optimize single v-for\n    if (children.length === 1 &&\n      el$1.for &&\n      el$1.tag !== 'template' &&\n      el$1.tag !== 'slot'\n    ) {\n      var normalizationType = checkSkip\n        ? state.maybeComponent(el$1) ? \",1\" : \",0\"\n        : \"\";\n      return (\"\" + ((altGenElement || genElement)(el$1, state)) + normalizationType)\n    }\n    var normalizationType$1 = checkSkip\n      ? getNormalizationType(children, state.maybeComponent)\n      : 0;\n    var gen = altGenNode || genNode;\n    return (\"[\" + (children.map(function (c) { return gen(c, state); }).join(',')) + \"]\" + (normalizationType$1 ? (\",\" + normalizationType$1) : ''))\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 (\n  children,\n  maybeComponent\n) {\n  var res = 0;\n  for (var i = 0; i < children.length; i++) {\n    var el = children[i];\n    if (el.type !== 1) {\n      continue\n    }\n    if (needsNormalization(el) ||\n        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {\n      res = 2;\n      break\n    }\n    if (maybeComponent(el) ||\n        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {\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  } else 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\n    ? 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.dynamicAttrs\n    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({\n        // slot props are camelized\n        name: camelize(attr.name),\n        value: attr.value,\n        dynamic: attr.dynamic\n      }); }))\n    : null;\n  var bind$$1 = el.attrsMap['v-bind'];\n  if ((attrs || bind$$1) && !children) {\n    res += \",null\";\n  }\n  if (attrs) {\n    res += \",\" + attrs;\n  }\n  if (bind$$1) {\n    res += (attrs ? '' : ',null') + \",\" + bind$$1;\n  }\n  return res + ')'\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent (\n  componentName,\n  el,\n  state\n) {\n  var children = el.inlineTemplate ? null : genChildren(el, state, true);\n  return (\"_c(\" + componentName + \",\" + (genData$2(el, state)) + (children ? (\",\" + children) : '') + \")\")\n}\n\nfunction genProps (props) {\n  var staticProps = \"\";\n  var dynamicProps = \"\";\n  for (var i = 0; i < props.length; i++) {\n    var prop = props[i];\n    var value = transformSpecialNewlines(prop.value);\n    if (prop.dynamic) {\n      dynamicProps += (prop.name) + \",\" + value + \",\";\n    } else {\n      staticProps += \"\\\"\" + (prop.name) + \"\\\":\" + value + \",\";\n    }\n  }\n  staticProps = \"{\" + (staticProps.slice(0, -1)) + \"}\";\n  if (dynamicProps) {\n    return (\"_d(\" + staticProps + \",[\" + (dynamicProps.slice(0, -1)) + \"])\")\n  } else {\n    return staticProps\n  }\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines (text) {\n  return text\n    .replace(/\\u2028/g, '\\\\u2028')\n    .replace(/\\u2029/g, '\\\\u2029')\n}\n\n/*  */\n\n\n\n// these keywords should not appear inside expressions, but operators like\n// typeof, instanceof and in are allowed\nvar prohibitedKeywordRE = new RegExp('\\\\b' + (\n  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +\n  'super,throw,while,yield,delete,export,import,return,switch,default,' +\n  'extends,finally,continue,debugger,function,arguments'\n).split(',').join('\\\\b|\\\\b') + '\\\\b');\n\n// these unary operators should not be used as property/method names\nvar unaryOperatorsRE = new RegExp('\\\\b' + (\n  'delete,typeof,void'\n).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, warn) {\n  if (ast) {\n    checkNode(ast, warn);\n  }\n}\n\nfunction checkNode (node, warn) {\n  if (node.type === 1) {\n    for (var name in node.attrsMap) {\n      if (dirRE.test(name)) {\n        var value = node.attrsMap[name];\n        if (value) {\n          var range = node.rawAttrsMap[name];\n          if (name === 'v-for') {\n            checkFor(node, (\"v-for=\\\"\" + value + \"\\\"\"), warn, range);\n          } else if (name === 'v-slot' || name[0] === '#') {\n            checkFunctionParameterExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), warn, range);\n          } else if (onRE.test(name)) {\n            checkEvent(value, (name + \"=\\\"\" + value + \"\\\"\"), warn, range);\n          } else {\n            checkExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), warn, range);\n          }\n        }\n      }\n    }\n    if (node.children) {\n      for (var i = 0; i < node.children.length; i++) {\n        checkNode(node.children[i], warn);\n      }\n    }\n  } else if (node.type === 2) {\n    checkExpression(node.expression, node.text, warn, node);\n  }\n}\n\nfunction checkEvent (exp, text, warn, range) {\n  var stripped = exp.replace(stripStringRE, '');\n  var keywordMatch = stripped.match(unaryOperatorsRE);\n  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {\n    warn(\n      \"avoid using JavaScript unary operator as property name: \" +\n      \"\\\"\" + (keywordMatch[0]) + \"\\\" in expression \" + (text.trim()),\n      range\n    );\n  }\n  checkExpression(exp, text, warn, range);\n}\n\nfunction checkFor (node, text, warn, range) {\n  checkExpression(node.for || '', text, warn, range);\n  checkIdentifier(node.alias, 'v-for alias', text, warn, range);\n  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);\n  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);\n}\n\nfunction checkIdentifier (\n  ident,\n  type,\n  text,\n  warn,\n  range\n) {\n  if (typeof ident === 'string') {\n    try {\n      new Function((\"var \" + ident + \"=_\"));\n    } catch (e) {\n      warn((\"invalid \" + type + \" \\\"\" + ident + \"\\\" in expression: \" + (text.trim())), range);\n    }\n  }\n}\n\nfunction checkExpression (exp, text, warn, range) {\n  try {\n    new Function((\"return \" + exp));\n  } catch (e) {\n    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n    if (keywordMatch) {\n      warn(\n        \"avoid using JavaScript keyword as property name: \" +\n        \"\\\"\" + (keywordMatch[0]) + \"\\\"\\n  Raw expression: \" + (text.trim()),\n        range\n      );\n    } else {\n      warn(\n        \"invalid expression: \" + (e.message) + \" in\\n\\n\" +\n        \"    \" + exp + \"\\n\\n\" +\n        \"  Raw expression: \" + (text.trim()) + \"\\n\",\n        range\n      );\n    }\n  }\n}\n\nfunction checkFunctionParameterExpression (exp, text, warn, range) {\n  try {\n    new Function(exp, '');\n  } catch (e) {\n    warn(\n      \"invalid function parameter expression: \" + (e.message) + \" in\\n\\n\" +\n      \"    \" + exp + \"\\n\\n\" +\n      \"  Raw expression: \" + (text.trim()) + \"\\n\",\n      range\n    );\n  }\n}\n\n/*  */\n\nvar range = 2;\n\nfunction generateCodeFrame (\n  source,\n  start,\n  end\n) {\n  if ( start === void 0 ) start = 0;\n  if ( end === void 0 ) end = source.length;\n\n  var lines = source.split(/\\r?\\n/);\n  var count = 0;\n  var res = [];\n  for (var i = 0; i < lines.length; i++) {\n    count += lines[i].length + 1;\n    if (count >= start) {\n      for (var j = i - range; j <= i + range || end > count; j++) {\n        if (j < 0 || j >= lines.length) { continue }\n        res.push((\"\" + (j + 1) + (repeat$1(\" \", 3 - String(j + 1).length)) + \"|  \" + (lines[j])));\n        var lineLength = lines[j].length;\n        if (j === i) {\n          // push underline\n          var pad = start - (count - lineLength) + 1;\n          var length = end > count ? lineLength - pad : end - start;\n          res.push(\"   |  \" + repeat$1(\" \", pad) + repeat$1(\"^\", length));\n        } else if (j > i) {\n          if (end > count) {\n            var length$1 = Math.min(end - count, lineLength);\n            res.push(\"   |  \" + repeat$1(\"^\", length$1));\n          }\n          count += lineLength + 1;\n        }\n      }\n      break\n    }\n  }\n  return res.join('\\n')\n}\n\nfunction repeat$1 (str, n) {\n  var result = '';\n  if (n > 0) {\n    while (true) { // eslint-disable-line\n      if (n & 1) { result += str; }\n      n >>>= 1;\n      if (n <= 0) { break }\n      str += str;\n    }\n  }\n  return result\n}\n\n/*  */\n\n\n\nfunction createFunction (code, errors) {\n  try {\n    return new Function(code)\n  } catch (err) {\n    errors.push({ err: err, code: code });\n    return noop\n  }\n}\n\nfunction createCompileToFunctionFn (compile) {\n  var cache = Object.create(null);\n\n  return function compileToFunctions (\n    template,\n    options,\n    vm\n  ) {\n    options = extend({}, options);\n    var warn$$1 = options.warn || warn;\n    delete options.warn;\n\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production') {\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$$1(\n            'It seems you are using the standalone build of Vue.js in an ' +\n            'environment with Content Security Policy that prohibits unsafe-eval. ' +\n            'The template compiler cannot work in this environment. Consider ' +\n            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +\n            'templates into render functions.'\n          );\n        }\n      }\n    }\n\n    // check cache\n    var key = options.delimiters\n      ? String(options.delimiters) + template\n      : 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 (process.env.NODE_ENV !== 'production') {\n      if (compiled.errors && compiled.errors.length) {\n        if (options.outputSourceRange) {\n          compiled.errors.forEach(function (e) {\n            warn$$1(\n              \"Error compiling template:\\n\\n\" + (e.msg) + \"\\n\\n\" +\n              generateCodeFrame(template, e.start, e.end),\n              vm\n            );\n          });\n        } else {\n          warn$$1(\n            \"Error compiling template:\\n\\n\" + template + \"\\n\\n\" +\n            compiled.errors.map(function (e) { return (\"- \" + e); }).join('\\n') + '\\n',\n            vm\n          );\n        }\n      }\n      if (compiled.tips && compiled.tips.length) {\n        if (options.outputSourceRange) {\n          compiled.tips.forEach(function (e) { return tip(e.msg, vm); });\n        } else {\n          compiled.tips.forEach(function (msg) { return 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 (process.env.NODE_ENV !== 'production') {\n      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {\n        warn$$1(\n          \"Failed to generate render function:\\n\\n\" +\n          fnGenErrors.map(function (ref) {\n            var err = ref.err;\n            var code = ref.code;\n\n            return ((err.toString()) + \" in\\n\\n\" + code + \"\\n\");\n        }).join('\\n'),\n          vm\n        );\n      }\n    }\n\n    return (cache[key] = res)\n  }\n}\n\n/*  */\n\nfunction createCompilerCreator (baseCompile) {\n  return function createCompiler (baseOptions) {\n    function compile (\n      template,\n      options\n    ) {\n      var finalOptions = Object.create(baseOptions);\n      var errors = [];\n      var tips = [];\n\n      var warn = function (msg, range, tip) {\n        (tip ? tips : errors).push(msg);\n      };\n\n      if (options) {\n        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {\n          // $flow-disable-line\n          var leadingSpaceLength = template.match(/^\\s*/)[0].length;\n\n          warn = function (msg, range, tip) {\n            var data = { msg: msg };\n            if (range) {\n              if (range.start != null) {\n                data.start = range.start + leadingSpaceLength;\n              }\n              if (range.end != null) {\n                data.end = range.end + leadingSpaceLength;\n              }\n            }\n            (tip ? tips : errors).push(data);\n          };\n        }\n        // merge custom modules\n        if (options.modules) {\n          finalOptions.modules =\n            (baseOptions.modules || []).concat(options.modules);\n        }\n        // merge custom directives\n        if (options.directives) {\n          finalOptions.directives = extend(\n            Object.create(baseOptions.directives || null),\n            options.directives\n          );\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      finalOptions.warn = warn;\n\n      var compiled = baseCompile(template.trim(), finalOptions);\n      if (process.env.NODE_ENV !== 'production') {\n        detectErrors(compiled.ast, warn);\n      }\n      compiled.errors = errors;\n      compiled.tips = tips;\n      return compiled\n    }\n\n    return {\n      compile: compile,\n      compileToFunctions: createCompileToFunctionFn(compile)\n    }\n  }\n}\n\n/*  */\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 = createCompilerCreator(function baseCompile (\n  template,\n  options\n) {\n  var ast = parse(template.trim(), options);\n  if (options.optimize !== false) {\n    optimize(ast, options);\n  }\n  var code = generate(ast, options);\n  return {\n    ast: ast,\n    render: code.render,\n    staticRenderFns: code.staticRenderFns\n  }\n});\n\n/*  */\n\nvar ref$1 = createCompiler(baseOptions);\nvar compile = ref$1.compile;\nvar compileToFunctions = ref$1.compileToFunctions;\n\n/*  */\n\n// check whether current browser encodes a char inside attribute values\nvar div;\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 = inBrowser ? getShouldDecode(false) : false;\n// #6828: chrome encodes content in a[href]\nvar shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false;\n\n/*  */\n\nvar idToTemplate = cached(function (id) {\n  var el = query(id);\n  return el && el.innerHTML\n});\n\nvar mount = Vue.prototype.$mount;\nVue.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && query(el);\n\n  /* istanbul ignore if */\n  if (el === document.body || el === document.documentElement) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"Do not mount Vue to <html> or <body> - mount to normal elements instead.\"\n    );\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 (process.env.NODE_ENV !== 'production' && !template) {\n            warn(\n              (\"Template element not found or is empty: \" + (options.template)),\n              this\n            );\n          }\n        }\n      } else if (template.nodeType) {\n        template = template.innerHTML;\n      } else {\n        if (process.env.NODE_ENV !== 'production') {\n          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 (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n        mark('compile');\n      }\n\n      var ref = compileToFunctions(template, {\n        outputSourceRange: process.env.NODE_ENV !== 'production',\n        shouldDecodeNewlines: shouldDecodeNewlines,\n        shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,\n        delimiters: options.delimiters,\n        comments: options.comments\n      }, this);\n      var render = ref.render;\n      var staticRenderFns = ref.staticRenderFns;\n      options.render = render;\n      options.staticRenderFns = staticRenderFns;\n\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n        mark('compile end');\n        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\nVue.compile = compileToFunctions;\n\nexport default Vue;\n"],"names":["normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","options","_compiled","functional","_scopeId","context","this","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","call","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","concat","exports","extend","a","b","key","encodeReserveRE","encodeReserveReplacer","c","charCodeAt","toString","commaRE","encode","str","encodeURIComponent","replace","decode","decodeURIComponent","err","castQueryParamValue","value","String","parseQuery","query","res","trim","split","forEach","param","parts","shift","val","length","join","undefined","Array","isArray","push","stringifyQuery","obj","Object","keys","map","result","val2","filter","x","trailingSlashRE","createRoute","record","location","redirectedFrom","router","clone","e","route","name","meta","path","hash","params","fullPath","getFullPath","matched","formatMatch","freeze","START","unshift","ref","_stringifyQuery","isSameRoute","onlyPath","isObjectEqual","aKeys","sort","bKeys","every","i","aVal","bVal","handleRouteEntered","instances","instance","cbs","enteredCbs","i$1","_isBeingDestroyed","View","props","type","default","_","children","data","routerView","$createElement","$route","cache","_routerViewCache","depth","inactive","_routerRoot","vnodeData","keepAlive","_directInactive","_inactive","$parent","routerViewDepth","cachedData","cachedComponent","component","configProps","fillPropsinData","components","registerRouteInstance","vm","current","prepatch","vnode","componentInstance","init","propsToPass","config","resolveProps","attrs","resolvePath","relative","base","append","firstChar","charAt","stack","pop","segments","segment","cleanPath","isarray","arr","prototype","pathToRegexp_1","pathToRegexp","parse_1","parse","compile_1","tokensToFunction","tokensToFunction_1","tokensToRegExp_1","tokensToRegExp","PATH_REGEXP","RegExp","tokens","index","defaultDelimiter","delimiter","exec","m","escaped","offset","slice","next","prefix","capture","group","modifier","asterisk","partial","repeat","optional","pattern","escapeGroup","escapeString","substr","encodeURIComponentPretty","encodeURI","toUpperCase","matches","flags","opts","pretty","token","TypeError","JSON","stringify","j","test","attachKeys","re","sensitive","strict","end","endsWithDelimiter","groups","source","match","regexpToRegexp","arrayToRegexp","stringToRegexp","compile","regexpCompileCache","create","fillParams","routeMsg","filler","pathMatch","normalizeLocation","raw","_normalized","params$1","rawPath","parsedPath","hashIndex","indexOf","queryIndex","parsePath","basePath","extraQuery","_parseQuery","parsedQuery","resolveQuery","_Vue","noop","Link","to","required","tag","custom","Boolean","exact","exactPath","activeClass","exactActiveClass","ariaCurrentValue","event","this$1$1","$router","resolve","href","classes","globalActiveClass","linkActiveClass","globalExactActiveClass","linkExactActiveClass","activeClassFallback","exactActiveClassFallback","compareTarget","target","queryIncludes","isIncludedRoute","handler","guardEvent","on","click","class","scopedSlot","$scopedSlots","$hasNormal","navigate","isActive","isExactActive","findAnchor","$slots","isStatic","aData","handler$1","event$1","aAttrs","metaKey","altKey","ctrlKey","shiftKey","defaultPrevented","button","currentTarget","getAttribute","preventDefault","child","inBrowser","window","createRouteMap","routes","oldPathList","oldPathMap","oldNameMap","parentRoute","pathList","pathMap","nameMap","addRouteRecord","l","splice","matchAs","pathToRegexpOptions","normalizedPath","normalizePath","caseSensitive","regex","compileRouteRegex","alias","redirect","beforeEnter","childMatchAs","aliases","aliasRoute","createMatcher","currentRoute","_createRoute","paramNames","record$1","matchRoute","originalRedirect","hasOwnProperty","resolveRecordPath","aliasedMatch","aliasedRecord","addRoute","parentOrRoute","getRoutes","addRoutes","len","Time","performance","now","Date","genStateKey","toFixed","_key","getStateKey","setStateKey","positionStore","setupScroll","history","scrollRestoration","protocolAndPath","protocol","host","absolutePath","stateCopy","state","replaceState","addEventListener","handlePopState","removeEventListener","handleScroll","from","isPop","app","behavior","scrollBehavior","$nextTick","position","getScrollPosition","shouldScroll","then","scrollToPosition","catch","saveScrollPosition","pageXOffset","y","pageYOffset","isValidPosition","isNumber","normalizePosition","v","hashStartsWithNumberRE","isObject","selector","el","document","getElementById","querySelector","docRect","documentElement","getBoundingClientRect","elRect","left","top","getElementPosition","style","scrollTo","ua","supportsPushState","navigator","userAgent","pushState","url","NavigationFailureType","redirected","aborted","cancelled","duplicated","createNavigationRedirectedError","createRouterError","propertiesToLog","createNavigationCancelledError","message","error","Error","_isRouter","isError","isNavigationFailure","errorType","runQueue","queue","fn","cb","step","resolveAsyncComponents","hasAsync","pending","flatMapComponents","def","cid","once","resolvedDef","__esModule","hasSymbol","Symbol","toStringTag","resolved","reject","reason","msg","comp","flatten","apply","called","args","arguments","History","baseEl","normalizeBase","ready","readyCbs","readyErrorCbs","errorCbs","listeners","extractGuards","records","bind","reverse","guards","guard","extractGuard","bindGuard","listen","onReady","errorCb","onError","transitionTo","onComplete","onAbort","prev","confirmTransition","updateRoute","ensureURL","afterHooks","abort","console","lastRouteIndex","lastCurrentIndex","max","Math","updated","activated","deactivated","resolveQueue","extractLeaveGuards","beforeHooks","extractUpdateHooks","iterator","createNavigationAbortedError","enterGuards","bindEnterGuard","extractEnterGuards","resolveHooks","setupListeners","teardown","cleanupListener","HTML5History","_startLocation","getLocation","__proto__","constructor","expectScroll","supportsScroll","handleRoutingEvent","go","n","fromRoute","getCurrentLocation","pathname","pathLowerCase","toLowerCase","baseLowerCase","search","HashHistory","fallback","checkFallback","ensureSlash","getHash","replaceHash","eventType","pushHash","getUrl","AbstractHistory","targetIndex","VueRouter","apps","matcher","mode","prototypeAccessors","configurable","get","$once","routeOrError","handleInitialScroll","_route","beforeEach","registerHook","beforeResolve","afterEach","Promise","back","forward","getMatchedComponents","createHref","normalizedTo","defineProperties","VueRouter$1","list","install","Vue","installed","isDef","registerInstance","callVal","_parentVnode","mixin","_router","util","defineReactive","destroyed","defineProperty","strats","optionMergeStrategies","beforeRouteEnter","beforeRouteLeave","beforeRouteUpdate","created","version","START_LOCATION","use","emptyObject","isUndef","isTrue","isPrimitive","_toString","isPlainObject","isRegExp","isValidArrayIndex","parseFloat","floor","isFinite","isPromise","toNumber","isNaN","makeMap","expectsLowerCase","isBuiltInTag","isReservedAttribute","remove","item","hasOwn","cached","camelizeRE","camelize","capitalize","hyphenateRE","hyphenate","Function","ctx","boundFn","_length","toArray","start","ret","_from","toObject","no","identity","looseEqual","isObjectA","isObjectB","isArrayA","isArrayB","getTime","keysA","keysB","looseIndexOf","SSR_ATTR","ASSET_TYPES","LIFECYCLE_HOOKS","silent","productionTip","devtools","errorHandler","warnHandler","ignoredElements","keyCodes","isReservedTag","isReservedAttr","isUnknownElement","getTagNamespace","parsePlatformTagName","mustUseProp","async","_lifecycleHooks","unicodeRegExp","isReserved","enumerable","writable","bailRE","_isServer","hasProto","inWeex","WXEnvironment","platform","weexPlatform","UA","isIE","isIE9","isEdge","isIOS","isFF","nativeWatch","watch","supportsPassive","isServerRendering","g","env","VUE_ENV","__VUE_DEVTOOLS_GLOBAL_HOOK__","isNative","Ctor","_Set","Reflect","ownKeys","Set","set","has","clear","warn","uid","Dep","id","subs","addSub","sub","removeSub","depend","addDep","notify","update","targetStack","pushTarget","popTarget","VNode","text","elm","componentOptions","asyncFactory","ns","fnContext","fnOptions","fnScopeId","isRootInsert","isComment","isCloned","isOnce","asyncMeta","isAsyncPlaceholder","createEmptyVNode","node","createTextVNode","cloneVNode","cloned","arrayProto","arrayMethods","method","original","inserted","ob","__ob__","observeArray","dep","arrayKeys","getOwnPropertyNames","shouldObserve","toggleObserving","Observer","vmCount","src","protoAugment","copyAugment","walk","observe","asRootData","isExtensible","_isVue","defineReactive$$1","customSetter","shallow","property","getOwnPropertyDescriptor","getter","setter","childOb","dependArray","newVal","del","items","mergeData","toVal","fromVal","mergeDataOrFn","parentVal","childVal","instanceData","defaultData","mergeHook","hooks","dedupeHooks","mergeAssets","key$1","methods","inject","computed","provide","defaultStrat","mergeOptions","normalizeProps","normalized","normalizeInject","dirs","directives","def$$1","normalizeDirectives","_base","extends","mixins","mergeField","strat","resolveAsset","warnMissing","assets","camelizedId","PascalCaseId","validateProp","propOptions","propsData","prop","absent","booleanIndex","getTypeIndex","stringIndex","_props","getType","getPropDefaultValue","prevShouldObserve","isSameType","expectedTypes","handleError","info","cur","errorCaptured","globalHandleError","invokeWithErrorHandling","_handled","logError","timerFunc","isUsingMicroTask","callbacks","flushCallbacks","copies","p","setTimeout","MutationObserver","setImmediate","counter","observer","textNode","createTextNode","characterData","nextTick","_resolve","seenObjects","traverse","_traverse","seen","isA","isFrozen","depId","normalizeEvent","passive","once$$1","createFnInvoker","fns","invoker","arguments$1","updateListeners","oldOn","remove$$1","createOnceHandler","old","mergeVNodeHook","hookKey","oldHook","wrappedHook","merged","checkProp","preserve","normalizeChildren","normalizeArrayChildren","isTextNode","nestedIndex","lastIndex","last","_isVList","resolveInject","provideKey","_provided","provideDefault","resolveSlots","slots","slot","name$1","isWhitespace","normalizeScopedSlots","normalSlots","prevSlots","hasNormalSlots","isStable","$stable","$key","normalizeScopedSlot","key$2","proxyNormalSlot","proxy","renderList","done","renderSlot","bindObject","nodes","scopedSlotFn","resolveFilter","isKeyNotMatch","expect","actual","checkKeyCodes","eventKeyCode","builtInKeyCode","eventKeyName","builtInKeyName","mappedKeyCode","bindObjectProps","asProp","isSync","loop","domProps","camelizedKey","hyphenatedKey","$event","renderStatic","isInFor","_staticTrees","tree","markStatic","_renderProxy","markOnce","markStaticNode","bindObjectListeners","ours","resolveScopedSlots","hasDynamicKeys","contentHashKey","bindDynamicKeys","baseObj","values","prependModifier","symbol","installRenderHelpers","_o","_n","_s","_l","_t","_q","_i","_m","_f","_k","_b","_v","_e","_u","_g","_d","_p","FunctionalRenderContext","contextVm","this$1","_original","isCompiled","needNormalization","injections","scopedSlots","_c","d","createElement","cloneAndMarkFunctionalResult","renderContext","mergeProps","componentVNodeHooks","hydrating","_isDestroyed","mountedNode","_isComponent","inlineTemplate","createComponentInstanceForVnode","activeInstance","$mount","oldVnode","parentVnode","renderChildren","newScopedSlots","oldScopedSlots","hasDynamicScopedSlot","needsForceUpdate","_renderChildren","_vnode","$attrs","$listeners","propKeys","_propKeys","oldListeners","_parentListeners","updateComponentListeners","$forceUpdate","updateChildComponent","insert","_isMounted","callHook","activatedChildren","activateChildComponent","destroy","deactivateChildComponent","$destroy","hooksToMerge","createComponent","baseCtor","factory","errorComp","owner","currentRenderingInstance","owners","loading","loadingComp","sync","timerLoading","timerTimeout","$on","forceRender","renderCompleted","clearTimeout","ensureCtor","delay","timeout","resolveAsyncComponent","createAsyncPlaceholder","resolveConstructorOptions","model","callback","transformModel","extractPropsFromVNodeData","vnodes","createFunctionalComponent","nativeOn","abstract","toMerge","_merged","mergeHook$1","installComponentHooks","f1","f2","normalizationType","alwaysNormalize","is","simpleNormalizeChildren","pre","applyNS","registerDeepBindings","_createElement","force","getFirstComponentChild","remove$1","$off","_target","onceHandler","setActiveInstance","prevActiveInstance","isInInactiveTree","direct","$children","handlers","_hasHookEvent","$emit","waiting","flushing","currentFlushTimestamp","getNow","createEvent","timeStamp","flushSchedulerQueue","watcher","before","run","activatedQueue","updatedQueue","callActivatedHooks","_watcher","callUpdatedHooks","emit","uid$2","Watcher","expOrFn","isRenderWatcher","_watchers","deep","user","lazy","active","dirty","deps","newDeps","depIds","newDepIds","expression","cleanupDeps","tmp","queueWatcher","oldValue","evaluate","sharedPropertyDefinition","sourceKey","initState","propsOptions","isRoot","initProps","initMethods","_data","getData","initData","watchers","_computedWatchers","isSSR","userDef","computedWatcherOptions","defineComputed","initComputed","createWatcher","initWatch","shouldCache","createComputedGetter","createGetterInvoker","$watch","uid$3","super","superOptions","modifiedOptions","modified","latest","sealed","sealedOptions","resolveModifiedOptions","extendOptions","_init","initExtend","Super","SuperId","cachedCtors","_Ctor","Sub","Comp","initProps$1","initComputed$1","getComponentName","pruneCache","keepAliveInstance","cachedNode","pruneCacheEntry","cached$$1","_uid","vnodeComponentOptions","_componentTag","initInternalComponent","_self","$refs","initLifecycle","_events","initEvents","parentData","initRender","initInjections","initProvide","initMixin","dataDef","propsDef","$set","$delete","immediate","stateMixin","hookRE","eventsMixin","_update","prevEl","$el","prevVnode","restoreActiveInstance","__patch__","__vue__","lifecycleMixin","_render","renderMixin","patternTypes","builtInComponents","KeepAlive","include","exclude","Number","mounted","parseInt","configDef","delete","observable","plugin","installedPlugins","_installedPlugins","initUse","initMixin$1","definition","initAssetRegisters","initGlobalAPI","acceptValue","attr","isEnumeratedAttr","isValidContentEditableValue","isBooleanAttr","xlinkNS","isXlink","getXlinkProp","isFalsyAttrValue","genClassForVnode","parentNode","childNode","mergeClassData","staticClass","dynamicClass","stringifyClass","renderClass","stringified","stringifyArray","stringifyObject","namespaceMap","svg","math","isHTMLTag","isSVG","unknownElementCache","isTextInputType","selected","nodeOps","tagName","multiple","setAttribute","createElementNS","namespace","createComment","insertBefore","newNode","referenceNode","removeChild","appendChild","nextSibling","setTextContent","textContent","setStyleScope","registerRef","isRemoval","refs","refInFor","emptyNode","sameVnode","typeA","typeB","sameInputType","createKeyToOldIdx","beginIdx","endIdx","updateDirectives","oldDir","dir","isCreate","isDestroy","oldDirs","normalizeDirectives$1","newDirs","dirsWithInsert","dirsWithPostpatch","oldArg","arg","callHook$1","componentUpdated","callInsert","emptyModifiers","modifiers","getRawDirName","rawName","baseModules","updateAttrs","inheritAttrs","oldAttrs","setAttr","removeAttributeNS","removeAttribute","baseSetAttr","convertEnumeratedValue","setAttributeNS","__ieph","blocker","stopImmediatePropagation","updateClass","oldData","cls","transitionClass","_transitionClasses","_prevClass","chr","index$1","expressionPos","expressionEndPos","klass","validDivisionCharRE","parseFilters","exp","filters","inSingle","inDouble","inTemplateString","inRegex","curly","square","paren","lastFilterIndex","pushFilter","wrapFilter","baseWarn","range","pluckModuleFunction","modules","addProp","dynamic","rangeSetItem","plain","addAttr","dynamicAttrs","addRawAttr","attrsMap","attrsList","addDirective","isDynamicArg","prependModifierMarker","addHandler","important","events","right","middle","native","nativeEvents","newHandler","getBindingAttr","getStatic","dynamicValue","getAndRemoveAttr","staticValue","removeFromMap","getAndRemoveAttrByRegex","genComponentModel","number","baseValueExpression","valueExpression","assignment","genAssignmentCode","lastIndexOf","eof","isStringStart","parseString","parseBracket","parseModel","inBracket","stringQuote","target$1","RANGE_TOKEN","CHECKBOX_RADIO_TOKEN","createOnceHandler$1","remove$2","useMicrotaskFix","add$1","attachedTimestamp","_wrapper","ownerDocument","updateDOMListeners","change","normalizeEvents","svgContainer","updateDOMProps","oldProps","childNodes","_value","strCur","shouldUpdateValue","innerHTML","firstChild","checkVal","composing","notInFocus","activeElement","isNotInFocusAndDirty","_vModifiers","isDirtyWithModifiers","parseStyleText","cssText","propertyDelimiter","normalizeStyleData","normalizeStyleBinding","staticStyle","bindingStyle","emptyStyle","cssVarRE","importantRE","setProp","setProperty","normalizedName","normalize","vendorNames","capName","updateStyle","oldStaticStyle","oldStyleBinding","normalizedStyle","oldStyle","newStyle","checkChild","styleData","getStyle","whitespaceRE","addClass","classList","removeClass","tar","resolveTransition","css","autoCssTransition","enterClass","enterToClass","enterActiveClass","leaveClass","leaveToClass","leaveActiveClass","hasTransition","TRANSITION","ANIMATION","transitionProp","transitionEndEvent","animationProp","animationEndEvent","ontransitionend","onwebkittransitionend","onanimationend","onwebkitanimationend","raf","requestAnimationFrame","nextFrame","addTransitionClass","transitionClasses","removeTransitionClass","whenTransitionEnds","expectedType","getTransitionInfo","propCount","ended","onEnd","transformRE","styles","getComputedStyle","transitionDelays","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationDurations","animationTimeout","hasTransform","delays","durations","toMs","s","enter","toggleDisplay","_leaveCb","transition","_enterCb","nodeType","appearClass","appearToClass","appearActiveClass","afterEnter","enterCancelled","beforeAppear","appear","afterAppear","appearCancelled","duration","transitionNode","isAppear","startClass","toClass","beforeEnterHook","enterHook","afterEnterHook","enterCancelledHook","explicitEnterDuration","expectsCSS","userWantsControl","getHookArgumentsLength","show","pendingNode","_pending","isValidDuration","leave","rm","beforeLeave","afterLeave","leaveCancelled","delayLeave","explicitLeaveDuration","performLeave","invokerFns","_enter","patch","backend","removeNode","createElm","insertedVnodeQueue","parentElm","refElm","nested","ownerArray","isReactivated","initComponent","innerNode","activate","reactivateComponent","setScope","createChildren","invokeCreateHooks","pendingInsert","isPatchable","ref$$1","ancestor","addVnodes","startIdx","invokeDestroyHook","removeVnodes","ch","removeAndInvokeRemoveHook","childElm","createRmCb","findIdxInOld","oldCh","patchVnode","removeOnly","hydrate","newCh","oldKeyToIdx","idxInOld","vnodeToMove","oldStartIdx","newStartIdx","oldEndIdx","oldStartVnode","oldEndVnode","newEndIdx","newStartVnode","newEndVnode","canMove","updateChildren","postpatch","invokeInsertHook","initial","isRenderedModule","inVPre","hasChildNodes","childrenMatch","fullInvoke","isInitialPatch","isRealElement","hasAttribute","oldElm","patchable","i$2","createPatchFunction","vmodel","trigger","directive","binding","_vOptions","setSelected","getValue","onCompositionStart","onCompositionEnd","prevOptions","curOptions","some","o","hasNoMatchingOption","actuallySetSelected","isMultiple","option","selectedIndex","initEvent","dispatchEvent","locateNode","transition$$1","originalDisplay","__vOriginalDisplay","display","unbind","platformDirectives","transitionProps","getRealChild","compOptions","extractTransitionData","placeholder","rawChild","isNotTextNode","isVShowDirective","Transition","hasParentTransition","_leaving","oldRawChild","oldChild","isSameChild","delayedLeave","moveClass","callPendingCbs","_moveCb","recordPosition","newPos","applyTranslation","oldPos","pos","dx","dy","moved","transform","WebkitTransform","transitionDuration","platformComponents","TransitionGroup","beforeMount","kept","prevChildren","rawChildren","transitionData","removed","c$1","hasMove","_reflow","body","offsetHeight","propertyName","_hasMove","cloneNode","HTMLUnknownElement","HTMLElement","updateComponent","mountComponent","defaultTagRE","regexEscapeRE","buildRegex","delimiters","open","close","klass$1","staticKeys","transformNode","classBinding","genData","decoder","style$1","styleBinding","he","html","isUnaryTag","canBeLeftOpenTag","isNonPhrasingTag","attribute","dynamicArgAttribute","ncname","qnameCapture","startTagOpen","startTagClose","endTag","doctype","comment","conditionalComment","isPlainTextElement","reCache","decodingMap","encodedAttr","encodedAttrWithNewLines","isIgnoreNewlineTag","shouldIgnoreFirstNewline","decodeAttr","shouldDecodeNewlines","warn$2","transforms","preTransforms","postTransforms","platformIsPreTag","platformMustUseProp","platformGetTagNamespace","onRE","dirRE","forAliasRE","forIteratorRE","stripParensRE","dynamicArgRE","argRE","bindRE","modifierRE","slotRE","lineBreakRE","whitespaceRE$1","decodeHTMLCached","emptySlotScopeToken","createASTElement","makeAttrsMap","rawAttrsMap","template","isPreTag","root","currentParent","preserveWhitespace","whitespaceOption","whitespace","inPre","closeElement","element","trimEndingWhitespace","processed","processElement","if","elseif","else","addIfCondition","block","forbidden","findPrevElement","slotScope","slotTarget","lastNode","lastTag","expectHTML","isUnaryTag$$1","canBeLeftOpenTag$$1","endTagLength","stackedTag","reStackedTag","rest$1","all","chars","parseEndTag","textEnd","commentEnd","shouldKeepComment","substring","advance","conditionalEnd","doctypeMatch","endTagMatch","curIndex","startTagMatch","parseStartTag","handleStartTag","rest","unarySlash","unary","shouldDecodeNewlinesForHref","lowerCasedTag","lowerCasedTagName","parseHTML","comments","outputSourceRange","start$1","ieNSBug","ieNSPrefix","guardIESVGBug","processPre","processRawAttrs","processFor","processIf","processOnce","end$1","tagRE","tokenValue","rawTokens","parseText","processKey","for","checkInFor","processRef","slotTargetDynamic","getRawBindingAttr","slotBinding","getSlotName","slotBinding$1","ref$1","dynamic$1","slotContainer","processSlotContent","slotName","processComponent","syncGen","isDynamic","hasBindings","parseModifiers","camel","argMatch","processAttrs","inMatch","iteratorMatch","iterator1","iterator2","parseFor","condition","ifConditions","cloneASTElement","modules$1","preTransformNode","typeBinding","ifCondition","ifConditionExtra","hasElse","elseIfCondition","branch0","branch1","branch2","isStaticKey","isPlatformReservedTag","directives$1","_warn","code","genSelect","valueBinding","trueValueBinding","falseValueBinding","genCheckboxModel","genRadioModel","needCompositionGuard","genDefaultModel","baseOptions","reduce","genStaticKeys","genStaticKeysCached","optimize","markStatic$1","markStaticRoots","static","isDirectChildOfTemplateFor","l$1","staticInFor","staticRoot","fnExpRE","fnInvokeRE","simplePathRE","esc","tab","space","up","down","keyNames","genGuard","modifierCode","stop","prevent","self","ctrl","alt","genHandlers","staticHandlers","dynamicHandlers","handlerCode","genHandler","isMethodPath","isFunctionExpression","isFunctionInvocation","genModifierCode","keyModifier","genFilterCode","genKeyFilter","keyVal","keyCode","keyName","baseDirectives","wrapListeners","wrapData","cloak","CodegenState","dataGenFns","maybeComponent","onceId","generate","ast","genElement","staticProcessed","genStatic","onceProcessed","genOnce","forProcessed","genFor","ifProcessed","genIf","genChildren","genProps","bind$$1","genSlot","componentName","genData$2","genComponent","originalPreState","altGen","altEmpty","genIfConditions","conditions","genTernaryExp","altHelper","needRuntime","hasRuntime","gen","genDirectives","containsSlotChild","needsKey","generatedSlots","genScopedSlot","inlineRenderFns","genInlineTemplate","isLegacySyntax","reverseProxy","checkSkip","altGenElement","altGenNode","el$1","normalizationType$1","needsNormalization","getNormalizationType","genNode","genComment","transformSpecialNewlines","genText","staticProps","dynamicProps","createFunction","errors","createCompileToFunctionFn","compiled","fnGenErrors","baseCompile","div","createCompiler","finalOptions","tips","tip","compileToFunctions","getShouldDecode","idToTemplate","mount","outerHTML","container","getOuterHTML"],"sourceRoot":""}