libv8-node 21.7.2.0-aarch64-linux-musl → 24.12.0.0-aarch64-linux-musl

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

@@ -182,7 +182,7 @@ class PersistentValueMapBase {
    */
   Local<V> Get(const K& key) {
     V* p = FromVal(Traits::Get(&impl_, key));
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
     if (p == nullptr) return Local<V>();
 #endif
     return Local<V>::New(isolate_, p);
@@ -240,8 +240,9 @@ class PersistentValueMapBase {
         : value_(other.value_) { }
 
     Local<V> NewLocal(Isolate* isolate) const {
-      return Local<V>::New(
-          isolate, internal::ValueHelper::SlotAsValue<V>(FromVal(value_)));
+      return Local<V>::New(isolate,
+                           internal::ValueHelper::SlotAsValue<V>(
+                               reinterpret_cast<internal::Address*>(value_)));
     }
     bool IsEmpty() const {
       return value_ == kPersistentContainerNotFound;
@@ -298,7 +299,8 @@ class PersistentValueMapBase {
   typename Traits::Impl* impl() { return &impl_; }
 
   static V* FromVal(PersistentContainerValue v) {
-    return reinterpret_cast<V*>(v);
+    return internal::ValueHelper::SlotAsValue<V>(
+        reinterpret_cast<internal::Address*>(v));
   }
 
   static PersistentContainerValue ClearAndLeak(Global<V>* persistent) {
@@ -318,7 +320,7 @@ class PersistentValueMapBase {
    */
   static Global<V> Release(PersistentContainerValue v) {
     Global<V> p;
-    p.slot() = reinterpret_cast<internal::Address*>(FromVal(v));
+    p.slot() = reinterpret_cast<internal::Address*>(v);
     if (Traits::kCallbackType != kNotWeak && p.IsWeak()) {
       Traits::DisposeCallbackData(
           p.template ClearWeak<typename Traits::WeakCallbackDataType>());
@@ -328,8 +330,8 @@ class PersistentValueMapBase {
 
   void RemoveWeak(const K& key) {
     Global<V> p;
-    p.slot() = reinterpret_cast<internal::Address*>(
-        FromVal(Traits::Remove(&impl_, key)));
+    p.slot() =
+        reinterpret_cast<internal::Address*>(Traits::Remove(&impl_, key));
     p.Reset();
   }
 
@@ -345,8 +347,7 @@ class PersistentValueMapBase {
                                     PersistentContainerValue value) {
     bool hasValue = value != kPersistentContainerNotFound;
     if (hasValue) {
-      returnValue->SetInternal(
-          *reinterpret_cast<internal::Address*>(FromVal(value)));
+      returnValue->SetInternal(*reinterpret_cast<internal::Address*>(value));
     }
     return hasValue;
   }
@@ -543,122 +544,6 @@ class StdGlobalValueMap : public GlobalValueMap<K, V, Traits> {
       : GlobalValueMap<K, V, Traits>(isolate) {}
 };
 
-class DefaultPersistentValueVectorTraits {
- public:
-  typedef std::vector<PersistentContainerValue> Impl;
-
-  static void Append(Impl* impl, PersistentContainerValue value) {
-    impl->push_back(value);
-  }
-  static bool IsEmpty(const Impl* impl) {
-    return impl->empty();
-  }
-  static size_t Size(const Impl* impl) {
-    return impl->size();
-  }
-  static PersistentContainerValue Get(const Impl* impl, size_t i) {
-    return (i < impl->size()) ? impl->at(i) : kPersistentContainerNotFound;
-  }
-  static void ReserveCapacity(Impl* impl, size_t capacity) {
-    impl->reserve(capacity);
-  }
-  static void Clear(Impl* impl) {
-    impl->clear();
-  }
-};
-
-/**
- * A vector wrapper that safely stores Global values.
- * C++11 embedders don't need this class, as they can use Global
- * directly in std containers.
- *
- * This class relies on a backing vector implementation, whose type and methods
- * are described by the Traits class. The backing map will handle values of type
- * PersistentContainerValue, with all conversion into and out of V8
- * handles being transparently handled by this class.
- */
-template <typename V, typename Traits = DefaultPersistentValueVectorTraits>
-class V8_DEPRECATE_SOON("Use std::vector<Global<V>>.") PersistentValueVector {
- public:
-  explicit PersistentValueVector(Isolate* isolate) : isolate_(isolate) { }
-
-  ~PersistentValueVector() {
-    Clear();
-  }
-
-  /**
-   * Append a value to the vector.
-   */
-  void Append(Local<V> value) {
-    Global<V> persistent(isolate_, value);
-    Traits::Append(&impl_, ClearAndLeak(&persistent));
-  }
-
-  /**
-   * Append a persistent's value to the vector.
-   */
-  void Append(Global<V> persistent) {
-    Traits::Append(&impl_, ClearAndLeak(&persistent));
-  }
-
-  /**
-   * Are there any values in the vector?
-   */
-  bool IsEmpty() const {
-    return Traits::IsEmpty(&impl_);
-  }
-
-  /**
-   * How many elements are in the vector?
-   */
-  size_t Size() const {
-    return Traits::Size(&impl_);
-  }
-
-  /**
-   * Retrieve the i-th value in the vector.
-   */
-  Local<V> Get(size_t index) const {
-    return Local<V>::New(isolate_, internal::ValueHelper::SlotAsValue<V>(
-                                       FromVal(Traits::Get(&impl_, index))));
-  }
-
-  /**
-   * Remove all elements from the vector.
-   */
-  void Clear() {
-    size_t length = Traits::Size(&impl_);
-    for (size_t i = 0; i < length; i++) {
-      Global<V> p;
-      p.slot() =
-          reinterpret_cast<internal::Address>(FromVal(Traits::Get(&impl_, i)));
-    }
-    Traits::Clear(&impl_);
-  }
-
-  /**
-   * Reserve capacity in the vector.
-   * (Efficiency gains depend on the backing implementation.)
-   */
-  void ReserveCapacity(size_t capacity) {
-    Traits::ReserveCapacity(&impl_, capacity);
-  }
-
- private:
-  static PersistentContainerValue ClearAndLeak(Global<V>* persistent) {
-    auto slot = persistent->slot();
-    persistent->Clear();
-    return reinterpret_cast<PersistentContainerValue>(slot);
-  }
-
-  static V* FromVal(PersistentContainerValue v) {
-    return reinterpret_cast<V*>(v);
-  }
-
-  Isolate* isolate_;
-  typename Traits::Impl impl_;
-};
-
 }  // namespace v8
 
 #endif  // V8_UTIL_H

data/vendor/v8/include/v8-value-serializer-version.h

@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef INCLUDE_V8_VALUE_SERIALIZER_VERSION_H_
+#define INCLUDE_V8_VALUE_SERIALIZER_VERSION_H_
+
 /**
  * Compile-time constants.
  *
@@ -10,9 +13,6 @@
  * to V8.
  */
 
-#ifndef INCLUDE_V8_VALUE_SERIALIZER_VERSION_H_
-#define INCLUDE_V8_VALUE_SERIALIZER_VERSION_H_
-
 #include <stdint.h>
 
 namespace v8 {

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

@@ -16,7 +16,7 @@
  */
 namespace v8 {
 
-class Primiitive;
+class Primitive;
 class Numeric;
 class BigInt;
 class Int32;
@@ -63,7 +63,7 @@ class V8_EXPORT Value : public Data {
    * conversion to boolean, i.e. the result of `Boolean(value)` in JS, whereas
    * this checks `value === true`.
    */
-  bool IsTrue() const;
+  V8_INLINE bool IsTrue() const;
 
   /**
    * Returns true if this value is false.
@@ -72,7 +72,7 @@ class V8_EXPORT Value : public Data {
    * conversion to boolean, i.e. the result of `!Boolean(value)` in JS, whereas
    * this checks `value === false`.
    */
-  bool IsFalse() const;
+  V8_INLINE bool IsFalse() const;
 
   /**
    * Returns true if this value is a symbol or a string.
@@ -301,6 +301,11 @@ class V8_EXPORT Value : public Data {
    */
   bool IsInt32Array() const;
 
+  /**
+   * Returns true if this value is a Float16Array.
+   */
+  bool IsFloat16Array() const;
+
   /**
    * Returns true if this value is a Float32Array.
    */
@@ -341,6 +346,11 @@ class V8_EXPORT Value : public Data {
    */
   bool IsWasmMemoryObject() const;
 
+  /**
+   * Returns true if this value is a WasmMemoryMapDescriptor.
+   */
+  bool IsWasmMemoryMapDescriptor() const;
+
   /**
    * Returns true if this value is a WasmModuleObject.
    */
@@ -356,6 +366,11 @@ class V8_EXPORT Value : public Data {
    */
   bool IsModuleNamespaceObject() const;
 
+  /**
+   * Returns true if the value is a primitive.
+   */
+  bool IsPrimitive() const;
+
   /**
    * Perform `ToPrimitive(value)` as specified in:
    * https://tc39.es/ecma262/#sec-toprimitive.
@@ -391,7 +406,7 @@ class V8_EXPORT Value : public Data {
   V8_WARN_UNUSED_RESULT MaybeLocal<String> ToDetailString(
       Local<Context> context) const;
   /**
-   * Perform the equivalent of `Object(value)` in JS.
+   * Perform the equivalent of `Tagged<Object>(value)` in JS.
    */
   V8_WARN_UNUSED_RESULT MaybeLocal<Object> ToObject(
       Local<Context> context) const;
@@ -457,18 +472,67 @@ class V8_EXPORT Value : public Data {
 
   Maybe<bool> InstanceOf(Local<Context> context, Local<Object> object);
 
+  /**
+   * Get the hash of this value. The hash is not guaranteed to be
+   * unique. For |Object| and |Name| instances the result is equal to
+   * |GetIdentityHash|. Hashes are not guaranteed to be stable across
+   * different isolates or processes.
+   */
+  uint32_t GetHash();
+
  private:
   V8_INLINE bool QuickIsUndefined() const;
   V8_INLINE bool QuickIsNull() const;
   V8_INLINE bool QuickIsNullOrUndefined() const;
+#if V8_STATIC_ROOTS_BOOL
+  V8_INLINE bool QuickIsTrue() const;
+  V8_INLINE bool QuickIsFalse() const;
+#endif  // V8_STATIC_ROOTS_BOOL
   V8_INLINE bool QuickIsString() const;
   bool FullIsUndefined() const;
   bool FullIsNull() const;
+  bool FullIsTrue() const;
+  bool FullIsFalse() const;
   bool FullIsString() const;
 
   static void CheckCast(Data* that);
 };
 
+/**
+ * Can be used to avoid repeated expensive type checks for groups of objects
+ * that are expected to be similar (e.g. when Blink converts a bunch of
+ * JavaScript objects to "ScriptWrappable" after a "HasInstance" check) by
+ * making use of V8-internal "hidden classes". An object that has passed the
+ * full check can be remembered via {Update}; further objects can be queried
+ * using {Matches}.
+ * Note that the answer will be conservative/"best-effort": when {Matches}
+ * returns true, then the {candidate} can be relied upon to have the same
+ * shape/constructor/prototype/etc. as the {baseline}. Otherwise, no reliable
+ * statement can be made (the objects might still have indistinguishable shapes
+ * for all intents and purposes, but this mechanism, being optimized for speed,
+ * couldn't determine that quickly).
+ */
+class V8_EXPORT TypecheckWitness {
+ public:
+  explicit TypecheckWitness(Isolate* isolate);
+
+  /**
+   * Checks whether {candidate} can cheaply be identified as being "similar"
+   * to the {baseline} that was passed to {Update} earlier.
+   * It's safe to call this on an uninitialized {TypecheckWitness} instance:
+   * it will then return {false} for any input.
+   */
+  V8_INLINE bool Matches(Local<Value> candidate) const;
+
+  /**
+   * Remembers a new baseline for future {Matches} queries.
+   */
+  void Update(Local<Value> baseline);
+
+ private:
+  Local<Data> cached_map_;
+};
+
 template <>
 V8_INLINE Value* Value::Cast(Data* value) {
 #ifdef V8_ENABLE_CHECKS
@@ -541,6 +605,40 @@ bool Value::QuickIsNullOrUndefined() const {
 #endif  // V8_STATIC_ROOTS_BOOL
 }
 
+bool Value::IsTrue() const {
+#if V8_STATIC_ROOTS_BOOL && !defined(V8_ENABLE_CHECKS)
+  return QuickIsTrue();
+#else
+  return FullIsTrue();
+#endif
+}
+
+#if V8_STATIC_ROOTS_BOOL
+bool Value::QuickIsTrue() const {
+  using A = internal::Address;
+  using I = internal::Internals;
+  A obj = internal::ValueHelper::ValueAsAddress(this);
+  return I::is_identical(obj, I::StaticReadOnlyRoot::kTrueValue);
+}
+#endif  // V8_STATIC_ROOTS_BOOL
+
+bool Value::IsFalse() const {
+#if V8_STATIC_ROOTS_BOOL && !defined(V8_ENABLE_CHECKS)
+  return QuickIsFalse();
+#else
+  return FullIsFalse();
+#endif
+}
+
+#if V8_STATIC_ROOTS_BOOL
+bool Value::QuickIsFalse() const {
+  using A = internal::Address;
+  using I = internal::Internals;
+  A obj = internal::ValueHelper::ValueAsAddress(this);
+  return I::is_identical(obj, I::StaticReadOnlyRoot::kFalseValue);
+}
+#endif  // V8_STATIC_ROOTS_BOOL
+
 bool Value::IsString() const {
 #ifdef V8_ENABLE_CHECKS
   return FullIsString();
@@ -555,13 +653,22 @@ bool Value::QuickIsString() const {
   A obj = internal::ValueHelper::ValueAsAddress(this);
   if (!I::HasHeapObjectTag(obj)) return false;
 #if V8_STATIC_ROOTS_BOOL && !V8_MAP_PACKING
-  return I::CheckInstanceMapRange(obj, I::StaticReadOnlyRoot::kFirstStringMap,
-                                  I::StaticReadOnlyRoot::kLastStringMap);
+  return I::CheckInstanceMapRange(obj,
+                                  I::StaticReadOnlyRoot::kStringMapLowerBound,
+                                  I::StaticReadOnlyRoot::kStringMapUpperBound);
 #else
   return (I::GetInstanceType(obj) < I::kFirstNonstringType);
 #endif  // V8_STATIC_ROOTS_BOOL
 }
 
+bool TypecheckWitness::Matches(Local<Value> candidate) const {
+  internal::Address obj = internal::ValueHelper::ValueAsAddress(*candidate);
+  internal::Address obj_map = internal::Internals::LoadMap(obj);
+  internal::Address cached =
+      internal::ValueHelper::ValueAsAddress(*cached_map_);
+  return obj_map == cached;
+}
+
 }  // namespace v8
 
 #endif  // INCLUDE_V8_VALUE_H_

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

@@ -8,9 +8,9 @@
 // These macros define the version number for the current version.
 // NOTE these macros are used by some of the tool scripts and the build
 // system so their names cannot be changed without changing the scripts.
-#define V8_MAJOR_VERSION 11
-#define V8_MINOR_VERSION 8
-#define V8_BUILD_NUMBER 172
+#define V8_MAJOR_VERSION 13
+#define V8_MINOR_VERSION 6
+#define V8_BUILD_NUMBER 233
 #define V8_PATCH_LEVEL 17
 
 // Use 1 for candidates and 0 otherwise.

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

@@ -9,6 +9,7 @@
 #include <memory>
 #include <string>
 
+#include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-memory-span.h"   // NOLINT(build/include_directory)
 #include "v8-object.h"        // NOLINT(build/include_directory)
@@ -129,6 +130,8 @@ class V8_EXPORT WasmModuleObject : public Object {
  */
 class V8_EXPORT WasmStreaming final {
  public:
+  static constexpr internal::ExternalPointerTag kManagedTag =
+      internal::kWasmWasmStreamingTag;
   class WasmStreamingImpl;
 
   explicit WasmStreaming(std::unique_ptr<WasmStreamingImpl> impl);
@@ -196,6 +199,30 @@ class V8_EXPORT WasmStreaming final {
   std::unique_ptr<WasmStreamingImpl> impl_;
 };
 
+/**
+ * The V8 interface for a WebAssembly memory map descriptor. This is an
+ * experimental feature that may change and be removed without further
+ * communication.
+ */
+class V8_EXPORT WasmMemoryMapDescriptor : public Object {
+ public:
+  WasmMemoryMapDescriptor() = delete;
+
+  V8_INLINE static WasmMemoryMapDescriptor* Cast(Value* value) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(value);
+#endif
+    return static_cast<WasmMemoryMapDescriptor*>(value);
+  }
+
+  using WasmFileDescriptor = int32_t;
+
+  static Local<WasmMemoryMapDescriptor> New(Isolate* isolate,
+                                            WasmFileDescriptor fd);
+
+ private:
+  static void CheckCast(Value* object);
+};
 }  // namespace v8
 
 #endif  // INCLUDE_V8_WASM_H_

data/vendor/v8/include/v8-weak-callback-info.h

@@ -5,6 +5,9 @@
 #ifndef INCLUDE_V8_WEAK_CALLBACK_INFO_H_
 #define INCLUDE_V8_WEAK_CALLBACK_INFO_H_
 
+#include <cstring>
+
+#include "cppgc/internal/conditional-stack-allocated.h"  // NOLINT(build/include_directory)
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
@@ -15,11 +18,12 @@ namespace api_internal {
 V8_EXPORT void InternalFieldOutOfBounds(int index);
 }  // namespace api_internal
 
-static const int kInternalFieldsInWeakCallback = 2;
-static const int kEmbedderFieldsInWeakCallback = 2;
+static constexpr int kInternalFieldsInWeakCallback = 2;
+static constexpr int kEmbedderFieldsInWeakCallback = 2;
 
 template <typename T>
-class WeakCallbackInfo {
+class WeakCallbackInfo
+    : public cppgc::internal::ConditionalStackAllocatedBase<T> {
  public:
   using Callback = void (*)(const WeakCallbackInfo<T>& data);
 
@@ -27,21 +31,25 @@ class WeakCallbackInfo {
                    void* embedder_fields[kEmbedderFieldsInWeakCallback],
                    Callback* callback)
       : isolate_(isolate), parameter_(parameter), callback_(callback) {
-    for (int i = 0; i < kEmbedderFieldsInWeakCallback; ++i) {
-      embedder_fields_[i] = embedder_fields[i];
-    }
+    memcpy(embedder_fields_, embedder_fields,
+           sizeof(embedder_fields[0]) * kEmbedderFieldsInWeakCallback);
   }
 
   V8_INLINE Isolate* GetIsolate() const { return isolate_; }
   V8_INLINE T* GetParameter() const { return parameter_; }
   V8_INLINE void* GetInternalField(int index) const;
 
-  // When first called, the embedder MUST Reset() the Global which triggered the
-  // callback. The Global itself is unusable for anything else. No v8 other api
-  // calls may be called in the first callback. Should additional work be
-  // required, the embedder must set a second pass callback, which will be
-  // called after all the initial callbacks are processed.
-  // Calling SetSecondPassCallback on the second pass will immediately crash.
+  /**
+   * When a weak callback is first invoked the embedders _must_ Reset() the
+   * handle which triggered the callback. The handle itself is unusable for
+   * anything else. No other V8 API calls may be called in the first callback.
+   * Additional work requires scheduling a second invocation via
+   * `SetSecondPassCallback()` which will be called some time after all the
+   * initial callbacks are processed.
+   *
+   * The second pass callback is prohibited from executing JavaScript. Embedders
+   * should schedule another callback in case this is required.
+   */
   void SetSecondPassCallback(Callback callback) const { *callback_ = callback; }
 
  private:

data/vendor/v8/include/v8.h

@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef INCLUDE_V8_H_
+#define INCLUDE_V8_H_
+
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
@@ -12,9 +15,6 @@
  * For other documentation see https://v8.dev/.
  */
 
-#ifndef INCLUDE_V8_H_
-#define INCLUDE_V8_H_
-
 #include <stddef.h>
 #include <stdint.h>