V1

node_modules/@nuxt/cli/dist/cli-banner.js

@@ -0,0 +1,93 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+const consola = require('consola');
+const env = require('std-env');
+const chalk = require('chalk');
+const index = require('./cli-index.js');
+const prettyBytes = require('pretty-bytes');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+const env__default = /*#__PURE__*/_interopDefaultLegacy(env);
+const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
+const prettyBytes__default = /*#__PURE__*/_interopDefaultLegacy(prettyBytes);
+
+function getMemoryUsage () {
+  // https://nodejs.org/api/process.html#process_process_memoryusage
+  const { heapUsed, rss } = process.memoryUsage();
+  return { heap: heapUsed, rss }
+}
+
+function getFormattedMemoryUsage () {
+  const { heap, rss } = getMemoryUsage();
+  return `Memory usage: ${chalk__default['default'].bold(prettyBytes__default['default'](heap))} (RSS: ${prettyBytes__default['default'](rss)})`
+}
+
+function showMemoryUsage () {
+  consola__default['default'].info(getFormattedMemoryUsage());
+}
+
+function showBanner (nuxt, showMemoryUsage = true) {
+  if (env__default['default'].test) {
+    return
+  }
+
+  if (env__default['default'].minimalCLI) {
+    for (const listener of nuxt.server.listeners) {
+      consola__default['default'].info('Listening on: ' + listener.url);
+    }
+    return
+  }
+
+  const titleLines = [];
+  const messageLines = [];
+
+  // Name and version
+  const { bannerColor, badgeMessages } = nuxt.options.cli;
+  titleLines.push(`${chalk__default['default'][bannerColor].bold('Nuxt')} @ ${nuxt.constructor.version || 'exotic'}\n`);
+
+  const label = name => chalk__default['default'].bold.cyan(`▸ ${name}:`);
+
+  // Environment
+  const isDev = nuxt.options.dev;
+  let _env = isDev ? 'development' : 'production';
+  if (process.env.NODE_ENV !== _env) {
+    _env += ` (${chalk__default['default'].cyan(process.env.NODE_ENV)})`;
+  }
+  titleLines.push(`${label('Environment')} ${_env}`);
+
+  // Rendering
+  const isSSR = nuxt.options.render.ssr;
+  const rendering = isSSR ? 'server-side' : 'client-side';
+  titleLines.push(`${label('Rendering')}   ${rendering}`);
+
+  // Target
+  const target = nuxt.options.target || 'server';
+  titleLines.push(`${label('Target')}      ${target}`);
+
+  if (showMemoryUsage) {
+    titleLines.push('\n' + getFormattedMemoryUsage());
+  }
+
+  // Listeners
+  for (const listener of nuxt.server.listeners) {
+    messageLines.push(chalk__default['default'].bold('Listening: ') + chalk__default['default'].underline.blue(listener.url));
+  }
+
+  // Add custom badge messages
+  if (badgeMessages.length) {
+    messageLines.push('', ...badgeMessages);
+  }
+
+  process.stdout.write(index.successBox(messageLines.join('\n'), titleLines.join('\n')));
+}
+
+exports.showBanner = showBanner;
+exports.showMemoryUsage = showMemoryUsage;

node_modules/@nuxt/cli/dist/cli-build.js

@@ -0,0 +1,118 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+const consola = require('consola');
+const utils = require('@nuxt/utils');
+const index = require('./cli-index.js');
+require('@nuxt/config');
+require('path');
+require('exit');
+require('chalk');
+require('std-env');
+require('wrap-ansi');
+require('boxen');
+require('minimist');
+require('hable');
+require('defu');
+require('semver');
+require('fs');
+require('execa');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+
+const build = {
+  name: 'build',
+  description: 'Compiles the application for production deployment',
+  usage: 'build <dir>',
+  options: {
+    ...index.common,
+    ...index.locking,
+    analyze: {
+      alias: 'a',
+      type: 'boolean',
+      description: 'Launch webpack-bundle-analyzer to optimize your bundles',
+      prepare (cmd, options, argv) {
+        // Analyze option
+        options.build = options.build || {};
+        if (argv.analyze && typeof options.build.analyze !== 'object') {
+          options.build.analyze = true;
+        }
+      }
+    },
+    devtools: {
+      type: 'boolean',
+      default: false,
+      description: 'Enable Vue devtools',
+      prepare (cmd, options, argv) {
+        options.vue = options.vue || {};
+        options.vue.config = options.vue.config || {};
+        if (argv.devtools) {
+          options.vue.config.devtools = true;
+        }
+      }
+    },
+    generate: {
+      type: 'boolean',
+      default: true,
+      description: 'Don\'t generate static version for SPA mode (useful for nuxt start)'
+    },
+    quiet: {
+      alias: 'q',
+      type: 'boolean',
+      description: 'Disable output except for errors',
+      prepare (cmd, options, argv) {
+        // Silence output when using --quiet
+        options.build = options.build || {};
+        if (argv.quiet) {
+          options.build.quiet = Boolean(argv.quiet);
+        }
+      }
+    },
+    standalone: {
+      type: 'boolean',
+      default: false,
+      description: 'Bundle all server dependencies (useful for nuxt-start)',
+      prepare (cmd, options, argv) {
+        if (argv.standalone) {
+          options.build.standalone = true;
+        }
+      }
+    }
+  },
+  async run (cmd) {
+    const config = await cmd.getNuxtConfig({ dev: false, server: false, _build: true });
+    config.server = (config.mode === utils.MODES.spa || config.ssr === false) && cmd.argv.generate !== false;
+    const nuxt = await cmd.getNuxt(config);
+
+    if (cmd.argv.lock) {
+      await cmd.setLock(await index.createLock({
+        id: 'build',
+        dir: nuxt.options.buildDir,
+        root: config.rootDir
+      }));
+    }
+
+    // TODO: remove if in Nuxt 3
+    if (nuxt.options.mode === utils.MODES.spa && nuxt.options.target === utils.TARGETS.server && cmd.argv.generate !== false) {
+      // Build + Generate for static deployment
+      const generator = await cmd.getGenerator(nuxt);
+      await generator.generate({ build: true });
+    } else {
+      // Build only
+      const builder = await cmd.getBuilder(nuxt);
+      await builder.build();
+
+      const nextCommand = nuxt.options.target === utils.TARGETS.static ? 'nuxt generate' : 'nuxt start';
+      consola__default['default'].info('Ready to run `' + (nextCommand) + '`');
+    }
+  }
+};
+
+exports.default = build;

node_modules/@nuxt/cli/dist/cli-dev.js

