@atlaspack/cli 2.13.7-canary.43 → 2.13.7-canary.430

package/bin/atlaspack.js

@@ -1,2 +1,13 @@
 #!/usr/bin/env node
-require('../lib/bin');
+'use strict';
+
+if (
+  process.env.ATLASPACK_REGISTER_USE_SRC === 'true' ||
+  process.env.ATLASPACK_BUILD_ENV === 'test' ||
+  process.env.ATLASPACK_SELF_BUILD
+) {
+  require('@atlaspack/babel-register');
+  require('../src/cli');
+} else {
+  require('../lib/cli');
+}

package/dist/applyOptions.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyOptions = applyOptions;
+// @ts-expect-error TS2305
+const commander_1 = __importDefault(require("commander"));
+function applyOptions(cmd, options) {
+    for (let opt in options) {
+        const option = options[opt];
+        if (option instanceof commander_1.default.Option) {
+            cmd.addOption(option);
+        }
+        else if (Array.isArray(option)) {
+            // @ts-expect-error TS2345
+            cmd.option(opt, ...option);
+        }
+        else if (typeof option === 'string') {
+            cmd.option(opt, option);
+        }
+    }
+}

package/dist/cli.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@atlaspack/core");
+const fs_1 = require("@atlaspack/fs");
+const utils_1 = require("@atlaspack/utils");
+const events_1 = require("@atlaspack/events");
+const logger_1 = require("@atlaspack/logger");
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = __importDefault(require("commander"));
+const path_1 = __importDefault(require("path"));
+const package_json_1 = require("../package.json");
+const applyOptions_1 = require("./applyOptions");
+const makeDebugCommand_1 = require("./makeDebugCommand");
+const normalizeOptions_1 = require("./normalizeOptions");
+const handleUncaughtException_1 = require("./handleUncaughtException");
+const options_1 = require("./options");
+const program = new commander_1.default.Command();
+// Exit codes in response to signals are traditionally
+// 128 + signal value
+// https://tldp.org/LDP/abs/html/exitcodes.html
+const SIGINT_EXIT_CODE = 130;
+process.on('unhandledRejection', handleUncaughtException_1.handleUncaughtException);
+program.storeOptionsAsProperties();
+program.version(package_json_1.version);
+let serve = program
+    .command('serve [input...]')
+    .description('starts a development server')
+    .option('--public-url <url>', 'the path prefix for absolute urls')
+    .option('--open [browser]', 'automatically open in specified browser, defaults to default browser')
+    .option('--watch-for-stdin', 'exit when stdin closes')
+    .option('--lazy [includes]', 'Build async bundles on demand, when requested in the browser. Defaults to all async bundles, unless a comma separated list of source file globs is provided. Only async bundles whose entry points match these globs will be built lazily')
+    .option('--lazy-exclude <excludes>', 'Can only be used in combination with --lazy. Comma separated list of source file globs, async bundles whose entry points match these globs will not be built lazily')
+    .option('--production', 'Run with production mode defaults')
+    .action(runCommand);
+(0, applyOptions_1.applyOptions)(serve, options_1.hmrOptions);
+(0, applyOptions_1.applyOptions)(serve, options_1.commonOptions);
+let watch = program
+    .command('watch [input...]')
+    .description('starts the bundler in watch mode')
+    .option('--public-url <url>', 'the path prefix for absolute urls')
+    .option('--no-content-hash', 'disable content hashing')
+    .option('--watch-for-stdin', 'exit when stdin closes')
+    .option('--production', 'Run with production mode defaults')
+    .action(runCommand);
+(0, applyOptions_1.applyOptions)(watch, options_1.hmrOptions);
+(0, applyOptions_1.applyOptions)(watch, options_1.commonOptions);
+let build = program
+    .command('build [input...]')
+    .description('bundles for production')
+    .option('--no-optimize', 'disable minification')
+    .option('--no-scope-hoist', 'disable scope-hoisting')
+    .option('--public-url <url>', 'the path prefix for absolute urls')
+    .option('--no-content-hash', 'disable content hashing')
+    .action(runCommand);
+(0, applyOptions_1.applyOptions)(build, options_1.commonOptions);
+program.addCommand((0, makeDebugCommand_1.makeDebugCommand)());
+program
+    .command('help [command]')
+    .description('display help information for a command')
+    .action(function (command) {
+    let cmd = program.commands.find((c) => c.name() === command) || program;
+    cmd.help();
+});
+program.on('--help', function () {
+    logger_1.INTERNAL_ORIGINAL_CONSOLE.log('');
+    logger_1.INTERNAL_ORIGINAL_CONSOLE.log('  Run `' +
+        chalk_1.default.bold('atlaspack help <command>') +
+        '` for more information on specific commands');
+    logger_1.INTERNAL_ORIGINAL_CONSOLE.log('');
+});
+// Override to output option description if argument was missing
+commander_1.default.Command.prototype.optionMissingArgument = function (option) {
+    logger_1.INTERNAL_ORIGINAL_CONSOLE.error("error: option `%s' argument missing", option.flags);
+    logger_1.INTERNAL_ORIGINAL_CONSOLE.log(program.createHelp().optionDescription(option));
+    process.exit(1);
+};
+// Make serve the default command except for --help
+var args = process.argv;
+if (args[2] === '--help' || args[2] === '-h')
+    args[2] = 'help';
+if (!args[2] || !program.commands.some((c) => c.name() === args[2])) {
+    args.splice(2, 0, 'serve');
+}
+program.parse(args);
+// @ts-expect-error TS7019
+function runCommand(...args) {
+    // @ts-expect-error TS2556
+    run(...args).catch(handleUncaughtException_1.handleUncaughtException);
+}
+async function run(entries, _opts, // using pre v7 Commander options as properties
+command) {
+    if (entries.length === 0) {
+        entries = ['.'];
+    }
+    entries = entries.map((entry) => path_1.default.resolve(entry));
+    let Atlaspack = require('@atlaspack/core').default;
+    let fs = new fs_1.NodeFS();
+    let options = await (0, normalizeOptions_1.normalizeOptions)(command, fs);
+    let atlaspack = new Atlaspack({
+        entries,
+        defaultConfig: require.resolve('@atlaspack/config-default', {
+            paths: [fs.cwd(), __dirname],
+        }),
+        shouldPatchConsole: false,
+        ...options,
+    });
+    let disposable = new events_1.Disposable();
+    let unsubscribe;
+    // @ts-expect-error TS7034
+    let isExiting;
+    async function exit(exitCode = 0) {
+        // @ts-expect-error TS7005
+        if (isExiting) {
+            return;
+        }
+        isExiting = true;
+        if (unsubscribe != null) {
+            await unsubscribe();
+        }
+        else if (atlaspack.isProfiling) {
+            await atlaspack.stopProfiling();
+        }
+        if (process.stdin.isTTY && process.stdin.isRaw) {
+            process.stdin.setRawMode(false);
+        }
+        disposable.dispose();
+        process.exit(exitCode);
+    }
+    const isWatching = command.name() === 'watch' || command.name() === 'serve';
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        require('readline').emitKeypressEvents(process.stdin);
+        let stream = process.stdin.on('keypress', async (char, key) => {
+            if (!key.ctrl) {
+                return;
+            }
+            switch (key.name) {
+                case 'c':
+                    // Detect the ctrl+c key, and gracefully exit after writing the asset graph to the cache.
+                    // This is mostly for tools that wrap Atlaspack as a child process like yarn and npm.
+                    //
+                    // Setting raw mode prevents SIGINT from being sent in response to ctrl-c:
+                    // https://nodejs.org/api/tty.html#tty_readstream_setrawmode_mode
+                    //
+                    // We don't use the SIGINT event for this because when run inside yarn, the parent
+                    // yarn process ends before Atlaspack and it appears that Atlaspack has ended while it may still
+                    // be cleaning up. Handling events from stdin prevents this impression.
+                    //
+                    // When watching, a 0 success code is acceptable when Atlaspack is interrupted with ctrl-c.
+                    // When building, fail with a code as if we received a SIGINT.
+                    await exit(isWatching ? 0 : SIGINT_EXIT_CODE);
+                    break;
+                case 'e':
+                    await (atlaspack.isProfiling
+                        ? atlaspack.stopProfiling()
+                        : atlaspack.startProfiling());
+                    break;
+                case 'y':
+                    await atlaspack.takeHeapSnapshot();
+                    break;
+            }
+        });
+        disposable.add(() => {
+            stream.destroy();
+        });
+    }
+    if (isWatching) {
+        // @ts-expect-error TS7006
+        ({ unsubscribe } = await atlaspack.watch((err) => {
+            if (err) {
+                throw err;
+            }
+        }));
+        if (command.open && options.serveOptions) {
+            await (0, utils_1.openInBrowser)(`${options.serveOptions.https ? 'https' : 'http'}://${options.serveOptions.host || 'localhost'}:${options.serveOptions.port}`, command.open);
+        }
+        if (command.watchForStdin) {
+            process.stdin.on('end', async () => {
+                logger_1.INTERNAL_ORIGINAL_CONSOLE.log('STDIN closed, ending');
+                await exit();
+            });
+            process.stdin.resume();
+        }
+        // In non-tty cases, respond to SIGINT by cleaning up. Since we're watching,
+        // a 0 success code is acceptable.
+        process.on('SIGINT', () => exit());
+        process.on('SIGTERM', () => exit());
+    }
+    else {
+        try {
+            await atlaspack.run();
+        }
+        catch (err) {
+            // If an exception is thrown during Atlaspack.build, it is given to reporters in a
+            // buildFailure event, and has been shown to the user.
+            if (!(err instanceof core_1.BuildError)) {
+                await (0, handleUncaughtException_1.logUncaughtError)(err);
+            }
+            await exit(1);
+        }
+        await exit();
+    }
+}

