@kungfu-tech/libnode-win32-x64 0.0.0-bootstrap.0 → 22.22.3-kf.1

package/dist/node/include/node_errors.h

@@ -0,0 +1,380 @@
+#ifndef SRC_NODE_ERRORS_H_
+#define SRC_NODE_ERRORS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "debug_utils-inl.h"
+#include "env.h"
+#include "node_buffer.h"
+#include "v8.h"
+
+// Use ostringstream to print exact-width integer types
+// because the format specifiers are not available on AIX.
+#include <sstream>
+
+namespace node {
+// This forward declaration is required to have the method
+// available in error messages.
+namespace errors {
+const char* errno_string(int errorno);
+}
+
+enum ErrorHandlingMode { CONTEXTIFY_ERROR, FATAL_ERROR, MODULE_ERROR };
+void AppendExceptionLine(Environment* env,
+                         v8::Local<v8::Value> er,
+                         v8::Local<v8::Message> message,
+                         enum ErrorHandlingMode mode);
+
+// This function calls backtrace, it should have not be marked as [[noreturn]].
+// But it is a public API, removing the attribute can break.
+// Prefer UNREACHABLE() internally instead, it doesn't need manually set
+// location.
+[[noreturn]] void OnFatalError(const char* location, const char* message);
+// This function calls backtrace, do not mark as [[noreturn]]. Read more in the
+// ABORT macro.
+void OOMErrorHandler(const char* location, const v8::OOMDetails& details);
+
+// Helpers to construct errors similar to the ones provided by
+// lib/internal/errors.js.
+// Example: with `V(ERR_INVALID_ARG_TYPE, TypeError)`, there will be
+// `node::ERR_INVALID_ARG_TYPE(isolate, "message")` returning
+// a `Local<Value>` containing the TypeError with proper code and message
+
+#define ERRORS_WITH_CODE(V)                                                    \
+  V(ERR_ACCESS_DENIED, Error)                                                  \
+  V(ERR_BUFFER_CONTEXT_NOT_AVAILABLE, Error)                                   \
+  V(ERR_BUFFER_OUT_OF_BOUNDS, RangeError)                                      \
+  V(ERR_BUFFER_TOO_LARGE, Error)                                               \
+  V(ERR_CLOSED_MESSAGE_PORT, Error)                                            \
+  V(ERR_CONSTRUCT_CALL_REQUIRED, TypeError)                                    \
+  V(ERR_CONSTRUCT_CALL_INVALID, TypeError)                                     \
+  V(ERR_CPU_PROFILE_ALREADY_STARTED, Error)                                    \
+  V(ERR_CPU_PROFILE_NOT_STARTED, Error)                                        \
+  V(ERR_CPU_PROFILE_TOO_MANY, Error)                                           \
+  V(ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED, Error)                             \
+  V(ERR_CRYPTO_INITIALIZATION_FAILED, Error)                                   \
+  V(ERR_CRYPTO_INVALID_AUTH_TAG, TypeError)                                    \
+  V(ERR_CRYPTO_INVALID_COUNTER, TypeError)                                     \
+  V(ERR_CRYPTO_INVALID_CURVE, TypeError)                                       \
+  V(ERR_CRYPTO_INVALID_DIGEST, TypeError)                                      \
+  V(ERR_CRYPTO_INVALID_IV, TypeError)                                          \
+  V(ERR_CRYPTO_INVALID_JWK, TypeError)                                         \
+  V(ERR_CRYPTO_INVALID_KEYLEN, RangeError)                                     \
+  V(ERR_CRYPTO_INVALID_KEYPAIR, RangeError)                                    \
+  V(ERR_CRYPTO_INVALID_KEYTYPE, RangeError)                                    \
+  V(ERR_CRYPTO_INVALID_MESSAGELEN, RangeError)                                 \
+  V(ERR_CRYPTO_INVALID_SCRYPT_PARAMS, RangeError)                              \
+  V(ERR_CRYPTO_INVALID_STATE, Error)                                           \
+  V(ERR_CRYPTO_INVALID_TAG_LENGTH, RangeError)                                 \
+  V(ERR_CRYPTO_JWK_UNSUPPORTED_CURVE, Error)                                   \
+  V(ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE, Error)                                \
+  V(ERR_CRYPTO_OPERATION_FAILED, Error)                                        \
+  V(ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH, RangeError)                           \
+  V(ERR_CRYPTO_UNKNOWN_CIPHER, Error)                                          \
+  V(ERR_CRYPTO_UNKNOWN_DH_GROUP, Error)                                        \
+  V(ERR_CRYPTO_UNSUPPORTED_OPERATION, Error)                                   \
+  V(ERR_CRYPTO_JOB_INIT_FAILED, Error)                                         \
+  V(ERR_DLOPEN_DISABLED, Error)                                                \
+  V(ERR_DLOPEN_FAILED, Error)                                                  \
+  V(ERR_ENCODING_INVALID_ENCODED_DATA, TypeError)                              \
+  V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE, Error)                            \
+  V(ERR_FS_CP_EINVAL, Error)                                                   \
+  V(ERR_FS_CP_DIR_TO_NON_DIR, Error)                                           \
+  V(ERR_FS_CP_NON_DIR_TO_DIR, Error)                                           \
+  V(ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY, Error)                                  \
+  V(ERR_FS_EISDIR, Error)                                                      \
+  V(ERR_FS_CP_EEXIST, Error)                                                   \
+  V(ERR_FS_CP_SOCKET, Error)                                                   \
+  V(ERR_FS_CP_FIFO_PIPE, Error)                                                \
+  V(ERR_FS_CP_UNKNOWN, Error)                                                  \
+  V(ERR_ILLEGAL_CONSTRUCTOR, Error)                                            \
+  V(ERR_INVALID_ADDRESS, Error)                                                \
+  V(ERR_INVALID_ARG_VALUE, TypeError)                                          \
+  V(ERR_OSSL_EVP_INVALID_DIGEST, Error)                                        \
+  V(ERR_INVALID_ARG_TYPE, TypeError)                                           \
+  V(ERR_INVALID_FILE_URL_HOST, TypeError)                                      \
+  V(ERR_INVALID_FILE_URL_PATH, TypeError)                                      \
+  V(ERR_INVALID_INVOCATION, TypeError)                                         \
+  V(ERR_INVALID_PACKAGE_CONFIG, Error)                                         \
+  V(ERR_INVALID_OBJECT_DEFINE_PROPERTY, TypeError)                             \
+  V(ERR_INVALID_MODULE, Error)                                                 \
+  V(ERR_INVALID_STATE, Error)                                                  \
+  V(ERR_INVALID_THIS, TypeError)                                               \
+  V(ERR_INVALID_URL, TypeError)                                                \
+  V(ERR_INVALID_URL_SCHEME, TypeError)                                         \
+  V(ERR_LOAD_SQLITE_EXTENSION, Error)                                          \
+  V(ERR_MEMORY_ALLOCATION_FAILED, Error)                                       \
+  V(ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE, Error)                             \
+  V(ERR_MISSING_ARGS, TypeError)                                               \
+  V(ERR_MISSING_PASSPHRASE, TypeError)                                         \
+  V(ERR_MISSING_PLATFORM_FOR_WORKER, Error)                                    \
+  V(ERR_MODULE_NOT_FOUND, Error)                                               \
+  V(ERR_MODULE_LINK_MISMATCH, TypeError)                                       \
+  V(ERR_NON_CONTEXT_AWARE_DISABLED, Error)                                     \
+  V(ERR_OPTIONS_BEFORE_BOOTSTRAPPING, Error)                                   \
+  V(ERR_OUT_OF_RANGE, RangeError)                                              \
+  V(ERR_REQUIRE_ASYNC_MODULE, Error)                                           \
+  V(ERR_SCRIPT_EXECUTION_INTERRUPTED, Error)                                   \
+  V(ERR_SCRIPT_EXECUTION_TIMEOUT, Error)                                       \
+  V(ERR_STRING_TOO_LONG, Error)                                                \
+  V(ERR_TLS_INVALID_PROTOCOL_METHOD, TypeError)                                \
+  V(ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED, Error)                                \
+  V(ERR_VM_MODULE_CACHED_DATA_REJECTED, Error)                                 \
+  V(ERR_VM_MODULE_LINK_FAILURE, Error)                                         \
+  V(ERR_WASI_NOT_STARTED, Error)                                               \
+  V(ERR_ZLIB_INITIALIZATION_FAILED, Error)                                     \
+  V(ERR_WORKER_INIT_FAILED, Error)                                             \
+  V(ERR_PROTO_ACCESS, Error)
+
+// If the macros are used as ERR_*(isolate, message) or
+// THROW_ERR_*(isolate, message) with a single string argument, do run
+// formatter on the message, and allow the caller to pass in a message
+// directly with characters that would otherwise need escaping if used
+// as format string unconditionally.
+#define V(code, type)                                                          \
+  template <typename... Args>                                                  \
+  inline v8::Local<v8::Object> code(                                           \
+      v8::Isolate* isolate, std::string_view format, Args&&... args) {         \
+    std::string message;                                                       \
+    if (sizeof...(Args) == 0) {                                                \
+      message = format;                                                        \
+    } else {                                                                   \
+      message = SPrintF(format, std::forward<Args>(args)...);                  \
+    }                                                                          \
+    v8::Local<v8::String> js_code = FIXED_ONE_BYTE_STRING(isolate, #code);     \
+    v8::Local<v8::String> js_msg =                                             \
+        v8::String::NewFromUtf8(isolate,                                       \
+                                message.c_str(),                               \
+                                v8::NewStringType::kNormal,                    \
+                                message.length())                              \
+            .ToLocalChecked();                                                 \
+    v8::Local<v8::Object> e = v8::Exception::type(js_msg)                      \
+                                  ->ToObject(isolate->GetCurrentContext())     \
+                                  .ToLocalChecked();                           \
+    e->Set(isolate->GetCurrentContext(),                                       \
+           FIXED_ONE_BYTE_STRING(isolate, "code"),                             \
+           js_code)                                                            \
+        .Check();                                                              \
+    return e;                                                                  \
+  }                                                                            \
+  template <typename... Args>                                                  \
+  inline void THROW_##code(                                                    \
+      v8::Isolate* isolate, std::string_view format, Args&&... args) {         \
+    isolate->ThrowException(                                                   \
+        code(isolate, format, std::forward<Args>(args)...));                   \
+  }                                                                            \
+  template <typename... Args>                                                  \
+  inline void THROW_##code(                                                    \
+      Environment* env, std::string_view format, Args&&... args) {             \
+    THROW_##code(env->isolate(), format, std::forward<Args>(args)...);         \
+  }                                                                            \
+  template <typename... Args>                                                  \
+  inline void THROW_##code(                                                    \
+      Realm* realm, std::string_view format, Args&&... args) {                 \
+    THROW_##code(realm->isolate(), format, std::forward<Args>(args)...);       \
+  }
+ERRORS_WITH_CODE(V)
+#undef V
+
+// Errors with predefined static messages
+
+#define PREDEFINED_ERROR_MESSAGES(V)                                           \
+  V(ERR_ACCESS_DENIED, "Access to this API has been restricted")               \
+  V(ERR_BUFFER_CONTEXT_NOT_AVAILABLE,                                          \
+    "Buffer is not available for the current Context")                         \
+  V(ERR_CLOSED_MESSAGE_PORT, "Cannot send data on closed MessagePort")         \
+  V(ERR_CONSTRUCT_CALL_INVALID, "Constructor cannot be called")                \
+  V(ERR_CONSTRUCT_CALL_REQUIRED, "Cannot call constructor without `new`")      \
+  V(ERR_CRYPTO_INITIALIZATION_FAILED, "Initialization failed")                 \
+  V(ERR_CRYPTO_INVALID_AUTH_TAG, "Invalid authentication tag")                 \
+  V(ERR_CRYPTO_INVALID_COUNTER, "Invalid counter")                             \
+  V(ERR_CRYPTO_INVALID_CURVE, "Invalid EC curve name")                         \
+  V(ERR_CRYPTO_INVALID_DIGEST, "Invalid digest")                               \
+  V(ERR_CRYPTO_INVALID_IV, "Invalid initialization vector")                    \
+  V(ERR_CRYPTO_INVALID_JWK, "Invalid JWK format")                              \
+  V(ERR_CRYPTO_INVALID_KEYLEN, "Invalid key length")                           \
+  V(ERR_CRYPTO_INVALID_KEYPAIR, "Invalid key pair")                            \
+  V(ERR_CRYPTO_INVALID_KEYTYPE, "Invalid key type")                            \
+  V(ERR_CRYPTO_INVALID_MESSAGELEN, "Invalid message length")                   \
+  V(ERR_CRYPTO_INVALID_SCRYPT_PARAMS, "Invalid scrypt params")                 \
+  V(ERR_CRYPTO_INVALID_STATE, "Invalid state")                                 \
+  V(ERR_CRYPTO_INVALID_TAG_LENGTH, "Invalid taglength")                        \
+  V(ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE, "Unsupported JWK Key Type.")          \
+  V(ERR_CRYPTO_OPERATION_FAILED, "Operation failed")                           \
+  V(ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH,                                       \
+    "Input buffers must have the same byte length")                            \
+  V(ERR_CRYPTO_UNKNOWN_CIPHER, "Unknown cipher")                               \
+  V(ERR_CRYPTO_UNKNOWN_DH_GROUP, "Unknown DH group")                           \
+  V(ERR_CRYPTO_UNSUPPORTED_OPERATION, "Unsupported crypto operation")          \
+  V(ERR_CRYPTO_JOB_INIT_FAILED, "Failed to initialize crypto job config")      \
+  V(ERR_DLOPEN_FAILED, "DLOpen failed")                                        \
+  V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE,                                   \
+    "Context not associated with Node.js environment")                         \
+  V(ERR_ILLEGAL_CONSTRUCTOR, "Illegal constructor")                            \
+  V(ERR_INVALID_ADDRESS, "Invalid socket address")                             \
+  V(ERR_INVALID_INVOCATION, "Invalid invocation")                              \
+  V(ERR_INVALID_MODULE, "No such module")                                      \
+  V(ERR_INVALID_STATE, "Invalid state")                                        \
+  V(ERR_INVALID_THIS, "Value of \"this\" is the wrong type")                   \
+  V(ERR_INVALID_URL_SCHEME, "The URL must be of scheme file:")                 \
+  V(ERR_LOAD_SQLITE_EXTENSION, "Failed to load SQLite extension")              \
+  V(ERR_MEMORY_ALLOCATION_FAILED, "Failed to allocate memory")                 \
+  V(ERR_OSSL_EVP_INVALID_DIGEST, "Invalid digest used")                        \
+  V(ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE,                                    \
+    "A message object could not be deserialized successfully in the target "   \
+    "vm.Context")                                                              \
+  V(ERR_MISSING_PLATFORM_FOR_WORKER,                                           \
+    "The V8 platform used by this instance of Node does not support "          \
+    "creating Workers")                                                        \
+  V(ERR_NON_CONTEXT_AWARE_DISABLED,                                            \
+    "Loading non context-aware native addons has been disabled")               \
+  V(ERR_SCRIPT_EXECUTION_INTERRUPTED,                                          \
+    "Script execution was interrupted by `SIGINT`")                            \
+  V(ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED, "Failed to set PSK identity hint")    \
+  V(ERR_WASI_NOT_STARTED, "wasi.start() has not been called")                  \
+  V(ERR_WORKER_INIT_FAILED, "Worker initialization failure")                   \
+  V(ERR_PROTO_ACCESS,                                                          \
+    "Accessing Object.prototype.__proto__ has been "                           \
+    "disallowed with --disable-proto=throw")
+
+#define V(code, message)                                                       \
+  inline v8::Local<v8::Object> code(v8::Isolate* isolate) {                    \
+    return code(isolate, message);                                             \
+  }                                                                            \
+  inline void THROW_##code(v8::Isolate* isolate) {                             \
+    isolate->ThrowException(code(isolate, message));                           \
+  }                                                                            \
+  inline void THROW_##code(Environment* env) { THROW_##code(env->isolate()); }
+PREDEFINED_ERROR_MESSAGES(V)
+#undef V
+
+// Errors with predefined non-static messages
+inline void THROW_ERR_SCRIPT_EXECUTION_TIMEOUT(Environment* env,
+                                               int64_t timeout) {
+  THROW_ERR_SCRIPT_EXECUTION_TIMEOUT(
+      env, "Script execution timed out after %dms", timeout);
+}
+
+inline void THROW_ERR_REQUIRE_ASYNC_MODULE(
+    Environment* env,
+    v8::Local<v8::Value> filename,
+    v8::Local<v8::Value> parent_filename) {
+  static constexpr const char* prefix =
+      "require() cannot be used on an ESM graph with top-level await. Use "
+      "import() instead. To see where the top-level await comes from, use "
+      "--experimental-print-required-tla.";
+  std::string message = prefix;
+  if (!parent_filename.IsEmpty() && parent_filename->IsString()) {
+    Utf8Value utf8(env->isolate(), parent_filename);
+    message += "\n  From ";
+    message += utf8.ToStringView();
+  }
+  if (!filename.IsEmpty() && filename->IsString()) {
+    Utf8Value utf8(env->isolate(), filename);
+    message += "\n  Requiring ";
+    message += utf8.ToStringView();
+  }
+  THROW_ERR_REQUIRE_ASYNC_MODULE(env, message);
+}
+
+inline v8::Local<v8::Object> ERR_BUFFER_TOO_LARGE(v8::Isolate* isolate) {
+  char message[128];
+  snprintf(message,
+           sizeof(message),
+           "Cannot create a Buffer larger than 0x%zx bytes",
+           Buffer::kMaxLength);
+  return ERR_BUFFER_TOO_LARGE(isolate, message);
+}
+
+inline v8::Local<v8::Object> ERR_STRING_TOO_LONG(v8::Isolate* isolate) {
+  char message[128];
+  snprintf(message, sizeof(message),
+      "Cannot create a string longer than 0x%x characters",
+      v8::String::kMaxLength);
+  return ERR_STRING_TOO_LONG(isolate, message);
+}
+
+#define THROW_AND_RETURN_IF_NOT_BUFFER(env, val, prefix)                     \
+  do {                                                                       \
+    if (!Buffer::HasInstance(val))                                           \
+      return node::THROW_ERR_INVALID_ARG_TYPE(env,                           \
+                                              prefix " must be a buffer");   \
+  } while (0)
+
+#define THROW_AND_RETURN_IF_NOT_STRING(env, val, prefix)                     \
+  do {                                                                       \
+    if (!val->IsString())                                                    \
+      return node::THROW_ERR_INVALID_ARG_TYPE(env,                           \
+                                              prefix " must be a string");   \
+  } while (0)
+
+namespace errors {
+
+class TryCatchScope : public v8::TryCatch {
+ public:
+  enum class CatchMode { kNormal, kFatal, kFatalRethrowStackOverflow };
+
+  explicit TryCatchScope(Environment* env, CatchMode mode = CatchMode::kNormal)
+      : v8::TryCatch(env->isolate()), env_(env), mode_(mode) {}
+  ~TryCatchScope();
+
+  // Since the dtor is not virtual we need to make sure no one creates
+  // object of it in the free store that might be held by polymorphic pointers.
+  void* operator new(std::size_t count) = delete;
+  void* operator new[](std::size_t count) = delete;
+  TryCatchScope(TryCatchScope&) = delete;
+  TryCatchScope(TryCatchScope&&) = delete;
+  TryCatchScope operator=(TryCatchScope&) = delete;
+  TryCatchScope operator=(TryCatchScope&&) = delete;
+
+ private:
+  Environment* env_;
+  CatchMode mode_;
+};
+
+// Trigger the global uncaught exception handler `process._fatalException`
+// in JS land (which emits the 'uncaughtException' event). If that returns
+// true, continue program execution, otherwise exit the process.
+void TriggerUncaughtException(v8::Isolate* isolate,
+                              const v8::TryCatch& try_catch);
+void TriggerUncaughtException(v8::Isolate* isolate,
+                              v8::Local<v8::Value> error,
+                              v8::Local<v8::Message> message,
+                              bool from_promise = false);
+
+const char* errno_string(int errorno);
+void PerIsolateMessageListener(v8::Local<v8::Message> message,
+                               v8::Local<v8::Value> error);
+
+void DecorateErrorStack(Environment* env,
+                        const errors::TryCatchScope& try_catch);
+void DecorateErrorStack(Environment* env,
+                        v8::Local<v8::Value> error,
+                        v8::Local<v8::Message> message);
+
+class PrinterTryCatch : public v8::TryCatch {
+ public:
+  enum PrintSourceLine { kPrintSourceLine, kDontPrintSourceLine };
+  explicit PrinterTryCatch(v8::Isolate* isolate,
+                           PrintSourceLine print_source_line)
+      : v8::TryCatch(isolate),
+        isolate_(isolate),
+        print_source_line_(print_source_line) {}
+  ~PrinterTryCatch();
+
+ private:
+  v8::Isolate* isolate_;
+  PrintSourceLine print_source_line_;
+};
+
+}  // namespace errors
+
+v8::ModifyCodeGenerationFromStringsResult ModifyCodeGenerationFromStrings(
+    v8::Local<v8::Context> context,
+    v8::Local<v8::Value> source,
+    bool is_code_like);
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_ERRORS_H_

