libv8-node 17.9.1.0-x86_64-linux-musl → 18.8.0.0-x86_64-linux-musl

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

@@ -12,7 +12,6 @@
 #include "cppgc/common.h"
 #include "cppgc/custom-space.h"
 #include "cppgc/heap-statistics.h"
-#include "cppgc/internal/write-barrier.h"
 #include "cppgc/visitor.h"
 #include "v8-internal.h"       // NOLINT(build/include_directory)
 #include "v8-platform.h"       // NOLINT(build/include_directory)
@@ -148,6 +147,14 @@ class V8_EXPORT CppHeap {
    */
   void CollectGarbageForTesting(cppgc::EmbedderStackState stack_state);
 
+  /**
+   * Performs a stop-the-world minor garbage collection for testing purposes.
+   *
+   * \param stack_state The stack state to assume for the garbage collection.
+   */
+  void CollectGarbageInYoungGenerationForTesting(
+      cppgc::EmbedderStackState stack_state);
+
  private:
   CppHeap() = default;
 
@@ -157,6 +164,7 @@ class V8_EXPORT CppHeap {
 class JSVisitor : public cppgc::Visitor {
  public:
   explicit JSVisitor(cppgc::Visitor::Key key) : cppgc::Visitor(key) {}
+  ~JSVisitor() override = default;
 
   void Trace(const TracedReferenceBase& ref) {
     if (ref.IsEmptyThreadSafe()) return;
@@ -169,129 +177,6 @@ class JSVisitor : public cppgc::Visitor {
   virtual void Visit(const TracedReferenceBase& ref) {}
 };
 
-/**
- * **DO NOT USE: Use the appropriate managed types.**
- *
- * Consistency helpers that aid in maintaining a consistent internal state of
- * the garbage collector.
- */
-class V8_EXPORT JSHeapConsistency final {
- public:
-  using WriteBarrierParams = cppgc::internal::WriteBarrier::Params;
-  using WriteBarrierType = cppgc::internal::WriteBarrier::Type;
-
-  /**
-   * Gets the required write barrier type for a specific write.
-   *
-   * Note: Handling for C++ to JS references.
-   *
-   * \param ref The reference being written to.
-   * \param params Parameters that may be used for actual write barrier calls.
-   *   Only filled if return value indicates that a write barrier is needed. The
-   *   contents of the `params` are an implementation detail.
-   * \param callback Callback returning the corresponding heap handle. The
-   *   callback is only invoked if the heap cannot otherwise be figured out. The
-   *   callback must not allocate.
-   * \returns whether a write barrier is needed and which barrier to invoke.
-   */
-  template <typename HeapHandleCallback>
-  static V8_INLINE WriteBarrierType
-  GetWriteBarrierType(const TracedReferenceBase& ref,
-                      WriteBarrierParams& params, HeapHandleCallback callback) {
-    if (ref.IsEmpty()) return WriteBarrierType::kNone;
-
-    if (V8_LIKELY(!cppgc::internal::WriteBarrier::
-                      IsAnyIncrementalOrConcurrentMarking())) {
-      return cppgc::internal::WriteBarrier::Type::kNone;
-    }
-    cppgc::HeapHandle& handle = callback();
-    if (!cppgc::subtle::HeapState::IsMarking(handle)) {
-      return cppgc::internal::WriteBarrier::Type::kNone;
-    }
-    params.heap = &handle;
-#if V8_ENABLE_CHECKS
-    params.type = cppgc::internal::WriteBarrier::Type::kMarking;
-#endif  // !V8_ENABLE_CHECKS
-    return cppgc::internal::WriteBarrier::Type::kMarking;
-  }
-
-  /**
-   * Gets the required write barrier type for a specific write.
-   *
-   * Note: Handling for JS to C++ references.
-   *
-   * \param wrapper The wrapper that has been written into.
-   * \param wrapper_index The wrapper index in `wrapper` that has been written
-   *   into.
-   * \param wrappable The value that was written.
-   * \param params Parameters that may be used for actual write barrier calls.
-   *   Only filled if return value indicates that a write barrier is needed. The
-   *   contents of the `params` are an implementation detail.
-   * \param callback Callback returning the corresponding heap handle. The
-   *   callback is only invoked if the heap cannot otherwise be figured out. The
-   *   callback must not allocate.
-   * \returns whether a write barrier is needed and which barrier to invoke.
-   */
-  template <typename HeapHandleCallback>
-  static V8_INLINE WriteBarrierType GetWriteBarrierType(
-      v8::Local<v8::Object>& wrapper, int wrapper_index, const void* wrappable,
-      WriteBarrierParams& params, HeapHandleCallback callback) {
-#if V8_ENABLE_CHECKS
-    CheckWrapper(wrapper, wrapper_index, wrappable);
-#endif  // V8_ENABLE_CHECKS
-    return cppgc::internal::WriteBarrier::
-        GetWriteBarrierTypeForExternallyReferencedObject(wrappable, params,
-                                                         callback);
-  }
-
-  /**
-   * Conservative Dijkstra-style write barrier that processes an object if it
-   * has not yet been processed.
-   *
-   * \param params The parameters retrieved from `GetWriteBarrierType()`.
-   * \param ref The reference being written to.
-   */
-  static V8_INLINE void DijkstraMarkingBarrier(const WriteBarrierParams& params,
-                                               cppgc::HeapHandle& heap_handle,
-                                               const TracedReferenceBase& ref) {
-    cppgc::internal::WriteBarrier::CheckParams(WriteBarrierType::kMarking,
-                                               params);
-    DijkstraMarkingBarrierSlow(heap_handle, ref);
-  }
-
-  /**
-   * Conservative Dijkstra-style write barrier that processes an object if it
-   * has not yet been processed.
-   *
-   * \param params The parameters retrieved from `GetWriteBarrierType()`.
-   * \param object The pointer to the object. May be an interior pointer to a
-   *   an interface of the actual object.
-   */
-  static V8_INLINE void DijkstraMarkingBarrier(const WriteBarrierParams& params,
-                                               cppgc::HeapHandle& heap_handle,
-                                               const void* object) {
-    cppgc::internal::WriteBarrier::DijkstraMarkingBarrier(params, object);
-  }
-
-  /**
-   * Generational barrier for maintaining consistency when running with multiple
-   * generations.
-   *
-   * \param params The parameters retrieved from `GetWriteBarrierType()`.
-   * \param ref The reference being written to.
-   */
-  static V8_INLINE void GenerationalBarrier(const WriteBarrierParams& params,
-                                            const TracedReferenceBase& ref) {}
-
- private:
-  JSHeapConsistency() = delete;
-
-  static void CheckWrapper(v8::Local<v8::Object>&, int, const void*);
-
-  static void DijkstraMarkingBarrierSlow(cppgc::HeapHandle&,
-                                         const TracedReferenceBase& ref);
-};
-
 /**
  * Provided as input to `CppHeap::CollectCustomSpaceStatisticsAtLastGC()`.
  *
@@ -318,8 +203,13 @@ namespace cppgc {
 
 template <typename T>
 struct TraceTrait<v8::TracedReference<T>> {
-  static void Trace(Visitor* visitor, const v8::TracedReference<T>* self) {
-    static_cast<v8::JSVisitor*>(visitor)->Trace(*self);
+  static cppgc::TraceDescriptor GetTraceDescriptor(const void* self) {
+    return {nullptr, Trace};
+  }
+
+  static void Trace(Visitor* visitor, const void* self) {
+    static_cast<v8::JSVisitor*>(visitor)->Trace(
+        *static_cast<const v8::TracedReference<T>*>(self));
   }
 };
 

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

@@ -27,6 +27,11 @@ class V8_EXPORT Data {
    */
   bool IsModule() const;
 
+  /**
+   * Returns tru if this data is a |v8::FixedArray|
+   */
+  bool IsFixedArray() const;
+
   /**
    * Returns true if this data is a |v8::Private|.
    */
@@ -58,6 +63,16 @@ class V8_EXPORT FixedArray : public Data {
  public:
   int Length() const;
   Local<Data> Get(Local<Context> context, int i) const;
+
+  V8_INLINE static FixedArray* Cast(Data* data) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(data);
+#endif
+    return reinterpret_cast<FixedArray*>(data);
+  }
+
+ private:
+  static void CheckCast(Data* obj);
 };
 
 }  // namespace v8

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

@@ -7,8 +7,8 @@
 
 #include <stdint.h>
 
-#include "v8-local-handle.h"  // NOLINT(build/include_directory)
-#include "v8config.h"         // NOLINT(build/include_directory)
+#include "v8-script.h"  // NOLINT(build/include_directory)
+#include "v8config.h"   // NOLINT(build/include_directory)
 
 namespace v8 {
 
@@ -20,13 +20,18 @@ class String;
  */
 class V8_EXPORT StackFrame {
  public:
+  /**
+   * Returns the source location, 0-based, for the associated function call.
+   */
+  Location GetLocation() const;
+
   /**
    * Returns the number, 1-based, of the line for the associate function call.
    * This method will return Message::kNoLineNumberInfo if it is unable to
    * retrieve the line number, or if kLineNumber was not passed as an option
    * when capturing the StackTrace.
    */
-  int GetLineNumber() const;
+  int GetLineNumber() const { return GetLocation().GetLineNumber() + 1; }
 
   /**
    * Returns the 1-based column offset on the line for the associated function
@@ -35,7 +40,7 @@ class V8_EXPORT StackFrame {
    * the column number, or if kColumnOffset was not passed as an option when
    * capturing the StackTrace.
    */
-  int GetColumn() const;
+  int GetColumn() const { return GetLocation().GetColumnNumber() + 1; }
 
   /**
    * Returns the id of the script for the function for this StackFrame.
@@ -144,6 +149,18 @@ class V8_EXPORT StackTrace {
    */
   static Local<StackTrace> CurrentStackTrace(
       Isolate* isolate, int frame_limit, StackTraceOptions options = kDetailed);
+
+  /**
+   * Returns the first valid script name or source URL starting at the top of
+   * the JS stack. The returned string is either an empty handle if no script
+   * name/url was found or a non-zero-length string.
+   *
+   * This method is equivalent to calling StackTrace::CurrentStackTrace and
+   * walking the resulting frames from the beginning until a non-empty script
+   * name/url is found. The difference is that this method won't allocate
+   * a stack trace.
+   */
+  static Local<String> CurrentScriptNameOrSourceURL(Isolate* isolate);
 };
 
 }  // namespace v8

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

@@ -34,24 +34,21 @@ class V8_EXPORT EmbedderRootsHandler {
   virtual ~EmbedderRootsHandler() = default;
 
   /**
-   * Returns true if the TracedGlobal handle should be considered as root for
-   * the currently running non-tracing garbage collection and false otherwise.
-   * The default implementation will keep all TracedGlobal references as roots.
+   * Returns true if the |TracedReference| handle should be considered as root
+   * for the currently running non-tracing garbage collection and false
+   * otherwise. The default implementation will keep all |TracedReference|
+   * references as roots.
    *
    * If this returns false, then V8 may decide that the object referred to by
-   * such a handle is reclaimed. In that case:
-   * - No action is required if handles are used with destructors, i.e., by just
-   *   using |TracedGlobal|.
-   * - When run without destructors, i.e., by using |TracedReference|, V8 calls
-   *  |ResetRoot|.
+   * such a handle is reclaimed. In that case, V8 calls |ResetRoot()| for the
+   * |TracedReference|.
    *
-   * Note that the |handle| is different from the handle that the embedder holds
+   * 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.
    */
   virtual bool IsRoot(const v8::TracedReference<v8::Value>& handle) = 0;
-  virtual bool IsRoot(const v8::TracedGlobal<v8::Value>& handle) = 0;
 
   /**
    * Used in combination with |IsRoot|. Called by V8 when an
@@ -83,12 +80,11 @@ class V8_EXPORT EmbedderHeapTracer {
   };
 
   /**
-   * Interface for iterating through TracedGlobal handles.
+   * Interface for iterating through |TracedReference| handles.
    */
   class V8_EXPORT TracedGlobalHandleVisitor {
    public:
     virtual ~TracedGlobalHandleVisitor() = default;
-    virtual void VisitTracedGlobalHandle(const TracedGlobal<Value>& handle) {}
     virtual void VisitTracedReference(const TracedReference<Value>& handle) {}
   };
 
@@ -113,8 +109,8 @@ class V8_EXPORT EmbedderHeapTracer {
   virtual ~EmbedderHeapTracer() = default;
 
   /**
-   * Iterates all TracedGlobal handles created for the v8::Isolate the tracer is
-   * attached to.
+   * Iterates all |TracedReference| handles created for the |v8::Isolate| the
+   * tracer is attached to.
    */
   void IterateTracedGlobalHandles(TracedGlobalHandleVisitor* visitor);
 
@@ -124,14 +120,6 @@ class V8_EXPORT EmbedderHeapTracer {
    */
   void SetStackStart(void* stack_start);
 
-  /**
-   * Called by the embedder to notify V8 of an empty execution stack.
-   */
-  V8_DEPRECATE_SOON(
-      "This call only optimized internal caches which V8 is able to figure out "
-      "on its own now.")
-  void NotifyEmptyEmbedderStack();
-
   /**
    * Called by v8 to register internal fields of found wrappers.
    *
@@ -197,7 +185,6 @@ class V8_EXPORT EmbedderHeapTracer {
    */
   virtual bool IsRootForNonTracingGC(
       const v8::TracedReference<v8::Value>& handle);
-  virtual bool IsRootForNonTracingGC(const v8::TracedGlobal<v8::Value>& handle);
 
   /**
    * See documentation on EmbedderRootsHandler.
@@ -205,13 +192,6 @@ class V8_EXPORT EmbedderHeapTracer {
   virtual void ResetHandleInNonTracingGC(
       const v8::TracedReference<v8::Value>& handle);
 
-  /*
-   * Called by the embedder to immediately perform a full garbage collection.
-   *
-   * Should only be used in testing code.
-   */
-  void GarbageCollectionForTesting(EmbedderStackState stack_state);
-
   /*
    * Called by the embedder to signal newly allocated or freed memory. Not bound
    * to tracing phases. Embedders should trade off when increments are reported

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

@@ -0,0 +1,51 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef INCLUDE_V8_EMBEDDER_STATE_SCOPE_H_
+#define INCLUDE_V8_EMBEDDER_STATE_SCOPE_H_
+
+#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 {
+
+namespace internal {
+class EmbedderState;
+}  // namespace internal
+
+// A StateTag represents a possible state of the embedder.
+enum class EmbedderStateTag : uint8_t {
+  // reserved
+  EMPTY = 0,
+  OTHER = 1,
+  // embedder can define any state after
+};
+
+// A stack-allocated class that manages an embedder state on the isolate.
+// After an EmbedderState scope has been created, a new embedder state will be
+// pushed on the isolate stack.
+class V8_EXPORT EmbedderStateScope {
+ public:
+  EmbedderStateScope(Isolate* isolate, Local<v8::Context> context,
+                     EmbedderStateTag tag);
+
+  ~EmbedderStateScope();
+
+ private:
+  // Declaring operator new and delete as deleted is not spec compliant.
+  // Therefore declare them private instead to disable dynamic alloc
+  void* operator new(size_t size);
+  void* operator new[](size_t size);
+  void operator delete(void*, size_t);
+  void operator delete[](void*, size_t);
+
+  std::unique_ptr<internal::EmbedderState> embedder_state_;
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_V8_EMBEDDER_STATE_SCOPE_H_

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

@@ -169,13 +169,6 @@ class V8_EXPORT TryCatch {
    */
   void SetCaptureMessage(bool value);
 
-  V8_DEPRECATE_SOON(
-      "This is private information that should not be exposed by the API")
-  static void* JSStackComparableAddress(TryCatch* handler) {
-    if (handler == nullptr) return nullptr;
-    return reinterpret_cast<void*>(handler->JSStackComparableAddressPrivate());
-  }
-
   TryCatch(const TryCatch&) = delete;
   void operator=(const TryCatch&) = delete;
 

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

@@ -249,6 +249,15 @@ class CTypeInfo {
     kV8Value,
     kApiObject,  // This will be deprecated once all users have
                  // 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
+                 // 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
+                 // and can be added to the other simulators as well when fast
+                 // calls having both GP and FP params need to be supported.
   };
 
   // kCallbackOptionsType is not part of the Type enum
@@ -404,6 +413,37 @@ class V8_EXPORT CFunctionInfo {
   const CTypeInfo* arg_info_;
 };
 
+struct FastApiCallbackOptions;
+
+// Provided for testing.
+struct 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;
+    Local<Object> object_value;
+    Local<Array> sequence_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;
+    FastApiCallbackOptions* options_value;
+  };
+};
+
+static_assert(
+    sizeof(AnyCType) == 8,
+    "The AnyCType struct should have size == 64 bits, as this is assumed "
+    "by EffectControlLinearizer.");
+
 class V8_EXPORT CFunction {
  public:
   constexpr CFunction() : address_(nullptr), type_info_(nullptr) {}
@@ -460,10 +500,17 @@ class V8_EXPORT CFunction {
     return ArgUnwrap<F*>::Make(func);
   }
 
-  template <typename F>
-  V8_DEPRECATED("Use CFunctionBuilder instead.")
-  static CFunction MakeWithFallbackSupport(F* func) {
-    return ArgUnwrap<F*>::Make(func);
+  // Provided for testing purposes.
+  template <typename R, typename... Args, typename R_Patch,
+            typename... Args_Patch>
+  static CFunction Make(R (*func)(Args...),
+                        R_Patch (*patching_func)(Args_Patch...)) {
+    CFunction c_func = ArgUnwrap<R (*)(Args...)>::Make(func);
+    static_assert(
+        sizeof...(Args_Patch) == sizeof...(Args),
+        "The patching function must have the same number of arguments.");
+    c_func.address_ = reinterpret_cast<void*>(patching_func);
+    return c_func;
   }
 
   CFunction(const void* address, const CFunctionInfo* type_info);
@@ -485,10 +532,6 @@ class V8_EXPORT CFunction {
   };
 };
 
-struct ApiObject {
-  uintptr_t address;
-};
-
 /**
  * A struct which may be passed to a fast call callback, like so:
  * \code
@@ -561,7 +604,8 @@ class CFunctionInfoImpl : public CFunctionInfo {
                       kReturnType == CTypeInfo::Type::kInt32 ||
                       kReturnType == CTypeInfo::Type::kUint32 ||
                       kReturnType == CTypeInfo::Type::kFloat32 ||
-                      kReturnType == CTypeInfo::Type::kFloat64,
+                      kReturnType == CTypeInfo::Type::kFloat64 ||
+                      kReturnType == CTypeInfo::Type::kAny,
                   "64-bit int and api object values are not currently "
                   "supported return types.");
   }
@@ -612,7 +656,7 @@ struct CTypeInfoTraits {};
   V(void, kVoid)                     \
   V(v8::Local<v8::Value>, kV8Value)  \
   V(v8::Local<v8::Object>, kV8Value) \
-  V(ApiObject, kApiObject)
+  V(AnyCType, kAny)
 
 // ApiObject was a temporary solution to wrap the pointer to the v8::Value.
 // Please use v8::Local<v8::Value> in new code for the arguments and
@@ -684,17 +728,19 @@ struct TypeInfoHelper<FastApiCallbackOptions&> {
 #define STATIC_ASSERT_IMPLIES(COND, ASSERTION, MSG) \
   static_assert(((COND) == 0) || (ASSERTION), MSG)
 
+}  // namespace internal
+
 template <typename T, CTypeInfo::Flags... Flags>
-class CTypeInfoBuilder {
+class V8_EXPORT CTypeInfoBuilder {
  public:
   using BaseType = T;
 
   static constexpr CTypeInfo Build() {
     constexpr CTypeInfo::Flags kFlags =
-        MergeFlags(TypeInfoHelper<T>::Flags(), Flags...);
-    constexpr CTypeInfo::Type kType = TypeInfoHelper<T>::Type();
+        MergeFlags(internal::TypeInfoHelper<T>::Flags(), Flags...);
+    constexpr CTypeInfo::Type kType = internal::TypeInfoHelper<T>::Type();
     constexpr CTypeInfo::SequenceType kSequenceType =
-        TypeInfoHelper<T>::SequenceType();
+        internal::TypeInfoHelper<T>::SequenceType();
 
     STATIC_ASSERT_IMPLIES(
         uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kAllowSharedBit),
@@ -722,8 +768,8 @@ class CTypeInfoBuilder {
         "TypedArrays are only supported from primitive types or void.");
 
     // Return the same type with the merged flags.
-    return CTypeInfo(TypeInfoHelper<T>::Type(),
-                     TypeInfoHelper<T>::SequenceType(), kFlags);
+    return CTypeInfo(internal::TypeInfoHelper<T>::Type(),
+                     internal::TypeInfoHelper<T>::SequenceType(), kFlags);
   }
 
  private:
@@ -735,6 +781,7 @@ class CTypeInfoBuilder {
   static constexpr CTypeInfo::Flags MergeFlags() { return CTypeInfo::Flags(0); }
 };
 
+namespace internal {
 template <typename RetBuilder, typename... ArgBuilders>
 class CFunctionBuilderWithFunction {
  public:
@@ -835,14 +882,14 @@ static constexpr CTypeInfo kTypeInfoFloat64 =
  * returns true on success. `type_info` will be used for conversions.
  */
 template <const CTypeInfo* type_info, typename T>
-V8_DEPRECATE_SOON(
+V8_DEPRECATED(
     "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
 bool V8_EXPORT V8_WARN_UNUSED_RESULT
     TryCopyAndConvertArrayToCppBuffer(Local<Array> src, T* dst,
                                       uint32_t max_length);
 
 template <>
-V8_DEPRECATE_SOON(
+V8_DEPRECATED(
     "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
 inline bool V8_WARN_UNUSED_RESULT
     TryCopyAndConvertArrayToCppBuffer<&kTypeInfoInt32, int32_t>(
@@ -851,7 +898,7 @@ inline bool V8_WARN_UNUSED_RESULT
 }
 
 template <>
-V8_DEPRECATE_SOON(
+V8_DEPRECATED(
     "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
 inline bool V8_WARN_UNUSED_RESULT
     TryCopyAndConvertArrayToCppBuffer<&kTypeInfoFloat64, double>(
@@ -864,24 +911,28 @@ bool V8_EXPORT V8_WARN_UNUSED_RESULT TryToCopyAndConvertArrayToCppBuffer(
     Local<Array> src, T* dst, uint32_t max_length);
 
 template <>
-bool V8_EXPORT V8_WARN_UNUSED_RESULT TryToCopyAndConvertArrayToCppBuffer<
-    internal::CTypeInfoBuilder<int32_t>::Build().GetId(), int32_t>(
-    Local<Array> src, int32_t* dst, uint32_t max_length);
+bool V8_EXPORT V8_WARN_UNUSED_RESULT
+TryToCopyAndConvertArrayToCppBuffer<CTypeInfoBuilder<int32_t>::Build().GetId(),
+                                    int32_t>(Local<Array> src, int32_t* dst,
+                                             uint32_t max_length);
 
 template <>
-bool V8_EXPORT V8_WARN_UNUSED_RESULT TryToCopyAndConvertArrayToCppBuffer<
-    internal::CTypeInfoBuilder<uint32_t>::Build().GetId(), uint32_t>(
-    Local<Array> src, uint32_t* dst, uint32_t max_length);
+bool V8_EXPORT V8_WARN_UNUSED_RESULT
+TryToCopyAndConvertArrayToCppBuffer<CTypeInfoBuilder<uint32_t>::Build().GetId(),
+                                    uint32_t>(Local<Array> src, uint32_t* dst,
+                                              uint32_t max_length);
 
 template <>
-bool V8_EXPORT V8_WARN_UNUSED_RESULT TryToCopyAndConvertArrayToCppBuffer<
-    internal::CTypeInfoBuilder<float>::Build().GetId(), float>(
-    Local<Array> src, float* dst, uint32_t max_length);
+bool V8_EXPORT V8_WARN_UNUSED_RESULT
+TryToCopyAndConvertArrayToCppBuffer<CTypeInfoBuilder<float>::Build().GetId(),
+                                    float>(Local<Array> src, float* dst,
+                                           uint32_t max_length);
 
 template <>
-bool V8_EXPORT V8_WARN_UNUSED_RESULT TryToCopyAndConvertArrayToCppBuffer<
-    internal::CTypeInfoBuilder<double>::Build().GetId(), double>(
-    Local<Array> src, double* dst, uint32_t max_length);
+bool V8_EXPORT V8_WARN_UNUSED_RESULT
+TryToCopyAndConvertArrayToCppBuffer<CTypeInfoBuilder<double>::Build().GetId(),
+                                    double>(Local<Array> src, double* dst,
+                                            uint32_t max_length);
 
 }  // namespace v8
 

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

@@ -18,6 +18,7 @@
 namespace v8 {
 
 class Context;
+class UnboundScript;
 
 /**
  * A JavaScript function object (ECMA-262, 15.3).
@@ -58,6 +59,8 @@ class V8_EXPORT Function : public Object {
   void SetName(Local<String> name);
   Local<Value> GetName() const;
 
+  MaybeLocal<UnboundScript> GetUnboundScript() const;
+
   /**
    * Name inferred from variable or property assignment of this function.
    * Used to facilitate debugging and profiling of JavaScript code written