libv8-node 21.7.2.0-x86_64-darwin → 22.5.1.0-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d6e28fd3a35d71869fa478fb1354f85c4c596ee9fef0a5d4e3c2c9543176ba0
-  data.tar.gz: 07b2438b6a6b423754036ac83ae6132b23909d6a58234019f38067801d085380
+  metadata.gz: 2aedac8c624c6c1883d33b9b00ce598225850b8f3c1c026b887406a13ee4feb0
+  data.tar.gz: 28350c34ef92008a30f0d41f7d492d6f2ad91dbbfa8d51e30975cb0600480312
 SHA512:
-  metadata.gz: 8c8d7733723408399b6cdd9d6448f576078428e5f338c4205bdf3c883e538b02417a204bb0c2b28ade6f43297556577e9539b55d01b55a7763ee33e565c34858
-  data.tar.gz: 20d5edbde5b2487b0615c461bacbd0547588420fb0a452c5f680fc8e3a1080bf8ef4fd8d5ba0f49ca3618117a32175ef181078aff6b611bb27eaec8133b1bdab
+  metadata.gz: 914498aea73af82919e26f72f3a7d89c3e0fdeaf4c104076df9ae388389312b4d6188bb4d65d0f21350356fdb89fa827ddd2411b3660e4b3945b0dfda464fd7c
+  data.tar.gz: ce6e55d7fcd8546720bde81b45a721316c6732dbbd7efd748a758308bea1791dd3e3854a098297872d6c1479427a6077f5e594f43247a9a1040c2783bd6b6e56

data/lib/libv8/node/version.rb

@@ -1,7 +1,7 @@
 module Libv8; end
 
 module Libv8::Node
-  VERSION = '21.7.2.0'.freeze
-  NODE_VERSION = '21.7.2'.freeze
-  LIBV8_VERSION = '11.8.172.17'.freeze # from v8/include/v8-version.h
+  VERSION = '22.5.1.0'.freeze
+  NODE_VERSION = '22.5.1'.freeze
+  LIBV8_VERSION = '12.4.254.21'.freeze # from v8/include/v8-version.h
 end

data/vendor/v8/include/cppgc/internal/api-constants.h

@@ -32,7 +32,7 @@ static constexpr uint16_t kFullyConstructedBitMask = uint16_t{1};
 
 static constexpr size_t kPageSize = size_t{1} << 17;
 
-#if defined(V8_TARGET_ARCH_ARM64) && defined(V8_OS_DARWIN)
+#if defined(V8_HOST_ARCH_ARM64) && defined(V8_OS_DARWIN)
 constexpr size_t kGuardPageSize = 0;
 #else
 constexpr size_t kGuardPageSize = 4096;

data/vendor/v8/include/cppgc/type-traits.h

@@ -128,13 +128,13 @@ struct IsSubclassOfBasicMemberTemplate {
  private:
   template <typename T, typename CheckingPolicy, typename StorageType>
   static std::true_type SubclassCheck(
-      BasicMember<T, WeaknessTag, WriteBarrierPolicy, CheckingPolicy,
-                  StorageType>*);
+      const BasicMember<T, WeaknessTag, WriteBarrierPolicy, CheckingPolicy,
+                        StorageType>*);
   static std::false_type SubclassCheck(...);
 
  public:
-  static constexpr bool value =
-      decltype(SubclassCheck(std::declval<BasicMemberCandidate*>()))::value;
+  static constexpr bool value = decltype(SubclassCheck(
+      std::declval<std::decay_t<BasicMemberCandidate>*>()))::value;
 };
 
 template <typename T,
@@ -180,6 +180,14 @@ constexpr bool IsStrictlyBaseOfV =
     std::is_base_of_v<std::decay_t<B>, std::decay_t<D>> &&
     !IsDecayedSameV<B, D>;
 