@@ -0,0 +1,144 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+const consola = require('consola');
+const chalk = require('chalk');
+const opener = require('opener');
+const index = require('./cli-index.js');
+const banner = require('./cli-banner.js');
+require('@nuxt/utils');
+require('@nuxt/config');
+require('path');
+require('exit');
+require('std-env');
+require('wrap-ansi');
+require('boxen');
+require('minimist');
+require('hable');
+require('defu');
+require('semver');
+require('fs');
+require('execa');
+require('pretty-bytes');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
+const opener__default = /*#__PURE__*/_interopDefaultLegacy(opener);
+
+const dev = {
+  name: 'dev',
+  description: 'Start the application in development mode (e.g. hot-code reloading, error reporting)',
+  usage: 'dev <dir>',
+  options: {
+    ...index.common,
+    ...index.server$1,
+    open: {
+      alias: 'o',
+      type: 'boolean',
+      description: 'Opens the server listeners url in the default browser'
+    }
+  },
+
+  async run (cmd) {
+    const { argv } = cmd;
+
+    await this.startDev(cmd, argv, argv.open);
+  },
+
+  async startDev (cmd, argv) {
+    let nuxt;
+    try {
+      nuxt = await this._listenDev(cmd, argv);
+    } catch (error) {
+      consola__default['default'].fatal(error);
+      return
+    }
+
+    try {
+      await this._buildDev(cmd, argv, nuxt);
+    } catch (error) {
+      await nuxt.callHook('cli:buildError', error);
+      consola__default['default'].error(error);
+    }
+
+    return nuxt
+  },
+
+  async _listenDev (cmd, argv) {
+    const config = await cmd.getNuxtConfig({ dev: true, _build: true });
+    const nuxt = await cmd.getNuxt(config);
+
+    // Setup hooks
+    nuxt.hook('watch:restart', payload => this.onWatchRestart(payload, { nuxt, cmd, argv }));
+    nuxt.hook('bundler:change', changedFileName => this.onBundlerChange(changedFileName));
+
+    // Wait for nuxt to be ready
+    await nuxt.ready();
+
+    // Start listening
+    await nuxt.server.listen();
+
+    // Show banner when listening
+    banner.showBanner(nuxt, false);
+
+    // Opens the server listeners url in the default browser (only once)
+    if (argv.open) {
+      argv.open = false;
+      const openerPromises = nuxt.server.listeners.map(listener => opener__default['default'](listener.url));
+      await Promise.all(openerPromises);
+    }
+
+    // Return instance
+    return nuxt
+  },
+
+  async _buildDev (cmd, argv, nuxt) {
+    // Create builder instance
+    const builder = await cmd.getBuilder(nuxt);
+
+    // Start Build
+    await builder.build();
+
+    // Print memory usage
+    banner.showMemoryUsage();
+
+    // Display server urls after the build
+    for (const listener of nuxt.server.listeners) {
+      consola__default['default'].info(chalk__default['default'].bold('Listening on: ') + listener.url);
+    }
+
+    // Return instance
+    return nuxt
+  },
+
+  logChanged ({ event, path }) {
+    const { icon, color, action } = index.eventsMapping[event] || index.eventsMapping.change;
+
+    consola__default['default'].log({
+      type: event,
+      icon: chalk__default['default'][color].bold(icon),
+      message: `${action} ${chalk__default['default'].cyan(index.formatPath(path))}`
+    });
+  },
+
+  async onWatchRestart ({ event, path }, { nuxt, cmd, argv }) {
+    this.logChanged({ event, path });
+
+    await nuxt.close();
+
+    await this.startDev(cmd, argv);
+  },
+
+  onBundlerChange (path) {
+    this.logChanged({ event: 'change', path });
+  }
+};
+
+exports.default = dev;

node_modules/@nuxt/cli/dist/cli-export.js

@@ -0,0 +1,44 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+const consola = require('consola');
+const generate = require('./cli-generate.js');
+require('@nuxt/utils');
+require('./cli-index.js');
+require('@nuxt/config');
+require('path');
+require('exit');
+require('chalk');
+require('std-env');
+require('wrap-ansi');
+require('boxen');
+require('minimist');
+require('hable');
+require('defu');
+require('semver');
+require('fs');
+require('execa');
+require('upath');
+require('fs-extra');
+require('crc/lib/crc32');
+require('globby');
+require('destr');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+
+const _export = {
+  ...generate['default'],
+  run (...args) {
+    consola__default['default'].warn('`nuxt export` has been deprecated! Please use `nuxt generate`.');
+    return generate['default'].run.call(this, ...args)
+  }
+};
+
+exports.default = _export;

node_modules/@nuxt/cli/dist/cli-generate.js

