#include "node_options.h" // NOLINT(build/include_inline)

#include "node_options-inl.h"

#include "env-inl.h"

#include "node_binding.h"

#include "node_errors.h"

#include "node_external_reference.h"

#include "node_internals.h"

#include "node_sea.h"

#include "uv.h"

#if HAVE_OPENSSL

#include "openssl/opensslv.h"

#endif

#include <algorithm>

#include <array>

#include <charconv>

#include <cstdint>

#include <limits>

#include <sstream>

#include <string_view>

using v8::Boolean;

using v8::Context;

using v8::FunctionCallbackInfo;

using v8::Integer;

using v8::Isolate;

using v8::Local;

using v8::LocalVector;

using v8::Map;

using v8::Name;

using v8::Null;

using v8::Number;

using v8::Object;

using v8::String;

using v8::Undefined;

using v8::Value;

namespace node {

namespace per_process {

Mutex cli_options_mutex;

std::shared_ptr<PerProcessOptions> cli_options{new PerProcessOptions()};

} // namespace per_process

void DebugOptions::CheckOptions(std::vector<std::string>* errors,

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::string_view_literals::operator""sv;

const std::vector<std::string_view> destinations =

SplitString(inspect_publish_uid_string, ","sv);

inspect_publish_uid.console = false;

inspect_publish_uid.http = false;

for (const std::string_view destination : destinations) {

if (destination == "stderr"sv) {

inspect_publish_uid.console = true;

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

inspect_publish_uid.http = true;

} else {

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

"stderr or http");

}

}

}

void PerProcessOptions::CheckOptions(std::vector<std::string>* errors,

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.

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 // 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);

}

void PerIsolateOptions::HandleMaxOldSpaceSizePercentage(

std::vector<std::string>* errors,

std::string* max_old_space_size_percentage) {

std::string original_input_for_error = *max_old_space_size_percentage;

// Parse the percentage value

char* end_ptr;

double percentage =

std::strtod(max_old_space_size_percentage->c_str(), &end_ptr);

// Validate the percentage value

if (*end_ptr != '\0' || percentage <= 0.0 || percentage > 100.0) {

errors->push_back("--max-old-space-size-percentage must be greater "

"than 0 and up to 100. Got: " +

original_input_for_error);

return;

}

// Get available memory in bytes

uint64_t total_memory = uv_get_total_memory();

uint64_t constrained_memory = uv_get_constrained_memory();

// Use constrained memory if available, otherwise use total memory

// This logic correctly handles the documented guarantees.

// Use uint64_t for the result to prevent data loss on 32-bit systems.

uint64_t available_memory =

(constrained_memory > 0 && constrained_memory != UINT64_MAX)

? constrained_memory

: total_memory;

if (available_memory == 0) {

errors->push_back("the available memory can not be calculated");

return;

}

// Convert to MB and calculate the percentage

uint64_t memory_mb = available_memory / (1024 * 1024);

uint64_t calculated_mb = static_cast<size_t>(memory_mb * percentage / 100.0);

// Convert back to string

max_old_space_size = std::to_string(calculated_mb);

}

void PerIsolateOptions::CheckOptions(std::vector<std::string>* errors,

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

if (!max_old_space_size_percentage.empty()) {

HandleMaxOldSpaceSizePercentage(errors, &max_old_space_size_percentage);

}

per_env->CheckOptions(errors, argv);

}

void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors,

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 (!type.empty()) {

if (type != "commonjs" && type != "module") {

errors->push_back("--experimental-default-type must be "

"\"module\" or \"commonjs\"");

}

}

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 --experimental-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

}

namespace options_parser {

class DebugOptionsParser : public OptionsParser<DebugOptions> {

public:

DebugOptionsParser();

};

class EnvironmentOptionsParser : public OptionsParser<EnvironmentOptions> {

public:

EnvironmentOptionsParser();

explicit EnvironmentOptionsParser(const DebugOptionsParser& dop)

: EnvironmentOptionsParser() {

Insert(dop, &EnvironmentOptions::get_debug_options);

}

};

class PerIsolateOptionsParser : public OptionsParser<PerIsolateOptions> {

public:

PerIsolateOptionsParser() = delete;

explicit PerIsolateOptionsParser(const EnvironmentOptionsParser& eop);

};

class PerProcessOptionsParser : public OptionsParser<PerProcessOptions> {

public:

PerProcessOptionsParser() = delete;

explicit PerProcessOptionsParser(const PerIsolateOptionsParser& iop);

};

#if HAVE_INSPECTOR

const DebugOptionsParser _dop_instance{};

const EnvironmentOptionsParser _eop_instance{_dop_instance};

// This Parse is not dead code. It is used by embedders (e.g., Electron).

template <>

void Parse(

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);

}

#else

const EnvironmentOptionsParser _eop_instance{};

#endif // HAVE_INSPECTOR

const PerIsolateOptionsParser _piop_instance{_eop_instance};

const PerProcessOptionsParser _ppop_instance{_piop_instance};

template <>

void Parse(

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);

}

template <>

void Parse(

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);

}

// XXX: If you add an option here, please also add it to doc/node.1 and

// doc/api/cli.md

// TODO(addaleax): Make that unnecessary.

DebugOptionsParser::DebugOptionsParser() {

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);

}

EnvironmentOptionsParser::EnvironmentOptionsParser() {

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",

"experimental Fetch API",

&EnvironmentOptions::experimental_fetch,

kAllowedInEnvvar,

true);

