{"version":3,"sources":["jsdelivr-header.js","/npm/@nickprogramm/atomjs@1.0.4/atom.js"],"names":[],"mappings":"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","file":"/npm/@nickprogramm/atomjs@1.0.4/atom.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@nickprogramm/atomjs@1.0.4/atom.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*!\n * Atom.js v2.0.0\n * (c) 2019 Nikolay Konovalov\n * Released under the Apache 2.0 License.\n */\n function isAtom() {\n\treturn \"OK\";\n }\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = global || self, global.Atom = factory());\n}(this, function () { 'use strict';\n\n  /*  */\n\n  var emptyObject = Object.freeze({});\n\n  // These helpers produce better VM code in JS engines due to their\n  // explicitness and function inlining.\n  function isUndef (v) {\n    return v === undefined || v === null\n  }\n\n  function isDef (v) {\n    return v !== undefined && v !== null\n  }\n\n  function isTrue (v) {\n    return v === true\n  }\n\n  function isFalse (v) {\n    return v === false\n  }\n\n  /**\n   * Check if value is primitive.\n   */\n  function 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   */\n  function 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   */\n  var _toString = Object.prototype.toString;\n\n  function 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   */\n  function isPlainObject (obj) {\n    return _toString.call(obj) === '[object Object]'\n  }\n\n  function isRegExp (v) {\n    return _toString.call(v) === '[object RegExp]'\n  }\n\n  /**\n   * Check if val is a valid array index.\n   */\n  function isValidArrayIndex (val) {\n    var n = parseFloat(String(val));\n    return n >= 0 && Math.floor(n) === n && isFinite(val)\n  }\n\n  function 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   */\n  function 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   */\n  function 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   */\n  function 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   */\n  var isBuiltInTag = makeMap('slot,component', true);\n\n  /**\n   * Check if an attribute is a reserved attribute.\n   */\n  var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');\n\n  /**\n   * Remove an item from an array.\n   */\n  function 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   */\n  var hasOwnProperty = Object.prototype.hasOwnProperty;\n  function hasOwn (obj, key) {\n    return hasOwnProperty.call(obj, key)\n  }\n\n  /**\n   * Create a cached version of a pure function.\n   */\n  function 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   */\n  var camelizeRE = /-(\\w)/g;\n  var camelize = cached(function (str) {\n    return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n  });\n\n  /**\n   * Capitalize a string.\n   */\n  var capitalize = cached(function (str) {\n    return str.charAt(0).toUpperCase() + str.slice(1)\n  });\n\n  /**\n   * Hyphenate a camelCase string.\n   */\n  var hyphenateRE = /\\B([A-Z])/g;\n  var 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 */\n  function 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\n  function nativeBind (fn, ctx) {\n    return fn.bind(ctx)\n  }\n\n  var bind = Function.prototype.bind\n    ? nativeBind\n    : polyfillBind;\n\n  /**\n   * Convert an Array-like object to a real Array.\n   */\n  function 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   */\n  function 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   */\n  function 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   */\n  function noop (a, b, c) {}\n\n  /**\n   * Always return false.\n   */\n  var no = function (a, b, c) { return false; };\n\n  /* eslint-enable no-unused-vars */\n\n  /**\n   * Return the same value.\n   */\n  var identity = function (_) { return _; };\n\n  /**\n   * Generate a string containing static keys from compiler modules.\n   */\n  function 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   */\n  function 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   */\n  function 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   */\n  function once (fn) {\n    var called = false;\n    return function () {\n      if (!called) {\n        called = true;\n        fn.apply(this, arguments);\n      }\n    }\n  }\n\n  var SSR_ATTR = 'data-server-rendered';\n\n  var ASSET_TYPES = [\n    'component',\n    'directive',\n    'filter'\n  ];\n\n  var 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\n  var 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: \"development\" !== 'production',\n\n    /**\n     * Whether to enable devtools\n     */\n    devtools: \"development\" !== 'production',\n\n    /**\n     * Whether to record perf\n     */\n    performance: false,\n\n    /**\n     * Error handler for watcher errors\n     */\n    errorHandler: null,\n\n    /**\n     * Warn handler for watcher warns\n     */\n    warnHandler: null,\n\n    /**\n     * Ignore certain custom elements\n     */\n    ignoredElements: [],\n\n    /**\n     * Custom user key aliases for v-on\n     */\n    // $flow-disable-line\n    keyCodes: Object.create(null),\n\n    /**\n     * Check if a tag is reserved so that it cannot be registered as a\n     * component. This is platform-dependent and may be overwritten.\n     */\n    isReservedTag: 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 Atom 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   */\n  var unicodeRegExp = /a-zA-Z\\u00B7\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u203F-\\u2040\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD/;\n\n  /**\n   * Check if a string starts with $ or _\n   */\n  function isReserved (str) {\n    var c = (str + '').charCodeAt(0);\n    return c === 0x24 || c === 0x5F\n  }\n\n  /**\n   * Define a property.\n   */\n  function 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   */\n  var bailRE = new RegExp((\"[^\" + (unicodeRegExp.source) + \".$_\\\\d]\"));\n  function 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__?\n  var hasProto = '__proto__' in {};\n\n  // Browser environment sniffing\n  var inBrowser = typeof window !== 'undefined';\n  var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;\n  var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();\n  var UA = inBrowser && window.navigator.userAgent.toLowerCase();\n  var isIE = UA && /msie|trident/.test(UA);\n  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;\n  var isEdge = UA && UA.indexOf('edge/') > 0;\n  var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');\n  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');\n  var isChrome = UA && /chrome\\/\\d+/.test(UA) && !isEdge;\n  var isPhantomJS = UA && /phantomjs/.test(UA);\n  var isFF = UA && UA.match(/firefox\\/(\\d+)/);\n\n  // Firefox has a \"watch\" function on Object.prototype...\n  var nativeWatch = ({}).watch;\n\n  var supportsPassive = false;\n  if (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 Atom may be required before\n  // Atom-server-renderer can set Atom_ENV\n  var _isServer;\n  var isServerRendering = function () {\n    if (_isServer === undefined) {\n      /* istanbul ignore if */\n      if (!inBrowser && !inWeex && typeof global !== 'undefined') {\n        // detect presence of Atom-server-renderer and avoid\n        // Webpack shimming the process\n        _isServer = global['process'] && global['process'].env.Atom_ENV === 'server';\n      } else {\n        _isServer = false;\n      }\n    }\n    return _isServer\n  };\n\n  // detect devtools\n  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n  /* istanbul ignore next */\n  function isNative (Ctor) {\n    return typeof Ctor === 'function' && /native code/.test(Ctor.toString())\n  }\n\n  var hasSymbol =\n    typeof Symbol !== 'undefined' && isNative(Symbol) &&\n    typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);\n\n  var _Set;\n  /* istanbul ignore if */ // $flow-disable-line\n  if (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\n  var warn = noop;\n  var tip = noop;\n  var generateComponentTrace = (noop); // work around flow check\n  var formatComponentName = (noop);\n\n  {\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((\"[Atom warn]: \" + msg + trace));\n      }\n    };\n\n    tip = function (msg, vm) {\n      if (hasConsole && (!config.silent)) {\n        console.warn(\"[Atom 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._isAtom\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(/([^/\\\\]+)\\.Atom$/);\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._isAtom && 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\n  var uid = 0;\n\n  /**\n   * A dep is an observable that can have multiple\n   * directives subscribing to it.\n   */\n  var Dep = function Dep () {\n    this.id = uid++;\n    this.subs = [];\n  };\n\n  Dep.prototype.addSub = function addSub (sub) {\n    this.subs.push(sub);\n  };\n\n  Dep.prototype.removeSub = function removeSub (sub) {\n    remove(this.subs, sub);\n  };\n\n  Dep.prototype.depend = function depend () {\n    if (Dep.target) {\n      Dep.target.addDep(this);\n    }\n  };\n\n  Dep.prototype.notify = function notify () {\n    // stabilize the subscriber list first\n    var subs = this.subs.slice();\n    if (!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.\n  Dep.target = null;\n  var targetStack = [];\n\n  function pushTarget (target) {\n    targetStack.push(target);\n    Dep.target = target;\n  }\n\n  function popTarget () {\n    targetStack.pop();\n    Dep.target = targetStack[targetStack.length - 1];\n  }\n\n  /*  */\n\n  var 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\n  var prototypeAccessors = { child: { configurable: true } };\n\n  // DEPRECATED: alias for componentInstance for backwards compat.\n  /* istanbul ignore next */\n  prototypeAccessors.child.get = function () {\n    return this.componentInstance\n  };\n\n  Object.defineProperties( VNode.prototype, prototypeAccessors );\n\n  var 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\n  function 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.\n  function 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\n  var arrayProto = Array.prototype;\n  var arrayMethods = Object.create(arrayProto);\n\n  var 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   */\n  methodsToPatch.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\n  var arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n  /**\n   * In some cases we may want to disable observation inside a component's\n   * update computation.\n   */\n  var shouldObserve = true;\n\n  function 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   */\n  var 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   */\n  Observer.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   */\n  Observer.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   */\n  function 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 */\n  function 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   */\n  function 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._isAtom\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   */\n  function 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 (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   */\n  function set (target, key, val) {\n    if (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._isAtom || (ob && ob.vmCount)) {\n      warn(\n        'Avoid adding reactive properties to a Atom 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   */\n  function del (target, key) {\n    if (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._isAtom || (ob && ob.vmCount)) {\n      warn(\n        'Avoid deleting properties on a Atom 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   */\n  function 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   */\n  var strats = config.optionMergeStrategies;\n\n  /**\n   * Options with restrictions\n   */\n  {\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   */\n  function 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   */\n  function mergeDataOrFn (\n    parentVal,\n    childVal,\n    vm\n  ) {\n    if (!vm) {\n      // in a Atom.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\n  strats.data = function (\n    parentVal,\n    childVal,\n    vm\n  ) {\n    if (!vm) {\n      if (childVal && typeof childVal !== 'function') {\n        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   */\n  function 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\n  function 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\n  LIFECYCLE_HOOKS.forEach(function (hook) {\n    strats[hook] = mergeHook;\n  });\n\n  /**\n   * Assets\n   *\n   * When a vm is present (instance creation), we need to do\n   * a three-way merge between constructor options, instance\n   * options and parent options.\n   */\n  function mergeAssets (\n    parentVal,\n    childVal,\n    vm,\n    key\n  ) {\n    var res = Object.create(parentVal || null);\n    if (childVal) {\n      assertObjectType(key, childVal, vm);\n      return extend(res, childVal)\n    } else {\n      return res\n    }\n  }\n\n  ASSET_TYPES.forEach(function (type) {\n    strats[type + 's'] = mergeAssets;\n  });\n\n  /**\n   * Watchers.\n   *\n   * Watchers hashes should not overwrite one\n   * another, so we merge them as arrays.\n   */\n  strats.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    {\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   */\n  strats.props =\n  strats.methods =\n  strats.inject =\n  strats.computed = function (\n    parentVal,\n    childVal,\n    vm,\n    key\n  ) {\n    if (childVal && \"development\" !== '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  };\n  strats.provide = mergeDataOrFn;\n\n  /**\n   * Default strategy.\n   */\n  var defaultStrat = function (parentVal, childVal) {\n    return childVal === undefined\n      ? parentVal\n      : childVal\n  };\n\n  /**\n   * Validate component names\n   */\n  function checkComponents (options) {\n    for (var key in options.components) {\n      validateComponentName(key);\n    }\n  }\n\n  function 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   */\n  function 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 {\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 {\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   */\n  function 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 {\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   */\n  function 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\n  function 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   */\n  function mergeOptions (\n    parent,\n    child,\n    vm\n  ) {\n    {\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   */\n  function 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 (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\n  function 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    {\n      assertProp(prop, key, value, vm, absent);\n    }\n    return value\n  }\n\n  /**\n   * Get the default value of a prop.\n   */\n  function 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 (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   */\n  function 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\n  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;\n\n  function 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   */\n  function getType (fn) {\n    var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n    return match ? match[1] : ''\n  }\n\n  function isSameType (a, b) {\n    return getType(a) === getType(b)\n  }\n\n  function getTypeIndex (type, expectedTypes) {\n    if (!Array.isArray(expectedTypes)) {\n      return isSameType(expectedTypes, type) ? 0 : -1\n    }\n    for (var i = 0, len = expectedTypes.length; i < len; i++) {\n      if (isSameType(expectedTypes[i], type)) {\n        return i\n      }\n    }\n    return -1\n  }\n\n  function 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\n  function 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\n  function isExplicable (value) {\n    var explicitTypes = ['string', 'number', 'boolean'];\n    return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })\n  }\n\n  function 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\n  function handleError (err, vm, info) {\n    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.\n    // See: https://github.com/Atomjs/Atomx/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\n  function 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._isAtom && 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\n  function 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\n  function logError (err, vm, info) {\n    {\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\n  var isUsingMicroTask = false;\n\n  var callbacks = [];\n  var pending = false;\n\n  function 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).\n  var 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 */\n  if (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    // Techinically 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\n  function 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\n  var mark;\n  var measure;\n\n  {\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\n  var initProxy;\n\n  {\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://Atomjs.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 Atom instance to ' +\n        'prevent conflicts with Atom internals' +\n        'See: https://Atomjs.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\n  var 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   */\n  function traverse (val) {\n    _traverse(val, seenObjects);\n    seenObjects.clear();\n  }\n\n  function _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\n  var 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\n  function 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\n  function 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        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\n  function 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\n  function 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        {\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\n  function 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.\n  function 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.\n  function normalizeChildren (children) {\n    return isPrimitive(children)\n      ? [createTextVNode(children)]\n      : Array.isArray(children)\n        ? normalizeArrayChildren(children)\n        : undefined\n  }\n\n  function isTextNode (node) {\n    return isDef(node) && isDef(node.text) && isFalse(node.isComment)\n  }\n\n  function 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\n  function 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\n  function 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        {\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        }\n      });\n      toggleObserving(true);\n    }\n  }\n\n  function 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 {\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   */\n  function 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 Atom 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\n  function isWhitespace (node) {\n    return (node.isComment && !node.asyncFactory) || node.text === ' '\n  }\n\n  /*  */\n\n  function 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\n  function 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\n  function proxyNormalSlot(slots, key) {\n    return function () { return slots[key]; }\n  }\n\n  /*  */\n\n  /**\n   * Runtime helper for rendering v-for lists.\n   */\n  function 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   */\n  function 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 (!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   */\n  function resolveFilter (id) {\n    return resolveAsset(this.$options, 'filters', id, true) || identity\n  }\n\n  /*  */\n\n  function 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 Atom.prototype._k\n   * passing in eventKeyName as last argument separately for backwards compat\n   */\n  function 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   */\n  function bindObjectProps (\n    data,\n    tag,\n    value,\n    asProp,\n    isSync\n  ) {\n    if (value) {\n      if (!isObject(value)) {\n        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   */\n  function 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   */\n  function markOnce (\n    tree,\n    index,\n    key\n  ) {\n    markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n    return tree\n  }\n\n  function 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\n  function markStaticNode (node, key, isOnce) {\n    node.isStatic = true;\n    node.key = key;\n    node.isOnce = isOnce;\n  }\n\n  /*  */\n\n  function bindObjectListeners (data, value) {\n    if (value) {\n      if (!isPlainObject(value)) {\n        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\n  function 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\n  function 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 (key !== '' && key !== null) {\n        // null is a speical 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.\n  function prependModifier (value, symbol) {\n    return typeof value === 'string' ? symbol + value : value\n  }\n\n  /*  */\n\n  function 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\n  function 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\n  installRenderHelpers(FunctionalRenderContext.prototype);\n\n  function 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\n  function 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    {\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\n  function 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\n  var 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          // Atom-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\n  var hooksToMerge = Object.keys(componentVNodeHooks);\n\n  function 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      {\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      (\"Atom-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\n  function 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\n  function 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\n  function 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.\n  function 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\n  var SIMPLE_NORMALIZE = 1;\n  var ALWAYS_NORMALIZE = 2;\n\n  // wrapper function for providing a more flexible interface\n  // without getting yelled at by flow\n  function 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\n  function _createElement (\n    context,\n    tag,\n    data,\n    children,\n    normalizationType\n  ) {\n    if (isDef(data) && isDef((data).__ob__)) {\n      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 (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        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\n  function 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\n  function 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\n  function 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    {\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    }\n  }\n\n  var currentRenderingInstance = null;\n\n  function renderMixin (Atom) {\n    // install runtime convenience helpers\n    installRenderHelpers(Atom.prototype);\n\n    Atom.prototype.$nextTick = function (fn) {\n      return nextTick(fn, this)\n    };\n\n    Atom.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 becaues 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 (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 (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\n  function 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\n  function 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\n  function 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        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                  \"timeout (\" + (res.timeout) + \"ms)\"\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\n  function isAsyncPlaceholder (node) {\n    return node.isComment && node.asyncFactory\n  }\n\n  /*  */\n\n  function 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\n  function 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\n  var target;\n\n  function add (event, fn) {\n    target.$on(event, fn);\n  }\n\n  function remove$1 (event, fn) {\n    target.$off(event, fn);\n  }\n\n  function 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\n  function 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\n  function eventsMixin (Atom) {\n    var hookRE = /^hook:/;\n    Atom.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    Atom.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    Atom.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    Atom.prototype.$emit = function (event) {\n      var vm = this;\n      {\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\n  var activeInstance = null;\n  var isUpdatingChildComponent = false;\n\n  function setActiveInstance(vm) {\n    var prevActiveInstance = activeInstance;\n    activeInstance = vm;\n    return function () {\n      activeInstance = prevActiveInstance;\n    }\n  }\n\n  function 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\n  function lifecycleMixin (Atom) {\n    Atom.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      // Atom.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 __Atom__ reference\n      if (prevEl) {\n        prevEl.__Atom__ = null;\n      }\n      if (vm.$el) {\n        vm.$el.__Atom__ = 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    Atom.prototype.$forceUpdate = function () {\n      var vm = this;\n      if (vm._watcher) {\n        vm._watcher.update();\n      }\n    };\n\n    Atom.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 __Atom__ reference\n      if (vm.$el) {\n        vm.$el.__Atom__ = null;\n      }\n      // release circular reference (#6759)\n      if (vm.$vnode) {\n        vm.$vnode.parent = null;\n      }\n    };\n  }\n\n  function mountComponent (\n    vm,\n    el,\n    hydrating\n  ) {\n    vm.$el = el;\n    if (!vm.$options.render) {\n      vm.$options.render = createEmptyVNode;\n      {\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 Atom 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 (config.performance && mark) {\n      updateComponent = function () {\n        var name = vm._name;\n        var id = vm._uid;\n        var startTag = \"Atom-perf-start:\" + id;\n        var endTag = \"Atom-perf-end:\" + id;\n\n        mark(startTag);\n        var vnode = vm._render();\n        mark(endTag);\n        measure((\"Atom \" + name + \" render\"), startTag, endTag);\n\n        mark(startTag);\n        vm._update(vnode, hydrating);\n        mark(endTag);\n        measure((\"Atom \" + 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\n  function updateChildComponent (\n    vm,\n    propsData,\n    listeners,\n    parentVnode,\n    renderChildren\n  ) {\n    {\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    {\n      isUpdatingChildComponent = false;\n    }\n  }\n\n  function isInInactiveTree (vm) {\n    while (vm && (vm = vm.$parent)) {\n      if (vm._inactive) { return true }\n    }\n    return false\n  }\n\n  function 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\n  function 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\n  function 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\n  var MAX_UPDATE_COUNT = 100;\n\n  var queue = [];\n  var activatedChildren = [];\n  var has = {};\n  var circular = {};\n  var waiting = false;\n  var flushing = false;\n  var index = 0;\n\n  /**\n   * Reset the scheduler's state.\n   */\n  function resetSchedulerState () {\n    index = queue.length = activatedChildren.length = 0;\n    has = {};\n    {\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.\n  var currentFlushTimestamp = 0;\n\n  // Async edge case fix requires storing an event listener's attach timestamp.\n  var 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)\n  if (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   */\n  function 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 (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\n  function 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   */\n  function 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\n  function 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   */\n  function 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 (!config.async) {\n          flushSchedulerQueue();\n          return\n        }\n        nextTick(flushSchedulerQueue);\n      }\n    }\n  }\n\n  /*  */\n\n\n\n  var 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   */\n  var 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 = expOrFn.toString();\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        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   */\n  Watcher.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   */\n  Watcher.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   */\n  Watcher.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   */\n  Watcher.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   */\n  Watcher.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   */\n  Watcher.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   */\n  Watcher.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   */\n  Watcher.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\n  var sharedPropertyDefinition = {\n    enumerable: true,\n    configurable: true,\n    get: noop,\n    set: noop\n  };\n\n  function 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\n  function 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\n  function 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      {\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      }\n      // static props are already proxied on the component's prototype\n      // during Atom.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\n  function 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      warn(\n        'data functions should return an object:\\n' +\n        'https://Atomjs.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      {\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        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\n  function 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\n  var computedWatcherOptions = { lazy: true };\n\n  function 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 (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 {\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\n  function 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 (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\n  function 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\n  function createGetterInvoker(fn) {\n    return function computedGetter () {\n      return fn.call(this, this)\n    }\n  }\n\n  function initMethods (vm, methods) {\n    var props = vm.$options.props;\n    for (var key in methods) {\n      {\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 Atom 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\n  function 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\n  function 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\n  function stateMixin (Atom) {\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    {\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(Atom.prototype, '$data', dataDef);\n    Object.defineProperty(Atom.prototype, '$props', propsDef);\n\n    Atom.prototype.$set = set;\n    Atom.prototype.$delete = del;\n\n    Atom.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\n  var uid$3 = 0;\n\n  function initMixin (Atom) {\n    Atom.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 (config.performance && mark) {\n        startTag = \"Atom-perf-start:\" + (vm._uid);\n        endTag = \"Atom-perf-end:\" + (vm._uid);\n        mark(startTag);\n      }\n\n      // a flag to avoid this being observed\n      vm._isAtom = 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      {\n        initProxy(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 (config.performance && mark) {\n        vm._name = formatComponentName(vm, false);\n        mark(endTag);\n        measure((\"Atom \" + (vm._name) + \" init\"), startTag, endTag);\n      }\n\n      if (vm.$options.el) {\n        vm.$mount(vm.$options.el);\n      }\n    };\n  }\n\n  function 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\n  function 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\n  function 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\n  function Atom (options) {\n    if (!(this instanceof Atom)\n    ) {\n      warn('Atom is a constructor and should be called with the `new` keyword');\n    }\n    this._init(options);\n  }\n\n  initMixin(Atom);\n  stateMixin(Atom);\n  eventsMixin(Atom);\n  lifecycleMixin(Atom);\n  renderMixin(Atom);\n\n  /*  */\n\n  function initUse (Atom) {\n    Atom.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\n  function initMixin$1 (Atom) {\n    Atom.mixin = function (mixin) {\n      this.options = mergeOptions(this.options, mixin);\n      return this\n    };\n  }\n\n  /*  */\n\n  function initExtend (Atom) {\n    /**\n     * Each instance constructor, including Atom, has a unique\n     * cid. This enables us to create wrapped \"child\n     * constructors\" for prototypal inheritance and cache them.\n     */\n    Atom.cid = 0;\n    var cid = 1;\n\n    /**\n     * Class inheritance\n     */\n    Atom.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 (name) {\n        validateComponentName(name);\n      }\n\n      var Sub = function AtomComponent (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 Atom 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\n  function initProps$1 (Comp) {\n    var props = Comp.options.props;\n    for (var key in props) {\n      proxy(Comp.prototype, \"_props\", key);\n    }\n  }\n\n  function 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\n  function initAssetRegisters (Atom) {\n    /**\n     * Create asset registration methods.\n     */\n    ASSET_TYPES.forEach(function (type) {\n      Atom[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 (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\n  function getComponentName (opts) {\n    return opts && (opts.Ctor.options.name || opts.tag)\n  }\n\n  function 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\n  function 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\n  function 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\n  var patternTypes = [String, RegExp, Array];\n\n  var 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\n  var builtInComponents = {\n    KeepAlive: KeepAlive\n  };\n\n  /*  */\n\n  function initGlobalAPI (Atom) {\n    // config\n    var configDef = {};\n    configDef.get = function () { return config; };\n    {\n      configDef.set = function () {\n        warn(\n          'Do not replace the Atom.config object, set individual fields instead.'\n        );\n      };\n    }\n    Object.defineProperty(Atom, '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    Atom.util = {\n      warn: warn,\n      extend: extend,\n      mergeOptions: mergeOptions,\n      defineReactive: defineReactive$$1\n    };\n\n    Atom.set = set;\n    Atom.delete = del;\n    Atom.nextTick = nextTick;\n\n    // 2.6 explicit observable API\n    Atom.observable = function (obj) {\n      observe(obj);\n      return obj\n    };\n\n    Atom.options = Object.create(null);\n    ASSET_TYPES.forEach(function (type) {\n      Atom.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    Atom.options._base = Atom;\n\n    extend(Atom.options.components, builtInComponents);\n\n    initUse(Atom);\n    initMixin$1(Atom);\n    initExtend(Atom);\n    initAssetRegisters(Atom);\n  }\n\n  initGlobalAPI(Atom);\n\n  Object.defineProperty(Atom.prototype, '$isServer', {\n    get: isServerRendering\n  });\n\n  Object.defineProperty(Atom.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\n  Object.defineProperty(Atom, 'FunctionalRenderContext', {\n    value: FunctionalRenderContext\n  });\n\n  Atom.version = '2.6.10';\n\n  /*  */\n\n  // these are reserved for web because they are directly compiled away\n  // during template compilation\n  var isReservedAttr = makeMap('style,class');\n\n  // attributes that should be using props for binding\n  var acceptValue = makeMap('input,textarea,option,select,progress');\n  var 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\n  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\n  var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');\n\n  var 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\n  var 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\n  var xlinkNS = 'http://www.w3.org/1999/xlink';\n\n  var isXlink = function (name) {\n    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n  };\n\n  var getXlinkProp = function (name) {\n    return isXlink(name) ? name.slice(6, name.length) : ''\n  };\n\n  var isFalsyAttrValue = function (val) {\n    return val == null || val === false\n  };\n\n  /*  */\n\n  function 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\n  function 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\n  function 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\n  function concat (a, b) {\n    return a ? b ? (a + ' ' + b) : a : (b || '')\n  }\n\n  function 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\n  function 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\n  function 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\n  var namespaceMap = {\n    svg: 'http://www.w3.org/2000/svg',\n    math: 'http://www.w3.org/1998/Math/MathML'\n  };\n\n  var 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.\n  var 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\n  var isPreTag = function (tag) { return tag === 'pre'; };\n\n  var isReservedTag = function (tag) {\n    return isHTMLTag(tag) || isSVG(tag)\n  };\n\n  function 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\n  var unknownElementCache = Object.create(null);\n  function 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\n  var 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   */\n  function query (el) {\n    if (typeof el === 'string') {\n      var selected = document.querySelector(el);\n      if (!selected) {\n        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\n  function 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\n  function createElementNS (namespace, tagName) {\n    return document.createElementNS(namespaceMap[namespace], tagName)\n  }\n\n  function createTextNode (text) {\n    return document.createTextNode(text)\n  }\n\n  function createComment (text) {\n    return document.createComment(text)\n  }\n\n  function insertBefore (parentNode, newNode, referenceNode) {\n    parentNode.insertBefore(newNode, referenceNode);\n  }\n\n  function removeChild (node, child) {\n    node.removeChild(child);\n  }\n\n  function appendChild (node, child) {\n    node.appendChild(child);\n  }\n\n  function parentNode (node) {\n    return node.parentNode\n  }\n\n  function nextSibling (node) {\n    return node.nextSibling\n  }\n\n  function tagName (node) {\n    return node.tagName\n  }\n\n  function setTextContent (node, text) {\n    node.textContent = text;\n  }\n\n  function setStyleScope (node, scopeId) {\n    node.setAttribute(scopeId, '');\n  }\n\n  var 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\n  var 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\n  function 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\n  var emptyNode = new VNode('', {}, []);\n\n  var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];\n\n  function 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\n  function 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\n  function 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\n  function 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        {\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 (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        {\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 (parentElm, 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      {\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(parentElm, 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          {\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(elm, 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      {\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 (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 (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('Atom-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 {\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(parentElm, [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\n  var directives = {\n    create: updateDirectives,\n    update: updateDirectives,\n    destroy: function unbindDirectives (vnode) {\n      updateDirectives(vnode, emptyNode);\n    }\n  };\n\n  function updateDirectives (oldVnode, vnode) {\n    if (oldVnode.data.directives || vnode.data.directives) {\n      _update(oldVnode, vnode);\n    }\n  }\n\n  function _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\n  var emptyModifiers = Object.create(null);\n\n  function 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\n  function getRawDirName (dir) {\n    return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n  }\n\n  function 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\n  var baseModules = [\n    ref,\n    directives\n  ];\n\n  /*  */\n\n  function 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\n  function 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\n  function 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\n  var attrs = {\n    create: updateAttrs,\n    update: updateAttrs\n  };\n\n  /*  */\n\n  function 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\n  var klass = {\n    create: updateClass,\n    update: updateClass\n  };\n\n  /*  */\n\n  var validDivisionCharRE = /[\\w).+\\-_$\\]]/;\n\n  function 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\n  function 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 */\n  function baseWarn (msg, range) {\n    console.error((\"[Atom compiler]: \" + msg));\n  }\n  /* eslint-enable no-unused-vars */\n\n  function pluckModuleFunction (\n    modules,\n    key\n  ) {\n    return modules\n      ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })\n      : []\n  }\n\n  function 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\n  function 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)\n  function addRawAttr (el, name, value, range) {\n    el.attrsMap[name] = value;\n    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));\n  }\n\n  function 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\n  function prependModifierMarker (symbol, name, dynamic) {\n    return dynamic\n      ? (\"_p(\" + name + \",\\\"\" + symbol + \"\\\")\")\n      : symbol + name // mark the event as captured\n  }\n\n  function 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      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\n  function getRawBindingAttr (\n    el,\n    name\n  ) {\n    return el.rawAttrsMap[':' + name] ||\n      el.rawAttrsMap['v-bind:' + name] ||\n      el.rawAttrsMap[name]\n  }\n\n  function 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.\n  function 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\n  function 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\n  function 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   */\n  function 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   */\n  function 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\n  var len, str, chr, index$1, expressionPos, expressionEndPos;\n\n\n\n  function parseModel (val) {\n    // Fix https://github.com/Atomjs/Atom/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\n  function next () {\n    return str.charCodeAt(++index$1)\n  }\n\n  function eof () {\n    return index$1 >= len\n  }\n\n  function isStringStart (chr) {\n    return chr === 0x22 || chr === 0x27\n  }\n\n  function 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\n  function parseString (chr) {\n    var stringQuote = chr;\n    while (!eof()) {\n      chr = next();\n      if (chr === stringQuote) {\n        break\n      }\n    }\n  }\n\n  /*  */\n\n  var 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.\n  var RANGE_TOKEN = '__r';\n  var CHECKBOX_RADIO_TOKEN = '__c';\n\n  function 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    {\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 {\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\n  function 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\n  function 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\n  function 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\n  function 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    {\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.\n  function 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\n  var target$1;\n\n  function 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.\n  var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);\n\n  function 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\n  function 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\n  function 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\n  var events = {\n    create: updateDOMListeners,\n    update: updateDOMListeners\n  };\n\n  /*  */\n\n  var svgContainer;\n\n  function 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\n  function shouldUpdateValue (elm, checkVal) {\n    return (!elm.composing && (\n      elm.tagName === 'OPTION' ||\n      isNotInFocusAndDirty(elm, checkVal) ||\n      isDirtyWithModifiers(elm, checkVal)\n    ))\n  }\n\n  function 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\n  function 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\n  var domProps = {\n    create: updateDOMProps,\n    update: updateDOMProps\n  };\n\n  /*  */\n\n  var 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\n  function 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\n  function 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   */\n  function 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\n  var cssVarRE = /^--/;\n  var importantRE = /\\s*!important$/;\n  var 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\n  var vendorNames = ['Webkit', 'Moz', 'ms'];\n\n  var emptyStyle;\n  var 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\n  function 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\n  var style = {\n    create: updateStyle,\n    update: updateStyle\n  };\n\n  /*  */\n\n  var whitespaceRE = /\\s+/;\n\n  /**\n   * Add class with compatibility for SVG since classList is not supported on\n   * SVG elements in IE\n   */\n  function 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   */\n  function 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\n  function 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\n  var 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\n  var hasTransition = inBrowser && !isIE9;\n  var TRANSITION = 'transition';\n  var ANIMATION = 'animation';\n\n  // Transition property/event sniffing\n  var transitionProp = 'transition';\n  var transitionEndEvent = 'transitionend';\n  var animationProp = 'animation';\n  var animationEndEvent = 'animationend';\n  if (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\n  var raf = inBrowser\n    ? window.requestAnimationFrame\n      ? window.requestAnimationFrame.bind(window)\n      : setTimeout\n    : /* istanbul ignore next */ function (fn) { return fn(); };\n\n  function nextFrame (fn) {\n    raf(function () {\n      raf(fn);\n    });\n  }\n\n  function 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\n  function removeTransitionClass (el, cls) {\n    if (el._transitionClasses) {\n      remove(el._transitionClasses, cls);\n    }\n    removeClass(el, cls);\n  }\n\n  function 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\n  var transformRE = /\\b(transform|all)(,|$)/;\n\n  function 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\n  function 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\n  function toMs (s) {\n    return Number(s.slice(0, -1).replace(',', '.')) * 1000\n  }\n\n  /*  */\n\n  function 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 (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\n  function 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 (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\n  function 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\n  function 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   */\n  function 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\n  function _enter (_, vnode) {\n    if (vnode.data.show !== true) {\n      enter(vnode);\n    }\n  }\n\n  var 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\n  var 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.\n  var modules = platformModules.concat(baseModules);\n\n  var 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 */\n  if (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\n  var 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\n  function 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\n  function actuallySetSelected (el, binding, vm) {\n    var value = binding.value;\n    var isMultiple = el.multiple;\n    if (isMultiple && !Array.isArray(value)) {\n      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\n  function hasNoMatchingOption (value, options) {\n    return options.every(function (o) { return !looseEqual(o, value); })\n  }\n\n  function getValue (option) {\n    return '_value' in option\n      ? option._value\n      : option.value\n  }\n\n  function onCompositionStart (e) {\n    e.target.composing = true;\n  }\n\n  function 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\n  function 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\n  function locateNode (vnode) {\n    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n      ? locateNode(vnode.componentInstance._vnode)\n      : vnode\n  }\n\n  var 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\n  var platformDirectives = {\n    model: directive,\n    show: show\n  };\n\n  /*  */\n\n  var 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\n  function 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\n  function 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\n  function 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\n  function hasParentTransition (vnode) {\n    while ((vnode = vnode.parent)) {\n      if (vnode.data.transition) {\n        return true\n      }\n    }\n  }\n\n  function isSameChild (child, oldChild) {\n    return oldChild.key === child.key && oldChild.tag === child.tag\n  }\n\n  var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };\n\n  var isVShowDirective = function (d) { return d.name === 'show'; };\n\n  var 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 (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 (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\n  var props = extend({\n    tag: String,\n    moveClass: String\n  }, transitionProps);\n\n  delete props.mode;\n\n  var 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 {\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\n  function 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\n  function recordPosition (c) {\n    c.data.newPos = c.elm.getBoundingClientRect();\n  }\n\n  function 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\n  var platformComponents = {\n    Transition: Transition,\n    TransitionGroup: TransitionGroup\n  };\n\n  /*  */\n\n  // install platform specific utils\n  Atom.config.mustUseProp = mustUseProp;\n  Atom.config.isReservedTag = isReservedTag;\n  Atom.config.isReservedAttr = isReservedAttr;\n  Atom.config.getTagNamespace = getTagNamespace;\n  Atom.config.isUnknownElement = isUnknownElement;\n\n  // install platform runtime directives & components\n  extend(Atom.options.directives, platformDirectives);\n  extend(Atom.options.components, platformComponents);\n\n  // install platform patch function\n  Atom.prototype.__patch__ = inBrowser ? patch : noop;\n\n  // public mount method\n  Atom.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 */\n  if (inBrowser) {\n    setTimeout(function () {\n      if (config.devtools) {\n        if (devtools) {\n          devtools.emit('init', Atom);\n        } else {\n          console[console.info ? 'info' : 'log'](\n            'Welcome to Atom new js-framework'\n          );\n        }\n      }\n      if (config.productionTip !== false &&\n        typeof console !== 'undefined'\n      ) {\n        console[console.info ? 'info' : 'log'](\n          \"You are running Atom in development mode.\\n\" +\n          \"Make sure to turn on production mode when deploying for production.\\n\" +\n          \"See more tips at https://Atomjs.org/guide/deployment.html\"\n        );\n      }\n    }, 0);\n  }\n\n  /*  */\n\n  var defaultTagRE = /\\{\\{((?:.|\\r?\\n)+?)\\}\\}/g;\n  var regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\n  var 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\n  function 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\n  function transformNode (el, options) {\n    var warn = options.warn || baseWarn;\n    var staticClass = getAndRemoveAttr(el, 'class');\n    if (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\n  function 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\n  var klass$1 = {\n    staticKeys: ['staticClass'],\n    transformNode: transformNode,\n    genData: genData\n  };\n\n  /*  */\n\n  function transformNode$1 (el, options) {\n    var warn = options.warn || baseWarn;\n    var staticStyle = getAndRemoveAttr(el, 'style');\n    if (staticStyle) {\n      /* istanbul ignore if */\n      {\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\n  function 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\n  var style$1 = {\n    staticKeys: ['staticStyle'],\n    transformNode: transformNode$1,\n    genData: genData$1\n  };\n\n  /*  */\n\n  var decoder;\n\n  var 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\n  var 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)\n  var 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\n  var 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\n  var attribute = /^\\s*([^\\s\"'<>\\/=]+)(?:\\s*(=)\\s*(?:\"([^\"]*)\"+|'([^']*)'+|([^\\s\"'=<>`]+)))?/;\n  var dynamicArgAttribute = /^\\s*((?:v-[\\w-]+:|@|:|#)\\[[^=]+\\][^\\s\"'<>\\/=]*)(?:\\s*(=)\\s*(?:\"([^\"]*)\"+|'([^']*)'+|([^\\s\"'=<>`]+)))?/;\n  var ncname = \"[a-zA-Z_][\\\\-\\\\.0-9_a-zA-Z\" + (unicodeRegExp.source) + \"]*\";\n  var qnameCapture = \"((?:\" + ncname + \"\\\\:)?\" + ncname + \")\";\n  var startTagOpen = new RegExp((\"^<\" + qnameCapture));\n  var startTagClose = /^\\s*(\\/?)>/;\n  var endTag = new RegExp((\"^<\\\\/\" + qnameCapture + \"[^>]*>\"));\n  var doctype = /^<!DOCTYPE [^>]+>/i;\n  // #7298: escape - to avoid being pased as HTML comment when inlined in page\n  var comment = /^<!\\--/;\n  var conditionalComment = /^<!\\[/;\n\n  // Special Elements (can contain anything)\n  var isPlainTextElement = makeMap('script,style,textarea', true);\n  var reCache = {};\n\n  var decodingMap = {\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&amp;': '&',\n    '&#10;': '\\n',\n    '&#9;': '\\t',\n    '&#39;': \"'\"\n  };\n  var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;\n  var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;\n\n  // #5992\n  var isIgnoreNewlineTag = makeMap('pre,textarea', true);\n  var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\\n'; };\n\n  function decodeAttr (value, shouldDecodeNewlines) {\n    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;\n    return value.replace(re, function (match) { return decodingMap[match]; })\n  }\n\n  function 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 (!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 (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 (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\n  var onRE = /^@|^v-on:/;\n  var dirRE = /^v-|^@|^:/;\n  var forAliasRE = /([\\s\\S]*?)\\s+(?:in|of)\\s+([\\s\\S]*)/;\n  var forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/;\n  var stripParensRE = /^\\(|\\)$/g;\n  var dynamicArgRE = /^\\[.*\\]$/;\n\n  var argRE = /:(.*)$/;\n  var bindRE = /^:|^\\.|^v-bind:/;\n  var modifierRE = /\\.[^.\\]]+(?=[^\\]]*$)/g;\n\n  var slotRE = /^v-slot(:|$)|^#/;\n\n  var lineBreakRE = /[\\r\\n]/;\n  var whitespaceRE$1 = /\\s+/g;\n\n  var invalidAttributeRE = /[\\s\"'<>\\/=]/;\n\n  var decodeHTMLCached = cached(he.decode);\n\n  var emptySlotScopeToken = \"_empty_\";\n\n  // configurable state\n  var warn$2;\n  var delimiters;\n  var transforms;\n  var preTransforms;\n  var postTransforms;\n  var platformIsPreTag;\n  var platformMustUseProp;\n  var platformGetTagNamespace;\n  var maybeComponent;\n\n  function 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   */\n  function 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          {\n            checkRootConstraints(element);\n          }\n          addIfCondition(root, {\n            exp: element.elseif,\n            block: element\n          });\n        } else {\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        {\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          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          {\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 (options.outputSourceRange) {\n          element.end = end$1;\n        }\n        closeElement(element);\n      },\n\n      chars: function chars (text, start, end) {\n        if (!currentParent) {\n          {\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 (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 (options.outputSourceRange) {\n            child.start = start;\n            child.end = end;\n          }\n          currentParent.children.push(child);\n        }\n      }\n    });\n    return root\n  }\n\n  function processPre (el) {\n    if (getAndRemoveAttr(el, 'v-pre') != null) {\n      el.pre = true;\n    }\n  }\n\n  function 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\n  function 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\n  function processKey (el) {\n    var exp = getBindingAttr(el, 'key');\n    if (exp) {\n      {\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\n  function processRef (el) {\n    var ref = getBindingAttr(el, 'ref');\n    if (ref) {\n      el.ref = ref;\n      el.refInFor = checkInFor(el);\n    }\n  }\n\n  function 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 {\n        warn$2(\n          (\"Invalid v-for expression: \" + exp),\n          el.rawAttrsMap['v-for']\n        );\n      }\n    }\n  }\n\n\n\n  function 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\n  function 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\n  function 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 {\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\n  function findPrevElement (children) {\n    var i = children.length;\n    while (i--) {\n      if (children[i].type === 1) {\n        return children[i]\n      } else {\n        if (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\n  function addIfCondition (el, condition) {\n    if (!el.ifConditions) {\n      el.ifConditions = [];\n    }\n    el.ifConditions.push(condition);\n  }\n\n  function 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\">\n  function processSlotContent (el) {\n    var slotScope;\n    if (el.tag === 'template') {\n      slotScope = getAndRemoveAttr(el, 'scope');\n      /* istanbul ignore if */\n      if (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 (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          {\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 the 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          {\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\n  function getSlotName (binding) {\n    var name = binding.name.replace(slotRE, '');\n    if (!name) {\n      if (binding.name[0] !== '#') {\n        name = 'default';\n      } else {\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\n  function processSlotOutlet (el) {\n    if (el.tag === 'slot') {\n      el.slotName = getBindingAttr(el, 'name');\n      if (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\n  function 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\n  function 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            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 (name === 'model') {\n            checkForAliasModel(el, value);\n          }\n        }\n      } else {\n        // literal attribute\n        {\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\n  function 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\n  function 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\n  function makeAttrsMap (attrs) {\n    var map = {};\n    for (var i = 0, l = attrs.length; i < l; i++) {\n      if (\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\n  function isTextTag (el) {\n    return el.tag === 'script' || el.tag === 'style'\n  }\n\n  function 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\n  var ieNSBug = /^xmlns:NS\\d+/;\n  var ieNSPrefix = /^NS\\d+:/;\n\n  /* istanbul ignore next */\n  function 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\n  function 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\n  function 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\n  function cloneASTElement (el) {\n    return createASTElement(el.tag, el.attrsList.slice(), el.parent)\n  }\n\n  var model$1 = {\n    preTransformNode: preTransformNode\n  };\n\n  var modules$1 = [\n    klass$1,\n    style$1,\n    model$1\n  ];\n\n  /*  */\n\n  function text (el, dir) {\n    if (dir.value) {\n      addProp(el, 'textContent', (\"_s(\" + (dir.value) + \")\"), dir);\n    }\n  }\n\n  /*  */\n\n  function html (el, dir) {\n    if (dir.value) {\n      addProp(el, 'innerHTML', (\"_s(\" + (dir.value) + \")\"), dir);\n    }\n  }\n\n  var directives$1 = {\n    model: model,\n    text: text,\n    html: html\n  };\n\n  /*  */\n\n  var 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\n  var isStaticKey;\n  var isPlatformReservedTag;\n\n  var 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   */\n  function 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\n  function genStaticKeys$1 (keys) {\n    return makeMap(\n      'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +\n      (keys ? ',' + keys : '')\n    )\n  }\n\n  function 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\n  function 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\n  function 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\n  function 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\n  var fnExpRE = /^([\\w$_]+|\\([^)]*?\\))\\s*=>|^function\\s*(?:[\\w$]+)?\\s*\\(/;\n  var fnInvokeRE = /\\([^)]*?\\);*$/;\n  var simplePathRE = /^[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['[^']*?']|\\[\"[^\"]*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*$/;\n\n  // KeyboardEvent.keyCode aliases\n  var 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\n  var 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\n  var genGuard = function (condition) { return (\"if(\" + condition + \")return null;\"); };\n\n  var 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function on (el, dir) {\n    if (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\n  function 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\n  var baseDirectives = {\n    on: on,\n    bind: bind$1,\n    cloak: noop\n  };\n\n  /*  */\n\n\n\n\n\n  var 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\n  function 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\n  function 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\n  function 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\n  function 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        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\n  function 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\n  function 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\n  function 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 (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://Atomjs.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\n  function 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\n  function 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\n  function genInlineTemplate (el, state) {\n    var ast = el.children[0];\n    if (el.children.length !== 1 || ast.type !== 1) {\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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function needsNormalization (el) {\n    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'\n  }\n\n  function 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\n  function 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\n  function genComment (comment) {\n    return (\"_e(\" + (JSON.stringify(comment.text)) + \")\")\n  }\n\n  function 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\n  function 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\n  function 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\n  function 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\n  var 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\n  var unaryOperatorsRE = new RegExp('\\\\b' + (\n    'delete,typeof,void'\n  ).split(',').join('\\\\s*\\\\([^\\\\)]*\\\\)|\\\\b') + '\\\\s*\\\\([^\\\\)]*\\\\)');\n\n  // strip strings in expressions\n  var stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n  // detect problematic expressions in a template\n  function detectErrors (ast, warn) {\n    if (ast) {\n      checkNode(ast, warn);\n    }\n  }\n\n  function 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 (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\n  function checkEvent (exp, text, warn, range) {\n    var stipped = exp.replace(stripStringRE, '');\n    var keywordMatch = stipped.match(unaryOperatorsRE);\n    if (keywordMatch && stipped.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\n  function 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\n  function 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\n  function 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\n  /*  */\n\n  var range = 2;\n\n  function 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\n  function 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\n  function 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\n  function 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      {\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 Atom.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      {\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      {\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\n  function 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 (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        {\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.\n  var 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\n  var ref$1 = createCompiler(baseOptions);\n  var compile = ref$1.compile;\n  var compileToFunctions = ref$1.compileToFunctions;\n\n  /*  */\n\n  // check whether current browser encodes a char inside attribute values\n  var div;\n  function 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\n  var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;\n  // #6828: chrome encodes content in a[href]\n  var shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false;\n\n  /*  */\n\n  var idToTemplate = cached(function (id) {\n    var el = query(id);\n    return el && el.innerHTML\n  });\n\n  var mount = Atom.prototype.$mount;\n  Atom.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      warn(\n        \"Do not mount Atom 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 (!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          {\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 (config.performance && mark) {\n          mark('compile');\n        }\n\n        var ref = compileToFunctions(template, {\n          outputSourceRange: \"development\" !== '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 (config.performance && mark) {\n          mark('compile end');\n          measure((\"Atom \" + (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   */\n  function getOuterHTML (el) {\n    if (el.outerHTML) {\n      return el.outerHTML\n    } else {\n      var container = document.createElement('div');\n      container.appendChild(el.cloneNode(true));\n      return container.innerHTML\n    }\n  }\n\n  Atom.compile = compileToFunctions;\n\n  return Atom;\n\n}));\n"]}