@@ -0,0 +1,334 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+const utils = require('@nuxt/utils');
+const consola = require('consola');
+const index = require('./cli-index.js');
+const path = require('path');
+const upath = require('upath');
+const fs = require('fs-extra');
+const crc32 = require('crc/lib/crc32');
+const globby = require('globby');
+const destr = require('destr');
+require('@nuxt/config');
+require('exit');
+require('chalk');
+require('std-env');
+require('wrap-ansi');
+require('boxen');
+require('minimist');
+require('hable');
+require('defu');
+require('semver');
+require('fs');
+require('execa');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+const upath__default = /*#__PURE__*/_interopDefaultLegacy(upath);
+const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+const crc32__default = /*#__PURE__*/_interopDefaultLegacy(crc32);
+const globby__default = /*#__PURE__*/_interopDefaultLegacy(globby);
+const destr__default = /*#__PURE__*/_interopDefaultLegacy(destr);
+
+async function generate$1 (cmd) {
+  const nuxt = await getNuxt({ server: true }, cmd);
+  const generator = await cmd.getGenerator(nuxt);
+
+  await nuxt.server.listen(0);
+  const { errors } = await generator.generate({ build: false });
+  await nuxt.close();
+  if (cmd.argv['fail-on-error'] && errors.length > 0) {
+    throw new Error('Error generating pages, exiting with non-zero code')
+  }
+}
+
+async function ensureBuild (cmd) {
+  const nuxt = await getNuxt({ _build: true, server: false }, cmd);
+  const { options } = nuxt;
+
+  if (options.generate.cache === false || destr__default['default'](process.env.NUXT_BUILD) || cmd.argv['force-build']) {
+    const builder = await cmd.getBuilder(nuxt);
+    await builder.build();
+    await nuxt.close();
+    return
+  }
+
+  // Default build ignore files
+  const ignore = [
+    options.buildDir,
+    options.dir.static,
+    options.generate.dir,
+    'node_modules',
+    '.**/*',
+    '.*',
+    'README.md'
+  ];
+
+  // Extend ignore
+  const { generate } = options;
+  if (typeof generate.cache.ignore === 'function') {
+    generate.cache.ignore = generate.cache.ignore(ignore);
+  } else if (Array.isArray(generate.cache.ignore)) {
+    generate.cache.ignore = generate.cache.ignore.concat(ignore);
+  }
+  await nuxt.callHook('generate:cache:ignore', generate.cache.ignore);
+
+  // Take a snapshot of current project
+  const snapshotOptions = {
+    rootDir: options.rootDir,
+    ignore: generate.cache.ignore.map(upath__default['default'].normalize),
+    globbyOptions: generate.cache.globbyOptions
+  };
+
+  const currentBuildSnapshot = await snapshot(snapshotOptions);
+
+  // Detect process.env usage in nuxt.config
+  const processEnv = {};
+  if (nuxt.options._nuxtConfigFile) {
+    const configSrc = await fs__default['default'].readFile(nuxt.options._nuxtConfigFile);
+    const envRegex = /process.env.(\w+)/g;
+    let match;
+    // eslint-disable-next-line no-cond-assign
+    while (match = envRegex.exec(configSrc)) {
+      processEnv[match[1]] = process.env[match[1]];
+    }
+  }
+
+  // Current build meta
+  const currentBuild = {
+    // @ts-ignore
+    nuxtVersion: nuxt.constructor.version,
+    ssr: nuxt.options.ssr,
+    target: nuxt.options.target,
+    snapshot: currentBuildSnapshot,
+    env: nuxt.options.env,
+    'process.env': processEnv
+  };
+
+  // Check if build can be skipped
+  const nuxtBuildFile = path__default['default'].resolve(nuxt.options.buildDir, 'build.json');
+  if (fs__default['default'].existsSync(nuxtBuildFile)) {
+    const previousBuild = destr__default['default'](fs__default['default'].readFileSync(nuxtBuildFile, 'utf-8')) || {};
+
+    // Quick diff
+    let needBuild = false;
+    for (const field of ['nuxtVersion', 'ssr', 'target', 'env', 'process.env']) {
+      if (JSON.stringify(previousBuild[field]) !== JSON.stringify(currentBuild[field])) {
+        needBuild = true;
+        consola__default['default'].info(`Doing webpack rebuild because ${field} changed`);
+        break
+      }
+    }
+
+    // Full snapshot diff
+    if (!needBuild) {
+      const changed = compareSnapshots(previousBuild.snapshot, currentBuild.snapshot);
+      if (!changed) {
+        consola__default['default'].success('Skipping webpack build as no changes detected');
+        return
+      } else {
+        consola__default['default'].info(`Doing webpack rebuild because ${changed} modified`);
+      }
+    }
+  }
+
+  // Webpack build
+  const builder = await cmd.getBuilder(nuxt);
+  await builder.build();
+
+  // Write build.json
+  fs__default['default'].writeFileSync(nuxtBuildFile, JSON.stringify(currentBuild, null, 2), 'utf-8');
+
+  await nuxt.close();
+}
+
+async function getNuxt (args, cmd) {
+  const config = await cmd.getNuxtConfig({ dev: false, ...args });
+
+  if (config.target === utils.TARGETS.static) {
+    config._export = true;
+  } else {
+    config._legacyGenerate = true;
+  }
+  config.buildDir = (config.static && config.static.cacheDir) || path__default['default'].resolve(config.rootDir, 'node_modules/.cache/nuxt');
+  config.build = config.build || {};
+  // https://github.com/nuxt/nuxt.js/issues/7390
+  config.build.parallel = false;
+  config.build.transpile = config.build.transpile || [];
+  if (!config.static || !config.static.cacheDir) {
+    config.build.transpile.push('.cache/nuxt');
+  }
+
+  const nuxt = await cmd.getNuxt(config);
+
+  return nuxt
+}
+
+function compareSnapshots (from, to) {
+  const allKeys = Array.from(new Set([
+    ...Object.keys(from).sort(),
+    ...Object.keys(to).sort()
+  ]));
+
+  for (const key of allKeys) {
+    if (JSON.stringify(from[key]) !== JSON.stringify(to[key])) {
+      return key
+    }
+  }
+
+  return false
+}
+
+async function snapshot ({ globbyOptions, ignore, rootDir }) {
+  const snapshot = {};
+
+  const files = await globby__default['default']('**/*.*', {
+    ...globbyOptions,
+    ignore,
+    cwd: rootDir,
+    absolute: true
+  });
+
+  await Promise.all(files.map(async (p) => {
+    const key = path.relative(rootDir, p);
+    try {
+      const fileContent = await fs__default['default'].readFile(p);
+      snapshot[key] = {
+        checksum: await crc32__default['default'](fileContent).toString(16)
+      };
+    } catch (e) {
+      // TODO: Check for other errors like permission denied
+      snapshot[key] = {
+        exists: false
+      };
+    }
+  }));
+
+  return snapshot
+}
+
+const generate = {
+  name: 'generate',
+  description: 'Generate a static web application (server-rendered)',
+  usage: 'generate <dir>',
+  options: {
+    ...index.common,
+    ...index.locking,
+    build: {
+      type: 'boolean',
+      default: true,
+      description: 'Only generate pages for dynamic routes, used for incremental builds. Generate has to be run once without this option before using it'
+    },
+    devtools: {
+      type: 'boolean',
+      default: false,
+      description: 'Enable Vue devtools',
+      prepare (cmd, options, argv) {
+        options.vue = options.vue || {};
+        options.vue.config = options.vue.config || {};
+        if (argv.devtools) {
+          options.vue.config.devtools = true;
+        }
+      }
+    },
+    quiet: {
+      alias: 'q',
+      type: 'boolean',
+      description: 'Disable output except for errors',
+      prepare (cmd, options, argv) {
+        // Silence output when using --quiet
+        options.build = options.build || {};
+        if (argv.quiet) {
+          options.build.quiet = true;
+        }
+      }
+    },
+    modern: {
+      ...index.common.modern,
+      description: 'Generate app in modern build (modern mode can be only client)',
+      prepare (cmd, options, argv) {
+        if (index.normalizeArg(argv.modern)) {
+          options.modern = 'client';
+        }
+      }
+    },
+    'force-build': {
+      type: 'boolean',
+      default: false,
+      description: 'Force to build the application with webpack'
+    },
+    'fail-on-error': {
+      type: 'boolean',
+      default: false,
+      description: 'Exit with non-zero status code if there are errors when generating pages'
+    }
+  },
+  async run (cmd) {
+    const config = await cmd.getNuxtConfig({ dev: false });
+
+    // Disable analyze if set by the nuxt config
+    config.build = config.build || {};
+    config.build.analyze = false;
+
+    // Full static
+    if (config.target === utils.TARGETS.static) {
+      await ensureBuild(cmd);
+      await generate$1(cmd);
+      return
+    }
+
+    // Forcing static target anyway
+    config.target = utils.TARGETS.static;
+    consola__default['default'].warn(`When using \`nuxt generate\`, you should set \`target: 'static'\` in your \`nuxt.config\`\n       👉 Learn more about it on https://go.nuxtjs.dev/static-target`);
+
+    // Set flag to keep the prerendering behaviour
+    config._legacyGenerate = true;
+    if (config.build) {
+      // https://github.com/nuxt/nuxt.js/issues/7390
+      config.build.parallel = false;
+    }
+
+    const nuxt = await cmd.getNuxt(config);
+
+    if (cmd.argv.lock) {
+      await cmd.setLock(await index.createLock({
+        id: 'build',
+        dir: nuxt.options.buildDir,
+        root: config.rootDir
+      }));
+
+      nuxt.hook('build:done', async () => {
+        await cmd.releaseLock();
+
+        await cmd.setLock(await index.createLock({
+          id: 'generate',
+          dir: nuxt.options.generate.dir,
+          root: config.rootDir
+        }));
+      });
+    }
+
+    const generator = await cmd.getGenerator(nuxt);
+    await nuxt.server.listen(0);
+
+    const { errors } = await generator.generate({
+      init: true,
+      build: cmd.argv.build
+    });
+
+    await nuxt.close();
+    if (cmd.argv['fail-on-error'] && errors.length > 0) {
+      throw new Error('Error generating pages, exiting with non-zero code')
+    }
+  }
+};
+
+exports.default = generate;

