ignore .nuxt

.nuxt/App.js

@@ -1,102 +0,0 @@
-import Vue from 'vue'
-import NuxtLoading from './components/nuxt-loading.vue'
-
-import '../node_modules/element-ui/lib/theme-chalk/index.css'
-
-import '../static/css/main.css'
-
-import _6f6c098b from '../layouts/default.vue'
-
-const layouts = { "_default": _6f6c098b }
-
-export default {
-  head: {"title":"boss","meta":[{"charset":"utf-8"},{"name":"viewport","content":"width=device-width, initial-scale=1"},{"hid":"description","name":"description","content":"boss ssr ver"}],"link":[{"rel":"icon","type":"image\u002Fx-icon","href":"\u002Ffavicon.ico"}],"style":[],"script":[]},
-
-  render(h, props) {
-    const loadingEl = h('nuxt-loading', { ref: 'loading' })
-    const layoutEl = h(this.layout || 'nuxt')
-    const templateEl = h('div', {
-      domProps: {
-        id: '__layout'
-      },
-      key: this.layoutName
-    }, [ layoutEl ])
-
-    const transitionEl = h('transition', {
-      props: {
-        name: 'layout',
-        mode: 'out-in'
-      },
-      on: {
-        beforeEnter(el) {
-          // Ensure to trigger scroll event after calling scrollBehavior
-          window.$nuxt.$nextTick(() => {
-            window.$nuxt.$emit('triggerScroll')
-          })
-        }
-      }
-    }, [ templateEl ])
-
-    return h('div', {
-      domProps: {
-        id: '__nuxt'
-      }
-    }, [
-      loadingEl,
-      transitionEl
-    ])
-  },
-  data: () => ({
-    layout: null,
-    layoutName: ''
-  }),
-  beforeCreate() {
-    Vue.util.defineReactive(this, 'nuxt', this.$options.nuxt)
-  },
-  created() {
-    // Add this.$nuxt in child instances
-    Vue.prototype.$nuxt = this
-    // add to window so we can listen when ready
-    if (typeof window !== 'undefined') {
-      window.$nuxt = this
-    }
-    // Add $nuxt.error()
-    this.error = this.nuxt.error
-  },
-
-  mounted() {
-    this.$loading = this.$refs.loading
-  },
-  watch: {
-    'nuxt.err': 'errorChanged'
-  },
-
-  methods: {
-    errorChanged() {
-      if (this.nuxt.err && this.$loading) {
-        if (this.$loading.fail) this.$loading.fail()
-        if (this.$loading.finish) this.$loading.finish()
-      }
-    },
-
-    setLayout(layout) {
-      if(layout && typeof layout !== 'string') throw new Error('[nuxt] Avoid using non-string value as layout property.')
-
-      if (!layout || !layouts['_' + layout]) {
-        layout = 'default'
-      }
-      this.layoutName = layout
-      this.layout = layouts['_' + layout]
-      return this.layout
-    },
-    loadLayout(layout) {
-      if (!layout || !layouts['_' + layout]) {
-        layout = 'default'
-      }
-      return Promise.resolve(layouts['_' + layout])
-    }
-  },
-  components: {
-    NuxtLoading
-  }
-}

.nuxt/axios.js

@@ -1,157 +0,0 @@
-import Axios from 'axios'
-
-// Axios.prototype cannot be modified
-const axiosExtra = {
-  setHeader (name, value, scopes = 'common') {
-    for (let scope of Array.isArray(scopes) ? scopes : [ scopes ]) {
-      if (!value) {
-        delete this.defaults.headers[scope][name];
-        return
-      }
-      this.defaults.headers[scope][name] = value
-    }
-  },
-  setToken (token, type, scopes = 'common') {
-    const value = !token ? null : (type ? type + ' ' : '') + token
-    this.setHeader('Authorization', value, scopes)
-  },
-  onRequest(fn) {
-    this.interceptors.request.use(config => fn(config) || config)
-  },
-  onResponse(fn) {
-    this.interceptors.response.use(response => fn(response) || response)
-  },
-  onRequestError(fn) {
-    this.interceptors.request.use(undefined, error => fn(error) || Promise.reject(error))
-  },
-  onResponseError(fn) {
-    this.interceptors.response.use(undefined, error => fn(error) || Promise.reject(error))
-  },
-  onError(fn) {
-    this.onRequestError(fn)
-    this.onResponseError(fn)
-  }
-}
-
-// Request helpers ($get, $post, ...)
-for (let method of ['request', 'delete', 'get', 'head', 'options', 'post', 'put', 'patch']) {
-  axiosExtra['$' + method] = function () { return this[method].apply(this, arguments).then(res => res && res.data) }
-}
-
-const extendAxiosInstance = axios => {
-  for (let key in axiosExtra) {
-    axios[key] = axiosExtra[key].bind(axios)
-  }
-}
-
-const setupProgress = (axios, ctx) => {
-  if (process.server) {
-    return
-  }
-
-  // A noop loading inteterface for when $nuxt is not yet ready
-  const noopLoading = {
-    finish: () => { },
-    start: () => { },
-    fail: () => { },
-    set: () => { }
-  }
-
-  const $loading = () => (window.$nuxt && window.$nuxt.$loading && window.$nuxt.$loading.set) ? window.$nuxt.$loading : noopLoading
-
-  let currentRequests = 0
-
-  axios.onRequest(config => {
-    if (config && config.progress === false) {
-      return
-    }
-
-    currentRequests++
-  })
-
-  axios.onResponse(response => {
-    if (response && response.config && response.config.progress === false) {
-      return
-    }
-
-    currentRequests--
-    if (currentRequests <= 0) {
-      currentRequests = 0
-      $loading().finish()
-    }
-  })
-
-  axios.onError(error => {
-    if (error && error.config && error.config.progress === false) {
-      return
-    }
-
-    currentRequests--
-    $loading().fail()
-    $loading().finish()
-  })
-
-  const onProgress = e => {
-    if (!currentRequests) {
-      return
-    }
-    const progress = ((e.loaded * 100) / (e.total * currentRequests))
-    $loading().set(Math.min(100, progress))
-  }
-
-  axios.defaults.onUploadProgress = onProgress
-  axios.defaults.onDownloadProgress = onProgress
-}
-
-export default (ctx, inject) => {
-  // baseURL
-  const baseURL = process.browser
-      ? 'http://localhost:3000/'
-      : (process.env._AXIOS_BASE_URL_ || 'http://localhost:3000/')
-
-  // Create fresh objects for all default header scopes
-  // Axios creates only one which is shared across SSR requests!
-  // https://github.com/mzabriskie/axios/blob/master/lib/defaults.js
-  const headers = {
-    common : {
-      'Accept': 'application/json, text/plain, */*'
-    },
-    delete: {},
-    get: {},
-    head: {},
-    post: {},
-    put: {},
-    patch: {}
-  }
-
-  const axiosOptions = {
-    baseURL,
-    headers
-  }
-
-  // Proxy SSR request headers headers
-  axiosOptions.headers.common = (ctx.req && ctx.req.headers) ? Object.assign({}, ctx.req.headers) : {}
-  delete axiosOptions.headers.common['accept']
-  delete axiosOptions.headers.common['host']
-  delete axiosOptions.headers.common['cf-ray']
-  delete axiosOptions.headers.common['cf-connecting-ip']
-
-  if (process.server) {
-    // Don't accept brotli encoding because Node can't parse it
-    axiosOptions.headers.common['Accept-Encoding'] = 'gzip, deflate'
-  }
-
-  // Create new axios instance
-  const axios = Axios.create(axiosOptions)
-
-  // Extend axios proto
-  extendAxiosInstance(axios)
-
-  // Setup interceptors
-
-  setupProgress(axios, ctx)
-
-  // Inject axios to the context as $axios
-  ctx.$axios = axios
-  inject('axios', axios)
-}

.nuxt/client.js

