@encharm/cws 4.4.1 → 4.5.1

package/src/headers/16/node_messaging.h

@@ -1,373 +0,0 @@
-#ifndef SRC_NODE_MESSAGING_H_
-#define SRC_NODE_MESSAGING_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "env.h"
-#include "node_mutex.h"
-#include "v8.h"
-#include <deque>
-#include <string>
-#include <unordered_map>
-#include <set>
-
-namespace node {
-namespace worker {
-
-class MessagePortData;
-class MessagePort;
-
-typedef MaybeStackBuffer<v8::Local<v8::Value>, 8> TransferList;
-
-// Used to represent the in-flight structure of an object that is being
-// transferred or cloned using postMessage().
-class TransferData : public MemoryRetainer {
- public:
-  // Deserialize this object on the receiving end after a .postMessage() call.
-  // - `context` may not be the same as `env->context()`. This method should
-  //    not produce JS objects coming from Contexts other than `context`.
-  // - `self` is a unique_ptr for the object that this is being called on.
-  // - The return value is treated like a `Maybe`, i.e. if `nullptr` is
-  //   returned, any further deserialization of the message is stopped and
-  //   control is returned to the event loop or JS as soon as possible.
-  virtual BaseObjectPtr<BaseObject> Deserialize(
-      Environment* env,
-      v8::Local<v8::Context> context,
-      std::unique_ptr<TransferData> self) = 0;
-  // FinalizeTransferWrite() is the counterpart to
-  // BaseObject::FinalizeTransferRead(). It is called right after the transfer
-  // data was created, and defaults to doing nothing. After this function,
-  // this object should not hold any more Isolate-specific data.
-  virtual v8::Maybe<bool> FinalizeTransferWrite(
-      v8::Local<v8::Context> context, v8::ValueSerializer* serializer);
-};
-
-// Represents a single communication message.
-class Message : public MemoryRetainer {
- public:
-  // Create a Message with a specific underlying payload, in the format of the
-  // V8 ValueSerializer API. If `payload` is empty, this message indicates
-  // that the receiving message port should close itself.
-  explicit Message(MallocedBuffer<char>&& payload = MallocedBuffer<char>());
-  ~Message() = default;
-
-  Message(Message&& other) = default;
-  Message& operator=(Message&& other) = default;
-  Message& operator=(const Message&) = delete;
-  Message(const Message&) = delete;
-
-  // Whether this is a message indicating that the port is to be closed.
-  // This is the last message to be received by a MessagePort.
-  bool IsCloseMessage() const;
-
-  // Deserialize the contained JS value. May only be called once, and only
-  // after Serialize() has been called (e.g. by another thread).
-  v8::MaybeLocal<v8::Value> Deserialize(
-      Environment* env,
-      v8::Local<v8::Context> context,
-      v8::Local<v8::Value>* port_list = nullptr);
-
-  // Serialize a JS value, and optionally transfer objects, into this message.
-  // The Message object retains ownership of all transferred objects until
-  // deserialization.
-  // The source_port parameter, if provided, will make Serialize() throw a
-  // "DataCloneError" DOMException if source_port is found in transfer_list.
-  v8::Maybe<bool> Serialize(Environment* env,
-                            v8::Local<v8::Context> context,
-                            v8::Local<v8::Value> input,
-                            const TransferList& transfer_list,
-                            v8::Local<v8::Object> source_port =
-                                v8::Local<v8::Object>());
-
-  // Internal method of Message that is called when a new SharedArrayBuffer
-  // object is encountered in the incoming value's structure.
-  void AddSharedArrayBuffer(std::shared_ptr<v8::BackingStore> backing_store);
-  // Internal method of Message that is called once serialization finishes
-  // and that transfers ownership of `data` to this message.
-  void AddTransferable(std::unique_ptr<TransferData>&& data);
-  // Internal method of Message that is called when a new WebAssembly.Module
-  // object is encountered in the incoming value's structure.
-  uint32_t AddWASMModule(v8::CompiledWasmModule&& mod);
-
-  // The host objects that will be transferred, as recorded by Serialize()
-  // (e.g. MessagePorts).
-  // Used for warning user about posting the target MessagePort to itself,
-  // which will as a side effect destroy the communication channel.
-  const std::vector<std::unique_ptr<TransferData>>& transferables() const {
-    return transferables_;
-  }
-  bool has_transferables() const {
-    return !transferables_.empty() || !array_buffers_.empty();
-  }
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-
-  SET_MEMORY_INFO_NAME(Message)
-  SET_SELF_SIZE(Message)
-
- private:
-  MallocedBuffer<char> main_message_buf_;
-  // TODO(addaleax): Make this a std::variant to save storage size in the common
-  // case (which is that all of these vectors are empty) once that is available
-  // with C++17.
-  std::vector<std::shared_ptr<v8::BackingStore>> array_buffers_;
-  std::vector<std::shared_ptr<v8::BackingStore>> shared_array_buffers_;
-  std::vector<std::unique_ptr<TransferData>> transferables_;
-  std::vector<v8::CompiledWasmModule> wasm_modules_;
-
-  friend class MessagePort;
-};
-
-class SiblingGroup final : public std::enable_shared_from_this<SiblingGroup> {
- public:
-  // Named SiblingGroup, Used for one-to-many BroadcastChannels.
-  static std::shared_ptr<SiblingGroup> Get(const std::string& name);
-
-  // Anonymous SiblingGroup, Used for one-to-one MessagePort pairs.
-  SiblingGroup() = default;
-  explicit SiblingGroup(const std::string& name);
-  ~SiblingGroup();
-
-  // Dispatches the Message to the collection of associated
-  // ports. If there is more than one destination port and
-  // the Message contains transferables, Dispatch will fail.
-  // Returns Just(true) if successful and the message was
-  // dispatched to at least one destination. Returns Just(false)
-  // if there were no destinations. Returns Nothing<bool>()
-  // if there was an error. If error is not nullptr, it will
-  // be set to an error message or warning message as appropriate.
-  v8::Maybe<bool> Dispatch(
-      MessagePortData* source,
-      std::shared_ptr<Message> message,
-      std::string* error = nullptr);
-
-  void Entangle(MessagePortData* data);
-  void Entangle(std::initializer_list<MessagePortData*> data);
-  void Disentangle(MessagePortData* data);
-
-  const std::string& name() const { return name_; }
-
-  size_t size() const { return ports_.size(); }
-
- private:
-  const std::string name_;
-  RwLock group_mutex_;  // Protects ports_.
-  std::set<MessagePortData*> ports_;
-
-  static void CheckSiblingGroup(const std::string& name);
-
-  using Map =
-      std::unordered_map<std::string, std::weak_ptr<SiblingGroup>>;
-
-  static Mutex groups_mutex_;
-  static Map groups_;
-};
-
-// This contains all data for a `MessagePort` instance that is not tied to
-// a specific Environment/Isolate/event loop, for easier transfer between those.
-class MessagePortData : public TransferData {
- public:
-  explicit MessagePortData(MessagePort* owner);
-  ~MessagePortData() override;
-
-  MessagePortData(MessagePortData&& other) = delete;
-  MessagePortData& operator=(MessagePortData&& other) = delete;
-  MessagePortData(const MessagePortData& other) = delete;
-  MessagePortData& operator=(const MessagePortData& other) = delete;
-
-  // Add a message to the incoming queue and notify the receiver.
-  // This may be called from any thread.
-  void AddToIncomingQueue(std::shared_ptr<Message> message);
-  v8::Maybe<bool> Dispatch(
-      std::shared_ptr<Message> message,
-      std::string* error = nullptr);
-
-  // Turns `a` and `b` into siblings, i.e. connects the sending side of one
-  // to the receiving side of the other. This is not thread-safe.
-  static void Entangle(MessagePortData* a, MessagePortData* b);
-
-  // Removes any possible sibling. This is thread-safe (it acquires both
-  // `sibling_mutex_` and `mutex_`), and has to be because it is called once
-  // the corresponding JS handle handle wants to close
-  // which can happen on either side of a worker.
-  void Disentangle();
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  BaseObjectPtr<BaseObject> Deserialize(
-      Environment* env,
-      v8::Local<v8::Context> context,
-      std::unique_ptr<TransferData> self) override;
-
-  SET_MEMORY_INFO_NAME(MessagePortData)
-  SET_SELF_SIZE(MessagePortData)
-
- private:
-  // This mutex protects all fields below it, with the exception of
-  // sibling_.
-  mutable Mutex mutex_;
-  // TODO(addaleax): Make this a std::variant<std::shared_ptr, std::unique_ptr>
-  // once that is available with C++17, because std::shared_ptr comes with
-  // overhead that is only necessary for BroadcastChannel.
-  std::deque<std::shared_ptr<Message>> incoming_messages_;
-  MessagePort* owner_ = nullptr;
-  std::shared_ptr<SiblingGroup> group_;
-  friend class MessagePort;
-  friend class SiblingGroup;
-};
-
-// A message port that receives messages from other threads, including
-// the uv_async_t handle that is used to notify the current event loop of
-// new incoming messages.
-class MessagePort : public HandleWrap {
- private:
-  // Create a new MessagePort. The `context` argument specifies the Context
-  // instance that is used for creating the values emitted from this port.
-  // This is called by MessagePort::New(), which is the public API used for
-  // creating MessagePort instances.
-  MessagePort(Environment* env,
-              v8::Local<v8::Context> context,
-              v8::Local<v8::Object> wrap);
-
- public:
-  ~MessagePort() override;
-
-  // Create a new message port instance, optionally over an existing
-  // `MessagePortData` object.
-  static MessagePort* New(Environment* env,
-                          v8::Local<v8::Context> context,
-                          std::unique_ptr<MessagePortData> data = {},
-                          std::shared_ptr<SiblingGroup> sibling_group = {});
-
-  // Send a message, i.e. deliver it into the sibling's incoming queue.
-  // If this port is closed, or if there is no sibling, this message is
-  // serialized with transfers, then silently discarded.
-  v8::Maybe<bool> PostMessage(Environment* env,
-                              v8::Local<v8::Context> context,
-                              v8::Local<v8::Value> message,
-                              const TransferList& transfer);
-
-  // Start processing messages on this port as a receiving end.
-  void Start();
-  // Stop processing messages on this port as a receiving end.
-  void Stop();
-
-  /* constructor */
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  /* prototype methods */
-  static void PostMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CheckType(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Drain(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void ReceiveMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  /* static */
-  static void MoveToContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  // Turns `a` and `b` into siblings, i.e. connects the sending side of one
-  // to the receiving side of the other. This is not thread-safe.
-  static void Entangle(MessagePort* a, MessagePort* b);
-  static void Entangle(MessagePort* a, MessagePortData* b);
-
-  // Detach this port's data for transferring. After this, the MessagePortData
-  // is no longer associated with this handle, although it can still receive
-  // messages.
-  std::unique_ptr<MessagePortData> Detach();
-
-  void Close(
-      v8::Local<v8::Value> close_callback = v8::Local<v8::Value>()) override;
-
-  // Returns true if either data_ has been freed, or if the handle is being
-  // closed. Equivalent to the [[Detached]] internal slot in the HTML Standard.
-  //
-  // If checking if a JavaScript MessagePort object is detached, this method
-  // alone is often not enough, since the backing C++ MessagePort object may
-  // have been deleted already. For all intents and purposes, an object with a
-  // NULL pointer to the C++ MessagePort object is also detached.
-  inline bool IsDetached() const;
-
-  TransferMode GetTransferMode() const override;
-  std::unique_ptr<TransferData> TransferForMessaging() override;
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(MessagePort)
-  SET_SELF_SIZE(MessagePort)
-
- private:
-  enum class MessageProcessingMode {
-    kNormalOperation,
-    kForceReadMessages
-  };
-
-  void OnClose() override;
-  void OnMessage(MessageProcessingMode mode);
-  void TriggerAsync();
-  v8::MaybeLocal<v8::Value> ReceiveMessage(
-      v8::Local<v8::Context> context,
-      MessageProcessingMode mode,
-      v8::Local<v8::Value>* port_list = nullptr);
-
-  std::unique_ptr<MessagePortData> data_ = nullptr;
-  bool receiving_messages_ = false;
-  uv_async_t async_;
-  v8::Global<v8::Function> emit_message_fn_;
-
-  friend class MessagePortData;
-};
-
-// Provide a base class from which JS classes that should be transferable or
-// cloneable by postMesssage() can inherit.
-// See e.g. FileHandle in internal/fs/promises.js for an example.
-class JSTransferable : public BaseObject {
- public:
-  JSTransferable(Environment* env, v8::Local<v8::Object> obj);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  TransferMode GetTransferMode() const override;
-  std::unique_ptr<TransferData> TransferForMessaging() override;
-  std::unique_ptr<TransferData> CloneForMessaging() const override;
-  v8::Maybe<std::vector<BaseObjectPtr<BaseObject>>>
-      NestedTransferables() const override;
-  v8::Maybe<bool> FinalizeTransferRead(
-      v8::Local<v8::Context> context,
-      v8::ValueDeserializer* deserializer) override;
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(JSTransferable)
-  SET_SELF_SIZE(JSTransferable)
-
- private:
-  std::unique_ptr<TransferData> TransferOrClone(TransferMode mode) const;
-
-  class Data : public TransferData {
-   public:
-    Data(std::string&& deserialize_info, v8::Global<v8::Value>&& data);
-
-    BaseObjectPtr<BaseObject> Deserialize(
-        Environment* env,
-        v8::Local<v8::Context> context,
-        std::unique_ptr<TransferData> self) override;
-    v8::Maybe<bool> FinalizeTransferWrite(
-        v8::Local<v8::Context> context,
-        v8::ValueSerializer* serializer) override;
-
-    SET_NO_MEMORY_INFO()
-    SET_MEMORY_INFO_NAME(JSTransferableTransferData)
-    SET_SELF_SIZE(Data)
-
-   private:
-    std::string deserialize_info_;
-    v8::Global<v8::Value> data_;
-  };
-};
-
-v8::Local<v8::FunctionTemplate> GetMessagePortConstructorTemplate(
-    Environment* env);
-
-}  // namespace worker
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-
-#endif  // SRC_NODE_MESSAGING_H_

package/src/headers/16/node_metadata.h

@@ -1,122 +0,0 @@
-#ifndef SRC_NODE_METADATA_H_
-#define SRC_NODE_METADATA_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <string>
-#include "node_version.h"
-
-#if HAVE_OPENSSL
-#include <openssl/crypto.h>
-#endif  // HAVE_OPENSSL
-
-namespace node {
-
-// if this is a release build and no explicit base has been set
-// substitute the standard release download URL
-#ifndef NODE_RELEASE_URLBASE
-#if NODE_VERSION_IS_RELEASE
-#define NODE_RELEASE_URLBASE "https://nodejs.org/download/release/"
-#endif  // NODE_VERSION_IS_RELEASE
-#endif  // NODE_RELEASE_URLBASE
-
-#if defined(NODE_RELEASE_URLBASE)
-#define NODE_HAS_RELEASE_URLS
-#endif
-
-#define NODE_VERSIONS_KEYS_BASE(V)                                             \
-  V(node)                                                                      \
-  V(v8)                                                                        \
-  V(uv)                                                                        \
-  V(zlib)                                                                      \
-  V(brotli)                                                                    \
-  V(ares)                                                                      \
-  V(modules)                                                                   \
-  V(nghttp2)                                                                   \
-  V(napi)                                                                      \
-  V(llhttp)                                                                    \
-
-#if HAVE_OPENSSL
-#define NODE_VERSIONS_KEY_CRYPTO(V) V(openssl)
-#else
-#define NODE_VERSIONS_KEY_CRYPTO(V)
-#endif
-
-#ifdef NODE_HAVE_I18N_SUPPORT
-#define NODE_VERSIONS_KEY_INTL(V)                                              \
-  V(cldr)                                                                      \
-  V(icu)                                                                       \
-  V(tz)                                                                        \
-  V(unicode)
-#else
-#define NODE_VERSIONS_KEY_INTL(V)
-#endif  // NODE_HAVE_I18N_SUPPORT
-
-#ifdef OPENSSL_INFO_QUIC
-#define NODE_VERSIONS_KEY_QUIC(V)                                             \
-  V(ngtcp2)                                                                   \
-  V(nghttp3)
-#else
-#define NODE_VERSIONS_KEY_QUIC(V)
-#endif
-
-#define NODE_VERSIONS_KEYS(V)                                                  \
-  NODE_VERSIONS_KEYS_BASE(V)                                                   \
-  NODE_VERSIONS_KEY_CRYPTO(V)                                                  \
-  NODE_VERSIONS_KEY_INTL(V)                                                    \
-  NODE_VERSIONS_KEY_QUIC(V)
-
-class Metadata {
- public:
-  Metadata();
-  Metadata(Metadata&) = delete;
-  Metadata(Metadata&&) = delete;
-  Metadata operator=(Metadata&) = delete;
-  Metadata operator=(Metadata&&) = delete;
-
-  struct Versions {
-    Versions();
-
-#ifdef NODE_HAVE_I18N_SUPPORT
-    // Must be called on the main thread after
-    // i18n::InitializeICUDirectory()
-    void InitializeIntlVersions();
-#endif  // NODE_HAVE_I18N_SUPPORT
-
-#define V(key) std::string key;
-    NODE_VERSIONS_KEYS(V)
-#undef V
-  };
-
-  struct Release {
-    Release();
-
-    std::string name;
-#if NODE_VERSION_IS_LTS
-    std::string lts;
-#endif  // NODE_VERSION_IS_LTS
-
-#ifdef NODE_HAS_RELEASE_URLS
-    std::string source_url;
-    std::string headers_url;
-#ifdef _WIN32
-    std::string lib_url;
-#endif  // _WIN32
-#endif  // NODE_HAS_RELEASE_URLS
-  };
-
-  Versions versions;
-  const Release release;
-  const std::string arch;
-  const std::string platform;
-};
-
-// Per-process global
-namespace per_process {
-extern Metadata metadata;
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_NODE_METADATA_H_

package/src/headers/16/node_native_module.h

@@ -1,101 +0,0 @@
-#ifndef SRC_NODE_NATIVE_MODULE_H_
-#define SRC_NODE_NATIVE_MODULE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include "node_mutex.h"
-#include "node_union_bytes.h"
-#include "v8.h"
-
-// Forward declare test fixture for `friend` declaration.
-class PerProcessTest;
-
-namespace node {
-namespace native_module {
-
-using NativeModuleRecordMap = std::map<std::string, UnionBytes>;
-using NativeModuleCacheMap =
-    std::unordered_map<std::string,
-                       std::unique_ptr<v8::ScriptCompiler::CachedData>>;
-
-// The native (C++) side of the NativeModule in JS land, which
-// handles compilation and caching of builtin modules (NativeModule)
-// and bootstrappers, whose source are bundled into the binary
-// as static data.
-// This class should not depend on any Environment, or depend on access to
-// the its own singleton - that should be encapsulated in NativeModuleEnv
-// instead.
-class NativeModuleLoader {
- public:
-  NativeModuleLoader(const NativeModuleLoader&) = delete;
-  NativeModuleLoader& operator=(const NativeModuleLoader&) = delete;
-
- private:
-  // Only allow access from friends.
-  friend class NativeModuleEnv;
-  friend class CodeCacheBuilder;
-
-  NativeModuleLoader();
-  static NativeModuleLoader* GetInstance();
-
-  // Generated by tools/js2c.py as node_javascript.cc
-  void LoadJavaScriptSource();  // Loads data into source_
-  UnionBytes GetConfig();       // Return data for config.gypi
-
-  bool Exists(const char* id);
-  bool Add(const char* id, const UnionBytes& source);
-
-  v8::Local<v8::Object> GetSourceObject(v8::Local<v8::Context> context);
-  v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
-  std::vector<std::string> GetModuleIds();
-
-  struct ModuleCategories {
-    bool is_initialized = false;
-    std::set<std::string> can_be_required;
-    std::set<std::string> cannot_be_required;
-  };
-  void InitializeModuleCategories();
-  const std::set<std::string>& GetCannotBeRequired();
-  const std::set<std::string>& GetCanBeRequired();
-
-  bool CanBeRequired(const char* id);
-  bool CannotBeRequired(const char* id);
-
-  NativeModuleCacheMap* code_cache();
-  v8::ScriptCompiler::CachedData* GetCodeCache(const char* id) const;
-  enum class Result { kWithCache, kWithoutCache };
-  v8::MaybeLocal<v8::String> LoadBuiltinModuleSource(v8::Isolate* isolate,
-                                                     const char* id);
-  // If an exception is encountered (e.g. source code contains
-  // syntax error), the returned value is empty.
-  v8::MaybeLocal<v8::Function> LookupAndCompile(
-      v8::Local<v8::Context> context,
-      const char* id,
-      std::vector<v8::Local<v8::String>>* parameters,
-      Result* result);
-  v8::MaybeLocal<v8::Function> CompileAsModule(v8::Local<v8::Context> context,
-                                               const char* id,
-                                               Result* result);
-
-  static NativeModuleLoader instance_;
-  ModuleCategories module_categories_;
-  NativeModuleRecordMap source_;
-  NativeModuleCacheMap code_cache_;
-  UnionBytes config_;
-
-  // Used to synchronize access to the code cache map
-  Mutex code_cache_mutex_;
-
-  friend class ::PerProcessTest;
-};
-}  // namespace native_module
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_NATIVE_MODULE_H_

package/src/headers/16/node_native_module_env.h

@@ -1,68 +0,0 @@
-#ifndef SRC_NODE_NATIVE_MODULE_ENV_H_
-#define SRC_NODE_NATIVE_MODULE_ENV_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_native_module.h"
-
-namespace node {
-class Environment;
-class ExternalReferenceRegistry;
-
-namespace native_module {
-
-extern const bool has_code_cache;
-
-class NativeModuleEnv {
- public:
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context,
-                         void* priv);
-
-  static v8::MaybeLocal<v8::Function> LookupAndCompile(
-      v8::Local<v8::Context> context,
-      const char* id,
-      std::vector<v8::Local<v8::String>>* parameters,
-      Environment* optional_env);
-
-  static v8::Local<v8::Object> GetSourceObject(v8::Local<v8::Context> context);
-  // Returns config.gypi as a JSON string
-  static v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
-  static bool Exists(const char* id);
-  static bool Add(const char* id, const UnionBytes& source);
-
-  // Loads data into NativeModuleLoader::.instance.code_cache_
-  // Generated by mkcodecache as node_code_cache.cc when
-  // the build is configured with --code-cache-path=.... They are noops
-  // in node_code_cache_stub.cc
-  static void InitializeCodeCache();
-
- private:
-  static void RecordResult(const char* id,
-                           NativeModuleLoader::Result result,
-                           Environment* env);
-  static void GetModuleCategories(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Value>& info);
-  static void GetCacheUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
-  // Passing ids of builtin module source code into JS land as
-  // internalBinding('native_module').moduleIds
-  static void ModuleIdsGetter(v8::Local<v8::Name> property,
-                              const v8::PropertyCallbackInfo<v8::Value>& info);
-  // Passing config.gypi into JS land as internalBinding('native_module').config
-  static void ConfigStringGetter(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Value>& info);
-  // Compile a specific native module as a function
-  static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
-};
-
-}  // namespace native_module
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_NATIVE_MODULE_ENV_H_