拿掉 build files

node_modules/@nuxt/vue-app/template/.eslintignore

@@ -1,3 +0,0 @@
-dist
-_nuxt
-*.json

node_modules/@nuxt/vue-app/template/App.js

@@ -1,347 +0,0 @@
-import Vue from 'vue'
-import { decode, parsePath, withoutBase, withoutTrailingSlash, normalizeURL } from 'ufo'
-<% utilsImports = [
-  ...(features.asyncData || features.fetch) ? [
-    'getMatchedComponentsInstances',
-    'getChildrenComponentInstancesUsingFetch',
-    'promisify',
-    'globalHandleError',
-    'urlJoin'
-  ] : [],
-  ...features.layouts ? [
-    'sanitizeComponent'
-  ]: []
-] %>
-<% if (utilsImports.length) { %>import { <%= utilsImports.join(', ') %> } from './utils'<% } %>
-import NuxtError from '<%= components.ErrorPage ? components.ErrorPage : "./components/nuxt-error.vue" %>'
-<% if (loading) { %>import NuxtLoading from '<%= (typeof loading === "string" ? loading : "./components/nuxt-loading.vue") %>'<% } %>
-<% if (buildIndicator) { %>import NuxtBuildIndicator from './components/nuxt-build-indicator'<% } %>
-<% css.forEach((c) => { %>
-import '<%= relativeToBuild(resolvePath(c.src || c, { isStyle: true })) %>'
-<% }) %>
-
-<% if (features.layouts) { %>
-<%= Object.keys(layouts).map((key) => {
-  if (splitChunks.layouts) {
-    return `const _${hash(key)} = () => import('${layouts[key]}'  /* webpackChunkName: "${wChunk('layouts/' + key)}" */).then(m => sanitizeComponent(m.default || m))`
-  } else {
-    return `import _${hash(key)} from '${layouts[key]}'`
-  }
-}).join('\n') %>
-
-<% if (splitChunks.layouts) { %>
-let resolvedLayouts = {}
-const layouts = { <%= Object.keys(layouts).map(key => `"_${key}": _${hash(key)}`).join(',') %> }<%= isTest ? '// eslint-disable-line' : '' %>
-<% } else { %>
-const layouts = { <%= Object.keys(layouts).map(key => `"_${key}": sanitizeComponent(_${hash(key)})`).join(',') %> }<%= isTest ? '// eslint-disable-line' : '' %>
-<% } %>
-
-<% } %>
-
-export default {
-  render (h, props) {
-    <% if (loading) { %>const loadingEl = h('NuxtLoading', { ref: 'loading' })<% } %>
-    <% if (features.layouts) { %>
-    const layoutEl = h(this.layout || 'nuxt')
-    const templateEl = h('div', {
-      domProps: {
-        id: '__layout'
-      },
-      key: this.layoutName
-    }, [layoutEl])
-    <% } else { %>
-    const templateEl = h('nuxt')
-    <% } %>
-
-    <% if (features.transitions) { %>
-    const transitionEl = h('transition', {
-      props: {
-        name: '<%= layoutTransition.name %>',
-        mode: '<%= layoutTransition.mode %>'
-      },
-      on: {
-        beforeEnter (el) {
-          // Ensure to trigger scroll event after calling scrollBehavior
-          window.<%= globals.nuxt %>.$nextTick(() => {
-            window.<%= globals.nuxt %>.$emit('triggerScroll')
-          })
-        }
-      }
-    }, [templateEl])
-    <% } %>
-
-    return h('div', {
-      domProps: {
-        id: '<%= globals.id %>'
-      }
-    }, [
-      <% if (loading) { %>loadingEl, <% } %>
-      <% if (buildIndicator) { %>h(NuxtBuildIndicator), <% } %>
-      <% if (features.transitions) { %>transitionEl<% } else { %>templateEl<% } %>
-    ])
-  },
-  <% if (features.clientOnline || features.layouts) { %>
-  data: () => ({
-    <% if (features.clientOnline) { %>
-    isOnline: true,
-    <% } %>
-    <% if (features.layouts) { %>
-    layout: null,
-    layoutName: '',
-    <% } %>
-    <% if (features.fetch) { %>
-    nbFetching: 0
-    <% } %>
-    }),
-  <% } %>
-  beforeCreate () {
-    Vue.util.defineReactive(this, 'nuxt', this.$options.nuxt)
-  },
-  created () {
-    // Add this.$nuxt in child instances
-    this.$root.$options.<%= globals.nuxt %> = this
-
-    if (process.client) {
-      // add to window so we can listen when ready
-      window.<%= globals.nuxt %> = <%= (globals.nuxt !== '$nuxt' ? 'window.$nuxt = ' : '') %>this
-      <% if (features.clientOnline) { %>
-      this.refreshOnlineStatus()
-      // Setup the listeners
-      window.addEventListener('online', this.refreshOnlineStatus)
-      window.addEventListener('offline', this.refreshOnlineStatus)
-      <% } %>
-    }
-    // Add $nuxt.error()
-    this.error = this.nuxt.error
-    // Add $nuxt.context
-    this.context = this.$options.context
-  },
-  <% if (loading || isFullStatic) { %>
-  async mounted () {
-    <% if (loading) { %>this.$loading = this.$refs.loading<% } %>
-    <% if (isFullStatic) {%>
-    if (this.isPreview) {
-      if (this.$store && this.$store._actions.nuxtServerInit) {
-        <% if (loading) { %>this.$loading.start()<% } %>
-        await this.$store.dispatch('nuxtServerInit', this.context)
-      }
-      await this.refresh()
-      <% if (loading) { %>this.$loading.finish()<% } %>
-    }
-    <% } %>
-  },
-  <% } %>
-  watch: {
-    'nuxt.err': 'errorChanged'
-  },
-  <% if (features.clientOnline) { %>
-  computed: {
-    isOffline () {
-      return !this.isOnline
-    },
-    <% if (features.fetch) { %>
-    isFetching () {
-      return this.nbFetching > 0
-    },<% } %>
-    <% if (nuxtOptions.target === 'static') { %>
-    isPreview () {
-      return Boolean(this.$options.previewData)
-    },<% } %>
-  },
-  <% } %>
-  methods: {
-    <%= isTest ? '/* eslint-disable comma-dangle */' : '' %>
-    <% if (features.clientOnline) { %>
-    refreshOnlineStatus () {
-      if (process.client) {
-        if (typeof window.navigator.onLine === 'undefined') {
-          // If the browser doesn't support connection status reports
-          // assume that we are online because most apps' only react
-          // when they now that the connection has been interrupted
-          this.isOnline = true
-        } else {
-          this.isOnline = window.navigator.onLine
-        }
-      }
-    },
-    <% } %>
-    async refresh () {
-      <% if (features.asyncData || features.fetch) { %>
-      const pages = getMatchedComponentsInstances(this.$route)
-
-      if (!pages.length) {
-        return
-      }
-      <% if (loading) { %>this.$loading.start()<% } %>
-
-      const promises = pages.map((page) => {
-        const p = []
-
-        <% if (features.fetch) { %>
-        // Old fetch
-        if (page.$options.fetch && page.$options.fetch.length) {
-          p.push(promisify(page.$options.fetch, this.context))
-        }
-        if (page.$fetch) {
-          p.push(page.$fetch())
-        } else {
-          // Get all component instance to call $fetch
-          for (const component of getChildrenComponentInstancesUsingFetch(page.$vnode.componentInstance)) {
-            p.push(component.$fetch())
-          }
-        }
-        <% } %>
-        <% if (features.asyncData) { %>
-        if (page.$options.asyncData) {
-          p.push(
-            promisify(page.$options.asyncData, this.context)
-              .then((newData) => {
-                for (const key in newData) {
-                  Vue.set(page.$data, key, newData[key])
-                }
-              })
-          )
-        }
-        <% } %>
-        return Promise.all(p)
-      })
-      try {
-        await Promise.all(promises)
-      } catch (error) {
-        <% if (loading) { %>this.$loading.fail(error)<% } %>
-        globalHandleError(error)
-        this.error(error)
-      }
-      <% if (loading) { %>this.$loading.finish()<% } %>
-      <% } %>
-    },
-    <% if (splitChunks.layouts) { %>async <% } %>errorChanged () {
-      if (this.nuxt.err) {
-        <% if (loading) { %>
-        if (this.$loading) {
-          if (this.$loading.fail) {
-            this.$loading.fail(this.nuxt.err)
-          }
-          if (this.$loading.finish) {
-            this.$loading.finish()
-          }
-        }
-        <% } %>
-        let errorLayout = (NuxtError.options || NuxtError).layout;
-
-        if (typeof errorLayout === 'function') {
-          errorLayout = errorLayout(this.context)
-        }
-        <% if (splitChunks.layouts) { %>
-        await this.loadLayout(errorLayout)
-        <% } %>
-        this.setLayout(errorLayout)
-      }
-    },
-    <% if (features.layouts) { %>
-    <% if (splitChunks.layouts) { %>
-    setLayout (layout) {
-      <% if (debug) { %>
-      if(layout && typeof layout !== 'string') {
-        throw new Error('[nuxt] Avoid using non-string value as layout property.')
-      }
-      <% } %>
-      if (!layout || !resolvedLayouts['_' + layout]) {
-        layout = 'default'
-      }
-      this.layoutName = layout
-      let _layout = '_' + layout
-      this.layout = resolvedLayouts[_layout]
-      return this.layout
-    },
-    loadLayout (layout) {
-      const undef = !layout
-      const nonexistent = !(layouts['_' + layout] || resolvedLayouts['_' + layout])
-      let _layout = '_' + ((undef || nonexistent) ? 'default' : layout)
-      if (resolvedLayouts[_layout]) {
-        return Promise.resolve(resolvedLayouts[_layout])
-      }
-      return layouts[_layout]()
-        .then((Component) => {
-          resolvedLayouts[_layout] = Component
-          delete layouts[_layout]
-          return resolvedLayouts[_layout]
-        })
-        .catch((e) => {
-          if (this.<%= globals.nuxt %>) {
-            return this.<%= globals.nuxt %>.error({ statusCode: 500, message: e.message })
-          }
-        })
-    },
-    <% } else { %>
-    setLayout (layout) {
-      <% if (debug) { %>
-      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])
-    },
-    <% } /* splitChunks.layouts */ %>
-    <% } /* features.layouts */ %>
-    <% if (isFullStatic) { %>
-    getRouterBase() {
-      return withoutTrailingSlash(this.$router.options.base)
-    },
-    getRoutePath(route = '/') {
-      const base = this.getRouterBase()
-      return withoutTrailingSlash(withoutBase(parsePath(route).pathname, base))
-    },
-    getStaticAssetsPath(route = '/') {
-      const { staticAssetsBase } = window.<%= globals.context %>
-
-      return urlJoin(staticAssetsBase, this.getRoutePath(route))
-    },
-    <% if (nuxtOptions.generate.manifest) { %>
-      async fetchStaticManifest() {
-      return window.__NUXT_IMPORT__('manifest.js', normalizeURL(urlJoin(this.getStaticAssetsPath(), 'manifest.js')))
-    },
-    <% } %>
-    setPagePayload(payload) {
-      this._pagePayload = payload
-      this._fetchCounters = {}
-    },
-    async fetchPayload(route, prefetch) {
-      const path = decode(this.getRoutePath(route))
-      <% if (nuxtOptions.generate.manifest) { %>
-      const manifest = await this.fetchStaticManifest()
-      if (!manifest.routes.includes(path)) {
-        if (!prefetch) { this.setPagePayload(false) }
-        throw new Error(`Route ${path} is not pre-rendered`)
-      }
-      <% } %>
-      const src = urlJoin(this.getStaticAssetsPath(route), 'payload.js')
-      try {
-        const payload = await window.__NUXT_IMPORT__(path, normalizeURL(src))
-        if (!prefetch) { this.setPagePayload(payload) }
-        return payload
-      } catch (err) {
-        if (!prefetch) { this.setPagePayload(false) }
-        throw err
-      }
-    }
-    <% } %>
-  },
-  <% if (loading) { %>
-  components: {
-    NuxtLoading
-  }
-  <% } %>
-  <%= isTest ? '/* eslint-enable comma-dangle */' : '' %>
-}

node_modules/@nuxt/vue-app/template/client.js