package/dist/handleUncaughtException.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logUncaughtError = logUncaughtError;
+exports.handleUncaughtException = handleUncaughtException;
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const utils_1 = require("@atlaspack/utils");
+const logger_1 = require("@atlaspack/logger");
+const chalk_1 = __importDefault(require("chalk"));
+async function logUncaughtError(e) {
+    if (e instanceof diagnostic_1.default) {
+        for (let diagnostic of e.diagnostics) {
+            let { message, codeframe, stack, hints, documentation } = await (0, utils_1.prettyDiagnostic)(diagnostic);
+            logger_1.INTERNAL_ORIGINAL_CONSOLE.error(chalk_1.default.red(message));
+            if (codeframe || stack) {
+                logger_1.INTERNAL_ORIGINAL_CONSOLE.error('');
+            }
+            logger_1.INTERNAL_ORIGINAL_CONSOLE.error(codeframe);
+            logger_1.INTERNAL_ORIGINAL_CONSOLE.error(stack);
+            if ((stack || codeframe) && hints.length > 0) {
+                logger_1.INTERNAL_ORIGINAL_CONSOLE.error('');
+            }
+            for (let h of hints) {
+                logger_1.INTERNAL_ORIGINAL_CONSOLE.error(chalk_1.default.blue(h));
+            }
+            if (documentation) {
+                logger_1.INTERNAL_ORIGINAL_CONSOLE.error(chalk_1.default.magenta.bold(documentation));
+            }
+        }
+    }
+    else {
+        logger_1.INTERNAL_ORIGINAL_CONSOLE.error(e);
+    }
+    // A hack to definitely ensure we logged the uncaught exception
+    await new Promise((resolve) => setTimeout(resolve, 100));
+}
+async function handleUncaughtException(exception) {
+    try {
+        await logUncaughtError(exception);
+    }
+    catch (err) {
+        console.error(exception);
+        console.error(err);
+    }
+    process.exit(1);
+}

