@encharm/cws 4.3.0 → 4.4.0

package/src/headers/20/node_contextify.h

@@ -0,0 +1,182 @@
+#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 {
+
+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;
+  std::unique_ptr<v8::MicrotaskQueue> own_microtask_queue;
+};
+
+class ContextifyContext : public BaseObject {
+ public:
+  ContextifyContext(Environment* env,
+                    v8::Local<v8::Object> wrapper,
+                    v8::Local<v8::Context> v8_context,
+                    ContextOptions* options);
+  ~ContextifyContext();
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(ContextifyContext)
+  SET_SELF_SIZE(ContextifyContext)
+
+  static v8::MaybeLocal<v8::Context> CreateV8Context(
+      v8::Isolate* isolate,
+      v8::Local<v8::ObjectTemplate> object_template,
+      const SnapshotData* snapshot_data,
+      v8::MicrotaskQueue* queue);
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static ContextifyContext* ContextFromContextifiedSandbox(
+      Environment* env,
+      const v8::Local<v8::Object>& sandbox);
+
+  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 v8::MicrotaskQueue* microtask_queue() const {
+    return microtask_queue_.get();
+  }
+
+  template <typename T>
+  static ContextifyContext* Get(const v8::PropertyCallbackInfo<T>& args);
+  static ContextifyContext* Get(v8::Local<v8::Object> object);
+
+  static void InitializeGlobalTemplates(IsolateData* isolate_data);
+
+ private:
+  static BaseObjectPtr<ContextifyContext> New(Environment* env,
+                                              v8::Local<v8::Object> sandbox_obj,
+                                              ContextOptions* options);
+  // Initialize a context created from CreateV8Context()
+  static BaseObjectPtr<ContextifyContext> New(v8::Local<v8::Context> ctx,
+                                              Environment* env,
+                                              v8::Local<v8::Object> sandbox_obj,
+                                              ContextOptions* options);
+
+  static bool IsStillInitializing(const ContextifyContext* ctx);
+  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);
+
+  v8::Global<v8::Context> context_;
+  std::unique_ptr<v8::MicrotaskQueue> microtask_queue_;
+};
+
+class ContextifyScript : public BaseObject {
+ public:
+  enum InternalFields {
+    kUnboundScriptSlot = BaseObject::kInternalFieldCount,
+    kInternalFieldCount
+  };
+
+  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 CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> 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 RunInContext(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static bool EvalMachine(v8::Local<v8::Context> context,
+                          Environment* env,
+                          const int64_t timeout,
+                          const bool display_errors,
+                          const bool break_on_sigint,
+                          const bool break_on_first_line,
+                          v8::MicrotaskQueue* microtask_queue,
+                          const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ private:
+  v8::Global<v8::UnboundScript> script_;
+};
+
+v8::Maybe<bool> StoreCodeCacheResult(
+    Environment* env,
+    v8::Local<v8::Object> target,
+    v8::ScriptCompiler::CompileOptions compile_options,
+    const v8::ScriptCompiler::Source& source,
+    bool produce_cached_data,
+    std::unique_ptr<v8::ScriptCompiler::CachedData> new_cached_data);
+
+v8::MaybeLocal<v8::Function> CompileFunction(
+    v8::Local<v8::Context> context,
+    v8::Local<v8::String> filename,
+    v8::Local<v8::String> content,
+    std::vector<v8::Local<v8::String>>* parameters);
+
+}  // namespace contextify
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_CONTEXTIFY_H_

package/src/headers/20/node_crypto.h

@@ -0,0 +1,56 @@
+// 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_CRYPTO_H_
+#define SRC_NODE_CRYPTO_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+// All of the crypto definitions previously contained in this header
+// have been split across multiple headers in src/crypto. This header
+// remains for convenience for any code that still imports it. New
+// code should include the relevant src/crypto headers directly.
+#include "crypto/crypto_aes.h"
+#include "crypto/crypto_bio.h"
+#include "crypto/crypto_cipher.h"
+#include "crypto/crypto_context.h"
+#include "crypto/crypto_dh.h"
+#include "crypto/crypto_dsa.h"
+#include "crypto/crypto_ec.h"
+#include "crypto/crypto_hash.h"
+#include "crypto/crypto_hkdf.h"
+#include "crypto/crypto_hmac.h"
+#include "crypto/crypto_keygen.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_pbkdf2.h"
+#include "crypto/crypto_random.h"
+#include "crypto/crypto_rsa.h"
+#include "crypto/crypto_scrypt.h"
+#include "crypto/crypto_sig.h"
+#include "crypto/crypto_spkac.h"
+#include "crypto/crypto_timing.h"
+#include "crypto/crypto_tls.h"
+#include "crypto/crypto_util.h"
+#include "crypto/crypto_x509.h"
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_CRYPTO_H_

package/src/headers/20/node_dir.h

@@ -0,0 +1,52 @@
+#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/20/node_dotenv.h

@@ -0,0 +1,37 @@
+#ifndef SRC_NODE_DOTENV_H_
+#define SRC_NODE_DOTENV_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util-inl.h"
+
+#include <map>
+
+namespace node {
+
+class Dotenv {
+ public:
+  Dotenv() = default;
+  Dotenv(const Dotenv& d) = default;
+  Dotenv(Dotenv&& d) noexcept = default;
+  Dotenv& operator=(Dotenv&& d) noexcept = default;
+  Dotenv& operator=(const Dotenv& d) = default;
+  ~Dotenv() = default;
+
+  void ParsePath(const std::string_view path);
+  void AssignNodeOptionsIfAvailable(std::string* node_options);
+  void SetEnvironment(Environment* env);
+
+  static std::vector<std::string> GetPathFromArgs(
+      const std::vector<std::string>& args);
+
+ private:
+  void ParseLine(const std::string_view line);
+  std::map<std::string, std::string> store_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_DOTENV_H_

package/src/headers/20/node_errors.h

@@ -0,0 +1,313 @@
+#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 OnFatalError(const char* location, const char* message);
+[[noreturn]] 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_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_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_OBJECT_DEFINE_PROPERTY, TypeError)                             \
+  V(ERR_INVALID_MODULE, Error)                                                 \
+  V(ERR_INVALID_STATE, Error)                                                  \
+  V(ERR_INVALID_THIS, TypeError)                                               \
+  V(ERR_INVALID_TRANSFER_OBJECT, TypeError)                                    \
+  V(ERR_INVALID_URL, TypeError)                                                \
+  V(ERR_INVALID_URL_SCHEME, 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_MODULE_NOT_FOUND, 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_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_MODULE, "No such module")                                      \
+  V(ERR_INVALID_STATE, "Invalid state")                                        \
+  V(ERR_INVALID_THIS, "Value of \"this\" is the wrong type")                   \
+  V(ERR_INVALID_TRANSFER_OBJECT, "Found invalid object in transferList")       \
+  V(ERR_INVALID_URL_SCHEME, "The URL must be of scheme file:")                 \
+  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 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::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);
+
+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_