node_modules/@nuxt/cli/dist/cli-help.js

@@ -0,0 +1,86 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+const consola = require('consola');
+const index = require('./cli-index.js');
+const chalk = require('chalk');
+require('@nuxt/utils');
+require('@nuxt/config');
+require('path');
+require('exit');
+require('std-env');
+require('wrap-ansi');
+require('boxen');
+require('minimist');
+require('hable');
+require('defu');
+require('semver');
+require('fs');
+require('execa');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
+
+async function listCommands () {
+  const commandsOrder = ['dev', 'build', 'generate', 'start', 'help'];
+
+  // Load all commands
+  const _commands = await Promise.all(
+    commandsOrder.map(cmd => index.getCommand(cmd))
+  );
+
+  let maxLength = 0;
+  const commandsHelp = [];
+
+  for (const command of _commands) {
+    commandsHelp.push([command.usage, command.description]);
+    maxLength = Math.max(maxLength, command.usage.length);
+  }
+
+  const _cmds = commandsHelp.map(([cmd, description]) => {
+    const i = index.indent(maxLength + index.optionSpaces - cmd.length);
+    return index.foldLines(
+      chalk__default['default'].green(cmd) + i + description,
+      index.startSpaces + maxLength + index.optionSpaces * 2,
+      index.startSpaces + index.optionSpaces
+    )
+  }).join('\n');
+
+  const usage = index.foldLines('Usage: nuxt <command> [--help|-h]', index.startSpaces);
+  const cmds = index.foldLines('Commands:', index.startSpaces) + '\n\n' + _cmds;
+
+  process.stderr.write(index.colorize(`${usage}\n\n${cmds}\n\n`));
+}
+
+const help = {
+  name: 'help',
+  description: 'Shows help for <command>',
+  usage: 'help <command>',
+  options: {
+    help: index.common.help,
+    version: index.common.version
+  },
+  async run (cmd) {
+    const [name] = cmd._argv;
+    if (!name) {
+      return listCommands()
+    }
+    const command = await index.getCommand(name);
+
+    if (!command) {
+      consola__default['default'].info(`Unknown command: ${name}`);
+      return
+    }
+
+    index.NuxtCommand.from(command).showHelp();
+  }
+};
+
+exports.default = help;

node_modules/@nuxt/cli/dist/cli-index.js