+template <typename T>
+constexpr bool IsAnyMemberTypeV = false;
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename StorageType>
+constexpr bool IsAnyMemberTypeV<internal::BasicMember<
+    T, WeaknessTag, WriteBarrierPolicy, CheckingPolicy, StorageType>> = true;
+
 }  // namespace internal
 
 /**
@@ -245,6 +253,19 @@ constexpr bool IsWeakV = internal::IsWeak<T>::value;
 template <typename T>
 constexpr bool IsCompleteV = internal::IsComplete<T>::value;
 
+/**
+ * Value is true for member types `Member<T>` and `WeakMember<T>`.
+ */
+template <typename T>
+constexpr bool IsMemberOrWeakMemberTypeV =
+    IsMemberTypeV<T> || IsWeakMemberTypeV<T>;
+
+/**
+ * Value is true for any member type.
+ */
+template <typename T>
+constexpr bool IsAnyMemberTypeV = internal::IsAnyMemberTypeV<std::decay_t<T>>;
+
 }  // namespace cppgc
 
 #endif  // INCLUDE_CPPGC_TYPE_TRAITS_H_

data/vendor/v8/include/v8-array-buffer.h

@@ -318,6 +318,12 @@ class V8_EXPORT ArrayBuffer : public Object {
    */
   std::shared_ptr<BackingStore> GetBackingStore();
 
+  /**
+   * More efficient shortcut for
+   * GetBackingStore()->IsResizableByUserJavaScript().
+   */
+  bool IsResizableByUserJavaScript() const;
+
   /**
    * More efficient shortcut for GetBackingStore()->Data(). The returned pointer
    * is valid as long as the ArrayBuffer is alive.

data/vendor/v8/include/v8-callbacks.h

@@ -327,10 +327,6 @@ using WasmAsyncResolvePromiseCallback = void (*)(
 using WasmLoadSourceMapCallback = Local<String> (*)(Isolate* isolate,
                                                     const char* name);
 
-// --- Callback for checking if WebAssembly GC is enabled ---
-// If the callback returns true, it will also enable Wasm stringrefs.
-using WasmGCEnabledCallback = bool (*)(Local<Context> context);
-
 // --- Callback for checking if WebAssembly imported strings are enabled ---
 using WasmImportedStringsEnabledCallback = bool (*)(Local<Context> context);
 
@@ -342,6 +338,9 @@ using SharedArrayBufferConstructorEnabledCallback =
 using JavaScriptCompileHintsMagicEnabledCallback =
     bool (*)(Local<Context> context);
 
+// --- Callback for checking if WebAssembly JSPI is enabled ---
+using WasmJSPIEnabledCallback = bool (*)(Local<Context> context);
+
 /**
  * HostImportModuleDynamicallyCallback is called when we
  * require the embedder to load a module. This is used as part of the dynamic
@@ -352,11 +351,11 @@ using JavaScriptCompileHintsMagicEnabledCallback =
  *
  * The specifier is the name of the module that should be imported.
  *
- * The import_assertions are import assertions for this request in the form:
+ * The import_attributes are import attributes for this request in the form:
  * [key1, value1, key2, value2, ...] where the keys and values are of type
  * v8::String. Note, unlike the FixedArray passed to ResolveModuleCallback and
  * returned from ModuleRequest::GetImportAssertions(), this array does not
- * contain the source Locations of the assertions.
+ * contain the source Locations of the attributes.
  *
  * The embedder must compile, instantiate, evaluate the Module, and
  * obtain its namespace object.
@@ -368,15 +367,10 @@ using JavaScriptCompileHintsMagicEnabledCallback =
  * fails (e.g. due to stack overflow), the embedder must propagate
  * that exception by returning an empty MaybeLocal.
  */
-using HostImportModuleDynamicallyWithImportAssertionsCallback =
-    MaybeLocal<Promise> (*)(Local<Context> context,
-                            Local<ScriptOrModule> referrer,
-                            Local<String> specifier,
-                            Local<FixedArray> import_assertions);
 using HostImportModuleDynamicallyCallback = MaybeLocal<Promise> (*)(
     Local<Context> context, Local<Data> host_defined_options,
     Local<Value> resource_name, Local<String> specifier,
-    Local<FixedArray> import_assertions);
+    Local<FixedArray> import_attributes);
 
 /**
  * Callback for requesting a compile hint for a function from the embedder. The

data/vendor/v8/include/v8-container.h

@@ -8,6 +8,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <functional>
+
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-object.h"        // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
@@ -43,6 +45,58 @@ class V8_EXPORT Array : public Object {
     return static_cast<Array*>(value);
   }
 
+  /**
+   * Creates a JavaScript array from a provided callback.
+   *
+   * \param context The v8::Context to create the array in.
+   * \param length The length of the array to be created.
+   * \param next_value_callback The callback that is invoked to retrieve
+   *     elements for the array. The embedder can signal that the array
+   *     initialization should be aborted by throwing an exception and returning
+   *     an empty MaybeLocal.
+   * \returns The v8::Array if all elements were constructed successfully and an
+   *     empty MaybeLocal otherwise.
+   */
+  static MaybeLocal<Array> New(
+      Local<Context> context, size_t length,
+      std::function<MaybeLocal<v8::Value>()> next_value_callback);
+
+  enum class CallbackResult {
+    kException,
+    kBreak,
+    kContinue,
+  };
+  using IterationCallback = CallbackResult (*)(uint32_t index,
+                                               Local<Value> element,
+                                               void* data);
+
+  /**
+   * Calls {callback} for every element of this array, passing {callback_data}
+   * as its {data} parameter.
+   * This function will typically be faster than calling {Get()} repeatedly.
+   * As a consequence of being optimized for low overhead, the provided
+   * callback must adhere to the following restrictions:
+   *  - It must not allocate any V8 objects and continue iterating; it may
+   *    allocate (e.g. an error message/object) and then immediately terminate
+   *    the iteration.
+   *  - It must not modify the array being iterated.
+   *  - It must not call back into V8 (unless it can guarantee that such a
+   *    call does not violate the above restrictions, which is difficult).
+   *  - The {Local<Value> element} must not "escape", i.e. must not be assigned
+   *    to any other {Local}. Creating a {Global} from it, or updating a
+   *    v8::TypecheckWitness with it, is safe.
+   * These restrictions may be lifted in the future if use cases arise that
+   * justify a slower but more robust implementation.
+   *
+   * Returns {Nothing} on exception; use a {TryCatch} to catch and handle this
+   * exception.
+   * When the {callback} returns {kException}, iteration is terminated
+   * immediately, returning {Nothing}. By returning {kBreak}, the callback
+   * can request non-exceptional early termination of the iteration.
+   */
+  Maybe<void> Iterate(Local<Context> context, IterationCallback callback,
+                      void* callback_data);
+
  private:
   Array();
   static void CheckCast(Value* obj);