@@ -1,654 +0,0 @@
-import Vue from 'vue'
-import middleware from './middleware'
-import {
-  applyAsyncData,
-  sanitizeComponent,
-  resolveRouteComponents,
-  getMatchedComponents,
-  getMatchedComponentsInstances,
-  flatMapComponents,
-  setContext,
-  middlewareSeries,
-  promisify,
-  getLocation,
-  compile,
-  getQueryDiff,
-  globalHandleError
-} from './utils'
-import { createApp, NuxtError } from './index'
-
-const noopData = () => { return {} }
-const noopFetch = () => {}
-
-// Global shared references
-let _lastPaths = []
-let app
-let router
-
-// Try to rehydrate SSR data from window
-const NUXT = window.__NUXT__ || {}
-
-Object.assign(Vue.config, {"silent":false,"performance":true})
-
-// Setup global Vue error handler
-if (!Vue.config.$nuxt) {
-  const defaultErrorHandler = Vue.config.errorHandler
-  Vue.config.errorHandler = (err, vm, info, ...rest) => {
-    // Call other handler if exist
-    let handled = null
-    if (typeof defaultErrorHandler === 'function') {
-      handled = defaultErrorHandler(err, vm, info, ...rest)
-    }
-    if (handled === true) {
-      return handled
-    }
-
-    if (vm && vm.$root) {
-      const nuxtApp = Object.keys(Vue.config.$nuxt)
-        .find(nuxtInstance => vm.$root[nuxtInstance])
-
-      // Show Nuxt Error Page
-      if (nuxtApp && vm.$root[nuxtApp].error && info !== 'render function') {
-        vm.$root[nuxtApp].error(err)
-      }
-    }
-
-    if (typeof defaultErrorHandler === 'function') {
-      return handled
-    }
-
-    // Log to console
-    if (process.env.NODE_ENV !== 'production') {
-      console.error(err)
-    } else {
-      console.error(err.message || err)
-    }
-  }
-  Vue.config.$nuxt = {}
-}
-Vue.config.$nuxt.$nuxt = true
-
-// Create and mount App
-createApp()
-  .then(mountApp)
-  .catch((err) => {
-    console.error('[nuxt] Error while initializing app', err)
-  })
-
-function componentOption(component, key, ...args) {
-  if (!component || !component.options || !component.options[key]) {
-    return {}
-  }
-  const option = component.options[key]
-  if (typeof option === 'function') {
-    return option(...args)
-  }
-  return option
-}
-
-function mapTransitions(Components, to, from) {
-  const componentTransitions = (component) => {
-    const transition = componentOption(component, 'transition', to, from) || {}
-    return (typeof transition === 'string' ? { name: transition } : transition)
-  }
-
-  return Components.map((Component) => {
-    // Clone original object to prevent overrides
-    const transitions = Object.assign({}, componentTransitions(Component))
-
-    // Combine transitions & prefer `leave` transitions of 'from' route
-    if (from && from.matched.length && from.matched[0].components.default) {
-      const fromTransitions = componentTransitions(from.matched[0].components.default)
-      Object.keys(fromTransitions)
-        .filter(key => fromTransitions[key] && key.toLowerCase().includes('leave'))
-        .forEach((key) => { transitions[key] = fromTransitions[key] })
-    }
-
-    return transitions
-  })
-}
-
-async function loadAsyncComponents(to, from, next) {
-  // Check if route path changed (this._pathChanged), only if the page is not an error (for validate())
-  this._pathChanged = !!app.nuxt.err || from.path !== to.path
-  this._queryChanged = JSON.stringify(to.query) !== JSON.stringify(from.query)
-  this._diffQuery = (this._queryChanged ? getQueryDiff(to.query, from.query) : [])
-
-  if (this._pathChanged && this.$loading.start && !this.$loading.manual) {
-    this.$loading.start()
-  }
-
-  try {
-    const Components = await resolveRouteComponents(to)
-
-    if (!this._pathChanged && this._queryChanged) {
-      // Add a marker on each component that it needs to refresh or not
-      const startLoader = Components.some((Component) => {
-        const watchQuery = Component.options.watchQuery
-        if (watchQuery === true) return true
-        if (Array.isArray(watchQuery)) {
-          return watchQuery.some(key => this._diffQuery[key])
-        }
-        return false
-      })
-      if (startLoader && this.$loading.start && !this.$loading.manual) {
-        this.$loading.start()
-      }
-    }
-
-    // Call next()
-    next()
-  } catch (err) {
-    this.error(err)
-    this.$nuxt.$emit('routeChanged', to, from, error)
-    next(false)
-  }
-}
-
-function applySSRData(Component, ssrData) {
-  if (NUXT.serverRendered && ssrData) {
-    applyAsyncData(Component, ssrData)
-  }
-  Component._Ctor = Component
-  return Component
-}
-
-// Get matched components
-function resolveComponents(router) {
-  const path = getLocation(router.options.base, router.options.mode)
-
-  return flatMapComponents(router.match(path), async (Component, _, match, key, index) => {
-    // If component is not resolved yet, resolve it
-    if (typeof Component === 'function' && !Component.options) {
-      Component = await Component()
-    }
-    // Sanitize it and save it
-    const _Component = applySSRData(sanitizeComponent(Component), NUXT.data ? NUXT.data[index] : null)
-    match.components[key] = _Component
-    return _Component
-  })
-}
-
-function callMiddleware(Components, context, layout) {
-  let midd = []
-  let unknownMiddleware = false
-
-  // If layout is undefined, only call global middleware
-  if (typeof layout !== 'undefined') {
-    midd = [] // Exclude global middleware if layout defined (already called before)
-    if (layout.middleware) {
-      midd = midd.concat(layout.middleware)
-    }
-    Components.forEach((Component) => {
-      if (Component.options.middleware) {
-        midd = midd.concat(Component.options.middleware)
-      }
-    })
-  }
-
-  midd = midd.map((name) => {
-    if (typeof name === 'function') return name
-    if (typeof middleware[name] !== 'function') {
-      unknownMiddleware = true
-      this.error({ statusCode: 500, message: 'Unknown middleware ' + name })
-    }
-    return middleware[name]
-  })
-
-  if (unknownMiddleware) return
-  return middlewareSeries(midd, context)
-}
-
-async function render(to, from, next) {
-  if (this._pathChanged === false && this._queryChanged === false) return next()
-  // Handle first render on SPA mode
-  if (to === from) _lastPaths = []
-  else {
-    const fromMatches = []
-    _lastPaths = getMatchedComponents(from, fromMatches).map((Component, i) => {
-      return compile(from.matched[fromMatches[i]].path)(from.params)
-    })
-  }
-
-  // nextCalled is true when redirected
-  let nextCalled = false
-  const _next = (path) => {
-    if (from.path === path.path && this.$loading.finish) {
-      this.$loading.finish()
-    }
-
-    if (from.path !== path.path && this.$loading.pause) {
-      this.$loading.pause()
-    }
-
-    if (nextCalled) return
-    nextCalled = true
-    next(path)
-  }
-
-  // Update context
-  await setContext(app, {
-    route: to,
-    from,
-    next: _next.bind(this)
-  })
-  this._dateLastError = app.nuxt.dateErr
-  this._hadError = !!app.nuxt.err
-
-  // Get route's matched components
-  const matches = []
-  const Components = getMatchedComponents(to, matches)
-
-  // If no Components matched, generate 404
-  if (!Components.length) {
-    // Default layout
-    await callMiddleware.call(this, Components, app.context)
-    if (nextCalled) return
-    // Load layout for error page
-    const layout = await this.loadLayout(
-      typeof NuxtError.layout === 'function'
-        ? NuxtError.layout(app.context)
-        : NuxtError.layout
-    )
-    await callMiddleware.call(this, Components, app.context, layout)
-    if (nextCalled) return
-    // Show error page
-    app.context.error({ statusCode: 404, message: `This page could not be found` })
-    return next()
-  }
-
-  // Update ._data and other properties if hot reloaded
-  Components.forEach((Component) => {
-    if (Component._Ctor && Component._Ctor.options) {
-      Component.options.asyncData = Component._Ctor.options.asyncData
-      Component.options.fetch = Component._Ctor.options.fetch
-    }
-  })
-
-  // Apply transitions
-  this.setTransitions(mapTransitions(Components, to, from))
-
-  try {
-    // Call middleware
-    await callMiddleware.call(this, Components, app.context)
-    if (nextCalled) return
-    if (app.context._errored) return next()
-
-    // Set layout
-    let layout = Components[0].options.layout
-    if (typeof layout === 'function') {
-      layout = layout(app.context)
-    }
-    layout = await this.loadLayout(layout)
-
-    // Call middleware for layout
-    await callMiddleware.call(this, Components, app.context, layout)
-    if (nextCalled) return
-    if (app.context._errored) return next()
-
-    // Call .validate()
-    let isValid = true
-    try {
-      for (const Component of Components) {
-        if (typeof Component.options.validate !== 'function') {
-          continue
-        }
-
-        isValid = await Component.options.validate(app.context)
-
-        if (!isValid) {
-          break
-        }
-      }
-    } catch (validationError) {
-      // ...If .validate() threw an error
-      this.error({
-        statusCode: validationError.statusCode || '500',
-        message: validationError.message
-      })
-      return next()
-    }
-
-    // ...If .validate() returned false
-    if (!isValid) {
-      this.error({ statusCode: 404, message: `This page could not be found` })
-      return next()
-    }
-
-    // Call asyncData & fetch hooks on components matched by the route.
-    await Promise.all(Components.map((Component, i) => {
-      // Check if only children route changed
-      Component._path = compile(to.matched[matches[i]].path)(to.params)
-      Component._dataRefresh = false
-      // Check if Component need to be refreshed (call asyncData & fetch)
-      // Only if its slug has changed or is watch query changes
-      if ((this._pathChanged && this._queryChanged) || Component._path !== _lastPaths[i]) {
-        Component._dataRefresh = true
-      } else if (!this._pathChanged && this._queryChanged) {
-        const watchQuery = Component.options.watchQuery
-        if (watchQuery === true) {
-          Component._dataRefresh = true
-        } else if (Array.isArray(watchQuery)) {
-          Component._dataRefresh = watchQuery.some(key => this._diffQuery[key])
-        }
-      }
-      if (!this._hadError && this._isMounted && !Component._dataRefresh) {
-        return Promise.resolve()
-      }
-
-      const promises = []
-
-      const hasAsyncData = (
-        Component.options.asyncData &&
-        typeof Component.options.asyncData === 'function'
-      )
-      const hasFetch = !!Component.options.fetch
-
-      const loadingIncrease = (hasAsyncData && hasFetch) ? 30 : 45
-
-      // Call asyncData(context)
-      if (hasAsyncData) {
-        const promise = promisify(Component.options.asyncData, app.context)
-          .then((asyncDataResult) => {
-            applyAsyncData(Component, asyncDataResult)
-
-            if (this.$loading.increase) {
-              this.$loading.increase(loadingIncrease)
-            }
-          })
-        promises.push(promise)
-      }
-
-      // Check disabled page loading
-      this.$loading.manual = Component.options.loading === false
-
-      // Call fetch(context)
-      if (hasFetch) {
-        let p = Component.options.fetch(app.context)
-        if (!p || (!(p instanceof Promise) && (typeof p.then !== 'function'))) {
-          p = Promise.resolve(p)
-        }
-        p.then((fetchResult) => {
-          if (this.$loading.increase) {
-            this.$loading.increase(loadingIncrease)
-          }
-        })
-        promises.push(p)
-      }
-
-      return Promise.all(promises)
-    }))
-
-    // If not redirected
-    if (!nextCalled) {
-      if (this.$loading.finish && !this.$loading.manual) {
-        this.$loading.finish()
-      }
-
-      next()
-    }
-  } catch (err) {
-    const error = err || {}
-    if (error.message === 'ERR_REDIRECT') {
-      return this.$nuxt.$emit('routeChanged', to, from, error)
-    }
-    _lastPaths = []
-
-    globalHandleError(error)
-
-    // Load error layout
-    let layout = NuxtError.layout
-    if (typeof layout === 'function') {
-      layout = layout(app.context)
-    }
-    await this.loadLayout(layout)
-
-    this.error(error)
-    this.$nuxt.$emit('routeChanged', to, from, error)
-    next(false)
-  }
-}
-
-// Fix components format in matched, it's due to code-splitting of vue-router
-function normalizeComponents(to, ___) {
-  flatMapComponents(to, (Component, _, match, key) => {
-    if (typeof Component === 'object' && !Component.options) {
-      // Updated via vue-router resolveAsyncComponents()
-      Component = Vue.extend(Component)
-      Component._Ctor = Component
-      match.components[key] = Component
-    }
-    return Component
-  })
-}
-
-function showNextPage(to) {
-  // Hide error component if no error
-  if (this._hadError && this._dateLastError === this.$options.nuxt.dateErr) {
-    this.error()
-  }
-
-  // Set layout
-  let layout = this.$options.nuxt.err
-    ? NuxtError.layout
-    : to.matched[0].components.default.options.layout
-
-  if (typeof layout === 'function') {
-    layout = layout(app.context)
-  }
-  this.setLayout(layout)
-}
-
-// When navigating on a different route but the same component is used, Vue.js
-// Will not update the instance data, so we have to update $data ourselves
-function fixPrepatch(to, ___) {
-  if (this._pathChanged === false && this._queryChanged === false) return
-
-  Vue.nextTick(() => {
-    const matches = []
-    const instances = getMatchedComponentsInstances(to, matches)
-    const Components = getMatchedComponents(to, matches)
-
-    instances.forEach((instance, i) => {
-      if (!instance) return
-      // if (
-      //   !this._queryChanged &&
-      //   to.matched[matches[i]].path.indexOf(':') === -1 &&
-      //   to.matched[matches[i]].path.indexOf('*') === -1
-      // ) return // If not a dynamic route, skip
-      if (
-        instance.constructor._dataRefresh &&
-        Components[i] === instance.constructor &&
-        typeof instance.constructor.options.data === 'function'
-      ) {
-        const newData = instance.constructor.options.data.call(instance)
-        for (const key in newData) {
-          Vue.set(instance.$data, key, newData[key])
-        }
-      }
-    })
-    showNextPage.call(this, to)
-
-    // Hot reloading
-    setTimeout(() => hotReloadAPI(this), 100)
-  })
-}
-
-function nuxtReady(_app) {
-  window.onNuxtReadyCbs.forEach((cb) => {
-    if (typeof cb === 'function') {
-      cb(_app)
-    }
-  })
-  // Special JSDOM
-  if (typeof window._onNuxtLoaded === 'function') {
-    window._onNuxtLoaded(_app)
-  }
-  // Add router hooks
-  router.afterEach((to, from) => {
-    // Wait for fixPrepatch + $data updates
-    Vue.nextTick(() => _app.$nuxt.$emit('routeChanged', to, from))
-  })
-}
-
-// Special hot reload with asyncData(context)
-function getNuxtChildComponents($parent, $components = []) {
-  $parent.$children.forEach(($child) => {
-    if ($child.$vnode.data.nuxtChild && !$components.find(c =>(c.$options.__file === $child.$options.__file))) {
-      $components.push($child)
-    }
-    if ($child.$children && $child.$children.length) {
-      getNuxtChildComponents($child, $components)
-    }
-  })
-
-  return $components
-}
-
-function hotReloadAPI(_app) {
-  if (!module.hot) return
-
-  let $components = getNuxtChildComponents(_app.$nuxt, [])
-
-  $components.forEach(addHotReload.bind(_app))
-}
-
-function addHotReload($component, depth) {
-  if ($component.$vnode.data._hasHotReload) return
-  $component.$vnode.data._hasHotReload = true
-
-  var _forceUpdate = $component.$forceUpdate.bind($component.$parent)
-
-  $component.$vnode.context.$forceUpdate = async () => {
-    let Components = getMatchedComponents(router.currentRoute)
-    let Component = Components[depth]
-    if (!Component) return _forceUpdate()
-    if (typeof Component === 'object' && !Component.options) {
-      // Updated via vue-router resolveAsyncComponents()
-      Component = Vue.extend(Component)
-      Component._Ctor = Component
-    }
-    this.error()
-    let promises = []
-    const next = function (path) {
-      this.$loading.finish && this.$loading.finish()
-      router.push(path)
-    }
-    await setContext(app, {
-      route: router.currentRoute,
-      isHMR: true,
-      next: next.bind(this)
-    })
-    const context = app.context
-
-    if (this.$loading.start && !this.$loading.manual) this.$loading.start()
-
-    callMiddleware.call(this, Components, context)
-    .then(() => {
-      // If layout changed
-      if (depth !== 0) return Promise.resolve()
-      let layout = Component.options.layout || 'default'
-      if (typeof layout === 'function') {
-        layout = layout(context)
-      }
-      if (this.layoutName === layout) return Promise.resolve()
-      let promise = this.loadLayout(layout)
-      promise.then(() => {
-        this.setLayout(layout)
-        Vue.nextTick(() => hotReloadAPI(this))
-      })
-      return promise
-    })
-    .then(() => {
-      return callMiddleware.call(this, Components, context, this.layout)
-    })
-    .then(() => {
-      // Call asyncData(context)
-      let pAsyncData = promisify(Component.options.asyncData || noopData, context)
-      pAsyncData.then((asyncDataResult) => {
-        applyAsyncData(Component, asyncDataResult)
-        this.$loading.increase && this.$loading.increase(30)
-      })
-      promises.push(pAsyncData)
-      // Call fetch()
-      Component.options.fetch = Component.options.fetch || noopFetch
-      let pFetch = Component.options.fetch(context)
-      if (!pFetch || (!(pFetch instanceof Promise) && (typeof pFetch.then !== 'function'))) { pFetch = Promise.resolve(pFetch) }
-      pFetch.then(() => this.$loading.increase && this.$loading.increase(30))
-      promises.push(pFetch)
-      return Promise.all(promises)
-    })
-    .then(() => {
-      this.$loading.finish && this.$loading.finish()
-      _forceUpdate()
-      setTimeout(() => hotReloadAPI(this), 100)
-    })
-  }
-}
-
-async function mountApp(__app) {
-  // Set global variables
-  app = __app.app
-  router = __app.router
-
-  // Resolve route components
-  const Components = await Promise.all(resolveComponents(router))
-
-  // Create Vue instance
-  const _app = new Vue(app)
-
-  // Mounts Vue app to DOM element
-  const mount = () => {
-    _app.$mount('#__nuxt')
-
-    // Listen for first Vue update
-    Vue.nextTick(() => {
-      // Call window.{{globals.readyCallback}} callbacks
-      nuxtReady(_app)
-
-      // Enable hot reloading
-      hotReloadAPI(_app)
-    })
-  }
-
-  // Enable transitions
-  _app.setTransitions = _app.$options.nuxt.setTransitions.bind(_app)
-  if (Components.length) {
-    _app.setTransitions(mapTransitions(Components, router.currentRoute))
-    _lastPaths = router.currentRoute.matched.map(route => compile(route.path)(router.currentRoute.params))
-  }
-
-  // Initialize error handler
-  _app.$loading = {} // To avoid error while _app.$nuxt does not exist
-  if (NUXT.error) _app.error(NUXT.error)
-
-  // Add router hooks
-  router.beforeEach(loadAsyncComponents.bind(_app))
-  router.beforeEach(render.bind(_app))
-  router.afterEach(normalizeComponents)
-  router.afterEach(fixPrepatch.bind(_app))
-
-  // If page already is server rendered
-  if (NUXT.serverRendered) {
-    mount()
-    return
-  }
-
-  // First render on client-side
-  render.call(_app, router.currentRoute, router.currentRoute, (path) => {
-    // If not redirected
-    if (!path) {
-      normalizeComponents(router.currentRoute, router.currentRoute)
-      showNextPage.call(_app, router.currentRoute)
-      // Don't call fixPrepatch.call(_app, router.currentRoute, router.currentRoute) since it's first render
-      mount()
-      return
-    }
-
-    // Push the path and then mount app
-    router.push(path, () => mount(), (err) => {
-      if (!err) return mount()
-      console.error(err)
-    })
-  })
-}

