@encharm/cws 4.1.0 → 4.2.0

package/src/headers/12/node_options.h

@@ -1,479 +0,0 @@
-#ifndef SRC_NODE_OPTIONS_H_
-#define SRC_NODE_OPTIONS_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-#include "node_constants.h"
-#include "node_mutex.h"
-#include "util.h"
-
-namespace node {
-
-class HostPort {
- public:
-  HostPort(const std::string& host_name, int port)
-      : host_name_(host_name), port_(port) {}
-  HostPort(const HostPort&) = default;
-  HostPort& operator=(const HostPort&) = default;
-  HostPort(HostPort&&) = default;
-  HostPort& operator=(HostPort&&) = default;
-
-  void set_host(const std::string& host) { host_name_ = host; }
-
-  void set_port(int port) { port_ = port; }
-
-  const std::string& host() const { return host_name_; }
-
-  int port() const {
-    // TODO(joyeecheung): make port a uint16_t
-    CHECK_GE(port_, 0);
-    return port_;
-  }
-
-  void Update(const HostPort& other) {
-    if (!other.host_name_.empty()) host_name_ = other.host_name_;
-    if (other.port_ >= 0) port_ = other.port_;
-  }
-
- private:
-  std::string host_name_;
-  int port_;
-};
-
-class Options {
- public:
-  virtual void CheckOptions(std::vector<std::string>* errors) {}
-  virtual ~Options() = default;
-};
-
-struct InspectPublishUid {
-  bool console;
-  bool http;
-};
-
-// These options are currently essentially per-Environment, but it can be nice
-// to keep them separate since they are a group of options applying to a very
-// specific part of Node. It might also make more sense for them to be
-// per-Isolate, rather than per-Environment.
-class DebugOptions : public Options {
- public:
-  DebugOptions() = default;
-  DebugOptions(const DebugOptions&) = default;
-  DebugOptions& operator=(const DebugOptions&) = default;
-  DebugOptions(DebugOptions&&) = default;
-  DebugOptions& operator=(DebugOptions&&) = default;
-
-  // --inspect
-  bool inspector_enabled = false;
-  // --debug
-  bool deprecated_debug = false;
-  // --inspect-brk
-  bool break_first_line = false;
-  // --inspect-brk-node
-  bool break_node_first_line = false;
-  // --inspect-publish-uid
-  std::string inspect_publish_uid_string = "stderr,http";
-
-  InspectPublishUid inspect_publish_uid;
-
-  enum { kDefaultInspectorPort = 9229 };
-
-  HostPort host_port{"127.0.0.1", kDefaultInspectorPort};
-
-  // Used to patch the options as if --inspect-brk is passed.
-  void EnableBreakFirstLine() {
-    inspector_enabled = true;
-    break_first_line = true;
-  }
-
-  bool wait_for_connect() const {
-    return break_first_line || break_node_first_line;
-  }
-
-  void CheckOptions(std::vector<std::string>* errors) override;
-};
-
-class EnvironmentOptions : public Options {
- public:
-  bool abort_on_uncaught_exception = false;
-  bool enable_source_maps = false;
-  bool experimental_json_modules = false;
-  bool experimental_modules = false;
-  std::string experimental_specifier_resolution;
-  std::string es_module_specifier_resolution;
-  bool experimental_wasm_modules = false;
-  bool experimental_import_meta_resolve = false;
-  std::string module_type;
-  std::string experimental_policy;
-  std::string experimental_policy_integrity;
-  bool has_policy_integrity_string;
-  bool experimental_repl_await = false;
-  bool experimental_vm_modules = false;
-  bool expose_internals = false;
-  bool frozen_intrinsics = false;
-  std::string heap_snapshot_signal;
-  std::string http_parser = "llhttp";
-  uint64_t http_server_default_timeout = 120000;
-  bool no_deprecation = false;
-  bool no_force_async_hooks_checks = false;
-  bool no_warnings = false;
-  bool force_context_aware = false;
-  bool pending_deprecation = false;
-  bool preserve_symlinks = false;
-  bool preserve_symlinks_main = false;
-  bool prof_process = false;
-#if HAVE_INSPECTOR
-  std::string cpu_prof_dir;
-  static const uint64_t kDefaultCpuProfInterval = 1000;
-  uint64_t cpu_prof_interval = kDefaultCpuProfInterval;
-  std::string cpu_prof_name;
-  bool cpu_prof = false;
-  std::string heap_prof_dir;
-  std::string heap_prof_name;
-  static const uint64_t kDefaultHeapProfInterval = 512 * 1024;
-  uint64_t heap_prof_interval = kDefaultHeapProfInterval;
-  bool heap_prof = false;
-#endif  // HAVE_INSPECTOR
-  std::string redirect_warnings;
-  bool test_udp_no_try_send = false;
-  bool throw_deprecation = false;
-  bool trace_deprecation = false;
-  bool trace_exit = false;
-  bool trace_sync_io = false;
-  bool trace_tls = false;
-  bool trace_uncaught = false;
-  bool trace_warnings = false;
-  std::string unhandled_rejections;
-  std::string userland_loader;
-
-  bool syntax_check_only = false;
-  bool has_eval_string = false;
-  bool experimental_wasi = false;
-  std::string eval_string;
-  bool print_eval = false;
-  bool force_repl = false;
-
-  bool insecure_http_parser = false;
-
-  bool tls_min_v1_0 = false;
-  bool tls_min_v1_1 = false;
-  bool tls_min_v1_2 = false;
-  bool tls_min_v1_3 = false;
-  bool tls_max_v1_2 = false;
-  bool tls_max_v1_3 = false;
-  std::string tls_keylog;
-
-  std::vector<std::string> preload_modules;
-
-  std::vector<std::string> user_argv;
-
-  inline DebugOptions* get_debug_options() { return &debug_options_; }
-  inline const DebugOptions& debug_options() const { return debug_options_; }
-
-  void CheckOptions(std::vector<std::string>* errors) override;
-
- private:
-  DebugOptions debug_options_;
-};
-
-class PerIsolateOptions : public Options {
- public:
-  std::shared_ptr<EnvironmentOptions> per_env { new EnvironmentOptions() };
-  bool track_heap_objects = false;
-  bool no_node_snapshot = false;
-  bool report_uncaught_exception = false;
-  bool report_on_signal = false;
-  std::string report_signal = "SIGUSR2";
-  inline EnvironmentOptions* get_per_env_options();
-  void CheckOptions(std::vector<std::string>* errors) override;
-};
-
-class PerProcessOptions : public Options {
- public:
-  // Options shouldn't be here unless they affect the entire process scope, and
-  // that should avoided when possible.
-  //
-  // When an option is used during process initialization, it does not need
-  // protection, but any use after that will likely require synchronization
-  // using the node::per_process::cli_options_mutex, typically:
-  //
-  //     Mutex::ScopedLock lock(node::per_process::cli_options_mutex);
-  std::shared_ptr<PerIsolateOptions> per_isolate { new PerIsolateOptions() };
-
-  std::string title;
-  std::string trace_event_categories;
-  std::string trace_event_file_pattern = "node_trace.${rotation}.log";
-  uint64_t max_http_header_size = 8 * 1024;
-  int64_t v8_thread_pool_size = 4;
-  bool zero_fill_all_buffers = false;
-  bool debug_arraybuffer_allocations = false;
-  std::string disable_proto;
-
-  std::vector<std::string> security_reverts;
-  bool print_bash_completion = false;
-  bool print_help = false;
-  bool print_v8_help = false;
-  bool print_version = false;
-
-#ifdef NODE_HAVE_I18N_SUPPORT
-  std::string icu_data_dir;
-#endif
-
-  // Per-process because they affect singleton OpenSSL shared library state,
-  // or are used once during process intialization.
-#if HAVE_OPENSSL
-  std::string openssl_config;
-  std::string tls_cipher_list = DEFAULT_CIPHER_LIST_CORE;
-#ifdef NODE_OPENSSL_CERT_STORE
-  bool ssl_openssl_cert_store = true;
-#else
-  bool ssl_openssl_cert_store = false;
-#endif
-  bool use_openssl_ca = false;
-  bool use_bundled_ca = false;
-#if NODE_FIPS_MODE
-  bool enable_fips_crypto = false;
-  bool force_fips_crypto = false;
-#endif
-#endif
-
-  // Per-process because reports can be triggered outside a known V8 context.
-  bool report_on_fatalerror = false;
-  bool report_compact = false;
-  std::string report_directory;
-  std::string report_filename;
-
-  // TODO(addaleax): Some of these could probably be per-Environment.
-  std::string use_largepages = "off";
-  bool trace_sigint = false;
-  std::vector<std::string> cmdline;
-
-  inline PerIsolateOptions* get_per_isolate_options();
-  void CheckOptions(std::vector<std::string>* errors) override;
-};
-
-// The actual options parser, as opposed to the structs containing them:
-
-namespace options_parser {
-
-HostPort SplitHostPort(const std::string& arg,
-    std::vector<std::string>* errors);
-void GetOptions(const v8::FunctionCallbackInfo<v8::Value>& args);
-std::string GetBashCompletion();
-
-enum OptionType {
-  kNoOp,
-  kV8Option,
-  kBoolean,
-  kInteger,
-  kUInteger,
-  kString,
-  kHostPort,
-  kStringList,
-};
-
-template <typename Options>
-class OptionsParser {
- public:
-  virtual ~OptionsParser() = default;
-
-  typedef Options TargetType;
-
-  struct NoOp {};
-  struct V8Option {};
-
-  // These methods add a single option to the parser. Optionally, it can be
-  // specified whether the option should be allowed from environment variable
-  // sources (i.e. NODE_OPTIONS).
-  void AddOption(const char* name,
-                 const char* help_text,
-                 bool Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 uint64_t Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 int64_t Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 std::string Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 std::vector<std::string> Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 HostPort Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 NoOp no_op_tag,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 V8Option v8_option_tag,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-
-  // Adds aliases. An alias can be of the form "--option-a" -> "--option-b",
-  // or have a more complex group expansion, like
-  //   "--option-a" -> { "--option-b", "--harmony-foobar", "--eval", "42" }
-  // If `from` has the form "--option-a=", the alias will only be expanded if
-  // the option is presented in that form (i.e. with a '=').
-  // If `from` has the form "--option-a <arg>", the alias will only be expanded
-  // if the option has a non-option argument (not starting with -) following it.
-  void AddAlias(const char* from, const char* to);
-  void AddAlias(const char* from, const std::vector<std::string>& to);
-  void AddAlias(const char* from,
-                const std::initializer_list<std::string>& to);
-
-  // Add implications from some arbitrary option to a boolean one, either
-  // in a way that makes `from` set `to` to true or to false.
-  void Implies(const char* from, const char* to);
-  void ImpliesNot(const char* from, const char* to);
-
-  // Insert options from another options parser into this one, along with
-  // a method that yields the target options type from this parser's options
-  // type.
-  template <typename ChildOptions>
-  void Insert(const OptionsParser<ChildOptions>& child_options_parser,
-              ChildOptions* (Options::* get_child)());
-
-  // Parse a sequence of options into an options struct, a list of
-  // arguments that were parsed as options, a list of unknown/JS engine options,
-  // and leave the remainder in the input `args` vector.
-  //
-  // For example, an `args` input of
-  //
-  //   node --foo --harmony-bar --fizzle=42 -- /path/to/cow moo
-  //
-  // expands as
-  //
-  // - `args` -> { "node", "/path/to/cow", "moo" }
-  // - `exec_args` -> { "--foo", "--harmony-bar", "--fizzle=42" }
-  // - `v8_args` -> `{ "node", "--harmony-bar" }
-  // - `options->foo == true`, `options->fizzle == 42`.
-  //
-  // If `*error` is set, the result of the parsing should be discarded and the
-  // contents of any of the argument vectors should be considered undefined.
-  void Parse(std::vector<std::string>* const args,
-             std::vector<std::string>* const exec_args,
-             std::vector<std::string>* const v8_args,
-             Options* const options,
-             OptionEnvvarSettings required_env_settings,
-             std::vector<std::string>* const errors) const;
-
- private:
-  // We support the wide variety of different option types by remembering
-  // how to access them, given a certain `Options` struct.
-
-  // Represents a field within `Options`.
-  class BaseOptionField {
-   public:
-    virtual ~BaseOptionField() = default;
-    virtual void* LookupImpl(Options* options) const = 0;
-
-    template <typename T>
-    inline T* Lookup(Options* options) const {
-      return static_cast<T*>(LookupImpl(options));
-    }
-  };
-
-  // Represents a field of type T within `Options` that can be looked up
-  // as a C++ member field.
-  template <typename T>
-  class SimpleOptionField : public BaseOptionField {
-   public:
-    explicit SimpleOptionField(T Options::* field) : field_(field) {}
-    void* LookupImpl(Options* options) const override {
-      return static_cast<void*>(&(options->*field_));
-    }
-
-   private:
-    T Options::* field_;
-  };
-
-  template <typename T>
-  inline T* Lookup(std::shared_ptr<BaseOptionField> field,
-                   Options* options) const {
-    return field->template Lookup<T>(options);
-  }
-
-  // An option consists of:
-  // - A type.
-  // - A way to store/access the property value.
-  // - The information of whether it may occur in an env var or not.
-  struct OptionInfo {
-    OptionType type;
-    std::shared_ptr<BaseOptionField> field;
-    OptionEnvvarSettings env_setting;
-    std::string help_text;
-  };
-
-  // An implied option is composed of the information on where to store a
-  // specific boolean value (if another specific option is encountered).
-  struct Implication {
-    std::shared_ptr<BaseOptionField> target_field;
-    bool target_value;
-  };
-
-  // These are helpers that make `Insert()` support properties of other
-  // options structs, if we know how to access them.
-  template <typename OriginalField, typename ChildOptions>
-  static auto Convert(
-      std::shared_ptr<OriginalField> original,
-      ChildOptions* (Options::* get_child)());
-  template <typename ChildOptions>
-  static auto Convert(
-      typename OptionsParser<ChildOptions>::OptionInfo original,
-      ChildOptions* (Options::* get_child)());
-  template <typename ChildOptions>
-  static auto Convert(
-      typename OptionsParser<ChildOptions>::Implication original,
-      ChildOptions* (Options::* get_child)());
-
-  std::unordered_map<std::string, OptionInfo> options_;
-  std::unordered_map<std::string, std::vector<std::string>> aliases_;
-  std::unordered_multimap<std::string, Implication> implications_;
-
-  template <typename OtherOptions>
-  friend class OptionsParser;
-
-  friend void GetOptions(const v8::FunctionCallbackInfo<v8::Value>& args);
-  friend std::string GetBashCompletion();
-};
-
-using StringVector = std::vector<std::string>;
-template <class OptionsType, class = Options>
-void Parse(
-  StringVector* const args, StringVector* const exec_args,
-  StringVector* const v8_args, OptionsType* const options,
-  OptionEnvvarSettings required_env_settings, StringVector* const errors);
-
-}  // namespace options_parser
-
-namespace per_process {
-
-extern Mutex cli_options_mutex;
-extern std::shared_ptr<PerProcessOptions> cli_options;
-
-}  // namespace per_process
-
-void HandleEnvOptions(std::shared_ptr<EnvironmentOptions> env_options);
-void HandleEnvOptions(std::shared_ptr<EnvironmentOptions> env_options,
-                      std::function<std::string(const char*)> opt_getter);
-
-std::vector<std::string> ParseNodeOptionsEnvVar(
-    const std::string& node_options, std::vector<std::string>* errors);
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_OPTIONS_H_

package/src/headers/12/node_perf.h

@@ -1,181 +0,0 @@
-#ifndef SRC_NODE_PERF_H_
-#define SRC_NODE_PERF_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node.h"
-#include "node_perf_common.h"
-#include "base_object-inl.h"
-#include "histogram-inl.h"
-
-#include "v8.h"
-#include "uv.h"
-
-#include <string>
-
-namespace node {
-
-class Environment;
-
-namespace performance {
-
-extern const uint64_t timeOrigin;
-
-static inline const char* GetPerformanceMilestoneName(
-    enum PerformanceMilestone milestone) {
-  switch (milestone) {
-#define V(name, label) case NODE_PERFORMANCE_MILESTONE_##name: return label;
-  NODE_PERFORMANCE_MILESTONES(V)
-#undef V
-    default:
-      UNREACHABLE();
-  }
-}
-
-static inline PerformanceMilestone ToPerformanceMilestoneEnum(const char* str) {
-#define V(name, label)                                                        \
-  if (strcmp(str, label) == 0) return NODE_PERFORMANCE_MILESTONE_##name;
-  NODE_PERFORMANCE_MILESTONES(V)
-#undef V
-  return NODE_PERFORMANCE_MILESTONE_INVALID;
-}
-
-static inline PerformanceEntryType ToPerformanceEntryTypeEnum(
-    const char* type) {
-#define V(name, label)                                                        \
-  if (strcmp(type, label) == 0) return NODE_PERFORMANCE_ENTRY_TYPE_##name;
-  NODE_PERFORMANCE_ENTRY_TYPES(V)
-#undef V
-  return NODE_PERFORMANCE_ENTRY_TYPE_INVALID;
-}
-
-class PerformanceEntry {
- public:
-  static void Notify(Environment* env,
-                     PerformanceEntryType type,
-                     v8::Local<v8::Value> object);
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  PerformanceEntry(Environment* env,
-                   const char* name,
-                   const char* type,
-                   uint64_t startTime,
-                   uint64_t endTime) : env_(env),
-                                       name_(name),
-                                       type_(type),
-                                       startTime_(startTime),
-                                       endTime_(endTime) { }
-
-  virtual ~PerformanceEntry() = default;
-
-  virtual v8::MaybeLocal<v8::Object> ToObject() const;
-
-  Environment* env() const { return env_; }
-
-  const std::string& name() const { return name_; }
-
-  const std::string& type() const { return type_; }
-
-  PerformanceEntryType kind() {
-    return ToPerformanceEntryTypeEnum(type().c_str());
-  }
-
-  double startTime() const { return startTimeNano() / 1e6; }
-
-  double duration() const { return durationNano() / 1e6; }
-
-  uint64_t startTimeNano() const { return startTime_ - timeOrigin; }
-
-  uint64_t durationNano() const { return endTime_ - startTime_; }
-
- private:
-  Environment* env_;
-  const std::string name_;
-  const std::string type_;
-  const uint64_t startTime_;
-  const uint64_t endTime_;
-};
-
-enum PerformanceGCKind {
-  NODE_PERFORMANCE_GC_MAJOR = v8::GCType::kGCTypeMarkSweepCompact,
-  NODE_PERFORMANCE_GC_MINOR = v8::GCType::kGCTypeScavenge,
-  NODE_PERFORMANCE_GC_INCREMENTAL = v8::GCType::kGCTypeIncrementalMarking,
-  NODE_PERFORMANCE_GC_WEAKCB = v8::GCType::kGCTypeProcessWeakCallbacks
-};
-
-enum PerformanceGCFlags {
-  NODE_PERFORMANCE_GC_FLAGS_NO =
-    v8::GCCallbackFlags::kNoGCCallbackFlags,
-  NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED =
-    v8::GCCallbackFlags::kGCCallbackFlagConstructRetainedObjectInfos,
-  NODE_PERFORMANCE_GC_FLAGS_FORCED =
-    v8::GCCallbackFlags::kGCCallbackFlagForced,
-  NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING =
-    v8::GCCallbackFlags::kGCCallbackFlagSynchronousPhantomCallbackProcessing,
-  NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE =
-    v8::GCCallbackFlags::kGCCallbackFlagCollectAllAvailableGarbage,
-  NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY =
-    v8::GCCallbackFlags::kGCCallbackFlagCollectAllExternalMemory,
-  NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE =
-    v8::GCCallbackFlags::kGCCallbackScheduleIdleGarbageCollection
-};
-
-class GCPerformanceEntry : public PerformanceEntry {
- public:
-  GCPerformanceEntry(Environment* env,
-                     PerformanceGCKind gckind,
-                     PerformanceGCFlags gcflags,
-                     uint64_t startTime,
-                     uint64_t endTime) :
-                         PerformanceEntry(env, "gc", "gc", startTime, endTime),
-                         gckind_(gckind),
-                         gcflags_(gcflags) { }
-
-  PerformanceGCKind gckind() const { return gckind_; }
-  PerformanceGCFlags gcflags() const { return gcflags_; }
-
- private:
-  PerformanceGCKind gckind_;
-  PerformanceGCFlags gcflags_;
-};
-
-class ELDHistogram : public HandleWrap, public Histogram {
- public:
-  ELDHistogram(Environment* env,
-               v8::Local<v8::Object> wrap,
-               int32_t resolution);
-
-  bool RecordDelta();
-  bool Enable();
-  bool Disable();
-  void ResetState() {
-    Reset();
-    exceeds_ = 0;
-    prev_ = 0;
-  }
-  int64_t Exceeds() const { return exceeds_; }
-
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackFieldWithSize("histogram", GetMemorySize());
-  }
-
-  SET_MEMORY_INFO_NAME(ELDHistogram)
-  SET_SELF_SIZE(ELDHistogram)
-
- private:
-  static void DelayIntervalCallback(uv_timer_t* req);
-
-  bool enabled_ = false;
-  int32_t resolution_ = 0;
-  int64_t exceeds_ = 0;
-  uint64_t prev_ = 0;
-  uv_timer_t timer_;
-};
-
-}  // namespace performance
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_PERF_H_

package/src/headers/12/node_process.h

@@ -1,41 +0,0 @@
-#ifndef SRC_NODE_PROCESS_H_
-#define SRC_NODE_PROCESS_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "v8.h"
-
-namespace node {
-
-v8::MaybeLocal<v8::Object> CreateEnvVarProxy(v8::Local<v8::Context> context,
-                                             v8::Isolate* isolate,
-                                             v8::Local<v8::Object> data);
-
-// Most of the time, it's best to use `console.error` to write
-// to the process.stderr stream.  However, in some cases, such as
-// when debugging the stream.Writable class or the process.nextTick
-// function, it is useful to bypass JavaScript entirely.
-void RawDebug(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-v8::MaybeLocal<v8::Value> ProcessEmit(Environment* env,
-                                      const char* event,
-                                      v8::Local<v8::Value> message);
-
-v8::Maybe<bool> ProcessEmitWarningGeneric(Environment* env,
-                                          const char* warning,
-                                          const char* type = nullptr,
-                                          const char* code = nullptr);
-
-v8::Maybe<bool> ProcessEmitWarning(Environment* env, const char* fmt, ...);
-v8::Maybe<bool> ProcessEmitExperimentalWarning(Environment* env,
-                                              const char* warning);
-v8::Maybe<bool> ProcessEmitDeprecationWarning(Environment* env,
-                                              const char* warning,
-                                              const char* deprecation_code);
-
-v8::MaybeLocal<v8::Object> CreateProcessObject(Environment* env);
-void PatchProcessObject(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-}  // namespace node
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_NODE_PROCESS_H_