package/dist/makeDebugCommand.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDebugCommand = makeDebugCommand;
+const fs_1 = require("@atlaspack/fs");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+// @ts-expect-error TS2305
+const commander_1 = __importDefault(require("commander"));
+const path_1 = __importDefault(require("path"));
+const normalizeOptions_1 = require("./normalizeOptions");
+const applyOptions_1 = require("./applyOptions");
+const options_1 = require("./options");
+const handleUncaughtException_1 = require("./handleUncaughtException");
+function makeDebugCommand() {
+    const debug = new commander_1.default.Command('debug').description('Debug commands for atlaspack');
+    const getInstance = async (args, opts, command) => {
+        let entries = args;
+        if (entries.length === 0) {
+            entries = ['.'];
+        }
+        entries = entries.map((entry) => path_1.default.resolve(entry));
+        Object.assign(command, opts);
+        const fs = new fs_1.NodeFS();
+        const options = await (0, normalizeOptions_1.normalizeOptions)(command, fs);
+        const Atlaspack = require('@atlaspack/core').default;
+        const atlaspack = new Atlaspack({
+            entries,
+            defaultConfig: require.resolve('@atlaspack/config-default', {
+                paths: [fs.cwd(), __dirname],
+            }),
+            shouldPatchConsole: false,
+            shouldBuildLazily: false,
+            ...options,
+            watchBackend: 'watchman',
+        });
+        logger_1.default.info({
+            message: 'Created atlaspack instance',
+            origin: '@atlaspack/cli',
+        });
+        return atlaspack;
+    };
+    const invalidate = debug
+        .command('invalidate [input...]')
+        .description('Run cache invalidation, then exit')
+        .action(async (args, opts, command) => {
+        try {
+            const atlaspack = await getInstance(args, opts, command);
+            await atlaspack.unstable_invalidate();
+            logger_1.default.info({
+                message: 'Done invalidating cache',
+                origin: '@atlaspack/cli',
+            });
+        }
+        catch (err) {
+            (0, handleUncaughtException_1.handleUncaughtException)(err);
+        }
+    });
+    (0, applyOptions_1.applyOptions)(invalidate, options_1.commonOptions);
+    const buildAssetGraph = debug
+        .command('build-asset-graph [input...]')
+        .description('Build the asset graph then exit')
+        .action(async (args, opts, command) => {
+        try {
+            const atlaspack = await getInstance(args, opts, command);
+            await atlaspack.unstable_buildAssetGraph();
+            logger_1.default.info({
+                message: 'Done building asset graph',
+                origin: '@atlaspack/cli',
+            });
+            process.exit(0);
+        }
+        catch (err) {
+            (0, handleUncaughtException_1.handleUncaughtException)(err);
+        }
+    });
+    (0, applyOptions_1.applyOptions)(buildAssetGraph, options_1.commonOptions);
+    const compactCache = debug
+        .command('compact-cache [input...]')
+        .description('Compact the cache')
+        .action(async (args, opts, command) => {
+        const atlaspack = await getInstance(args, opts, command);
+        try {
+            await atlaspack.unstable_compactCache();
+            logger_1.default.info({
+                message: 'Done compacting cache',
+                origin: '@atlaspack/cli',
+            });
+            process.exit(0);
+        }
+        catch (err) {
+            (0, handleUncaughtException_1.handleUncaughtException)(err);
+        }
+    });
+    (0, applyOptions_1.applyOptions)(compactCache, options_1.commonOptions);
+    return debug;
+}