@@ -0,0 +1,750 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+const utils = require('@nuxt/utils');
+const config = require('@nuxt/config');
+const path = require('path');
+const exit = require('exit');
+const chalk = require('chalk');
+const env = require('std-env');
+const wrapAnsi = require('wrap-ansi');
+const boxen = require('boxen');
+const consola = require('consola');
+const minimist = require('minimist');
+const Hookable = require('hable');
+const defu = require('defu');
+const semver = require('semver');
+const fs = require('fs');
+const execa = require('execa');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+const exit__default = /*#__PURE__*/_interopDefaultLegacy(exit);
+const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
+const env__default = /*#__PURE__*/_interopDefaultLegacy(env);
+const wrapAnsi__default = /*#__PURE__*/_interopDefaultLegacy(wrapAnsi);
+const boxen__default = /*#__PURE__*/_interopDefaultLegacy(boxen);
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+const minimist__default = /*#__PURE__*/_interopDefaultLegacy(minimist);
+const Hookable__default = /*#__PURE__*/_interopDefaultLegacy(Hookable);
+const defu__default = /*#__PURE__*/_interopDefaultLegacy(defu);
+const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+const execa__default = /*#__PURE__*/_interopDefaultLegacy(execa);
+
+const commands = {
+  start: () => Promise.resolve().then(function () { return require('./cli-start.js'); }),
+  serve: () => Promise.resolve().then(function () { return require('./cli-serve.js'); }),
+  dev: () => Promise.resolve().then(function () { return require('./cli-dev.js'); }),
+  build: () => Promise.resolve().then(function () { return require('./cli-build.js'); }),
+  generate: () => Promise.resolve().then(function () { return require('./cli-generate.js'); }),
+  export: () => Promise.resolve().then(function () { return require('./cli-export.js'); }),
+  webpack: () => Promise.resolve().then(function () { return require('./cli-webpack.js'); }),
+  help: () => Promise.resolve().then(function () { return require('./cli-help.js'); })
+};
+
+function getCommand (name) {
+  if (!commands[name]) {
+    return Promise.resolve(null)
+  }
+  return commands[name]().then(m => m.default)
+}
+
+const index$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': getCommand
+});
+
+const importModule = (id) => {
+  try {
+    return Promise.resolve(utils.requireModule(id))
+  } catch (err) {
+    if (err.code === 'MODULE_NOT_FOUND') {
+      err.message = `Cannot import module '${id}'`;
+    }
+    return Promise.reject(err)
+  }
+};
+
+const builder = () => importModule('@nuxt/builder');
+const webpack = () => importModule('@nuxt/webpack');
+const generator = () => importModule('@nuxt/generator');
+const core = () => importModule('@nuxt/core');
+const server$1 = () => importModule('@nuxt/server');
+
+const imports = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  importModule: importModule,
+  builder: builder,
+  webpack: webpack,
+  generator: generator,
+  core: core,
+  server: server$1
+});
+
+const forceExitTimeout = 5;
+
+const startSpaces = 2;
+const optionSpaces = 2;
+
+// 80% of terminal column width
+// this is a fn because console width can have changed since startup
+const maxCharsPerLine = () => (process.stdout.columns || 100) * 80 / 100;
+
+function indent (count, chr = ' ') {
+  return chr.repeat(count)
+}
+
+function indentLines (string, spaces, firstLineSpaces) {
+  const lines = Array.isArray(string) ? string : string.split('\n');
+  let s = '';
+  if (lines.length) {
+    const i0 = indent(firstLineSpaces === undefined ? spaces : firstLineSpaces);
+    s = i0 + lines.shift();
+  }
+  if (lines.length) {
+    const i = indent(spaces);
+    s += '\n' + lines.map(l => i + l).join('\n');
+  }
+  return s
+}
+
+function foldLines (string, spaces, firstLineSpaces, charsPerLine = maxCharsPerLine()) {
+  return indentLines(wrapAnsi__default['default'](string, charsPerLine), spaces, firstLineSpaces)
+}
+
+function colorize (text) {
+  return text
+    .replace(/\[[^ ]+]/g, m => chalk__default['default'].grey(m))
+    .replace(/<[^ ]+>/g, m => chalk__default['default'].green(m))
+    .replace(/ (-[-\w,]+)/g, m => chalk__default['default'].bold(m))
+    .replace(/`([^`]+)`/g, (_, m) => chalk__default['default'].bold.cyan(m))
+}
+
+function box (message, title, options) {
+  return boxen__default['default']([
+    title || chalk__default['default'].white('Nuxt Message'),
+    '',
+    chalk__default['default'].white(foldLines(message, 0, 0, maxCharsPerLine()))
+  ].join('\n'), Object.assign({
+    borderColor: 'white',
+    borderStyle: 'round',
+    padding: 1,
+    margin: 1
+  }, options)) + '\n'
+}
+
+function successBox (message, title) {
+  return box(message, title || chalk__default['default'].green('✔ Nuxt Success'), {
+    borderColor: 'green'
+  })
+}
+
+function warningBox (message, title) {
+  return box(message, title || chalk__default['default'].yellow('⚠ Nuxt Warning'), {
+    borderColor: 'yellow'
+  })
+}
+
+function errorBox (message, title) {
+  return box(message, title || chalk__default['default'].red('✖ Nuxt Error'), {
+    borderColor: 'red'
+  })
+}
+
+function fatalBox (message, title) {
+  return errorBox(message, title || chalk__default['default'].red('✖ Nuxt Fatal Error'))
+}
+
+const eventsMapping = {
+  add: { icon: '+', color: 'green', action: 'Created' },
+  change: { icon: env__default['default'].windows ? '»' : '↻', color: 'blue', action: 'Updated' },
+  unlink: { icon: '-', color: 'red', action: 'Removed' }
+};
+
+function formatPath (filePath) {
+  if (!filePath) {
+    return
+  }
+  return filePath.replace(process.cwd() + path__default['default'].sep, '')
+}
+
+/**
+ * Normalize string argument in command
+ *
+ * @export
+ * @param {String} argument
+ * @param {*} defaultValue
+ * @returns formatted argument
+ */
+function normalizeArg (arg, defaultValue) {
+  switch (arg) {
+    case 'true': arg = true; break
+    case '': arg = true; break
+    case 'false': arg = false; break
+    case undefined: arg = defaultValue; break
+  }
+  return arg
+}
+
+function forceExit (cmdName, timeout) {
+  if (timeout !== false) {
+    const exitTimeout = setTimeout(() => {
+      const msg = `The command 'nuxt ${cmdName}' finished but did not exit after ${timeout}s
+This is most likely not caused by a bug in Nuxt
+Make sure to cleanup all timers and listeners you or your plugins/modules start.
+Nuxt will now force exit
+
+${chalk__default['default'].bold('DeprecationWarning: Starting with Nuxt version 3 this will be a fatal error')}`;
+
+      // TODO: Change this to a fatal error in v3
+      process.stderr.write(warningBox(msg));
+      exit__default['default'](0);
+    }, timeout * 1000);
+    exitTimeout.unref();
+  } else {
+    exit__default['default'](0);
+  }
+}
+
+// An immediate export throws an error when mocking with jest
+// TypeError: Cannot set property createLock of #<Object> which has only a getter
+function createLock (...args) {
+  return utils.lock(...args)
+}
+
+const common = {
+  spa: {
+    alias: 's',
+    type: 'boolean',
+    description: 'Launch in SPA mode'
+  },
+  universal: {
+    alias: 'u',
+    type: 'boolean',
+    description: 'Launch in Universal mode (default)'
+  },
+  'config-file': {
+    alias: 'c',
+    type: 'string',
+    default: config.defaultNuxtConfigFile,
+    description: `Path to Nuxt config file (default: \`${config.defaultNuxtConfigFile}\`)`
+  },
+  modern: {
+    alias: 'm',
+    type: 'string',
+    description: 'Build/Start app for modern browsers, e.g. server, client and false',
+    prepare (cmd, options, argv) {
+      if (argv.modern !== undefined) {
+        options.modern = normalizeArg(argv.modern);
+      }
+    }
+  },
+  target: {
+    alias: 't',
+    type: 'string',
+    description: 'Build/start app for a different target, e.g. server, serverless and static',
+    prepare (cmd, options, argv) {
+      if (argv.target) {
+        options.target = argv.target;
+      }
+    }
+  },
+  'force-exit': {
+    type: 'boolean',
+    default (cmd) {
+      return ['build', 'generate', 'export'].includes(cmd.name)
+    },
+    description: 'Whether Nuxt should force exit after the command has finished'
+  },
+  version: {
+    alias: 'v',
+    type: 'boolean',
+    description: 'Display the Nuxt version'
+  },
+  help: {
+    alias: 'h',
+    type: 'boolean',
+    description: 'Display this message'
+  },
+  processenv: {
+    type: 'boolean',
+    default: true,
+    description: 'Disable reading from `process.env` and updating it with dotenv'
+  },
+  dotenv: {
+    type: 'string',
+    default: '.env',
+    description: 'Specify path to dotenv file (default: `.env`). Use `false` to disable'
+  }
+};
+
+const server = {
+  port: {
+    alias: 'p',
+    type: 'string',
+    description: 'Port number on which to start the application',
+    prepare (cmd, options, argv) {
+      if (argv.port) {
+        options.server.port = +argv.port;
+      }
+    }
+  },
+  hostname: {
+    alias: 'H',
+    type: 'string',
+    description: 'Hostname on which to start the application',
+    prepare (cmd, options, argv) {
+      if (argv.hostname === '') {
+        consola__default['default'].fatal('Provided hostname argument has no value');
+      }
+    }
+  },
+  'unix-socket': {
+    alias: 'n',
+    type: 'string',
+    description: 'Path to a UNIX socket'
+  }
+};
+
+const locking = {
+  lock: {
+    type: 'boolean',
+    default: true,
+    description: 'Do not set a lock on the project when building'
+  }
+};
+
+const index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  common: common,
+  server: server,
+  locking: locking
+});
+
+var name = "@nuxt/cli";
+var version = "2.15.8";
+
+async function loadNuxtConfig (argv, configContext) {
+  const rootDir = path__default['default'].resolve(argv._[0] || '.');
+  const configFile = argv['config-file'];
+
+  // Load config
+  const options = await config.loadNuxtConfig({
+    rootDir,
+    configFile,
+    configContext,
+    envConfig: {
+      dotenv: argv.dotenv === 'false' ? false : argv.dotenv,
+      env: argv.processenv ? process.env : {}
+    }
+  });
+
+  if (argv.spa === true) {
+    options.ssr = false;
+  } else if (argv.universal === true) {
+    options.ssr = true;
+  }
+
+  // Server options
+  options.server = defu__default['default']({
+    port: argv.port || null,
+    host: argv.hostname || null,
+    socket: argv['unix-socket'] || null
+  }, options.server || {}, config.getDefaultNuxtConfig().server);
+
+  return options
+}
+
+class NuxtCommand extends Hookable__default['default'] {
+  constructor (cmd = { name: '', usage: '', description: '' }, argv = process.argv.slice(2), hooks = {}) {
+    super(consola__default['default']);
+    this.addHooks(hooks);
+
+    if (!cmd.options) {
+      cmd.options = {};
+    }
+    this.cmd = cmd;
+
+    this._argv = Array.from(argv);
+    this._parsedArgv = null; // Lazy evaluate
+  }
+
+  static run (cmd, argv, hooks) {
+    return NuxtCommand.from(cmd, argv, hooks).run()
+  }
+
+  static from (cmd, argv, hooks) {
+    if (cmd instanceof NuxtCommand) {
+      return cmd
+    }
+    return new NuxtCommand(cmd, argv, hooks)
+  }
+
+  async run () {
+    await this.callHook('run:before', {
+      argv: this._argv,
+      cmd: this.cmd,
+      rootDir: path__default['default'].resolve(this.argv._[0] || '.')
+    });
+
+    if (this.argv.help) {
+      this.showHelp();
+      return
+    }
+
+    if (this.argv.version) {
+      this.showVersion();
+      return
+    }
+
+    if (typeof this.cmd.run !== 'function') {
+      throw new TypeError('Invalid command! Commands should at least implement run() function.')
+    }
+
+    let cmdError;
+
+    try {
+      await this.cmd.run(this);
+    } catch (e) {
+      cmdError = e;
+    }
+
+    if (this.argv.lock) {
+      await this.releaseLock();
+    }
+
+    if (this.argv['force-exit']) {
+      const forceExitByUser = this.isUserSuppliedArg('force-exit');
+      if (cmdError) {
+        consola__default['default'].fatal(cmdError);
+      }
+      forceExit(this.cmd.name, forceExitByUser ? false : forceExitTimeout);
+      if (forceExitByUser) {
+        return
+      }
+    }
+
+    if (cmdError) {
+      throw cmdError
+    }
+  }
+
+  showVersion () {
+    process.stdout.write(`${name} v${version}\n`);
+  }
+
+  showHelp () {
+    process.stdout.write(this._getHelp());
+  }
+
+  get argv () {
+    if (!this._parsedArgv) {
+      const minimistOptions = this._getMinimistOptions();
+      this._parsedArgv = minimist__default['default'](this._argv, minimistOptions);
+    }
+    return this._parsedArgv
+  }
+
+  async getNuxtConfig (extraOptions = {}) {
+    // Flag to indicate nuxt is running with CLI (not programmatic)
+    extraOptions._cli = true;
+
+    const context = {
+      command: this.cmd.name,
+      dev: !!extraOptions.dev
+    };
+
+    const config = await loadNuxtConfig(this.argv, context);
+    const options = Object.assign(config, extraOptions);
+
+    for (const name of Object.keys(this.cmd.options)) {
+      this.cmd.options[name].prepare && this.cmd.options[name].prepare(this, options, this.argv);
+    }
+
+    await this.callHook('config', options);
+
+    return options
+  }
+
+  async getNuxt (options) {
+    const { Nuxt } = await core();
+
+    const nuxt = new Nuxt(options);
+    await nuxt.ready();
+
+    return nuxt
+  }
+
+  async getBuilder (nuxt) {
+    const { Builder } = await builder();
+    const { BundleBuilder } = await webpack();
+    return new Builder(nuxt, BundleBuilder)
+  }
+
+  async getGenerator (nuxt) {
+    const { Generator } = await generator();
+    const builder = await this.getBuilder(nuxt);
+    return new Generator(nuxt, builder)
+  }
+
+  async setLock (lockRelease) {
+    if (lockRelease) {
+      if (this._lockRelease) {
+        consola__default['default'].warn(`A previous unreleased lock was found, this shouldn't happen and is probably an error in 'nuxt ${this.cmd.name}' command. The lock will be removed but be aware of potential strange results`);
+
+        await this.releaseLock();
+        this._lockRelease = lockRelease;
+      } else {
+        this._lockRelease = lockRelease;
+      }
+    }
+  }
+
+  async releaseLock () {
+    if (this._lockRelease) {
+      await this._lockRelease();
+      this._lockRelease = undefined;
+    }
+  }
+
+  isUserSuppliedArg (option) {
+    return this._argv.includes(`--${option}`) || this._argv.includes(`--no-${option}`)
+  }
+
+  _getDefaultOptionValue (option) {
+    return typeof option.default === 'function' ? option.default(this.cmd) : option.default
+  }
+
+  _getMinimistOptions () {
+    const minimistOptions = {
+      alias: {},
+      boolean: [],
+      string: [],
+      default: {}
+    };
+
+    for (const name of Object.keys(this.cmd.options)) {
+      const option = this.cmd.options[name];
+
+      if (option.alias) {
+        minimistOptions.alias[option.alias] = name;
+      }
+      if (option.type) {
+        minimistOptions[option.type].push(option.alias || name);
+      }
+      if (option.default) {
+        minimistOptions.default[option.alias || name] = this._getDefaultOptionValue(option);
+      }
+    }
+
+    return minimistOptions
+  }
+
+  _getHelp () {
+    const options = [];
+    let maxOptionLength = 0;
+
+    for (const name in this.cmd.options) {
+      const option = this.cmd.options[name];
+
+      let optionHelp = '--';
+      optionHelp += option.type === 'boolean' && this._getDefaultOptionValue(option) ? 'no-' : '';
+      optionHelp += name;
+      if (option.alias) {
+        optionHelp += `, -${option.alias}`;
+      }
+
+      maxOptionLength = Math.max(maxOptionLength, optionHelp.length);
+      options.push([optionHelp, option.description]);
+    }
+
+    const _opts = options.map(([option, description]) => {
+      const i = indent(maxOptionLength + optionSpaces - option.length);
+      return foldLines(
+        option + i + description,
+        startSpaces + maxOptionLength + optionSpaces * 2,
+        startSpaces + optionSpaces
+      )
+    }).join('\n');
+
+    const usage = foldLines(`Usage: nuxt ${this.cmd.usage} [options]`, startSpaces);
+    const description = foldLines(this.cmd.description, startSpaces);
+    const opts = foldLines('Options:', startSpaces) + '\n\n' + _opts;
+
+    let helpText = colorize(`${usage}\n\n`);
+    if (this.cmd.description) {
+      helpText += colorize(`${description}\n\n`);
+    }
+    if (options.length) {
+      helpText += colorize(`${opts}\n\n`);
+    }
+
+    return helpText
+  }
+}
+
+const dependencies = {
+  webpack: '^4.46.0',
+  'css-loader': '>=4.2.0',
+  'sass-loader': '^10.1.1'
+};
+
+const nodeVersion = '>=12.0.0';
+
+function getInstalledVersion (name) {
+  try {
+    return utils.getPKG(name).version
+  } catch { }
+}
+
+function checkDependencies () {
+  for (const name in dependencies) {
+    const installedVersion = getInstalledVersion(name);
+    if (!installedVersion) {
+      continue // Ignore to avoid false-positive warnings
+    }
+    const expectedRange = dependencies[name];
+    if (!semver.satisfies(installedVersion, expectedRange)) {
+      consola__default['default'].warn(`${name}@${installedVersion} is installed but ${expectedRange} is expected`);
+    }
+  }
+
+  // Check Node versions
+  if (!semver.satisfies(process.version, nodeVersion)) {
+    consola__default['default'].warn(`You are using an unsupported version of Node.js (${process.version}). It is recommended to use the latest LTS version (https://nodejs.org/en/about/releases)`);
+  }
+}
+
+let _setup = false;
+
+function setup ({ dev }) {
+  // Apply default NODE_ENV if not provided
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = dev ? 'development' : 'production';
+  }
+
+  if (_setup) {
+    return
+  }
+  _setup = true;
+
+  checkDependencies();
+
+  // Global error handler
+  /* istanbul ignore next */
+  process.on('unhandledRejection', (err) => {
+    consola__default['default'].error(err);
+  });
+
+  // Exit process on fatal errors
+  /* istanbul ignore next */
+  consola__default['default'].addReporter({
+    log (logObj) {
+      if (logObj.type === 'fatal') {
+        const errorMessage = String(logObj.args[0]);
+        process.stderr.write(fatalBox(errorMessage));
+        exit__default['default'](1);
+      }
+    }
+  });
+
+  // Wrap all console logs with consola for better DX
+  consola__default['default'].wrapConsole();
+}
+
+function isNuxtDir (rootDir) {
+  if (fs__default['default'].existsSync(path__default['default'].join(rootDir, 'nuxt.config.js')) ||
+    fs__default['default'].existsSync(path__default['default'].join(rootDir, 'pages')) ||
+    fs__default['default'].existsSync(path__default['default'].join(rootDir, 'nuxt.config.ts'))) {
+    return true
+  }
+  return false
+}
+
+async function run (_argv, hooks = {}) {
+  // Check for not installing both nuxt and nuxt-edge
+  const dupPkg = 'cli-edge';
+  const dupPkgJSON = path.resolve(__dirname, '../..' /* dist/../.. */, dupPkg, 'package.json');
+  if (fs.existsSync(dupPkgJSON) && utils.requireModule(dupPkgJSON).name !== '@nuxt/' + dupPkg) {
+    consola__default['default'].warn('Both `nuxt` and `nuxt-edge` dependencies are installed! Please choose one and remove the other one from dependencies.');
+  }
+
+  // Read from process.argv
+  const argv = _argv ? Array.from(_argv) : process.argv.slice(2);
+
+  // Check for internal command
+  let cmd = await getCommand(argv[0]);
+
+  // Matching `nuxt` or `nuxt [dir]` or `nuxt -*` for `nuxt dev` shortcut
+  if (!cmd && (!argv[0] || argv[0][0] === '-' || isNuxtDir(argv[0]))) {
+    argv.unshift('dev');
+    cmd = await getCommand('dev');
+  }
+
+  // Check for dev
+  const dev = argv[0] === 'dev';
+
+  // Setup env
+  setup({ dev });
+
+  // Try internal command
+  if (cmd) {
+    return NuxtCommand.run(cmd, argv.slice(1), hooks)
+  }
+
+  // Try external command
+  try {
+    await execa__default['default'](`nuxt-${argv[0]}`, argv.slice(1), {
+      stdout: process.stdout,
+      stderr: process.stderr,
+      stdin: process.stdin
+    });
+  } catch (error) {
+    if (error.exitCode === 2) {
+      throw String(`Command not found: nuxt-${argv[0]}`)
+    }
+    throw String(`Failed to run command \`nuxt-${argv[0]}\`:\n${error}`)
+  }
+}
+
+async function getWebpackConfig (name = 'client', loadOptions = {}) {
+  const { loadNuxt } = await core();
+  const { getBuilder } = await builder();
+
+  const nuxt = await loadNuxt(loadOptions);
+  const builder$1 = await getBuilder(nuxt);
+  const { bundleBuilder } = builder$1;
+  return bundleBuilder.getWebpackConfig(name)
+}
+
+exports.NuxtCommand = NuxtCommand;
+exports.colorize = colorize;
+exports.common = common;
+exports.core = core;
+exports.createLock = createLock;
+exports.eventsMapping = eventsMapping;
+exports.foldLines = foldLines;
+exports.formatPath = formatPath;
+exports.getCommand = getCommand;
+exports.getWebpackConfig = getWebpackConfig;
+exports.imports = imports;
+exports.indent = indent;
+exports.index = index$1;
+exports.index$1 = index;
+exports.isNuxtDir = isNuxtDir;
+exports.loadNuxtConfig = loadNuxtConfig;
+exports.locking = locking;
+exports.normalizeArg = normalizeArg;
+exports.optionSpaces = optionSpaces;
+exports.run = run;
+exports.server = server$1;
+exports.server$1 = server;
+exports.setup = setup;
+exports.startSpaces = startSpaces;
+exports.successBox = successBox;