data/vendor/v8/include/v8-context.h

@@ -84,6 +84,29 @@ class V8_EXPORT Context : public Data {
    * created by a previous call to Context::New with the same global
    * template. The state of the global object will be completely reset
    * and only object identify will remain.
+   *
+   * \param internal_fields_deserializer An optional callback used
+   * to deserialize fields set by
+   * v8::Object::SetAlignedPointerInInternalField() in wrapper objects
+   * from the default context snapshot. It should match the
+   * SerializeInternalFieldsCallback() used by
+   * v8::SnapshotCreator::SetDefaultContext() when the default context
+   * snapshot is created. It does not need to be configured if the default
+   * context snapshot contains no wrapper objects with pointer internal
+   * fields, or if no custom startup snapshot is configured
+   * in the v8::CreateParams used to create the isolate.
+   *
+   * \param microtask_queue An optional microtask queue used to manage
+   * the microtasks created in this context. If not set the per-isolate
+   * default microtask queue would be used.
+   *
+   * \param context_data_deserializer An optional callback used
+   * to deserialize embedder data set by
+   * v8::Context::SetAlignedPointerInEmbedderData() in the default
+   * context from the default context snapshot. It does not need to be
+   * configured if the default context snapshot contains no pointer embedder
+   * data, or if no custom startup snapshot is configured in the
+   * v8::CreateParams used to create the isolate.
    */
   static Local<Context> New(
       Isolate* isolate, ExtensionConfiguration* extensions = nullptr,
@@ -91,7 +114,9 @@ class V8_EXPORT Context : public Data {
       MaybeLocal<Value> global_object = MaybeLocal<Value>(),
       DeserializeInternalFieldsCallback internal_fields_deserializer =
           DeserializeInternalFieldsCallback(),
-      MicrotaskQueue* microtask_queue = nullptr);
+      MicrotaskQueue* microtask_queue = nullptr,
+      DeserializeContextDataCallback context_data_deserializer =
+          DeserializeContextDataCallback());
 
   /**
    * Create a new context from a (non-default) context snapshot. There
@@ -103,21 +128,37 @@ class V8_EXPORT Context : public Data {
    * \param context_snapshot_index The index of the context snapshot to
    * deserialize from. Use v8::Context::New for the default snapshot.
    *
-   * \param embedder_fields_deserializer Optional callback to deserialize
-   * internal fields. It should match the SerializeInternalFieldCallback used
-   * to serialize.
+   * \param internal_fields_deserializer An optional callback used
+   * to deserialize fields set by
+   * v8::Object::SetAlignedPointerInInternalField() in wrapper objects
+   * from the default context snapshot. It does not need to be
+   * configured if there are no wrapper objects with no internal
+   * pointer fields in the default context snapshot or if no startup
+   * snapshot is configured when the isolate is created.
    *
    * \param extensions See v8::Context::New.
    *
    * \param global_object See v8::Context::New.
+   *
+   * \param internal_fields_deserializer Similar to
+   * internal_fields_deserializer in v8::Context::New but applies to
+   * the context specified by the context_snapshot_index.
+   *
+   * \param microtask_queue  See v8::Context::New.
+   *
+   * \param context_data_deserializer  Similar to
+   * context_data_deserializer in v8::Context::New but applies to
+   * the context specified by the context_snapshot_index.
    */
   static MaybeLocal<Context> FromSnapshot(
       Isolate* isolate, size_t context_snapshot_index,
-      DeserializeInternalFieldsCallback embedder_fields_deserializer =
+      DeserializeInternalFieldsCallback internal_fields_deserializer =
           DeserializeInternalFieldsCallback(),
       ExtensionConfiguration* extensions = nullptr,
       MaybeLocal<Value> global_object = MaybeLocal<Value>(),
-      MicrotaskQueue* microtask_queue = nullptr);
+      MicrotaskQueue* microtask_queue = nullptr,
+      DeserializeContextDataCallback context_data_deserializer =
+          DeserializeContextDataCallback());
 
   /**
    * Returns an global object that isn't backed by an actual context.
@@ -182,7 +223,7 @@ class V8_EXPORT Context : public Data {
      * parameter. Returns true if the operation completed successfully.
      */
     virtual bool FreezeEmbedderObjectAndGetChildren(
-        Local<Object> obj, std::vector<Local<Object>>& children_out) = 0;
+        Local<Object> obj, LocalVector<Object>& children_out) = 0;
   };
 
   /**
@@ -309,18 +350,6 @@ class V8_EXPORT Context : public Data {
                                                 Local<Context> context);
   void SetAbortScriptExecution(AbortScriptExecutionCallback callback);
 
-  /**
-   * Returns the value that was set or restored by
-   * SetContinuationPreservedEmbedderData(), if any.
-   */
-  Local<Value> GetContinuationPreservedEmbedderData() const;
-
-  /**
-   * Sets a value that will be stored on continuations and reset while the
-   * continuation runs.
-   */
-  void SetContinuationPreservedEmbedderData(Local<Value> context);
-
   /**
    * Set or clear hooks to be invoked for promise lifecycle operations.
    * To clear a hook, set it to an empty v8::Function. Each function will
@@ -436,12 +465,12 @@ void* Context::GetAlignedPointerFromEmbedderData(int index) {
 
 template <class T>
 MaybeLocal<T> Context::GetDataFromSnapshotOnce(size_t index) {
-  auto slot = GetDataFromSnapshotOnce(index);
-  if (slot) {
+  if (auto slot = GetDataFromSnapshotOnce(index); slot) {
     internal::PerformCastCheck(
         internal::ValueHelper::SlotAsValue<T, false>(slot));
+    return Local<T>::FromSlot(slot);
   }
-  return Local<T>::FromSlot(slot);
+  return {};
 }
 
 Context* Context::Cast(v8::Data* data) {

data/vendor/v8/include/v8-embedder-heap.h

@@ -9,6 +9,9 @@
 #include "v8config.h"          // NOLINT(build/include_directory)
 
 namespace v8 {
+namespace internal {
+class TracedHandles;
+}  // namespace internal
 
 class Isolate;
 class Value;
@@ -18,8 +21,17 @@ class Value;
  */
 class V8_EXPORT EmbedderRootsHandler {
  public:
+  enum class RootHandling {
+    kQueryEmbedderForNonDroppableReferences,
+    kDontQueryEmbedderForAnyReference,
+  };
+
   virtual ~EmbedderRootsHandler() = default;
 
+  EmbedderRootsHandler() = default;
+  explicit EmbedderRootsHandler(RootHandling default_traced_reference_handling)
+      : default_traced_reference_handling_(default_traced_reference_handling) {}
+
   /**
    * Returns true if the |TracedReference| handle should be considered as root
    * for the currently running non-tracing garbage collection and false
@@ -31,9 +43,7 @@ class V8_EXPORT EmbedderRootsHandler {
    * |TracedReference|.
    *
    * Note that the `handle` is different from the handle that the embedder holds
-   * for retaining the object. The embedder may use |WrapperClassId()| to
-   * distinguish cases where it wants handles to be treated as roots from not
-   * being treated as roots.
+   * for retaining the object.
    *
    * The concrete implementations must be thread-safe.
    */
@@ -59,6 +69,12 @@ class V8_EXPORT EmbedderRootsHandler {
     ResetRoot(handle);
     return true;
   }
+
+ private:
+  const RootHandling default_traced_reference_handling_ =
+      RootHandling::kQueryEmbedderForNonDroppableReferences;
+
+  friend class internal::TracedHandles;
 };
 
 }  // namespace v8