package/dist/normalizeOptions.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = normalizeOptions;
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const get_port_1 = __importDefault(require("get-port"));
+const logger_1 = require("@atlaspack/logger");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+function parsePort(portValue) {
+    let parsedPort = Number(portValue);
+    // Throw an error if port value is invalid...
+    if (!Number.isInteger(parsedPort)) {
+        throw new Error(`Port ${portValue} is not a valid integer.`);
+    }
+    return parsedPort;
+}
+function shouldUseProductionDefaults(command) {
+    return command.name() === 'build' || command.production === true;
+}
+async function normalizeOptions(command, inputFS) {
+    let nodeEnv;
+    if (shouldUseProductionDefaults(command)) {
+        nodeEnv = process.env.NODE_ENV ?? 'production';
+        // Autoinstall unless explicitly disabled or we detect a CI environment.
+        command.autoinstall = !(command.autoinstall === false || process.env.CI);
+    }
+    else {
+        nodeEnv = process.env.NODE_ENV ?? 'development';
+    }
+    // Set process.env.NODE_ENV to a default if undefined so that it is
+    // available in JS configs and plugins.
+    process.env.NODE_ENV = nodeEnv;
+    let https = !!command.https;
+    if (command.cert != null && command.key != null) {
+        // @ts-expect-error TS2322
+        https = {
+            cert: command.cert,
+            key: command.key,
+        };
+    }
+    let serveOptions = false;
+    let { host } = command;
+    // Ensure port is valid and available
+    let port = parsePort(command.port != null ? String(command.port) : '1234');
+    let originalPort = port;
+    if (!shouldUseProductionDefaults(command) &&
+        (command.name() === 'serve' || Boolean(command.hmr))) {
+        try {
+            port = await (0, get_port_1.default)({ port, host });
+        }
+        catch (err) {
+            throw new diagnostic_1.default({
+                diagnostic: {
+                    message: `Could not get available port: ${err.message}`,
+                    origin: 'atlaspack',
+                    stack: err.stack,
+                },
+            });
+        }
+        if (port !== originalPort) {
+            let errorMessage = `Port "${originalPort}" could not be used`;
+            if (command.port != null) {
+                // Throw the error if the user defined a custom port
+                throw new Error(errorMessage);
+            }
+            else {
+                // Atlaspack logger is not set up at this point, so just use native INTERNAL_ORIGINAL_CONSOLE
+                logger_1.INTERNAL_ORIGINAL_CONSOLE.warn(errorMessage);
+            }
+        }
+    }
+    if (command.name() === 'serve') {
+        let { publicUrl } = command;
+        // @ts-expect-error TS2322
+        serveOptions = {
+            https,
+            port,
+            host,
+            publicUrl,
+        };
+    }
+    let hmrOptions = null;
+    if (!shouldUseProductionDefaults(command) && command.hmr !== false) {
+        let hmrport = command.hmrPort != null ? parsePort(command.hmrPort) : port;
+        let hmrhost = command.hmrHost != null ? String(command.hmrHost) : host;
+        hmrOptions = {
+            port: hmrport,
+            host: hmrhost,
+        };
+    }
+    if (command.detailedReport === true) {
+        command.detailedReport = '10';
+    }
+    let additionalReporters = [
+        { packageName: '@atlaspack/reporter-cli', resolveFrom: __filename },
+        ...command.reporter.map((packageName) => ({
+            packageName,
+            resolveFrom: path_1.default.join(inputFS.cwd(), 'index'),
+        })),
+    ];
+    if (command.trace) {
+        additionalReporters.unshift({
+            packageName: '@atlaspack/reporter-tracer',
+            resolveFrom: __filename,
+        });
+    }
+    let mode = shouldUseProductionDefaults(command)
+        ? 'production'
+        : 'development';
+    const normalizeIncludeExcludeList = (input) => {
+        if (typeof input !== 'string')
+            return [];
+        return input.split(',').map((value) => value.trim());
+    };
+    let nativeProfiler;
+    if (typeof command.profileNative === 'string') {
+        if (command.profileNative === 'instruments' ||
+            command.profileNative === 'samply') {
+            nativeProfiler = command.profileNative;
+        }
+        else {
+            nativeProfiler = undefined;
+        }
+    }
+    else if (command.profileNative) {
+        nativeProfiler = os_1.default.platform() === 'darwin' ? 'instruments' : 'samply';
+    }
+    else {
+        nativeProfiler = undefined;
+    }
+    return {
+        shouldDisableCache: command.cache === false,
+        cacheDir: command.cacheDir,
+        projectRoot: command.projectRoot,
+        watchDir: command.watchDir,
+        watchBackend: command.watchBackend,
+        watchIgnore: command.watchIgnore,
+        config: command.config,
+        mode,
+        hmrOptions,
+        shouldContentHash: hmrOptions ? false : command.contentHash,
+        // @ts-expect-error TS2322
+        serveOptions,
+        targets: command.target.length > 0 ? command.target : null,
+        shouldAutoInstall: command.autoinstall ?? true,
+        logLevel: command.logLevel,
+        shouldProfile: command.profile,
+        nativeProfiler,
+        shouldTrace: command.trace,
+        shouldBuildLazily: typeof command.lazy !== 'undefined',
+        lazyIncludes: normalizeIncludeExcludeList(command.lazy),
+        lazyExcludes: normalizeIncludeExcludeList(command.lazyExclude),
+        shouldBundleIncrementally: process.env.ATLASPACK_INCREMENTAL_BUNDLING === 'false' ? false : true,
+        detailedReport: command.detailedReport != null
+            ? {
+                // @ts-expect-error TS2345
+                assetsPerBundle: parseInt(command.detailedReport, 10),
+            }
+            : null,
+        env: {
+            NODE_ENV: nodeEnv,
+        },
+        additionalReporters,
+        defaultTargetOptions: {
+            shouldOptimize: command.optimize != null ? command.optimize : mode === 'production',
+            sourceMaps: command.sourceMaps ?? true,
+            shouldScopeHoist: command.scopeHoist,
+            publicUrl: command.publicUrl,
+            distDir: command.distDir,
+        },
+        featureFlags: command.featureFlag,
+    };
+}

