text: import Vue from 'vue'
  
  const noopData = () => ({})
  
  // window.onNuxtReady(() => console.log('Ready')) hook
  // Useful for jsdom testing or plugins (https://github.com/tmpvar/jsdom#dealing-with-asynchronous-script-loading)
  if (process.browser) {
    window._nuxtReadyCbs = []
    window.onNuxtReady = function (cb) {
      window._nuxtReadyCbs.push(cb)
    }
  }
  
  export function applyAsyncData(Component, asyncData) {
    const ComponentData = Component.options.data || noopData
    // Prevent calling this method for each request on SSR context
    if (!asyncData && Component.options.hasAsyncData) {
      return
    }
    Component.options.hasAsyncData = true
    Component.options.data = function () {
      const data =  ComponentData.call(this)
      if (this.$ssrContext) {
        asyncData = this.$ssrContext.asyncData[Component.cid]
      }
      return { ...data, ...asyncData }
    }
    if (Component._Ctor && Component._Ctor.options) {
      Component._Ctor.options.data = Component.options.data
    }
  }
  
  export function sanitizeComponent(Component) {
    // If Component already sanitized
    if (Component.options && Component._Ctor === Component) {
      return Component
    }
    if (!Component.options) {
      Component = Vue.extend(Component) // fix issue #6
      Component._Ctor = Component
    } else {
      Component._Ctor = Component
      Component.extendOptions = Component.options
    }
    // For debugging purpose
    if (!Component.options.name && Component.options.__file) {
      Component.options.name = Component.options.__file
    }
    return Component
  }
  
  export function getMatchedComponents(route, matches = false) {
    return [].concat.apply([], route.matched.map(function (m, index) {
      return Object.keys(m.components).map(function (key) {
        matches && matches.push(index)
        return m.components[key]
      })
    }))
  }
  
  export function getMatchedComponentsInstances(route, matches = false) {
    return [].concat.apply([], route.matched.map(function (m, index) {
      return Object.keys(m.instances).map(function (key) {
        matches && matches.push(index)
        return m.instances[key]
      })
    }))
  }
  
  export function flatMapComponents(route, fn) {
    return Array.prototype.concat.apply([], route.matched.map(function (m, index) {
      return Object.keys(m.components).map(function (key) {
        return fn(m.components[key], m.instances[key], m, key, index)
      })
    }))
  }
  
  export function resolveRouteComponents(route) {
    return Promise.all(
      flatMapComponents(route, async (Component, _, match, key) => {
        // If component is a function, resolve it
        if (typeof Component === 'function' && !Component.options) {
          Component = await Component()
        }
        return match.components[key] = sanitizeComponent(Component)
      })
    )
  }
  
  export async function getRouteData(route) {
    // Make sure the components are resolved (code-splitting)
    await resolveRouteComponents(route)
    // Send back a copy of route with meta based on Component definition
    return {
      ...route,
      meta: getMatchedComponents(route).map((Component) => {
        return Component.options.meta || {}
      })
    }
  }
  
  export async function setContext(app, context) {
    const route = (context.to ? context.to : context.route)
    // If context not defined, create it
    if (!app.context) {
      app.context = {
        get isServer() {
          console.warn('context.isServer has been deprecated, please use process.server instead.')
          return process.server
        },
        get isClient() {
          console.warn('context.isClient has been deprecated, please use process.client instead.')
          return process.client
        },
        isStatic: process.static,
        isDev: false,
        isHMR: false,
        app,
        store: app.store,
        payload: context.payload,
        error: context.error,
        base: '/',
        env: {}
      }
      // Only set once
      if (context.req) app.context.req = context.req
      if (context.res) app.context.res = context.res
      app.context.redirect = function (status, path, query) {
        if (!status) return
        app.context._redirected = true // Used in middleware
        // if only 1 or 2 arguments: redirect('/') or redirect('/', { foo: 'bar' })
        let pathType = typeof path
        if (typeof status !== 'number' && (pathType === 'undefined' || pathType === 'object')) {
          query = path || {}
          path = status
          pathType = typeof path
          status = 302
        }
        if (pathType === 'object') {
          path = app.router.resolve(path).href
        }
        // "/absolute/route", "./relative/route" or "../relative/route"
        if (/(^[.]{1,2}\/)|(^\/(?!\/))/.test(path)) {
          app.context.next({
            path: path,
            query: query,
            status: status
          })
        } else {
          path = formatUrl(path, query)
          if (process.server) {
            app.context.next({
              path: path,
              status: status
            })
          }
          if (process.client) {
            // https://developer.mozilla.org/en-US/docs/Web/API/Location/replace
            window.location.replace(path)
  
            // Throw a redirect error
            throw new Error('ERR_REDIRECT')
          }
        }
      }
      if (process.server) app.context.beforeNuxtRender = (fn) => context.beforeRenderFns.push(fn)
      if (process.client) app.context.nuxtState = window.__NUXT__
    }
    // Dynamic keys
    app.context.next = context.next
    app.context._redirected = false
    app.context._errored = false
    app.context.isHMR = !!context.isHMR
    if (context.route) app.context.route = await getRouteData(context.route)
    app.context.params = app.context.route.params || {}
    app.context.query = app.context.route.query || {}
    if (context.from) app.context.from = await getRouteData(context.from)
  }
  
  export function middlewareSeries(promises, appContext) {
    if (!promises.length || appContext._redirected || appContext._errored) {
      return Promise.resolve()
    }
    return promisify(promises[0], appContext)
    .then(() => {
      return middlewareSeries(promises.slice(1), appContext)
    })
  }
  
  export function promisify(fn, context) {
    let promise
    if (fn.length === 2) {
      // fn(context, callback)
      promise = new Promise((resolve) => {
        fn(context, function (err, data) {
          if (err) {
            context.error(err)
          }
          data = data || {}
          resolve(data)
        })
      })
    } else {
      promise = fn(context)
    }
    if (!promise || (!(promise instanceof Promise) && (typeof promise.then !== 'function'))) {
      promise = Promise.resolve(promise)
    }
    return promise
  }
  
  // Imported from vue-router
  export function getLocation(base, mode) {
    var path = window.location.pathname
    if (mode === 'hash') {
      return window.location.hash.replace(/^#\//, '')
    }
    if (base && path.indexOf(base) === 0) {
      path = path.slice(base.length)
    }
    return (path || '/') + window.location.search + window.location.hash
  }
  
  export function urlJoin() {
    return [].slice.call(arguments).join('/').replace(/\/+/g, '/')
  }
  
  // Imported from path-to-regexp
  
  /**
   * Compile a string to a template function for the path.
   *
   * @param  {string}             str
   * @param  {Object=}            options
   * @return {!function(Object=, Object=)}
   */
  export function compile(str, options) {
    return tokensToFunction(parse(str, options))
  }
  
  export function getQueryDiff(toQuery, fromQuery) {
    const diff = {}
    const queries = { ...toQuery, ...fromQuery }
    for (const k in queries) {
      if (String(toQuery[k]) !== String(fromQuery[k])) {
        diff[k] = true
      }
    }
    return diff
  }
  
  /**
   * The main path matching regexp utility.
   *
   * @type {RegExp}
   */
  const PATH_REGEXP = new RegExp([
    // Match escaped characters that would otherwise appear in future matches.
    // This allows the user to escape special characters that won't transform.
    '(\\\\.)',
    // Match Express-style parameters and un-named parameters with a prefix
    // and optional suffixes. Matches appear as:
    //
    // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]
    // "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined, undefined]
    // "/*"            => ["/", undefined, undefined, undefined, undefined, "*"]
    '([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))'
  ].join('|'), 'g')
  
  /**
   * Parse a string for the raw tokens.
   *
   * @param  {string}  str
   * @param  {Object=} options
   * @return {!Array}
   */
  function parse(str, options) {
    var tokens = []
    var key = 0
    var index = 0
    var path = ''
    var defaultDelimiter = options && options.delimiter || '/'
    var res
  
    while ((res = PATH_REGEXP.exec(str)) != null) {
      var m = res[0]
      var escaped = res[1]
      var offset = res.index
      path += str.slice(index, offset)
      index = offset + m.length
  
      // Ignore already escaped sequences.
      if (escaped) {
        path += escaped[1]
        continue
      }
  
      var next = str[index]
      var prefix = res[2]
      var name = res[3]
      var capture = res[4]
      var group = res[5]
      var modifier = res[6]
      var asterisk = res[7]
  
      // Push the current path onto the tokens.
      if (path) {
        tokens.push(path)
        path = ''
      }
  
      var partial = prefix != null && next != null && next !== prefix
      var repeat = modifier === '+' || modifier === '*'
      var optional = modifier === '?' || modifier === '*'
      var delimiter = res[2] || defaultDelimiter
      var pattern = capture || group
  
      tokens.push({
        name: name || key++,
        prefix: prefix || '',
        delimiter: delimiter,
        optional: optional,
        repeat: repeat,
        partial: partial,
        asterisk: !!asterisk,
        pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')
      })
    }
  
    // Match any characters still remaining.
    if (index < str.length) {
      path += str.substr(index)
    }
  
    // If the path exists, push it onto the end.
    if (path) {
      tokens.push(path)
    }
  
    return tokens
  }
  
  /**
   * Prettier encoding of URI path segments.
   *
   * @param  {string}
   * @return {string}
   */
  function encodeURIComponentPretty(str) {
    return encodeURI(str).replace(/[\/?#]/g, function (c) {
      return '%' + c.charCodeAt(0).toString(16).toUpperCase()
    })
  }
  
  /**
   * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.
   *
   * @param  {string}
   * @return {string}
   */
  function encodeAsterisk(str) {
    return encodeURI(str).replace(/[?#]/g, function (c) {
      return '%' + c.charCodeAt(0).toString(16).toUpperCase()
    })
  }
  
  /**
   * Expose a method for transforming tokens into the path function.
   */
  function tokensToFunction(tokens) {
    // Compile all the tokens into regexps.
    var matches = new Array(tokens.length)
  
    // Compile all the patterns before compilation.
    for (var i = 0; i < tokens.length; i++) {
      if (typeof tokens[i] === 'object') {
        matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$')
      }
    }
  
    return function(obj, opts) {
      var path = ''
      var data = obj || {}
      var options = opts || {}
      var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent
  
      for (var i = 0; i < tokens.length; i++) {
        var token = tokens[i]
  
        if (typeof token === 'string') {
          path += token
  
          continue
        }
  
        var value = data[token.name]
        var segment
  
        if (value == null) {
          if (token.optional) {
            // Prepend partial segment prefixes.
            if (token.partial) {
              path += token.prefix
            }
  
            continue
          } else {
            throw new TypeError('Expected "' + token.name + '" to be defined')
          }
        }
  
        if (Array.isArray(value)) {
          if (!token.repeat) {
            throw new TypeError('Expected "' + token.name + '" to not repeat, but received `' + JSON.stringify(value) + '`')
          }
  
          if (value.length === 0) {
            if (token.optional) {
              continue
            } else {
              throw new TypeError('Expected "' + token.name + '" to not be empty')
            }
          }
  
          for (var j = 0; j < value.length; j++) {
            segment = encode(value[j])
  
            if (!matches[i].test(segment)) {
              throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + JSON.stringify(segment) + '`')
            }
  
            path += (j === 0 ? token.prefix : token.delimiter) + segment
          }
  
          continue
        }
  
        segment = token.asterisk ? encodeAsterisk(value) : encode(value)
  
        if (!matches[i].test(segment)) {
          throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"')
        }
  
        path += token.prefix + segment
      }
  
      return path
    }
  }
  
  /**
   * Escape a regular expression string.
   *
   * @param  {string} str
   * @return {string}
   */
  function escapeString(str) {
    return str.replace(/([.+*?=^!:()[\]|\/\\])/g, '\\$1')
  }
  
  /**
   * Escape the capturing group by escaping special characters and meaning.
   *
   * @param  {string} group
   * @return {string}
   */
  function escapeGroup(group) {
    return group.replace(/([=!:$\/()])/g, '\\$1')
  }
  
  /**
   * Format given url, append query to url query string
   *
   * @param  {string} url
   * @param  {string} query
   * @return {string}
   */
  function formatUrl (url, query) {
    let protocol
    let index = url.indexOf('://')
    if (index !== -1) {
      protocol = url.substring(0, index)
      url = url.substring(index + 3)
    } else if (url.indexOf('//') === 0) {
      url = url.substring(2)
    }
  
    let parts = url.split('/')
    let result = (protocol ? protocol + '://' : '//') + parts.shift()
  
    let path = parts.filter(Boolean).join('/')
    let hash
    parts = path.split('#')
    if (parts.length === 2) {
      path = parts[0]
      hash = parts[1]
    }
  
    result += path ? '/' + path : ''
  
    if (query && JSON.stringify(query) !== '{}') {
      result += (url.split('?').length === 2 ? '&' : '?') + formatQuery(query)
    }
    result += hash ? '#' + hash : ''
  
    return result
  }
  
  /**
   * Transform data object to query string
   *
   * @param  {object} query
   * @return {string}
   */
  function formatQuery (query) {
    return Object.keys(query).sort().map(key => {
      var val = query[key]
      if (val == null) {
        return ''
      }
      if (Array.isArray(val)) {
        return val.slice().map(val2 => [key, '=', val2].join('')).join('&')
      }
      return key + '=' + val
    }).filter(Boolean).join('&')
  }
  