@@ -1,951 +0,0 @@
-import Vue from 'vue'
-<% if (fetch.client) { %>import fetch from 'unfetch'<% } %>
-<% if (features.middleware) { %>import middleware from './middleware.js'<% } %>
-import {
-  <% if (features.asyncData) { %>applyAsyncData,
-  promisify,<% } %>
-  <% if (features.middleware) { %>middlewareSeries,<% } %>
-  <% if (features.transitions || (features.middleware && features.layouts)) { %>sanitizeComponent,<% } %>
-  resolveRouteComponents,
-  getMatchedComponents,
-  getMatchedComponentsInstances,
-  flatMapComponents,
-  setContext,
-  <% if (features.transitions || features.asyncData || features.fetch) { %>getLocation,<% } %>
-  compile,
-  getQueryDiff,
-  globalHandleError,
-  isSamePath,
-  urlJoin
-} from './utils.js'
-import { createApp<% if (features.layouts) { %>, NuxtError<% } %> } from './index.js'
-<% if (features.fetch) { %>import fetchMixin from './mixins/fetch.client'<% } %>
-import NuxtLink from './components/nuxt-link.<%= features.clientPrefetch ? "client" : "server" %>.js' // should be included after ./index.js
-<% if (isFullStatic) { %>import { installJsonp } from './jsonp'<% } %>
-
-<% if (isFullStatic) { %>installJsonp()<% } %>
-
-<% if (features.fetch) { %>
-// Fetch mixin
-if (!Vue.__nuxt__fetch__mixin__) {
-  Vue.mixin(fetchMixin)
-  Vue.__nuxt__fetch__mixin__ = true
-}
-<% } %>
-
-// Component: <NuxtLink>
-Vue.component(NuxtLink.name, NuxtLink)
-<% if (features.componentAliases) { %>Vue.component('NLink', NuxtLink)<% } %>
-
-<% if (fetch.client) { %>if (!global.fetch) { global.fetch = fetch }<% } %>
-
-// Global shared references
-let _lastPaths = []<%= isTest ? '// eslint-disable-line no-unused-vars' : '' %>
-let app
-let router
-<% if (store) { %>let store<%= isTest ? '// eslint-disable-line no-unused-vars' : '' %><% } %>
-
-// Try to rehydrate SSR data from window
-const NUXT = window.<%= globals.context %> || {}
-
-const $config = NUXT.config || {}
-if ($config._app) {
-  __webpack_public_path__ = urlJoin($config._app.cdnURL, $config._app.assetsPath)
-}
-
-Object.assign(Vue.config, <%= serialize(vue.config) %>)<%= isTest ? '// eslint-disable-line' : '' %>
-
-<% if (nuxtOptions.render.ssrLog) { %>
-const logs = NUXT.logs || []
-  if (logs.length > 0) {
-  const ssrLogStyle = 'background: #2E495E;border-radius: 0.5em;color: white;font-weight: bold;padding: 2px 0.5em;'
-  console.group && console.group<%= nuxtOptions.render.ssrLog === 'collapsed' ? 'Collapsed' : '' %> ('%cNuxt SSR', ssrLogStyle)
-  logs.forEach(logObj => (console[logObj.type] || console.log)(...logObj.args))
-  delete NUXT.logs
-  console.groupEnd && console.groupEnd()
-}
-<% } %>
-<% if (debug) { %>
-// Setup global Vue error handler
-if (!Vue.config.$nuxt) {
-  const defaultErrorHandler = Vue.config.errorHandler
-  Vue.config.errorHandler = async (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') {
-        const currentApp = vm.$root[nuxtApp]
-        <% if (features.layouts) { %>
-        // Load error layout
-        let layout = (NuxtError.options || NuxtError).layout
-        if (typeof layout === 'function') {
-          layout = layout(currentApp.context)
-        }
-        if (layout) {
-          await currentApp.loadLayout(layout).catch(() => {})
-        }
-        currentApp.setLayout(layout)
-        <% } %>
-        currentApp.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.<%= globals.nuxt %> = true
-<% } %>
-const errorHandler = Vue.config.errorHandler || console.error
-
-// Create and mount App
-createApp(null, NUXT.config).then(mountApp).catch(errorHandler)
-
-<% if (features.transitions) { %>
-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 (toComponents, to, from) {
-  const componentTransitions = (component) => {
-    const transition = componentOption(component, 'transition', to, from) || {}
-    return (typeof transition === 'string' ? { name: transition } : transition)
-  }
-
-  const fromComponents = from ? getMatchedComponents(from) : []
-  const maxDepth = Math.max(toComponents.length, fromComponents.length)
-
-  const mergedTransitions = []
-  for (let i=0; i<maxDepth; i++) {
-    // Clone original objects to prevent overrides
-    const toTransitions = Object.assign({}, componentTransitions(toComponents[i]))
-    const transitions = Object.assign({}, componentTransitions(fromComponents[i]))
-
-    // Combine transitions & prefer `leave` properties of "from" route
-    Object.keys(toTransitions)
-        .filter(key => typeof toTransitions[key] !== 'undefined' && !key.toLowerCase().includes('leave'))
-        .forEach((key) => { transitions[key] = toTransitions[key] })
-
-    mergedTransitions.push(transitions)
-  }
-  return mergedTransitions
-}
-<% } %>
-async function loadAsyncComponents (to, from, next) {
-  // Check if route changed (this._routeChanged), only if the page is not an error (for validate())
-  this._routeChanged = Boolean(app.nuxt.err) || from.name !== to.name
-  this._paramChanged = !this._routeChanged && from.path !== to.path
-  this._queryChanged = !this._paramChanged && from.fullPath !== to.fullPath
-  this._diffQuery = (this._queryChanged ? getQueryDiff(to.query, from.query) : [])
-
-  <% if (loading) { %>
-  if ((this._routeChanged || this._paramChanged) && this.$loading.start && !this.$loading.manual) {
-    this.$loading.start()
-  }
-  <% } %>
-
-  try {
-    if (this._queryChanged) {
-      const Components = await resolveRouteComponents(
-        to,
-        (Component, instance) => ({ Component, instance })
-      )
-      // Add a marker on each component that it needs to refresh or not
-      const startLoader = Components.some(({ Component, instance }) => {
-        const watchQuery = Component.options.watchQuery
-        if (watchQuery === true) {
-          return true
-        }
-        if (Array.isArray(watchQuery)) {
-          return watchQuery.some(key => this._diffQuery[key])
-        }
-        if (typeof watchQuery === 'function') {
-          return watchQuery.apply(instance, [to.query, from.query])
-        }
-        return false
-      })
-      <% if (loading) { %>
-      if (startLoader && this.$loading.start && !this.$loading.manual) {
-        this.$loading.start()
-      }
-      <% } %>
-    }
-    // Call next()
-    next()
-  } catch (error) {
-    const err = error || {}
-    const statusCode = err.statusCode || err.status || (err.response && err.response.status) || 500
-    const message = err.message || ''
-
-    // Handle chunk loading errors
-    // This may be due to a new deployment or a network problem
-    if (/^Loading( CSS)? chunk (\d)+ failed\./.test(message)) {
-      window.location.reload(true /* skip cache */)
-      return // prevent error page blinking for user
-    }
-
-    this.error({ statusCode, message })
-    this.<%= globals.nuxt %>.$emit('routeChanged', to, from, err)
-    next()
-  }
-}
-
-<% if (features.transitions || features.asyncData || features.fetch) { %>
-function applySSRData (Component, ssrData) {
-  <% if (features.asyncData) { %>
-  if (NUXT.serverRendered && ssrData) {
-    applyAsyncData(Component, ssrData)
-  }
-  <% } %>
-  Component._Ctor = Component
-  return Component
-}
-
-// Get matched components
-function resolveComponents (route) {
-  return flatMapComponents(route, 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
-  })
-}
-<% } %>
-
-<% if (features.middleware) { %>
-function callMiddleware (Components, context, layout) {
-  let midd = <%= devalue(router.middleware) %><%= isTest ? '// eslint-disable-line' : '' %>
-  let unknownMiddleware = false
-
-  <% if (features.layouts) { %>
-  // If layout is undefined, only call global middleware
-  if (typeof layout !== 'undefined') {
-    midd = [] // Exclude global middleware if layout defined (already called before)
-    layout = sanitizeComponent(layout)
-    if (layout.options.middleware) {
-      midd = midd.concat(layout.options.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)
-}
-<% } else if (isDev) {
-// This is a placeholder function mainly so we dont have to
-// refactor the promise chain in addHotReload()
-%>
-function callMiddleware () {
-  return Promise.resolve(true)
-}
-<% } %>
-async function render (to, from, next) {
-  if (this._routeChanged === false && this._paramChanged === false && this._queryChanged === false) {
-    return next()
-  }
-  // Handle first render on SPA mode
-  let spaFallback = false
-  if (to === from) {
-    _lastPaths = []
-    spaFallback = true
-  } 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 (loading) { %>
-    if (from.path === path.path && this.$loading.finish) {
-      this.$loading.finish()
-    }
-    <% } %>
-    <% if (loading) { %>
-    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 = Boolean(app.nuxt.err)
-
-  // Get route's matched components
-  const matches = []
-  const Components = getMatchedComponents(to, matches)
-
-  // If no Components matched, generate 404
-  if (!Components.length) {
-    <% if (features.middleware) { %>
-    // Default layout
-    await callMiddleware.call(this, Components, app.context)
-    if (nextCalled) {
-      return
-    }
-    <% } %>
-
-    <% if (features.layouts) { %>
-    // Load layout for error page
-    const errorLayout = (NuxtError.options || NuxtError).layout
-    const layout = await this.loadLayout(
-      typeof errorLayout === 'function'
-        ? errorLayout.call(NuxtError, app.context)
-        : errorLayout
-    )
-    <% } %>
-
-    <% if (features.middleware) { %>
-    await callMiddleware.call(this, Components, app.context, layout)
-    if (nextCalled) {
-      return
-    }
-    <% } %>
-
-    // Show error page
-    app.context.error({ statusCode: 404, message: '<%= messages.error_404 %>' })
-    return next()
-  }
-
-  <% if (features.asyncData || features.fetch) { %>
-  // Update ._data and other properties if hot reloaded
-  Components.forEach((Component) => {
-    if (Component._Ctor && Component._Ctor.options) {
-      <% if (features.asyncData) { %>Component.options.asyncData = Component._Ctor.options.asyncData<% } %>
-      <% if (features.fetch) { %>Component.options.fetch = Component._Ctor.options.fetch<% } %>
-    }
-  })
-  <% } %>
-
-  <% if (features.transitions) { %>
-  // Apply transitions
-  this.setTransitions(mapTransitions(Components, to, from))
-  <% } %>
-  try {
-    <% if (features.middleware) { %>
-    // Call middleware
-    await callMiddleware.call(this, Components, app.context)
-    if (nextCalled) {
-      return
-    }
-    if (app.context._errored) {
-      return next()
-    }
-    <% } %>
-
-    <% if (features.layouts) { %>
-    // Set layout
-    let layout = Components[0].options.layout
-    if (typeof layout === 'function') {
-      layout = layout(app.context)
-    }
-    layout = await this.loadLayout(layout)
-    <% } %>
-
-    <% if (features.middleware) { %>
-    // Call middleware for layout
-    await callMiddleware.call(this, Components, app.context, layout)
-    if (nextCalled) {
-      return
-    }
-    if (app.context._errored) {
-      return next()
-    }
-    <% } %>
-
-
-    <% if (features.validate) { %>
-    // 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: '<%= messages.error_404 %>' })
-      return next()
-    }
-    <% } %>
-
-    <% if (features.asyncData || features.fetch) { %>
-    let instances
-    // Call asyncData & fetch hooks on components matched by the route.
-    await Promise.all(Components.map(async (Component, i) => {
-      // Check if only children route changed
-      Component._path = compile(to.matched[matches[i]].path)(to.params)
-      Component._dataRefresh = false
-      const childPathChanged = Component._path !== _lastPaths[i]
-      // Refresh component (call asyncData & fetch) when:
-      // Route path changed part includes current component
-      // Or route param changed part includes current component and watchParam is not `false`
-      // Or route query is changed and watchQuery returns `true`
-      if (this._routeChanged && childPathChanged) {
-        Component._dataRefresh = true
-      } else if (this._paramChanged && childPathChanged) {
-        const watchParam = Component.options.watchParam
-        Component._dataRefresh = watchParam !== false
-      } else if (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])
-        } else if (typeof watchQuery === 'function') {
-          if (!instances) {
-            instances = getMatchedComponentsInstances(to)
-          }
-          Component._dataRefresh = watchQuery.apply(instances[i], [to.query, from.query])
-        }
-      }
-      if (!this._hadError && this._isMounted && !Component._dataRefresh) {
-        return
-      }
-
-      const promises = []
-
-      <% if (features.asyncData) { %>
-      const hasAsyncData = (
-        Component.options.asyncData &&
-        typeof Component.options.asyncData === 'function'
-      )
-      <% } else { %>
-      const hasAsyncData = false
-      <% } %>
-
-      <% if (features.fetch) { %>
-      const hasFetch = Boolean(Component.options.fetch) && Component.options.fetch.length
-      <% } else { %>
-      const hasFetch = false
-      <% } %>
-
-      <% if (loading) { %>
-      const loadingIncrease = (hasAsyncData && hasFetch) ? 30 : 45
-      <% } %>
-
-      <% if (features.asyncData) { %>
-      // Call asyncData(context)
-      if (hasAsyncData) {
-        <% if (isFullStatic) { %>
-          let promise
-
-          if (this.isPreview || spaFallback) {
-            promise = promisify(Component.options.asyncData, app.context)
-          } else {
-              promise = this.fetchPayload(to.path)
-                .then(payload => payload.data[i])
-                .catch(_err => promisify(Component.options.asyncData, app.context)) // Fallback
-          }
-        <% } else { %>
-        const promise = promisify(Component.options.asyncData, app.context)
-        <% } %>
-        promise.then((asyncDataResult) => {
-          applyAsyncData(Component, asyncDataResult)
-          <% if (loading) { %>
-          if (this.$loading.increase) {
-            this.$loading.increase(loadingIncrease)
-          }
-          <% } %>
-        })
-        promises.push(promise)
-      }
-      <% } %>
-
-      <% if (isFullStatic && store) { %>
-      if (!this.isPreview && !spaFallback) {
-        // Replay store mutations, catching to avoid error page on SPA fallback
-        promises.push(this.fetchPayload(to.path).then(payload => {
-          payload.mutations.forEach(m => { this.$store.commit(m[0], m[1]) })
-        }).catch(err => null))
-      }
-      <% } %>
-
-      // Check disabled page loading
-      this.$loading.manual = Component.options.loading === false
-
-      <% if (features.fetch) { %>
-        <% if (isFullStatic) { %>
-        if (!this.isPreview && !spaFallback) {
-          // Catching the error here for letting the SPA fallback and normal fetch behaviour
-          promises.push(this.fetchPayload(to.path).catch(err => null))
-        }
-      <% } %>
-      // 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 (loading) { %>
-          if (this.$loading.increase) {
-            this.$loading.increase(loadingIncrease)
-          }
-          <% } %>
-        })
-        promises.push(p)
-      }
-      <% } %>
-
-      return Promise.all(promises)
-    }))
-    <% } %>
-
-    // If not redirected
-    if (!nextCalled) {
-      <% if (loading) { %>
-      if (this.$loading.finish && !this.$loading.manual) {
-        this.$loading.finish()
-      }
-      <% } %>
-      next()
-    }
-
-  } catch (err) {
-    const error = err || {}
-    if (error.message === 'ERR_REDIRECT') {
-      return this.<%= globals.nuxt %>.$emit('routeChanged', to, from, error)
-    }
-    _lastPaths = []
-
-    globalHandleError(error)
-
-    <% if (features.layouts) { %>
-    // Load error layout
-    let layout = (NuxtError.options || NuxtError).layout
-    if (typeof layout === 'function') {
-      layout = layout(app.context)
-    }
-    await this.loadLayout(layout)
-    <% } %>
-
-    this.error(error)
-    this.<%= globals.nuxt %>.$emit('routeChanged', to, from, error)
-    next()
-  }
-}
-
-// 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
-  })
-}
-
-<% if (features.layouts) { %>
-<% if (splitChunks.layouts) { %>async <% } %>function setLayoutForNextPage (to) {
-  // Set layout
-  let hasError = Boolean(this.$options.nuxt.err)
-  if (this._hadError && this._dateLastError === this.$options.nuxt.dateErr) {
-    hasError = false
-  }
-  let layout = hasError
-    ? (NuxtError.options || NuxtError).layout
-    : to.matched[0].components.default.options.layout
-
-  if (typeof layout === 'function') {
-    layout = layout(app.context)
-  }
-  <% if (splitChunks.layouts) { %>
-  await this.loadLayout(layout)
-  <% } %>
-  this.setLayout(layout)
-}
-<% } %>
-
-function checkForErrors (app) {
-  // Hide error component if no error
-  if (app._hadError && app._dateLastError === app.$options.nuxt.dateErr) {
-    app.error()
-  }
-}
-
-// 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._routeChanged === false && this._paramChanged === false && this._queryChanged === false) {
-    return
-  }
-
-  const instances = getMatchedComponentsInstances(to)
-  const Components = getMatchedComponents(to)
-
-  let triggerScroll = <%= features.transitions ? 'false' : 'true' %>
-
-  Vue.nextTick(() => {
-    instances.forEach((instance, i) => {
-      if (!instance || instance._isDestroyed) {
-        return
-      }
-
-      if (
-        instance.constructor._dataRefresh &&
-        Components[i] === instance.constructor &&
-        instance.$vnode.data.keepAlive !== true &&
-        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])
-        }
-
-        triggerScroll = true
-      }
-    })
-
-    if (triggerScroll) {
-      // Ensure to trigger scroll event after calling scrollBehavior
-      window.<%= globals.nuxt %>.$nextTick(() => {
-        window.<%= globals.nuxt %>.$emit('triggerScroll')
-      })
-    }
-
-    checkForErrors(this)
-    <% if (isDev) { %>
-    // Hot reloading
-    setTimeout(() => hotReloadAPI(this), 100)
-    <% } %>
-  })
-}
-
-function nuxtReady (_app) {
-  window.<%= globals.readyCallback %>Cbs.forEach((cb) => {
-    if (typeof cb === 'function') {
-      cb(_app)
-    }
-  })
-  // Special JSDOM
-  if (typeof window.<%= globals.loadedCallback %> === 'function') {
-    window.<%= globals.loadedCallback %>(_app)
-  }
-  // Add router hooks
-  router.afterEach((to, from) => {
-    // Wait for fixPrepatch + $data updates
-    Vue.nextTick(() => _app.<%= globals.nuxt %>.$emit('routeChanged', to, from))
-  })
-}
-
-<% if (isDev) { %>
-const noopData = () => { return {} }
-const noopFetch = () => {}
-
-// Special hot reload with asyncData(context)
-function getNuxtChildComponents ($parent, $components = []) {
-  $parent.$children.forEach(($child) => {
-    if ($child.$vnode && $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.<%= globals.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) {
-      <%= (loading ? '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 (loading) { %>
-    if (this.$loading.start && !this.$loading.manual) {
-      this.$loading.start()
-    }
-    <% } %>
-
-    callMiddleware.call(this, Components, context)
-    .then(() => {
-      <% if (features.layouts) { %>
-      // If layout changed
-      if (depth !== 0) {
-        return
-      }
-
-      let layout = Component.options.layout || 'default'
-      if (typeof layout === 'function') {
-        layout = layout(context)
-      }
-      if (this.layoutName === layout) {
-        return
-      }
-      let promise = this.loadLayout(layout)
-      promise.then(() => {
-        this.setLayout(layout)
-        Vue.nextTick(() => hotReloadAPI(this))
-      })
-      return promise
-      <% } else { %>
-      return
-      <% } %>
-    })
-    <% if (features.layouts) { %>
-    .then(() => {
-      return callMiddleware.call(this, Components, context, this.layout)
-    })
-    <% } %>
-    .then(() => {
-      <% if (features.asyncData) { %>
-      // Call asyncData(context)
-      let pAsyncData = promisify(Component.options.asyncData || noopData, context)
-      pAsyncData.then((asyncDataResult) => {
-        applyAsyncData(Component, asyncDataResult)
-        <%= (loading ? 'this.$loading.increase && this.$loading.increase(30)' : '') %>
-      })
-      promises.push(pAsyncData)
-      <% } %>
-
-      <% if (features.fetch) { %>
-      // Call fetch()
-      Component.options.fetch = Component.options.fetch || noopFetch
-      let pFetch = Component.options.fetch.length && Component.options.fetch(context)
-      if (!pFetch || (!(pFetch instanceof Promise) && (typeof pFetch.then !== 'function'))) { pFetch = Promise.resolve(pFetch) }
-      <%= (loading ? 'pFetch.then(() => this.$loading.increase && this.$loading.increase(30))' : '') %>
-      promises.push(pFetch)
-      <% } %>
-      return Promise.all(promises)
-    })
-    .then(() => {
-      <%= (loading ? 'this.$loading.finish && this.$loading.finish()' : '') %>
-      _forceUpdate()
-      setTimeout(() => hotReloadAPI(this), 100)
-    })
-  }
-}
-<% } %>
-
-async function mountApp (__app) {
-  // Set global variables
-  app = __app.app
-  router = __app.router
-  <% if (store) { %>store = __app.store<% } %>
-
-  // Create Vue instance
-  const _app = new Vue(app)
-
-  <% if (isFullStatic) { %>
-  // Load page chunk
-  if (!NUXT.data && NUXT.serverRendered) {
-    try {
-      const payload = await _app.fetchPayload(NUXT.routePath || _app.context.route.path)
-      Object.assign(NUXT, payload)
-    } catch (err) {}
-  }
-  <% } %>
-
-  <% if (features.layouts && mode !== 'spa') { %>
-  // Load layout
-  const layout = NUXT.layout || 'default'
-  await _app.loadLayout(layout)
-  _app.setLayout(layout)
-  <% } %>
-
-  // Mounts Vue app to DOM element
-  const mount = () => {
-    _app.$mount('#<%= globals.id %>')
-
-    // Add afterEach router hooks
-    router.afterEach(normalizeComponents)
-    <% if (features.layouts) { %>
-    router.afterEach(setLayoutForNextPage.bind(_app))
-    <% } %>
-    router.afterEach(fixPrepatch.bind(_app))
-
-    // Listen for first Vue update
-    Vue.nextTick(() => {
-      // Call window.{{globals.readyCallback}} callbacks
-      nuxtReady(_app)
-      <% if (isDev) { %>
-      // Enable hot reloading
-      hotReloadAPI(_app)
-      <% } %>
-    })
-  }
-  <% if (features.transitions) { %>
-  // Resolve route components
-  const Components = await Promise.all(resolveComponents(app.context.route))
-
-  // 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))
-  }
-  <% } else if (features.asyncData || features.fetch) { %>
-  await Promise.all(resolveComponents(app.context.route))
-  <% } %>
-  // Initialize error handler
-  _app.$loading = {} // To avoid error while _app.$nuxt does not exist
-  if (NUXT.error) {
-    _app.error(NUXT.error)
-  }
-
-  // Add beforeEach router hooks
-  router.beforeEach(loadAsyncComponents.bind(_app))
-  router.beforeEach(render.bind(_app))
-
-  // Fix in static: remove trailing slash to force hydration
-  // Full static, if server-rendered: hydrate, to allow custom redirect to generated page
-  <% if (isFullStatic) { %>
-  if (NUXT.serverRendered) {
-    return mount()
-  }
-  <% } else { %>
-  // Fix in static: remove trailing slash to force hydration
-  if (NUXT.serverRendered && isSamePath(NUXT.routePath, _app.context.route.path)) {
-    return mount()
-  }
-  <% } %>
-
-  // First render on client-side
-  const clientFirstMount = () => {
-    normalizeComponents(router.currentRoute, router.currentRoute)
-    setLayoutForNextPage.call(_app, router.currentRoute)
-    checkForErrors(_app)
-    // Don't call fixPrepatch.call(_app, router.currentRoute, router.currentRoute) since it's first render
-    mount()
-  }
-
-  // fix: force next tick to avoid having same timestamp when an error happen on spa fallback
-  await new Promise(resolve => setTimeout(resolve, 0))
-  render.call(_app, router.currentRoute, router.currentRoute, (path) => {
-    // If not redirected
-    if (!path) {
-      clientFirstMount()
-      return
-    }
-
-    // Add a one-time afterEach hook to
-    // mount the app wait for redirect and route gets resolved
-    const unregisterHook = router.afterEach((to, from) => {
-      unregisterHook()
-      clientFirstMount()
-    })
-
-    // Push the path and let route to be resolved
-    router.push(path, undefined, (err) => {
-      if (err) {
-        errorHandler(err)
-      }
-    })
-  })
-}

node_modules/@nuxt/vue-app/template/components/nuxt-build-indicator.vue

@@ -1,143 +0,0 @@
-<template>
-  <transition appear>
-    <div v-if="building" class="nuxt__build_indicator" :style="indicatorStyle">
-      <svg viewBox="0 0 96 72" version="1" xmlns="http://www.w3.org/2000/svg">
-        <g fill="none" fill-rule="evenodd">
-          <path d="M6 66h23l1-3 21-37L40 6 6 66zM79 66h11L62 17l-5 9 22 37v3zM54 31L35 66h38z" />
-          <path d="M29 69v-1-2H6L40 6l11 20 3-6L44 3s-2-3-4-3-3 1-5 3L1 63c0 1-2 3 0 6 0 1 2 2 5 2h28c-3 0-4-1-5-2z" fill="#00C58E" />
-          <path d="M95 63L67 14c0-1-2-3-5-3-1 0-3 0-4 3l-4 6 3 6 5-9 28 49H79a5 5 0 0 1 0 3c-2 2-5 2-5 2h16c1 0 4 0 5-2 1-1 2-3 0-6z" fill="#00C58E" />
-          <path d="M79 69v-1-2-3L57 26l-3-6-3 6-21 37-1 3a5 5 0 0 0 0 3c1 1 2 2 5 2h40s3 0 5-2zM54 31l19 35H35l19-35z" fill="#FFF" fill-rule="nonzero" />
-        </g>
-      </svg>
-      {{ animatedProgress }}%
-    </div>
-  </transition>
-</template>
-
-<script>
-export default {
-  name: 'NuxtBuildIndicator',
-  data () {
-    return {
-      building: false,
-      progress: 0,
-      animatedProgress: 0,
-      reconnectAttempts: 0
-    }
-  },
-  computed: {
-    options: () => (<%= JSON.stringify(buildIndicator) %>),
-    indicatorStyle () {
-      const [d1, d2] = this.options.position.split('-')
-      return {
-        [d1]: '20px',
-        [d2]: '20px',
-        'background-color': this.options.backgroundColor,
-        color: this.options.color
-      }
-    }
-  },
-  watch: {
-    progress (val, oldVal) {
-      // Average progress may decrease but ignore it!
-      if (val < oldVal) {
-        return
-      }
-      // Cancel old animation
-      clearInterval(this._progressAnimation)
-      // Jump to edge immediately
-      if (val < 10 || val > 90) {
-        this.animatedProgress = val
-        return
-      }
-      // Animate to value
-      this._progressAnimation = setInterval(() => {
-        const diff = this.progress - this.animatedProgress
-        if (diff > 0) {
-          this.animatedProgress++
-        } else {
-          clearInterval(this._progressAnimation)
-        }
-      }, 50)
-    }
-  },
-  mounted () {
-    if (EventSource === undefined) {
-      return // Unsupported
-    }
-    this.sseConnect()
-  },
-  beforeDestroy () {
-    this.sseClose()
-    clearInterval(this._progressAnimation)
-  },
-  methods: {
-    sseConnect () {
-      if (this._connecting) {
-        return
-      }
-      this._connecting = true
-      this.sse = new EventSource('<%= nuxtOptions.build.loadingScreen.baseURLAlt %>/sse')
-      this.sse.addEventListener('message', event => this.onSseMessage(event))
-    },
-    onSseMessage (message) {
-      const data = JSON.parse(message.data)
-      if (!data.states) {
-        return
-      }
-
-      this.progress = Math.round(data.states.reduce((p, s) => p + s.progress, 0) / data.states.length)
-
-      if (!data.allDone) {
-        this.building = true
-      } else {
-        this.$nextTick(() => {
-          this.building = false
-          this.animatedProgress = 0
-          this.progress = 0
-          clearInterval(this._progressAnimation)
-        })
-      }
-    },
-
-    sseClose () {
-      if (this.sse) {
-        this.sse.close()
-        delete this.sse
-      }
-    }
-  }
-}
-</script>
-
-<style scoped>
-.nuxt__build_indicator {
-  box-sizing: border-box;
-  position: fixed;
-  font-family: monospace;
-  padding: 5px 10px;
-  border-radius: 5px;
-  box-shadow: 1px 1px 2px 0px rgba(0,0,0,0.2);
-  width: 88px;
-  z-index: 2147483647;
-  font-size: 16px;
-  line-height: 1.2rem;
-}
-.v-enter-active, .v-leave-active {
-  transition-delay: 0.2s;
-  transition-property: all;
-  transition-duration: 0.3s;
-}
-.v-leave-to {
-  opacity: 0;
-  transform: translateY(20px);
-}
-svg {
-  display: inline-block;
-  vertical-align: baseline;
-  width: 1.1em;
-  height: 0.825em;
-  position: relative;
-  top: 1px;
-}
-</style>

node_modules/@nuxt/vue-app/template/components/nuxt-child.js

@@ -1,128 +0,0 @@
-<%= isTest ? '// @vue/component' : '' %>
-export default {
-  name: 'NuxtChild',
-  functional: true,
-  props: {
-    nuxtChildKey: {
-      type: String,
-      default: ''
-    },
-    keepAlive: Boolean,
-    keepAliveProps: {
-      type: Object,
-      default: undefined
-    }
-  },
-  render (_, { parent, data, props }) {
-    const h = parent.$createElement
-    <% if (features.transitions) { %>
-    data.nuxtChild = true
-    const _parent = parent
-    const transitions = parent.<%= globals.nuxt %>.nuxt.transitions
-    const defaultTransition = parent.<%= globals.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)
-      }
-    })
-    if (process.client) {
-      // Add triggerScroll event on beforeEnter (fix #1376)
-      const beforeEnter = listeners.beforeEnter
-      listeners.beforeEnter = (el) => {
-        // Ensure to trigger scroll event after calling scrollBehavior
-        window.<%= globals.nuxt %>.$nextTick(() => {
-          window.<%= globals.nuxt %>.$emit('triggerScroll')
-        })
-        if (beforeEnter) {
-          return beforeEnter.call(_parent, el)
-        }
-      }
-    }
-
-    // make sure that leave is called asynchronous (fix #5703)
-    if (transition.css === false) {
-      const leave = listeners.leave
-
-      // only add leave listener when user didnt provide one
-      // or when it misses the done argument
-      if (!leave || leave.length < 2) {
-        listeners.leave = (el, done) => {
-          if (leave) {
-            leave.call(_parent, el)
-          }
-
-          _parent.$nextTick(done)
-        }
-      }
-    }
-    <% } %>
-    let routerView = h('routerView', data)
-
-    if (props.keepAlive) {
-      routerView = h('keep-alive', { props: props.keepAliveProps }, [routerView])
-    }
-
-    <% if (features.transitions) { %>
-    return h('transition', {
-      props: transitionProps,
-      on: listeners
-    }, [routerView])
-    <% } else { %>
-    return routerView
-    <% } %>
-  }
-}
-
-<% if (features.transitions) { %>
-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'
-]
-<% } %>