.nuxt/components/no-ssr.js

@@ -1,6 +0,0 @@
-/*
-** From https://github.com/egoist/vue-no-ssr
-** With the authorization of @egoist
-*/
-import NoSSR from 'vue-no-ssr'
-export default NoSSR

.nuxt/components/nuxt-child.js

@@ -1,97 +0,0 @@
-
-export default {
-  name: 'nuxt-child',
-  functional: true,
-  props: {
-    nuxtChildKey: {
-      type: String,
-      default: ''
-    },
-    keepAlive: Boolean
-  },
-  render(h, { parent, data, props }) {
-    data.nuxtChild = true
-    const _parent = parent
-    const transitions = parent.$nuxt.nuxt.transitions
-    const defaultTransition = parent.$nuxt.nuxt.defaultTransition
-
-    let depth = 0
-    while (parent) {
-      if (parent.$vnode && parent.$vnode.data.nuxtChild) {
-        depth++
-      }
-      parent = parent.$parent
-    }
-    data.nuxtChildDepth = depth
-    const transition = transitions[depth] || defaultTransition
-    const transitionProps = {}
-    transitionsKeys.forEach((key) => {
-      if (typeof transition[key] !== 'undefined') {
-        transitionProps[key] = transition[key]
-      }
-    })
-
-    const listeners = {}
-    listenersKeys.forEach((key) => {
-      if (typeof transition[key] === 'function') {
-        listeners[key] = transition[key].bind(_parent)
-      }
-    })
-    // Add triggerScroll event on beforeEnter (fix #1376)
-    const beforeEnter = listeners.beforeEnter
-    listeners.beforeEnter = (el) => {
-      // Ensure to trigger scroll event after calling scrollBehavior
-      window.$nuxt.$nextTick(() => {
-        window.$nuxt.$emit('triggerScroll')
-      })
-      if (beforeEnter) return beforeEnter.call(_parent, el)
-    }
-
-    let routerView = [
-      h('router-view', data)
-    ]
-    if (props.keepAlive) {
-      routerView = [
-        h('keep-alive', { props: props.keepAliveProps }, routerView)
-      ]
-    }
-    return h('transition', {
-      props: transitionProps,
-      on: listeners
-    }, routerView)
-  }
-}
-
-const transitionsKeys = [
-  'name',
-  'mode',
-  'appear',
-  'css',
-  'type',
-  'duration',
-  'enterClass',
-  'leaveClass',
-  'appearClass',
-  'enterActiveClass',
-  'enterActiveClass',
-  'leaveActiveClass',
-  'appearActiveClass',
-  'enterToClass',
-  'leaveToClass',
-  'appearToClass'
-]
-
-const listenersKeys = [
-  'beforeEnter',
-  'enter',
-  'afterEnter',
-  'enterCancelled',
-  'beforeLeave',
-  'leave',
-  'afterLeave',
-  'leaveCancelled',
-  'beforeAppear',
-  'appear',
-  'afterAppear',
-  'appearCancelled'
-]

