@encharm/cws 4.4.1 → 4.5.1

package/src/headers/16/node_contextify.h

@@ -1,196 +0,0 @@
-#ifndef SRC_NODE_CONTEXTIFY_H_
-#define SRC_NODE_CONTEXTIFY_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base_object-inl.h"
-#include "node_context_data.h"
-#include "node_errors.h"
-
-namespace node {
-class ExternalReferenceRegistry;
-
-namespace contextify {
-
-class MicrotaskQueueWrap : public BaseObject {
- public:
-  MicrotaskQueueWrap(Environment* env, v8::Local<v8::Object> obj);
-
-  const std::shared_ptr<v8::MicrotaskQueue>& microtask_queue() const;
-
-  static void Init(Environment* env, v8::Local<v8::Object> target);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  // This could have methods for running the microtask queue, if we ever decide
-  // to make that fully customizable from userland.
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(MicrotaskQueueWrap)
-  SET_SELF_SIZE(MicrotaskQueueWrap)
-
- private:
-  std::shared_ptr<v8::MicrotaskQueue> microtask_queue_;
-};
-
-struct ContextOptions {
-  v8::Local<v8::String> name;
-  v8::Local<v8::String> origin;
-  v8::Local<v8::Boolean> allow_code_gen_strings;
-  v8::Local<v8::Boolean> allow_code_gen_wasm;
-  BaseObjectPtr<MicrotaskQueueWrap> microtask_queue_wrap;
-};
-
-class ContextifyContext {
- public:
-  enum InternalFields { kSlot, kInternalFieldCount };
-  ContextifyContext(Environment* env,
-                    v8::Local<v8::Object> sandbox_obj,
-                    const ContextOptions& options);
-  ~ContextifyContext();
-  static void CleanupHook(void* arg);
-
-  v8::MaybeLocal<v8::Object> CreateDataWrapper(Environment* env);
-  v8::MaybeLocal<v8::Context> CreateV8Context(Environment* env,
-                                              v8::Local<v8::Object> sandbox_obj,
-                                              const ContextOptions& options);
-  static void Init(Environment* env, v8::Local<v8::Object> target);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-
-  static ContextifyContext* ContextFromContextifiedSandbox(
-      Environment* env,
-      const v8::Local<v8::Object>& sandbox);
-
-  inline Environment* env() const {
-    return env_;
-  }
-
-  inline v8::Local<v8::Context> context() const {
-    return PersistentToLocal::Default(env()->isolate(), context_);
-  }
-
-  inline v8::Local<v8::Object> global_proxy() const {
-    return context()->Global();
-  }
-
-  inline v8::Local<v8::Object> sandbox() const {
-    return context()->GetEmbedderData(ContextEmbedderIndex::kSandboxObject)
-        .As<v8::Object>();
-  }
-
-  inline std::shared_ptr<v8::MicrotaskQueue> microtask_queue() const {
-    if (!microtask_queue_wrap_) return {};
-    return microtask_queue_wrap_->microtask_queue();
-  }
-
-
-  template <typename T>
-  static ContextifyContext* Get(const v8::PropertyCallbackInfo<T>& args);
-
- private:
-  static void MakeContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void IsContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CompileFunction(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void WeakCallback(
-      const v8::WeakCallbackInfo<ContextifyContext>& data);
-  static void PropertyGetterCallback(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void PropertySetterCallback(
-      v8::Local<v8::Name> property,
-      v8::Local<v8::Value> value,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void PropertyDescriptorCallback(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void PropertyDefinerCallback(
-      v8::Local<v8::Name> property,
-      const v8::PropertyDescriptor& desc,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void PropertyDeleterCallback(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Boolean>& args);
-  static void PropertyEnumeratorCallback(
-      const v8::PropertyCallbackInfo<v8::Array>& args);
-  static void IndexedPropertyGetterCallback(
-      uint32_t index,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void IndexedPropertySetterCallback(
-      uint32_t index,
-      v8::Local<v8::Value> value,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void IndexedPropertyDescriptorCallback(
-      uint32_t index,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void IndexedPropertyDefinerCallback(
-      uint32_t index,
-      const v8::PropertyDescriptor& desc,
-      const v8::PropertyCallbackInfo<v8::Value>& args);
-  static void IndexedPropertyDeleterCallback(
-      uint32_t index,
-      const v8::PropertyCallbackInfo<v8::Boolean>& args);
-  Environment* const env_;
-  v8::Global<v8::Context> context_;
-  BaseObjectPtr<MicrotaskQueueWrap> microtask_queue_wrap_;
-};
-
-class ContextifyScript : public BaseObject {
- public:
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(ContextifyScript)
-  SET_SELF_SIZE(ContextifyScript)
-
-  ContextifyScript(Environment* env, v8::Local<v8::Object> object);
-  ~ContextifyScript() override;
-
-  static void Init(Environment* env, v8::Local<v8::Object> target);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static bool InstanceOf(Environment* env, const v8::Local<v8::Value>& args);
-  static void CreateCachedData(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void RunInThisContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void RunInContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static bool EvalMachine(Environment* env,
-                          const int64_t timeout,
-                          const bool display_errors,
-                          const bool break_on_sigint,
-                          const bool break_on_first_line,
-                          std::shared_ptr<v8::MicrotaskQueue> microtask_queue,
-                          const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  inline uint32_t id() { return id_; }
-
- private:
-  v8::Global<v8::UnboundScript> script_;
-  uint32_t id_;
-};
-
-class CompiledFnEntry final : public BaseObject {
- public:
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(CompiledFnEntry)
-  SET_SELF_SIZE(CompiledFnEntry)
-
-  CompiledFnEntry(Environment* env,
-                  v8::Local<v8::Object> object,
-                  uint32_t id,
-                  v8::Local<v8::ScriptOrModule> script);
-  ~CompiledFnEntry();
-
-  bool IsNotIndicativeOfMemoryLeakAtExit() const override { return true; }
-
- private:
-  uint32_t id_;
-  v8::Global<v8::ScriptOrModule> script_;
-
-  static void WeakCallback(const v8::WeakCallbackInfo<CompiledFnEntry>& data);
-};
-
-}  // namespace contextify
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_CONTEXTIFY_H_

package/src/headers/16/node_dir.h

@@ -1,52 +0,0 @@
-#ifndef SRC_NODE_DIR_H_
-#define SRC_NODE_DIR_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_file.h"
-
-namespace node {
-
-namespace fs_dir {
-
-// Needed to propagate `uv_dir_t`.
-class DirHandle : public AsyncWrap {
- public:
-  static DirHandle* New(Environment* env, uv_dir_t* dir);
-  ~DirHandle() override;
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Read(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  inline uv_dir_t* dir() { return dir_; }
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(DirHandle)
-  SET_SELF_SIZE(DirHandle)
-
-  DirHandle(const DirHandle&) = delete;
-  DirHandle& operator=(const DirHandle&) = delete;
-  DirHandle(const DirHandle&&) = delete;
-  DirHandle& operator=(const DirHandle&&) = delete;
-
- private:
-  DirHandle(Environment* env, v8::Local<v8::Object> obj, uv_dir_t* dir);
-
-  // Synchronous close that emits a warning
-  void GCClose();
-
-  uv_dir_t* dir_;
-  // Multiple entries are read through a single libuv call.
-  std::vector<uv_dirent_t> dirents_;
-  bool closing_ = false;
-  bool closed_ = false;
-};
-
-}  // namespace fs_dir
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_DIR_H_

package/src/headers/16/node_dtrace.h

@@ -1,86 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-#ifndef SRC_NODE_DTRACE_H_
-#define SRC_NODE_DTRACE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "v8.h"
-
-extern "C" {
-/*
- * The following structures are passed directly to DTrace when probes are fired.
- * Translators in node.d translate these structures into the corresponding D
- * structures, taking care of dealing with the user process data model (32-bit
- * or 64-bit) and structure versions (see node_dtrace_http_server_request_t
- * below).
- */
-
-typedef struct {
-  int32_t fd;
-  int32_t port;
-  char* remote;
-  int32_t buffered;
-} node_dtrace_connection_t;
-
-typedef struct {
-  char* url;
-  char* method;
-} node_dtrace_http_client_request_t;
-
-/*
- * The original version of this structure contained only a url and method, just
- * like the client request above.  To add the new forwardedFor field, the
- * structure layout was changed to begin with an integer version.  The
- * translator knows whether it's looking at an old- or new-version structure
- * based on whether the version field's value is a reasonable pointer (i.e.
- * address greater than 4K).  No doubt this is filthy, but there's not much else
- * we can do, and it works reliably.
- *
- * This version of the structure also contains padding that should be zeroed out
- * by the consumer so that future versions of the translator can simply check if
- * a field is present by checking it against nullptr.
- */
-typedef struct {
-  union {
-    uint32_t version;
-    uintptr_t unused;  /* for compat. with old 64-bit struct */
-  } _un;
-  char* url;
-  char* method;
-  char* forwardedFor;
-  char* _pad[8];
-} node_dtrace_http_server_request_t;
-
-}  // extern "C"
-
-namespace node {
-
-class Environment;
-
-void InitDTrace(Environment* env);
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_DTRACE_H_

package/src/headers/16/node_errors.h

@@ -1,277 +0,0 @@
-#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 "v8.h"
-
-// Use ostringstream to print exact-width integer types
-// because the format specifiers are not available on AIX.
-#include <sstream>
-
-namespace node {
-
-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);
-
-[[noreturn]] void FatalError(const char* location, const char* message);
-void OnFatalError(const char* location, const char* message);
-
-// 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_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_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_EXECUTION_ENVIRONMENT_NOT_AVAILABLE, 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_MODULE, Error)                                                 \
-  V(ERR_INVALID_THIS, TypeError)                                               \
-  V(ERR_INVALID_TRANSFER_OBJECT, TypeError)                                    \
-  V(ERR_MEMORY_ALLOCATION_FAILED, Error)                                       \
-  V(ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE, Error)                             \
-  V(ERR_MISSING_ARGS, TypeError)                                               \
-  V(ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST, TypeError)                      \
-  V(ERR_MISSING_PASSPHRASE, TypeError)                                         \
-  V(ERR_MISSING_PLATFORM_FOR_WORKER, Error)                                    \
-  V(ERR_NON_CONTEXT_AWARE_DISABLED, Error)                                     \
-  V(ERR_OUT_OF_RANGE, RangeError)                                              \
-  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_WORKER_INIT_FAILED, Error)                                             \
-  V(ERR_PROTO_ACCESS, Error)
-
-#define V(code, type)                                                          \
-  template <typename... Args>                                                  \
-  inline v8::Local<v8::Value> code(                                            \
-      v8::Isolate* isolate, const char* format, Args&&... args) {              \
-    std::string message = SPrintF(format, std::forward<Args>(args)...);        \
-    v8::Local<v8::String> js_code = OneByteString(isolate, #code);             \
-    v8::Local<v8::String> js_msg =                                             \
-        OneByteString(isolate, message.c_str(), message.length());             \
-    v8::Local<v8::Object> e = v8::Exception::type(js_msg)                      \
-                                  ->ToObject(isolate->GetCurrentContext())     \
-                                  .ToLocalChecked();                           \
-    e->Set(isolate->GetCurrentContext(),                                       \
-           OneByteString(isolate, "code"),                                     \
-           js_code)                                                            \
-        .Check();                                                              \
-    return e;                                                                  \
-  }                                                                            \
-  template <typename... Args>                                                  \
-  inline void THROW_##code(                                                    \
-      v8::Isolate* isolate, const char* format, Args&&... args) {              \
-    isolate->ThrowException(                                                   \
-        code(isolate, format, std::forward<Args>(args)...));                   \
-  }                                                                            \
-  template <typename... Args>                                                  \
-  inline void THROW_##code(                                                    \
-      Environment* env, const char* format, Args&&... args) {                  \
-    THROW_##code(env->isolate(), format, std::forward<Args>(args)...);         \
-  }
-ERRORS_WITH_CODE(V)
-#undef V
-
-// Errors with predefined static messages
-
-#define PREDEFINED_ERROR_MESSAGES(V)                                           \
-  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_INVALID_ADDRESS, "Invalid socket address")                             \
-  V(ERR_INVALID_MODULE, "No such module")                                      \
-  V(ERR_INVALID_THIS, "Value of \"this\" is the wrong type")                   \
-  V(ERR_INVALID_TRANSFER_OBJECT, "Found invalid object in transferList")       \
-  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_TRANSFERABLE_IN_TRANSFER_LIST,                                 \
-    "Object that needs transfer was found in message but not listed "          \
-    "in transferList")                                                         \
-  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 modules 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::Value> 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) {
-  std::ostringstream message;
-  message << "Script execution timed out after ";
-  message << timeout << "ms";
-  THROW_ERR_SCRIPT_EXECUTION_TIMEOUT(env, message.str().c_str());
-}
-
-inline v8::Local<v8::Value> ERR_BUFFER_TOO_LARGE(v8::Isolate* isolate) {
-  char message[128];
-  snprintf(message, sizeof(message),
-      "Cannot create a Buffer larger than 0x%zx bytes",
-      v8::TypedArray::kMaxLength);
-  return ERR_BUFFER_TOO_LARGE(isolate, message);
-}
-
-inline v8::Local<v8::Value> 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 };
-
-  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);
-}  // namespace errors
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_ERRORS_H_