node_modules/@nuxt/vue-app/template/components/nuxt-error.vue

@@ -1,99 +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">
-        <a v-if="typeof $route === 'undefined'" class="error-link" href="/"><% messages.back_to_home %></a>
-        <NuxtLink v-else class="error-link" to="/"><%= messages.back_to_home %></NuxtLink>
-      </p>
-      <% if(debug) { %>
-      <p class="description" v-else><%= messages.client_error_details %></p>
-      <% } %>
-
-      <div class="logo">
-        <a href="https://nuxtjs.org" target="_blank" rel="noopener"><%= messages.nuxtjs %></a>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script>
-export default {
-  name: 'NuxtError',
-  props: {
-    error: {
-      type: Object,
-      default: null
-    }
-  },
-  computed: {
-    statusCode () {
-      return (this.error && this.error.statusCode) || 500
-    },
-    message () {
-      return this.error.message || '<%= messages.client_error %>'
-    }
-  },
-  head () {
-    return {
-      title: this.message,
-      meta: [
-        {
-          name: 'viewport',
-          content: 'width=device-width,initial-scale=1.0,minimum-scale=1.0'
-        }
-      ]
-    }
-  }
-}
-</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>

node_modules/@nuxt/vue-app/template/components/nuxt-link.client.js

@@ -1,128 +0,0 @@
-import Vue from 'vue'
-
-const requestIdleCallback = window.requestIdleCallback ||
-  function (cb) {
-    const start = Date.now()
-    return setTimeout(function () {
-      cb({
-        didTimeout: false,
-        timeRemaining: () => Math.max(0, 50 - (Date.now() - start))
-      })
-    }, 1)
-  }
-
-const cancelIdleCallback = window.cancelIdleCallback || function (id) {
-  clearTimeout(id)
-}
-
-const observer = window.IntersectionObserver && new window.IntersectionObserver((entries) => {
-  entries.forEach(({ intersectionRatio, target: link }) => {
-    if (intersectionRatio <= 0 || !link.__prefetch) {
-      return
-    }
-    link.__prefetch()
-  })
-})
-
-<%= isTest ? '// @vue/component' : '' %>
-export default {
-  name: 'NuxtLink',
-  extends: Vue.component('RouterLink'),
-  props: {
-    prefetch: {
-      type: Boolean,
-      default: <%= router.prefetchLinks ? 'true' : 'false' %>
-    },
-    noPrefetch: {
-      type: Boolean,
-      default: false
-    }<% if (router.linkPrefetchedClass) { %>,
-    prefetchedClass: {
-      type: String,
-      default: '<%= router.linkPrefetchedClass %>'
-    }<% } %>
-  },
-  mounted () {
-    if (this.prefetch && !this.noPrefetch) {
-      this.handleId = requestIdleCallback(this.observe, { timeout: 2e3 })
-    }
-  },
-  beforeDestroy () {
-    cancelIdleCallback(this.handleId)
-
-    if (this.__observed) {
-      observer.unobserve(this.$el)
-      delete this.$el.__prefetch
-    }
-  },
-  methods: {
-    observe () {
-      // If no IntersectionObserver, avoid prefetching
-      if (!observer) {
-        return
-      }
-      // Add to observer
-      if (this.shouldPrefetch()) {
-        this.$el.__prefetch = this.prefetchLink.bind(this)
-        observer.observe(this.$el)
-        this.__observed = true
-      }<% if (router.linkPrefetchedClass) { %> else {
-        this.addPrefetchedClass()
-      }<% } %>
-    },
-    shouldPrefetch () {
-      <% if (isFullStatic && router.prefetchPayloads) { %>
-      const ref = this.$router.resolve(this.to, this.$route, this.append)
-      const Components = ref.resolved.matched.map(r => r.components.default)
-
-      return Components.filter(Component => ref.href || (typeof Component === 'function' && !Component.options && !Component.__prefetched)).length
-      <% } else { %>return this.getPrefetchComponents().length > 0<% } %>
-    },
-    canPrefetch () {
-      const conn = navigator.connection
-      const hasBadConnection = this.<%= globals.nuxt %>.isOffline || (conn && ((conn.effectiveType || '').includes('2g') || conn.saveData))
-
-      return !hasBadConnection
-    },
-    getPrefetchComponents () {
-      const ref = this.$router.resolve(this.to, this.$route, this.append)
-      const Components = ref.resolved.matched.map(r => r.components.default)
-
-      return Components.filter(Component => typeof Component === 'function' && !Component.options && !Component.__prefetched)
-    },
-    prefetchLink () {
-      if (!this.canPrefetch()) {
-        return
-      }
-      // Stop observing this link (in case of internet connection changes)
-      observer.unobserve(this.$el)
-      const Components = this.getPrefetchComponents()
-      <% if (router.linkPrefetchedClass) { %>const promises = []<% } %>
-
-      for (const Component of Components) {
-        const componentOrPromise = Component()
-        if (componentOrPromise instanceof Promise) {
-          componentOrPromise.catch(() => {})
-          <% if (router.linkPrefetchedClass) { %>promises.push(componentOrPromise)<% } %>
-        }
-        Component.__prefetched = true
-      }
-      <% if (isFullStatic && router.prefetchPayloads) { %>
-      // Preload the data only if not in preview mode
-      if (!this.$root.isPreview) {
-        const { href } = this.$router.resolve(this.to, this.$route, this.append)
-        if (this.<%= globals.nuxt %>)
-          this.<%= globals.nuxt %>.fetchPayload(href, true).catch(() => {})
-      }
-      <% } %>
-      <% if (router.linkPrefetchedClass) { %>
-      return Promise.all(promises).then(() => this.addPrefetchedClass())
-      <% } %>
-    }<% if (router.linkPrefetchedClass) { %>,
-    addPrefetchedClass () {
-      if (this.prefetchedClass !== 'false') {
-        this.$el.className = (this.$el.className + ' ' + this.prefetchedClass).trim()
-      }
-    }<% } %>
-  }
-}

node_modules/@nuxt/vue-app/template/components/nuxt-link.server.js

@@ -1,17 +0,0 @@
-import Vue from 'vue'
-
-<%= isTest ? '// @vue/component' : '' %>
-export default {
-  name: 'NuxtLink',
-  extends: Vue.component('RouterLink'),
-  props: {
-    prefetch: {
-      type: Boolean,
-      default: <%= router.prefetchLinks ? 'true' : 'false' %>
-    },
-    noPrefetch: {
-      type: Boolean,
-      default: false
-    }
-  }
-}

node_modules/@nuxt/vue-app/template/components/nuxt-loading.vue

@@ -1,177 +0,0 @@
-<script>
-export default {
-  name: 'NuxtLoading',
-  data () {
-    return {
-      percent: 0,
-      show: false,
-      canSucceed: true,
-      reversed: false,
-      skipTimerCount: 0,
-      rtl: <%= Boolean(loading.rtl) %>,
-      throttle: <%= typeof loading.throttle === 'number' ? loading.throttle : 200 %>,
-      duration: <%= typeof loading.duration === 'number' ? loading.duration : 3000 %>,
-      continuous: <%= Boolean(loading.continuous) %>
-    }
-  },
-  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 (error) {
-      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>
-<% if (loading && loading.css) { %>
-<style>
-.nuxt-progress {
-  position: fixed;
-  top: 0px;
-  left: <%= loading.rtl === true ? 'auto' : '0px' %>;
-  right: 0px;
-  height: <%= loading.height %>;
-  width: 0%;
-  opacity: 1;
-  transition: width 0.1s, opacity 0.4s;
-  background-color: <%= loading.color %>;
-  z-index: 999999;
-}
-
-.nuxt-progress.nuxt-progress-notransition {
-  transition: none;
-}
-
-.nuxt-progress-failed {
-  background-color: <%= loading.failedColor %>;
-}
-</style><% } %>

node_modules/@nuxt/vue-app/template/components/nuxt.js

@@ -1,109 +0,0 @@
-import Vue from 'vue'
-import { compile } from '../utils'
-
-<% if (components.ErrorPage) { %>
-  <% if (('~@').includes(components.ErrorPage.charAt(0))) { %>
-import NuxtError from '<%= components.ErrorPage %>'
-  <% } else { %>
-import NuxtError from '<%= "../" + components.ErrorPage %>'
-  <% } %>
-<% } else { %>
-import NuxtError from './nuxt-error.vue'
-<% } /* components */ %>
-import NuxtChild from './nuxt-child'
-
-<%= isTest ? '// @vue/component' : '' %>
-export default {
-  name: 'Nuxt',
-  components: {
-    NuxtChild,
-    NuxtError
-  },
-  props: {
-    nuxtChildKey: {
-      type: String,
-      default: undefined
-    },
-    keepAlive: Boolean,
-    keepAliveProps: {
-      type: Object,
-      default: undefined
-    },
-    name: {
-      type: String,
-      default: 'default'
-    }
-  },
-  errorCaptured (error) {
-    // if we receive and error while showing the NuxtError component
-    // capture the error and force an immediate update so we re-render
-    // without the NuxtError component
-    if (this.displayingNuxtError) {
-      this.errorFromNuxtError = error
-      this.$forceUpdate()
-    }
-  },
-  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 [matchedRoute] = this.$route.matched
-
-      if (!matchedRoute) {
-        return this.$route.path
-      }
-
-      const Component = matchedRoute.components.default
-
-      if (Component && Component.options) {
-        const { options } = Component
-
-        if (options.key) {
-          return (typeof options.key === 'function' ? options.key(this.$route) : options.key)
-        }
-      }
-
-      const strict = /\/$/.test(matchedRoute.path)
-      return strict ? this.$route.path : this.$route.path.replace(/\/$/, '')
-    }
-  },
-  beforeCreate () {
-    Vue.util.defineReactive(this, 'nuxt', this.$root.$options.nuxt)
-  },
-  render (h) {
-    // if there is no error
-    if (!this.nuxt.err) {
-      // Directly return nuxt child
-      return h('NuxtChild', {
-        key: this.routerViewKey,
-        props: this.$props
-      })
-    }
-
-    // if an error occurred within NuxtError show a simple
-    // error message instead to prevent looping
-    if (this.errorFromNuxtError) {
-      this.$nextTick(() => (this.errorFromNuxtError = false))
-
-      return h('div', {}, [
-        h('h2', 'An error occurred while showing the error page'),
-        h('p', 'Unfortunately an error occurred and while showing the error page another error occurred'),
-        h('p', `Error details: ${this.errorFromNuxtError.toString()}`),
-        h('nuxt-link', { props: { to: '/' } }, 'Go back to home')
-      ])
-    }
-
-    // track if we are showing the NuxtError component
-    this.displayingNuxtError = true
-    this.$nextTick(() => (this.displayingNuxtError = false))
-
-    return h(NuxtError, {
-      props: {
-        error: this.nuxt.err
-      }
-    })
-  }
-}