.nuxt/components/nuxt-error.vue

@@ -1,95 +0,0 @@
-<template>
-  <div class="__nuxt-error-page">
-    <div class="error">
-      <svg xmlns="http://www.w3.org/2000/svg" width="90" height="90" fill="#DBE1EC" viewBox="0 0 48 48"><path d="M22 30h4v4h-4zm0-16h4v12h-4zm1.99-10C12.94 4 4 12.95 4 24s8.94 20 19.99 20S44 35.05 44 24 35.04 4 23.99 4zM24 40c-8.84 0-16-7.16-16-16S15.16 8 24 8s16 7.16 16 16-7.16 16-16 16z" /></svg>
-
-      <div class="title">{{ message }}</div>
-      <p v-if="statusCode === 404" class="description">
-        <nuxt-link class="error-link" to="/">Back to the home page</nuxt-link>
-      </p>
-
-      <p class="description" v-else>An error occurred while rendering the page. Check developer tools console for details.</p>
-
-      <div class="logo">
-        <a href="https://nuxtjs.org" target="_blank" rel="noopener">Nuxt.js</a>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script>
-export default {
-  name: 'nuxt-error',
-  props: {
-    error: {
-      type: Object,
-      default: null
-    }
-  },
-  head() {
-    return {
-      title: this.message,
-      meta: [
-        {
-          name: 'viewport',
-          content: 'width=device-width,initial-scale=1.0,minimum-scale=1.0,maximum-scale=1.0,user-scalable=no'
-        }
-      ]
-    }
-  },
-  computed: {
-    statusCode() {
-      return (this.error && this.error.statusCode) || 500
-    },
-    message() {
-      return this.error.message || `Error`
-    }
-  }
-}
-</script>
-
-<style>
-.__nuxt-error-page {
-  padding: 1rem;
-  background: #F7F8FB;
-  color: #47494E;
-  text-align: center;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  flex-direction: column;
-  font-family: sans-serif;
-  font-weight: 100 !important;
-  -ms-text-size-adjust: 100%;
-  -webkit-text-size-adjust: 100%;
-  -webkit-font-smoothing: antialiased;
-  position: absolute;
-  top: 0;
-  left: 0;
-  right: 0;
-  bottom: 0;
-}
-.__nuxt-error-page .error {
-  max-width: 450px;
-}
-.__nuxt-error-page .title {
-  font-size: 1.5rem;
-  margin-top: 15px;
-  color: #47494E;
-  margin-bottom: 8px;
-}
-.__nuxt-error-page .description {
-  color: #7F828B;
-  line-height: 21px;
-  margin-bottom: 10px;
-}
-.__nuxt-error-page a {
-  color: #7F828B !important;
-  text-decoration: none;
-}
-.__nuxt-error-page .logo {
-  position: fixed;
-  left: 12px;
-  bottom: 12px;
-}
-</style>

.nuxt/components/nuxt-loading.vue