package/dist/node/include/node_exit_code.h

@@ -0,0 +1,54 @@
+#ifndef SRC_NODE_EXIT_CODE_H_
+#define SRC_NODE_EXIT_CODE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+namespace node {
+#define EXIT_CODE_LIST(V)                                                      \
+  V(NoFailure, 0)                                                              \
+  /* 1 was intended for uncaught JS exceptions from the user land but we */    \
+  /* actually use this for all kinds of generic errors. */                     \
+  V(GenericUserError, 1)                                                       \
+  /* 2 is unused */                                                            \
+  /* 3 is actually unused because we pre-compile all builtins during */        \
+  /* snapshot building, when we exit with 1 if there's any error.  */          \
+  V(InternalJSParseError, 3)                                                   \
+  /* 4 is actually unused. We exit with 1 in this case. */                     \
+  V(InternalJSEvaluationFailure, 4)                                            \
+  /* 5 is actually unused. We exit with 133 (128+SIGTRAP) or 134 */            \
+  /* (128+SIGABRT) in this case. */                                            \
+  V(V8FatalError, 5)                                                           \
+  V(InvalidFatalExceptionMonkeyPatching, 6)                                    \
+  V(ExceptionInFatalExceptionHandler, 7)                                       \
+  /* 8 is unused */                                                            \
+  V(InvalidCommandLineArgument, 9)                                             \
+  V(BootstrapFailure, 10)                                                      \
+  /* 11 is unused */                                                           \
+  /* This was intended for invalid inspector arguments but is actually now */  \
+  /* just a duplicate of InvalidCommandLineArgument */                         \
+  V(InvalidCommandLineArgument2, 12)                                           \
+  V(UnsettledTopLevelAwait, 13)                                                \
+  V(StartupSnapshotFailure, 14)                                                \
+  /* If the process exits from unhandled signals e.g. SIGABRT, SIGTRAP, */     \
+  /* typically the exit codes are 128 + signal number. We also exit with */    \
+  /* certain error codes directly for legacy reasons. Here we define those */  \
+  /* that are used to normalize the exit code on Windows. */                   \
+  V(Abort, 134)
+
+// TODO(joyeecheung): expose this to user land when the codes are stable.
+// The underlying type should be an int, or we can get undefined behavior when
+// casting error codes into exit codes (technically we shouldn't do that,
+// but that's how things have been).
+enum class ExitCode : int {
+#define V(Name, Code) k##Name = Code,
+  EXIT_CODE_LIST(V)
+#undef V
+};
+
+[[noreturn]] void Exit(ExitCode exit_code);
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_EXIT_CODE_H_