node_modules/@nuxt/vue-app/template/empty.js

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

node_modules/@nuxt/vue-app/template/index.js

@@ -1,305 +0,0 @@
-import Vue from 'vue'
-<% if (store) { %>import Vuex from 'vuex'<% } %>
-<% if (features.meta) { %>import Meta from 'vue-meta'<% } %>
-<% if (features.componentClientOnly) { %>import ClientOnly from 'vue-client-only'<% } %>
-<% if (features.deprecations) { %>import NoSsr from 'vue-no-ssr'<% } %>
-import { createRouter } from './router.js'
-import NuxtChild from './components/nuxt-child.js'
-import NuxtError from '<%= components.ErrorPage ? components.ErrorPage : "./components/nuxt-error.vue" %>'
-import Nuxt from './components/nuxt.js'
-import App from '<%= appPath %>'
-import { setContext, getLocation, getRouteData, normalizeError } from './utils'
-<% if (store) { %>import { createStore } from './store.js'<% } %>
-
-/* Plugins */
-<%= isTest ? '/* eslint-disable camelcase */' : '' %>
-<% plugins.forEach((plugin) => { %>import <%= plugin.name %> from '<%= plugin.name %>' // Source: <%= relativeToBuild(plugin.src) %> (mode: '<%= plugin.mode %>')
-<% }) %>
-<%= isTest ? '/* eslint-enable camelcase */' : '' %>
-
-<% if (features.componentClientOnly) { %>
-// Component: <ClientOnly>
-Vue.component(ClientOnly.name, ClientOnly)
-<% } %>
-<% if (features.deprecations) { %>
-// TODO: Remove in Nuxt 3: <NoSsr>
-Vue.component(NoSsr.name, {
-  ...NoSsr,
-  render (h, ctx) {
-    if (process.client && !NoSsr._warned) {
-      NoSsr._warned = true
-      <%= isTest ? '// eslint-disable-next-line no-console' : '' %>
-      console.warn('<no-ssr> has been deprecated and will be removed in Nuxt 3, please use <client-only> instead')
-    }
-    return NoSsr.render(h, ctx)
-  }
-})
-<% } %>
-// Component: <NuxtChild>
-Vue.component(NuxtChild.name, NuxtChild)
-<% if (features.componentAliases) { %>Vue.component('NChild', NuxtChild)<% } %>
-
-// Component NuxtLink is imported in server.js or client.js
-
-// Component: <Nuxt>
-Vue.component(Nuxt.name, Nuxt)
-
-Object.defineProperty(Vue.prototype, '<%= globals.nuxt %>', {
-  get() {
-    const globalNuxt = this.$root.$options.<%= globals.nuxt %>
-    if (process.client && !globalNuxt && typeof window !== 'undefined') {
-      return window.<%= globals.nuxt %>
-    }
-    return globalNuxt
-  },
-  configurable: true
-})
-
-<% if (features.meta) {
-// vue-meta configuration
-const vueMetaOptions = {
-  ...nuxtOptions.vueMeta,
-  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
-}
-%>
-Vue.use(Meta, <%= JSON.stringify(vueMetaOptions) %>)<%= isTest ? '// eslint-disable-line' : '' %>
-<% } %>
-
-<% if (features.transitions) { %>
-const defaultTransition = <%=
-  serialize(pageTransition)
-  .replace('beforeEnter(', 'function(').replace('enter(', 'function(').replace('afterEnter(', 'function(')
-  .replace('enterCancelled(', 'function(').replace('beforeLeave(', 'function(').replace('leave(', 'function(')
-  .replace('afterLeave(', 'function(').replace('leaveCancelled(', 'function(').replace('beforeAppear(', 'function(')
-  .replace('appear(', 'function(').replace('afterAppear(', 'function(').replace('appearCancelled(', 'function(')
-%><%= isTest ? '// eslint-disable-line' : '' %>
-<% } %>
-
-<% if (store) { %>
-const originalRegisterModule = Vuex.Store.prototype.registerModule
-
-function registerModule (path, rawModule, options = {}) {
-  const preserveState = process.client && (
-    Array.isArray(path)
-      ? !!path.reduce((namespacedState, path) => namespacedState && namespacedState[path], this.state)
-      : path in this.state
-  )
-  return originalRegisterModule.call(this, path, rawModule, { preserveState, ...options })
-}
-<% } %>
-
-async function createApp(ssrContext, config = {}) {
-  const router = await createRouter(ssrContext, config)
-
-  <% if (store) { %>
-  const store = createStore(ssrContext)
-  // Add this.$router into store actions/mutations
-  store.$router = router
-    <% if (mode === 'universal') { %>
-  // Fix SSR caveat https://github.com/nuxt/nuxt.js/issues/3757#issuecomment-414689141
-  store.registerModule = registerModule
-    <% } %>
-  <% } %>
-
-  // 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 = {
-    <% if (features.meta) { %>
-    <%= isTest ? '/* eslint-disable array-bracket-spacing, quotes, quote-props, semi, indent, comma-spacing, key-spacing, object-curly-spacing, space-before-function-paren, object-shorthand  */' : '' %>
-    head: <%= serializeFunction(head) %>,
-    <%= isTest ? '/* eslint-enable array-bracket-spacing, quotes, quote-props, semi, indent, comma-spacing, key-spacing, object-curly-spacing, space-before-function-paren, object-shorthand */' : '' %>
-    <% } %>
-    <% if (store) { %>store,<%  } %>
-    router,
-    nuxt: {
-      <% if (features.transitions) { %>
-      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 = Boolean(err)
-        err = err ? normalizeError(err) : null
-        let nuxt = app.nuxt // to work with @vue/composition-api, see https://github.com/nuxt/nuxt.js/issues/6517#issuecomment-573280207
-        if (this) {
-          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
-  }
-  <% if (store) { %>
-  // Make app available into store via this.app
-  store.app = 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, router.options.mode)
-    route = router.resolve(path).route
-  }
-
-  // Set context to app.context
-  await setContext(app, {
-    <% if (store) { %>store,<% } %>
-    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,
-    ssrContext
-  })
-
-  function inject(key, value) {
-    if (!key) {
-      throw new Error('inject(key, value) has no key provided')
-    }
-    if (value === undefined) {
-      throw new Error(`inject('${key}', value) has no value provided`)
-    }
-
-    key = '$' + key
-    // Add into app
-    app[key] = value
-    // Add into context
-    if (!app.context[key]) {
-      app.context[key] = value
-    }
-    <% if (store) { %>
-    // Add into store
-    store[key] = app[key]
-    <% } %>
-    // Check if plugin not already installed
-    const installKey = '__<%= globals.pluginPrefix %>_' + key + '_installed__'
-    if (Vue[installKey]) {
-      return
-    }
-    Vue[installKey] = true
-    // Call Vue.use() to install the plugin into vm
-    Vue.use(() => {
-      if (!Object.prototype.hasOwnProperty.call(Vue.prototype, key)) {
-        Object.defineProperty(Vue.prototype, key, {
-          get () {
-            return this.$root.$options[key]
-          }
-        })
-      }
-    })
-  }
-
-  // Inject runtime config as $config
-  inject('config', config)
-
-  <% if (store) { %>
-  if (process.client) {
-    // Replace store state before plugins execution
-    if (window.<%= globals.context %> && window.<%= globals.context %>.state) {
-      store.replaceState(window.<%= globals.context %>.state)
-    }
-  }
-  <% } %>
-
-  // Add enablePreview(previewData = {}) in context for plugins
-  if (process.static && process.client) {
-    app.context.enablePreview = function (previewData = {}) {
-      app.previewData = Object.assign({}, previewData)
-      inject('preview', previewData)
-    }
-  }
-  // Plugin execution
-  <%= isTest ? '/* eslint-disable camelcase */' : '' %>
-  <% plugins.forEach((plugin) => { %>
-  <% if (plugin.mode == 'client') { %>
-  if (process.client && typeof <%= plugin.name %> === 'function') {
-    await <%= plugin.name %>(app.context, inject)
-  }
-  <% } else if (plugin.mode == 'server') { %>
-  if (process.server && typeof <%= plugin.name %> === 'function') {
-    await <%= plugin.name %>(app.context, inject)
-  }
-  <% } else { %>
-  if (typeof <%= plugin.name %> === 'function') {
-    await <%= plugin.name %>(app.context, inject)
-  }
-  <% } %>
-  <% }) %>
-  <%= isTest ? '/* eslint-enable camelcase */' : '' %>
-  // Lock enablePreview in context
-  if (process.static && process.client) {
-    app.context.enablePreview = function () {
-      console.warn('You cannot call enablePreview() outside a plugin.')
-    }
-  }
-
-  // Wait for async component to be resolved first
-  await new Promise((resolve, reject) => {
-    // Ignore 404s rather than blindly replacing URL in browser
-    if (process.client) {
-      const { route } = router.resolve(app.context.route.fullPath)
-      if (!route.matched.length) {
-        return resolve()
-      }
-    }
-    router.replace(app.context.route.fullPath, resolve, (err) => {
-      // https://github.com/vuejs/vue-router/blob/v3.4.3/src/util/errors.js
-      if (!err._isRouter) return reject(err)
-      if (err.type !== 2 /* NavigationFailureType.redirected */) return resolve()
-
-      // navigated to a different route in router guard
-      const unregister = router.afterEach(async (to, from) => {
-        if (process.server && ssrContext && ssrContext.url) {
-          ssrContext.url = to.fullPath
-        }
-        app.context.route = await getRouteData(to)
-        app.context.params = to.params || {}
-        app.context.query = to.query || {}
-        unregister()
-        resolve()
-      })
-    })
-  })
-
-  return {
-    <% if(store) { %>store,<%  } %>
-    app,
-    router
-  }
-}
-
-export { createApp, NuxtError }

node_modules/@nuxt/vue-app/template/jsonp.js

@@ -1,83 +0,0 @@
-const chunks = {} // chunkId => exports
-const chunksInstalling = {} // chunkId => Promise
-const failedChunks = {}
-
-function importChunk(chunkId, src) {
-  // Already installed
-  if (chunks[chunkId]) {
-    return Promise.resolve(chunks[chunkId])
-  }
-
-  // Failed loading
-  if (failedChunks[chunkId]) {
-    return Promise.reject(failedChunks[chunkId])
-  }
-
-  // Installing
-  if (chunksInstalling[chunkId]) {
-    return chunksInstalling[chunkId]
-  }
-
-  // Set a promise in chunk cache
-  let resolve, reject
-  const promise = chunksInstalling[chunkId] = new Promise((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  })
-
-  // Clear chunk data from cache
-  delete chunks[chunkId]
-
-  // Start chunk loading
-  const script = document.createElement('script')
-  script.charset = 'utf-8'
-  script.timeout = 120
-  script.src = src
-  let timeout
-
-  // Create error before stack unwound to get useful stacktrace later
-  const error = new Error()
-
-  // Complete handlers
-  const onScriptComplete = script.onerror = script.onload = (event) => {
-    // Cleanups
-    clearTimeout(timeout)
-    delete chunksInstalling[chunkId]
-
-    // Avoid mem leaks in IE
-    script.onerror = script.onload = null
-
-    // Verify chunk is loaded
-    if (chunks[chunkId]) {
-      return resolve(chunks[chunkId])
-    }
-
-    // Something bad happened
-    const errorType = event && (event.type === 'load' ? 'missing' : event.type)
-    const realSrc = event && event.target && event.target.src
-    error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')'
-    error.name = 'ChunkLoadError'
-    error.type = errorType
-    error.request = realSrc
-    failedChunks[chunkId] = error
-    reject(error)
-  }
-
-  // Timeout
-  timeout = setTimeout(() => {
-    onScriptComplete({ type: 'timeout', target: script })
-  }, 120000)
-
-  // Append script
-  document.head.appendChild(script)
-
-  // Return promise
-  return promise
-}
-
-export function installJsonp() {
-  window.__NUXT_JSONP__ = function (chunkId, exports) { chunks[chunkId] = exports }
-  window.__NUXT_JSONP_CACHE__ = chunks
-  window.__NUXT_IMPORT__ = importChunk
-}
-

node_modules/@nuxt/vue-app/template/layouts/default.vue

@@ -1,3 +0,0 @@
-<template>
-  <Nuxt />
-</template>

node_modules/@nuxt/vue-app/template/middleware.js

@@ -1,12 +0,0 @@
-const middleware = {}
-<%= isTest ? '/* eslint-disable dot-notation */' : '' %>
-<% for (const m of middleware) {
-  // TODO: remove duplicate logic in v3 (see builder.resolveMiddleware)
-  const name = m.name || m.src.replace(new RegExp(`\\.(${extensions})$`), '')
-  const dst = m.dst || relativeToBuild(srcDir, dir.middleware, m.src)
-%>
-middleware['<%= name %>'] = require('<%= dst %>')
-middleware['<%= name %>'] = middleware['<%= name %>'].default || middleware['<%= name %>']
-<% } %>
-<%= isTest ? '/* eslint-enable dot-notation */' : '' %>
-export default middleware

node_modules/@nuxt/vue-app/template/mixins/fetch.client.js

@@ -1,134 +0,0 @@
-import Vue from 'vue'
-import { hasFetch, normalizeError, addLifecycleHook, createGetCounter } from '../utils'
-
-const isSsrHydration = (vm) => vm.$vnode && vm.$vnode.elm && vm.$vnode.elm.dataset && vm.$vnode.elm.dataset.fetchKey
-const nuxtState = window.<%= globals.context %>
-
-export default {
-  beforeCreate () {
-    if (!hasFetch(this)) {
-      return
-    }
-
-    this._fetchDelay = typeof this.$options.fetchDelay === 'number' ? this.$options.fetchDelay : 200
-
-    Vue.util.defineReactive(this, '$fetchState', {
-      pending: false,
-      error: null,
-      timestamp: Date.now()
-    })
-
-    this.$fetch = $fetch.bind(this)
-    addLifecycleHook(this, 'created', created)
-    addLifecycleHook(this, 'beforeMount', beforeMount)
-  }
-}
-
-function beforeMount() {
-  if (!this._hydrated) {
-    return this.$fetch()
-  }
-}
-
-function created() {
-  if (!isSsrHydration(this)) {
-    <% if (isFullStatic) { %>createdFullStatic.call(this)<% } %>
-    return
-  }
-
-  // Hydrate component
-  this._hydrated = true
-  this._fetchKey = this.$vnode.elm.dataset.fetchKey
-  const data = nuxtState.fetch[this._fetchKey]
-
-  // If fetch error
-  if (data && data._error) {
-    this.$fetchState.error = data._error
-    return
-  }
-
-  // Merge data
-  for (const key in data) {
-    Vue.set(this.$data, key, data[key])
-  }
-}
-
-<% if (isFullStatic) { %>
-function createdFullStatic() {
-  // Check if component has been fetched on server
-  let fetchedOnServer = this.$options.fetchOnServer !== false
-  if (typeof this.$options.fetchOnServer === 'function') {
-    fetchedOnServer = this.$options.fetchOnServer.call(this) !== false
-  }
-  if (!fetchedOnServer || this.<%= globals.nuxt %>.isPreview || !this.<%= globals.nuxt %>._pagePayload) {
-    return
-  }
-  this._hydrated = true
-
-  const defaultKey = this.$options._scopeId || this.$options.name || ''
-  const getCounter = createGetCounter(this.<%= globals.nuxt %>._fetchCounters, defaultKey)
-
-  if (typeof this.$options.fetchKey === 'function') {
-    this._fetchKey = this.$options.fetchKey.call(this, getCounter)
-  } else {
-    const key = 'string' === typeof this.$options.fetchKey ? this.$options.fetchKey : defaultKey
-    this._fetchKey = key ? key + ':' + getCounter(key) : String(getCounter(key))
-  }
-
-  const data = this.<%= globals.nuxt %>._pagePayload.fetch[this._fetchKey]
-
-  // If fetch error
-  if (data && data._error) {
-    this.$fetchState.error = data._error
-    return
-  }
-
-  // If there is a missing payload
-  if (!data) {
-    this.$fetch()
-    return
-  }
-
-  // Merge data
-  for (const key in data) {
-    Vue.set(this.$data, key, data[key])
-  }
-}
-<% } %>
-
-function $fetch() {
-  if (!this._fetchPromise) {
-    this._fetchPromise = $_fetch.call(this)
-      .then(() => { delete this._fetchPromise })
-  }
-  return this._fetchPromise
-}
-
-async function $_fetch() {
-  this.<%= globals.nuxt %>.nbFetching++
-  this.$fetchState.pending = true
-  this.$fetchState.error = null
-  this._hydrated = false
-  let error = null
-  const startTime = Date.now()
-
-  try {
-    await this.$options.fetch.call(this)
-  } catch (err) {
-    if (process.dev) {
-      console.error('Error in fetch():', err)
-    }
-    error = normalizeError(err)
-  }
-
-  const delayLeft = this._fetchDelay - (Date.now() - startTime)
-  if (delayLeft > 0) {
-    await new Promise(resolve => setTimeout(resolve, delayLeft))
-  }
-
-  this.$fetchState.error = error
-  this.$fetchState.pending = false
-  this.$fetchState.timestamp = Date.now()
-
-  this.$nextTick(() => this.<%= globals.nuxt %>.nbFetching--)
-}

node_modules/@nuxt/vue-app/template/mixins/fetch.server.js

@@ -1,70 +0,0 @@
-import Vue from 'vue'
-import { hasFetch, normalizeError, addLifecycleHook, purifyData, createGetCounter } from '../utils'
-
-async function serverPrefetch() {
-  if (!this._fetchOnServer) {
-    return
-  }
-
-  // Call and await on $fetch
-  try {
-    await this.$options.fetch.call(this)
-  } catch (err) {
-    if (process.dev) {
-      console.error('Error in fetch():', err)
-    }
-    this.$fetchState.error = normalizeError(err)
-  }
-  this.$fetchState.pending = false
-
-
-  // Define an ssrKey for hydration
-  this._fetchKey = this._fetchKey || this.$ssrContext.fetchCounters['']++
-
-  // Add data-fetch-key on parent element of Component
-  const attrs = this.$vnode.data.attrs = this.$vnode.data.attrs || {}
-  attrs['data-fetch-key'] = this._fetchKey
-
-  // Add to ssrContext for window.__NUXT__.fetch
-  <% if (debug) { %>
-  if (this.$ssrContext.nuxt.fetch[this._fetchKey] !== undefined) {
-    console.warn(`Duplicate fetch key detected (${this._fetchKey}). This may lead to unexpected results.`)
-  }
-  <% } %>
-  this.$ssrContext.nuxt.fetch[this._fetchKey] =
-    this.$fetchState.error ? { _error: this.$fetchState.error } : purifyData(this._data)
-}
-
-export default {
-  created() {
-    if (!hasFetch(this)) {
-      return
-    }
-
-    if (typeof this.$options.fetchOnServer === 'function') {
-      this._fetchOnServer = this.$options.fetchOnServer.call(this) !== false
-    } else {
-      this._fetchOnServer = this.$options.fetchOnServer !== false
-    }
-
-    const defaultKey = this.$options._scopeId || this.$options.name || ''
-    const getCounter = createGetCounter(this.$ssrContext.fetchCounters, defaultKey)
-
-    if (typeof this.$options.fetchKey === 'function') {
-      this._fetchKey = this.$options.fetchKey.call(this, getCounter)
-    } else {
-      const key = 'string' === typeof this.$options.fetchKey ? this.$options.fetchKey : defaultKey
-      this._fetchKey = key ? key + ':' + getCounter(key) : String(getCounter(key))
-    }
-
-    // Added for remove vue undefined warning while ssr
-    this.$fetch = () => {} // issue #8043
-    Vue.util.defineReactive(this, '$fetchState', {
-      pending: true,
-      error: null,
-      timestamp: Date.now()
-    })
-
-    addLifecycleHook(this, 'serverPrefetch', serverPrefetch)
-  }
-}

node_modules/@nuxt/vue-app/template/nuxt/config.json

@@ -1,5 +0,0 @@
-<%= JSON.stringify({
-  isFullStatic: isFullStatic,
-  ssr: nuxtOptions.render.ssr,
-  target: nuxtOptions.target
-}, null, 2) %>

node_modules/@nuxt/vue-app/template/pages/index.vue

@@ -1,108 +0,0 @@
-<template>
-  <div>
-    <section class="Landscape">
-      <div class="Landscape__Logo">
-        <svg class="logo" width="220" height="166" xmlns="http://www.w3.org/2000/svg">
-          <g transform="translate(-18 -29)" fill="none" fill-rule="evenodd">
-            <path d="M0 176h67.883a22.32 22.32 0 0 1 2.453-7.296L134 57.718 100.881 0 0 176zM218.694 176H250L167.823 32 153 58.152l62.967 110.579a21.559 21.559 0 0 1 2.727 7.269z" />
-            <path d="M86.066 189.388a8.241 8.241 0 0 1-.443-.908 11.638 11.638 0 0 1-.792-6.566H31.976l78.55-138.174 33.05 58.932L154 94.882l-32.69-58.64C120.683 35.1 116.886 29 110.34 29c-2.959 0-7.198 1.28-10.646 7.335L20.12 176.185c-.676 1.211-3.96 7.568-.7 13.203C20.912 191.95 24.08 195 31.068 195h66.646c-6.942 0-10.156-3.004-11.647-5.612z" fill="#00C58E" />
-            <path d="M235.702 175.491L172.321 62.216c-.655-1.191-4.313-7.216-10.68-7.216-2.868 0-6.977 1.237-10.32 7.193L143 75.706v26.104l18.709-32.31 62.704 111.626h-23.845c.305 1.846.134 3.74-.496 5.498a7.06 7.06 0 0 1-.497 1.122l-.203.413c-3.207 5.543-10.139 5.841-11.494 5.841h37.302c1.378 0 8.287-.298 11.493-5.841 1.423-2.52 2.439-6.758-.97-12.668z" fill="#108775" />
-            <path d="M201.608 189.07l.21-.418c.206-.364.378-.745.515-1.139a10.94 10.94 0 0 0 .515-5.58 16.938 16.938 0 0 0-2.152-5.72l-49.733-87.006L143.5 76h-.136l-7.552 13.207-49.71 87.006a17.534 17.534 0 0 0-1.917 5.72c-.4 2.21-.148 4.486.725 6.557.13.31.278.613.444.906 1.497 2.558 4.677 5.604 11.691 5.604h92.592c1.473 0 8.651-.302 11.971-5.93zm-58.244-86.657l45.455 79.52H97.934l45.43-79.52z" fill="#2F4A5F" fill-rule="nonzero" />
-          </g>
-        </svg>
-      </div>
-      <h2 class="Landscape__Title">The Vue.js Framework</h2>
-      <a href="https://nuxtjs.org/guide/installation#starting-from-scratch" target="_blank" class="button">
-        Get Started
-      </a>
-      <p class="Landscape__Page__Explanation">Please create <a href="https://nuxtjs.org/guide/directory-structure#the-pages-directory" target="_blank">the pages directory</a> to suppress this default page.</p>
-    </section>
-  </div>
-</template>
-
-<style>
-  .Landscape {
-    min-height: calc(100vh - 200px);
-    background-color: #fff;
-    padding: 70px 15px;
-    padding-top: 80px;
-    text-align: center;
-  }
-
-  @media (min-width: 992px) {
-    .Landscape {
-      padding: 0 30px;
-      padding-top: 140px;
-    }
-  }
-
-  .Landscape__Logo__Title {
-    margin:0;
-    padding:0;
-    font-family: "Quicksand", "Source Sans Pro", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-    display: block;
-    font-weight: 300;
-    font-size: 100px;
-    color: #35495e;
-    letter-spacing: 1px;
-    padding: 0 15px;
-  }
-
-  @media (min-width: 992px) {
-    .Landscape__Logo__Title {
-      font-size: 120px;
-      display: inline-block;
-      padding: 0;
-      padding-left: 30px;
-    }
-  }
-
-  .Landscape__Title {
-      font-family: "Quicksand", "Source Sans Pro", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-      font-size: 45px;
-      font-weight: 300;
-      line-height: normal;
-      margin: 0;
-      margin-top: 10px;
-      color: #526488;
-      word-spacing: 5px;
-  }
-
-  .Landscape__Page__Explanation {
-      font-family: "Quicksand", "Source Sans Pro", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-      color: #35495e;
-      margin: 16px 0 0;
-      font-size: 16px;
-  }
-
-  .Landscape__Page__Explanation > a {
-      color: #3b8070;
-      text-decoration: underline;
-  }
-
-  @media (min-width: 992px) {
-    .Landscape__Title {
-      font-size: 60px;
-    }
-  }
-
-  .button {
-    font-family: "Quicksand", "Source Sans Pro", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-    position: relative;
-    display: inline-block;
-    color: #fff!important;
-    font-size: 16px;
-    font-weight: 600;
-    padding: 14px 42px;
-    padding-top: 13px;
-    min-width: 150px;
-    text-align: center;
-    text-transform: uppercase;
-    text-decoration: none;
-    background-color: #3b8070;
-    border-radius: 4px;
-    letter-spacing: 1px;
-    border: 1px solid #3b8070;
-    margin-top: 40px;
-  }
-</style>

node_modules/@nuxt/vue-app/template/router.js

@@ -1,123 +0,0 @@
-import Vue from 'vue'
-import Router from 'vue-router'
-import { normalizeURL, decode } from 'ufo'
-import { interopDefault } from './utils'<%= isTest ? '// eslint-disable-line no-unused-vars' : '' %>
-import scrollBehavior from './router.scrollBehavior.js'
-
-<% function recursiveRoutes(routes, tab, components, indentCount) {
-  let res = ''
-  const baseIndent = tab.repeat(indentCount)
-  const firstIndent = '\n' + tab.repeat(indentCount + 1)
-  const nextIndent = ',' + firstIndent
-  routes.forEach((route, i) => {
-    let resMap = ''
-    // If need to handle named views
-    if (route.components) {
-      let _name = '_' + hash(route.components.default)
-      if (splitChunks.pages) {
-        resMap += `${firstIndent}${tab}default: ${_name}`
-      } else {
-        resMap += `${firstIndent}${tab}default: () => ${_name}.default || ${_name}`
-      }
-      for (const k in route.components) {
-        _name = '_' + hash(route.components[k])
-        const component = { _name, component: route.components[k] }
-        if (k === 'default') {
-          components.push({
-            ...component,
-            name: route.name,
-            chunkName: route.chunkName
-          })
-        } else {
-          components.push({
-            ...component,
-            name: `${route.name}-${k}`,
-            chunkName: route.chunkNames[k]
-          })
-          if (splitChunks.pages) {
-            resMap += `${nextIndent}${tab}${k}: ${_name}`
-          } else {
-            resMap += `${nextIndent}${tab}${k}: () => ${_name}.default || ${_name}`
-          }
-        }
-      }
-      route.component = false
-    } else {
-      route._name = '_' + hash(route.component)
-      components.push({ _name: route._name, component: route.component, name: route.name, chunkName: route.chunkName })
-    }
-    // @see: https://router.vuejs.org/api/#router-construction-options
-    res += '{'
-    res += firstIndent + 'path: ' + JSON.stringify(route.path)
-    res += (route.components) ? nextIndent + 'components: {' + resMap + '\n' + baseIndent + tab + '}' : ''
-    res += (route.component) ? nextIndent + 'component: ' + route._name : ''
-    res += (route.redirect) ? nextIndent + 'redirect: ' + (typeof route.redirect === 'function' ? serialize(route.redirect) : JSON.stringify(route.redirect)) : ''
-    res += (route.meta) ? nextIndent + 'meta: ' + JSON.stringify(route.meta) : ''
-    res += (typeof route.props !== 'undefined') ? nextIndent + 'props: ' + (typeof route.props === 'function' ? serialize(route.props) : JSON.stringify(route.props)) : ''
-    res += (typeof route.caseSensitive !== 'undefined') ? nextIndent + 'caseSensitive: ' + JSON.stringify(route.caseSensitive) : ''
-    res += (route.alias) ? nextIndent + 'alias: ' + JSON.stringify(route.alias) : ''
-    res += (route.pathToRegexpOptions) ? nextIndent + 'pathToRegexpOptions: ' + JSON.stringify(route.pathToRegexpOptions) : ''
-    res += (route.name) ? nextIndent + 'name: ' + JSON.stringify(route.name) : ''
-    if (route.beforeEnter) {
-      if(isTest) { res += ',\n/* eslint-disable indent, semi */' }
-      res += (isTest ? firstIndent : nextIndent) + 'beforeEnter: ' + serialize(route.beforeEnter)
-      if(isTest) { res += firstIndent + '/* eslint-enable indent, semi */' }
-    }
-    res += (route.children) ? nextIndent + 'children: [' + recursiveRoutes(routes[i].children, tab, components, indentCount + 1) + ']' : ''
-    res += '\n' + baseIndent + '}' + (i + 1 === routes.length ? '' : ', ')
-  })
-  return res
-}
-const _components = []
-const _routes = recursiveRoutes(router.routes, '  ', _components, 1)
-%><%= uniqBy(_components, '_name').map((route) => {
-  if (!route.component) return ''
-  const path = relativeToBuild(route.component)
-  const chunkName = wChunk(route.chunkName)
-  const name = route._name
-
-  if (splitChunks.pages) {
-    return `const ${name} = () => interopDefault(import('${path}' /* webpackChunkName: "${chunkName}" */))`
-  } else {
-    return `import ${name} from '${path}'`
-  }
-}).join('\n')%>
-
-const emptyFn = () => {}
-
-Vue.use(Router)
-
-export const routerOptions = {
-  mode: '<%= router.mode %>',
-  base: '<%= router.base %>',
-  linkActiveClass: '<%= router.linkActiveClass %>',
-  linkExactActiveClass: '<%= router.linkExactActiveClass %>',
-  scrollBehavior,
-  <%= isTest ? '/* eslint-disable array-bracket-spacing, quotes, quote-props, object-curly-spacing, key-spacing */' : '' %>
-  routes: [<%= _routes %>],
-  <%= isTest ? '/* eslint-enable array-bracket-spacing, quotes, quote-props, object-curly-spacing, key-spacing */' : '' %>
-  <% if (router.parseQuery) { %>parseQuery: <%= serializeFunction(router.parseQuery) %>,<% } %>
-  <% if (router.stringifyQuery) { %>stringifyQuery: <%= serializeFunction(router.stringifyQuery) %>,<% } %>
-  fallback: <%= router.fallback %>
-}
-
-export function createRouter (ssrContext, config) {
-  const base = (config._app && config._app.basePath) || routerOptions.base
-  const router = new Router({ ...routerOptions, base  })
-
-  // TODO: remove in Nuxt 3
-  const originalPush = router.push
-  router.push = function push (location, onComplete = emptyFn, onAbort) {
-    return originalPush.call(this, location, onComplete, onAbort)
-  }
-
-  const resolve = router.resolve.bind(router)
-  router.resolve = (to, current, append) => {
-    if (typeof to === 'string') {
-      to = normalizeURL(to)
-    }
-    return resolve(to, current, append)
-  }
-
-  return router
-}

node_modules/@nuxt/vue-app/template/router.scrollBehavior.js

@@ -1,82 +0,0 @@
-<% if (router.scrollBehavior) { %>
-<%= isTest ? '/* eslint-disable quotes, semi, indent, comma-spacing, key-spacing, object-curly-spacing, space-before-function-paren  */' : '' %>
-export default <%= serializeFunction(router.scrollBehavior) %>
-<%= isTest ? '/* eslint-enable quotes, semi, indent, comma-spacing, key-spacing, object-curly-spacing, space-before-function-paren  */' : '' %>
-<% } else { %>import { getMatchedComponents, setScrollRestoration } from './utils'
-
-if (process.client) {
-  if ('scrollRestoration' in window.history) {
-    setScrollRestoration('manual')
-
-    // reset scrollRestoration to auto when leaving page, allowing page reload
-    // and back-navigation from other pages to use the browser to restore the
-    // scrolling position.
-    window.addEventListener('beforeunload', () => {
-      setScrollRestoration('auto')
-    })
-
-    // Setting scrollRestoration to manual again when returning to this page.
-    window.addEventListener('load', () => {
-      setScrollRestoration('manual')
-    })
-  }
-}
-
-function shouldScrollToTop(route) {
-   const Pages = getMatchedComponents(route)
-   if (Pages.length === 1) {
-     const { options = {} } = Pages[0]
-     return options.scrollToTop !== false
-   }
-   return Pages.some(({ options }) => options && options.scrollToTop)
-}
-
-export default function (to, from, savedPosition) {
-  // If the returned position is falsy or an empty object, will retain current scroll position
-  let position = false
-  const isRouteChanged = to !== from
-
-  // savedPosition is only available for popstate navigations (back button)
-  if (savedPosition) {
-    position = savedPosition
-  } else if (isRouteChanged && shouldScrollToTop(to)) {
-    position = { x: 0, y: 0 }
-  }
-
-  const nuxt = window.<%= globals.nuxt %>
-
-  if (
-    // Initial load (vuejs/vue-router#3199)
-    !isRouteChanged ||
-    // Route hash changes
-    (to.path === from.path && to.hash !== from.hash)
-  ) {
-    nuxt.$nextTick(() => nuxt.$emit('triggerScroll'))
-  }
-
-  return new Promise((resolve) => {
-    // wait for the out transition to complete (if necessary)
-    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) {
-          <%= isTest ? '// eslint-disable-next-line no-console' : '' %>
-          console.warn('Failed to save scroll position. Please add CSS.escape() polyfill (https://github.com/mathiasbynens/CSS.escape).')
-        }
-      }
-      resolve(position)
-    })
-  })
-}
-<% } %>