@@ -1,177 +0,0 @@
-<script>
-export default {
-  name: 'nuxt-loading',
-  data() {
-    return {
-      percent: 0,
-      show: false,
-      canSucceed: true,
-      reversed: false,
-      skipTimerCount: 0,
-      rtl: false,
-      throttle: 200,
-      duration: 5000,
-      continuous: false
-    }
-  },
-  computed: {
-    left() {
-      if (!this.continuous && !this.rtl) {
-        return false
-      }
-      return this.rtl
-        ? (this.reversed ? '0px' : 'auto')
-        : (!this.reversed ? '0px' : 'auto')
-    }
-  },
-  beforeDestroy() {
-    this.clear()
-  },
-  methods: {
-    clear() {
-      clearInterval(this._timer)
-      clearTimeout(this._throttle)
-      this._timer = null
-    },
-    start() {
-      this.clear()
-      this.percent = 0
-      this.reversed = false
-      this.skipTimerCount = 0
-      this.canSucceed = true
-
-      if (this.throttle) {
-        this._throttle = setTimeout(() => this.startTimer(), this.throttle)
-      } else {
-        this.startTimer()
-      }
-      return this
-    },
-    set(num) {
-      this.show = true
-      this.canSucceed = true
-      this.percent = Math.min(100, Math.max(0, Math.floor(num)))
-      return this
-    },
-    get() {
-      return this.percent
-    },
-    increase(num) {
-      this.percent = Math.min(100, Math.floor(this.percent + num))
-      return this
-    },
-    decrease(num) {
-      this.percent = Math.max(0, Math.floor(this.percent - num))
-      return this
-    },
-    pause() {
-      clearInterval(this._timer)
-      return this
-    },
-    resume() {
-      this.startTimer()
-      return this
-    },
-    finish() {
-      this.percent = this.reversed ? 0 : 100
-      this.hide()
-      return this
-    },
-    hide() {
-      this.clear()
-      setTimeout(() => {
-        this.show = false
-        this.$nextTick(() => {
-          this.percent = 0
-          this.reversed = false
-        })
-      }, 500)
-      return this
-    },
-    fail() {
-      this.canSucceed = false
-      return this
-    },
-    startTimer() {
-      if (!this.show) {
-        this.show = true
-      }
-      if (typeof this._cut === 'undefined') {
-        this._cut = 10000 / Math.floor(this.duration)
-      }
-
-      this._timer = setInterval(() => {
-        /**
-         * When reversing direction skip one timers
-         * so 0, 100 are displayed for two iterations
-         * also disable css width transitioning
-         * which otherwise interferes and shows
-         * a jojo effect
-         */
-        if (this.skipTimerCount > 0) {
-          this.skipTimerCount--
-          return
-        }
-
-        if (this.reversed) {
-          this.decrease(this._cut)
-        } else {
-          this.increase(this._cut)
-        }
-
-        if (this.continuous) {
-          if (this.percent >= 100) {
-            this.skipTimerCount = 1
-
-            this.reversed = !this.reversed
-          } else if (this.percent <= 0) {
-            this.skipTimerCount = 1
-
-            this.reversed = !this.reversed
-          }
-        }
-      }, 100)
-    }
-  },
-  render(h) {
-    let el = h(false)
-    if (this.show) {
-      el = h('div', {
-        staticClass: 'nuxt-progress',
-        class: {
-          'nuxt-progress-notransition': this.skipTimerCount > 0,
-          'nuxt-progress-failed': !this.canSucceed
-        },
-        style: {
-          'width': this.percent + '%',
-          'left': this.left
-        }
-      })
-    }
-    return el
-  }
-}
-</script>
-
-<style>
-.nuxt-progress {
-  position: fixed;
-  top: 0px;
-  left: 0px;
-  right: 0px;
-  height: 2px;
-  width: 0%;
-  opacity: 1;
-  transition: width 0.1s, opacity 0.4s;
-  background-color: #fff;
-  z-index: 999999;
-}
-
-.nuxt-progress.nuxt-progress-notransition {
-  transition: none;
-}
-
-.nuxt-progress-failed {
-  background-color: red;
-}
-</style>

.nuxt/components/nuxt.js

@@ -1,50 +0,0 @@
-
-import Vue from 'vue'
-import { compile } from '../utils'
-
-import NuxtError from './nuxt-error.vue'
-
-import NuxtChild from './nuxt-child'
-
-export default {
-  name: 'nuxt',
-  props: {
-    nuxtChildKey: String,
-    keepAlive: Boolean
-  },
-  render(h) {
-    // If there is some error
-    if (this.nuxt.err) {
-      return h('nuxt-error', {
-        props: {
-          error: this.nuxt.err
-        }
-      })
-    }
-    // Directly return nuxt child
-    return h('nuxt-child', {
-      key: this.routerViewKey,
-      props: this.$props
-    })
-  },
-  beforeCreate() {
-    Vue.util.defineReactive(this, 'nuxt', this.$root.$options.nuxt)
-  },
-  computed: {
-    routerViewKey() {
-      // If nuxtChildKey prop is given or current route has children
-      if (typeof this.nuxtChildKey !== 'undefined' || this.$route.matched.length > 1) {
-        return this.nuxtChildKey || compile(this.$route.matched[0].path)(this.$route.params)
-      }
-      const Component = this.$route.matched[0] && this.$route.matched[0].components.default
-      if (Component && Component.options && Component.options.key) {
-        return (typeof Component.options.key === 'function' ? Component.options.key(this.$route) : Component.options.key)
-      }
-      return this.$route.path
-    }
-  },
-  components: {
-    NuxtChild,
-    NuxtError
-  }
-}

.nuxt/empty.js

@@ -1 +0,0 @@
-// This file is intentionally left empty for noop aliases

.nuxt/index.js

@@ -1,164 +0,0 @@
-import Vue from 'vue'
-import Meta from 'vue-meta'
-import { createRouter } from './router.js'
-import NoSSR from './components/no-ssr.js'
-import NuxtChild from './components/nuxt-child.js'
-import NuxtLink from './components/nuxt-link.js'
-import NuxtError from './components/nuxt-error.vue'
-import Nuxt from './components/nuxt.js'
-import App from './App.js'
-import { setContext, getLocation, getRouteData, normalizeError } from './utils'
-
-/* Plugins */
-
-import nuxt_plugin_axios_0c5c16d5 from 'nuxt_plugin_axios_0c5c16d5' // Source: ./axios.js
-import nuxt_plugin_elementui_d905880e from 'nuxt_plugin_elementui_d905880e' // Source: ../plugins/element-ui
-import nuxt_plugin_http_926ab708 from 'nuxt_plugin_http_926ab708' // Source: ../plugins/http
-import nuxt_plugin_quill_23090991 from 'nuxt_plugin_quill_23090991' // Source: ../plugins/quill
-
-// Component: <no-ssr>
-Vue.component(NoSSR.name, NoSSR)
-
-// Component: <nuxt-child>
-Vue.component(NuxtChild.name, NuxtChild)
-
-// Component: <nuxt-link>
-Vue.component(NuxtLink.name, NuxtLink)
-
-// Component: <nuxt>`
-Vue.component(Nuxt.name, Nuxt)
-
-// vue-meta configuration
-Vue.use(Meta, {
-  keyName: 'head', // the component option name that vue-meta looks for meta info on.
-  attribute: 'data-n-head', // the attribute name vue-meta adds to the tags it observes
-  ssrAttribute: 'data-n-head-ssr', // the attribute name that lets vue-meta know that meta info has already been server-rendered
-  tagIDKeyName: 'hid' // the property name that vue-meta uses to determine whether to overwrite or append a tag
-})
-
-const defaultTransition = {"name":"page","mode":"out-in","appear":true,"appearClass":"appear","appearActiveClass":"appear-active","appearToClass":"appear-to"}
-
-async function createApp(ssrContext) {
-  const router = await createRouter(ssrContext)
-
-  // Create Root instance
-
-  // here we inject the router and store to all child components,
-  // making them available everywhere as `this.$router` and `this.$store`.
-  const app = {
-    router,
-
-    nuxt: {
-      defaultTransition,
-      transitions: [ defaultTransition ],
-      setTransitions(transitions) {
-        if (!Array.isArray(transitions)) {
-          transitions = [ transitions ]
-        }
-        transitions = transitions.map((transition) => {
-          if (!transition) {
-            transition = defaultTransition
-          } else if (typeof transition === 'string') {
-            transition = Object.assign({}, defaultTransition, { name: transition })
-          } else {
-            transition = Object.assign({}, defaultTransition, transition)
-          }
-          return transition
-        })
-        this.$options.nuxt.transitions = transitions
-        return transitions
-      },
-      err: null,
-      dateErr: null,
-      error(err) {
-        err = err || null
-        app.context._errored = !!err
-        err = err ? normalizeError(err) : null
-        const nuxt = this.nuxt || this.$options.nuxt
-        nuxt.dateErr = Date.now()
-        nuxt.err = err
-        // Used in src/server.js
-        if (ssrContext) ssrContext.nuxt.error = err
-        return err
-      }
-    },
-    ...App
-  }
-
-  const next = ssrContext ? ssrContext.next : location => app.router.push(location)
-  // Resolve route
-  let route
-  if (ssrContext) {
-    route = router.resolve(ssrContext.url).route
-  } else {
-    const path = getLocation(router.options.base)
-    route = router.resolve(path).route
-  }
-
-  // Set context to app.context
-  await setContext(app, {
-    route,
-    next,
-    error: app.nuxt.error.bind(app),
-
-    payload: ssrContext ? ssrContext.payload : undefined,
-    req: ssrContext ? ssrContext.req : undefined,
-    res: ssrContext ? ssrContext.res : undefined,
-    beforeRenderFns: ssrContext ? ssrContext.beforeRenderFns : undefined
-  })
-
-  const inject = function (key, value) {
-    if (!key) throw new Error('inject(key, value) has no key provided')
-    if (typeof value === 'undefined') throw new Error('inject(key, value) has no value provided')
-    key = '$' + key
-    // Add into app
-    app[key] = value
-
-    // Check if plugin not already installed
-    const installKey = '__nuxt_' + key + '_installed__'
-    if (Vue[installKey]) return
-    Vue[installKey] = true
-    // Call Vue.use() to install the plugin into vm
-    Vue.use(() => {
-      if (!Vue.prototype.hasOwnProperty(key)) {
-        Object.defineProperty(Vue.prototype, key, {
-          get() {
-            return this.$root.$options[key]
-          }
-        })
-      }
-    })
-  }
-
-  // Plugin execution
-
-  if (typeof nuxt_plugin_axios_0c5c16d5 === 'function') await nuxt_plugin_axios_0c5c16d5(app.context, inject)
-  if (typeof nuxt_plugin_elementui_d905880e === 'function') await nuxt_plugin_elementui_d905880e(app.context, inject)
-  if (typeof nuxt_plugin_http_926ab708 === 'function') await nuxt_plugin_http_926ab708(app.context, inject)
-  if (typeof nuxt_plugin_quill_23090991 === 'function') await nuxt_plugin_quill_23090991(app.context, inject)
-
-  // If server-side, wait for async component to be resolved first
-  if (process.server && ssrContext && ssrContext.url) {
-    await new Promise((resolve, reject) => {
-      router.push(ssrContext.url, resolve, () => {
-        // navigated to a different route in router guard
-        const unregister = router.afterEach(async (to, from, next) => {
-          ssrContext.url = to.fullPath
-          app.context.route = await getRouteData(to)
-          app.context.params = to.params || {}
-          app.context.query = to.query || {}
-          unregister()
-          resolve()
-        })
-      })
-    })
-  }
-
-  return {
-    app,
-
-    router
-  }
-}
-
-export { createApp, NuxtError }