node_modules/@nuxt/cli/dist/cli-serve.js

@@ -0,0 +1,44 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+const consola = require('consola');
+const start = require('./cli-start.js');
+require('@nuxt/utils');
+require('./cli-index.js');
+require('@nuxt/config');
+require('path');
+require('exit');
+require('chalk');
+require('std-env');
+require('wrap-ansi');
+require('boxen');
+require('minimist');
+require('hable');
+require('defu');
+require('semver');
+require('fs');
+require('execa');
+require('./cli-banner.js');
+require('pretty-bytes');
+require('connect');
+require('serve-static');
+require('compression');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+
+const serve = {
+  ...start['default'],
+  run (...args) {
+    consola__default['default'].warn('`nuxt serve` has been deprecated! Please use `nuxt start`.');
+    return start['default'].run.call(this, ...args)
+  }
+};
+
+exports.default = serve;

node_modules/@nuxt/cli/dist/cli-start.js

@@ -0,0 +1,129 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+const utils = require('@nuxt/utils');
+const index = require('./cli-index.js');
+const banner = require('./cli-banner.js');
+const fs = require('fs');
+const path = require('path');
+const consola = require('consola');
+const connect = require('connect');
+const serveStatic = require('serve-static');
+const compression = require('compression');
+const config = require('@nuxt/config');
+require('exit');
+require('chalk');
+require('std-env');
+require('wrap-ansi');
+require('boxen');
+require('minimist');
+require('hable');
+require('defu');
+require('semver');
+require('execa');
+require('pretty-bytes');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+const connect__default = /*#__PURE__*/_interopDefaultLegacy(connect);
+const serveStatic__default = /*#__PURE__*/_interopDefaultLegacy(serveStatic);
+const compression__default = /*#__PURE__*/_interopDefaultLegacy(compression);
+
+async function serve (cmd) {
+  const _config = await cmd.getNuxtConfig({ dev: false });
+
+  // add default options
+  const options = config.getNuxtConfig(_config);
+
+  try {
+    // overwrites with build config
+    const buildConfig = utils.requireModule(path.join(options.buildDir, 'nuxt/config.json'));
+    options.target = buildConfig.target;
+  } catch (err) { }
+
+  const distStat = await fs.promises.stat(options.generate.dir).catch(err => null); // eslint-disable-line node/handle-callback-err
+  const distPath = path.join(options.generate.dir.replace(process.cwd() + path.sep, ''), path.sep);
+  if (!distStat || !distStat.isDirectory()) {
+    throw new Error('Output directory `' + distPath + '` does not exist, please use `nuxt generate` before `nuxt start` for static target.')
+  }
+  const app = connect__default['default']();
+  app.use(compression__default['default']({ threshold: 0 }));
+  app.use(
+    options.router.base,
+    serveStatic__default['default'](options.generate.dir, {
+      extensions: ['html']
+    })
+  );
+  if (options.generate.fallback) {
+    const fallbackFile = await fs.promises.readFile(path.join(options.generate.dir, options.generate.fallback), 'utf-8');
+    app.use((req, res, next) => {
+      const ext = path.extname(req.url) || '.html';
+
+      if (ext !== '.html') {
+        return next()
+      }
+      res.writeHeader(200, {
+        'Content-Type': 'text/html'
+      });
+      res.write(fallbackFile);
+      res.end();
+    });
+  }
+
+  const { port, host, socket, https } = options.server;
+  const { Listener } = await index.server();
+  const listener = new Listener({
+    port,
+    host,
+    socket,
+    https,
+    app,
+    dev: true, // try another port if taken
+    baseURL: options.router.base
+  });
+
+  await listener.listen();
+
+  const { Nuxt } = await index.core();
+
+  banner.showBanner({
+    constructor: Nuxt,
+    options,
+    server: {
+      listeners: [listener]
+    }
+  }, false);
+
+  consola__default['default'].info(`Serving static application from \`${distPath}\``);
+}
+
+const start = {
+  name: 'start',
+  description: 'Start the application in production mode (the application should be compiled with `nuxt build` first)',
+  usage: 'start <dir>',
+  options: {
+    ...index.common,
+    ...index.server$1
+  },
+  async run (cmd) {
+    const config = await cmd.getNuxtConfig({ dev: false, _start: true });
+
+    if (config.target === utils.TARGETS.static) {
+      return serve(cmd)
+    }
+
+    const nuxt = await cmd.getNuxt(config);
+
+    // Listen and show ready banner
+    await nuxt.server.listen();
+    banner.showBanner(nuxt);
+  }
+};
+
+exports.default = start;