node_modules/@nuxt/vue-app/template/routes.json

@@ -1 +0,0 @@
-<%= JSON.stringify(router.routes, null, 2) %>

node_modules/@nuxt/vue-app/template/server.js

@@ -1,351 +0,0 @@
-import Vue from 'vue'
-import { joinURL, normalizeURL, withQuery } from 'ufo'
-<% if (fetch.server) { %>import fetch from 'node-fetch'<% } %>
-<% if (features.middleware) { %>import middleware from './middleware.js'<% } %>
-import {
-  <% if (features.asyncData) { %>applyAsyncData,<% } %>
-  <% if (features.middleware) { %>middlewareSeries,<% } %>
-  <% if (features.middleware && features.layouts) { %>sanitizeComponent,<% } %>
-  getMatchedComponents,
-  promisify
-} from './utils.js'
-<% if (features.fetch) { %>import fetchMixin from './mixins/fetch.server'<% } %>
-import { createApp<% if (features.layouts) { %>, NuxtError<% } %> } from './index.js'
-import NuxtLink from './components/nuxt-link.server.js' // should be included after ./index.js
-
-<% if (features.fetch) { %>
-// Update serverPrefetch strategy
-Vue.config.optionMergeStrategies.serverPrefetch = Vue.config.optionMergeStrategies.created
-
-// Fetch mixin
-if (!Vue.__nuxt__fetch__mixin__) {
-  Vue.mixin(fetchMixin)
-  Vue.__nuxt__fetch__mixin__ = true
-}
-<% } %>
-
-<% if (isDev) { %>
-if (!Vue.__original_use__) {
-  Vue.__original_use__ = Vue.use
-  Vue.__install_times__ = 0
-  Vue.use = function (plugin, ...args) {
-    plugin.__nuxt_external_installed__ = Vue._installedPlugins.includes(plugin)
-    return Vue.__original_use__(plugin, ...args)
-  }
-}
-if (Vue.__install_times__ === 2) {
-  Vue.__install_times__ = 0
-  Vue._installedPlugins = Vue._installedPlugins.filter(plugin => {
-    return plugin.__nuxt_external_installed__ === true
-  })
-}
-Vue.__install_times__++
-<% } %>
-
-// Component: <NuxtLink>
-Vue.component(NuxtLink.name, NuxtLink)
-<% if (features.componentAliases) { %>Vue.component('NLink', NuxtLink)<% } %>
-
-<% if (fetch.server) { %>if (!global.fetch) { global.fetch = fetch }<% } %>
-
-const noopApp = () => new Vue({ render: h => h('div', { domProps: { id: '<%= globals.id %>' } }) })
-
-const createNext = ssrContext => (opts) => {
-  // If static target, render on client-side
-  ssrContext.redirected = opts
-  if (ssrContext.target === 'static' || !ssrContext.res) {
-    ssrContext.nuxt.serverRendered = false
-    return
-  }
-  let fullPath = withQuery(opts.path, opts.query)
-  const $config = ssrContext.runtimeConfig || {}
-  const routerBase = ($config._app && $config._app.basePath) || '<%= router.base %>'
-  if (!fullPath.startsWith('http') && (routerBase !== '/' && !fullPath.startsWith(routerBase))) {
-    fullPath = joinURL(routerBase, fullPath)
-  }
-  // Avoid loop redirect
-  if (decodeURI(fullPath) === decodeURI(ssrContext.url)) {
-    ssrContext.redirected = false
-    return
-  }
-  ssrContext.res.writeHead(opts.status, {
-    Location: normalizeURL(fullPath)
-  })
-  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 = { <% if (features.layouts) { %>layout: 'default', <% } %>data: [], <% if (features.fetch) { %>fetch: {}, <% } %>error: null<%= (store ? ', state: null' : '') %>, serverRendered: true, routePath: '' }
-  <% if (features.fetch) { %>
-    ssrContext.fetchCounters = {}
-  <% } %>
-
-  // Remove query from url is static target
-  <% if (isFullStatic) { %>
-  if (ssrContext.url) {
-    ssrContext.url = ssrContext.url.split('?')[0]
-  }
-  <% } %>
-  // Public runtime config
-  ssrContext.nuxt.config = ssrContext.runtimeConfig.public
-  if (ssrContext.nuxt.config._app) {
-    __webpack_public_path__ = joinURL(ssrContext.nuxt.config._app.cdnURL, ssrContext.nuxt.config._app.assetsPath)
-  }
-  // Create the app definition and the instance (created for each request)
-  const { app, router<%= (store ? ', store' : '') %> } = await createApp(ssrContext, ssrContext.runtimeConfig.private)
-  const _app = new Vue(app)
-  // Add ssr route path to nuxt context so we can account for page navigation between ssr and csr
-  ssrContext.nuxt.routePath = app.context.route.path
-
-  <% if (features.meta) { %>
-  // Add meta infos (used in renderer.js)
-  ssrContext.meta = _app.$meta()
-  <% } %>
-  <% if (features.asyncData) { %>
-  // 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 })))
-    <% if (store) { %>
-    ssrContext.rendered = () => {
-      // Add the state from the vuex store
-      ssrContext.nuxt.state = store.state
-      <% if (isFullStatic && store) { %>
-      // Stop recording store mutations
-      ssrContext.unsetMutationObserver()
-      <% } %>
-    }
-    <% } %>
-  }
-
-  const renderErrorPage = async () => {
-    // Don't server-render the page in static target
-    if (ssrContext.target === 'static') {
-      ssrContext.nuxt.serverRendered = false
-    }
-    <% if (features.layouts) { %>
-    // Load layout for error page
-    const layout = (NuxtError.options || NuxtError).layout
-    const errLayout = typeof layout === 'function' ? layout.call(NuxtError, app.context) : 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: '<%= messages.error_404 %>' })
-    return renderErrorPage()
-  }
-
-  <% if (debug) { %>const s = Date.now()<% } %>
-
-  // Components are already resolved by setContext -> getRouteData (app/utils.js)
-  const Components = getMatchedComponents(app.context.route)
-
-  <% if (store) { %>
-  /*
-  ** Dispatch store nuxtServerInit
-  */
-  if (store._actions && store._actions.nuxtServerInit) {
-    try {
-      await store.dispatch('nuxtServerInit', app.context)
-    } catch (err) {
-      console.debug('Error occurred when calling nuxtServerInit: ', err.message)<%= isTest ? '// eslint-disable-line no-console' : '' %>
-      throw err
-    }
-  }
-  // ...If there is a redirect or an error, stop the process
-  if (ssrContext.redirected) {
-    return noopApp()
-  }
-  if (ssrContext.nuxt.error) {
-    return renderErrorPage()
-  }
-  <% } %>
-
-  <% if (features.middleware) { %>
-  /*
-  ** Call global middleware (nuxt.config.js)
-  */
-  let midd = <%= serialize(router.middleware).replace('middleware(', 'function(') %><%= isTest ? '// eslint-disable-line' : '' %>
-  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()
-  }
-  <% } %>
-
-  <% if (isFullStatic && store) { %>
-  // Record store mutations for full-static after nuxtServerInit and Middleware
-  ssrContext.nuxt.mutations =[]
-  ssrContext.unsetMutationObserver = store.subscribe(m => { ssrContext.nuxt.mutations.push([m.type, m.payload]) })
-  <% } %>
-
-  <% if (features.layouts) { %>
-  /*
-  ** 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
-  <% } %>
-
-  <% if (features.middleware) { %>
-  /*
-  ** Call middleware (layout + pages)
-  */
-  midd = []
-  <% if (features.layouts) { %>
-  layout = sanitizeComponent(layout)
-  if (layout.options.middleware) {
-    midd = midd.concat(layout.options.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()
-  }
-  <% } %>
-
-  <% if (features.validate) { %>
-  /*
-  ** 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) {
-    // Render a 404 error page
-    return render404Page()
-  }
-  <% } %>
-
-  // If no Components found, returns 404
-  if (!Components.length) {
-    return render404Page()
-  }
-
-  <% if (features.asyncData || features.fetch) { %>
-  // Call asyncData & fetch hooks on components matched by the route.
-  const asyncDatas = await Promise.all(Components.map((Component) => {
-    const promises = []
-
-    <% if (features.asyncData) { %>
-    // 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)
-    }
-    <% } %>
-
-    <% if (features.fetch) { %>
-    // Call fetch(context)
-    if (Component.options.fetch && Component.options.fetch.length) {
-      promises.push(Component.options.fetch(app.context))
-    } else {
-      promises.push(null)
-    }
-    <% } %>
-
-    return Promise.all(promises)
-  }))
-
-  <% if (debug) { %>if (process.env.DEBUG && asyncDatas.length) console.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
-}

node_modules/@nuxt/vue-app/template/store.js

@@ -1,158 +0,0 @@
-import Vue from 'vue'
-import Vuex from 'vuex'
-
-Vue.use(Vuex)
-
-<%
-const willResolveStoreModules = storeModules.some(s => s.src.indexOf('index.') !== 0)
-if (willResolveStoreModules) { %>
-const VUEX_PROPERTIES = ['state', 'getters', 'actions', 'mutations']
-<% } %>
-let store = {};
-
-(function updateModules () {
-  <% storeModules.some(s => {
-    if(s.src.indexOf('index.') === 0) { %>
-  store = normalizeRoot(require('<%= relativeToBuild(srcDir, dir.store, s.src) %>'), '<%= dir.store %>/<%= s.src %>')
-  <% return true }}) %>
-
-  // If store is an exported method = classic mode (deprecated)
-  <% if (isDev) { %>
-  if (typeof store === 'function') {
-    <%= isTest ? '// eslint-disable-next-line no-console' : '' %>
-    return console.warn('Classic mode for store/ is deprecated and will be removed in Nuxt 3.')
-  }<% } %>
-
-  // Enforce store modules
-  store.modules = store.modules || {}
-
-  <% storeModules.forEach(s => {
-    if(s.src.indexOf('index.') !== 0) { %>
-  resolveStoreModules(require('<%= relativeToBuild(srcDir, dir.store, s.src) %>'), '<%= s.src %>')<% }}) %>
-
-  // If the environment supports hot reloading...
-  <% if (isDev) { %>
-  if (process.client && module.hot) {
-    // Whenever any Vuex module is updated...
-    module.hot.accept([<% storeModules.forEach(s => { %>
-      '<%= relativeToBuild(srcDir, dir.store, s.src) %>',<% }) %>
-    ], () => {
-      // Update `root.modules` with the latest definitions.
-      updateModules()
-      // Trigger a hot update in the store.
-      window.<%= globals.nuxt %>.$store.hotUpdate(store)
-    })
-  }<% } %>
-})()
-
-// createStore
-export const createStore = store instanceof Function ? store : () => {
-  return new Vuex.Store(Object.assign({
-    strict: (process.env.NODE_ENV !== 'production')
-  }, store))
-}
-
-function normalizeRoot (moduleData, filePath) {
-  moduleData = moduleData.default || moduleData
-
-  if (moduleData.commit) {
-    throw new Error(`[nuxt] ${filePath} should export a method that returns a Vuex instance.`)
-  }
-
-  if (typeof moduleData !== 'function') {
-    // Avoid TypeError: setting a property that has only a getter when overwriting top level keys
-    moduleData = Object.assign({}, moduleData)
-  }
-  return normalizeModule(moduleData, filePath)
-}
-
-function normalizeModule (moduleData, filePath) {
-  if (moduleData.state && typeof moduleData.state !== 'function') {
-    <%= isTest ? '// eslint-disable-next-line no-console' : '' %>
-    console.warn(`'state' should be a method that returns an object in ${filePath}`)
-
-    const state = Object.assign({}, moduleData.state)
-    // Avoid TypeError: setting a property that has only a getter when overwriting top level keys
-    moduleData = Object.assign({}, moduleData, { state: () => state })
-  }
-  return moduleData
-}
-
-<% if (willResolveStoreModules) { %>
-function resolveStoreModules (moduleData, filename) {
-  moduleData = moduleData.default || moduleData
-  // Remove store src + extension (./foo/index.js -> foo/index)
-  const namespace = filename.replace(/\.(<%= extensions %>)$/, '')
-  const namespaces = namespace.split('/')
-  let moduleName = namespaces[namespaces.length - 1]
-  const filePath = `<%= dir.store %>/${filename}`
-
-  moduleData = moduleName === 'state'
-    ? normalizeState(moduleData, filePath)
-    : normalizeModule(moduleData, filePath)
-
-  // If src is a known Vuex property
-  if (VUEX_PROPERTIES.includes(moduleName)) {
-    const property = moduleName
-    const propertyStoreModule = getStoreModule(store, namespaces, { isProperty: true })
-
-    // Replace state since it's a function
-    mergeProperty(propertyStoreModule, moduleData, property)
-    return
-  }
-
-  // If file is foo/index.js, it should be saved as foo
-  const isIndexModule = (moduleName === 'index')
-  if (isIndexModule) {
-    namespaces.pop()
-    moduleName = namespaces[namespaces.length - 1]
-  }
-
-  const storeModule = getStoreModule(store, namespaces)
-
-  for (const property of VUEX_PROPERTIES) {
-    mergeProperty(storeModule, moduleData[property], property)
-  }
-
-  if (moduleData.namespaced === false) {
-    delete storeModule.namespaced
-  }
-}
-
-function normalizeState (moduleData, filePath) {
-  if (typeof moduleData !== 'function') {
-    <%= isTest ? '// eslint-disable-next-line no-console' : '' %>
-    console.warn(`${filePath} should export a method that returns an object`)
-    const state = Object.assign({}, moduleData)
-    return () => state
-  }
-  return normalizeModule(moduleData, filePath)
-}
-
-function getStoreModule (storeModule, namespaces, { isProperty = false } = {}) {
-  // If ./mutations.js
-  if (!namespaces.length || (isProperty && namespaces.length === 1)) {
-    return storeModule
-  }
-
-  const namespace = namespaces.shift()
-
-  storeModule.modules[namespace] = storeModule.modules[namespace] || {}
-  storeModule.modules[namespace].namespaced = true
-  storeModule.modules[namespace].modules = storeModule.modules[namespace].modules || {}
-
-  return getStoreModule(storeModule.modules[namespace], namespaces, { isProperty })
-}
-
-function mergeProperty (storeModule, moduleData, property) {
-  if (!moduleData) {
-    return
-  }
-
-  if (property === 'state') {
-    storeModule.state = moduleData || storeModule.state
-  } else {
-    storeModule[property] = Object.assign({}, storeModule[property], moduleData)
-  }
-}
-<% } %>

node_modules/@nuxt/vue-app/template/utils.js

@@ -1,639 +0,0 @@
-import Vue from 'vue'
-import { isSamePath as _isSamePath, joinURL, normalizeURL, withQuery, withoutTrailingSlash } from 'ufo'
-
-// window.{{globals.loadedCallback}} hook
-// Useful for jsdom testing or plugins (https://github.com/tmpvar/jsdom#dealing-with-asynchronous-script-loading)
-if (process.client) {
-  window.<%= globals.readyCallback %>Cbs = []
-  window.<%= globals.readyCallback %> = (cb) => {
-    window.<%= globals.readyCallback %>Cbs.push(cb)
-  }
-}
-
-export function createGetCounter (counterObject, defaultKey = '') {
-  return function getCounter (id = defaultKey) {
-    if (counterObject[id] === undefined) {
-      counterObject[id] = 0
-    }
-    return counterObject[id]++
-  }
-}
-
-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)
-}
-
-<% if (features.fetch) { %>
-export function hasFetch(vm) {
-  return vm.$options && typeof vm.$options.fetch === 'function' && !vm.$options.fetch.length
-}
-export function purifyData(data) {
-  if (process.env.NODE_ENV === 'production') {
-    return data
-  }
-
-  return Object.entries(data).filter(
-    ([key, value]) => {
-      const valid = !(value instanceof Function) && !(value instanceof Promise)
-      if (!valid) {
-        console.warn(`${key} is not able to be stringified. This will break in a production environment.`)
-      }
-      return valid
-    }
-    ).reduce((obj, [key, value]) => {
-      obj[key] = value
-      return obj
-    }, {})
-}
-export function getChildrenComponentInstancesUsingFetch(vm, instances = []) {
-  const children = vm.$children || []
-  for (const child of children) {
-    if (child.$fetch) {
-      instances.push(child)
-      continue; // Don't get the children since it will reload the template
-    }
-    if (child.$children) {
-      getChildrenComponentInstancesUsingFetch(child, instances)
-    }
-  }
-  return instances
-}
-<% } %>
-<% if (features.asyncData) { %>
-export function applyAsyncData (Component, asyncData) {
-  if (
-    // For SSR, we once all this function without second param to just apply asyncData
-    // Prevent doing this for each SSR request
-    !asyncData && Component.options.__hasNuxtData
-  ) {
-    return
-  }
-
-  const ComponentData = Component.options._originDataFn || Component.options.data || function () { return {} }
-  Component.options._originDataFn = ComponentData
-
-  Component.options.data = function () {
-    const data = ComponentData.call(this, this)
-    if (this.$ssrContext) {
-      asyncData = this.$ssrContext.asyncData[Component.cid]
-    }
-    return { ...data, ...asyncData }
-  }
-
-  Component.options.__hasNuxtData = true
-
-  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
-  }
-  // If no component name defined, set file path as name, (also fixes #5703)
-  if (!Component.options.name && Component.options.__file) {
-    Component.options.name = Component.options.__file
-  }
-  return Component
-}
-
-export function getMatchedComponents (route, matches = false, prop = 'components') {
-  return Array.prototype.concat.apply([], route.matched.map((m, index) => {
-    return Object.keys(m[prop]).map((key) => {
-      matches && matches.push(index)
-      return m[prop][key]
-    })
-  }))
-}
-
-export function getMatchedComponentsInstances (route, matches = false) {
-  return getMatchedComponents(route, matches, 'instances')
-}
-
-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, fn) {
-  return Promise.all(
-    flatMapComponents(route, async (Component, instance, match, key) => {
-      // If component is a function, resolve it
-      if (typeof Component === 'function' && !Component.options) {
-        try {
-          Component = await Component()
-        } catch (error) {
-          // Handle webpack chunk loading errors
-          // This may be due to a new deployment or a network problem
-          if (
-            error &&
-            error.name === 'ChunkLoadError' &&
-            typeof window !== 'undefined' &&
-            window.sessionStorage
-          ) {
-            const timeNow = Date.now()
-            const previousReloadTime = parseInt(window.sessionStorage.getItem('nuxt-reload'))
-
-            // check for previous reload time not to reload infinitely
-            if (!previousReloadTime || previousReloadTime + 60000 < timeNow) {
-              window.sessionStorage.setItem('nuxt-reload', timeNow)
-              window.location.reload(true /* skip cache */)
-            }
-          }
-
-          throw error
-        }
-      }
-      match.components[key] = Component = sanitizeComponent(Component)
-      return typeof fn === 'function' ? fn(Component, instance, match, key) : Component
-    })
-  )
-}
-
-export async function getRouteData (route) {
-  if (!route) {
-    return
-  }
-  // 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, index) => {
-      return { ...Component.options.meta, ...(route.matched[index] || {}).meta }
-    })
-  }
-}
-
-export async function setContext (app, context) {
-  // If context not defined, create it
-  if (!app.context) {
-    app.context = {
-      isStatic: process.static,
-      isDev: <%= isDev %>,
-      isHMR: false,
-      app,
-      <%= (store ? 'store: app.store,' : '') %>
-      payload: context.payload,
-      error: context.error,
-      base: app.router.options.base,
-      env: <%= JSON.stringify(env) %><%= isTest ? '// eslint-disable-line' : '' %>
-    }
-    // Only set once
-    <% if (!isFullStatic) { %>
-    if (context.req) {
-      app.context.req = context.req
-    }
-    if (context.res) {
-      app.context.res = context.res
-    }
-    <% } %>
-    if (context.ssrContext) {
-      app.context.ssrContext = context.ssrContext
-    }
-    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).route.fullPath
-      }
-      // "/absolute/route", "./relative/route" or "../relative/route"
-      if (/(^[.]{1,2}\/)|(^\/(?!\/))/.test(path)) {
-        app.context.next({
-          path,
-          query,
-          status
-        })
-      } else {
-        path = withQuery(path, query)
-        if (process.server) {
-          app.context.next({
-            path,
-            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.<%= globals.context %>
-    }
-  }
-
-  // Dynamic keys
-  const [currentRouteData, fromRouteData] = await Promise.all([
-    getRouteData(context.route),
-    getRouteData(context.from)
-  ])
-
-  if (context.route) {
-    app.context.route = currentRouteData
-  }
-
-  if (context.from) {
-    app.context.from = fromRouteData
-  }
-
-  app.context.next = context.next
-  app.context._redirected = false
-  app.context._errored = false
-  app.context.isHMR = <% if(isDev) { %>Boolean(context.isHMR)<% } else { %>false<% } %>
-  app.context.params = app.context.route.params || {}
-  app.context.query = app.context.route.query || {}
-}
-<% if (features.middleware) { %>
-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) {
-  <% if (features.deprecations) { %>
-  let promise
-  if (fn.length === 2) {
-    <% if (isDev) { %>
-      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)
-  }
-  <% } else { %>
-  const promise = fn(context)
-  <% } %>
-  if (promise && promise instanceof Promise && typeof promise.then === 'function') {
-    return promise
-  }
-  return Promise.resolve(promise)
-}
-
-// Imported from vue-router
-export function getLocation (base, mode) {
-  if (mode === 'hash') {
-    return window.location.hash.replace(/^#\//, '')
-  }
-
-  base = decodeURI(base).slice(0, -1) // consideration is base is normalized with trailing slash
-  let path = decodeURI(window.location.pathname)
-
-  if (base && path.startsWith(base)) {
-    path = path.slice(base.length)
-  }
-
-  const fullPath = (path || '/') + window.location.search + window.location.hash
-
-  return normalizeURL(fullPath)
-}
-
-// 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), 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 {
-    ...err,
-    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,
-      optional,
-      repeat,
-      partial,
-      asterisk: Boolean(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, slashAllowed) {
-  const re = slashAllowed ? /[?#]/g : /[/?#]/g
-  return encodeURI(str).replace(re, (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 encodeURIComponentPretty(str, true)
-}
-
-/**
- * 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')
-}
-
-/**
- * Expose a method for transforming tokens into the path function.
- */
-function tokensToFunction (tokens, options) {
-  // 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 + ')$', flags(options))
-    }
-  }
-
-  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
-  }
-}
-
-/**
- * Get the flags for a regexp from the options.
- *
- * @param  {Object} options
- * @return {string}
- */
-function flags (options) {
-  return options && options.sensitive ? '' : 'i'
-}
-
-export function addLifecycleHook(vm, hook, fn) {
-  if (!vm.$options[hook]) {
-    vm.$options[hook] = []
-  }
-  if (!vm.$options[hook].includes(fn)) {
-    vm.$options[hook].push(fn)
-  }
-}
-
-export const urlJoin = joinURL
-
-export const stripTrailingSlash = withoutTrailingSlash
-
-export const isSamePath = _isSamePath
-
-export function setScrollRestoration (newVal) {
-  try {
-    window.history.scrollRestoration = newVal;
-  } catch(e) {}
-}
-

node_modules/@nuxt/vue-app/template/views/app.template.html

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

node_modules/@nuxt/vue-app/template/views/error.html

@@ -1,23 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<title><%= messages.server_error %></title>
-<meta charset="utf-8">
-<meta content="width=device-width,initial-scale=1.0,minimum-scale=1.0,maximum-scale=1.0,user-scalable=no" name=viewport>
-<style>
-.__nuxt-error-page{padding: 1rem;background:#f7f8fb;color:#47494e;text-align:center;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;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:24px;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>
-</head>
-<body>
-  <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"><%= messages.server_error %></div>
-        <div class="description"><% if (debug) { %>{{ message }}<% } else { %><%= messages.server_error_details %><% } %></div>
-    </div>
-    <div class="logo">
-      <a href="https://nuxtjs.org" target="_blank" rel="noopener"><%= messages.nuxtjs %></a>
-    </div>
-  </div>
-</body>
-</html>

node_modules/@nuxt/vue-app/template/views/loading/chasing-dots.html

@@ -1,67 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= options.background %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-
-.spinner {
-  width: 40px;
-  height: 40px;
-  position: relative;
-  text-align: center;
-
-  -webkit-animation: sk-rotate 2.0s infinite linear;
-  animation: sk-rotate 2.0s infinite linear;
-}
-
-.dot1, .dot2 {
-  width: 60%;
-  height: 60%;
-  display: inline-block;
-  position: absolute;
-  top: 0;
-  background-color: <%= options.color %>;
-  border-radius: 100%;
-
-  -webkit-animation: sk-bounce 2.0s infinite ease-in-out;
-  animation: sk-bounce 2.0s infinite ease-in-out;
-}
-
-.dot2 {
-  top: auto;
-  bottom: 0;
-  -webkit-animation-delay: -1.0s;
-  animation-delay: -1.0s;
-}
-
-@-webkit-keyframes sk-rotate { 100% { -webkit-transform: rotate(360deg) }}
-@keyframes sk-rotate { 100% { transform: rotate(360deg); -webkit-transform: rotate(360deg) }}
-
-@-webkit-keyframes sk-bounce {
-  0%, 100% { -webkit-transform: scale(0.0) }
-  50% { -webkit-transform: scale(1.0) }
-}
-
-@keyframes sk-bounce {
-  0%, 100% {
-    transform: scale(0.0);
-    -webkit-transform: scale(0.0);
-  } 50% {
-    transform: scale(1.0);
-    -webkit-transform: scale(1.0);
-  }
-}
-</style>
-
-<div class="spinner">
-  <div class="dot1"></div>
-  <div class="dot2"></div>
-</div>
-
-<%= options.dev ? '<!-- http://tobiasahlin.com/spinkit -->' : '' %>

node_modules/@nuxt/vue-app/template/views/loading/circle.html

@@ -1,150 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= options.background %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-
-.sk-circle {
-  width: 40px;
-  height: 40px;
-  position: relative;
-}
-.sk-circle .sk-child {
-  width: 100%;
-  height: 100%;
-  position: absolute;
-  left: 0;
-  top: 0;
-}
-.sk-circle .sk-child:before {
-  content: '';
-  display: block;
-  margin: 0 auto;
-  width: 15%;
-  height: 15%;
-  background-color: <%= options.color %>;
-  border-radius: 100%;
-  -webkit-animation: sk-circleBounceDelay 1.2s infinite ease-in-out both;
-          animation: sk-circleBounceDelay 1.2s infinite ease-in-out both;
-}
-.sk-circle .sk-circle2 {
-  -webkit-transform: rotate(30deg);
-      -ms-transform: rotate(30deg);
-          transform: rotate(30deg); }
-.sk-circle .sk-circle3 {
-  -webkit-transform: rotate(60deg);
-      -ms-transform: rotate(60deg);
-          transform: rotate(60deg); }
-.sk-circle .sk-circle4 {
-  -webkit-transform: rotate(90deg);
-      -ms-transform: rotate(90deg);
-          transform: rotate(90deg); }
-.sk-circle .sk-circle5 {
-  -webkit-transform: rotate(120deg);
-      -ms-transform: rotate(120deg);
-          transform: rotate(120deg); }
-.sk-circle .sk-circle6 {
-  -webkit-transform: rotate(150deg);
-      -ms-transform: rotate(150deg);
-          transform: rotate(150deg); }
-.sk-circle .sk-circle7 {
-  -webkit-transform: rotate(180deg);
-      -ms-transform: rotate(180deg);
-          transform: rotate(180deg); }
-.sk-circle .sk-circle8 {
-  -webkit-transform: rotate(210deg);
-      -ms-transform: rotate(210deg);
-          transform: rotate(210deg); }
-.sk-circle .sk-circle9 {
-  -webkit-transform: rotate(240deg);
-      -ms-transform: rotate(240deg);
-          transform: rotate(240deg); }
-.sk-circle .sk-circle10 {
-  -webkit-transform: rotate(270deg);
-      -ms-transform: rotate(270deg);
-          transform: rotate(270deg); }
-.sk-circle .sk-circle11 {
-  -webkit-transform: rotate(300deg);
-      -ms-transform: rotate(300deg);
-          transform: rotate(300deg); }
-.sk-circle .sk-circle12 {
-  -webkit-transform: rotate(330deg);
-      -ms-transform: rotate(330deg);
-          transform: rotate(330deg); }
-.sk-circle .sk-circle2:before {
-  -webkit-animation-delay: -1.1s;
-          animation-delay: -1.1s; }
-.sk-circle .sk-circle3:before {
-  -webkit-animation-delay: -1s;
-          animation-delay: -1s; }
-.sk-circle .sk-circle4:before {
-  -webkit-animation-delay: -0.9s;
-          animation-delay: -0.9s; }
-.sk-circle .sk-circle5:before {
-  -webkit-animation-delay: -0.8s;
-          animation-delay: -0.8s; }
-.sk-circle .sk-circle6:before {
-  -webkit-animation-delay: -0.7s;
-          animation-delay: -0.7s; }
-.sk-circle .sk-circle7:before {
-  -webkit-animation-delay: -0.6s;
-          animation-delay: -0.6s; }
-.sk-circle .sk-circle8:before {
-  -webkit-animation-delay: -0.5s;
-          animation-delay: -0.5s; }
-.sk-circle .sk-circle9:before {
-  -webkit-animation-delay: -0.4s;
-          animation-delay: -0.4s; }
-.sk-circle .sk-circle10:before {
-  -webkit-animation-delay: -0.3s;
-          animation-delay: -0.3s; }
-.sk-circle .sk-circle11:before {
-  -webkit-animation-delay: -0.2s;
-          animation-delay: -0.2s; }
-.sk-circle .sk-circle12:before {
-  -webkit-animation-delay: -0.1s;
-          animation-delay: -0.1s; }
-
-@-webkit-keyframes sk-circleBounceDelay {
-  0%, 80%, 100% {
-    -webkit-transform: scale(0);
-            transform: scale(0);
-  } 40% {
-    -webkit-transform: scale(1);
-            transform: scale(1);
-  }
-}
-
-@keyframes sk-circleBounceDelay {
-  0%, 80%, 100% {
-    -webkit-transform: scale(0);
-            transform: scale(0);
-  } 40% {
-    -webkit-transform: scale(1);
-            transform: scale(1);
-  }
-}
-</style>
-
-<div class="sk-circle">
-  <div class="sk-circle1 sk-child"></div>
-  <div class="sk-circle2 sk-child"></div>
-  <div class="sk-circle3 sk-child"></div>
-  <div class="sk-circle4 sk-child"></div>
-  <div class="sk-circle5 sk-child"></div>
-  <div class="sk-circle6 sk-child"></div>
-  <div class="sk-circle7 sk-child"></div>
-  <div class="sk-circle8 sk-child"></div>
-  <div class="sk-circle9 sk-child"></div>
-  <div class="sk-circle10 sk-child"></div>
-  <div class="sk-circle11 sk-child"></div>
-  <div class="sk-circle12 sk-child"></div>
-</div>
-
-<%= options.dev ? '<!-- http://tobiasahlin.com/spinkit -->' : '' %>

node_modules/@nuxt/vue-app/template/views/loading/cube-grid.html

@@ -1,87 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= options.background %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-
-.sk-cube-grid {
-  width: 40px;
-  height: 40px;
-}
-
-.sk-cube-grid .sk-cube {
-  width: 33%;
-  height: 33%;
-  background-color: <%= options.color %>;
-  float: left;
-  -webkit-animation: sk-cubeGridScaleDelay 1.3s infinite ease-in-out;
-          animation: sk-cubeGridScaleDelay 1.3s infinite ease-in-out;
-}
-.sk-cube-grid .sk-cube1 {
-  -webkit-animation-delay: 0.2s;
-          animation-delay: 0.2s; }
-.sk-cube-grid .sk-cube2 {
-  -webkit-animation-delay: 0.3s;
-          animation-delay: 0.3s; }
-.sk-cube-grid .sk-cube3 {
-  -webkit-animation-delay: 0.4s;
-          animation-delay: 0.4s; }
-.sk-cube-grid .sk-cube4 {
-  -webkit-animation-delay: 0.1s;
-          animation-delay: 0.1s; }
-.sk-cube-grid .sk-cube5 {
-  -webkit-animation-delay: 0.2s;
-          animation-delay: 0.2s; }
-.sk-cube-grid .sk-cube6 {
-  -webkit-animation-delay: 0.3s;
-          animation-delay: 0.3s; }
-.sk-cube-grid .sk-cube7 {
-  -webkit-animation-delay: 0s;
-          animation-delay: 0s; }
-.sk-cube-grid .sk-cube8 {
-  -webkit-animation-delay: 0.1s;
-          animation-delay: 0.1s; }
-.sk-cube-grid .sk-cube9 {
-  -webkit-animation-delay: 0.2s;
-          animation-delay: 0.2s; }
-
-@-webkit-keyframes sk-cubeGridScaleDelay {
-  0%, 70%, 100% {
-    -webkit-transform: scale3D(1, 1, 1);
-            transform: scale3D(1, 1, 1);
-  } 35% {
-    -webkit-transform: scale3D(0, 0, 1);
-            transform: scale3D(0, 0, 1);
-  }
-}
-
-@keyframes sk-cubeGridScaleDelay {
-  0%, 70%, 100% {
-    -webkit-transform: scale3D(1, 1, 1);
-            transform: scale3D(1, 1, 1);
-  } 35% {
-    -webkit-transform: scale3D(0, 0, 1);
-            transform: scale3D(0, 0, 1);
-  }
-}
-</style>
-
-<div class="sk-cube-grid">
-  <div class="sk-cube sk-cube1"></div>
-  <div class="sk-cube sk-cube2"></div>
-  <div class="sk-cube sk-cube3"></div>
-  <div class="sk-cube sk-cube4"></div>
-  <div class="sk-cube sk-cube5"></div>
-  <div class="sk-cube sk-cube6"></div>
-  <div class="sk-cube sk-cube7"></div>
-  <div class="sk-cube sk-cube8"></div>
-  <div class="sk-cube sk-cube9"></div>
-</div>
-
-<%= options.dev ? '<!-- http://tobiasahlin.com/spinkit -->' : '' %>

node_modules/@nuxt/vue-app/template/views/loading/default.html

@@ -1,110 +0,0 @@
-<style>
-#nuxt-loading {
-  background: <%= options.background %>;
-  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 <%= options.color2 %>;
-  border-left: .5rem solid <%= options.color %>;
-  -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><%= options.loading %></div></div>
-
-<%= options.dev ? '<!-- https://projects.lukehaas.me/css-loaders -->' : '' %>

node_modules/@nuxt/vue-app/template/views/loading/fading-circle.html

@@ -1,164 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= options.background %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-
-.sk-fading-circle {
-  width: 40px;
-  height: 40px;
-  position: relative;
-}
-
-.sk-fading-circle .sk-circle {
-  width: 100%;
-  height: 100%;
-  position: absolute;
-  left: 0;
-  top: 0;
-}
-
-.sk-fading-circle .sk-circle:before {
-  content: '';
-  display: block;
-  margin: 0 auto;
-  width: 15%;
-  height: 15%;
-  background-color: <%= options.color %>;
-  border-radius: 100%;
-  -webkit-animation: sk-circleFadeDelay 1.2s infinite ease-in-out both;
-          animation: sk-circleFadeDelay 1.2s infinite ease-in-out both;
-}
-.sk-fading-circle .sk-circle2 {
-  -webkit-transform: rotate(30deg);
-      -ms-transform: rotate(30deg);
-          transform: rotate(30deg);
-}
-.sk-fading-circle .sk-circle3 {
-  -webkit-transform: rotate(60deg);
-      -ms-transform: rotate(60deg);
-          transform: rotate(60deg);
-}
-.sk-fading-circle .sk-circle4 {
-  -webkit-transform: rotate(90deg);
-      -ms-transform: rotate(90deg);
-          transform: rotate(90deg);
-}
-.sk-fading-circle .sk-circle5 {
-  -webkit-transform: rotate(120deg);
-      -ms-transform: rotate(120deg);
-          transform: rotate(120deg);
-}
-.sk-fading-circle .sk-circle6 {
-  -webkit-transform: rotate(150deg);
-      -ms-transform: rotate(150deg);
-          transform: rotate(150deg);
-}
-.sk-fading-circle .sk-circle7 {
-  -webkit-transform: rotate(180deg);
-      -ms-transform: rotate(180deg);
-          transform: rotate(180deg);
-}
-.sk-fading-circle .sk-circle8 {
-  -webkit-transform: rotate(210deg);
-      -ms-transform: rotate(210deg);
-          transform: rotate(210deg);
-}
-.sk-fading-circle .sk-circle9 {
-  -webkit-transform: rotate(240deg);
-      -ms-transform: rotate(240deg);
-          transform: rotate(240deg);
-}
-.sk-fading-circle .sk-circle10 {
-  -webkit-transform: rotate(270deg);
-      -ms-transform: rotate(270deg);
-          transform: rotate(270deg);
-}
-.sk-fading-circle .sk-circle11 {
-  -webkit-transform: rotate(300deg);
-      -ms-transform: rotate(300deg);
-          transform: rotate(300deg);
-}
-.sk-fading-circle .sk-circle12 {
-  -webkit-transform: rotate(330deg);
-      -ms-transform: rotate(330deg);
-          transform: rotate(330deg);
-}
-.sk-fading-circle .sk-circle2:before {
-  -webkit-animation-delay: -1.1s;
-          animation-delay: -1.1s;
-}
-.sk-fading-circle .sk-circle3:before {
-  -webkit-animation-delay: -1s;
-          animation-delay: -1s;
-}
-.sk-fading-circle .sk-circle4:before {
-  -webkit-animation-delay: -0.9s;
-          animation-delay: -0.9s;
-}
-.sk-fading-circle .sk-circle5:before {
-  -webkit-animation-delay: -0.8s;
-          animation-delay: -0.8s;
-}
-.sk-fading-circle .sk-circle6:before {
-  -webkit-animation-delay: -0.7s;
-          animation-delay: -0.7s;
-}
-.sk-fading-circle .sk-circle7:before {
-  -webkit-animation-delay: -0.6s;
-          animation-delay: -0.6s;
-}
-.sk-fading-circle .sk-circle8:before {
-  -webkit-animation-delay: -0.5s;
-          animation-delay: -0.5s;
-}
-.sk-fading-circle .sk-circle9:before {
-  -webkit-animation-delay: -0.4s;
-          animation-delay: -0.4s;
-}
-.sk-fading-circle .sk-circle10:before {
-  -webkit-animation-delay: -0.3s;
-          animation-delay: -0.3s;
-}
-.sk-fading-circle .sk-circle11:before {
-  -webkit-animation-delay: -0.2s;
-          animation-delay: -0.2s;
-}
-.sk-fading-circle .sk-circle12:before {
-  -webkit-animation-delay: -0.1s;
-          animation-delay: -0.1s;
-}
-
-@-webkit-keyframes sk-circleFadeDelay {
-  0%, 39%, 100% { opacity: 0; }
-  40% { opacity: 1; }
-}
-
-@keyframes sk-circleFadeDelay {
-  0%, 39%, 100% { opacity: 0; }
-  40% { opacity: 1; }
-}
-</style>
-
-<div class="sk-fading-circle">
-  <div class="sk-circle1 sk-circle"></div>
-  <div class="sk-circle2 sk-circle"></div>
-  <div class="sk-circle3 sk-circle"></div>
-  <div class="sk-circle4 sk-circle"></div>
-  <div class="sk-circle5 sk-circle"></div>
-  <div class="sk-circle6 sk-circle"></div>
-  <div class="sk-circle7 sk-circle"></div>
-  <div class="sk-circle8 sk-circle"></div>
-  <div class="sk-circle9 sk-circle"></div>
-  <div class="sk-circle10 sk-circle"></div>
-  <div class="sk-circle11 sk-circle"></div>
-  <div class="sk-circle12 sk-circle"></div>
-</div>
-
-<%= options.dev ? '<!-- http://tobiasahlin.com/spinkit -->' : '' %>

node_modules/@nuxt/vue-app/template/views/loading/folding-cube.html

@@ -1,108 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= options.background %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-
-.sk-folding-cube {
-  width: 40px;
-  height: 40px;
-  position: relative;
-  -webkit-transform: rotateZ(45deg);
-          transform: rotateZ(45deg);
-}
-
-.sk-folding-cube .sk-cube {
-  float: left;
-  width: 50%;
-  height: 50%;
-  position: relative;
-  -webkit-transform: scale(1.1);
-      -ms-transform: scale(1.1);
-          transform: scale(1.1);
-}
-.sk-folding-cube .sk-cube:before {
-  content: '';
-  position: absolute;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-  background-color: <%= options.color %>;
-  -webkit-animation: sk-foldCubeAngle 2.4s infinite linear both;
-          animation: sk-foldCubeAngle 2.4s infinite linear both;
-  -webkit-transform-origin: 100% 100%;
-      -ms-transform-origin: 100% 100%;
-          transform-origin: 100% 100%;
-}
-.sk-folding-cube .sk-cube2 {
-  -webkit-transform: scale(1.1) rotateZ(90deg);
-          transform: scale(1.1) rotateZ(90deg);
-}
-.sk-folding-cube .sk-cube3 {
-  -webkit-transform: scale(1.1) rotateZ(180deg);
-          transform: scale(1.1) rotateZ(180deg);
-}
-.sk-folding-cube .sk-cube4 {
-  -webkit-transform: scale(1.1) rotateZ(270deg);
-          transform: scale(1.1) rotateZ(270deg);
-}
-.sk-folding-cube .sk-cube2:before {
-  -webkit-animation-delay: 0.3s;
-          animation-delay: 0.3s;
-}
-.sk-folding-cube .sk-cube3:before {
-  -webkit-animation-delay: 0.6s;
-          animation-delay: 0.6s;
-}
-.sk-folding-cube .sk-cube4:before {
-  -webkit-animation-delay: 0.9s;
-          animation-delay: 0.9s;
-}
-@-webkit-keyframes sk-foldCubeAngle {
-  0%, 10% {
-    -webkit-transform: perspective(140px) rotateX(-180deg);
-            transform: perspective(140px) rotateX(-180deg);
-    opacity: 0;
-  } 25%, 75% {
-    -webkit-transform: perspective(140px) rotateX(0deg);
-            transform: perspective(140px) rotateX(0deg);
-    opacity: 1;
-  } 90%, 100% {
-    -webkit-transform: perspective(140px) rotateY(180deg);
-            transform: perspective(140px) rotateY(180deg);
-    opacity: 0;
-  }
-}
-
-@keyframes sk-foldCubeAngle {
-  0%, 10% {
-    -webkit-transform: perspective(140px) rotateX(-180deg);
-            transform: perspective(140px) rotateX(-180deg);
-    opacity: 0;
-  } 25%, 75% {
-    -webkit-transform: perspective(140px) rotateX(0deg);
-            transform: perspective(140px) rotateX(0deg);
-    opacity: 1;
-  } 90%, 100% {
-    -webkit-transform: perspective(140px) rotateY(180deg);
-            transform: perspective(140px) rotateY(180deg);
-    opacity: 0;
-  }
-}
-</style>
-
-<div class="sk-folding-cube">
-  <div class="sk-cube1 sk-cube"></div>
-  <div class="sk-cube2 sk-cube"></div>
-  <div class="sk-cube4 sk-cube"></div>
-  <div class="sk-cube3 sk-cube"></div>
-</div>
-
-<%= options.dev ? '<!-- http://tobiasahlin.com/spinkit -->' : '' %>

node_modules/@nuxt/vue-app/template/views/loading/nuxt.html

@@ -1,59 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= (options.theme === 'dark' ? '#2F4A5F' : 'white') %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-#nuxt-loading {
-  animation: opacity 1s ease-in-out;
-  animation-fill-mode: forwards;
-  animation-delay: 1s;
-  opacity: 0;
-}
-#nuxt-loading .logo {
-  position: relative;
-  height: 166px;
-  width: 220px;
-}
-#nuxt-loading-status {
-  font-family: sans-serif;
-  font-weight: 500;
-  text-align: center;
-  color: <%= (options.theme === 'dark' ? 'white' : '#2F4A5F') %>;
-}
-#nuxt-loading-status.errored {
-  color: <%= (options.theme === 'dark' ? '#da6371' : '#D0021B') %>;
-}
-@keyframes opacity {
-  100% {
-    opacity: 1;
-  }
-}
-</style>
-
-<div id="nuxt-loading">
-  <svg class="logo" width="220" height="166" xmlns="http://www.w3.org/2000/svg">
-    <g transform="translate(-18 -29)" fill="none" fill-rule="evenodd">
-      <path d="M0 176h67.883a22.32 22.32 0 0 1 2.453-7.296L134 57.718 100.881 0 0 176zM218.694 176H250L167.823 32 153 58.152l62.967 110.579a21.559 21.559 0 0 1 2.727 7.269z" />
-      <path d="M86.066 189.388a8.241 8.241 0 0 1-.443-.908 11.638 11.638 0 0 1-.792-6.566H31.976l78.55-138.174 33.05 58.932L154 94.882l-32.69-58.64C120.683 35.1 116.886 29 110.34 29c-2.959 0-7.198 1.28-10.646 7.335L20.12 176.185c-.676 1.211-3.96 7.568-.7 13.203C20.912 191.95 24.08 195 31.068 195h66.646c-6.942 0-10.156-3.004-11.647-5.612z" fill="#00C58E" />
-      <path d="M235.702 175.491L172.321 62.216c-.655-1.191-4.313-7.216-10.68-7.216-2.868 0-6.977 1.237-10.32 7.193L143 75.706v26.104l18.709-32.31 62.704 111.626h-23.845c.305 1.846.134 3.74-.496 5.498a7.06 7.06 0 0 1-.497 1.122l-.203.413c-3.207 5.543-10.139 5.841-11.494 5.841h37.302c1.378 0 8.287-.298 11.493-5.841 1.423-2.52 2.439-6.758-.97-12.668z" fill="#108775" />
-      <path d="M201.608 189.07l.21-.418c.206-.364.378-.745.515-1.139a10.94 10.94 0 0 0 .515-5.58 16.938 16.938 0 0 0-2.152-5.72l-49.733-87.006L143.5 76h-.136l-7.552 13.207-49.71 87.006a17.534 17.534 0 0 0-1.917 5.72c-.4 2.21-.148 4.486.725 6.557.13.31.278.613.444.906 1.497 2.558 4.677 5.604 11.691 5.604h92.592c1.473 0 8.651-.302 11.971-5.93zm-58.244-86.657l45.455 79.52H97.934l45.43-79.52z" fill="<%= (options.theme === 'dark' ? 'white' : '#2F4A5F') %>" fill-rule="nonzero" />
-    </g>
-  </svg>
-  <h3 id="nuxt-loading-status">Loading...</h3>
-</div>
-
-<script>
-  window.addEventListener('error', function () {
-    var e = document.getElementById('nuxt-loading-status');
-    if (e) {
-      e.innerHTML = 'An error occurred';
-      e.className += 'errored'
-    }
-  });
-  </script>

