@encharm/cws 4.0.2 → 4.3.0

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

@@ -41,6 +41,9 @@
 #define RSA_PSS_SALTLEN_AUTO -2
 #endif
 
+#if defined(NODE_OPENSSL_DEFAULT_CIPHER_LIST)
+#define DEFAULT_CIPHER_LIST_CORE NODE_OPENSSL_DEFAULT_CIPHER_LIST
+#else
 // TLSv1.3 suites start with TLS_, and are the OpenSSL defaults, see:
 //   https://www.openssl.org/docs/man1.1.1/man3/SSL_CTX_set_ciphersuites.html
 #define DEFAULT_CIPHER_LIST_CORE \
@@ -68,7 +71,8 @@
                                  "!PSK:"                            \
                                  "!SRP:"                            \
                                  "!CAMELLIA"
-#endif
+#endif  // NODE_OPENSSL_DEFAULT_CIPHER_LIST
+#endif  // HAVE_OPENSSL
 
 namespace node {
 

package/src/headers/{12 → 18}/node_context_data.h

@@ -25,11 +25,16 @@ namespace node {
 #define NODE_CONTEXT_TAG 35
 #endif
 
+#ifndef NODE_BINDING_LIST
+#define NODE_BINDING_LIST_INDEX 36
+#endif
+
 enum ContextEmbedderIndex {
   kEnvironment = NODE_CONTEXT_EMBEDDER_DATA_INDEX,
   kSandboxObject = NODE_CONTEXT_SANDBOX_OBJECT_INDEX,
   kAllowWasmCodeGeneration = NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX,
   kContextTag = NODE_CONTEXT_TAG,
+  kBindingListIndex = NODE_BINDING_LIST_INDEX
 };
 
 }  // namespace node

package/src/headers/{12 → 18}/node_contextify.h

@@ -8,13 +8,37 @@
 #include "node_errors.h"
 
 namespace node {
+class ExternalReferenceRegistry;
+
 namespace contextify {
 
+class MicrotaskQueueWrap : public BaseObject {
+ public:
+  MicrotaskQueueWrap(Environment* env, v8::Local<v8::Object> obj);
+
+  const std::shared_ptr<v8::MicrotaskQueue>& microtask_queue() const;
+
+  static void Init(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  // This could have methods for running the microtask queue, if we ever decide
+  // to make that fully customizable from userland.
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(MicrotaskQueueWrap)
+  SET_SELF_SIZE(MicrotaskQueueWrap)
+
+ private:
+  std::shared_ptr<v8::MicrotaskQueue> microtask_queue_;
+};
+
 struct ContextOptions {
   v8::Local<v8::String> name;
   v8::Local<v8::String> origin;
   v8::Local<v8::Boolean> allow_code_gen_strings;
   v8::Local<v8::Boolean> allow_code_gen_wasm;
+  BaseObjectPtr<MicrotaskQueueWrap> microtask_queue_wrap;
 };
 
 class ContextifyContext {
@@ -31,6 +55,7 @@ class ContextifyContext {
                                               v8::Local<v8::Object> sandbox_obj,
                                               const ContextOptions& options);
   static void Init(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
   static ContextifyContext* ContextFromContextifiedSandbox(
       Environment* env,
@@ -49,8 +74,13 @@ class ContextifyContext {
   }
 
   inline v8::Local<v8::Object> sandbox() const {
-    return v8::Local<v8::Object>::Cast(
-        context()->GetEmbedderData(ContextEmbedderIndex::kSandboxObject));
+    return context()->GetEmbedderData(ContextEmbedderIndex::kSandboxObject)
+        .As<v8::Object>();
+  }
+
+  inline std::shared_ptr<v8::MicrotaskQueue> microtask_queue() const {
+    if (!microtask_queue_wrap_) return {};
+    return microtask_queue_wrap_->microtask_queue();
   }
 
 
@@ -102,6 +132,7 @@ class ContextifyContext {
       const v8::PropertyCallbackInfo<v8::Boolean>& args);
   Environment* const env_;
   v8::Global<v8::Context> context_;
+  BaseObjectPtr<MicrotaskQueueWrap> microtask_queue_wrap_;
 };
 
 class ContextifyScript : public BaseObject {
@@ -114,6 +145,7 @@ class ContextifyScript : public BaseObject {
   ~ContextifyScript() override;
 
   static void Init(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static bool InstanceOf(Environment* env, const v8::Local<v8::Value>& args);
   static void CreateCachedData(
@@ -125,6 +157,7 @@ class ContextifyScript : public BaseObject {
                           const bool display_errors,
                           const bool break_on_sigint,
                           const bool break_on_first_line,
+                          std::shared_ptr<v8::MicrotaskQueue> microtask_queue,
                           const v8::FunctionCallbackInfo<v8::Value>& args);
 
   inline uint32_t id() { return id_; }
@@ -146,6 +179,8 @@ class CompiledFnEntry final : public BaseObject {
                   v8::Local<v8::ScriptOrModule> script);
   ~CompiledFnEntry();
 
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override { return true; }
+
  private:
   uint32_t id_;
   v8::Global<v8::ScriptOrModule> script_;

package/src/headers/{10/node_javascript.h → 18/node_crypto.h}

@@ -19,23 +19,39 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-#ifndef SRC_NODE_JAVASCRIPT_H_
-#define SRC_NODE_JAVASCRIPT_H_
+#ifndef SRC_NODE_CRYPTO_H_
+#define SRC_NODE_CRYPTO_H_
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "node_internals.h"
-
-namespace node {
-
-void DefineJavaScript(Environment* env, v8::Local<v8::Object> target);
-void DefineJavaScriptHash(Environment* env, v8::Local<v8::Object> target);
-v8::Local<v8::String> NodePerContextSource(v8::Isolate* isolate);
-v8::Local<v8::String> LoadersBootstrapperSource(Environment* env);
-v8::Local<v8::String> NodeBootstrapperSource(Environment* env);
-
-}  // namespace node
+// 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_groups.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_tls.h"
+#include "crypto/crypto_timing.h"
+#include "crypto/crypto_util.h"
+#include "crypto/crypto_x509.h"
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#endif  // SRC_NODE_JAVASCRIPT_H_
+#endif  // SRC_NODE_CRYPTO_H_

package/src/headers/{12 → 18}/node_errors.h

@@ -3,6 +3,7 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "debug_utils-inl.h"
 #include "env.h"
 #include "v8.h"
 
@@ -31,18 +32,46 @@ void OnFatalError(const char* location, const char* message);
   V(ERR_BUFFER_CONTEXT_NOT_AVAILABLE, Error)                                   \
   V(ERR_BUFFER_OUT_OF_BOUNDS, RangeError)                                      \
   V(ERR_BUFFER_TOO_LARGE, Error)                                               \
+  V(ERR_CLOSED_MESSAGE_PORT, Error)                                            \
   V(ERR_CONSTRUCT_CALL_REQUIRED, TypeError)                                    \
   V(ERR_CONSTRUCT_CALL_INVALID, TypeError)                                     \
+  V(ERR_CRYPTO_INITIALIZATION_FAILED, Error)                                   \
+  V(ERR_CRYPTO_INVALID_AUTH_TAG, TypeError)                                    \
+  V(ERR_CRYPTO_INVALID_COUNTER, TypeError)                                     \
+  V(ERR_CRYPTO_INVALID_CURVE, TypeError)                                       \
+  V(ERR_CRYPTO_INVALID_DIGEST, TypeError)                                      \
+  V(ERR_CRYPTO_INVALID_IV, TypeError)                                          \
+  V(ERR_CRYPTO_INVALID_JWK, TypeError)                                         \
+  V(ERR_CRYPTO_INVALID_KEYLEN, RangeError)                                     \
+  V(ERR_CRYPTO_INVALID_KEYPAIR, RangeError)                                    \
+  V(ERR_CRYPTO_INVALID_KEYTYPE, RangeError)                                    \
+  V(ERR_CRYPTO_INVALID_MESSAGELEN, RangeError)                                 \
+  V(ERR_CRYPTO_INVALID_SCRYPT_PARAMS, RangeError)                              \
+  V(ERR_CRYPTO_INVALID_STATE, Error)                                           \
+  V(ERR_CRYPTO_INVALID_TAG_LENGTH, RangeError)                                 \
+  V(ERR_CRYPTO_JWK_UNSUPPORTED_CURVE, Error)                                   \
+  V(ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE, Error)                                \
+  V(ERR_CRYPTO_OPERATION_FAILED, Error)                                        \
+  V(ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH, RangeError)                           \
   V(ERR_CRYPTO_UNKNOWN_CIPHER, Error)                                          \
   V(ERR_CRYPTO_UNKNOWN_DH_GROUP, Error)                                        \
+  V(ERR_CRYPTO_UNSUPPORTED_OPERATION, Error)                                   \
+  V(ERR_CRYPTO_JOB_INIT_FAILED, Error)                                         \
+  V(ERR_DLOPEN_DISABLED, Error)                                                \
+  V(ERR_DLOPEN_FAILED, Error)                                                  \
   V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE, Error)                            \
+  V(ERR_INVALID_ADDRESS, Error)                                                \
   V(ERR_INVALID_ARG_VALUE, TypeError)                                          \
   V(ERR_OSSL_EVP_INVALID_DIGEST, Error)                                        \
   V(ERR_INVALID_ARG_TYPE, TypeError)                                           \
+  V(ERR_INVALID_OBJECT_DEFINE_PROPERTY, TypeError)                             \
+  V(ERR_INVALID_MODULE, Error)                                                 \
+  V(ERR_INVALID_THIS, TypeError)                                               \
   V(ERR_INVALID_TRANSFER_OBJECT, TypeError)                                    \
   V(ERR_MEMORY_ALLOCATION_FAILED, Error)                                       \
+  V(ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE, Error)                             \
   V(ERR_MISSING_ARGS, TypeError)                                               \
-  V(ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST, TypeError)                      \
+  V(ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST, TypeError)                      \
   V(ERR_MISSING_PASSPHRASE, TypeError)                                         \
   V(ERR_MISSING_PLATFORM_FOR_WORKER, Error)                                    \
   V(ERR_NON_CONTEXT_AWARE_DISABLED, Error)                                     \
@@ -51,32 +80,42 @@ void OnFatalError(const char* location, const char* message);
   V(ERR_SCRIPT_EXECUTION_TIMEOUT, Error)                                       \
   V(ERR_STRING_TOO_LONG, Error)                                                \
   V(ERR_TLS_INVALID_PROTOCOL_METHOD, TypeError)                                \
-  V(ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER, 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)                                                         \
-  inline v8::Local<v8::Value> code(v8::Isolate* isolate,                      \
-                                   const char* message)       {               \
-    v8::Local<v8::String> js_code = OneByteString(isolate, #code);            \
-    v8::Local<v8::String> js_msg = OneByteString(isolate, message);           \
-    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;                                                                 \
-  }                                                                           \
-  inline void THROW_ ## code(v8::Isolate* isolate, const char* message) {     \
-    isolate->ThrowException(code(isolate, message));                          \
-  }                                                                           \
-  inline void THROW_ ## code(Environment* env, const char* message) {         \
-    THROW_ ## code(env->isolate(), message);                                  \
+#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)
+ERRORS_WITH_CODE(V)
 #undef V
 
 // Errors with predefined static messages
@@ -84,17 +123,46 @@ void OnFatalError(const char* location, const char* message);
 #define PREDEFINED_ERROR_MESSAGES(V)                                           \
   V(ERR_BUFFER_CONTEXT_NOT_AVAILABLE,                                          \
     "Buffer is not available for the current Context")                         \
+  V(ERR_CLOSED_MESSAGE_PORT, "Cannot send data on closed MessagePort")         \
   V(ERR_CONSTRUCT_CALL_INVALID, "Constructor cannot be called")                \
   V(ERR_CONSTRUCT_CALL_REQUIRED, "Cannot call constructor without `new`")      \
+  V(ERR_CRYPTO_INITIALIZATION_FAILED, "Initialization failed")                 \
+  V(ERR_CRYPTO_INVALID_AUTH_TAG, "Invalid authentication tag")                 \
+  V(ERR_CRYPTO_INVALID_COUNTER, "Invalid counter")                             \
+  V(ERR_CRYPTO_INVALID_CURVE, "Invalid EC curve name")                         \
+  V(ERR_CRYPTO_INVALID_DIGEST, "Invalid digest")                               \
+  V(ERR_CRYPTO_INVALID_IV, "Invalid initialization vector")                    \
+  V(ERR_CRYPTO_INVALID_JWK, "Invalid JWK format")                              \
+  V(ERR_CRYPTO_INVALID_KEYLEN, "Invalid key length")                           \
+  V(ERR_CRYPTO_INVALID_KEYPAIR, "Invalid key pair")                            \
+  V(ERR_CRYPTO_INVALID_KEYTYPE, "Invalid key type")                            \
+  V(ERR_CRYPTO_INVALID_MESSAGELEN, "Invalid message length")                   \
+  V(ERR_CRYPTO_INVALID_SCRYPT_PARAMS, "Invalid scrypt params")                 \
+  V(ERR_CRYPTO_INVALID_STATE, "Invalid state")                                 \
+  V(ERR_CRYPTO_INVALID_TAG_LENGTH, "Invalid taglength")                        \
+  V(ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE, "Unsupported JWK Key Type.")          \
+  V(ERR_CRYPTO_OPERATION_FAILED, "Operation failed")                           \
+  V(ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH,                                       \
+    "Input buffers must have the same byte length")                            \
   V(ERR_CRYPTO_UNKNOWN_CIPHER, "Unknown cipher")                               \
   V(ERR_CRYPTO_UNKNOWN_DH_GROUP, "Unknown DH group")                           \
+  V(ERR_CRYPTO_UNSUPPORTED_OPERATION, "Unsupported crypto operation")          \
+  V(ERR_CRYPTO_JOB_INIT_FAILED, "Failed to initialize crypto job config")      \
+  V(ERR_DLOPEN_FAILED, "DLOpen failed")                                        \
   V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE,                                   \
     "Context not associated with Node.js environment")                         \
+  V(ERR_INVALID_ADDRESS, "Invalid socket address")                             \
+  V(ERR_INVALID_MODULE, "No such module")                                      \
+  V(ERR_INVALID_THIS, "Value of \"this\" is the wrong type")                   \
   V(ERR_INVALID_TRANSFER_OBJECT, "Found invalid object in transferList")       \
   V(ERR_MEMORY_ALLOCATION_FAILED, "Failed to allocate memory")                 \
   V(ERR_OSSL_EVP_INVALID_DIGEST, "Invalid digest used")                        \
-  V(ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST,                                 \
-    "MessagePort was found in message but not listed in transferList")         \
+  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")                                                        \
@@ -102,8 +170,6 @@ void OnFatalError(const char* location, const char* message);
     "Loading non context-aware native modules has been disabled")              \
   V(ERR_SCRIPT_EXECUTION_INTERRUPTED,                                          \
     "Script execution was interrupted by `SIGINT`")                            \
-  V(ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER,                           \
-    "Cannot serialize externalized SharedArrayBuffer")                         \
   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")                   \

package/src/headers/18/node_external_reference.h

@@ -0,0 +1,145 @@
+#ifndef SRC_NODE_EXTERNAL_REFERENCE_H_
+#define SRC_NODE_EXTERNAL_REFERENCE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include <vector>
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+namespace node {
+
+using CFunctionCallback = void (*)(v8::Local<v8::Value> receiver);
+
+// This class manages the external references from the V8 heap
+// to the C++ addresses in Node.js.
+class ExternalReferenceRegistry {
+ public:
+  ExternalReferenceRegistry();
+
+#define ALLOWED_EXTERNAL_REFERENCE_TYPES(V)                                    \
+  V(CFunctionCallback)                                                         \
+  V(const v8::CFunctionInfo*)                                                  \
+  V(v8::FunctionCallback)                                                      \
+  V(v8::AccessorGetterCallback)                                                \
+  V(v8::AccessorSetterCallback)                                                \
+  V(v8::AccessorNameGetterCallback)                                            \
+  V(v8::AccessorNameSetterCallback)                                            \
+  V(v8::GenericNamedPropertyDefinerCallback)                                   \
+  V(v8::GenericNamedPropertyDeleterCallback)                                   \
+  V(v8::GenericNamedPropertyEnumeratorCallback)                                \
+  V(v8::GenericNamedPropertyQueryCallback)                                     \
+  V(v8::GenericNamedPropertySetterCallback)
+
+#define V(ExternalReferenceType)                                               \
+  void Register(ExternalReferenceType addr) { RegisterT(addr); }
+  ALLOWED_EXTERNAL_REFERENCE_TYPES(V)
+#undef V
+
+  // This can be called only once.
+  const std::vector<intptr_t>& external_references();
+
+  bool is_empty() { return external_references_.empty(); }
+
+ private:
+  template <typename T>
+  void RegisterT(T* address) {
+    external_references_.push_back(reinterpret_cast<intptr_t>(address));
+  }
+  bool is_finalized_ = false;
+  std::vector<intptr_t> external_references_;
+};
+
+#define EXTERNAL_REFERENCE_BINDING_LIST_BASE(V)                                \
+  V(async_wrap)                                                                \
+  V(binding)                                                                   \
+  V(blob)                                                                      \
+  V(buffer)                                                                    \
+  V(contextify)                                                                \
+  V(credentials)                                                               \
+  V(env_var)                                                                   \
+  V(errors)                                                                    \
+  V(fs)                                                                        \
+  V(fs_dir)                                                                    \
+  V(fs_event_wrap)                                                             \
+  V(handle_wrap)                                                               \
+  V(heap_utils)                                                                \
+  V(messaging)                                                                 \
+  V(mksnapshot)                                                                \
+  V(native_module)                                                             \
+  V(options)                                                                   \
+  V(os)                                                                        \
+  V(performance)                                                               \
+  V(process_methods)                                                           \
+  V(process_object)                                                            \
+  V(report)                                                                    \
+  V(task_queue)                                                                \
+  V(tcp_wrap)                                                                  \
+  V(tty_wrap)                                                                  \
+  V(url)                                                                       \
+  V(util)                                                                      \
+  V(pipe_wrap)                                                                 \
+  V(serdes)                                                                    \
+  V(string_decoder)                                                            \
+  V(stream_wrap)                                                               \
+  V(signal_wrap)                                                               \
+  V(trace_events)                                                              \
+  V(timers)                                                                    \
+  V(types)                                                                     \
+  V(uv)                                                                        \
+  V(v8)                                                                        \
+  V(zlib)                                                                      \
+  V(wasm_web_api)                                                              \
+  V(worker)
+
+#if NODE_HAVE_I18N_SUPPORT
+#define EXTERNAL_REFERENCE_BINDING_LIST_I18N(V) V(icu)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_I18N(V)
+#endif  // NODE_HAVE_I18N_SUPPORT
+
+#if HAVE_INSPECTOR
+#define EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)                           \
+  V(inspector)                                                                 \
+  V(profiler)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)
+#endif  // HAVE_INSPECTOR
+
+#if HAVE_DTRACE || HAVE_ETW
+#define EXTERNAL_REFERENCE_BINDING_LIST_DTRACE(V) V(dtrace)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_DTRACE(V)
+#endif
+
+#if HAVE_OPENSSL
+#define EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V) V(crypto) V(tls_wrap)
+#else
+#define EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V)
+#endif  // HAVE_OPENSSL
+
+#define EXTERNAL_REFERENCE_BINDING_LIST(V)                                     \
+  EXTERNAL_REFERENCE_BINDING_LIST_BASE(V)                                      \
+  EXTERNAL_REFERENCE_BINDING_LIST_INSPECTOR(V)                                 \
+  EXTERNAL_REFERENCE_BINDING_LIST_I18N(V)                                      \
+  EXTERNAL_REFERENCE_BINDING_LIST_DTRACE(V)                                    \
+  EXTERNAL_REFERENCE_BINDING_LIST_CRYPTO(V)
+
+}  // namespace node
+
+// Declare all the external reference registration functions here,
+// and define them later with #NODE_MODULE_EXTERNAL_REFERENCE(modname, func);
+#define V(modname)                                                             \
+  void _register_external_reference_##modname(                                 \
+      node::ExternalReferenceRegistry* registry);
+EXTERNAL_REFERENCE_BINDING_LIST(V)
+#undef V
+
+#define NODE_MODULE_EXTERNAL_REFERENCE(modname, func)                          \
+  void _register_external_reference_##modname(                                 \
+      node::ExternalReferenceRegistry* registry) {                             \
+    func(registry);                                                            \
+  }
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_EXTERNAL_REFERENCE_H_

package/src/headers/{13 → 18}/node_file-inl.h

@@ -28,7 +28,7 @@ void FSContinuationData::MaybeSetFirstPath(const std::string& path) {
 }
 
 std::string FSContinuationData::PopPath() {
-  CHECK_GT(paths_.size(), 0);
+  CHECK(!paths_.empty());
   std::string path = std::move(paths_.back());
   paths_.pop_back();
   return path;
@@ -39,11 +39,13 @@ void FSContinuationData::Done(int result) {
   done_cb_(req_);
 }
 
-FSReqBase::FSReqBase(Environment* env,
-          v8::Local<v8::Object> req,
-          AsyncWrap::ProviderType type,
-          bool use_bigint)
-  : ReqWrap(env, req, type), use_bigint_(use_bigint) {
+FSReqBase::FSReqBase(BindingData* binding_data,
+                     v8::Local<v8::Object> req,
+                     AsyncWrap::ProviderType type,
+                     bool use_bigint)
+  : ReqWrap(binding_data->env(), req, type),
+    use_bigint_(use_bigint),
+    binding_data_(binding_data) {
 }
 
 void FSReqBase::Init(const char* syscall,
@@ -72,9 +74,13 @@ FSReqBase::Init(const char* syscall, size_t len, enum encoding encoding) {
   return buffer_;
 }
 
-FSReqCallback::FSReqCallback(Environment* env,
-                             v8::Local<v8::Object> req, bool use_bigint)
-  : FSReqBase(env, req, AsyncWrap::PROVIDER_FSREQCALLBACK, use_bigint) {}
+FSReqCallback::FSReqCallback(BindingData* binding_data,
+                             v8::Local<v8::Object> req,
+                             bool use_bigint)
+  : FSReqBase(binding_data,
+              req,
+              AsyncWrap::PROVIDER_FSREQCALLBACK,
+              use_bigint) {}
 
 template <typename NativeT, typename V8T>
 void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
@@ -112,18 +118,18 @@ void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
 #undef SET_FIELD_WITH_STAT
 }
 
-v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
+v8::Local<v8::Value> FillGlobalStatsArray(BindingData* binding_data,
                                           const bool use_bigint,
                                           const uv_stat_t* s,
                                           const bool second) {
   const ptrdiff_t offset =
       second ? static_cast<ptrdiff_t>(FsStatsOffset::kFsStatsFieldsNumber) : 0;
   if (use_bigint) {
-    auto* const arr = env->fs_stats_field_bigint_array();
+    auto* const arr = &binding_data->stats_field_bigint_array;
     FillStatsArray(arr, s, offset);
     return arr->GetJSArray();
   } else {
-    auto* const arr = env->fs_stats_field_array();
+    auto* const arr = &binding_data->stats_field_array;
     FillStatsArray(arr, s, offset);
     return arr->GetJSArray();
   }
@@ -131,7 +137,9 @@ v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
 
 template <typename AliasedBufferT>
 FSReqPromise<AliasedBufferT>*
-FSReqPromise<AliasedBufferT>::New(Environment* env, bool use_bigint) {
+FSReqPromise<AliasedBufferT>::New(BindingData* binding_data,
+                                  bool use_bigint) {
+  Environment* env = binding_data->env();
   v8::Local<v8::Object> obj;
   if (!env->fsreqpromise_constructor_template()
            ->NewInstance(env->context())
@@ -143,7 +151,7 @@ FSReqPromise<AliasedBufferT>::New(Environment* env, bool use_bigint) {
       obj->Set(env->context(), env->promise_string(), resolver).IsNothing()) {
     return nullptr;
   }
-  return new FSReqPromise(env, obj, use_bigint);
+  return new FSReqPromise(binding_data, obj, use_bigint);
 }
 
 template <typename AliasedBufferT>
@@ -154,12 +162,15 @@ FSReqPromise<AliasedBufferT>::~FSReqPromise() {
 
 template <typename AliasedBufferT>
 FSReqPromise<AliasedBufferT>::FSReqPromise(
-    Environment* env,
+    BindingData* binding_data,
     v8::Local<v8::Object> obj,
     bool use_bigint)
-  : FSReqBase(env, obj, AsyncWrap::PROVIDER_FSREQPROMISE, use_bigint),
+  : FSReqBase(binding_data,
+              obj,
+              AsyncWrap::PROVIDER_FSREQPROMISE,
+              use_bigint),
     stats_field_array_(
-        env->isolate(),
+        env()->isolate(),
         static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)) {}
 
 template <typename AliasedBufferT>
@@ -208,15 +219,21 @@ void FSReqPromise<AliasedBufferT>::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackField("stats_field_array", stats_field_array_);
 }
 
-FSReqBase* GetReqWrap(Environment* env, v8::Local<v8::Value> value,
+FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
+                      int index,
                       bool use_bigint) {
+  v8::Local<v8::Value> value = args[index];
   if (value->IsObject()) {
     return Unwrap<FSReqBase>(value.As<v8::Object>());
-  } else if (value->StrictEquals(env->fs_use_promises_symbol())) {
+  }
+
+  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+  Environment* env = binding_data->env();
+  if (value->StrictEquals(env->fs_use_promises_symbol())) {
     if (use_bigint) {
-      return FSReqPromise<AliasedBigUint64Array>::New(env, use_bigint);
+      return FSReqPromise<AliasedBigUint64Array>::New(binding_data, use_bigint);
     } else {
-      return FSReqPromise<AliasedFloat64Array>::New(env, use_bigint);
+      return FSReqPromise<AliasedFloat64Array>::New(binding_data, use_bigint);
     }
   }
   return nullptr;