package/dist/options.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hmrOptions = exports.commonOptions = exports.watcherBackendChoices = void 0;
+const logger_1 = require("@atlaspack/logger");
+const commander_1 = __importDefault(require("commander"));
+const feature_flags_1 = require("@atlaspack/feature-flags");
+// Only display choices available to callers OS
+exports.watcherBackendChoices = ['brute-force'];
+switch (process.platform) {
+    case 'darwin': {
+        exports.watcherBackendChoices.push('watchman', 'fs-events');
+        break;
+    }
+    case 'linux': {
+        exports.watcherBackendChoices.push('watchman', 'inotify');
+        break;
+    }
+    case 'win32': {
+        exports.watcherBackendChoices.push('watchman', 'windows');
+        break;
+    }
+    // @ts-expect-error TS2367
+    case 'freebsd' || 'openbsd': {
+        exports.watcherBackendChoices.push('watchman');
+        break;
+    }
+    default:
+        break;
+}
+// --no-cache, --cache-dir, --no-source-maps, --no-autoinstall, --global?, --public-url, --log-level
+// --no-content-hash, --experimental-scope-hoisting, --detailed-report
+exports.commonOptions = {
+    '--no-cache': 'disable the filesystem cache',
+    '--config <path>': 'specify which config to use. can be a path or a package name',
+    '--cache-dir <path>': 'set the cache directory. defaults to ".parcel-cache"',
+    '--project-root <path>': 'set the project root directory. defaults to nearest directory with lockfiles or version control, falls back to cwd',
+    '--watch-dir <path>': 'set the root watch directory. defaults to nearest lockfile or source control dir.',
+    '--watch-ignore [path]': [
+        `list of directories watcher should not be tracking for changes. defaults to ['.git', '.hg']`,
+        (dirs) => dirs.split(','),
+    ],
+    '--watch-backend': new commander_1.default.Option('--watch-backend <name>', 'set watcher backend').choices(exports.watcherBackendChoices),
+    '--no-source-maps': 'disable sourcemaps',
+    '--target [name]': [
+        'only build given target(s)',
+        (val, list) => list.concat([val]),
+        [],
+    ],
+    '--log-level <level>': new commander_1.default.Option('--log-level <level>', 'set the log level').choices(['none', 'error', 'warn', 'info', 'verbose']),
+    '--dist-dir <dir>': 'output directory to write to when unspecified by targets',
+    '--no-autoinstall': 'disable autoinstall',
+    '--profile': 'enable sampling build profiling',
+    '--profile-native [instruments|samply]': 'enable native build profiling (defaults to instruments on macOS, samply otherwise)',
+    '--trace': 'enable build tracing',
+    '-V, --version': 'output the version number',
+    '--detailed-report [count]': [
+        'print the asset timings and sizes in the build report',
+        parseOptionInt,
+    ],
+    '--reporter <name>': [
+        'additional reporters to run',
+        (val, acc) => {
+            acc.push(val);
+            return acc;
+        },
+        [],
+    ],
+    '--feature-flag <name=value>': [
+        'sets the value of a feature flag',
+        (value, previousValue) => {
+            let [name, val] = value.split('=');
+            if (name in feature_flags_1.DEFAULT_FEATURE_FLAGS) {
+                let featureFlagValue;
+                // @ts-expect-error TS7053
+                if (typeof feature_flags_1.DEFAULT_FEATURE_FLAGS[name] === 'boolean') {
+                    if (val !== 'true' && val !== 'false') {
+                        throw new Error(`Feature flag ${name} must be set to true or false`);
+                    }
+                    featureFlagValue = val === 'true';
+                }
+                previousValue[name] = featureFlagValue ?? String(val);
+            }
+            else {
+                logger_1.INTERNAL_ORIGINAL_CONSOLE.warn(`Unknown feature flag ${name} specified, it will be ignored`);
+            }
+            return previousValue;
+        },
+        {},
+    ],
+};
+exports.hmrOptions = {
+    '--no-hmr': 'disable hot module replacement',
+    '-p, --port <port>': [
+        'set the port to serve on. defaults to $PORT or 1234',
+        process.env.PORT,
+    ],
+    '--host <host>': 'set the host to listen on, defaults to listening on all interfaces',
+    '--https': 'serves files over HTTPS',
+    '--cert <path>': 'path to certificate to use with HTTPS',
+    '--key <path>': 'path to private key to use with HTTPS',
+    '--hmr-port <port>': ['hot module replacement port', process.env.HMR_PORT],
+    '--hmr-host <host>': ['hot module replacement host', process.env.HMR_HOST],
+};
+function parseOptionInt(value) {
+    const parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue)) {
+        throw new commander_1.default.InvalidOptionArgumentError('Must be an integer.');
+    }
+    return parsedValue;
+}