libv8-node 23.6.1.0-x86_64-linux → 24.1.0.0-x86_64-linux

data/vendor/v8/include/v8-local-handle.h

@@ -179,8 +179,14 @@ class LocalBase : public api_internal::DirectHandleBase {
   }
 
   V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) {
+    if (slot == nullptr) return LocalBase<T>();
     return LocalBase<T>(*slot);
   }
+
+  V8_INLINE static LocalBase<T> FromRepr(
+      internal::ValueHelper::InternalRepresentationType repr) {
+    return LocalBase<T>(repr);
+  }
 };
 
 #else  // !V8_ENABLE_DIRECT_HANDLE
@@ -213,6 +219,11 @@ class LocalBase : public api_internal::IndirectHandleBase {
   V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) {
     return LocalBase<T>(slot);
   }
+
+  V8_INLINE static LocalBase<T> FromRepr(
+      internal::ValueHelper::InternalRepresentationType repr) {
+    return LocalBase<T>(repr);
+  }
 };
 
 #endif  // V8_ENABLE_DIRECT_HANDLE
@@ -255,17 +266,19 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
 #endif
 {
  public:
+  /**
+   * Default constructor: Returns an empty handle.
+   */
   V8_INLINE Local() = default;
 
+  /**
+   * Constructor for handling automatic up casting.
+   * Ex. Local<Object> can be passed when Local<Value> is expected but not
+   * the other way round.
+   */
   template <class S>
-  V8_INLINE Local(Local<S> that) : LocalBase<T>(that) {
-    /**
-     * This check fails when trying to convert between incompatible
-     * handles. For example, converting from a Local<String> to a
-     * Local<Number>.
-     */
-    static_assert(std::is_base_of<T, S>::value, "type check");
-  }
+    requires std::is_base_of_v<T, S>
+  V8_INLINE Local(Local<S> that) : LocalBase<T>(that) {}
 
   V8_INLINE T* operator->() const { return this->template value<T>(); }
 
@@ -305,7 +318,7 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
   /**
    * Cast a handle to a subclass, e.g. Local<Value> to Local<Object>.
    * This is only valid if the handle actually refers to a value of the
-   * target type.
+   * target type or if the handle is empty.
    */
   template <class S>
   V8_INLINE static Local<T> Cast(Local<S> that) {
@@ -321,7 +334,7 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
   /**
    * Calling this is equivalent to Local<S>::Cast().
    * In particular, this is only valid if the handle actually refers to a value
-   * of the target type.
+   * of the target type or if the handle is empty.
    */
   template <class S>
   V8_INLINE Local<S> As() const {
@@ -396,6 +409,11 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
 
   V8_INLINE explicit Local(const LocalBase<T>& other) : LocalBase<T>(other) {}
 
+  V8_INLINE static Local<T> FromRepr(
+      internal::ValueHelper::InternalRepresentationType repr) {
+    return Local<T>(LocalBase<T>::FromRepr(repr));
+  }
+
   V8_INLINE static Local<T> FromSlot(internal::Address* slot) {
     return Local<T>(LocalBase<T>::FromSlot(slot));
   }
@@ -434,8 +452,9 @@ class V8_TRIVIAL_ABI LocalUnchecked : public Local<T> {
 #if defined(V8_ENABLE_LOCAL_OFF_STACK_CHECK) && V8_HAS_ATTRIBUTE_TRIVIAL_ABI
   // In this case, the check is also enforced in the copy constructor and we
   // need to suppress it.
-  LocalUnchecked(const LocalUnchecked& other)
-      : Local<T>(other, Local<T>::do_not_check) noexcept {}
+  LocalUnchecked(
+      const LocalUnchecked& other) noexcept  // NOLINT(runtime/explicit)
+      : Local<T>(other, Local<T>::do_not_check) {}
   LocalUnchecked& operator=(const LocalUnchecked&) noexcept = default;
 #endif
 
@@ -455,11 +474,9 @@ class StrongRootAllocator<LocalUnchecked<T>> : public StrongRootAllocatorBase {
   static_assert(std::is_standard_layout_v<value_type>);
   static_assert(sizeof(value_type) == sizeof(Address));
 
-  explicit StrongRootAllocator(Heap* heap) : StrongRootAllocatorBase(heap) {}
-  explicit StrongRootAllocator(Isolate* isolate)
-      : StrongRootAllocatorBase(isolate) {}
-  explicit StrongRootAllocator(v8::Isolate* isolate)
-      : StrongRootAllocatorBase(reinterpret_cast<Isolate*>(isolate)) {}
+  template <typename HeapOrIsolateT>
+  explicit StrongRootAllocator(HeapOrIsolateT* heap_or_isolate)
+      : StrongRootAllocatorBase(heap_or_isolate) {}
   template <typename U>
   StrongRootAllocator(const StrongRootAllocator<U>& other) noexcept
       : StrongRootAllocatorBase(other) {}
@@ -565,7 +582,11 @@ class LocalVector {
 
   void push_back(const Local<T>& x) { backing_.push_back(x); }
   void pop_back() { backing_.pop_back(); }
-  void emplace_back(const Local<T>& x) { backing_.emplace_back(x); }
+
+  template <typename... Args>
+  void emplace_back(Args&&... args) {
+    backing_.push_back(value_type{std::forward<Args>(args)...});
+  }
 
   void clear() noexcept { backing_.clear(); }
   void resize(size_t n) { backing_.resize(n); }
@@ -613,9 +634,22 @@ using Handle = Local<T>;
 template <class T>
 class MaybeLocal {
  public:
-  V8_INLINE MaybeLocal() : local_() {}
+  /**
+   * Default constructor: Returns an empty handle.
+   */
+  V8_INLINE MaybeLocal() = default;
+  /**
+   * Implicitly construct MaybeLocal from Local.
+   */
   template <class S>
+    requires std::is_base_of_v<T, S>
   V8_INLINE MaybeLocal(Local<S> that) : local_(that) {}
+  /**
+   * Implicitly up-cast MaybeLocal<S> to MaybeLocal<T> if T is a base of S.
+   */
+  template <class S>
+    requires std::is_base_of_v<T, S>
+  V8_INLINE MaybeLocal(MaybeLocal<S> that) : local_(that.local_) {}
 
   V8_INLINE bool IsEmpty() const { return local_.IsEmpty(); }
 
@@ -650,23 +684,17 @@ class MaybeLocal {
   /**
    * Cast a handle to a subclass, e.g. MaybeLocal<Value> to MaybeLocal<Object>.
    * This is only valid if the handle actually refers to a value of the target
-   * type.
+   * type or if the handle is empty.
    */
   template <class S>
   V8_INLINE static MaybeLocal<T> Cast(MaybeLocal<S> that) {
-#ifdef V8_ENABLE_CHECKS
-    // If we're going to perform the type check then we have to check
-    // that the handle isn't empty before doing the checked cast.
-    if (that.IsEmpty()) return MaybeLocal<T>();
-    T::Cast(that.local_.template value<S>());
-#endif
-    return MaybeLocal<T>(that.local_);
+    return MaybeLocal<T>{Local<T>::Cast(that.local_)};
   }
 
   /**
    * Calling this is equivalent to MaybeLocal<S>::Cast().
    * In particular, this is only valid if the handle actually refers to a value
-   * of the target type.
+   * of the target type or if the handle is empty.
    */
   template <class S>
   V8_INLINE MaybeLocal<S> As() const {

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

@@ -8,6 +8,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "cppgc/internal/conditional-stack-allocated.h"  // NOLINT(build/include_directory)
 #include "v8-internal.h"  // NOLINT(build/include_directory)
 #include "v8config.h"     // NOLINT(build/include_directory)
 
@@ -29,7 +30,7 @@ V8_EXPORT void FromJustIsNothing();
  * "Nothing" value is returned.
  */
 template <class T>
-class Maybe {
+class Maybe : public cppgc::internal::ConditionalStackAllocatedBase<T> {
  public:
   V8_INLINE bool IsNothing() const { return !has_value_; }
   V8_INLINE bool IsJust() const { return has_value_; }

data/vendor/v8/include/v8-memory-span.h

@@ -8,11 +8,46 @@
 #include <stddef.h>
 
 #include <array>
+#include <cstddef>
 #include <iterator>
 #include <type_traits>
 
 #include "v8config.h"  // NOLINT(build/include_directory)
 
+// TODO(pkasting): Use <compare>/spaceship unconditionally after dropping
+// support for old libstdc++ versions.
+#if __has_include(<version>)
+#include <version>
+#endif
+#if defined(__cpp_lib_three_way_comparison) && \
+    __cpp_lib_three_way_comparison >= 201711L
+#define V8_HAVE_SPACESHIP_OPERATOR 1
+#else
+#define V8_HAVE_SPACESHIP_OPERATOR 0
+#endif
+
+// TODO(pkasting): Make this block unconditional after dropping support for old
+// libstdc++ versions.
+#if __has_include(<ranges>)
+#include <ranges>
+
+namespace v8 {
+
+template <typename T>
+class V8_EXPORT MemorySpan;
+
+}  // namespace v8
+
+// Mark `MemorySpan` as satisfying the `view` and `borrowed_range` concepts.
+// This should be done before the definition of `MemorySpan`, so that any
+// inlined calls to range functionality use the correct specializations.
+template <typename T>
+inline constexpr bool std::ranges::enable_view<v8::MemorySpan<T>> = true;
+template <typename T>
+inline constexpr bool std::ranges::enable_borrowed_range<v8::MemorySpan<T>> =
+    true;
+#endif
+
 namespace v8 {
 
 /**
@@ -53,13 +88,13 @@ class V8_EXPORT MemorySpan {
       is_compatible_iterator<It>::value;
 
   template <typename U>
-  static constexpr U* to_address(U* p) noexcept {
+  [[nodiscard]] static constexpr U* to_address(U* p) noexcept {
     return p;
   }
 
   template <typename It,
             typename = std::void_t<decltype(std::declval<It&>().operator->())>>
-  static constexpr auto to_address(It it) noexcept {
+  [[nodiscard]] static constexpr auto to_address(It it) noexcept {
     return it.operator->();
   }
 
@@ -108,50 +143,139 @@ class V8_EXPORT MemorySpan {
       : data_(a.data()), size_{N} {}
 
   /** Returns a pointer to the beginning of the buffer. */
-  constexpr T* data() const { return data_; }
+  [[nodiscard]] constexpr T* data() const { return data_; }
   /** Returns the number of elements that the buffer holds. */
-  constexpr size_t size() const { return size_; }
+  [[nodiscard]] constexpr size_t size() const { return size_; }
 
-  constexpr T& operator[](size_t i) const { return data_[i]; }
+  [[nodiscard]] constexpr T& operator[](size_t i) const { return data_[i]; }
 
   /** Returns true if the buffer is empty. */
-  constexpr bool empty() const { return size() == 0; }
+  [[nodiscard]] constexpr bool empty() const { return size() == 0; }
 
   class Iterator {
    public:
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = T;
     using difference_type = std::ptrdiff_t;
+    using value_type = T;
     using pointer = value_type*;
     using reference = value_type&;
+    using iterator_category = std::random_access_iterator_tag;
+    // There seems to be no feature-test macro covering this, so use the
+    // presence of `<ranges>` as a crude proxy, since it was added to the
+    // standard as part of the Ranges papers.
+    // TODO(pkasting): Add this unconditionally after dropping support for old
+    // libstdc++ versions.
+#if __has_include(<ranges>)
+    using iterator_concept = std::contiguous_iterator_tag;
+#endif
+
+    // Required to satisfy `std::semiregular<>`.
+    constexpr Iterator() = default;
+
+    [[nodiscard]] friend constexpr bool operator==(const Iterator& a,
+                                                   const Iterator& b) {
+      // TODO(pkasting): Replace this body with `= default` after dropping
+      // support for old gcc versions.
+      return a.ptr_ == b.ptr_;
+    }
+#if V8_HAVE_SPACESHIP_OPERATOR
+    [[nodiscard]] friend constexpr auto operator<=>(const Iterator&,
+                                                    const Iterator&) = default;
+#else
+    // Assume that if spaceship isn't present, operator rewriting might not be
+    // either.
+    [[nodiscard]] friend constexpr bool operator!=(const Iterator& a,
+                                                   const Iterator& b) {
+      return a.ptr_ != b.ptr_;
+    }
 
-    T& operator*() const { return *ptr_; }
-    T* operator->() const { return ptr_; }
-
-    bool operator==(Iterator other) const { return ptr_ == other.ptr_; }
-    bool operator!=(Iterator other) const { return !(*this == other); }
+    [[nodiscard]] friend constexpr bool operator<(const Iterator& a,
+                                                  const Iterator& b) {
+      return a.ptr_ < b.ptr_;
+    }
+    [[nodiscard]] friend constexpr bool operator<=(const Iterator& a,
+                                                   const Iterator& b) {
+      return a.ptr_ <= b.ptr_;
+    }
+    [[nodiscard]] friend constexpr bool operator>(const Iterator& a,
+                                                  const Iterator& b) {
+      return a.ptr_ > b.ptr_;
+    }
+    [[nodiscard]] friend constexpr bool operator>=(const Iterator& a,
+                                                   const Iterator& b) {
+      return a.ptr_ >= b.ptr_;
+    }
+#endif
 
-    Iterator& operator++() {
+    constexpr Iterator& operator++() {
       ++ptr_;
       return *this;
     }
 
-    Iterator operator++(int) {
-      Iterator temp(*this);
-      ++(*this);
+    constexpr Iterator operator++(int) {
+      Iterator temp = *this;
+      ++*this;
       return temp;
     }
 
+    constexpr Iterator& operator--() {
+      --ptr_;
+      return *this;
+    }
+
+    constexpr Iterator operator--(int) {
+      Iterator temp = *this;
+      --*this;
+      return temp;
+    }
+
+    constexpr Iterator& operator+=(difference_type rhs) {
+      ptr_ += rhs;
+      return *this;
+    }
+
+    [[nodiscard]] friend constexpr Iterator operator+(Iterator lhs,
+                                                      difference_type rhs) {
+      lhs += rhs;
+      return lhs;
+    }
+
+    [[nodiscard]] friend constexpr Iterator operator+(difference_type lhs,
+                                                      const Iterator& rhs) {
+      return rhs + lhs;
+    }
+
+    constexpr Iterator& operator-=(difference_type rhs) {
+      ptr_ -= rhs;
+      return *this;
+    }
+
+    [[nodiscard]] friend constexpr Iterator operator-(Iterator lhs,
+                                                      difference_type rhs) {
+      lhs -= rhs;
+      return lhs;
+    }
+
+    [[nodiscard]] friend constexpr difference_type operator-(
+        const Iterator& lhs, const Iterator& rhs) {
+      return lhs.ptr_ - rhs.ptr_;
+    }
+
+    [[nodiscard]] constexpr reference operator*() const { return *ptr_; }
+    [[nodiscard]] constexpr pointer operator->() const { return ptr_; }
+    [[nodiscard]] constexpr reference operator[](size_t offset) const {
+      return ptr_[offset];
+    }
+
    private:
     friend class MemorySpan<T>;
 
-    explicit Iterator(T* ptr) : ptr_(ptr) {}
+    constexpr explicit Iterator(T* ptr) : ptr_(ptr) {}
 
     T* ptr_ = nullptr;
   };
 
-  Iterator begin() const { return Iterator(data_); }
-  Iterator end() const { return Iterator(data_ + size_); }
+  [[nodiscard]] Iterator begin() const { return Iterator(data_); }
+  [[nodiscard]] Iterator end() const { return Iterator(data_ + size_); }
 
  private:
   T* data_ = nullptr;
@@ -171,25 +295,26 @@ class V8_EXPORT MemorySpan {
 
 namespace detail {
 template <class T, std::size_t N, std::size_t... I>
-constexpr std::array<std::remove_cv_t<T>, N> to_array_lvalue_impl(
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array_lvalue_impl(
     T (&a)[N], std::index_sequence<I...>) {
   return {{a[I]...}};
 }
 
 template <class T, std::size_t N, std::size_t... I>
-constexpr std::array<std::remove_cv_t<T>, N> to_array_rvalue_impl(
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array_rvalue_impl(
     T (&&a)[N], std::index_sequence<I...>) {
   return {{std::move(a[I])...}};
 }
 }  // namespace detail
 
 template <class T, std::size_t N>
-constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) {
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) {
   return detail::to_array_lvalue_impl(a, std::make_index_sequence<N>{});
 }
 
 template <class T, std::size_t N>
-constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&&a)[N]) {
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array(
+    T (&&a)[N]) {
   return detail::to_array_rvalue_impl(std::move(a),
                                       std::make_index_sequence<N>{});
 }

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

@@ -9,6 +9,7 @@
 
 #include <iosfwd>
 
+#include "v8-callbacks.h"     // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-maybe.h"         // NOLINT(build/include_directory)
 #include "v8-primitive.h"     // NOLINT(build/include_directory)
@@ -185,7 +186,14 @@ class V8_EXPORT Message {
   bool IsSharedCrossOrigin() const;
   bool IsOpaque() const;
 
-  static void PrintCurrentStackTrace(Isolate* isolate, std::ostream& out);
+  /**
+   * If provided, the callback can be used to selectively include
+   * or redact frames based on their script names. (true to include a frame)
+   */
+  static void PrintCurrentStackTrace(
+      Isolate* isolate, std::ostream& out,
+      PrintCurrentStackTraceFilterCallback should_include_frame_callback =
+          nullptr);
 
   static const int kNoLineNumberInfo = 0;
   static const int kNoColumnInfo = 0;

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

@@ -8,9 +8,11 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <vector>
 
 #include "v8-internal.h"      // NOLINT(build/include_directory)
+#include "v8-isolate.h"       // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
@@ -37,6 +39,10 @@ struct GarbageCollectionSizes {
 
 struct GarbageCollectionFullCycle {
   int reason = -1;
+  // The priority of the isolate during the GC cycle. A nullopt value denotes a
+  // mixed priority cycle, meaning the Isolate's priority was changed while the
+  // cycle was in progress.
+  std::optional<v8::Isolate::Priority> priority = std::nullopt;
   GarbageCollectionPhases total;
   GarbageCollectionPhases total_cpp;
   GarbageCollectionPhases main_thread;
@@ -86,6 +92,10 @@ using GarbageCollectionFullMainThreadBatchedIncrementalSweep =
 
 struct GarbageCollectionYoungCycle {
   int reason = -1;
+  // The priority of the isolate during the GC cycle. A nullopt value denotes a
+  // mixed priority cycle, meaning the Isolate's priority was changed while the
+  // cycle was in progress.
+  std::optional<v8::Isolate::Priority> priority = std::nullopt;
   int64_t total_wall_clock_duration_in_us = -1;
   int64_t main_thread_wall_clock_duration_in_us = -1;
   double collection_rate_in_percent = -1.0;

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

@@ -704,6 +704,7 @@ class V8_EXPORT Object : public Value {
    * Prefer using version with Isolate parameter.
    */
   MaybeLocal<Context> GetCreationContext(v8::Isolate* isolate);
+  V8_DEPRECATE_SOON("Use the version with the isolate argument.")
   MaybeLocal<Context> GetCreationContext();
 
   /**
@@ -712,13 +713,17 @@ class V8_EXPORT Object : public Value {
    * Prefer using version with Isolate parameter.
    **/
   Local<Context> GetCreationContextChecked(v8::Isolate* isolate);
+  V8_DEPRECATE_SOON("Use the version with the isolate argument.")
   Local<Context> GetCreationContextChecked();
 
   /** Same as above, but works for Persistents */
   V8_INLINE static MaybeLocal<Context> GetCreationContext(
-      const PersistentBase<Object>& object) {
-    return object.template value<Object>()->GetCreationContext();
+      v8::Isolate* isolate, const PersistentBase<Object>& object) {
+    return object.template value<Object>()->GetCreationContext(isolate);
   }
+  V8_DEPRECATE_SOON("Use the version with the isolate argument.")
+  V8_INLINE static MaybeLocal<Context> GetCreationContext(
+      const PersistentBase<Object>& object);
 
   /**
    * Gets the context in which the object was created (see GetCreationContext())

data/vendor/v8/include/v8-persistent-handle.h

@@ -46,7 +46,11 @@ class Eternal : public api_internal::IndirectHandleBase {
  public:
   V8_INLINE Eternal() = default;
 
+  /**
+   * Constructor for handling automatic up casting.
+   */
   template <class S>
+    requires(std::is_base_of_v<T, S>)
   V8_INLINE Eternal(Isolate* isolate, Local<S> handle) {
     Set(isolate, handle);
   }
@@ -59,8 +63,8 @@ class Eternal : public api_internal::IndirectHandleBase {
   }
 
   template <class S>
+    requires(std::is_base_of_v<T, S>)
   void Set(Isolate* isolate, Local<S> handle) {
-    static_assert(std::is_base_of<T, S>::value, "type check");
     slot() =
         api_internal::Eternalize(isolate, *handle.template UnsafeAs<Value>());
   }
@@ -251,28 +255,26 @@ class Persistent : public PersistentBase<T> {
   V8_INLINE Persistent() = default;
 
   /**
-   * Construct a Persistent from a Local.
+   * Construct a Persistent from a Local with automatic up casting.
    * When the Local is non-empty, a new storage cell is created
    * pointing to the same object, and no flags are set.
    */
   template <class S>
+    requires(std::is_base_of_v<T, S>)
   V8_INLINE Persistent(Isolate* isolate, Local<S> that)
       : PersistentBase<T>(
-            PersistentBase<T>::New(isolate, that.template value<S>())) {
-    static_assert(std::is_base_of<T, S>::value, "type check");
-  }
+            PersistentBase<T>::New(isolate, that.template value<S>())) {}
 
   /**
-   * Construct a Persistent from a Persistent.
+   * Construct a Persistent from a Persistent with automatic up casting.
    * When the Persistent is non-empty, a new storage cell is created
    * pointing to the same object, and no flags are set.
    */
   template <class S, class M2>
+    requires(std::is_base_of_v<T, S>)
   V8_INLINE Persistent(Isolate* isolate, const Persistent<S, M2>& that)
       : PersistentBase<T>(
-            PersistentBase<T>::New(isolate, that.template value<S>())) {
-    static_assert(std::is_base_of<T, S>::value, "type check");
-  }
+            PersistentBase<T>::New(isolate, that.template value<S>())) {}
 
   /**
    * The copy constructors and assignment operator create a Persistent
@@ -352,28 +354,26 @@ class Global : public PersistentBase<T> {
   V8_INLINE Global() = default;
 
   /**
-   * Construct a Global from a Local.
+   * Construct a Global from a Local with automatic up casting.
    * When the Local is non-empty, a new storage cell is created
    * pointing to the same object, and no flags are set.
    */
   template <class S>
+    requires(std::is_base_of_v<T, S>)
   V8_INLINE Global(Isolate* isolate, Local<S> that)
       : PersistentBase<T>(
-            PersistentBase<T>::New(isolate, that.template value<S>())) {
-    static_assert(std::is_base_of<T, S>::value, "type check");
-  }
+            PersistentBase<T>::New(isolate, that.template value<S>())) {}
 
   /**
-   * Construct a Global from a PersistentBase.
+   * Construct a Global from a PersistentBase with automatic up casting.
    * When the Persistent is non-empty, a new storage cell is created
    * pointing to the same object, and no flags are set.
    */
   template <class S>
+    requires(std::is_base_of_v<T, S>)
   V8_INLINE Global(Isolate* isolate, const PersistentBase<S>& that)
       : PersistentBase<T>(
-            PersistentBase<T>::New(isolate, that.template value<S>())) {
-    static_assert(std::is_base_of<T, S>::value, "type check");
-  }
+            PersistentBase<T>::New(isolate, that.template value<S>())) {}
 
   /**
    * Move constructor.