node_modules/@nuxt/vue-app/template/views/loading/pulse.html

@@ -1,48 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= options.background %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-
-.spinner {
-  width: 40px;
-  height: 40px;
-  background-color: <%= options.color %>;
-
-  border-radius: 100%;
-  -webkit-animation: sk-scaleout 1.0s infinite ease-in-out;
-  animation: sk-scaleout 1.0s infinite ease-in-out;
-}
-
-@-webkit-keyframes sk-scaleout {
-  0% { -webkit-transform: scale(0) }
-  100% {
-    -webkit-transform: scale(1.0);
-    opacity: 0;
-  }
-}
-
-@keyframes sk-scaleout {
-  0% {
-    -webkit-transform: scale(0);
-    transform: scale(0);
-  } 100% {
-    -webkit-transform: scale(1.0);
-    transform: scale(1.0);
-    opacity: 0;
-  }
-}
-</style>
-
-<div class="spinner">
-  <div class="double-bounce1"></div>
-  <div class="double-bounce2"></div>
-</div>
-
-<%= options.dev ? '<!-- http://tobiasahlin.com/spinkit -->' : '' %>

node_modules/@nuxt/vue-app/template/views/loading/rectangle-bounce.html

@@ -1,74 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= options.background %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-
-.spinner {
-  width: 50px;
-  height: 40px;
-  text-align: center;
-  font-size: 10px;
-}
-
-.spinner > div {
-  background-color: <%= options.color %>;
-  height: 100%;
-  width: 6px;
-  display: inline-block;
-
-  -webkit-animation: sk-stretchdelay 1.2s infinite ease-in-out;
-  animation: sk-stretchdelay 1.2s infinite ease-in-out;
-}
-
-.spinner .rect2 {
-  -webkit-animation-delay: -1.1s;
-  animation-delay: -1.1s;
-}
-
-.spinner .rect3 {
-  -webkit-animation-delay: -1.0s;
-  animation-delay: -1.0s;
-}
-
-.spinner .rect4 {
-  -webkit-animation-delay: -0.9s;
-  animation-delay: -0.9s;
-}
-
-.spinner .rect5 {
-  -webkit-animation-delay: -0.8s;
-  animation-delay: -0.8s;
-}
-
-@-webkit-keyframes sk-stretchdelay {
-  0%, 40%, 100% { -webkit-transform: scaleY(0.4) }
-  20% { -webkit-transform: scaleY(1.0) }
-}
-
-@keyframes sk-stretchdelay {
-  0%, 40%, 100% {
-    transform: scaleY(0.4);
-    -webkit-transform: scaleY(0.4);
-  }  20% {
-    transform: scaleY(1.0);
-    -webkit-transform: scaleY(1.0);
-  }
-}
-</style>
-
-<div class="spinner">
-  <div class="rect1"></div>
-  <div class="rect2"></div>
-  <div class="rect3"></div>
-  <div class="rect4"></div>
-  <div class="rect5"></div>
-</div>
-
-<%= options.dev ? '<!-- http://tobiasahlin.com/spinkit -->' : '' %>