node_modules/@nuxt/cli/dist/cli-webpack.js

@@ -0,0 +1,145 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+const util = require('util');
+const consola = require('consola');
+const lodash = require('lodash');
+const index = require('./cli-index.js');
+require('@nuxt/utils');
+require('@nuxt/config');
+require('path');
+require('exit');
+require('chalk');
+require('std-env');
+require('wrap-ansi');
+require('boxen');
+require('minimist');
+require('hable');
+require('defu');
+require('semver');
+require('fs');
+require('execa');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const util__default = /*#__PURE__*/_interopDefaultLegacy(util);
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+
+const webpack = {
+  name: 'webpack',
+  description: 'Inspect Nuxt webpack config',
+  usage: 'webpack [query...]',
+  options: {
+    ...index.common,
+    name: {
+      alias: 'n',
+      type: 'string',
+      default: 'client',
+      description: 'Webpack bundle name: server, client, modern'
+    },
+    depth: {
+      alias: 'd',
+      type: 'string',
+      default: 2,
+      description: 'Inspection depth'
+    },
+    colors: {
+      type: 'boolean',
+      default: process.stdout.isTTY,
+      description: 'Output with ANSI colors'
+    },
+    dev: {
+      type: 'boolean',
+      default: false,
+      description: 'Inspect development mode webpack config'
+    }
+  },
+  async run (cmd) {
+    const { name } = cmd.argv;
+    const queries = [...cmd.argv._];
+
+    const config = await cmd.getNuxtConfig({ dev: cmd.argv.dev, server: false });
+    const nuxt = await cmd.getNuxt(config);
+    const builder = await cmd.getBuilder(nuxt);
+    const { bundleBuilder } = builder;
+    const webpackConfig = bundleBuilder.getWebpackConfig(name);
+
+    let queryError;
+    const match = queries.reduce((result, query) => {
+      const m = advancedGet(result, query);
+      if (m === undefined) {
+        queryError = query;
+        return result
+      }
+      return m
+    }, webpackConfig);
+
+    const serialized = formatObj(match, {
+      depth: parseInt(cmd.argv.depth),
+      colors: cmd.argv.colors
+    });
+
+    consola__default['default'].log(serialized + '\n');
+
+    if (serialized.includes('[Object]' )) {
+      consola__default['default'].info('You can use `--depth` or add more queries to inspect `[Object]` and `[Array]` fields.');
+    }
+
+    if (queryError) {
+      consola__default['default'].warn(`No match in webpack config for \`${queryError}\``);
+    }
+  }
+};
+
+function advancedGet (obj = {}, query = '') {
+  let result = obj;
+
+  if (!query || !result) {
+    return result
+  }
+
+  const [l, r] = query.split('=');
+
+  if (!Array.isArray(result)) {
+    return typeof result === 'object' ? lodash.get(result, l) : result
+  }
+
+  result = result.filter((i) => {
+    const v = lodash.get(i, l);
+
+    if (!v) {
+      return false
+    }
+
+    if (
+      (v === r) ||
+      (typeof v.test === 'function' && v.test(r)) ||
+      (typeof v.match === 'function' && v.match(r)) ||
+      (r && r.match(v))
+    ) {
+      return true
+    }
+
+    return false
+  });
+
+  if (result.length === 1) {
+    return result[0]
+  }
+
+  return result.length ? result : undefined
+}
+
+function formatObj (obj, formatOptions) {
+  if (!util__default['default'].formatWithOptions) {
+    return util__default['default'].format(obj)
+  }
+  return util__default['default'].formatWithOptions(formatOptions, obj)
+}
+
+exports.default = webpack;

node_modules/@nuxt/cli/dist/cli.js

@@ -0,0 +1,38 @@
+/*!
+ * @nuxt/cli v2.15.8 (c) 2016-2021
+ * Released under the MIT License
+ * Repository: https://github.com/nuxt/nuxt.js
+ * Website: https://nuxtjs.org
+*/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./cli-index.js');
+require('@nuxt/utils');
+require('@nuxt/config');
+require('path');
+require('exit');
+require('chalk');
+require('std-env');
+require('wrap-ansi');
+require('boxen');
+require('consola');
+require('minimist');
+require('hable');
+require('defu');
+require('semver');
+require('fs');
+require('execa');
+
+
+
+exports.NuxtCommand = index.NuxtCommand;
+exports.commands = index.index;
+exports.getWebpackConfig = index.getWebpackConfig;
+exports.imports = index.imports;
+exports.isNuxtDir = index.isNuxtDir;
+exports.loadNuxtConfig = index.loadNuxtConfig;
+exports.options = index.index$1;
+exports.run = index.run;
+exports.setup = index.setup;