AddOption("--experimental-websocket",

"experimental WebSocket API",

&EnvironmentOptions::experimental_websocket,

kAllowedInEnvvar,

true);

AddOption("--experimental-sqlite",

"experimental node:sqlite module",

&EnvironmentOptions::experimental_sqlite,

kAllowedInEnvvar,

true);

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-customevent",

"expose experimental CustomEvent on the global scope",

&EnvironmentOptions::experimental_global_customevent,

kAllowedInEnvvar,

true);

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

"expose experimental Navigator API on the global scope",

&EnvironmentOptions::experimental_global_navigator,

kAllowedInEnvvar,

true);

AddOption("--experimental-global-webcrypto",

"expose experimental Web Crypto API on the global scope",

&EnvironmentOptions::experimental_global_web_crypto,

kAllowedInEnvvar,

true);

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", "", NoOp{}, 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);

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

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("--experimental-async-context-frame",

"Improve AsyncLocalStorage performance with AsyncContextFrame",

&EnvironmentOptions::async_context_frame,

kAllowedInEnvvar);

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("--use-env-proxy",

"parse proxy settings from HTTP_PROXY/HTTPS_PROXY/NO_PROXY"

"environment variables and apply the setting in global HTTP/HTTPS "

"clients",

&EnvironmentOptions::use_env_proxy,

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("--experimental-inspector-network-resource",

"experimental load network resources via the inspector",

&EnvironmentOptions::experimental_inspector_network_resource);

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);

AddOption("--test-concurrency",

"specify test runner concurrency",

&EnvironmentOptions::test_runner_concurrency);

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

"force test runner to exit upon completion",

&EnvironmentOptions::test_runner_force_exit);

AddOption("--test-timeout",

"specify test runner timeout",

&EnvironmentOptions::test_runner_timeout);

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

"regenerate test snapshots",

&EnvironmentOptions::test_runner_update_snapshots);

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

"enable code coverage in the test runner",

&EnvironmentOptions::test_runner_coverage);

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

"the branch coverage minimum threshold",

&EnvironmentOptions::test_coverage_branches,

kAllowedInEnvvar);

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

"the function coverage minimum threshold",

&EnvironmentOptions::test_coverage_functions,

kAllowedInEnvvar);

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

"the line coverage minimum threshold",

&EnvironmentOptions::test_coverage_lines,

kAllowedInEnvvar);

AddOption("--experimental-test-isolation",

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

&EnvironmentOptions::test_isolation);

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

"enable module mocking in the test runner",

&EnvironmentOptions::test_runner_module_mocks);

AddOption("--experimental-test-snapshots", "", NoOp{});

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

"run tests whose name matches this regular expression",

&EnvironmentOptions::test_name_pattern,

kAllowedInEnvvar);

AddOption("--test-reporter",

"report test output using the given reporter",

&EnvironmentOptions::test_reporter,

kAllowedInEnvvar);

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

"report given reporter to the given destination",

&EnvironmentOptions::test_reporter_destination,

kAllowedInEnvvar);

AddOption("--test-only",

"run tests with 'only' option set",

&EnvironmentOptions::test_only,

kAllowedInEnvvar);

AddOption("--test-shard",

"run test at specific shard",

&EnvironmentOptions::test_shard,

kAllowedInEnvvar);

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

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

&EnvironmentOptions::test_skip_pattern,

kAllowedInEnvvar);

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

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

&EnvironmentOptions::coverage_include_pattern,

kAllowedInEnvvar);

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

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

&EnvironmentOptions::coverage_exclude_pattern,

kAllowedInEnvvar);

AddOption("--test-udp-no-try-send", "", // For testing only.

&EnvironmentOptions::test_udp_no_try_send);

AddOption("--throw-deprecation",

"throw an exception on deprecations",

&EnvironmentOptions::throw_deprecation,

kAllowedInEnvvar);

AddOption("--trace-atomics-wait",

"(deprecated) trace Atomics.wait() operations",

&EnvironmentOptions::trace_atomics_wait,

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("--experimental-default-type",

"set module system to use by default",

&EnvironmentOptions::type,

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-kill-signal",

"kill signal to send to the process on watch mode restarts"

"(default: SIGTERM)",

&EnvironmentOptions::watch_mode_kill_signal,

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,

HAVE_AMARO);

Implies("--experimental-strip-types", "--experimental-detect-module");

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");

Implies("--experimental-transform-types", "--enable-source-maps");

AddOption("--interactive",

"always enter the REPL even if stdin does not appear "

"to be a terminal",

&EnvironmentOptions::force_repl);

AddAlias("-i", "--interactive");

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

AddOption("--tls-keylog",

"log TLS decryption keys to named file for traffic analysis",

&EnvironmentOptions::tls_keylog,

kAllowedInEnvvar);

AddOption("--tls-min-v1.0",

"set default TLS minimum to TLSv1.0 (default: TLSv1.2)",

&EnvironmentOptions::tls_min_v1_0,

kAllowedInEnvvar);

AddOption("--tls-min-v1.1",

"set default TLS minimum to TLSv1.1 (default: TLSv1.2)",

&EnvironmentOptions::tls_min_v1_1,

kAllowedInEnvvar);

AddOption("--tls-min-v1.2",

"set default TLS minimum to TLSv1.2 (default: TLSv1.2)",

&EnvironmentOptions::tls_min_v1_2,

kAllowedInEnvvar);

AddOption("--tls-min-v1.3",

"set default TLS minimum to TLSv1.3 (default: TLSv1.2)",

&EnvironmentOptions::tls_min_v1_3,

kAllowedInEnvvar);