node_modules/@nuxt/vue-app/template/views/loading/rotating-plane.html

@@ -1,44 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= options.background %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-
-.spinner {
-  width: 40px;
-  height: 40px;
-  background-color: <%= options.color %>;
-
-  -webkit-animation: sk-rotateplane 1.2s infinite ease-in-out;
-  animation: sk-rotateplane 1.2s infinite ease-in-out;
-}
-
-@-webkit-keyframes sk-rotateplane {
-  0% { -webkit-transform: perspective(120px) }
-  50% { -webkit-transform: perspective(120px) rotateY(180deg) }
-  100% { -webkit-transform: perspective(120px) rotateY(180deg)  rotateX(180deg) }
-}
-
-@keyframes sk-rotateplane {
-  0% {
-    transform: perspective(120px) rotateX(0deg) rotateY(0deg);
-    -webkit-transform: perspective(120px) rotateX(0deg) rotateY(0deg)
-  } 50% {
-    transform: perspective(120px) rotateX(-180.1deg) rotateY(0deg);
-    -webkit-transform: perspective(120px) rotateX(-180.1deg) rotateY(0deg)
-  } 100% {
-    transform: perspective(120px) rotateX(-180deg) rotateY(-179.9deg);
-    -webkit-transform: perspective(120px) rotateX(-180deg) rotateY(-179.9deg);
-  }
-}
-</style>
-
-<div class="spinner"></div>
-
-<%= options.dev ? '<!-- http://tobiasahlin.com/spinkit -->' : '' %>