data/vendor/v8/include/v8-embedder-state-scope.h

@@ -7,12 +7,13 @@
 
 #include <memory>
 
-#include "v8-context.h"       // NOLINT(build/include_directory)
 #include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
 
+class Context;
+
 namespace internal {
 class EmbedderState;
 }  // namespace internal

data/vendor/v8/include/v8-exception.h

@@ -30,14 +30,21 @@ class ThreadLocalTop;
  */
 class V8_EXPORT Exception {
  public:
-  static Local<Value> RangeError(Local<String> message);
-  static Local<Value> ReferenceError(Local<String> message);
-  static Local<Value> SyntaxError(Local<String> message);
-  static Local<Value> TypeError(Local<String> message);
-  static Local<Value> WasmCompileError(Local<String> message);
-  static Local<Value> WasmLinkError(Local<String> message);
-  static Local<Value> WasmRuntimeError(Local<String> message);
-  static Local<Value> Error(Local<String> message);
+  static Local<Value> RangeError(Local<String> message,
+                                 Local<Value> options = {});
+  static Local<Value> ReferenceError(Local<String> message,
+                                     Local<Value> options = {});
+  static Local<Value> SyntaxError(Local<String> message,
+                                  Local<Value> options = {});
+  static Local<Value> TypeError(Local<String> message,
+                                Local<Value> options = {});
+  static Local<Value> WasmCompileError(Local<String> message,
+                                       Local<Value> options = {});
+  static Local<Value> WasmLinkError(Local<String> message,
+                                    Local<Value> options = {});
+  static Local<Value> WasmRuntimeError(Local<String> message,
+                                       Local<Value> options = {});
+  static Local<Value> Error(Local<String> message, Local<Value> options = {});
 
   /**
    * Creates an error message for the given exception.
@@ -206,7 +213,6 @@ class V8_EXPORT TryCatch {
   bool can_continue_ : 1;
   bool capture_message_ : 1;
   bool rethrow_ : 1;
-  bool has_terminated_ : 1;
 
   friend class internal::Isolate;
   friend class internal::ThreadLocalTop;

data/vendor/v8/include/v8-fast-api-calls.h

@@ -254,8 +254,8 @@ class CTypeInfo {
                  // migrated from v8::ApiObject to v8::Local<v8::Value>.
     kAny,        // This is added to enable untyped representation of fast
                  // call arguments for test purposes. It can represent any of
-                 // the other types stored in the same memory as a union (see
-                 // the AnyCType struct declared below). This allows for
+                 // the other types stored in the same memory as a union
+                 // (see AnyCType declared below). This allows for
                  // uniform passing of arguments w.r.t. their location
                  // (in a register or on the stack), independent of their
                  // actual type. It's currently used by the arm64 simulator
@@ -344,7 +344,8 @@ struct FastApiTypedArray : public FastApiTypedArrayBase {
     ValidateIndex(index);
 #endif  // DEBUG
     T tmp;
-    memcpy(&tmp, reinterpret_cast<T*>(data_) + index, sizeof(T));
+    memcpy(&tmp, static_cast<void*>(reinterpret_cast<T*>(data_) + index),
+           sizeof(T));
     return tmp;
   }
 
@@ -434,35 +435,43 @@ class V8_EXPORT CFunctionInfo {
 struct FastApiCallbackOptions;
 
 // Provided for testing.
-struct AnyCType {
+union V8_TRIVIAL_ABI AnyCType {
   AnyCType() : int64_value(0) {}
 
-  union {
-    bool bool_value;
-    int32_t int32_value;
-    uint32_t uint32_value;
-    int64_t int64_value;
-    uint64_t uint64_value;
-    float float_value;
-    double double_value;
-    void* pointer_value;
-    Local<Object> object_value;
-    Local<Array> sequence_value;
-    const FastApiTypedArray<uint8_t>* uint8_ta_value;
-    const FastApiTypedArray<int32_t>* int32_ta_value;
-    const FastApiTypedArray<uint32_t>* uint32_ta_value;
-    const FastApiTypedArray<int64_t>* int64_ta_value;
-    const FastApiTypedArray<uint64_t>* uint64_ta_value;
-    const FastApiTypedArray<float>* float_ta_value;
-    const FastApiTypedArray<double>* double_ta_value;
-    const FastOneByteString* string_value;
-    FastApiCallbackOptions* options_value;
-  };
+#if defined(V8_ENABLE_LOCAL_OFF_STACK_CHECK) && V8_HAS_ATTRIBUTE_TRIVIAL_ABI
+  // In this case, Local<T> is not trivially copyable and the implicit
+  // copy constructor and copy assignment for the union are deleted.
+  AnyCType(const AnyCType& other) : int64_value(other.int64_value) {}
+  AnyCType& operator=(const AnyCType& other) {
+    int64_value = other.int64_value;
+    return *this;
+  }
+#endif
+
+  bool bool_value;
+  int32_t int32_value;
+  uint32_t uint32_value;
+  int64_t int64_value;
+  uint64_t uint64_value;
+  float float_value;
+  double double_value;
+  void* pointer_value;
+  Local<Object> object_value;
+  Local<Array> sequence_value;
+  const FastApiTypedArray<uint8_t>* uint8_ta_value;
+  const FastApiTypedArray<int32_t>* int32_ta_value;
+  const FastApiTypedArray<uint32_t>* uint32_ta_value;
+  const FastApiTypedArray<int64_t>* int64_ta_value;
+  const FastApiTypedArray<uint64_t>* uint64_ta_value;
+  const FastApiTypedArray<float>* float_ta_value;
+  const FastApiTypedArray<double>* double_ta_value;
+  const FastOneByteString* string_value;
+  FastApiCallbackOptions* options_value;
 };
 
 static_assert(
     sizeof(AnyCType) == 8,
-    "The AnyCType struct should have size == 64 bits, as this is assumed "
+    "The union AnyCType should have size == 64 bits, as this is assumed "
     "by EffectControlLinearizer.");
 
 class V8_EXPORT CFunction {

data/vendor/v8/include/v8-forward.h

@@ -27,6 +27,7 @@ class Context;
 class DataView;
 class Data;
 class Date;
+class DictionaryTemplate;
 class Extension;
 class External;
 class FixedArray;