text: #!/usr/bin/env node
  const pkg = require("./package.json");
  require("please-upgrade-node")(pkg, {
    message: function (requiredVersion) {
      return (
        "Eleventy requires Node " +
        requiredVersion +
        ". You will need to upgrade Node to use Eleventy!"
      );
    },
  });
  const debug = require("debug")("Eleventy:cmd");
  
  const EleventyErrorHandler = require("./src/EleventyErrorHandler");
  
  try {
    let errorHandler = new EleventyErrorHandler();
    const EleventyCommandCheckError = require("./src/EleventyCommandCheckError");
    const argv = require("minimist")(process.argv.slice(2), {
      string: [
        "input",
        "output",
        "formats",
        "config",
        "pathprefix",
        "port",
        "to",
      ],
      boolean: [
        "quiet",
        "version",
        "watch",
        "dryrun",
        "help",
        "serve",
        "passthroughall",
        "incremental",
      ],
      default: {
        quiet: null,
      },
      unknown: function (unknownArgument) {
        throw new EleventyCommandCheckError(
          `We don’t know what '${unknownArgument}' is. Use --help to see the list of supported commands.`
        );
      },
    });
  
    debug("command: eleventy %o", argv);
    const Eleventy = require("./src/Eleventy");
  
    process.on("unhandledRejection", (error, promise) => {
      errorHandler.fatal(error, "Unhandled rejection in promise");
    });
    process.on("uncaughtException", (error) => {
      errorHandler.fatal(error, "Uncaught exception");
    });
    process.on("rejectionHandled", (promise) => {
      errorHandler.warn(
        promise,
        "A promise rejection was handled asynchronously"
      );
    });
  
    if (argv.version) {
      console.log(Eleventy.getVersion());
    } else if (argv.help) {
      console.log(Eleventy.getHelp());
    } else {
      let elev = new Eleventy(argv.input, argv.output, {
        // --quiet and --quiet=true both resolve to true
        quietMode: argv.quiet,
        configPath: argv.config,
        source: "cli",
      });
  
      // reuse ErrorHandler instance in Eleventy
      errorHandler = elev.errorHandler;
  
      if (argv.to === "json" || argv.to === "ndjson") {
        // override logging output
        elev.setIsVerbose(false);
      }
  
      elev.setPathPrefix(argv.pathprefix);
      elev.setDryRun(argv.dryrun);
      elev.setIncrementalBuild(argv.incremental);
      elev.setPassthroughAll(argv.passthroughall);
      elev.setFormats(argv.formats);
  
      if (argv.watch) {
        elev.setRunMode("watch");
      } else if (argv.serve) {
        elev.setRunMode("serve");
      }
  
      // careful, we can’t use async/await here to error properly
      // with old node versions in `please-upgrade-node` above.
      elev
        .init()
        .then(function () {
          try {
            if (argv.serve) {
              let shouldStartServer = true;
              elev
                .watch()
                .catch((e) => {
                  // Build failed but error message already displayed.
                  shouldStartServer = false;
                  // A build error occurred and we aren’t going to --serve
                })
                .then(function () {
                  if (shouldStartServer) {
                    elev.serve(argv.port);
                  }
                });
            } else if (argv.watch) {
              elev.watch().catch((e) => {
                // A build error occurred and we aren’t going to --watch
              });
            } else {
              if (argv.to === "json") {
                elev.toJSON().then(function (result) {
                  console.log(JSON.stringify(result, null, 2));
                });
              } else if (argv.to === "ndjson") {
                elev.toNDJSON().then(function (stream) {
                  stream.pipe(process.stdout);
                });
              } else if (!argv.to || argv.to === "fs") {
                elev.write();
              } else {
                throw new EleventyCommandCheckError(
                  `Invalid --to value: ${argv.to}. Supported values: \`fs\` (default), \`json\`, and \`ndjson\`.`
                );
              }
            }
          } catch (e) {
            errorHandler.fatal(e, "Eleventy CLI Error");
          }
        })
        .catch(errorHandler.fatal.bind(errorHandler));
    }
  } catch (e) {
    let errorHandler = new EleventyErrorHandler();
    errorHandler.fatal(e, "Eleventy CLI Fatal Error");
  }
  