.nuxt/App.js

@@ -0,0 +1,100 @@
+import Vue from 'vue'
+import NuxtLoading from './components/nuxt-loading.vue'
+
+import '../node_modules/element-ui/lib/theme-chalk/index.css'
+
+import '../assets/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 || !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

@@ -0,0 +1,157 @@
+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://local-rooter.proginn.com:20201/'
+      : (process.env._AXIOS_BASE_URL_ || 'http://local-rooter.proginn.com:20201/')
+
+  // 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

@@ -0,0 +1,553 @@
+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":true,"performance":false})
+
+// 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)
+  })
+}
+
+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))
+  })
+}
+
+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 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

@@ -0,0 +1,6 @@
+/*
+** 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

@@ -0,0 +1,97 @@
+
+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

@@ -0,0 +1,93 @@
+<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>
+
+      <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-link.js

@@ -0,0 +1,8 @@
+
+export default {
+  name: 'nuxt-link',
+  functional: true,
+  render(h, { data, children }) {
+    return h('router-link', data, children)
+  }
+}

.nuxt/components/nuxt-loading.vue

@@ -0,0 +1,177 @@
+<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

@@ -0,0 +1,50 @@
+
+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/dist/client/LICENSES

@@ -0,0 +1,65 @@
+/*!
+ * Vue.js v2.5.22
+ * (c) 2014-2019 Evan You
+ * Released under the MIT License.
+ */
+
+/*!
+  * vue-router v3.0.2
+  * (c) 2018 Evan You
+  * @license MIT
+  */
+
+/**
+ * vue-meta v1.5.8
+ * (c) 2018 Declan de Wet & Sébastien Chopin (@Atinux)
+ * @license MIT
+ */
+
+/*
+	object-assign
+	(c) Sindre Sorhus
+	@license MIT
+	*/
+
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+/*!
+ * vue-no-ssr v1.1.1
+ * (c) 2018-present egoist <0x142857@gmail.com>
+ * Released under the MIT License.
+ */
+
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @param {?boolean} capture Check if the capture phase is supported.
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+
+/*!
+ * Quill Editor v1.3.6
+ * https://quilljs.com/
+ * Copyright (c) 2014, Jason Chen
+ * Copyright (c) 2013, salesforce.com
+ */
+
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */

.nuxt/dist/server/index.spa.html

@@ -0,0 +1,9 @@
+<!doctype html>
+<html {{ html_attrs }}>
+  <head>
+    {{ HEAD }}
+  </head>
+  <body {{ body_attrs }}>
+    {{ APP }}
+  <script type="text/javascript" src="/_nuxt/8e5691c610ce146c270b.js"></script><script type="text/javascript" src="/_nuxt/c3c421f45923e05d13fe.js"></script><script type="text/javascript" src="/_nuxt/5c08bb7c7c0580b90878.js"></script><script type="text/javascript" src="/_nuxt/6c0fcbc8fbc391176d59.js"></script></body>
+</html>

.nuxt/empty.js

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

.nuxt/index.js

@@ -0,0 +1,164 @@
+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

@@ -0,0 +1,105 @@
+<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>

.nuxt/middleware.js

@@ -0,0 +1,17 @@
+
+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

@@ -0,0 +1,152 @@
+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 _09cc8caa = () => interopDefault(import('../pages/main/index/check_edit.vue' /* webpackChunkName: "pages/main/index/check_edit" */))
+const _1bc5339c = () => interopDefault(import('../pages/main/index/check_pro.vue' /* webpackChunkName: "pages/main/index/check_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 _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: "check_edit",
+        component: _09cc8caa,
+        name: "main-index-check_edit"
+      }, {
+        path: "check_pro",
+        component: _1bc5339c,
+        name: "main-index-check_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_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

@@ -0,0 +1,204 @@
+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 = false
+
+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()
+  }
+
+  // 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)
+  }))
+
+  // 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

@@ -0,0 +1,562 @@
+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: false,
+      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) {
+    // 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

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

pages/main/index/vip_manager.vue

@@ -26,7 +26,7 @@
     <el-pagination
       @current-change="changePagination"
       :current-page.sync="currentPage"
-      :page-size="20"
+      :page-size="10"
       layout="total, prev, pager, next"
       :total="totalCount"
     ></el-pagination>

pages/main/index/vip_order.vue

@@ -25,7 +25,7 @@
     <el-pagination
       @current-change="changePagination"
       :current-page.sync="currentPage"
-      :page-size="20"
+      :page-size="10"
       layout="total, prev, pager, next"
       :total="totalCount"
     ></el-pagination>