package/dist/node/include/node_external_reference.h

@@ -0,0 +1,165 @@
+#ifndef SRC_NODE_EXTERNAL_REFERENCE_H_
+#define SRC_NODE_EXTERNAL_REFERENCE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include <vector>
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+namespace node {
+
+// This class manages the external references from the V8 heap
+// to the C++ addresses in Node.js.
+class ExternalReferenceRegistry {
+ public:
+  ExternalReferenceRegistry();
+
+#define ALLOWED_EXTERNAL_REFERENCE_TYPES(V)                                    \
+  V(v8::FunctionCallback)                                                      \
+  V(v8::AccessorNameGetterCallback)                                            \
+  V(v8::AccessorNameSetterCallback)                                            \
+  V(v8::NamedPropertyGetterCallback)                                           \
+  V(v8::NamedPropertyDefinerCallback)                                          \
+  V(v8::NamedPropertyDeleterCallback)                                          \
+  V(v8::NamedPropertyEnumeratorCallback)                                       \
+  V(v8::NamedPropertyQueryCallback)                                            \
+  V(v8::NamedPropertySetterCallback)                                           \
+  V(v8::IndexedPropertyGetterCallbackV2)                                       \
+  V(v8::IndexedPropertySetterCallbackV2)                                       \
+  V(v8::IndexedPropertyDefinerCallbackV2)                                      \
+  V(v8::IndexedPropertyDeleterCallbackV2)                                      \
+  V(v8::IndexedPropertyQueryCallbackV2)                                        \
+  V(const v8::String::ExternalStringResourceBase*)
+
+#define V(ExternalReferenceType)                                               \
+  void Register(ExternalReferenceType addr) { RegisterT(addr); }
+  ALLOWED_EXTERNAL_REFERENCE_TYPES(V)
+#undef V
+
+  // Registers both the underlying function pointer
+  // and the corresponding CFunctionInfo.
+  void Register(const v8::CFunction& c_func) {
+    RegisterT(c_func.GetAddress());
+    RegisterT(c_func.GetTypeInfo());
+  }
+
+  // This can be called only once.
+  const std::vector<intptr_t>& external_references();
+
+  bool is_empty() { return external_references_.empty(); }
+
+ private:
+  template <typename T>
+  void RegisterT(T* address) {
+    external_references_.push_back(reinterpret_cast<intptr_t>(address));
+  }
+  bool is_finalized_ = false;
+  std::vector<intptr_t> external_references_;
+};
+
+#define EXTERNAL_REFERENCE_BINDING_LIST_BASE(V)                                \
+  V(async_wrap)                                                                \
+  V(binding)                                                                   \
+  V(blob)                                                                      \
+  V(buffer)                                                                    \
+  V(builtins)                                                                  \
+  V(cares_wrap)                                                                \
+  V(config)                                                                    \
+  V(contextify)                                                                \
+  V(credentials)                                                               \
+  V(encoding_binding)                                                          \
+  V(env_var)                                                                   \
+  V(errors)                                                                    \
+  V(fs)                                                                        \
+  V(fs_dir)                                                                    \
+  V(fs_event_wrap)                                                             \
+  V(handle_wrap)                                                               \
+  V(heap_utils)                                                                \
+  V(http_parser)                                                               \
+  V(internal_only_v8)                                                          \
+  V(messaging)                                                                 \
+  V(mksnapshot)                                                                \
+  V(module_wrap)                                                               \
+  V(modules)                                                                   \
+  V(options)                                                                   \
+  V(os)                                                                        \
+  V(performance)                                                               \
+  V(permission)                                                                \
+  V(process_methods)                                                           \
+  V(process_object)                                                            \
+  V(process_wrap)                                                              \
+  V(report)                                                                    \
+  V(task_queue)                                                                \
+  V(tcp_wrap)                                                                  \
+  V(tty_wrap)                                                                  \
+  V(udp_wrap)                                                                  \
+  V(url)                                                                       \
+  V(util)                                                                      \
+  V(pipe_wrap)                                                                 \
+  V(sea)                                                                       \
+  V(serdes)                                                                    \
+  V(string_decoder)                                                            \
+  V(stream_wrap)                                                               \
+  V(signal_wrap)                                                               \
+  V(spawn_sync)                                                                \
+  V(trace_events)                                                              \
+  V(timers)                                                                    \
+  V(types)                                                                     \
+  V(uv)                                                                        \
+  V(v8)                                                                        \
+  V(zlib)                                                                      \
+  V(wasm_web_api)                                                              \
+  V(worker)
+
+#if NODE_HAVE_I18N_SUPPORT
+#define EXTERNAL_REFERENCE_BINDING_LIST_I18N(V) V(icu)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_I18N(V)
+#endif  // NODE_HAVE_I18N_SUPPORT
+
+#if HAVE_INSPECTOR
+#define EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)                           \
+  V(inspector)                                                                 \
+  V(profiler)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)
+#endif  // HAVE_INSPECTOR
+
+#if HAVE_OPENSSL
+#define EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V) V(crypto) V(tls_wrap)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V)
+#endif  // HAVE_OPENSSL
+
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#define EXTERNAL_REFERENCE_BINDING_LIST_QUIC(V) V(quic)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_QUIC(V)
+#endif
+
+#define EXTERNAL_REFERENCE_BINDING_LIST(V)                                     \
+  EXTERNAL_REFERENCE_BINDING_LIST_BASE(V)                                      \
+  EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)                                 \
+  EXTERNAL_REFERENCE_BINDING_LIST_I18N(V)                                      \
+  EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V)                                    \
+  EXTERNAL_REFERENCE_BINDING_LIST_QUIC(V)
+
+}  // namespace node
+
+// Declare all the external reference registration functions here,
+// and define them later with #NODE_BINDING_EXTERNAL_REFERENCE(modname, func);
+#define V(modname)                                                             \
+  void _register_external_reference_##modname(                                 \
+      node::ExternalReferenceRegistry* registry);
+EXTERNAL_REFERENCE_BINDING_LIST(V)
+#undef V
+
+#define NODE_BINDING_EXTERNAL_REFERENCE(modname, func)                         \
+  void _register_external_reference_##modname(                                 \
+      node::ExternalReferenceRegistry* registry) {                             \
+    func(registry);                                                            \
+  }
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_EXTERNAL_REFERENCE_H_