node_modules/@nuxt/vue-app/template/views/loading/three-bounce.html

@@ -1,61 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= options.background %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-
-.spinner {
-  width: 70px;
-  text-align: center;
-}
-
-.spinner > div {
-  width: 18px;
-  height: 18px;
-  background-color: <%= options.color %>;
-
-  border-radius: 100%;
-  display: inline-block;
-  -webkit-animation: sk-bouncedelay 1.4s infinite ease-in-out both;
-  animation: sk-bouncedelay 1.4s infinite ease-in-out both;
-}
-
-.spinner .bounce1 {
-  -webkit-animation-delay: -0.32s;
-  animation-delay: -0.32s;
-}
-
-.spinner .bounce2 {
-  -webkit-animation-delay: -0.16s;
-  animation-delay: -0.16s;
-}
-
-@-webkit-keyframes sk-bouncedelay {
-  0%, 80%, 100% { -webkit-transform: scale(0) }
-  40% { -webkit-transform: scale(1.0) }
-}
-
-@keyframes sk-bouncedelay {
-  0%, 80%, 100% {
-    -webkit-transform: scale(0);
-    transform: scale(0);
-  } 40% {
-    -webkit-transform: scale(1.0);
-    transform: scale(1.0);
-  }
-}
-</style>
-
-<div class="spinner">
-  <div class="bounce1"></div>
-  <div class="bounce2"></div>
-  <div class="bounce3"></div>
-</div>
-
-<%= options.dev ? '<!-- http://tobiasahlin.com/spinkit -->' : '' %>

node_modules/@nuxt/vue-app/template/views/loading/wandering-cubes.html

@@ -1,68 +0,0 @@
-<style>
-body, html, #<%= globals.id %> {
-  background: <%= options.background %>;
-  width: 100%;
-  height: 100%;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0;
-  padding: 0;
-}
-
-.spinner {
-  width: 40px;
-  height: 40px;
-  position: relative;
-}
-
-.cube1, .cube2 {
-  background-color: <%= options.color %>;
-  width: 15px;
-  height: 15px;
-  position: absolute;
-  top: 0;
-  left: 0;
-
-  -webkit-animation: sk-cubemove 1.8s infinite ease-in-out;
-  animation: sk-cubemove 1.8s infinite ease-in-out;
-}
-
-.cube2 {
-  -webkit-animation-delay: -0.9s;
-  animation-delay: -0.9s;
-}
-
-@-webkit-keyframes sk-cubemove {
-  25% { -webkit-transform: translateX(42px) rotate(-90deg) scale(0.5) }
-  50% { -webkit-transform: translateX(42px) translateY(42px) rotate(-180deg) }
-  75% { -webkit-transform: translateX(0px) translateY(42px) rotate(-270deg) scale(0.5) }
-  100% { -webkit-transform: rotate(-360deg) }
-}
-
-@keyframes sk-cubemove {
-  25% {
-    transform: translateX(42px) rotate(-90deg) scale(0.5);
-    -webkit-transform: translateX(42px) rotate(-90deg) scale(0.5);
-  } 50% {
-    transform: translateX(42px) translateY(42px) rotate(-179deg);
-    -webkit-transform: translateX(42px) translateY(42px) rotate(-179deg);
-  } 50.1% {
-    transform: translateX(42px) translateY(42px) rotate(-180deg);
-    -webkit-transform: translateX(42px) translateY(42px) rotate(-180deg);
-  } 75% {
-    transform: translateX(0px) translateY(42px) rotate(-270deg) scale(0.5);
-    -webkit-transform: translateX(0px) translateY(42px) rotate(-270deg) scale(0.5);
-  } 100% {
-    transform: rotate(-360deg);
-    -webkit-transform: rotate(-360deg);
-  }
-}
-</style>
-
-<div class="spinner">
-  <div class="cube1"></div>
-  <div class="cube2"></div>
-</div>
-
-<%= options.dev ? '<!-- http://tobiasahlin.com/spinkit -->' : '' %>