std::vector<std::string>* argv) {

#if !NODE_USE_V8_PLATFORM && !HAVE_INSPECTOR

if (inspector_enabled) {

errors->push_back("Inspector is not available when Node is compiled "

"--without-v8-platform and --without-inspector.");

}

#endif

if (deprecated_debug) {

errors->push_back("[DEP0062]: `node --debug` and `node --debug-brk` "

"are invalid. Please use `node --inspect` and "

"`node --inspect-brk` instead.");

}

using std::operator""sv;

auto entries = std::views::split(inspect_publish_uid_string, ","sv);

inspect_publish_uid.console = false;

inspect_publish_uid.http = false;

for (const auto& entry : entries) {

std::string_view destination(entry.data(), entry.size());

if (destination == "stderr"sv) {

inspect_publish_uid.console = true;

} else if (destination == "http"sv) {

inspect_publish_uid.http = true;

} else {

errors->emplace_back("--inspect-publish-uid destination can be "

"stderr or http");

}

}

std::vector<std::string>* argv) {

#if HAVE_OPENSSL

if (use_openssl_ca && use_bundled_ca) {

errors->push_back("either --use-openssl-ca or --use-bundled-ca can be "

"used, not both");

}

// Any value less than 2 disables use of the secure heap.

#ifndef V8_ENABLE_SANDBOX

// The secure heap is not supported when V8_ENABLE_SANDBOX is enabled.

if (secure_heap >= 2) {

if ((secure_heap & (secure_heap - 1)) != 0)

errors->push_back("--secure-heap must be a power of 2");

secure_heap_min =

std::min({

secure_heap,

secure_heap_min,

static_cast<int64_t>(std::numeric_limits<int>::max())});

secure_heap_min = std::max(static_cast<int64_t>(2), secure_heap_min);

if ((secure_heap_min & (secure_heap_min - 1)) != 0)

errors->push_back("--secure-heap-min must be a power of 2");

}

#endif // V8_ENABLE_SANDBOX

#endif // HAVE_OPENSSL

if (use_largepages != "off" &&

use_largepages != "on" &&

use_largepages != "silent") {

errors->push_back("invalid value for --use-largepages");

}

per_isolate->CheckOptions(errors, argv);

std::vector<std::string>* argv) {

if (!input_type.empty()) {

if (input_type != "commonjs" && input_type != "module" &&

input_type != "commonjs-typescript" &&

input_type != "module-typescript") {

errors->push_back(

"--input-type must be \"module\","

"\"commonjs\", \"module-typescript\" or \"commonjs-typescript\"");

}

}

if (syntax_check_only && has_eval_string) {

errors->push_back("either --check or --eval can be used, not both");

}

if (!unhandled_rejections.empty() &&

unhandled_rejections != "warn-with-error-code" &&

unhandled_rejections != "throw" &&

unhandled_rejections != "strict" &&

unhandled_rejections != "warn" &&

unhandled_rejections != "none") {

errors->push_back("invalid value for --unhandled-rejections");

}

if (tls_min_v1_3 && tls_max_v1_2) {

errors->push_back("either --tls-min-v1.3 or --tls-max-v1.2 can be "

"used, not both");

}

if (heap_snapshot_near_heap_limit < 0) {

errors->push_back("--heapsnapshot-near-heap-limit must not be negative");

}

if (!trace_require_module.empty() && trace_require_module != "all" &&

trace_require_module != "no-node-modules") {

errors->push_back("invalid value for --trace-require-module");

}

if (test_runner) {

if (test_isolation == "none") {

debug_options_.allow_attaching_debugger = true;

} else {

if (test_isolation != "process") {

errors->push_back("invalid value for --test-isolation");

}

#ifndef ALLOW_ATTACHING_DEBUGGER_IN_TEST_RUNNER

debug_options_.allow_attaching_debugger = false;

#endif

}

if (syntax_check_only) {

errors->push_back("either --test or --check can be used, not both");

}

if (has_eval_string) {

errors->push_back("either --test or --eval can be used, not both");

}

if (force_repl) {

errors->push_back("either --test or --interactive can be used, not both");

}

if (watch_mode_paths.size() > 0) {

errors->push_back(

"--watch-path cannot be used in combination with --test");

}

}

if (watch_mode) {

if (syntax_check_only) {

errors->push_back("either --watch or --check can be used, not both");

} else if (has_eval_string) {

errors->push_back("either --watch or --eval can be used, not both");

} else if (force_repl) {

errors->push_back("either --watch or --interactive "

"can be used, not both");

} else if (test_runner_force_exit) {

errors->push_back("either --watch or --test-force-exit "

"can be used, not both");

} else if (!test_runner && (argv->size() < 1 || (*argv)[1].empty())) {

errors->push_back("--watch requires specifying a file");

}

#ifndef ALLOW_ATTACHING_DEBUGGER_IN_WATCH_MODE

debug_options_.allow_attaching_debugger = false;

#endif

}

#if HAVE_INSPECTOR

if (!cpu_prof) {

if (!cpu_prof_name.empty()) {

errors->push_back("--cpu-prof-name must be used with --cpu-prof");

}

if (!cpu_prof_dir.empty()) {

errors->push_back("--cpu-prof-dir must be used with --cpu-prof");

}

// We can't catch the case where the value passed is the default value,

// then the option just becomes a noop which is fine.

if (cpu_prof_interval != kDefaultCpuProfInterval) {

errors->push_back("--cpu-prof-interval must be used with --cpu-prof");

}

}

if (cpu_prof && cpu_prof_dir.empty() && !diagnostic_dir.empty()) {

cpu_prof_dir = diagnostic_dir;

}

if (!heap_prof) {

if (!heap_prof_name.empty()) {

errors->push_back("--heap-prof-name must be used with --heap-prof");

}

if (!heap_prof_dir.empty()) {

errors->push_back("--heap-prof-dir must be used with --heap-prof");

}

// We can't catch the case where the value passed is the default value,

// then the option just becomes a noop which is fine.

if (heap_prof_interval != kDefaultHeapProfInterval) {

errors->push_back("--heap-prof-interval must be used with --heap-prof");

}

}

if (heap_prof && heap_prof_dir.empty() && !diagnostic_dir.empty()) {

heap_prof_dir = diagnostic_dir;

}

debug_options_.CheckOptions(errors, argv);

#endif // HAVE_INSPECTOR

Local<Context> context,

Local<Map> map,

const std::string& option_name,

const OptionType& option_type) {

std::string type;

switch (static_cast<int>(option_type)) {

case 0: // No-op

case 1: // V8 flags

break; // V8 and NoOp flags are not supported

case 2:

type = "boolean";

break;

case 3: // integer

case 4: // unsigned integer

case 6: // host port

type = "number";

break;

case 5: // string

type = "string";

break;

case 7: // string array

type = "array";

break;

default:

UNREACHABLE();

}

if (type.empty()) {

return true; // Skip this entry but continue processing

}

Local<String> option_key;

if (!String::NewFromUtf8(isolate,

option_name.data(),

v8::NewStringType::kNormal,

option_name.size())

.ToLocal(&option_key)) {

return true; // Skip this entry but continue processing

}

Local<String> type_value;

if (!String::NewFromUtf8(

isolate, type.data(), v8::NewStringType::kNormal, type.size())

.ToLocal(&type_value)) {

return true; // Skip this entry but continue processing

}

if (map->Set(context, option_key, type_value).IsEmpty()) {

return false; // Error occurred, stop processing

}

return true;

public:

EnvironmentOptionsParser();

explicit EnvironmentOptionsParser(const DebugOptionsParser& dop)

: EnvironmentOptionsParser() {

Insert(dop, &EnvironmentOptions::get_debug_options);

}

public:

PerIsolateOptionsParser() = delete;

explicit PerIsolateOptionsParser(const EnvironmentOptionsParser& eop);

public:

PerProcessOptionsParser() = delete;

explicit PerProcessOptionsParser(const PerIsolateOptionsParser& iop);

StringVector* const args, StringVector* const exec_args,

StringVector* const v8_args,

DebugOptions* const options,

OptionEnvvarSettings required_env_settings, StringVector* const errors) {

_dop_instance.Parse(

args, exec_args, v8_args, options, required_env_settings, errors);

StringVector* const args, StringVector* const exec_args,

StringVector* const v8_args,

PerIsolateOptions* const options,

OptionEnvvarSettings required_env_settings, StringVector* const errors) {

_piop_instance.Parse(

args, exec_args, v8_args, options, required_env_settings, errors);

StringVector* const args, StringVector* const exec_args,

StringVector* const v8_args,

PerProcessOptions* const options,

OptionEnvvarSettings required_env_settings, StringVector* const errors) {

_ppop_instance.Parse(

args, exec_args, v8_args, options, required_env_settings, errors);

#ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION

if (sea::IsSingleExecutable()) return;

#endif

AddOption("--inspect-port",

"set host:port for inspector",

&DebugOptions::host_port,

kAllowedInEnvvar);

AddAlias("--debug-port", "--inspect-port");

AddOption("--inspect",

"activate inspector on host:port (default: 127.0.0.1:9229)",

&DebugOptions::inspector_enabled,

kAllowedInEnvvar);

AddAlias("--inspect=", { "--inspect-port", "--inspect" });

AddOption("--debug", "", &DebugOptions::deprecated_debug);

AddAlias("--debug=", "--debug");

AddOption("--debug-brk", "", &DebugOptions::deprecated_debug);

AddAlias("--debug-brk=", "--debug-brk");

AddOption("--inspect-brk",

"activate inspector on host:port and break at start of user script",

&DebugOptions::break_first_line,

kAllowedInEnvvar);

Implies("--inspect-brk", "--inspect");

AddAlias("--inspect-brk=", { "--inspect-port", "--inspect-brk" });

AddOption("--inspect-brk-node", "", &DebugOptions::break_node_first_line);

Implies("--inspect-brk-node", "--inspect");

AddAlias("--inspect-brk-node=", { "--inspect-port", "--inspect-brk-node" });

AddOption(

"--inspect-wait",

"activate inspector on host:port and wait for debugger to be attached",

&DebugOptions::inspect_wait,

kAllowedInEnvvar);

Implies("--inspect-wait", "--inspect");

AddAlias("--inspect-wait=", {"--inspect-port", "--inspect-wait"});

AddOption("--inspect-publish-uid",

"comma separated list of destinations for inspector uid"

"(default: stderr,http)",

&DebugOptions::inspect_publish_uid_string,

kAllowedInEnvvar);

AddOption("--conditions",

"additional user conditions for conditional exports and imports",

&EnvironmentOptions::conditions,

kAllowedInEnvvar);

AddAlias("-C", "--conditions");

AddOption("--experimental-detect-module",

"when ambiguous modules fail to evaluate because they contain "

"ES module syntax, try again to evaluate them as ES modules",

&EnvironmentOptions::detect_module,

kAllowedInEnvvar,

true);

AddOption("--experimental-print-required-tla",

"Print pending top-level await. If --experimental-require-module "

"is true, evaluate asynchronous graphs loaded by `require()` but "

"do not run the microtasks, in order to to find and print "

"top-level await in the graph",

&EnvironmentOptions::print_required_tla,

kAllowedInEnvvar);

AddOption("--experimental-require-module",

"Allow loading synchronous ES Modules in require().",

&EnvironmentOptions::require_module,

kAllowedInEnvvar,

true);

AddOption("--diagnostic-dir",

"set dir for all output files"

" (default: current working directory)",

&EnvironmentOptions::diagnostic_dir,

kAllowedInEnvvar);

AddOption("--disable-sigusr1",

"Disable inspector thread to be listening for SIGUSR1 signal",

&EnvironmentOptions::disable_sigusr1,

kAllowedInEnvvar,

false);

AddOption("--dns-result-order",

"set default value of verbatim in dns.lookup. Options are "

"'ipv4first' (IPv4 addresses are placed before IPv6 addresses) "

"'ipv6first' (IPv6 addresses are placed before IPv4 addresses) "

"'verbatim' (addresses are in the order the DNS resolver "

"returned)",

&EnvironmentOptions::dns_result_order,

kAllowedInEnvvar);

AddOption("--network-family-autoselection",

"Disable network address family autodetection algorithm",

&EnvironmentOptions::network_family_autoselection,

kAllowedInEnvvar,

true);

AddOption("--network-family-autoselection-attempt-timeout",

"Sets the default value for the network family autoselection "

"attempt timeout.",

&EnvironmentOptions::network_family_autoselection_attempt_timeout,

kAllowedInEnvvar);

AddAlias("--enable-network-family-autoselection",

"--network-family-autoselection");

AddOption("--enable-source-maps",

"Source Map V3 support for stack traces",

&EnvironmentOptions::enable_source_maps,

kAllowedInEnvvar);

AddOption("--entry-url",

"Treat the entrypoint as a URL",

&EnvironmentOptions::entry_is_url,

kAllowedInEnvvar);

AddOption("--experimental-addon-modules",

"experimental import support for addons",

&EnvironmentOptions::experimental_addon_modules,

kAllowedInEnvvar);

AddOption("--experimental-abortcontroller", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-eventsource",

"experimental EventSource API",

&EnvironmentOptions::experimental_eventsource,

kAllowedInEnvvar,

false);

AddOption("--experimental-fetch", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-websocket",

"experimental WebSocket API",

&EnvironmentOptions::experimental_websocket,

kAllowedInEnvvar,

true);

AddOption("--experimental-global-customevent", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-sqlite",

"experimental node:sqlite module",

&EnvironmentOptions::experimental_sqlite,

kAllowedInEnvvar,

true);

AddOption("--experimental-quic",

"" /* undocumented until its development */,

#ifdef NODE_OPENSSL_HAS_QUIC

&EnvironmentOptions::experimental_quic,

#else

// Option is a no-op if the NODE_OPENSSL_HAS_QUIC

// compile flag is not enabled

NoOp{},

#endif

kAllowedInEnvvar);

AddOption("--experimental-webstorage",

"experimental Web Storage API",

&EnvironmentOptions::experimental_webstorage,

kAllowedInEnvvar);

AddOption("--localstorage-file",

"file used to persist localStorage data",

&EnvironmentOptions::localstorage_file,

kAllowedInEnvvar);

AddOption("--experimental-global-navigator",

"expose experimental Navigator API on the global scope",

&EnvironmentOptions::experimental_global_navigator,

kAllowedInEnvvar,

true);

AddOption("--experimental-global-webcrypto", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-json-modules", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-loader",

"use the specified module as a custom loader",

&EnvironmentOptions::userland_loaders,

kAllowedInEnvvar);

AddAlias("--loader", "--experimental-loader");

AddOption("--experimental-modules", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-wasm-modules",

"experimental ES Module support for webassembly modules",

&EnvironmentOptions::experimental_wasm_modules,

kAllowedInEnvvar);

AddOption("--experimental-import-meta-resolve",

"experimental ES Module import.meta.resolve() parentURL support",

&EnvironmentOptions::experimental_import_meta_resolve,

kAllowedInEnvvar);

AddOption("--permission",

"enable the permission system",

&EnvironmentOptions::permission,

kAllowedInEnvvar,

false);

AddOption("--allow-fs-read",

"allow permissions to read the filesystem",

&EnvironmentOptions::allow_fs_read,

kAllowedInEnvvar);

AddOption("--allow-fs-write",

"allow permissions to write in the filesystem",

&EnvironmentOptions::allow_fs_write,

kAllowedInEnvvar);

AddOption("--allow-addons",

"allow use of addons when any permissions are set",

&EnvironmentOptions::allow_addons,

kAllowedInEnvvar);

AddOption("--allow-child-process",

"allow use of child process when any permissions are set",

&EnvironmentOptions::allow_child_process,

kAllowedInEnvvar);

AddOption("--allow-wasi",

"allow wasi when any permissions are set",

&EnvironmentOptions::allow_wasi,

kAllowedInEnvvar);

AddOption("--allow-worker",

"allow worker threads when any permissions are set",

&EnvironmentOptions::allow_worker_threads,

kAllowedInEnvvar);

AddOption("--experimental-repl-await",

"experimental await keyword support in REPL",

&EnvironmentOptions::experimental_repl_await,

kAllowedInEnvvar,

true);

AddOption("--experimental-vm-modules",

"experimental ES Module support in vm module",

&EnvironmentOptions::experimental_vm_modules,

kAllowedInEnvvar);

AddOption("--experimental-worker", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-report", "", NoOp{}, kAllowedInEnvvar);

AddOption(

"--experimental-wasi-unstable-preview1", "", NoOp{}, kAllowedInEnvvar);

AddOption("--expose-gc", "expose gc extension", V8Option{}, kAllowedInEnvvar);

AddOption("--async-context-frame",

"Improve AsyncLocalStorage performance with AsyncContextFrame",

&EnvironmentOptions::async_context_frame,

kAllowedInEnvvar,

true);

AddOption("--expose-internals", "", &EnvironmentOptions::expose_internals);

AddOption("--frozen-intrinsics",

"experimental frozen intrinsics support",

&EnvironmentOptions::frozen_intrinsics,

kAllowedInEnvvar);

AddOption("--heapsnapshot-signal",

"Generate heap snapshot on specified signal",

&EnvironmentOptions::heap_snapshot_signal,

kAllowedInEnvvar);

AddOption("--heapsnapshot-near-heap-limit",

"Generate heap snapshots whenever V8 is approaching "

"the heap limit. No more than the specified number of "

"heap snapshots will be generated.",

&EnvironmentOptions::heap_snapshot_near_heap_limit,

kAllowedInEnvvar);

AddOption("--http-parser", "", NoOp{}, kAllowedInEnvvar);

AddOption("--insecure-http-parser",

"use an insecure HTTP parser that accepts invalid HTTP headers",

&EnvironmentOptions::insecure_http_parser,

kAllowedInEnvvar);

AddOption("--input-type",

"set module type for string input",

&EnvironmentOptions::input_type,

kAllowedInEnvvar);

AddOption(

"--experimental-specifier-resolution", "", NoOp{}, kAllowedInEnvvar);

AddAlias("--es-module-specifier-resolution",

"--experimental-specifier-resolution");

AddOption("--deprecation",

"silence deprecation warnings",

&EnvironmentOptions::deprecation,

kAllowedInEnvvar,

true);

AddOption("--force-async-hooks-checks",

"disable checks for async_hooks",

&EnvironmentOptions::force_async_hooks_checks,

kAllowedInEnvvar,

true);

AddOption(

"--force-node-api-uncaught-exceptions-policy",

"enforces 'uncaughtException' event on Node API asynchronous callbacks",

&EnvironmentOptions::force_node_api_uncaught_exceptions_policy,

kAllowedInEnvvar,

false);

AddOption("--addons",

"disable loading native addons",

&EnvironmentOptions::allow_native_addons,

kAllowedInEnvvar,

true);

AddOption("--global-search-paths",

"disable global module search paths",

&EnvironmentOptions::global_search_paths,

kAllowedInEnvvar,

true);

AddOption("--warnings",

"silence all process warnings",

&EnvironmentOptions::warnings,

kAllowedInEnvvar,

true);

AddOption("--disable-warning",

"silence specific process warnings",

&EnvironmentOptions::disable_warnings,

kAllowedInEnvvar);

AddOption("--force-context-aware",

"disable loading non-context-aware addons",

&EnvironmentOptions::force_context_aware,

kAllowedInEnvvar);

AddOption("--pending-deprecation",

"emit pending deprecation warnings",

&EnvironmentOptions::pending_deprecation,

kAllowedInEnvvar);

AddOption("--preserve-symlinks",

"preserve symbolic links when resolving",

&EnvironmentOptions::preserve_symlinks,

kAllowedInEnvvar);

AddOption("--preserve-symlinks-main",

"preserve symbolic links when resolving the main module",

&EnvironmentOptions::preserve_symlinks_main,

kAllowedInEnvvar);

AddOption("--prof",

"Generate V8 profiler output.",

V8Option{});

AddOption("--prof-process",

"process V8 profiler output generated using --prof",

&EnvironmentOptions::prof_process);

// Options after --prof-process are passed through to the prof processor.

AddAlias("--prof-process", {"--prof-process", "--"});

#if HAVE_INSPECTOR

AddOption("--cpu-prof",

"Start the V8 CPU profiler on start up, and write the CPU profile "

"to disk before exit. If --cpu-prof-dir is not specified, write "

"the profile to the current working directory.",

&EnvironmentOptions::cpu_prof,

kAllowedInEnvvar);

AddOption("--cpu-prof-name",

"specified file name of the V8 CPU profile generated with "

"--cpu-prof",

&EnvironmentOptions::cpu_prof_name,

kAllowedInEnvvar);

AddOption("--cpu-prof-interval",

"specified sampling interval in microseconds for the V8 CPU "

"profile generated with --cpu-prof. (default: 1000)",

&EnvironmentOptions::cpu_prof_interval,

kAllowedInEnvvar);

AddOption("--cpu-prof-dir",

"Directory where the V8 profiles generated by --cpu-prof will be "

"placed. Does not affect --prof.",

&EnvironmentOptions::cpu_prof_dir,

kAllowedInEnvvar);

AddOption("--experimental-network-inspection",

"experimental network inspection support",

&EnvironmentOptions::experimental_network_inspection);

AddOption("--experimental-worker-inspection",

"experimental worker inspection support",

&EnvironmentOptions::experimental_worker_inspection);

AddOption(

"--heap-prof",

"Start the V8 heap profiler on start up, and write the heap profile "

"to disk before exit. If --heap-prof-dir is not specified, write "

"the profile to the current working directory.",

&EnvironmentOptions::heap_prof,

kAllowedInEnvvar);

AddOption("--heap-prof-name",

"specified file name of the V8 heap profile generated with "

"--heap-prof",

&EnvironmentOptions::heap_prof_name,

kAllowedInEnvvar);

AddOption("--heap-prof-dir",

"Directory where the V8 heap profiles generated by --heap-prof "

"will be placed.",

&EnvironmentOptions::heap_prof_dir,

kAllowedInEnvvar);

AddOption("--heap-prof-interval",

"specified sampling interval in bytes for the V8 heap "

"profile generated with --heap-prof. (default: 512 * 1024)",

&EnvironmentOptions::heap_prof_interval,

kAllowedInEnvvar);

#endif // HAVE_INSPECTOR

AddOption("--max-http-header-size",

"set the maximum size of HTTP headers (default: 16384 (16KB))",

&EnvironmentOptions::max_http_header_size,

kAllowedInEnvvar);

AddOption("--redirect-warnings",

"write warnings to file instead of stderr",

&EnvironmentOptions::redirect_warnings,

kAllowedInEnvvar);

AddOption(

"[has_env_file_string]", "", &EnvironmentOptions::has_env_file_string);

AddOption("--env-file",

"set environment variables from supplied file",

&EnvironmentOptions::env_file);

Implies("--env-file", "[has_env_file_string]");

AddOption("--env-file-if-exists",

"set environment variables from supplied file",

&EnvironmentOptions::optional_env_file);

Implies("--env-file-if-exists", "[has_env_file_string]");

AddOption("--experimental-config-file",

"set config file from supplied file",

&EnvironmentOptions::experimental_config_file_path);

AddOption("--experimental-default-config-file",

"set config file from default config file",

&EnvironmentOptions::experimental_default_config_file);

AddOption("--test",

"launch test runner on startup",

&EnvironmentOptions::test_runner,

kDisallowedInEnvvar);

AddOption("--test-concurrency",

"specify test runner concurrency",

&EnvironmentOptions::test_runner_concurrency,

kDisallowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-force-exit",

"force test runner to exit upon completion",

&EnvironmentOptions::test_runner_force_exit,

kDisallowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-timeout",

"specify test runner timeout",

&EnvironmentOptions::test_runner_timeout,

kDisallowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-update-snapshots",

"regenerate test snapshots",

&EnvironmentOptions::test_runner_update_snapshots,

kDisallowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--experimental-test-coverage",

"enable code coverage in the test runner",

&EnvironmentOptions::test_runner_coverage,

kDisallowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-coverage-branches",

"the branch coverage minimum threshold",

&EnvironmentOptions::test_coverage_branches,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-coverage-functions",

"the function coverage minimum threshold",

&EnvironmentOptions::test_coverage_functions,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-coverage-lines",

"the line coverage minimum threshold",

&EnvironmentOptions::test_coverage_lines,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-isolation",

"configures the type of test isolation used in the test runner",

&EnvironmentOptions::test_isolation,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

// TODO(cjihrig): Remove this alias in a semver major.

AddAlias("--experimental-test-isolation", "--test-isolation");

AddOption("--experimental-test-module-mocks",

"enable module mocking in the test runner",

&EnvironmentOptions::test_runner_module_mocks,

kDisallowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--experimental-test-snapshots",

"",

NoOp{},

kDisallowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-name-pattern",

"run tests whose name matches this regular expression",

&EnvironmentOptions::test_name_pattern,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-reporter",

"report test output using the given reporter",

&EnvironmentOptions::test_reporter,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-reporter-destination",

"report given reporter to the given destination",

&EnvironmentOptions::test_reporter_destination,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-only",

"run tests with 'only' option set",

&EnvironmentOptions::test_only,

kAllowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-shard",

"run test at specific shard",

&EnvironmentOptions::test_shard,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-skip-pattern",

"run tests whose name do not match this regular expression",

&EnvironmentOptions::test_skip_pattern,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-coverage-include",

"include files in coverage report that match this glob pattern",

&EnvironmentOptions::coverage_include_pattern,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-coverage-exclude",

"exclude files from coverage report that match this glob pattern",

&EnvironmentOptions::coverage_exclude_pattern,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-global-setup",

"specifies the path to the global setup file",

&EnvironmentOptions::test_global_setup_path,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-udp-no-try-send",

"", // For testing only.

&EnvironmentOptions::test_udp_no_try_send,

kDisallowedInEnvvar);

AddOption("--throw-deprecation",

"throw an exception on deprecations",

&EnvironmentOptions::throw_deprecation,

kAllowedInEnvvar);

AddOption("--trace-deprecation",

"show stack traces on deprecations",

&EnvironmentOptions::trace_deprecation,

kAllowedInEnvvar);

AddOption("--trace-exit",

"show stack trace when an environment exits",

&EnvironmentOptions::trace_exit,

kAllowedInEnvvar);

AddOption("--trace-sync-io",

"show stack trace when use of sync IO is detected after the "

"first tick",

&EnvironmentOptions::trace_sync_io,

kAllowedInEnvvar);

AddOption("--trace-tls",

"prints TLS packet trace information to stderr",

&EnvironmentOptions::trace_tls,

kAllowedInEnvvar);

AddOption("--trace-uncaught",

"show stack traces for the `throw` behind uncaught exceptions",

&EnvironmentOptions::trace_uncaught,

kAllowedInEnvvar);

AddOption("--trace-warnings",

"show stack traces on process warnings",

&EnvironmentOptions::trace_warnings,

kAllowedInEnvvar);

AddOption("--trace-promises",

"show stack traces on promise initialization and resolution",

&EnvironmentOptions::trace_promises,

kAllowedInEnvvar);

AddOption("--trace-env",

"Print accesses to the environment variables",

&EnvironmentOptions::trace_env,

kAllowedInEnvvar);

Implies("--trace-env-js-stack", "--trace-env");

Implies("--trace-env-native-stack", "--trace-env");

AddOption("--trace-env-js-stack",

"Print accesses to the environment variables and the JavaScript "

"stack trace",

&EnvironmentOptions::trace_env_js_stack,

kAllowedInEnvvar);

AddOption(

"--trace-env-native-stack",

"Print accesses to the environment variables and the native stack trace",

&EnvironmentOptions::trace_env_native_stack,

kAllowedInEnvvar);

AddOption(

"--trace-require-module",

"Print access to require(esm). Options are 'all' (print all usage) and "

"'no-node-modules' (excluding usage from the node_modules folder)",

&EnvironmentOptions::trace_require_module,

kAllowedInEnvvar);

AddOption("--extra-info-on-fatal-exception",

"hide extra information on fatal exception that causes exit",

&EnvironmentOptions::extra_info_on_fatal_exception,

kAllowedInEnvvar,

true);

AddOption("--unhandled-rejections",

"define unhandled rejections behavior. Options are 'strict' "

"(always raise an error), 'throw' (raise an error unless "

"'unhandledRejection' hook is set), 'warn' (log a warning), 'none' "

"(silence warnings), 'warn-with-error-code' (log a warning and set "

"exit code 1 unless 'unhandledRejection' hook is set). (default: "

"throw)",

&EnvironmentOptions::unhandled_rejections,

kAllowedInEnvvar);

AddOption("--verify-base-objects",

"", /* undocumented, only for debugging */

&EnvironmentOptions::verify_base_objects,

kAllowedInEnvvar);

AddOption("--watch",

"run in watch mode",

&EnvironmentOptions::watch_mode,

kAllowedInEnvvar);

AddOption("--watch-path",

"path to watch",

&EnvironmentOptions::watch_mode_paths,

kAllowedInEnvvar);

AddOption("--watch-preserve-output",

"preserve outputs on watch mode restart",

&EnvironmentOptions::watch_mode_preserve_output,

kAllowedInEnvvar);

Implies("--watch-path", "--watch");

AddOption("--check",

"syntax check script without executing",

&EnvironmentOptions::syntax_check_only);

AddAlias("-c", "--check");

// This option is only so that we can tell --eval with an empty string from

// no eval at all. Having it not start with a dash makes it inaccessible

// from the parser itself, but available for using Implies().

// TODO(addaleax): When moving --help over to something generated from the

// programmatic descriptions, this will need some special care.

// (See also [ssl_openssl_cert_store] below.)

AddOption("[has_eval_string]", "", &EnvironmentOptions::has_eval_string);

AddOption("--eval", "evaluate script", &EnvironmentOptions::eval_string);

Implies("--eval", "[has_eval_string]");

AddOption("--print",

"evaluate script and print result",

&EnvironmentOptions::print_eval);

AddAlias("-e", "--eval");

AddAlias("--print <arg>", "-pe");

AddAlias("-pe", { "--print", "--eval" });

AddAlias("-p", "--print");

AddOption("--require",

"CommonJS module to preload (option can be repeated)",

&EnvironmentOptions::preload_cjs_modules,

kAllowedInEnvvar);

AddAlias("-r", "--require");

AddOption("--import",

"ES module to preload (option can be repeated)",

&EnvironmentOptions::preload_esm_modules,

kAllowedInEnvvar);

AddOption("--experimental-strip-types",

"Experimental type-stripping for TypeScript files.",

&EnvironmentOptions::experimental_strip_types,

kAllowedInEnvvar,

true);

AddOption("--experimental-transform-types",

"enable transformation of TypeScript-only"

"syntax into JavaScript code",

&EnvironmentOptions::experimental_transform_types,

kAllowedInEnvvar);

Implies("--experimental-transform-types", "--experimental-strip-types");