.nuxt/loading.html

@@ -1,107 +0,0 @@
-<style>
-#nuxt-loading {
-  visibility: hidden;
-  opacity: 0;
-  position: absolute;
-  left: 0;
-  right: 0;
-  top: 0;
-  bottom: 0;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  flex-direction: column;
-  animation: nuxtLoadingIn 10s ease;
-  -webkit-animation: nuxtLoadingIn 10s ease;
-  animation-fill-mode: forwards;
-  overflow: hidden;
-}
-
-@keyframes nuxtLoadingIn {
-  0% {
-    visibility: hidden;
-    opacity: 0;
-  }
-  20% {
-    visibility: visible;
-    opacity: 0;
-  }
-  100% {
-    visibility: visible;
-    opacity: 1;
-  }
-}
-
-@-webkit-keyframes nuxtLoadingIn {
-  0% {
-    visibility: hidden;
-    opacity: 0;
-  }
-  20% {
-    visibility: visible;
-    opacity: 0;
-  }
-  100% {
-    visibility: visible;
-    opacity: 1;
-  }
-}
-
-#nuxt-loading>div,
-#nuxt-loading>div:after {
-  border-radius: 50%;
-  width: 5rem;
-  height: 5rem;
-}
-
-#nuxt-loading>div {
-  font-size: 10px;
-  position: relative;
-  text-indent: -9999em;
-  border: .5rem solid #F5F5F5;
-  border-left: .5rem solid #fff;
-  -webkit-transform: translateZ(0);
-  -ms-transform: translateZ(0);
-  transform: translateZ(0);
-  -webkit-animation: nuxtLoading 1.1s infinite linear;
-  animation: nuxtLoading 1.1s infinite linear;
-}
-
-#nuxt-loading.error>div {
-  border-left: .5rem solid #ff4500;
-  animation-duration: 5s;
-}
-
-@-webkit-keyframes nuxtLoading {
-  0% {
-    -webkit-transform: rotate(0deg);
-    transform: rotate(0deg);
-  }
-  100% {
-    -webkit-transform: rotate(360deg);
-    transform: rotate(360deg);
-  }
-}
-
-@keyframes nuxtLoading {
-  0% {
-    -webkit-transform: rotate(0deg);
-    transform: rotate(0deg);
-  }
-  100% {
-    -webkit-transform: rotate(360deg);
-    transform: rotate(360deg);
-  }
-}
-</style>
-
-<script>
-window.addEventListener('error', function () {
-  var e = document.getElementById('nuxt-loading');
-  if (e) e.className += ' error';
-});
-</script>
-
-<div id="nuxt-loading" aria-live="polite" role="status"><div>Loading...</div></div>
-
-<!-- https://projects.lukehaas.me/css-loaders -->

.nuxt/middleware.js

