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