@encharm/cws 4.5.3 → 4.8.0

package/src/headers/26/node_task_runner.h

@@ -0,0 +1,92 @@
+#ifndef SRC_NODE_TASK_RUNNER_H_
+#define SRC_NODE_TASK_RUNNER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+#include "simdjson.h"
+#include "spawn_sync.h"
+#include "uv.h"
+
+#include <filesystem>
+#include <optional>
+#include <string_view>
+#include <tuple>
+
+namespace node::task_runner {
+
+using PositionalArgs = std::vector<std::string_view>;
+
+// ProcessRunner is the class responsible for running a process.
+// A class instance is created for each process to be run.
+// The class is responsible for spawning the process and handling its exit.
+// The class also handles the environment variables and arguments.
+class ProcessRunner {
+ public:
+  ProcessRunner(std::shared_ptr<InitializationResultImpl> result,
+                const std::filesystem::path& package_json_path,
+                std::string_view script_name,
+                std::string_view command,
+                std::string_view path_env_var,
+                const PositionalArgs& positional_args);
+  void Run();
+  static void ExitCallback(uv_process_t* req,
+                           int64_t exit_status,
+                           int term_signal);
+
+ private:
+  uv_loop_t* loop_ = uv_default_loop();
+  uv_process_t process_{};
+  uv_process_options_t options_{};
+  uv_stdio_container_t child_stdio_[3]{};
+  std::shared_ptr<InitializationResultImpl> init_result_;
+  std::vector<std::string> command_args_{};
+  std::vector<std::string> env_vars_{};
+  std::unique_ptr<char* []> env_ {};  // memory for options_.env
+  std::unique_ptr<char* []> arg_ {};  // memory for options_.args
+  std::string cwd_;
+
+  // OnExit is the callback function that is called when the process exits.
+  void OnExit(int64_t exit_status, int term_signal);
+  void SetEnvironmentVariables();
+
+#ifdef _WIN32
+  std::string file_ = "cmd.exe";
+#else
+  std::string file_ = "/bin/sh";
+#endif  // _WIN32
+
+  // Represents the absolute path to the package.json file.
+  std::filesystem::path package_json_path_;
+  // Represents the name of the script that is being run.
+  std::string script_name_;
+  // Represents PATH environment variable that contains
+  // all subdirectory paths appended with node_modules/.bin suffix.
+  std::string path_env_var_;
+};
+
+// This function traverses up to the root directory.
+// While traversing up, if it finds a package.json file, it reads its content.
+// If it cannot find a package.json file, it returns std::nullopt.
+// Otherwise, it returns a tuple of:
+// - the path to the package.json file
+// - package.json file content
+// - `path_env_var` variable
+//
+// For example, on POSIX, it returns the following for `path_env_var`,
+// if the current directory is `/anonrig`:
+// `/anonrig/node_modules/.bin:/node_modules/.bin`
+std::optional<std::tuple<std::filesystem::path, std::string, std::string>>
+FindPackageJson(const std::filesystem::path& cwd);
+
+void RunTask(const std::shared_ptr<InitializationResultImpl>& result,
+             std::string_view command_id,
+             const PositionalArgs& positional_args);
+PositionalArgs GetPositionalArgs(const std::vector<std::string>& args);
+std::string EscapeShell(std::string_view command);
+
+}  // namespace node::task_runner
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_TASK_RUNNER_H_

package/src/headers/26/node_threadsafe_cow-inl.h