@@ -1,17 +0,0 @@
-
-const files = require.context('@/middleware', false, /^\.\/(?!-)[^.]+\.(js|mjs)$/)
-const filenames = files.keys()
-
-function getModule(filename) {
-  const file = files(filename)
-  return file.default || file
-}
-const middleware = {}
-
-// Generate the middleware
-for (const filename of filenames) {
-  const name = filename.replace(/^\.\//, '').replace(/\.(js|mjs)$/, '')
-  middleware[name] = getModule(filename)
-}
-
-export default middleware

.nuxt/router.js

@@ -1,167 +0,0 @@
-import Vue from 'vue'
-import Router from 'vue-router'
-import { interopDefault } from './utils'
-
-const _5f556d43 = () => interopDefault(import('../pages/login/index.vue' /* webpackChunkName: "pages/login/index" */))
-const _3e02d096 = () => interopDefault(import('../pages/main/index.vue' /* webpackChunkName: "pages/main/index" */))
-const _1bf47b10 = () => interopDefault(import('../pages/main/index/index.vue' /* webpackChunkName: "pages/main/index/index" */))
-const _50052944 = () => interopDefault(import('../pages/main/index/404.vue' /* webpackChunkName: "pages/main/index/404" */))
-const _93979812 = () => interopDefault(import('../pages/main/index/cert_check.vue' /* webpackChunkName: "pages/main/index/cert_check" */))
-const _8140772a = () => interopDefault(import('../pages/main/index/cert_edit.vue' /* webpackChunkName: "pages/main/index/cert_edit" */))
-const _f59a5e48 = () => interopDefault(import('../pages/main/index/cert_pro.vue' /* webpackChunkName: "pages/main/index/cert_pro" */))
-const _817ecb10 = () => interopDefault(import('../pages/main/index/cloud_balance.vue' /* webpackChunkName: "pages/main/index/cloud_balance" */))
-const _2e5d8934 = () => interopDefault(import('../pages/main/index/cloud_developer.vue' /* webpackChunkName: "pages/main/index/cloud_developer" */))
-const _30eade4e = () => interopDefault(import('../pages/main/index/cloud_job.vue' /* webpackChunkName: "pages/main/index/cloud_job" */))
-const _ab6235f8 = () => interopDefault(import('../pages/main/index/dev_check.vue' /* webpackChunkName: "pages/main/index/dev_check" */))
-const _90d9e7c8 = () => interopDefault(import('../pages/main/index/dev_check_detail.vue' /* webpackChunkName: "pages/main/index/dev_check_detail" */))
-const _b3b60d9e = () => interopDefault(import('../pages/main/index/dev_show.vue' /* webpackChunkName: "pages/main/index/dev_show" */))
-const _b296c902 = () => interopDefault(import('../pages/main/index/gongmall.vue' /* webpackChunkName: "pages/main/index/gongmall" */))
-const _b110379e = () => interopDefault(import('../pages/main/index/vip_manager.vue' /* webpackChunkName: "pages/main/index/vip_manager" */))
-const _3c52635c = () => interopDefault(import('../pages/main/index/vip_order.vue' /* webpackChunkName: "pages/main/index/vip_order" */))
-const _c4504d58 = () => interopDefault(import('../pages/main/index/vip_setting.vue' /* webpackChunkName: "pages/main/index/vip_setting" */))
-const _1bb7fb75 = () => interopDefault(import('../pages/main/index/wage_details.vue' /* webpackChunkName: "pages/main/index/wage_details" */))
-const _c0df6474 = () => interopDefault(import('../pages/main/index/wage_settlement.vue' /* webpackChunkName: "pages/main/index/wage_settlement" */))
-const _794553a9 = () => interopDefault(import('../pages/index.vue' /* webpackChunkName: "pages/index" */))
-
-Vue.use(Router)
-
-if (process.client) {
-  window.history.scrollRestoration = 'manual'
-}
-const scrollBehavior = function (to, from, savedPosition) {
-  // if the returned position is falsy or an empty object,
-  // will retain current scroll position.
-  let position = false
-
-  // if no children detected
-  if (to.matched.length < 2) {
-    // scroll to the top of the page
-    position = { x: 0, y: 0 }
-  } else if (to.matched.some(r => r.components.default.options.scrollToTop)) {
-    // if one of the children has scrollToTop option set to true
-    position = { x: 0, y: 0 }
-  }
-
-  // savedPosition is only available for popstate navigations (back button)
-  if (savedPosition) {
-    position = savedPosition
-  }
-
-  return new Promise((resolve) => {
-    // wait for the out transition to complete (if necessary)
-    window.$nuxt.$once('triggerScroll', () => {
-      // coords will be used if no selector is provided,
-      // or if the selector didn't match any element.
-      if (to.hash) {
-        let hash = to.hash
-        // CSS.escape() is not supported with IE and Edge.
-        if (typeof window.CSS !== 'undefined' && typeof window.CSS.escape !== 'undefined') {
-          hash = '#' + window.CSS.escape(hash.substr(1))
-        }
-        try {
-          if (document.querySelector(hash)) {
-            // scroll to anchor by returning the selector
-            position = { selector: hash }
-          }
-        } catch (e) {
-          console.warn('Failed to save scroll position. Please add CSS.escape() polyfill (https://github.com/mathiasbynens/CSS.escape).')
-        }
-      }
-      resolve(position)
-    })
-  })
-}
-
-export function createRouter() {
-  return new Router({
-    mode: 'history',
-    base: '/',
-    linkActiveClass: 'nuxt-link-active',
-    linkExactActiveClass: 'nuxt-link-exact-active',
-    scrollBehavior,
-
-    routes: [{
-      path: "/login",
-      component: _5f556d43,
-      name: "login"
-    }, {
-      path: "/main",
-      component: _3e02d096,
-      children: [{
-        path: "",
-        component: _1bf47b10,
-        name: "main-index"
-      }, {
-        path: "404",
-        component: _50052944,
-        name: "main-index-404"
-      }, {
-        path: "cert_check",
-        component: _93979812,
-        name: "main-index-cert_check"
-      }, {
-        path: "cert_edit",
-        component: _8140772a,
-        name: "main-index-cert_edit"
-      }, {
-        path: "cert_pro",
-        component: _f59a5e48,
-        name: "main-index-cert_pro"
-      }, {
-        path: "cloud_balance",
-        component: _817ecb10,
-        name: "main-index-cloud_balance"
-      }, {
-        path: "cloud_developer",
-        component: _2e5d8934,
-        name: "main-index-cloud_developer"
-      }, {
-        path: "cloud_job",
-        component: _30eade4e,
-        name: "main-index-cloud_job"
-      }, {
-        path: "dev_check",
-        component: _ab6235f8,
-        name: "main-index-dev_check"
-      }, {
-        path: "dev_check_detail",
-        component: _90d9e7c8,
-        name: "main-index-dev_check_detail"
-      }, {
-        path: "dev_show",
-        component: _b3b60d9e,
-        name: "main-index-dev_show"
-      }, {
-        path: "gongmall",
-        component: _b296c902,
-        name: "main-index-gongmall"
-      }, {
-        path: "vip_manager",
-        component: _b110379e,
-        name: "main-index-vip_manager"
-      }, {
-        path: "vip_order",
-        component: _3c52635c,
-        name: "main-index-vip_order"
-      }, {
-        path: "vip_setting",
-        component: _c4504d58,
-        name: "main-index-vip_setting"
-      }, {
-        path: "wage_details",
-        component: _1bb7fb75,
-        name: "main-index-wage_details"
-      }, {
-        path: "wage_settlement",
-        component: _c0df6474,
-        name: "main-index-wage_settlement"
-      }]
-    }, {
-      path: "/",
-      component: _794553a9,
-      name: "index"
-    }],
-
-    fallback: false
-  })
-}

.nuxt/server.js

@@ -1,208 +0,0 @@
-import { stringify } from 'querystring'
-import Vue from 'vue'
-import omit from 'lodash/omit'
-import middleware from './middleware'
-import { applyAsyncData, sanitizeComponent, getMatchedComponents, getContext, middlewareSeries, promisify, urlJoin } from './utils'
-import { createApp, NuxtError } from './index'
-
-const debug = require('debug')('nuxt:render')
-debug.color = 4 // force blue color
-
-const isDev = true
-
-const noopApp = () => new Vue({ render: h => h('div') })
-
-const createNext = ssrContext => (opts) => {
-  ssrContext.redirected = opts
-  // If nuxt generate
-  if (!ssrContext.res) {
-    ssrContext.nuxt.serverRendered = false
-    return
-  }
-  opts.query = stringify(opts.query)
-  opts.path = opts.path + (opts.query ? '?' + opts.query : '')
-  const routerBase = '/'
-  if (!opts.path.startsWith('http') && (routerBase !== '/' && !opts.path.startsWith(routerBase))) {
-    opts.path = urlJoin(routerBase, opts.path)
-  }
-  // Avoid loop redirect
-  if (opts.path === ssrContext.url) {
-    ssrContext.redirected = false
-    return
-  }
-  ssrContext.res.writeHead(opts.status, {
-    'Location': opts.path
-  })
-  ssrContext.res.end()
-}
-
-// This exported function will be called by `bundleRenderer`.
-// This is where we perform data-prefetching to determine the
-// state of our application before actually rendering it.
-// Since data fetching is async, this function is expected to
-// return a Promise that resolves to the app instance.
-export default async (ssrContext) => {
-  // Create ssrContext.next for simulate next() of beforeEach() when wanted to redirect
-  ssrContext.redirected = false
-  ssrContext.next = createNext(ssrContext)
-  // Used for beforeNuxtRender({ Components, nuxtState })
-  ssrContext.beforeRenderFns = []
-  // Nuxt object (window{{globals.context}}, defaults to window.__NUXT__)
-  ssrContext.nuxt = { layout: 'default', data: [], error: null, serverRendered: true }
-  // Create the app definition and the instance (created for each request)
-  const { app, router } = await createApp(ssrContext)
-  const _app = new Vue(app)
-
-  // Add meta infos (used in renderer.js)
-  ssrContext.meta = _app.$meta()
-  // Keep asyncData for each matched component in ssrContext (used in app/utils.js via this.$ssrContext)
-  ssrContext.asyncData = {}
-
-  const beforeRender = async () => {
-    // Call beforeNuxtRender() methods
-    await Promise.all(ssrContext.beforeRenderFns.map(fn => promisify(fn, { Components, nuxtState: ssrContext.nuxt })))
-  }
-  const renderErrorPage = async () => {
-    // Load layout for error page
-    const errLayout = (typeof NuxtError.layout === 'function' ? NuxtError.layout(app.context) : NuxtError.layout)
-    ssrContext.nuxt.layout = errLayout || 'default'
-    await _app.loadLayout(errLayout)
-    _app.setLayout(errLayout)
-    await beforeRender()
-    return _app
-  }
-  const render404Page = () => {
-    app.context.error({ statusCode: 404, path: ssrContext.url, message: `This page could not be found` })
-    return renderErrorPage()
-  }
-
-  const s = isDev && Date.now()
-
-  // Components are already resolved by setContext -> getRouteData (app/utils.js)
-  const Components = getMatchedComponents(router.match(ssrContext.url))
-
-  /*
-  ** Call global middleware (nuxt.config.js)
-  */
-  let midd = []
-  midd = midd.map((name) => {
-    if (typeof name === 'function') return name
-    if (typeof middleware[name] !== 'function') {
-      app.context.error({ statusCode: 500, message: 'Unknown middleware ' + name })
-    }
-    return middleware[name]
-  })
-  await middlewareSeries(midd, app.context)
-  // ...If there is a redirect or an error, stop the process
-  if (ssrContext.redirected) return noopApp()
-  if (ssrContext.nuxt.error) return renderErrorPage()
-
-  /*
-  ** Set layout
-  */
-  let layout = Components.length ? Components[0].options.layout : NuxtError.layout
-  if (typeof layout === 'function') layout = layout(app.context)
-  await _app.loadLayout(layout)
-  if (ssrContext.nuxt.error) return renderErrorPage()
-  layout = _app.setLayout(layout)
-  ssrContext.nuxt.layout = _app.layoutName
-
-  /*
-  ** Call middleware (layout + pages)
-  */
-  midd = []
-  if (layout.middleware) midd = midd.concat(layout.middleware)
-  Components.forEach((Component) => {
-    if (Component.options.middleware) {
-      midd = midd.concat(Component.options.middleware)
-    }
-  })
-  midd = midd.map((name) => {
-    if (typeof name === 'function') return name
-    if (typeof middleware[name] !== 'function') {
-      app.context.error({ statusCode: 500, message: 'Unknown middleware ' + name })
-    }
-    return middleware[name]
-  })
-  await middlewareSeries(midd, app.context)
-  // ...If there is a redirect or an error, stop the process
-  if (ssrContext.redirected) return noopApp()
-  if (ssrContext.nuxt.error) return renderErrorPage()
-
-  /*
-  ** Call .validate()
-  */
-  let isValid = true
-  try {
-    for (const Component of Components) {
-      if (typeof Component.options.validate !== 'function') {
-        continue
-      }
-
-      isValid = await Component.options.validate(app.context)
-
-      if (!isValid) {
-        break
-      }
-    }
-  } catch (validationError) {
-    // ...If .validate() threw an error
-    app.context.error({
-      statusCode: validationError.statusCode || '500',
-      message: validationError.message
-    })
-    return renderErrorPage()
-  }
-
-  // ...If .validate() returned false
-  if (!isValid) {
-    // Don't server-render the page in generate mode
-    if (ssrContext._generate) ssrContext.nuxt.serverRendered = false
-    // Render a 404 error page
-    return render404Page()
-  }
-
-  // If no Components found, returns 404
-  if (!Components.length) return render404Page()
-
-  // Call asyncData & fetch hooks on components matched by the route.
-  const asyncDatas = await Promise.all(Components.map((Component) => {
-    const promises = []
-
-    // Call asyncData(context)
-    if (Component.options.asyncData && typeof Component.options.asyncData === 'function') {
-      const promise = promisify(Component.options.asyncData, app.context)
-      promise.then((asyncDataResult) => {
-        ssrContext.asyncData[Component.cid] = asyncDataResult
-        applyAsyncData(Component)
-        return asyncDataResult
-      })
-      promises.push(promise)
-    } else {
-      promises.push(null)
-    }
-
-    // Call fetch(context)
-    if (Component.options.fetch) {
-      promises.push(Component.options.fetch(app.context))
-    } else {
-      promises.push(null)
-    }
-
-    return Promise.all(promises)
-  }))
-
-  if (asyncDatas.length) debug('Data fetching ' + ssrContext.url + ': ' + (Date.now() - s) + 'ms')
-
-  // datas are the first row of each
-  ssrContext.nuxt.data = asyncDatas.map(r => r[0] || {})
-
-  // ...If there is a redirect or an error, stop the process
-  if (ssrContext.redirected) return noopApp()
-  if (ssrContext.nuxt.error) return renderErrorPage()
-
-  // Call beforeNuxtRender methods & add store state
-  await beforeRender()
-
-  return _app
-}

.nuxt/utils.js

@@ -1,565 +0,0 @@
-import Vue from 'vue'
-
-const noopData = () => ({})
-
-// window.{{globals.loadedCallback}} hook
-// Useful for jsdom testing or plugins (https://github.com/tmpvar/jsdom#dealing-with-asynchronous-script-loading)
-if (process.client) {
-  window.onNuxtReadyCbs = []
-  window.onNuxtReady = (cb) => {
-    window.onNuxtReadyCbs.push(cb)
-  }
-}
-
-export function empty() {}
-
-export function globalHandleError(error) {
-  if (Vue.config.errorHandler) {
-    Vue.config.errorHandler(error)
-  }
-}
-
-export function interopDefault(promise) {
-  return promise.then(m => m.default || m)
-}
-
-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 Array.prototype.concat.apply([], route.matched.map((m, index) => {
-    return Object.keys(m.components).map((key) => {
-      matches && matches.push(index)
-      return m.components[key]
-    })
-  }))
-}
-
-export function getMatchedComponentsInstances(route, matches = false) {
-  return Array.prototype.concat.apply([], route.matched.map((m, index) => {
-    return Object.keys(m.instances).map((key) => {
-      matches && matches.push(index)
-      return m.instances[key]
-    })
-  }))
-}
-
-export function flatMapComponents(route, fn) {
-  return Array.prototype.concat.apply([], route.matched.map((m, index) => {
-    return Object.keys(m.components).reduce((promises, key) => {
-      if (m.components[key]) {
-        promises.push(fn(m.components[key], m.instances[key], m, key, index))
-      } else {
-        delete m.components[key]
-      }
-      return promises
-    }, [])
-  }))
-}
-
-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()
-      }
-      match.components[key] = sanitizeComponent(Component)
-      return match.components[key]
-    })
-  )
-}
-
-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) {
-  // If context not defined, create it
-  if (!app.context) {
-    app.context = {
-      isStatic: process.static,
-      isDev: true,
-      isHMR: false,
-      app,
-
-      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 = (status, path, query) => {
-      if (!status) {
-        return
-      }
-      app.context._redirected = true
-      // 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) {
-      console.warn('Callback-based asyncData, fetch or middleware calls are deprecated. ' +
-        'Please switch to promises or async/await syntax')
-
-    // 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) {
-  let path = window.location.pathname
-  if (mode === 'hash') {
-    return window.location.hash.replace(/^#\//, '')
-  }
-  if (base && path.indexOf(base) === 0) {
-    path = path.slice(base.length)
-  }
-  return decodeURI(path || '/') + window.location.search + window.location.hash
-}
-
-export function urlJoin() {
-  return Array.prototype.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
-}
-
-export function normalizeError(err) {
-  let message
-  if (!(err.message || typeof err === 'string')) {
-    try {
-      message = JSON.stringify(err, null, 2)
-    } catch (e) {
-      message = `[${err.constructor.name}]`
-    }
-  } else {
-    message = err.message || err
-  }
-  return {
-    message: message,
-    statusCode: (err.statusCode || err.status || (err.response && err.response.status) || 500)
-  }
-}
-
-/**
- * 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) {
-  const tokens = []
-  let key = 0
-  let index = 0
-  let path = ''
-  const defaultDelimiter = (options && options.delimiter) || '/'
-  let res
-
-  while ((res = PATH_REGEXP.exec(str)) != null) {
-    const m = res[0]
-    const escaped = res[1]
-    const offset = res.index
-    path += str.slice(index, offset)
-    index = offset + m.length
-
-    // Ignore already escaped sequences.
-    if (escaped) {
-      path += escaped[1]
-      continue
-    }
-
-    const next = str[index]
-    const prefix = res[2]
-    const name = res[3]
-    const capture = res[4]
-    const group = res[5]
-    const modifier = res[6]
-    const asterisk = res[7]
-
-    // Push the current path onto the tokens.
-    if (path) {
-      tokens.push(path)
-      path = ''
-    }
-
-    const partial = prefix != null && next != null && next !== prefix
-    const repeat = modifier === '+' || modifier === '*'
-    const optional = modifier === '?' || modifier === '*'
-    const delimiter = res[2] || defaultDelimiter
-    const 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, (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, (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.
-  const matches = new Array(tokens.length)
-
-  // Compile all the patterns before compilation.
-  for (let i = 0; i < tokens.length; i++) {
-    if (typeof tokens[i] === 'object') {
-      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$')
-    }
-  }
-
-  return function (obj, opts) {
-    let path = ''
-    const data = obj || {}
-    const options = opts || {}
-    const encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent
-
-    for (let i = 0; i < tokens.length; i++) {
-      const token = tokens[i]
-
-      if (typeof token === 'string') {
-        path += token
-
-        continue
-      }
-
-      const value = data[token.name || 'pathMatch']
-      let 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 (let 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
-  const index = url.indexOf('://')
-  if (index !== -1) {
-    protocol = url.substring(0, index)
-    url = url.substring(index + 3)
-  } else if (url.startsWith('//')) {
-    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) => {
-    const 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('&')
-}

.nuxt/views/app.template.html

@@ -1,9 +0,0 @@
-<!DOCTYPE html>
-<html {{ HTML_ATTRS }}>
-  <head>
-    {{ HEAD }}
-  </head>
-  <body {{ BODY_ATTRS }}>
-    {{ APP }}
-  </body>
-</html>

nuxt.config.js

@@ -4,8 +4,8 @@ module.exports = {
   mode: 'spa',
 
   server: {
-    "host": "local-rooter.proginn.com",
-    "port": "20201"
+    host: "0.0.0.0",
+    port: 20201
   },
 
   /**