text: /*!
   * @nuxt/cli v2.15.2 (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 = /*#__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 = () => importModule('@nuxt/server');
  
  const imports = /*#__PURE__*/Object.freeze({
    __proto__: null,
    importModule: importModule,
    builder: builder,
    webpack: webpack,
    generator: generator,
    core: core,
    server: server
  });
  
  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$1 = {
    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$1 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    common: common,
    server: server$1,
    locking: locking
  });
  
  var name = "@nuxt/cli";
  var version = "2.15.2";
  
  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 = {
    postcss: '^7.0.32',
    webpack: '^4.46.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;
  exports.index$1 = index$1;
  exports.isNuxtDir = isNuxtDir;
  exports.loadNuxtConfig = loadNuxtConfig;
  exports.locking = locking;
  exports.normalizeArg = normalizeArg;
  exports.optionSpaces = optionSpaces;
  exports.run = run;
  exports.server = server;
  exports.server$1 = server$1;
  exports.setup = setup;
  exports.startSpaces = startSpaces;
  exports.successBox = successBox;
  