@@ -0,0 +1,54 @@
+#ifndef SRC_NODE_THREADSAFE_COW_INL_H_
+#define SRC_NODE_THREADSAFE_COW_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+namespace node {
+
+template <typename T>
+T* CopyOnWrite<T>::write() {
+  if (data_.use_count() > 1l) {
+    data_ = std::make_shared<T>(*data_);
+  }
+  return data_.get();
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Read::Read(const ThreadsafeCopyOnWrite<T>* cow)
+    : cow_(cow), lock_(cow->impl_->mutex) {}
+
+template <typename T>
+const T& ThreadsafeCopyOnWrite<T>::Read::operator*() const {
+  return cow_->impl_->data;
+}
+
+template <typename T>
+const T* ThreadsafeCopyOnWrite<T>::Read::operator->() const {
+  return &cow_->impl_->data;
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Write::Write(ThreadsafeCopyOnWrite<T>* cow)
+    : cow_(cow), impl_(cow->impl_.write()), lock_(impl_->mutex) {}
+
+template <typename T>
+T& ThreadsafeCopyOnWrite<T>::Write::operator*() {
+  return impl_->data;
+}
+
+template <typename T>
+T* ThreadsafeCopyOnWrite<T>::Write::operator->() {
+  return &impl_->data;
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Impl::Impl(const Impl& other) {
+  RwLock::ScopedReadLock lock(other.mutex);
+  data = other.data;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_THREADSAFE_COW_INL_H_

package/src/headers/26/node_threadsafe_cow.h

@@ -0,0 +1,105 @@
+#ifndef SRC_NODE_THREADSAFE_COW_H_
+#define SRC_NODE_THREADSAFE_COW_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util.h"
+#include "uv.h"
+
+#include <memory>   // std::shared_ptr<T>
+#include <utility>  // std::forward<T>
+
+namespace node {
+
+// Copy-on-write utility. Not threadsafe, i.e. there is no synchronization
+// of the copy operation with other operations.
+template <typename T>
+class CopyOnWrite final {
+ public:
+  template <typename... Args>
+  explicit CopyOnWrite(Args&&... args)
+      : data_(std::make_shared<T>(std::forward<Args>(args)...)) {}
+
+  CopyOnWrite(const CopyOnWrite<T>& other) = default;
+  CopyOnWrite& operator=(const CopyOnWrite<T>& other) = default;
+  CopyOnWrite(CopyOnWrite<T>&& other) = default;
+  CopyOnWrite& operator=(CopyOnWrite<T>&& other) = default;
+
+  const T* read() const { return data_.get(); }
+  T* write();
+
+  const T& operator*() const { return *read(); }
+  const T* operator->() const { return read(); }
+
+ private:
+  std::shared_ptr<T> data_;
+};
+
+// Threadsafe copy-on-write utility. Consumers need to use the Read and
+// Write helpers to access the target data structure.
+template <typename T>
+class ThreadsafeCopyOnWrite final {
+ private:
+  // Define this early since some of the public members depend on it
+  // and some compilers need it to be defined first in that case.
+  struct Impl {
+    explicit Impl(const T& data) : data(data) {}
+    explicit Impl(T&& data) : data(std::move(data)) {}
+
+    Impl(const Impl& other);
+    Impl& operator=(const Impl& other) = delete;
+    Impl(Impl&& other) = delete;
+    Impl& operator=(Impl&& other) = delete;
+
+    RwLock mutex;
+    T data;
+  };
+
+ public:
+  template <typename... Args>
+  ThreadsafeCopyOnWrite(Args&&... args)
+      : impl_(T(std::forward<Args>(args)...)) {}
+
+  ThreadsafeCopyOnWrite(const ThreadsafeCopyOnWrite<T>& other) = default;
+  ThreadsafeCopyOnWrite& operator=(const ThreadsafeCopyOnWrite<T>& other) =
+      default;
+  ThreadsafeCopyOnWrite(ThreadsafeCopyOnWrite<T>&& other) = default;
+  ThreadsafeCopyOnWrite& operator=(ThreadsafeCopyOnWrite<T>&& other) = default;
+
+  class Read {
+   public:
+    explicit Read(const ThreadsafeCopyOnWrite<T>* cow);
+
+    const T& operator*() const;
+    const T* operator->() const;
+
+   private:
+    const ThreadsafeCopyOnWrite<T>* cow_;
+    RwLock::ScopedReadLock lock_;
+  };
+
+  class Write {
+   public:
+    explicit Write(ThreadsafeCopyOnWrite<T>* cow);
+
+    T& operator*();
+    T* operator->();
+
+   private:
+    ThreadsafeCopyOnWrite<T>* cow_;
+    typename ThreadsafeCopyOnWrite<T>::Impl* impl_;
+    RwLock::ScopedLock lock_;
+  };
+
+  Read read() const { return Read(this); }
+  Write write() { return Write(this); }
+
+ private:
+  CopyOnWrite<Impl> impl_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_THREADSAFE_COW_H_

package/src/headers/26/node_union_bytes.h

@@ -0,0 +1,81 @@
+
+#ifndef SRC_NODE_UNION_BYTES_H_
+#define SRC_NODE_UNION_BYTES_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "v8.h"
+
+namespace node {
+
+// An external resource intended to be used with static lifetime.
+template <typename Char, typename IChar, typename Base>
+class StaticExternalByteResource : public Base {
+  static_assert(sizeof(IChar) == sizeof(Char),
+                "incompatible interface and internal pointers");
+
+ public:
+  explicit StaticExternalByteResource(const Char* data,
+                                      size_t length,
+                                      std::shared_ptr<void> owning_ptr)
+      : data_(data), length_(length), owning_ptr_(owning_ptr) {}
+
+  const IChar* data() const override {
+    return reinterpret_cast<const IChar*>(data_);
+  }
+  size_t length() const override { return length_; }
+
+  void Dispose() override {
+    // We ignore Dispose calls from V8, even if we "own" a resource via
+    // owning_ptr_. All instantiations of this class are static or owned by a
+    // static map, and will be destructed when static variables are destructed.
+  }
+
+  StaticExternalByteResource(const StaticExternalByteResource&) = delete;
+  StaticExternalByteResource& operator=(const StaticExternalByteResource&) =
+      delete;
+
+ private:
+  const Char* data_;
+  const size_t length_;
+  std::shared_ptr<void> owning_ptr_;
+};
+
+using StaticExternalOneByteResource =
+    StaticExternalByteResource<uint8_t,
+                               char,
+                               v8::String::ExternalOneByteStringResource>;
+using StaticExternalTwoByteResource =
+    StaticExternalByteResource<uint16_t,
+                               uint16_t,
+                               v8::String::ExternalStringResource>;
+
+// Similar to a v8::String, but it's independent from Isolates
+// and can be materialized in Isolates as external Strings
+// via ToStringChecked.
+class UnionBytes {
+ public:
+  explicit UnionBytes(StaticExternalOneByteResource* one_byte_resource)
+      : one_byte_resource_(one_byte_resource), two_byte_resource_(nullptr) {}
+  explicit UnionBytes(StaticExternalTwoByteResource* two_byte_resource)
+      : one_byte_resource_(nullptr), two_byte_resource_(two_byte_resource) {}
+
+  UnionBytes(const UnionBytes&) = default;
+  UnionBytes& operator=(const UnionBytes&) = default;
+  UnionBytes(UnionBytes&&) = default;
+  UnionBytes& operator=(UnionBytes&&) = default;
+
+  bool is_one_byte() const { return one_byte_resource_ != nullptr; }
+
+  v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) const;
+
+ private:
+  StaticExternalOneByteResource* one_byte_resource_;
+  StaticExternalTwoByteResource* two_byte_resource_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_UNION_BYTES_H_

package/src/headers/26/node_url.h

@@ -0,0 +1,101 @@
+#ifndef SRC_NODE_URL_H_
+#define SRC_NODE_URL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "ada.h"
+#include "aliased_buffer.h"
+#include "node.h"
+#include "node_snapshotable.h"
+#include "util.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+#include <optional>
+#include <string>
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace url {
+
+enum url_update_action {
+  kProtocol = 0,
+  kHost = 1,
+  kHostname = 2,
+  kPort = 3,
+  kUsername = 4,
+  kPassword = 5,
+  kPathname = 6,
+  kSearch = 7,
+  kHash = 8,
+  kHref = 9,
+};
+
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Realm* realm, v8::Local<v8::Object> obj);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(url_binding_data)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void DomainToASCII(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DomainToUnicode(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CanParse(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static bool FastCanParse(v8::Local<v8::Value> receiver,
+                           v8::Local<v8::Value> input,
+                           // NOLINTNEXTLINE(runtime/references) This is V8 api.
+                           v8::FastApiCallbackOptions& options);
+  static bool FastCanParseWithBase(
+      v8::Local<v8::Value> receiver,
+      v8::Local<v8::Value> input,
+      v8::Local<v8::Value> base,
+      // NOLINTNEXTLINE(runtime/references) This is V8 api.
+      v8::FastApiCallbackOptions& options);
+
+  static void Format(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetOrigin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Parse(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void PathToFileURL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Update(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> ctor);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+ private:
+  static constexpr size_t kURLComponentsLength = 9;
+  AliasedUint32Array url_components_buffer_;
+
+  void UpdateComponents(const ada::url_components& components,
+                        const ada::scheme::type type);
+
+  static v8::CFunction fast_can_parse_methods_[];
+};
+
+void ThrowInvalidURL(Environment* env,
+                     std::string_view input,
+                     std::optional<std::string> base);
+std::string FromFilePath(std::string_view file_path);
+std::optional<std::string> FileURLToPath(Environment* env,
+                                         const ada::url_aggregator& file_url);
+
+}  // namespace url
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_URL_H_

package/src/headers/26/node_url_pattern.h

@@ -0,0 +1,118 @@
+#ifndef SRC_NODE_URL_PATTERN_H_
+#define SRC_NODE_URL_PATTERN_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "ada.h"
+#include "base_object.h"
+#include "util.h"
+
+#include <v8.h>
+
+#include <optional>
+#include <string_view>
+
+namespace node::url_pattern {
+
+#define URL_PATTERN_COMPONENTS(V)                                              \
+  V(Protocol, protocol)                                                        \
+  V(Username, username)                                                        \
+  V(Password, password)                                                        \
+  V(Hostname, hostname)                                                        \
+  V(Port, port)                                                                \
+  V(Pathname, pathname)                                                        \
+  V(Search, search)                                                            \
+  V(Hash, hash)
+
+// By default, ada::url_pattern doesn't ship with any regex library.
+// Ada has a std::regex implementation, but it is considered unsafe and does
+// not have a fully compliant ecmascript syntax support. Therefore, Ada
+// supports passing custom regex provider that conforms to the following
+// class and function structure. For more information, please look into
+// url_pattern_regex.h inside github.com/ada-url/ada.
+class URLPatternRegexProvider {
+ public:
+  using regex_type = v8::Global<v8::RegExp>;
+  static std::optional<regex_type> create_instance(std::string_view pattern,
+                                                   bool ignore_case);
+  static std::optional<std::vector<std::optional<std::string>>> regex_search(
+      std::string_view input, const regex_type& pattern);
+  static bool regex_match(std::string_view input, const regex_type& pattern);
+};
+
+class URLPattern : public BaseObject {
+ public:
+  URLPattern(Environment* env,
+             v8::Local<v8::Object> object,
+             ada::url_pattern<URLPatternRegexProvider>&& url_pattern);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  // V8 APIs
+  // - Functions
+  static void Exec(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void Test(const v8::FunctionCallbackInfo<v8::Value>& info);
+  // - Component Getters
+#define URL_PATTERN_COMPONENT_GETTERS(name, _)                                 \
+  static void name(const v8::FunctionCallbackInfo<v8::Value>& info);
+  URL_PATTERN_COMPONENTS(URL_PATTERN_COMPONENT_GETTERS)
+#undef URL_PATTERN_COMPONENT_GETTERS
+  // - Has Regexp Groups
+  static void HasRegexpGroups(const v8::FunctionCallbackInfo<v8::Value>& info);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(URLPattern)
+  SET_SELF_SIZE(URLPattern)
+
+  class URLPatternInit {
+   public:
+    static std::optional<ada::url_pattern_init> FromJsObject(
+        Environment* env, v8::Local<v8::Object> obj);
+    static v8::MaybeLocal<v8::Value> ToJsObject(
+        Environment* env, const ada::url_pattern_init& init);
+  };
+
+  class URLPatternOptions {
+   public:
+    static std::optional<ada::url_pattern_options> FromJsObject(
+        Environment* env, v8::Local<v8::Object> obj);
+  };
+
+  class URLPatternResult {
+   public:
+    static v8::MaybeLocal<v8::Value> ToJSValue(
+        Environment* env, const ada::url_pattern_result& result);
+  };
+
+  class URLPatternComponentResult {
+   public:
+    static v8::MaybeLocal<v8::Object> ToJSObject(
+        Environment* env, const ada::url_pattern_component_result& result);
+  };
+
+ private:
+  ada::url_pattern<URLPatternRegexProvider> url_pattern_;
+  // Getter methods
+#define URL_PATTERN_COMPONENT_GETTERS(name, _) v8::MaybeLocal<v8::Value> name();
+  URL_PATTERN_COMPONENTS(URL_PATTERN_COMPONENT_GETTERS)
+#undef URL_PATTERN_COMPONENT_GETTERS
+  bool HasRegExpGroups() const;
+  // Public API
+  v8::MaybeLocal<v8::Value> Exec(
+      Environment* env,
+      const ada::url_pattern_input& input,
+      std::optional<std::string_view>& baseURL);  // NOLINT (runtime/references)
+  bool Test(
+      Environment* env,
+      const ada::url_pattern_input& input,
+      std::optional<std::string_view>& baseURL);  // NOLINT (runtime/references)
+
+#define URL_PATTERN_CACHED_VALUES(_, name) v8::Global<v8::Value> name;
+  URL_PATTERN_COMPONENTS(URL_PATTERN_CACHED_VALUES)
+#undef URL_PATTERN_CACHED_VALUES
+};
+
+}  // namespace node::url_pattern
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_URL_PATTERN_H_

package/src/headers/26/node_v8.h

@@ -0,0 +1,78 @@
+#ifndef SRC_NODE_V8_H_
+#define SRC_NODE_V8_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <sstream>
+#include "aliased_buffer.h"
+#include "base_object.h"
+#include "json_utils.h"
+#include "node_errors.h"
+#include "node_snapshotable.h"
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+class Environment;
+struct InternalFieldInfoBase;
+
+namespace v8_utils {
+class BindingData : public SnapshotableObject {
+ public:
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex heap_statistics_buffer;
+    AliasedBufferIndex heap_space_statistics_buffer;
+    AliasedBufferIndex heap_code_statistics_buffer;
+  };
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(v8_binding_data)
+
+  AliasedFloat64Array heap_statistics_buffer;
+  AliasedFloat64Array heap_space_statistics_buffer;
+  AliasedFloat64Array heap_code_statistics_buffer;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+ private:
+  InternalFieldInfo* internal_field_info_ = nullptr;
+};
+
+class GCProfiler : public BaseObject {
+ public:
+  enum class GCProfilerState { kInitialized, kStarted, kStopped };
+  GCProfiler(Environment* env, v8::Local<v8::Object> object);
+  inline ~GCProfiler() override;
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  JSONWriter* writer();
+
+  std::ostringstream* out_stream();
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(GCProfiler)
+  SET_SELF_SIZE(GCProfiler)
+
+  uint64_t start_time;
+  uint8_t current_gc_type;
+  GCProfilerState state;
+
+ private:
+  std::ostringstream out_stream_;
+  JSONWriter writer_;
+};
+
+}  // namespace v8_utils
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_V8_H_

package/src/headers/26/node_v8_embedder.h

@@ -0,0 +1,26 @@
+#ifndef SRC_NODE_V8_EMBEDDER_H_
+#define SRC_NODE_V8_EMBEDDER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cstdint>
+
+namespace node {
+
+// Type tags for different kinds of embedder data stored in V8 aligned pointer
+// slots.
+enum EmbedderDataTag : uint16_t {
+  // kDefault is used in slots that don't use V8 type tagging.
+  kDefault = 0,
+  // kEmbedderType is used by BaseObject to store the kEmbedderType value.
+  kEmbedderType,
+  // kPerContextData is used to store data on a `v8::Context`, including
+  // slots indexed by ContextEmbedderIndex.
+  kPerContextData,
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_V8_EMBEDDER_H_