@encharm/cws 4.4.1 → 4.5.2

package/src/headers/{18 → 22}/node_bob.h

@@ -11,12 +11,7 @@ constexpr size_t kMaxCountHint = 16;
 // Negative status codes indicate error conditions.
 enum Status : int {
   // Indicates that an attempt was made to pull after end.
-  STATUS_EOS = -1,
-
-  // Indicates the end of the stream. No additional
-  // data will be available and the consumer should stop
-  // pulling.
-  STATUS_END = 0,
+  STATUS_EOS = 0,
 
   // Indicates that there is additional data available
   // and the consumer may continue to pull.
@@ -72,6 +67,7 @@ using Next = std::function<void(int, const T*, size_t count, Done done)>;
 template <typename T>
 class Source {
  public:
+  virtual ~Source() = default;
   virtual int Pull(
       Next<T> next,
       int options,

package/src/headers/{18 → 22}/node_buffer.h

@@ -29,7 +29,7 @@ namespace node {
 
 namespace Buffer {
 
-static const size_t kMaxLength = v8::TypedArray::kMaxLength;
+static const size_t kMaxLength = v8::Uint8Array::kMaxLength;
 
 typedef void (*FreeCallback)(char* data, void* hint);
 

package/src/headers/22/node_builtins.h

@@ -0,0 +1,220 @@
+#ifndef SRC_NODE_BUILTINS_H_
+#define SRC_NODE_BUILTINS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <list>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include "node_external_reference.h"
+#include "node_mutex.h"
+#include "node_threadsafe_cow.h"
+#include "node_union_bytes.h"
+#include "v8.h"
+
+// Forward declare test fixture for `friend` declaration.
+class PerProcessTest;
+
+namespace node {
+class SnapshotBuilder;
+class ExternalReferenceRegistry;
+class Realm;
+
+namespace builtins {
+
+class BuiltinCodeCacheData {
+ public:
+  BuiltinCodeCacheData() : data(nullptr), length(0), owning_ptr(nullptr) {}
+
+  explicit BuiltinCodeCacheData(
+      std::shared_ptr<v8::ScriptCompiler::CachedData> cached_data)
+      : data(cached_data->data),
+        length(cached_data->length),
+        owning_ptr(cached_data) {}
+
+  explicit BuiltinCodeCacheData(
+      std::shared_ptr<std::vector<uint8_t>> cached_data)
+      : data(cached_data->data()),
+        length(cached_data->size()),
+        owning_ptr(cached_data) {}
+
+  BuiltinCodeCacheData(const uint8_t* data, size_t length)
+      : data(data), length(length), owning_ptr(nullptr) {}
+
+  const uint8_t* data;
+  size_t length;
+
+  // Returns a v8::ScriptCompiler::CachedData corresponding to this
+  // BuiltinCodeCacheData. The lifetime of the returned
+  // v8::ScriptCompiler::CachedData must not outlive that of the data.
+  std::unique_ptr<v8::ScriptCompiler::CachedData> AsCachedData() {
+    return std::make_unique<v8::ScriptCompiler::CachedData>(
+        data, length, v8::ScriptCompiler::CachedData::BufferNotOwned);
+  }
+
+ private:
+  // If not null, represents a pointer which owns data. Otherwise indicates
+  // that data has static lifetime.
+  std::shared_ptr<void> owning_ptr;
+};
+
+struct CodeCacheInfo {
+  std::string id;
+  BuiltinCodeCacheData data;
+};
+
+using BuiltinSourceMap = std::map<std::string, UnionBytes>;
+using BuiltinCodeCacheMap =
+    std::unordered_map<std::string, BuiltinCodeCacheData>;
+
+// Generated by tools/js2c.py as node_javascript.cc
+void RegisterExternalReferencesForInternalizedBuiltinCode(
+    ExternalReferenceRegistry* registry);
+
+// Handles compilation and caching of built-in JavaScript modules and
+// bootstrap scripts, whose source are bundled into the binary as static data.
+class NODE_EXTERN_PRIVATE BuiltinLoader {
+ public:
+  BuiltinLoader();
+  BuiltinLoader(const BuiltinLoader&) = delete;
+  BuiltinLoader& operator=(const BuiltinLoader&) = delete;
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+
+  // The parameters used to compile the scripts are detected based on
+  // the pattern of the id.
+  v8::MaybeLocal<v8::Function> LookupAndCompile(v8::Local<v8::Context> context,
+                                                const char* id,
+                                                Realm* optional_realm);
+
+  v8::MaybeLocal<v8::Function> LookupAndCompile(
+      v8::Local<v8::Context> context,
+      const char* id,
+      std::vector<v8::Local<v8::String>>* parameters,
+      Realm* optional_realm);
+
+  v8::MaybeLocal<v8::Value> CompileAndCall(v8::Local<v8::Context> context,
+                                           const char* id,
+                                           int argc,
+                                           v8::Local<v8::Value> argv[],
+                                           Realm* optional_realm);
+
+  v8::MaybeLocal<v8::Value> CompileAndCall(v8::Local<v8::Context> context,
+                                           const char* id,
+                                           Realm* realm);
+
+  // Returns config.gypi as a JSON string
+  v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
+  bool Exists(const char* id);
+  bool Add(const char* id, const UnionBytes& source);
+
+  bool CompileAllBuiltinsAndCopyCodeCache(
+      v8::Local<v8::Context> context,
+      const std::vector<std::string>& lazy_builtins,
+      std::vector<CodeCacheInfo>* out);
+  void RefreshCodeCache(const std::vector<CodeCacheInfo>& in);
+
+  void CopySourceAndCodeCacheReferenceFrom(const BuiltinLoader* other);
+
+  std::vector<std::string_view> GetBuiltinIds() const;
+
+  void SetEagerCompile() { should_eager_compile_ = true; }
+
+ private:
+  // Only allow access from friends.
+  friend class CodeCacheBuilder;
+
+  // Generated by tools/js2c.py as node_javascript.cc
+  void LoadJavaScriptSource();  // Loads data into source_
+  UnionBytes GetConfig();       // Return data for config.gypi
+
+  struct BuiltinCategories {
+    std::set<std::string> can_be_required;
+    std::set<std::string> cannot_be_required;
+  };
+  // This method builds `BuiltinCategories` from scratch every time,
+  // and is therefore somewhat expensive, but also currently only being
+  // used for testing, so that should not be an issue.
+  BuiltinCategories GetBuiltinCategories() const;
+
+  const v8::ScriptCompiler::CachedData* GetCodeCache(const char* id) const;
+  enum class Result { kWithCache, kWithoutCache };
+  v8::MaybeLocal<v8::String> LoadBuiltinSource(v8::Isolate* isolate,
+                                               const char* id) const;
+  // If an exception is encountered (e.g. source code contains
+  // syntax error), the returned value is empty.
+  v8::MaybeLocal<v8::Function> LookupAndCompileInternal(
+      v8::Local<v8::Context> context,
+      const char* id,
+      std::vector<v8::Local<v8::String>>* parameters,
+      Realm* optional_realm);
+  void SaveCodeCache(const char* id, v8::Local<v8::Function> fn);
+
+  static void RecordResult(const char* id,
+                           BuiltinLoader::Result result,
+                           Realm* realm);
+  static void GetBuiltinCategories(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void GetCacheUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
+  // Passing ids of built-in source code into JS land as
+  // internalBinding('builtins').builtinIds
+  static void BuiltinIdsGetter(v8::Local<v8::Name> property,
+                               const v8::PropertyCallbackInfo<v8::Value>& info);
+  // Passing config.gypi into JS land as internalBinding('builtins').config
+  static void ConfigStringGetter(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  // Compile a specific built-in as a function
+  static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HasCachedBuiltins(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  // For legacy process.binding('natives')
+  static void GetNatives(v8::Local<v8::Name> property,
+                         const v8::PropertyCallbackInfo<v8::Value>& info);
+
+  void AddExternalizedBuiltin(const char* id, const char* filename);
+
+  ThreadsafeCopyOnWrite<BuiltinSourceMap> source_;
+
+  const UnionBytes config_;
+
+  // If any bulitins should be eagerly compiled i.e. with inner functions
+  // compiled too, either use should_eager_compile_ to compile all builtins
+  // eagerly, or use to_eager_compile_ to compile specific builtins eagerly.
+  // Currently we set should_eager_compile_ to true when compiling primordials,
+  // and use to_eager_compile_ to compile code cache that complements the
+  // snapshot, where builtins already loaded in the snapshot and a few extras
+  // are compiled eagerly (other less-essential built-ins are compiled lazily to
+  // avoid bloating the binary size). At runtime any additional compilation is
+  // done lazily.
+  bool should_eager_compile_ = false;
+  std::unordered_set<std::string> to_eager_compile_;
+
+  struct BuiltinCodeCache {
+    RwLock mutex;
+    BuiltinCodeCacheMap map;
+    bool has_code_cache = false;
+  };
+  std::shared_ptr<BuiltinCodeCache> code_cache_;
+
+  friend class ::PerProcessTest;
+};
+
+}  // namespace builtins
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_BUILTINS_H_

package/src/headers/{18 → 22}/node_constants.h

@@ -27,6 +27,9 @@
 #include "node.h"
 #include "v8.h"
 
+#define EXTENSIONLESS_FORMAT_JAVASCRIPT (0)
+#define EXTENSIONLESS_FORMAT_WASM (1)
+
 #if HAVE_OPENSSL
 
 #ifndef RSA_PSS_SALTLEN_DIGEST
@@ -74,11 +77,6 @@
 #endif  // NODE_OPENSSL_DEFAULT_CIPHER_LIST
 #endif  // HAVE_OPENSSL
 
-namespace node {
-
-void DefineConstants(v8::Isolate* isolate, v8::Local<v8::Object> target);
-}  // namespace node
-
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #endif  // SRC_NODE_CONSTANTS_H_

package/src/headers/22/node_context_data.h

@@ -0,0 +1,168 @@
+#ifndef SRC_NODE_CONTEXT_DATA_H_
+#define SRC_NODE_CONTEXT_DATA_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+
+// Pick an index that's hopefully out of the way when we're embedded inside
+// another application. Performance-wise or memory-wise it doesn't matter:
+// Context::SetAlignedPointerInEmbedderData() is backed by a FixedArray,
+// worst case we pay a one-time penalty for resizing the array.
+#ifndef NODE_CONTEXT_EMBEDDER_DATA_INDEX
+#define NODE_CONTEXT_EMBEDDER_DATA_INDEX 32
+#endif
+
+#ifndef NODE_CONTEXT_SANDBOX_OBJECT_INDEX
+#define NODE_CONTEXT_SANDBOX_OBJECT_INDEX 33
+#endif
+
+#ifndef NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX
+#define NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX 34
+#endif
+
+#ifndef NODE_BINDING_DATA_STORE_INDEX
+#define NODE_BINDING_DATA_STORE_INDEX 35
+#endif
+
+#ifndef NODE_CONTEXT_ALLOW_CODE_GENERATION_FROM_STRINGS_INDEX
+#define NODE_CONTEXT_ALLOW_CODE_GENERATION_FROM_STRINGS_INDEX 36
+#endif
+
+#ifndef NODE_CONTEXT_CONTEXTIFY_CONTEXT_INDEX
+#define NODE_CONTEXT_CONTEXTIFY_CONTEXT_INDEX 37
+#endif
+
+#ifndef NODE_CONTEXT_REALM_INDEX
+#define NODE_CONTEXT_REALM_INDEX 38
+#endif
+
+// NODE_CONTEXT_TAG must be greater than any embedder indexes so that a single
+// check on the number of embedder data fields can assure the presence of all
+// embedder indexes.
+#ifndef NODE_CONTEXT_TAG
+#define NODE_CONTEXT_TAG 39
+#endif
+
+/**
+ * These are indexes used to set Node.js-specific data in the V8 contexts
+ * via v8::Context::SetAlignedPointerInEmbedderData() (for pointers) and
+ * v8::Context::SetEmbedderData() (for v8::Values).
+ *
+ * There are five types of contexts in Node.js:
+ * 1. Default V8 context, with nothing Node.js-specific. This is normally only
+ *    created by the embedders that uses v8::Context APIs directly and is not
+ *    available through the Node.js JS APIs. Its context snapshot in the
+ *    built-in v8 startup snapshot is stored using
+ *    v8::SnapshotCreator::SetDefaultContext() - effectively at index 0.
+ * 2. Default Node.js main context. When Node.js is launched typically there is
+ *    a main thread on which a main node::Environment is created. The
+ *    Environment is associated with its own v8::Isolate (env->isolate()) and a
+ *    main v8::Context (env->context()). The corresponding data structure is
+ *    node::NodeMainInstance and the Environment is created in
+ *    node::NodeMainInstance::Run(). Its context snapshot in the built-in V8
+ *    startup snapshot is stored at node::SnapshotData::kNodeMainContextIndex.
+ * 3. Node.js worker context. When a Worker instance is created via
+ *    new worker_threads.Worker(), it gets its own OS thread, its
+ *    own node::Environment, its own v8::Isolate and its own v8::Context.
+ *    The corresponding data structure is node::Worker and the Environment
+ *    is created in node::Worker::Run().
+ *    Its context snapshot in the built-in V8 startup snapshot is stored at
+ *    node::SnapshotData::kNodeBaseContextIndex.
+ * 4. Contextified vm context: When a contextified context is created via
+ *    vm.createContext() or other related vm APIs, the vm.Context instance
+ *    gets its own v8::Context. It shares the thread, the v8::Isolate and
+ *    the node::Environment with the context where the vm APIs are called.
+ *    The corresponding data structure is node::ContextifyContext and
+ *    the initialization code is in node::ContextifyContext::New().
+ *    Its context snapshot in the built-in V8 startup snapshot is stored at
+ *    node::SnapshotData::kNodeVMContextIndex.
+ * 5. ShadowRealm context: When a JS ShadowRealm is created via new ShadowRealm,
+ *    it gets its own v8::Context. It also shares the thread, the v8::Isolate
+ *    and the node::Environment with the context where the ShadowRealm
+ *    constructor is called.  The corresponding data structure is
+ *    node::ShadowRealm and the initialization code is in
+ *    node::ShadowRealm::New().
+ */
+enum ContextEmbedderIndex {
+  // Pointer to the node::Environment associated with the context. Only set for
+  // context type 2-5. Used by Environment::GetCurrent(context) to retrieve
+  // the node::Environment associated with any Node.js context in the
+  // V8 callbacks.
+  kEnvironment = NODE_CONTEXT_EMBEDDER_DATA_INDEX,
+  // A v8::Value which is the sandbox object used to create the contextified vm
+  // context. For example the first argument of vm.createContext().
+  // Only set for context type 4 and used in ContextifyContext methods.
+  kSandboxObject = NODE_CONTEXT_SANDBOX_OBJECT_INDEX,
+  // A v8::Value indicating whether the context allows WebAssembly code
+  // generation.
+  // Only set for context type 2-5, and for them the default is v8::True.
+  // For context type 4 it's configurable via options.codeGeneration.wasm in the
+  // vm APIs. Used in the default v8::AllowWasmCodeGenerationCallback.
+  kAllowWasmCodeGeneration = NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX,
+  // A v8::Value indicating whether the context allows code generation via
+  // eval() or new Function().
+  // Only set for context type 2-5, and for them the default is v8::True.
+  // For context type 4 it's configurable via options.codeGeneration.strings in
+  // the
+  // vm APIs. Used in the default v8::AllowCodeGenerationFromStringsCallback.
+  kAllowCodeGenerationFromStrings =
+      NODE_CONTEXT_ALLOW_CODE_GENERATION_FROM_STRINGS_INDEX,
+  // Pointer to the node::ContextifyContext associated with vm.Contexts.
+  // Only set for context type 4. Used by ContextifyContext::Get() to get
+  // to the ContextifyContext from the property interceptors.
+  kContextifyContext = NODE_CONTEXT_CONTEXTIFY_CONTEXT_INDEX,
+  // Pointer to the node::Realm associated with the context.
+  // Only set for context type 2-3 and 5. For context type 2-3, it points to a
+  // node::PrincipalRealm. For context type 5 it points to a node::ShadowRealm.
+  // Used by Realm::GetCurrent(context) to retrieve the associated node::Realm
+  // with any Node.js context in the V8 callbacks.
+  kRealm = NODE_CONTEXT_REALM_INDEX,
+  // Pointer to a constant address which is
+  // node::ContextEmbedderTag::kNodeContextTagPtr.
+  // Only set for context type 2-5. Used by ContextEmbedderTag::IsNodeContext()
+  // to check whether a context is a Node.js context.
+  kContextTag = NODE_CONTEXT_TAG,
+};
+
+class ContextEmbedderTag {
+ public:
+  static inline void TagNodeContext(v8::Local<v8::Context> context) {
+    // Used by ContextEmbedderTag::IsNodeContext to know that we are on a node
+    // context.
+    context->SetAlignedPointerInEmbedderData(
+        ContextEmbedderIndex::kContextTag,
+        ContextEmbedderTag::kNodeContextTagPtr);
+  }
+
+  static inline bool IsNodeContext(v8::Local<v8::Context> context) {
+    if (context.IsEmpty()) [[unlikely]] {
+      return false;
+    }
+    if (context->GetNumberOfEmbedderDataFields() <=
+        ContextEmbedderIndex::kContextTag) [[unlikely]] {
+      return false;
+    }
+    if (context->GetAlignedPointerFromEmbedderData(
+            ContextEmbedderIndex::kContextTag) !=
+        ContextEmbedderTag::kNodeContextTagPtr) [[unlikely]] {
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  static void* const kNodeContextTagPtr;
+  static int const kNodeContextTag;
+
+  ContextEmbedderTag() = delete;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_CONTEXT_DATA_H_

package/src/headers/22/node_contextify.h

@@ -0,0 +1,199 @@
+#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;
+  v8::Local<v8::Symbol> host_defined_options_id;
+  bool vanilla = false;
+};
+
+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>& wrapper_holder);
+
+  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 {
+    // Only vanilla contexts have undefined sandboxes. sandbox() is only used by
+    // interceptors who are not supposed to be called on vanilla contexts.
+    v8::Local<v8::Value> result =
+        context()->GetEmbedderData(ContextEmbedderIndex::kSandboxObject);
+    CHECK(!result->IsUndefined());
+    return result.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 v8::Local<v8::Object> CompileFunctionAndCacheResult(
+      Environment* env,
+      v8::Local<v8::Context> parsing_context,
+      v8::ScriptCompiler::Source* source,
+      std::vector<v8::Local<v8::String>> params,
+      std::vector<v8::Local<v8::Object>> context_extensions,
+      v8::ScriptCompiler::CompileOptions options,
+      bool produce_cached_data,
+      v8::Local<v8::Symbol> id_symbol,
+      const errors::TryCatchScope& try_catch);
+  static v8::Intercepted PropertyQueryCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Integer>& args);
+  static v8::Intercepted PropertyGetterCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static v8::Intercepted PropertySetterCallback(
+      v8::Local<v8::Name> property,
+      v8::Local<v8::Value> value,
+      const v8::PropertyCallbackInfo<void>& args);
+  static v8::Intercepted PropertyDescriptorCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& args);
+  static v8::Intercepted PropertyDefinerCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyDescriptor& desc,
+      const v8::PropertyCallbackInfo<void>& args);
+  static v8::Intercepted PropertyDeleterCallback(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Boolean>& args);
+  static void PropertyEnumeratorCallback(
+      const v8::PropertyCallbackInfo<v8::Array>& args);
+  static v8::Intercepted IndexedPropertyQueryCallback(
+      uint32_t index, const v8::PropertyCallbackInfo<v8::Integer>& args);
+  static v8::Intercepted IndexedPropertyGetterCallback(
+      uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& args);
+  static v8::Intercepted IndexedPropertySetterCallback(
+      uint32_t index,
+      v8::Local<v8::Value> value,
+      const v8::PropertyCallbackInfo<void>& args);
+  static v8::Intercepted IndexedPropertyDescriptorCallback(
+      uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& args);
+  static v8::Intercepted IndexedPropertyDefinerCallback(
+      uint32_t index,
+      const v8::PropertyDescriptor& desc,
+      const v8::PropertyCallbackInfo<void>& args);
+  static v8::Intercepted IndexedPropertyDeleterCallback(
+      uint32_t index, const v8::PropertyCallbackInfo<v8::Boolean>& args);
+  static void IndexedPropertyEnumeratorCallback(
+      const v8::PropertyCallbackInfo<v8::Array>& 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<void> 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/{16 → 22}/node_crypto.h

@@ -35,7 +35,6 @@
 #include "crypto/crypto_dh.h"
 #include "crypto/crypto_dsa.h"
 #include "crypto/crypto_ec.h"
-#include "crypto/crypto_groups.h"
 #include "crypto/crypto_hash.h"
 #include "crypto/crypto_hkdf.h"
 #include "crypto/crypto_hmac.h"
@@ -47,8 +46,8 @@
 #include "crypto/crypto_scrypt.h"
 #include "crypto/crypto_sig.h"
 #include "crypto/crypto_spkac.h"
-#include "crypto/crypto_tls.h"
 #include "crypto/crypto_timing.h"
+#include "crypto/crypto_tls.h"
 #include "crypto/crypto_util.h"
 #include "crypto/crypto_x509.h"