libv8-node 15.14.0.1-aarch64-linux → 16.10.0.0-aarch64-linux

data/vendor/v8/include/v8.h

@@ -19,6 +19,7 @@
 #include <stdint.h>
 #include <stdio.h>
 
+#include <atomic>
 #include <memory>
 #include <string>
 #include <type_traits>
@@ -46,9 +47,13 @@ class BigIntObject;
 class Boolean;
 class BooleanObject;
 class CFunction;
+class CallHandlerHelper;
 class Context;
+class CppHeap;
+class CTypeInfo;
 class Data;
 class Date;
+class EscapableHandleScope;
 class External;
 class Function;
 class FunctionTemplate;
@@ -57,8 +62,7 @@ class ImplementationUtilities;
 class Int32;
 class Integer;
 class Isolate;
-template <class T>
-class Maybe;
+class Isolate;
 class MicrotaskQueue;
 class Name;
 class Number;
@@ -68,6 +72,8 @@ class ObjectOperationDescriptor;
 class ObjectTemplate;
 class Platform;
 class Primitive;
+class PrimitiveArray;
+class Private;
 class Promise;
 class PropertyDescriptor;
 class Proxy;
@@ -75,72 +81,72 @@ class RawOperationDescriptor;
 class Script;
 class SharedArrayBuffer;
 class Signature;
-class StartupData;
 class StackFrame;
 class StackTrace;
+class StartupData;
 class String;
 class StringObject;
 class Symbol;
 class SymbolObject;
-class PrimitiveArray;
-class Private;
+class TracedReferenceBase;
 class Uint32;
 class Utils;
 class Value;
+class WasmMemoryObject;
 class WasmModuleObject;
-template <class T> class Local;
-template <class T>
-class MaybeLocal;
-template <class T> class Eternal;
+template <class K, class V, class T>
+class GlobalValueMap;
+template <class K, class V, class T>
+class PersistentValueMapBase;
 template<class T> class NonCopyablePersistentTraits;
-template<class T> class PersistentBase;
-template <class T, class M = NonCopyablePersistentTraits<T> >
+template <class T, class M = NonCopyablePersistentTraits<T>>
 class Persistent;
 template <class T>
+class BasicTracedReference;
+template <class T>
+class Eternal;
+template <class T>
 class Global;
 template <class T>
+class Local;
+template <class T>
+class Maybe;
+template <class T>
+class MaybeLocal;
+template <class T>
 class TracedGlobal;
 template <class T>
 class TracedReference;
-template <class T>
-class TracedReferenceBase;
 template<class K, class V, class T> class PersistentValueMap;
-template <class K, class V, class T>
-class PersistentValueMapBase;
-template <class K, class V, class T>
-class GlobalValueMap;
-template<class V, class T> class PersistentValueVector;
 template<class T, class P> class WeakCallbackObject;
-class FunctionTemplate;
-class ObjectTemplate;
+template <class T>
+class PersistentBase;
+template <class V, class T>
+class PersistentValueVector;
 template<typename T> class FunctionCallbackInfo;
 template<typename T> class PropertyCallbackInfo;
-class StackTrace;
-class StackFrame;
-class Isolate;
-class CallHandlerHelper;
-class EscapableHandleScope;
 template<typename T> class ReturnValue;
 
 namespace internal {
-enum class ArgumentsType;
-template <ArgumentsType>
-class Arguments;
-template <typename T>
-class CustomArguments;
+class BasicTracedReferenceExtractor;
+class ExternalString;
 class FunctionCallbackArguments;
 class GlobalHandles;
 class Heap;
 class HeapObject;
-class ExternalString;
 class Isolate;
 class LocalEmbedderHeapTracer;
 class MicrotaskQueue;
 class PropertyCallbackArguments;
 class ReadOnlyHeap;
 class ScopedExternalStringLock;
-struct ScriptStreamingData;
 class ThreadLocalTop;
+struct ScriptStreamingData;
+enum class ArgumentsType;
+template <ArgumentsType>
+class Arguments;
+template <typename T>
+class CustomArguments;
 
 namespace wasm {
 class NativeModule;
@@ -300,9 +306,10 @@ class Local {
   V8_INLINE static Local<T> New(Isolate* isolate,
                                 const PersistentBase<T>& that);
   V8_INLINE static Local<T> New(Isolate* isolate,
-                                const TracedReferenceBase<T>& that);
+                                const BasicTracedReference<T>& that);
 
  private:
+  friend class TracedReferenceBase;
   friend class Utils;
   template<class F> friend class Eternal;
   template<class F> friend class PersistentBase;
@@ -334,7 +341,7 @@ class Local {
   template <class F>
   friend class TracedGlobal;
   template <class F>
-  friend class TracedReferenceBase;
+  friend class BasicTracedReference;
   template <class F>
   friend class TracedReference;
 
@@ -429,7 +436,7 @@ static const int kEmbedderFieldsInWeakCallback = 2;
 template <typename T>
 class WeakCallbackInfo {
  public:
-  typedef void (*Callback)(const WeakCallbackInfo<T>& data);
+  using Callback = void (*)(const WeakCallbackInfo<T>& data);
 
   WeakCallbackInfo(Isolate* isolate, T* parameter,
                    void* embedder_fields[kEmbedderFieldsInWeakCallback],
@@ -590,7 +597,7 @@ template <class T> class PersistentBase {
    */
   V8_INLINE uint16_t WrapperClassId() const;
 
-  PersistentBase(const PersistentBase& other) = delete;  // NOLINT
+  PersistentBase(const PersistentBase& other) = delete;
   void operator=(const PersistentBase&) = delete;
 
  private:
@@ -623,7 +630,7 @@ template <class T> class PersistentBase {
 template<class T>
 class NonCopyablePersistentTraits {
  public:
-  typedef Persistent<T, NonCopyablePersistentTraits<T> > NonCopyablePersistent;
+  using NonCopyablePersistent = Persistent<T, NonCopyablePersistentTraits<T>>;
   static const bool kResetInDestructor = false;
   template<class S, class M>
   V8_INLINE static void Copy(const Persistent<S, M>& source,
@@ -640,7 +647,7 @@ class NonCopyablePersistentTraits {
  */
 template<class T>
 struct CopyablePersistentTraits {
-  typedef Persistent<T, CopyablePersistentTraits<T> > CopyablePersistent;
+  using CopyablePersistent = Persistent<T, CopyablePersistentTraits<T>>;
   static const bool kResetInDestructor = true;
   template<class S, class M>
   static V8_INLINE void Copy(const Persistent<S, M>& source,
@@ -702,7 +709,7 @@ template <class T, class M> class Persistent : public PersistentBase<T> {
     return *this;
   }
   template <class S, class M2>
-  V8_INLINE Persistent& operator=(const Persistent<S, M2>& that) { // NOLINT
+  V8_INLINE Persistent& operator=(const Persistent<S, M2>& that) {
     Copy(that);
     return *this;
   }
@@ -717,7 +724,7 @@ template <class T, class M> class Persistent : public PersistentBase<T> {
 
   // TODO(dcarney): this is pretty useless, fix or remove
   template <class S>
-  V8_INLINE static Persistent<T>& Cast(const Persistent<S>& that) {  // NOLINT
+  V8_INLINE static Persistent<T>& Cast(const Persistent<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.
@@ -728,7 +735,7 @@ template <class T, class M> class Persistent : public PersistentBase<T> {
 
   // TODO(dcarney): this is pretty useless, fix or remove
   template <class S>
-  V8_INLINE Persistent<S>& As() const {  // NOLINT
+  V8_INLINE Persistent<S>& As() const {
     return Persistent<S>::Cast(*this);
   }
 
@@ -797,12 +804,12 @@ class Global : public PersistentBase<T> {
   /**
    * Pass allows returning uniques from functions, etc.
    */
-  Global Pass() { return static_cast<Global&&>(*this); }  // NOLINT
+  Global Pass() { return static_cast<Global&&>(*this); }
 
   /*
    * For compatibility with Chromium's base::Bind (base::Passed).
    */
-  typedef void MoveOnlyTypeForCPP03;
+  using MoveOnlyTypeForCPP03 = void;
 
   Global(const Global&) = delete;
   void operator=(const Global&) = delete;
@@ -824,27 +831,11 @@ using UniquePersistent = Global<T>;
 template <typename T>
 struct TracedGlobalTrait {};
 
-/**
- * A traced handle with copy and move semantics. The handle is to be used
- * together with |v8::EmbedderHeapTracer| and specifies edges from the embedder
- * into V8's heap.
- *
- * The exact semantics are:
- * - Tracing garbage collections use |v8::EmbedderHeapTracer|.
- * - Non-tracing garbage collections refer to
- *   |v8::EmbedderHeapTracer::IsRootForNonTracingGC()| whether the handle should
- *   be treated as root or not.
- *
- * Note that the base class cannot be instantiated itself. Choose from
- * - TracedGlobal
- * - TracedReference
- */
-template <typename T>
 class TracedReferenceBase {
  public:
   /**
-   * Returns true if this TracedReferenceBase is empty, i.e., has not been
-   * assigned an object.
+   * Returns true if the reference is empty, i.e., has not been assigned
+   * object.
    */
   bool IsEmpty() const { return val_ == nullptr; }
 
@@ -855,36 +846,16 @@ class TracedReferenceBase {
   V8_INLINE void Reset();
 
   /**
-   * Construct a Local<T> from this handle.
+   * Construct a Local<Value> from this handle.
    */
-  Local<T> Get(Isolate* isolate) const { return Local<T>::New(isolate, *this); }
-
-  template <class S>
-  V8_INLINE bool operator==(const TracedReferenceBase<S>& that) const {
-    internal::Address* a = reinterpret_cast<internal::Address*>(val_);
-    internal::Address* b = reinterpret_cast<internal::Address*>(that.val_);
-    if (a == nullptr) return b == nullptr;
-    if (b == nullptr) return false;
-    return *a == *b;
-  }
-
-  template <class S>
-  V8_INLINE bool operator==(const Local<S>& that) const {
-    internal::Address* a = reinterpret_cast<internal::Address*>(val_);
-    internal::Address* b = reinterpret_cast<internal::Address*>(that.val_);
-    if (a == nullptr) return b == nullptr;
-    if (b == nullptr) return false;
-    return *a == *b;
-  }
-
-  template <class S>
-  V8_INLINE bool operator!=(const TracedReferenceBase<S>& that) const {
-    return !operator==(that);
-  }
+  V8_INLINE v8::Local<v8::Value> Get(v8::Isolate* isolate) const;
 
-  template <class S>
-  V8_INLINE bool operator!=(const Local<S>& that) const {
-    return !operator==(that);
+  /**
+   * Returns true if this TracedReference is empty, i.e., has not been
+   * assigned an object. This version of IsEmpty is thread-safe.
+   */
+  bool IsEmptyThreadSafe() const {
+    return this->GetSlotThreadSafe() == nullptr;
   }
 
   /**
@@ -898,41 +869,89 @@ class TracedReferenceBase {
    */
   V8_INLINE uint16_t WrapperClassId() const;
 
-  template <class S>
-  V8_INLINE TracedReferenceBase<S>& As() const {
-    return reinterpret_cast<TracedReferenceBase<S>&>(
-        const_cast<TracedReferenceBase<T>&>(*this));
-  }
-
  protected:
   /**
-   * Update this reference in a thread-safe way
+   * Update this reference in a thread-safe way.
    */
-  void SetSlotThreadSafe(T* new_val) {
-    reinterpret_cast<std::atomic<T*>*>(&val_)->store(new_val,
-                                                     std::memory_order_relaxed);
+  void SetSlotThreadSafe(void* new_val) {
+    reinterpret_cast<std::atomic<void*>*>(&val_)->store(
+        new_val, std::memory_order_relaxed);
   }
 
   /**
    * Get this reference in a thread-safe way
    */
-  const T* GetSlotThreadSafe() const {
-    return reinterpret_cast<std::atomic<const T*> const*>(&val_)->load(
+  const void* GetSlotThreadSafe() const {
+    return reinterpret_cast<std::atomic<const void*> const*>(&val_)->load(
         std::memory_order_relaxed);
   }
 
+  V8_EXPORT void CheckValue() const;
+
+  // val_ points to a GlobalHandles node.
+  internal::Address* val_ = nullptr;
+
+  friend class internal::BasicTracedReferenceExtractor;
+  template <typename F>
+  friend class Local;
+  template <typename U>
+  friend bool operator==(const TracedReferenceBase&, const Local<U>&);
+  friend bool operator==(const TracedReferenceBase&,
+                         const TracedReferenceBase&);
+};
+
+/**
+ * A traced handle with copy and move semantics. The handle is to be used
+ * together with |v8::EmbedderHeapTracer| or as part of GarbageCollected objects
+ * (see v8-cppgc.h) and specifies edges from C++ objects to JavaScript.
+ *
+ * The exact semantics are:
+ * - Tracing garbage collections use |v8::EmbedderHeapTracer| or cppgc.
+ * - Non-tracing garbage collections refer to
+ *   |v8::EmbedderRootsHandler::IsRoot()| whether the handle should
+ * be treated as root or not.
+ *
+ * Note that the base class cannot be instantiated itself. Choose from
+ * - TracedGlobal
+ * - TracedReference
+ */
+template <typename T>
+class BasicTracedReference : public TracedReferenceBase {
+ public:
+  /**
+   * Construct a Local<T> from this handle.
+   */
+  Local<T> Get(Isolate* isolate) const { return Local<T>::New(isolate, *this); }
+
+  template <class S>
+  V8_INLINE BasicTracedReference<S>& As() const {
+    return reinterpret_cast<BasicTracedReference<S>&>(
+        const_cast<BasicTracedReference<T>&>(*this));
+  }
+
+  T* operator->() const {
+#ifdef V8_ENABLE_CHECKS
+    CheckValue();
+#endif  // V8_ENABLE_CHECKS
+    return reinterpret_cast<T*>(val_);
+  }
+  T* operator*() const {
+#ifdef V8_ENABLE_CHECKS
+    CheckValue();
+#endif  // V8_ENABLE_CHECKS
+    return reinterpret_cast<T*>(val_);
+  }
+
  private:
   enum DestructionMode { kWithDestructor, kWithoutDestructor };
 
   /**
-   * An empty TracedReferenceBase without storage cell.
+   * An empty BasicTracedReference without storage cell.
    */
-  TracedReferenceBase() = default;
+  BasicTracedReference() = default;
 
-  V8_INLINE static T* New(Isolate* isolate, T* that, void* slot,
-                          DestructionMode destruction_mode);
-
-  T* val_ = nullptr;
+  V8_INLINE static internal::Address* New(Isolate* isolate, T* that, void* slot,
+                                          DestructionMode destruction_mode);
 
   friend class EmbedderHeapTracer;
   template <typename F>
@@ -943,27 +962,29 @@ class TracedReferenceBase {
   template <typename F>
   friend class TracedReference;
   template <typename F>
+  friend class BasicTracedReference;
+  template <typename F>
   friend class ReturnValue;
 };
 
 /**
  * A traced handle with destructor that clears the handle. For more details see
- * TracedReferenceBase.
+ * BasicTracedReference.
  */
 template <typename T>
-class TracedGlobal : public TracedReferenceBase<T> {
+class TracedGlobal : public BasicTracedReference<T> {
  public:
-  using TracedReferenceBase<T>::Reset;
+  using BasicTracedReference<T>::Reset;
 
   /**
-   * Destructor resetting the handle.
+   * Destructor resetting the handle.Is
    */
   ~TracedGlobal() { this->Reset(); }
 
   /**
    * An empty TracedGlobal without storage cell.
    */
-  TracedGlobal() : TracedReferenceBase<T>() {}
+  TracedGlobal() : BasicTracedReference<T>() {}
 
   /**
    * Construct a TracedGlobal from a Local.
@@ -972,9 +993,9 @@ class TracedGlobal : public TracedReferenceBase<T> {
    * pointing to the same object.
    */
   template <class S>
-  TracedGlobal(Isolate* isolate, Local<S> that) : TracedReferenceBase<T>() {
+  TracedGlobal(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
     this->val_ = this->New(isolate, that.val_, &this->val_,
-                           TracedReferenceBase<T>::kWithDestructor);
+                           BasicTracedReference<T>::kWithDestructor);
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -1071,7 +1092,7 @@ class TracedGlobal : public TracedReferenceBase<T> {
  * A traced handle without destructor that clears the handle. The embedder needs
  * to ensure that the handle is not accessed once the V8 object has been
  * reclaimed. This can happen when the handle is not passed through the
- * EmbedderHeapTracer. For more details see TracedReferenceBase.
+ * EmbedderHeapTracer. For more details see BasicTracedReference.
  *
  * The reference assumes the embedder has precise knowledge about references at
  * all times. In case V8 needs to separately handle on-stack references, the
@@ -1079,14 +1100,14 @@ class TracedGlobal : public TracedReferenceBase<T> {
  * |EmbedderHeapTracer::SetStackStart|.
  */
 template <typename T>
-class TracedReference : public TracedReferenceBase<T> {
+class TracedReference : public BasicTracedReference<T> {
  public:
-  using TracedReferenceBase<T>::Reset;
+  using BasicTracedReference<T>::Reset;
 
   /**
    * An empty TracedReference without storage cell.
    */
-  TracedReference() : TracedReferenceBase<T>() {}
+  TracedReference() : BasicTracedReference<T>() {}
 
   /**
    * Construct a TracedReference from a Local.
@@ -1095,9 +1116,9 @@ class TracedReference : public TracedReferenceBase<T> {
    * pointing to the same object.
    */
   template <class S>
-  TracedReference(Isolate* isolate, Local<S> that) : TracedReferenceBase<T>() {
+  TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
     this->val_ = this->New(isolate, that.val_, &this->val_,
-                           TracedReferenceBase<T>::kWithoutDestructor);
+                           BasicTracedReference<T>::kWithoutDestructor);
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -1173,14 +1194,6 @@ class TracedReference : public TracedReferenceBase<T> {
     return reinterpret_cast<TracedReference<S>&>(
         const_cast<TracedReference<T>&>(*this));
   }
-
-  /**
-   * Returns true if this TracedReference is empty, i.e., has not been
-   * assigned an object. This version of IsEmpty is thread-safe.
-   */
-  bool IsEmptyThreadSafe() const {
-    return this->GetSlotThreadSafe() == nullptr;
-  }
 };
 
  /**
@@ -1197,7 +1210,7 @@ class TracedReference : public TracedReferenceBase<T> {
  * handle and may deallocate it.  The behavior of accessing a handle
  * for which the handle scope has been deleted is undefined.
  */
-class V8_EXPORT HandleScope {
+class V8_EXPORT V8_NODISCARD HandleScope {
  public:
   explicit HandleScope(Isolate* isolate);
 
@@ -1244,12 +1257,11 @@ class V8_EXPORT HandleScope {
   friend class Context;
 };
 
-
 /**
  * A HandleScope which first allocates a handle in the current scope
  * which will be later filled with the escape value.
  */
-class V8_EXPORT EscapableHandleScope : public HandleScope {
+class V8_EXPORT V8_NODISCARD EscapableHandleScope : public HandleScope {
  public:
   explicit EscapableHandleScope(Isolate* isolate);
   V8_INLINE ~EscapableHandleScope() = default;
@@ -1290,7 +1302,7 @@ class V8_EXPORT EscapableHandleScope : public HandleScope {
  * are allowed. It can be useful for debugging handle leaks.
  * Handles can be allocated within inner normal HandleScopes.
  */
-class V8_EXPORT SealHandleScope {
+class V8_EXPORT V8_NODISCARD SealHandleScope {
  public:
   explicit SealHandleScope(Isolate* isolate);
   ~SealHandleScope();
@@ -1311,13 +1323,43 @@ class V8_EXPORT SealHandleScope {
   int prev_sealed_level_;
 };
 
-
 // --- Special objects ---
 
 /**
  * The superclass of objects that can reside on V8's heap.
  */
 class V8_EXPORT Data {
+ public:
+  /**
+   * Returns true if this data is a |v8::Value|.
+   */
+  bool IsValue() const;
+
+  /**
+   * Returns true if this data is a |v8::Module|.
+   */
+  bool IsModule() const;
+
+  /**
+   * Returns true if this data is a |v8::Private|.
+   */
+  bool IsPrivate() const;
+
+  /**
+   * Returns true if this data is a |v8::ObjectTemplate|.
+   */
+  bool IsObjectTemplate() const;
+
+  /**
+   * Returns true if this data is a |v8::FunctionTemplate|.
+   */
+  bool IsFunctionTemplate() const;
+
+  /**
+   * Returns true if this data is a |v8::Context|.
+   */
+  bool IsContext() const;
+
  private:
   Data();
 };
@@ -1398,10 +1440,12 @@ class ScriptOriginOptions {
  */
 class ScriptOrigin {
  public:
-  V8_INLINE ScriptOrigin(
-      Local<Value> resource_name,
-      Local<Integer> resource_line_offset = Local<Integer>(),
-      Local<Integer> resource_column_offset = Local<Integer>(),
+#if defined(_MSC_VER) && _MSC_VER >= 1910 /* Disable on VS2015 */
+  V8_DEPRECATE_SOON("Use constructor with primitive C++ types")
+#endif
+  V8_INLINE explicit ScriptOrigin(
+      Local<Value> resource_name, Local<Integer> resource_line_offset,
+      Local<Integer> resource_column_offset,
       Local<Boolean> resource_is_shared_cross_origin = Local<Boolean>(),
       Local<Integer> script_id = Local<Integer>(),
       Local<Value> source_map_url = Local<Value>(),
@@ -1409,21 +1453,47 @@ class ScriptOrigin {
       Local<Boolean> is_wasm = Local<Boolean>(),
       Local<Boolean> is_module = Local<Boolean>(),
       Local<PrimitiveArray> host_defined_options = Local<PrimitiveArray>());
+#if defined(_MSC_VER) && _MSC_VER >= 1910 /* Disable on VS2015 */
+  V8_DEPRECATE_SOON("Use constructor that takes an isolate")
+#endif
+  V8_INLINE explicit ScriptOrigin(
+      Local<Value> resource_name, int resource_line_offset = 0,
+      int resource_column_offset = 0,
+      bool resource_is_shared_cross_origin = false, int script_id = -1,
+      Local<Value> source_map_url = Local<Value>(),
+      bool resource_is_opaque = false, bool is_wasm = false,
+      bool is_module = false,
+      Local<PrimitiveArray> host_defined_options = Local<PrimitiveArray>());
+  V8_INLINE explicit ScriptOrigin(
+      Isolate* isolate, Local<Value> resource_name,
+      int resource_line_offset = 0, int resource_column_offset = 0,
+      bool resource_is_shared_cross_origin = false, int script_id = -1,
+      Local<Value> source_map_url = Local<Value>(),
+      bool resource_is_opaque = false, bool is_wasm = false,
+      bool is_module = false,
+      Local<PrimitiveArray> host_defined_options = Local<PrimitiveArray>());
 
   V8_INLINE Local<Value> ResourceName() const;
+  V8_DEPRECATE_SOON("Use getter with primitvie C++ types.")
   V8_INLINE Local<Integer> ResourceLineOffset() const;
+  V8_DEPRECATE_SOON("Use getter with primitvie C++ types.")
   V8_INLINE Local<Integer> ResourceColumnOffset() const;
+  V8_DEPRECATE_SOON("Use getter with primitvie C++ types.")
   V8_INLINE Local<Integer> ScriptID() const;
+  V8_INLINE int LineOffset() const;
+  V8_INLINE int ColumnOffset() const;
+  V8_INLINE int ScriptId() const;
   V8_INLINE Local<Value> SourceMapUrl() const;
   V8_INLINE Local<PrimitiveArray> HostDefinedOptions() const;
   V8_INLINE ScriptOriginOptions Options() const { return options_; }
 
  private:
+  Isolate* isolate_;
   Local<Value> resource_name_;
-  Local<Integer> resource_line_offset_;
-  Local<Integer> resource_column_offset_;
+  int resource_line_offset_;
+  int resource_column_offset_;
   ScriptOriginOptions options_;
-  Local<Integer> script_id_;
+  int script_id_;
   Local<Value> source_map_url_;
   Local<PrimitiveArray> host_defined_options_;
 };
@@ -1482,6 +1552,50 @@ class V8_EXPORT Location {
   int column_number_;
 };
 
+/**
+ * A fixed-sized array with elements of type Data.
+ */
+class V8_EXPORT FixedArray : public Data {
+ public:
+  int Length() const;
+  Local<Data> Get(Local<Context> context, int i) const;
+};
+
+class V8_EXPORT ModuleRequest : public Data {
+ public:
+  /**
+   * Returns the module specifier for this ModuleRequest.
+   */
+  Local<String> GetSpecifier() const;
+
+  /**
+   * Returns the source code offset of this module request.
+   * Use Module::SourceOffsetToLocation to convert this to line/column numbers.
+   */
+  int GetSourceOffset() const;
+
+  /**
+   * Contains the import assertions for this request in the form:
+   * [key1, value1, source_offset1, key2, value2, source_offset2, ...].
+   * The keys and values are of type v8::String, and the source offsets are of
+   * type Int32. Use Module::SourceOffsetToLocation to convert the source
+   * offsets to Locations with line/column numbers.
+   *
+   * All assertions present in the module request will be supplied in this
+   * list, regardless of whether they are supported by the host. Per
+   * https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions,
+   * hosts are expected to ignore assertions that they do not support (as
+   * opposed to, for example, triggering an error if an unsupported assertion is
+   * present).
+   */
+  Local<FixedArray> GetImportAssertions() const;
+
+  V8_INLINE static ModuleRequest* Cast(Data* data);
+
+ private:
+  static void CheckCast(Data* obj);
+};
+
 /**
  * A compiled JavaScript module.
  */
@@ -1516,28 +1630,48 @@ class V8_EXPORT Module : public Data {
   /**
    * Returns the number of modules requested by this module.
    */
+  V8_DEPRECATE_SOON("Use Module::GetModuleRequests() and FixedArray::Length().")
   int GetModuleRequestsLength() const;
 
   /**
    * Returns the ith module specifier in this module.
    * i must be < GetModuleRequestsLength() and >= 0.
    */
+  V8_DEPRECATE_SOON(
+      "Use Module::GetModuleRequests() and ModuleRequest::GetSpecifier().")
   Local<String> GetModuleRequest(int i) const;
 
   /**
    * Returns the source location (line number and column number) of the ith
    * module specifier's first occurrence in this module.
    */
+  V8_DEPRECATE_SOON(
+      "Use Module::GetModuleRequests(), ModuleRequest::GetSourceOffset(), and "
+      "Module::SourceOffsetToLocation().")
   Location GetModuleRequestLocation(int i) const;
 
+  /**
+   * Returns the ModuleRequests for this module.
+   */
+  Local<FixedArray> GetModuleRequests() const;
+
+  /**
+   * For the given source text offset in this module, returns the corresponding
+   * Location with line and column numbers.
+   */
+  Location SourceOffsetToLocation(int offset) const;
+
   /**
    * Returns the identity hash for this object.
    */
   int GetIdentityHash() const;
 
-  typedef MaybeLocal<Module> (*ResolveCallback)(Local<Context> context,
-                                                Local<String> specifier,
-                                                Local<Module> referrer);
+  using ResolveCallback =
+      MaybeLocal<Module> (*)(Local<Context> context, Local<String> specifier,
+                             Local<Module> referrer);
+  using ResolveModuleCallback = MaybeLocal<Module> (*)(
+      Local<Context> context, Local<String> specifier,
+      Local<FixedArray> import_assertions, Local<Module> referrer);
 
   /**
    * Instantiates the module and its dependencies.
@@ -1546,16 +1680,23 @@ class V8_EXPORT Module : public Data {
    * instantiation. (In the case where the callback throws an exception, that
    * exception is propagated.)
    */
+  V8_DEPRECATE_SOON(
+      "Use the version of InstantiateModule that takes a ResolveModuleCallback "
+      "parameter")
   V8_WARN_UNUSED_RESULT Maybe<bool> InstantiateModule(Local<Context> context,
                                                       ResolveCallback callback);
+  V8_WARN_UNUSED_RESULT Maybe<bool> InstantiateModule(
+      Local<Context> context, ResolveModuleCallback callback);
 
   /**
    * Evaluates the module and its dependencies.
    *
-   * If status is kInstantiated, run the module's code. On success, set status
-   * to kEvaluated and return the completion value; on failure, set status to
-   * kErrored and propagate the thrown exception (which is then also available
-   * via |GetException|).
+   * If status is kInstantiated, run the module's code and return a Promise
+   * object. On success, set status to kEvaluated and resolve the Promise with
+   * the completion value; on failure, set status to kErrored and reject the
+   * Promise with the error.
+   *
+   * If IsGraphAsync() is false, the returned Promise is settled.
    */
   V8_WARN_UNUSED_RESULT MaybeLocal<Value> Evaluate(Local<Context> context);
 
@@ -1581,6 +1722,14 @@ class V8_EXPORT Module : public Data {
    */
   int ScriptId();
 
+  /**
+   * Returns whether this module or any of its requested modules is async,
+   * i.e. contains top-level await.
+   *
+   * The module's status must be at least kInstantiated.
+   */
+  bool IsGraphAsync() const;
+
   /**
    * Returns whether the module is a SourceTextModule.
    */
@@ -1594,12 +1743,12 @@ class V8_EXPORT Module : public Data {
   /*
    * Callback defined in the embedder.  This is responsible for setting
    * the module's exported values with calls to SetSyntheticModuleExport().
-   * The callback must return a Value to indicate success (where no
+   * The callback must return a resolved Promise to indicate success (where no
    * exception was thrown) and return an empy MaybeLocal to indicate falure
    * (where an exception was thrown).
    */
-  typedef MaybeLocal<Value> (*SyntheticModuleEvaluationSteps)(
-      Local<Context> context, Local<Module> module);
+  using SyntheticModuleEvaluationSteps =
+      MaybeLocal<Value> (*)(Local<Context> context, Local<Module> module);
 
   /**
    * Creates a new SyntheticModule with the specified export names, where
@@ -1622,13 +1771,18 @@ class V8_EXPORT Module : public Data {
    */
   V8_WARN_UNUSED_RESULT Maybe<bool> SetSyntheticModuleExport(
       Isolate* isolate, Local<String> export_name, Local<Value> export_value);
-  V8_DEPRECATE_SOON(
+  V8_DEPRECATED(
       "Use the preceding SetSyntheticModuleExport with an Isolate parameter, "
       "instead of the one that follows.  The former will throw a runtime "
       "error if called for an export that doesn't exist (as per spec); "
       "the latter will crash with a failed CHECK().")
   void SetSyntheticModuleExport(Local<String> export_name,
                                 Local<Value> export_value);
+
+  V8_INLINE static Module* Cast(Data* data);
+
+ private:
+  static void CheckCast(Data* obj);
 };
 
 /**
@@ -1657,6 +1811,7 @@ class V8_EXPORT Script {
   Local<UnboundScript> GetUnboundScript();
 };
 
+enum class ScriptType { kClassic, kModule };
 
 /**
  * For compiling scripts.
@@ -1709,8 +1864,8 @@ class V8_EXPORT ScriptCompiler {
     // Source takes ownership of CachedData.
     V8_INLINE Source(Local<String> source_string, const ScriptOrigin& origin,
                      CachedData* cached_data = nullptr);
-    V8_INLINE Source(Local<String> source_string,
-                     CachedData* cached_data = nullptr);
+    V8_INLINE explicit Source(Local<String> source_string,
+                              CachedData* cached_data = nullptr);
     V8_INLINE ~Source();
 
     // Ownership of the CachedData or its buffers is *not* transferred to the
@@ -1731,8 +1886,8 @@ class V8_EXPORT ScriptCompiler {
 
     // Origin information
     Local<Value> resource_name;
-    Local<Integer> resource_line_offset;
-    Local<Integer> resource_column_offset;
+    int resource_line_offset;
+    int resource_column_offset;
     ScriptOriginOptions resource_options;
     Local<Value> source_map_url;
     Local<PrimitiveArray> host_defined_options;
@@ -1800,10 +1955,10 @@ class V8_EXPORT ScriptCompiler {
    */
   class V8_EXPORT StreamedSource {
    public:
-    enum Encoding { ONE_BYTE, TWO_BYTE, UTF8 };
+    enum Encoding { ONE_BYTE, TWO_BYTE, UTF8, WINDOWS_1252 };
 
 #if defined(_MSC_VER) && _MSC_VER >= 1910 /* Disable on VS2015 */
-    V8_DEPRECATE_SOON(
+    V8_DEPRECATED(
         "This class takes ownership of source_stream, so use the constructor "
         "taking a unique_ptr to make these semantics clearer")
 #endif
@@ -1824,7 +1979,7 @@ class V8_EXPORT ScriptCompiler {
 
   /**
    * A streaming task which the embedder must run on a background thread to
-   * stream scripts into V8. Returned by ScriptCompiler::StartStreamingScript.
+   * stream scripts into V8. Returned by ScriptCompiler::StartStreaming.
    */
   class V8_EXPORT ScriptStreamingTask final {
    public:
@@ -1873,7 +2028,8 @@ class V8_EXPORT ScriptCompiler {
    *
    * Note that when producing cached data, the source must point to NULL for
    * cached data. When consuming cached data, the cached data must have been
-   * produced by the same version of V8.
+   * produced by the same version of V8, and the embedder needs to ensure the
+   * cached data is the correct one for the given script.
    *
    * \param source Script source code.
    * \return Compiled script object (context independent; for running it must be
@@ -1911,9 +2067,13 @@ class V8_EXPORT ScriptCompiler {
    * This API allows to start the streaming with as little data as possible, and
    * the remaining data (for example, the ScriptOrigin) is passed to Compile.
    */
+  V8_DEPRECATED("Use ScriptCompiler::StartStreaming instead.")
   static ScriptStreamingTask* StartStreamingScript(
       Isolate* isolate, StreamedSource* source,
       CompileOptions options = kNoCompileOptions);
+  static ScriptStreamingTask* StartStreaming(
+      Isolate* isolate, StreamedSource* source,
+      ScriptType type = ScriptType::kClassic);
 
   /**
    * Compiles a streamed script (bound to current context).
@@ -1958,6 +2118,17 @@ class V8_EXPORT ScriptCompiler {
       CompileOptions options = kNoCompileOptions,
       NoCacheReason no_cache_reason = kNoCacheNoReason);
 
+  /**
+   * Compiles a streamed module script.
+   *
+   * This can only be called after the streaming has finished
+   * (ScriptStreamingTask has been run). V8 doesn't construct the source string
+   * during streaming, so the embedder needs to pass the full source here.
+   */
+  static V8_WARN_UNUSED_RESULT MaybeLocal<Module> CompileModule(
+      Local<Context> context, StreamedSource* v8_source,
+      Local<String> full_source_string, const ScriptOrigin& origin);
+
   /**
    * Compile a function for a given context. This is equivalent to running
    *
@@ -2018,6 +2189,8 @@ class V8_EXPORT Message {
    */
   Isolate* GetIsolate() const;
 
+  V8_WARN_UNUSED_RESULT MaybeLocal<String> GetSource(
+      Local<Context> context) const;
   V8_WARN_UNUSED_RESULT MaybeLocal<String> GetSourceLine(
       Local<Context> context) const;
 
@@ -2192,6 +2365,17 @@ class V8_EXPORT StackFrame {
    */
   Local<String> GetScriptNameOrSourceURL() const;
 
+  /**
+   * Returns the source of the script for the function for this StackFrame.
+   */
+  Local<String> GetScriptSource() const;
+
+  /**
+   * Returns the source mapping URL (if one is present) of the script for
+   * the function for this StackFrame.
+   */
+  Local<String> GetScriptSourceMappingURL() const;
+
   /**
    * Returns the name of the function associated with this stack frame.
    */
@@ -2234,14 +2418,25 @@ enum StateTag {
   IDLE
 };
 
+// Holds the callee saved registers needed for the stack unwinder. It is the
+// empty struct if no registers are required. Implemented in
+// include/v8-unwinder-state.h.
+struct CalleeSavedRegisters;
+
 // A RegisterState represents the current state of registers used
 // by the sampling profiler API.
-struct RegisterState {
-  RegisterState() : pc(nullptr), sp(nullptr), fp(nullptr), lr(nullptr) {}
+struct V8_EXPORT RegisterState {
+  RegisterState();
+  ~RegisterState();
+  RegisterState(const RegisterState& other);
+  RegisterState& operator=(const RegisterState& other);
+
   void* pc;  // Instruction pointer.
   void* sp;  // Stack pointer.
   void* fp;  // Frame pointer.
   void* lr;  // Link register (or nullptr on platforms without a link register).
+  // Callee saved registers (or null if no callee saved registers were stored)
+  std::unique_ptr<CalleeSavedRegisters> callee_saved;
 };
 
 // The output structure filled up by GetStackSample API function.
@@ -2262,14 +2457,6 @@ struct JSEntryStub {
   MemoryRange code;
 };
 
-struct UnwindState {
-  MemoryRange code_range;
-  MemoryRange embedded_code_range;
-  JSEntryStub js_entry_stub;
-  JSEntryStub js_construct_entry_stub;
-  JSEntryStub js_run_microtasks_entry_stub;
-};
-
 struct JSEntryStubs {
   JSEntryStub js_entry_stub;
   JSEntryStub js_construct_entry_stub;
@@ -2830,6 +3017,11 @@ class V8_EXPORT Value : public Data {
    */
   bool IsProxy() const;
 
+  /**
+   * Returns true if this value is a WasmMemoryObject.
+   */
+  bool IsWasmMemoryObject() const;
+
   /**
    * Returns true if this value is a WasmModuleObject.
    */
@@ -2934,6 +3126,8 @@ class V8_EXPORT Value : public Data {
   bool FullIsUndefined() const;
   bool FullIsNull() const;
   bool FullIsString() const;
+
+  static void CheckCast(Data* that);
 };
 
 
@@ -2950,11 +3144,11 @@ class V8_EXPORT Primitive : public Value { };
 class V8_EXPORT Boolean : public Primitive {
  public:
   bool Value() const;
-  V8_INLINE static Boolean* Cast(v8::Value* obj);
+  V8_INLINE static Boolean* Cast(v8::Data* data);
   V8_INLINE static Local<Boolean> New(Isolate* isolate, bool value);
 
  private:
-  static void CheckCast(v8::Value* obj);
+  static void CheckCast(v8::Data* that);
 };
 
 
@@ -2972,10 +3166,10 @@ class V8_EXPORT Name : public Primitive {
    */
   int GetIdentityHash();
 
-  V8_INLINE static Name* Cast(Value* obj);
+  V8_INLINE static Name* Cast(Data* data);
 
  private:
-  static void CheckCast(Value* obj);
+  static void CheckCast(Data* that);
 };
 
 /**
@@ -3089,16 +3283,21 @@ class V8_EXPORT String : public Name {
   V8_INLINE static Local<String> Empty(Isolate* isolate);
 
   /**
-   * Returns true if the string is external
+   * Returns true if the string is external.
    */
   bool IsExternal() const;
 
+  /**
+   * Returns true if the string is both external and two-byte.
+   */
+  bool IsExternalTwoByte() const;
+
   /**
    * Returns true if the string is both external and one-byte.
    */
   bool IsExternalOneByte() const;
 
-  class V8_EXPORT ExternalStringResourceBase {  // NOLINT
+  class V8_EXPORT ExternalStringResourceBase {
    public:
     virtual ~ExternalStringResourceBase() = default;
 
@@ -3164,7 +3363,8 @@ class V8_EXPORT String : public Name {
     ~ExternalStringResource() override = default;
 
     /**
-     * The string data from the underlying buffer.
+     * The string data from the underlying buffer. If the resource is cacheable
+     * then data() must return the same value for all invocations.
      */
     virtual const uint16_t* data() const = 0;
 
@@ -3173,8 +3373,29 @@ class V8_EXPORT String : public Name {
      */
     virtual size_t length() const = 0;
 
+    /**
+     * Returns the cached data from the underlying buffer. This method can be
+     * called only for cacheable resources (i.e. IsCacheable() == true) and only
+     * after UpdateDataCache() was called.
+     */
+    const uint16_t* cached_data() const {
+      CheckCachedDataInvariants();
+      return cached_data_;
+    }
+
+    /**
+     * Update {cached_data_} with the data from the underlying buffer. This can
+     * be called only for cacheable resources.
+     */
+    void UpdateDataCache();
+
    protected:
     ExternalStringResource() = default;
+
+   private:
+    void CheckCachedDataInvariants() const;
+
+    const uint16_t* cached_data_ = nullptr;
   };
 
   /**
@@ -3195,12 +3416,39 @@ class V8_EXPORT String : public Name {
      * buffer.
      */
     ~ExternalOneByteStringResource() override = default;
-    /** The string data from the underlying buffer.*/
+
+    /**
+     * The string data from the underlying buffer. If the resource is cacheable
+     * then data() must return the same value for all invocations.
+     */
     virtual const char* data() const = 0;
+
     /** The number of Latin-1 characters in the string.*/
     virtual size_t length() const = 0;
+
+    /**
+     * Returns the cached data from the underlying buffer. If the resource is
+     * uncacheable or if UpdateDataCache() was not called before, it has
+     * undefined behaviour.
+     */
+    const char* cached_data() const {
+      CheckCachedDataInvariants();
+      return cached_data_;
+    }
+
+    /**
+     * Update {cached_data_} with the data from the underlying buffer. This can
+     * be called only for cacheable resources.
+     */
+    void UpdateDataCache();
+
    protected:
     ExternalOneByteStringResource() = default;
+
+   private:
+    void CheckCachedDataInvariants() const;
+
+    const char* cached_data_ = nullptr;
   };
 
   /**
@@ -3223,7 +3471,7 @@ class V8_EXPORT String : public Name {
    */
   const ExternalOneByteStringResource* GetExternalOneByteStringResource() const;
 
-  V8_INLINE static String* Cast(v8::Value* obj);
+  V8_INLINE static String* Cast(v8::Data* data);
 
   /**
    * Allocates a new string from a UTF-8 literal. This is equivalent to calling
@@ -3380,7 +3628,7 @@ class V8_EXPORT String : public Name {
                                               const char* literal,
                                               NewStringType type, int length);
 
-  static void CheckCast(v8::Value* obj);
+  static void CheckCast(v8::Data* that);
 };
 
 // Zero-length string specialization (templated string size includes
@@ -3400,8 +3648,9 @@ class V8_EXPORT Symbol : public Name {
    * Returns the description string of the symbol, or undefined if none.
    */
   Local<Value> Description() const;
+  Local<Value> Description(Isolate* isolate) const;
 
-  V8_DEPRECATE_SOON("Use Symbol::Description()")
+  V8_DEPRECATED("Use Symbol::Description()")
   Local<Value> Name() const { return Description(); }
 
   /**
@@ -3440,11 +3689,11 @@ class V8_EXPORT Symbol : public Name {
   static Local<Symbol> GetToStringTag(Isolate* isolate);
   static Local<Symbol> GetUnscopables(Isolate* isolate);
 
-  V8_INLINE static Symbol* Cast(Value* obj);
+  V8_INLINE static Symbol* Cast(Data* data);
 
  private:
   Symbol();
-  static void CheckCast(Value* obj);
+  static void CheckCast(Data* that);
 };
 
 
@@ -3493,10 +3742,11 @@ class V8_EXPORT Number : public Primitive {
  public:
   double Value() const;
   static Local<Number> New(Isolate* isolate, double value);
-  V8_INLINE static Number* Cast(v8::Value* obj);
+  V8_INLINE static Number* Cast(v8::Data* data);
+
  private:
   Number();
-  static void CheckCast(v8::Value* obj);
+  static void CheckCast(v8::Data* that);
 };
 
 
@@ -3508,10 +3758,11 @@ class V8_EXPORT Integer : public Number {
   static Local<Integer> New(Isolate* isolate, int32_t value);
   static Local<Integer> NewFromUnsigned(Isolate* isolate, uint32_t value);
   int64_t Value() const;
-  V8_INLINE static Integer* Cast(v8::Value* obj);
+  V8_INLINE static Integer* Cast(v8::Data* data);
+
  private:
   Integer();
-  static void CheckCast(v8::Value* obj);
+  static void CheckCast(v8::Data* that);
 };
 
 
@@ -3521,11 +3772,11 @@ class V8_EXPORT Integer : public Number {
 class V8_EXPORT Int32 : public Integer {
  public:
   int32_t Value() const;
-  V8_INLINE static Int32* Cast(v8::Value* obj);
+  V8_INLINE static Int32* Cast(v8::Data* data);
 
  private:
   Int32();
-  static void CheckCast(v8::Value* obj);
+  static void CheckCast(v8::Data* that);
 };
 
 
@@ -3535,11 +3786,11 @@ class V8_EXPORT Int32 : public Integer {
 class V8_EXPORT Uint32 : public Integer {
  public:
   uint32_t Value() const;
-  V8_INLINE static Uint32* Cast(v8::Value* obj);
+  V8_INLINE static Uint32* Cast(v8::Data* data);
 
  private:
   Uint32();
-  static void CheckCast(v8::Value* obj);
+  static void CheckCast(v8::Data* that);
 };
 
 /**
@@ -3590,11 +3841,11 @@ class V8_EXPORT BigInt : public Primitive {
    */
   void ToWordsArray(int* sign_bit, int* word_count, uint64_t* words) const;
 
-  V8_INLINE static BigInt* Cast(v8::Value* obj);
+  V8_INLINE static BigInt* Cast(v8::Data* data);
 
  private:
   BigInt();
-  static void CheckCast(v8::Value* obj);
+  static void CheckCast(v8::Data* that);
 };
 
 /**
@@ -3616,23 +3867,17 @@ enum PropertyAttribute {
  * setting|getting a particular property. See Object and ObjectTemplate's
  * method SetAccessor.
  */
-typedef void (*AccessorGetterCallback)(
-    Local<String> property,
-    const PropertyCallbackInfo<Value>& info);
-typedef void (*AccessorNameGetterCallback)(
-    Local<Name> property,
-    const PropertyCallbackInfo<Value>& info);
-
-
-typedef void (*AccessorSetterCallback)(
-    Local<String> property,
-    Local<Value> value,
-    const PropertyCallbackInfo<void>& info);
-typedef void (*AccessorNameSetterCallback)(
-    Local<Name> property,
-    Local<Value> value,
-    const PropertyCallbackInfo<void>& info);
+using AccessorGetterCallback =
+    void (*)(Local<String> property, const PropertyCallbackInfo<Value>& info);
+using AccessorNameGetterCallback =
+    void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info);
 
+using AccessorSetterCallback = void (*)(Local<String> property,
+                                        Local<Value> value,
+                                        const PropertyCallbackInfo<void>& info);
+using AccessorNameSetterCallback =
+    void (*)(Local<Name> property, Local<Value> value,
+             const PropertyCallbackInfo<void>& info);
 
 /**
  * Access control specifications.
@@ -3757,8 +4002,7 @@ class V8_EXPORT Object : public Value {
   //
   // Returns true on success.
   V8_WARN_UNUSED_RESULT Maybe<bool> DefineProperty(
-      Local<Context> context, Local<Name> key,
-      PropertyDescriptor& descriptor);  // NOLINT(runtime/references)
+      Local<Context> context, Local<Name> key, PropertyDescriptor& descriptor);
 
   V8_WARN_UNUSED_RESULT MaybeLocal<Value> Get(Local<Context> context,
                                               Local<Value> key);
@@ -3941,10 +4185,10 @@ class V8_EXPORT Object : public Value {
     return object.val_->InternalFieldCount();
   }
 
-  /** Same as above, but works for TracedReferenceBase. */
+  /** Same as above, but works for BasicTracedReference. */
   V8_INLINE static int InternalFieldCount(
-      const TracedReferenceBase<Object>& object) {
-    return object.val_->InternalFieldCount();
+      const BasicTracedReference<Object>& object) {
+    return object->InternalFieldCount();
   }
 
   /** Gets the value from an internal field. */
@@ -3968,8 +4212,8 @@ class V8_EXPORT Object : public Value {
 
   /** Same as above, but works for TracedGlobal. */
   V8_INLINE static void* GetAlignedPointerFromInternalField(
-      const TracedReferenceBase<Object>& object, int index) {
-    return object.val_->GetAlignedPointerFromInternalField(index);
+      const BasicTracedReference<Object>& object, int index) {
+    return object->GetAlignedPointerFromInternalField(index);
   }
 
   /**
@@ -4067,12 +4311,18 @@ class V8_EXPORT Object : public Value {
   /**
    * Returns the context in which the object was created.
    */
+  V8_DEPRECATE_SOON("Use MaybeLocal<Context> GetCreationContext()")
   Local<Context> CreationContext();
+  MaybeLocal<Context> GetCreationContext();
 
   /** Same as above, but works for Persistents */
-  V8_INLINE static Local<Context> CreationContext(
+  V8_DEPRECATE_SOON(
+      "Use MaybeLocal<Context> GetCreationContext(const "
+      "PersistentBase<Object>& object)")
+  static Local<Context> CreationContext(const PersistentBase<Object>& object);
+  V8_INLINE static MaybeLocal<Context> GetCreationContext(
       const PersistentBase<Object>& object) {
-    return object.val_->CreationContext();
+    return object.val_->GetCreationContext();
   }
 
   /**
@@ -4152,6 +4402,16 @@ class V8_EXPORT Object : public Value {
 
   V8_INLINE static Object* Cast(Value* obj);
 
+  /**
+   * Support for TC39 "dynamic code brand checks" proposal.
+   *
+   * This API allows to query whether an object was constructed from a
+   * "code like" ObjectTemplate.
+   *
+   * See also: v8::ObjectTemplate::SetCodeLike
+   */
+  bool IsCodeLike(Isolate* isolate);
+
  private:
   Object();
   static void CheckCast(Value* obj);
@@ -4180,6 +4440,7 @@ class V8_EXPORT Array : public Object {
   static Local<Array> New(Isolate* isolate, Local<Value>* elements,
                           size_t length);
   V8_INLINE static Array* Cast(Value* obj);
+
  private:
   Array();
   static void CheckCast(Value* obj);
@@ -4265,7 +4526,7 @@ class ReturnValue {
   template <typename S>
   V8_INLINE void Set(const Global<S>& handle);
   template <typename S>
-  V8_INLINE void Set(const TracedReferenceBase<S>& handle);
+  V8_INLINE void Set(const BasicTracedReference<S>& handle);
   template <typename S>
   V8_INLINE void Set(const Local<S> handle);
   // Fast primitive setters
@@ -4474,8 +4735,7 @@ class PropertyCallbackInfo {
   internal::Address* args_;
 };
 
-
-typedef void (*FunctionCallback)(const FunctionCallbackInfo<Value>& info);
+using FunctionCallback = void (*)(const FunctionCallbackInfo<Value>& info);
 
 enum class ConstructorBehavior { kThrow, kAllow };
 
@@ -4536,6 +4796,11 @@ class V8_EXPORT Function : public Object {
    * User-defined name assigned to the "displayName" property of this function.
    * Used to facilitate debugging and profiling of JavaScript code.
    */
+  V8_DEPRECATED(
+      "Use v8::Object::Get() instead to look up \"displayName\". "
+      "V8 and DevTools no longer use \"displayName\" in stack "
+      "traces, but the standard \"name\" property. "
+      "See http://crbug.com/1177685.")
   Local<Value> GetDisplayName() const;
 
   /**
@@ -4560,6 +4825,15 @@ class V8_EXPORT Function : public Object {
    */
   Local<Value> GetBoundFunction() const;
 
+  /**
+   * Calls builtin Function.prototype.toString on this function.
+   * This is different from Value::ToString() that may call a user-defined
+   * toString() function, and different than Object::ObjectProtoToString() which
+   * always serializes "[object Function]".
+   */
+  V8_WARN_UNUSED_RESULT MaybeLocal<String> FunctionProtoToString(
+      Local<Context> context);
+
   ScriptOrigin GetScriptOrigin() const;
   V8_INLINE static Function* Cast(Value* obj);
   static const int kLineOffsetNotFound;
@@ -4653,6 +4927,12 @@ class V8_EXPORT Promise : public Object {
    */
   void MarkAsHandled();
 
+  /**
+   * Marks this promise as silent to prevent pausing the debugger when the
+   * promise is rejected.
+   */
+  void MarkAsSilent();
+
   V8_INLINE static Promise* Cast(Value* obj);
 
   static const int kEmbedderFieldCount = V8_PROMISE_INTERNAL_FIELD_COUNT;
@@ -4827,6 +5107,22 @@ class V8_EXPORT CompiledWasmModule {
   const std::string source_url_;
 };
 
+// An instance of WebAssembly.Memory.
+class V8_EXPORT WasmMemoryObject : public Object {
+ public:
+  WasmMemoryObject() = delete;
+
+  /**
+   * Returns underlying ArrayBuffer.
+   */
+  Local<ArrayBuffer> Buffer();
+
+  V8_INLINE static WasmMemoryObject* Cast(Value* obj);
+
+ private:
+  static void CheckCast(Value* object);
+};
+
 // An instance of WebAssembly.Module.
 class V8_EXPORT WasmModuleObject : public Object {
  public:
@@ -5090,7 +5386,7 @@ class V8_EXPORT ArrayBuffer : public Object {
    * Note that it is unsafe to call back into V8 from any of the allocator
    * functions.
    */
-  class V8_EXPORT Allocator { // NOLINT
+  class V8_EXPORT Allocator {
    public:
     virtual ~Allocator() = default;
 
@@ -5215,7 +5511,7 @@ class V8_EXPORT ArrayBuffer : public Object {
    * |Allocator::Free| once all ArrayBuffers referencing it are collected by
    * the garbage collector.
    */
-  V8_DEPRECATE_SOON(
+  V8_DEPRECATED(
       "Use the version that takes a BackingStore. "
       "See http://crbug.com/v8/9908.")
   static Local<ArrayBuffer> New(
@@ -5264,7 +5560,7 @@ class V8_EXPORT ArrayBuffer : public Object {
    * Returns true if ArrayBuffer is externalized, that is, does not
    * own its memory block.
    */
-  V8_DEPRECATE_SOON(
+  V8_DEPRECATED(
       "With v8::BackingStore externalized ArrayBuffers are "
       "the same as ordinary ArrayBuffers. See http://crbug.com/v8/9908.")
   bool IsExternal() const;
@@ -5292,8 +5588,7 @@ class V8_EXPORT ArrayBuffer : public Object {
    * deleter, which will call ArrayBuffer::Allocator::Free if the buffer
    * was allocated with ArrayBuffer::Allocator::Allocate.
    */
-  V8_DEPRECATE_SOON(
-      "Use GetBackingStore or Detach. See http://crbug.com/v8/9908.")
+  V8_DEPRECATED("Use GetBackingStore or Detach. See http://crbug.com/v8/9908.")
   Contents Externalize();
 
   /**
@@ -5303,7 +5598,7 @@ class V8_EXPORT ArrayBuffer : public Object {
    * With the new lifetime management of backing stores there is no need for
    * externalizing, so this function exists only to make the transition easier.
    */
-  V8_DEPRECATE_SOON("This will be removed together with IsExternal.")
+  V8_DEPRECATED("This will be removed together with IsExternal.")
   void Externalize(const std::shared_ptr<BackingStore>& backing_store);
 
   /**
@@ -5314,7 +5609,7 @@ class V8_EXPORT ArrayBuffer : public Object {
    * The embedder should make sure to hold a strong reference to the
    * ArrayBuffer while accessing this pointer.
    */
-  V8_DEPRECATE_SOON("Use GetBackingStore. See http://crbug.com/v8/9908.")
+  V8_DEPRECATED("Use GetBackingStore. See http://crbug.com/v8/9908.")
   Contents GetContents();
 
   /**
@@ -5698,7 +5993,7 @@ class V8_EXPORT SharedArrayBuffer : public Object {
    * specified. The memory block will not be reclaimed when a created
    * SharedArrayBuffer is garbage-collected.
    */
-  V8_DEPRECATE_SOON(
+  V8_DEPRECATED(
       "Use the version that takes a BackingStore. "
       "See http://crbug.com/v8/9908.")
   static Local<SharedArrayBuffer> New(
@@ -5758,7 +6053,7 @@ class V8_EXPORT SharedArrayBuffer : public Object {
    * Returns true if SharedArrayBuffer is externalized, that is, does not
    * own its memory block.
    */
-  V8_DEPRECATE_SOON(
+  V8_DEPRECATED(
       "With v8::BackingStore externalized SharedArrayBuffers are the same "
       "as ordinary SharedArrayBuffers. See http://crbug.com/v8/9908.")
   bool IsExternal() const;
@@ -5775,8 +6070,7 @@ class V8_EXPORT SharedArrayBuffer : public Object {
    * v8::Isolate::CreateParams::array_buffer_allocator.
    *
    */
-  V8_DEPRECATE_SOON(
-      "Use GetBackingStore or Detach. See http://crbug.com/v8/9908.")
+  V8_DEPRECATED("Use GetBackingStore or Detach. See http://crbug.com/v8/9908.")
   Contents Externalize();
 
   /**
@@ -5786,7 +6080,7 @@ class V8_EXPORT SharedArrayBuffer : public Object {
    * With the new lifetime management of backing stores there is no need for
    * externalizing, so this function exists only to make the transition easier.
    */
-  V8_DEPRECATE_SOON("This will be removed together with IsExternal.")
+  V8_DEPRECATED("This will be removed together with IsExternal.")
   void Externalize(const std::shared_ptr<BackingStore>& backing_store);
 
   /**
@@ -5801,7 +6095,7 @@ class V8_EXPORT SharedArrayBuffer : public Object {
    * by the allocator specified in
    * v8::Isolate::CreateParams::array_buffer_allocator.
    */
-  V8_DEPRECATE_SOON("Use GetBackingStore. See http://crbug.com/v8/9908.")
+  V8_DEPRECATED("Use GetBackingStore. See http://crbug.com/v8/9908.")
   Contents GetContents();
 
   /**
@@ -5932,6 +6226,10 @@ class V8_EXPORT RegExp : public Object {
   /**
    * Regular expression flag bits. They can be or'ed to enable a set
    * of flags.
+   * The kLinear value ('l') is experimental and can only be used with
+   * --enable-experimental-regexp-engine.  RegExps with kLinear flag are
+   *  guaranteed to be executed in asymptotic linear time wrt. the length of
+   *  the subject string.
    */
   enum Flags {
     kNone = 0,
@@ -5941,9 +6239,11 @@ class V8_EXPORT RegExp : public Object {
     kSticky = 1 << 3,
     kUnicode = 1 << 4,
     kDotAll = 1 << 5,
+    kLinear = 1 << 6,
+    kHasIndices = 1 << 7,
   };
 
-  static constexpr int kFlagCount = 6;
+  static constexpr int kFlagCount = 8;
 
   /**
    * Creates a regular expression from the given pattern string and
@@ -6085,7 +6385,6 @@ class V8_EXPORT Template : public Data {
   void SetNativeDataProperty(
       Local<String> name, AccessorGetterCallback getter,
       AccessorSetterCallback setter = nullptr,
-      // TODO(dcarney): gcc can't handle Local below
       Local<Value> data = Local<Value>(), PropertyAttribute attribute = None,
       Local<AccessorSignature> signature = Local<AccessorSignature>(),
       AccessControl settings = DEFAULT,
@@ -6094,7 +6393,6 @@ class V8_EXPORT Template : public Data {
   void SetNativeDataProperty(
       Local<Name> name, AccessorNameGetterCallback getter,
       AccessorNameSetterCallback setter = nullptr,
-      // TODO(dcarney): gcc can't handle Local below
       Local<Value> data = Local<Value>(), PropertyAttribute attribute = None,
       Local<AccessorSignature> signature = Local<AccessorSignature>(),
       AccessControl settings = DEFAULT,
@@ -6164,8 +6462,8 @@ class V8_EXPORT Template : public Data {
  *
  * See also `ObjectTemplate::SetHandler`.
  */
-typedef void (*GenericNamedPropertyGetterCallback)(
-    Local<Name> property, const PropertyCallbackInfo<Value>& info);
+using GenericNamedPropertyGetterCallback =
+    void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info);
 
 /**
  * Interceptor for set requests on an object.
@@ -6188,9 +6486,9 @@ typedef void (*GenericNamedPropertyGetterCallback)(
  * See also
  * `ObjectTemplate::SetHandler.`
  */
-typedef void (*GenericNamedPropertySetterCallback)(
-    Local<Name> property, Local<Value> value,
-    const PropertyCallbackInfo<Value>& info);
+using GenericNamedPropertySetterCallback =
+    void (*)(Local<Name> property, Local<Value> value,
+             const PropertyCallbackInfo<Value>& info);
 
 /**
  * Intercepts all requests that query the attributes of the
@@ -6213,8 +6511,8 @@ typedef void (*GenericNamedPropertySetterCallback)(
  * See also
  * `ObjectTemplate::SetHandler.`
  */
-typedef void (*GenericNamedPropertyQueryCallback)(
-    Local<Name> property, const PropertyCallbackInfo<Integer>& info);
+using GenericNamedPropertyQueryCallback =
+    void (*)(Local<Name> property, const PropertyCallbackInfo<Integer>& info);
 
 /**
  * Interceptor for delete requests on an object.
@@ -6237,8 +6535,8 @@ typedef void (*GenericNamedPropertyQueryCallback)(
  *
  * See also `ObjectTemplate::SetHandler.`
  */
-typedef void (*GenericNamedPropertyDeleterCallback)(
-    Local<Name> property, const PropertyCallbackInfo<Boolean>& info);
+using GenericNamedPropertyDeleterCallback =
+    void (*)(Local<Name> property, const PropertyCallbackInfo<Boolean>& info);
 
 /**
  * Returns an array containing the names of the properties the named
@@ -6246,8 +6544,8 @@ typedef void (*GenericNamedPropertyDeleterCallback)(
  *
  * Note: The values in the array must be of type v8::Name.
  */
-typedef void (*GenericNamedPropertyEnumeratorCallback)(
-    const PropertyCallbackInfo<Array>& info);
+using GenericNamedPropertyEnumeratorCallback =
+    void (*)(const PropertyCallbackInfo<Array>& info);
 
 /**
  * Interceptor for defineProperty requests on an object.
@@ -6269,9 +6567,9 @@ typedef void (*GenericNamedPropertyEnumeratorCallback)(
  *
  * See also `ObjectTemplate::SetHandler`.
  */
-typedef void (*GenericNamedPropertyDefinerCallback)(
-    Local<Name> property, const PropertyDescriptor& desc,
-    const PropertyCallbackInfo<Value>& info);
+using GenericNamedPropertyDefinerCallback =
+    void (*)(Local<Name> property, const PropertyDescriptor& desc,
+             const PropertyCallbackInfo<Value>& info);
 
 /**
  * Interceptor for getOwnPropertyDescriptor requests on an object.
@@ -6292,37 +6590,33 @@ typedef void (*GenericNamedPropertyDefinerCallback)(
  *
  * See also `ObjectTemplate::SetHandler`.
  */
-typedef void (*GenericNamedPropertyDescriptorCallback)(
-    Local<Name> property, const PropertyCallbackInfo<Value>& info);
+using GenericNamedPropertyDescriptorCallback =
+    void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info);
 
 /**
  * See `v8::GenericNamedPropertyGetterCallback`.
  */
-typedef void (*IndexedPropertyGetterCallback)(
-    uint32_t index,
-    const PropertyCallbackInfo<Value>& info);
+using IndexedPropertyGetterCallback =
+    void (*)(uint32_t index, const PropertyCallbackInfo<Value>& info);
 
 /**
  * See `v8::GenericNamedPropertySetterCallback`.
  */
-typedef void (*IndexedPropertySetterCallback)(
-    uint32_t index,
-    Local<Value> value,
-    const PropertyCallbackInfo<Value>& info);
+using IndexedPropertySetterCallback =
+    void (*)(uint32_t index, Local<Value> value,
+             const PropertyCallbackInfo<Value>& info);
 
 /**
  * See `v8::GenericNamedPropertyQueryCallback`.
  */
-typedef void (*IndexedPropertyQueryCallback)(
-    uint32_t index,
-    const PropertyCallbackInfo<Integer>& info);
+using IndexedPropertyQueryCallback =
+    void (*)(uint32_t index, const PropertyCallbackInfo<Integer>& info);
 
 /**
  * See `v8::GenericNamedPropertyDeleterCallback`.
  */
-typedef void (*IndexedPropertyDeleterCallback)(
-    uint32_t index,
-    const PropertyCallbackInfo<Boolean>& info);
+using IndexedPropertyDeleterCallback =
+    void (*)(uint32_t index, const PropertyCallbackInfo<Boolean>& info);
 
 /**
  * Returns an array containing the indices of the properties the indexed
@@ -6330,21 +6624,21 @@ typedef void (*IndexedPropertyDeleterCallback)(
  *
  * Note: The values in the array must be uint32_t.
  */
-typedef void (*IndexedPropertyEnumeratorCallback)(
-    const PropertyCallbackInfo<Array>& info);
+using IndexedPropertyEnumeratorCallback =
+    void (*)(const PropertyCallbackInfo<Array>& info);
 
 /**
  * See `v8::GenericNamedPropertyDefinerCallback`.
  */
-typedef void (*IndexedPropertyDefinerCallback)(
-    uint32_t index, const PropertyDescriptor& desc,
-    const PropertyCallbackInfo<Value>& info);
+using IndexedPropertyDefinerCallback =
+    void (*)(uint32_t index, const PropertyDescriptor& desc,
+             const PropertyCallbackInfo<Value>& info);
 
 /**
  * See `v8::GenericNamedPropertyDescriptorCallback`.
  */
-typedef void (*IndexedPropertyDescriptorCallback)(
-    uint32_t index, const PropertyCallbackInfo<Value>& info);
+using IndexedPropertyDescriptorCallback =
+    void (*)(uint32_t index, const PropertyCallbackInfo<Value>& info);
 
 /**
  * Access type specification.
@@ -6362,9 +6656,9 @@ enum AccessType {
  * Returns true if the given context should be allowed to access the given
  * object.
  */
-typedef bool (*AccessCheckCallback)(Local<Context> accessing_context,
-                                    Local<Object> accessed_object,
-                                    Local<Value> data);
+using AccessCheckCallback = bool (*)(Local<Context> accessing_context,
+                                     Local<Object> accessed_object,
+                                     Local<Value> data);
 
 /**
  * A FunctionTemplate is used to create functions at runtime. There
@@ -6484,6 +6778,15 @@ class V8_EXPORT FunctionTemplate : public Template {
       SideEffectType side_effect_type = SideEffectType::kHasSideEffect,
       const CFunction* c_function = nullptr);
 
+  /** Creates a function template for multiple overloaded fast API calls.*/
+  static Local<FunctionTemplate> NewWithCFunctionOverloads(
+      Isolate* isolate, FunctionCallback callback = nullptr,
+      Local<Value> data = Local<Value>(),
+      Local<Signature> signature = Local<Signature>(), int length = 0,
+      ConstructorBehavior behavior = ConstructorBehavior::kAllow,
+      SideEffectType side_effect_type = SideEffectType::kHasSideEffect,
+      const MemorySpan<const CFunction>& c_function_overloads = {});
+
   /**
    * Creates a function template backed/cached by a private property.
    */
@@ -6517,6 +6820,17 @@ class V8_EXPORT FunctionTemplate : public Template {
       SideEffectType side_effect_type = SideEffectType::kHasSideEffect,
       const CFunction* c_function = nullptr);
 
+  /**
+   * Set the call-handler callback for a FunctionTemplate.  This
+   * callback is called whenever the function created from this
+   * FunctionTemplate is called. The 'c_function' represents a fast
+   * API call, see the comment above the class declaration.
+   */
+  void SetCallHandlerV8_92(
+      FunctionCallback callback, Local<Value> data = Local<Value>(),
+      SideEffectType side_effect_type = SideEffectType::kHasSideEffect,
+      const MemorySpan<const CFunction>& c_function_overloads = {});
+
   /** Set the predefined length property for the FunctionTemplate. */
   void SetLength(int length);
 
@@ -6576,6 +6890,15 @@ class V8_EXPORT FunctionTemplate : public Template {
    */
   bool HasInstance(Local<Value> object);
 
+  /**
+   * Returns true if the given value is an API object that was constructed by an
+   * instance of this function template (without checking for inheriting
+   * function templates).
+   *
+   * This is an experimental feature and may still change significantly.
+   */
+  bool IsLeafTemplateForApiObject(v8::Local<v8::Value> value) const;
+
   V8_INLINE static FunctionTemplate* Cast(Data* data);
 
  private:
@@ -6940,6 +7263,18 @@ class V8_EXPORT ObjectTemplate : public Template {
    */
   void SetImmutableProto();
 
+  /**
+   * Support for TC39 "dynamic code brand checks" proposal.
+   *
+   * This API allows to mark (& query) objects as "code like", which causes
+   * them to be treated like Strings in the context of eval and function
+   * constructor.
+   *
+   * Reference: https://github.com/tc39/proposal-dynamic-code-brand-checks
+   */
+  void SetCodeLike();
+  bool IsCodeLike();
+
   V8_INLINE static ObjectTemplate* Cast(Data* data);
 
  private:
@@ -6997,7 +7332,7 @@ class V8_EXPORT AccessorSignature : public Data {
 /**
  * Ignore
  */
-class V8_EXPORT Extension {  // NOLINT
+class V8_EXPORT Extension {
  public:
   // Note that the strings passed into this constructor must live as long
   // as the Extension itself.
@@ -7099,6 +7434,11 @@ class V8_EXPORT ResourceConstraints {
   /**
    * The amount of virtual memory reserved for generated code. This is relevant
    * for 64-bit architectures that rely on code range for calls in code.
+   *
+   * When V8_COMPRESS_POINTERS_IN_SHARED_CAGE is defined, there is a shared
+   * process-wide code range that is lazily initialized. This value is used to
+   * configure that shared code range when the first Isolate is
+   * created. Subsequent Isolates ignore this value.
    */
   size_t code_range_size_in_bytes() const { return code_range_size_; }
   void set_code_range_size_in_bytes(size_t limit) { code_range_size_ = limit; }
@@ -7143,36 +7483,11 @@ class V8_EXPORT ResourceConstraints {
     initial_young_generation_size_ = initial_size;
   }
 
-  /**
-   * Deprecated functions. Do not use in new code.
-   */
-  V8_DEPRECATE_SOON("Use code_range_size_in_bytes.")
-  size_t code_range_size() const { return code_range_size_ / kMB; }
-  V8_DEPRECATE_SOON("Use set_code_range_size_in_bytes.")
-  void set_code_range_size(size_t limit_in_mb) {
-    code_range_size_ = limit_in_mb * kMB;
-  }
-  V8_DEPRECATE_SOON("Use max_young_generation_size_in_bytes.")
-  size_t max_semi_space_size_in_kb() const;
-  V8_DEPRECATE_SOON("Use set_max_young_generation_size_in_bytes.")
-  void set_max_semi_space_size_in_kb(size_t limit_in_kb);
-  V8_DEPRECATE_SOON("Use max_old_generation_size_in_bytes.")
-  size_t max_old_space_size() const { return max_old_generation_size_ / kMB; }
-  V8_DEPRECATE_SOON("Use set_max_old_generation_size_in_bytes.")
-  void set_max_old_space_size(size_t limit_in_mb) {
-    max_old_generation_size_ = limit_in_mb * kMB;
-  }
-  V8_DEPRECATE_SOON("Zone does not pool memory any more.")
-  size_t max_zone_pool_size() const { return max_zone_pool_size_; }
-  V8_DEPRECATE_SOON("Zone does not pool memory any more.")
-  void set_max_zone_pool_size(size_t bytes) { max_zone_pool_size_ = bytes; }
-
  private:
   static constexpr size_t kMB = 1048576u;
   size_t code_range_size_ = 0;
   size_t max_old_generation_size_ = 0;
   size_t max_young_generation_size_ = 0;
-  size_t max_zone_pool_size_ = 0;
   size_t initial_old_generation_size_ = 0;
   size_t initial_young_generation_size_ = 0;
   uint32_t* stack_limit_ = nullptr;
@@ -7181,19 +7496,18 @@ class V8_EXPORT ResourceConstraints {
 
 // --- Exceptions ---
 
+using FatalErrorCallback = void (*)(const char* location, const char* message);
 
-typedef void (*FatalErrorCallback)(const char* location, const char* message);
-
-typedef void (*OOMErrorCallback)(const char* location, bool is_heap_oom);
+using OOMErrorCallback = void (*)(const char* location, bool is_heap_oom);
 
-typedef void (*DcheckErrorCallback)(const char* file, int line,
-                                    const char* message);
+using DcheckErrorCallback = void (*)(const char* file, int line,
+                                     const char* message);
 
-typedef void (*MessageCallback)(Local<Message> message, Local<Value> data);
+using MessageCallback = void (*)(Local<Message> message, Local<Value> data);
 
 // --- Tracing ---
 
-typedef void (*LogEventCallback)(const char* name, int event);
+using LogEventCallback = void (*)(const char* name, int event);
 
 /**
  * Create new error objects by calling the corresponding error object
@@ -7227,14 +7541,12 @@ class V8_EXPORT Exception {
 
 // --- Counters Callbacks ---
 
-typedef int* (*CounterLookupCallback)(const char* name);
+using CounterLookupCallback = int* (*)(const char* name);
 
-typedef void* (*CreateHistogramCallback)(const char* name,
-                                         int min,
-                                         int max,
-                                         size_t buckets);
+using CreateHistogramCallback = void* (*)(const char* name, int min, int max,
+                                          size_t buckets);
 
-typedef void (*AddHistogramSampleCallback)(void* histogram, int sample);
+using AddHistogramSampleCallback = void (*)(void* histogram, int sample);
 
 // --- Crashkeys Callback ---
 enum class CrashKeyId {
@@ -7245,11 +7557,11 @@ enum class CrashKeyId {
   kDumpType,
 };
 
-typedef void (*AddCrashKeyCallback)(CrashKeyId id, const std::string& value);
+using AddCrashKeyCallback = void (*)(CrashKeyId id, const std::string& value);
 
 // --- Enter/Leave Script Callback ---
-typedef void (*BeforeCallEnteredCallback)(Isolate*);
-typedef void (*CallCompletedCallback)(Isolate*);
+using BeforeCallEnteredCallback = void (*)(Isolate*);
+using CallCompletedCallback = void (*)(Isolate*);
 
 /**
  * HostImportModuleDynamicallyCallback is called when we require the
@@ -7262,7 +7574,38 @@ typedef void (*CallCompletedCallback)(Isolate*);
  * The specifier is the name of the module that should be imported.
  *
  * The embedder must compile, instantiate, evaluate the Module, and
- * obtain it's namespace object.
+ * obtain its namespace object.
+ *
+ * The Promise returned from this function is forwarded to userland
+ * JavaScript. The embedder must resolve this promise with the module
+ * namespace object. In case of an exception, the embedder must reject
+ * this promise with the exception. If the promise creation itself
+ * fails (e.g. due to stack overflow), the embedder must propagate
+ * that exception by returning an empty MaybeLocal.
+ */
+using HostImportModuleDynamicallyCallback =
+    MaybeLocal<Promise> (*)(Local<Context> context,
+                            Local<ScriptOrModule> referrer,
+                            Local<String> specifier);
+
+/**
+ * HostImportModuleDynamicallyWithImportAssertionsCallback is called when we
+ * require the embedder to load a module. This is used as part of the dynamic
+ * import syntax.
+ *
+ * The referrer contains metadata about the script/module that calls
+ * import.
+ *
+ * The specifier is the name of the module that should be imported.
+ *
+ * The import_assertions are import assertions 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.
+ *
+ * The embedder must compile, instantiate, evaluate the Module, and
+ * obtain its namespace object.
  *
  * The Promise returned from this function is forwarded to userland
  * JavaScript. The embedder must resolve this promise with the module
@@ -7271,9 +7614,11 @@ typedef void (*CallCompletedCallback)(Isolate*);
  * fails (e.g. due to stack overflow), the embedder must propagate
  * that exception by returning an empty MaybeLocal.
  */
-typedef MaybeLocal<Promise> (*HostImportModuleDynamicallyCallback)(
-    Local<Context> context, Local<ScriptOrModule> referrer,
-    Local<String> specifier);
+using HostImportModuleDynamicallyWithImportAssertionsCallback =
+    MaybeLocal<Promise> (*)(Local<Context> context,
+                            Local<ScriptOrModule> referrer,
+                            Local<String> specifier,
+                            Local<FixedArray> import_assertions);
 
 /**
  * HostInitializeImportMetaObjectCallback is called the first time import.meta
@@ -7285,9 +7630,9 @@ typedef MaybeLocal<Promise> (*HostImportModuleDynamicallyCallback)(
  * The embedder should use v8::Object::CreateDataProperty to add properties on
  * the meta object.
  */
-typedef void (*HostInitializeImportMetaObjectCallback)(Local<Context> context,
-                                                       Local<Module> module,
-                                                       Local<Object> meta);
+using HostInitializeImportMetaObjectCallback = void (*)(Local<Context> context,
+                                                        Local<Module> module,
+                                                        Local<Object> meta);
 
 /**
  * PrepareStackTraceCallback is called when the stack property of an error is
@@ -7296,9 +7641,9 @@ typedef void (*HostInitializeImportMetaObjectCallback)(Local<Context> context,
  * |sites| is an array of call sites, specified in
  * https://v8.dev/docs/stack-trace-api
  */
-typedef MaybeLocal<Value> (*PrepareStackTraceCallback)(Local<Context> context,
-                                                       Local<Value> error,
-                                                       Local<Array> sites);
+using PrepareStackTraceCallback = MaybeLocal<Value> (*)(Local<Context> context,
+                                                        Local<Value> error,
+                                                        Local<Array> sites);
 
 /**
  * PromiseHook with type kInit is called when a new promise is
@@ -7318,8 +7663,8 @@ typedef MaybeLocal<Value> (*PrepareStackTraceCallback)(Local<Context> context,
  */
 enum class PromiseHookType { kInit, kResolve, kBefore, kAfter };
 
-typedef void (*PromiseHook)(PromiseHookType type, Local<Promise> promise,
-                            Local<Value> parent);
+using PromiseHook = void (*)(PromiseHookType type, Local<Promise> promise,
+                             Local<Value> parent);
 
 // --- Promise Reject Callback ---
 enum PromiseRejectEvent {
@@ -7345,12 +7690,11 @@ class PromiseRejectMessage {
   Local<Value> value_;
 };
 
-typedef void (*PromiseRejectCallback)(PromiseRejectMessage message);
+using PromiseRejectCallback = void (*)(PromiseRejectMessage message);
 
 // --- Microtasks Callbacks ---
-typedef void (*MicrotasksCompletedCallback)(Isolate*);
-typedef void (*MicrotasksCompletedCallbackWithData)(Isolate*, void*);
-typedef void (*MicrotaskCallback)(void* data);
+using MicrotasksCompletedCallbackWithData = void (*)(Isolate*, void*);
+using MicrotaskCallback = void (*)(void* data);
 
 /**
  * Policy for running microtasks:
@@ -7454,7 +7798,7 @@ class V8_EXPORT MicrotaskQueue {
  * kDoNotRunMicrotasks should be used to annotate calls not intended to trigger
  * microtasks.
  */
-class V8_EXPORT MicrotasksScope {
+class V8_EXPORT V8_NODISCARD MicrotasksScope {
  public:
   enum Type { kRunMicrotasks, kDoNotRunMicrotasks };
 
@@ -7487,11 +7831,9 @@ class V8_EXPORT MicrotasksScope {
   bool run_;
 };
 
-
 // --- Failed Access Check Callback ---
-typedef void (*FailedAccessCheckCallback)(Local<Object> target,
-                                          AccessType type,
-                                          Local<Value> data);
+using FailedAccessCheckCallback = void (*)(Local<Object> target,
+                                           AccessType type, Local<Value> data);
 
 // --- AllowCodeGenerationFromStrings callbacks ---
 
@@ -7499,8 +7841,8 @@ typedef void (*FailedAccessCheckCallback)(Local<Object> target,
  * Callback to check if code generation from strings is allowed. See
  * Context::AllowCodeGenerationFromStrings.
  */
-typedef bool (*AllowCodeGenerationFromStringsCallback)(Local<Context> context,
-                                                       Local<String> source);
+using AllowCodeGenerationFromStringsCallback = bool (*)(Local<Context> context,
+                                                        Local<String> source);
 
 struct ModifyCodeGenerationFromStringsResult {
   // If true, proceed with the codegen algorithm. Otherwise, block it.
@@ -7513,34 +7855,42 @@ struct ModifyCodeGenerationFromStringsResult {
 
 /**
  * Callback to check if codegen is allowed from a source object, and convert
- * the source to string if necessary.See  ModifyCodeGenerationFromStrings.
+ * the source to string if necessary. See: ModifyCodeGenerationFromStrings.
  */
-typedef ModifyCodeGenerationFromStringsResult (
-    *ModifyCodeGenerationFromStringsCallback)(Local<Context> context,
+using ModifyCodeGenerationFromStringsCallback =
+    ModifyCodeGenerationFromStringsResult (*)(Local<Context> context,
                                               Local<Value> source);
+using ModifyCodeGenerationFromStringsCallback2 =
+    ModifyCodeGenerationFromStringsResult (*)(Local<Context> context,
+                                              Local<Value> source,
+                                              bool is_code_like);
 
 // --- WebAssembly compilation callbacks ---
-typedef bool (*ExtensionCallback)(const FunctionCallbackInfo<Value>&);
+using ExtensionCallback = bool (*)(const FunctionCallbackInfo<Value>&);
 
-typedef bool (*AllowWasmCodeGenerationCallback)(Local<Context> context,
-                                                Local<String> source);
+using AllowWasmCodeGenerationCallback = bool (*)(Local<Context> context,
+                                                 Local<String> source);
 
 // --- Callback for APIs defined on v8-supported objects, but implemented
 // by the embedder. Example: WebAssembly.{compile|instantiate}Streaming ---
-typedef void (*ApiImplementationCallback)(const FunctionCallbackInfo<Value>&);
+using ApiImplementationCallback = void (*)(const FunctionCallbackInfo<Value>&);
 
 // --- Callback for WebAssembly.compileStreaming ---
-typedef void (*WasmStreamingCallback)(const FunctionCallbackInfo<Value>&);
-
-// --- Callback for checking if WebAssembly threads are enabled ---
-typedef bool (*WasmThreadsEnabledCallback)(Local<Context> context);
+using WasmStreamingCallback = void (*)(const FunctionCallbackInfo<Value>&);
 
 // --- Callback for loading source map file for Wasm profiling support
-typedef Local<String> (*WasmLoadSourceMapCallback)(Isolate* isolate,
-                                                   const char* name);
+using WasmLoadSourceMapCallback = Local<String> (*)(Isolate* isolate,
+                                                    const char* name);
 
 // --- Callback for checking if WebAssembly Simd is enabled ---
-typedef bool (*WasmSimdEnabledCallback)(Local<Context> context);
+using WasmSimdEnabledCallback = bool (*)(Local<Context> context);
+
+// --- Callback for checking if WebAssembly exceptions are enabled ---
+using WasmExceptionsEnabledCallback = bool (*)(Local<Context> context);
+
+// --- Callback for checking if the SharedArrayBuffer constructor is enabled ---
+using SharedArrayBufferConstructorEnabledCallback =
+    bool (*)(Local<Context> context);
 
 // --- Garbage Collection Callbacks ---
 
@@ -7584,9 +7934,9 @@ enum GCCallbackFlags {
   kGCCallbackScheduleIdleGarbageCollection = 1 << 6,
 };
 
-typedef void (*GCCallback)(GCType type, GCCallbackFlags flags);
+using GCCallback = void (*)(GCType type, GCCallbackFlags flags);
 
-typedef void (*InterruptCallback)(Isolate* isolate, void* data);
+using InterruptCallback = void (*)(Isolate* isolate, void* data);
 
 /**
  * This callback is invoked when the heap size is close to the heap limit and
@@ -7595,8 +7945,8 @@ typedef void (*InterruptCallback)(Isolate* isolate, void* data);
  * than the current_heap_limit. The initial heap limit is the limit that was
  * set after heap setup.
  */
-typedef size_t (*NearHeapLimitCallback)(void* data, size_t current_heap_limit,
-                                        size_t initial_heap_limit);
+using NearHeapLimitCallback = size_t (*)(void* data, size_t current_heap_limit,
+                                         size_t initial_heap_limit);
 
 /**
  * Collection of shared per-process V8 memory information.
@@ -7850,30 +8200,29 @@ enum JitCodeEventOptions {
  *
  * \param event code add, move or removal event.
  */
-typedef void (*JitCodeEventHandler)(const JitCodeEvent* event);
+using JitCodeEventHandler = void (*)(const JitCodeEvent* event);
 
 /**
  * Callback function passed to SetUnhandledExceptionCallback.
  */
 #if defined(V8_OS_WIN)
-typedef int (*UnhandledExceptionCallback)(
-    _EXCEPTION_POINTERS* exception_pointers);
+using UnhandledExceptionCallback =
+    int (*)(_EXCEPTION_POINTERS* exception_pointers);
 #endif
 
 /**
  * Interface for iterating through all external resources in the heap.
  */
-class V8_EXPORT ExternalResourceVisitor {  // NOLINT
+class V8_EXPORT ExternalResourceVisitor {
  public:
   virtual ~ExternalResourceVisitor() = default;
   virtual void VisitExternalString(Local<String> string) {}
 };
 
-
 /**
  * Interface for iterating through all the persistent handles in the heap.
  */
-class V8_EXPORT PersistentHandleVisitor {  // NOLINT
+class V8_EXPORT PersistentHandleVisitor {
  public:
   virtual ~PersistentHandleVisitor() = default;
   virtual void VisitPersistentHandle(Persistent<Value>* value,
@@ -7890,6 +8239,45 @@ class V8_EXPORT PersistentHandleVisitor {  // NOLINT
  */
 enum class MemoryPressureLevel { kNone, kModerate, kCritical };
 
+/**
+ * Handler for embedder roots on non-unified heap garbage collections.
+ */
+class V8_EXPORT EmbedderRootsHandler {
+ public:
+  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.
+   *
+   * 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|.
+   *
+   * 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
+   * object that is backed by a handle is reclaimed by a non-tracing garbage
+   * collection. It is up to the embedder to reset the original handle.
+   *
+   * Note that the |handle| is different from the handle that the embedder holds
+   * for retaining the object. It is up to the embedder to find the original
+   * handle via the object or class id.
+   */
+  virtual void ResetRoot(const v8::TracedReference<v8::Value>& handle) = 0;
+};
+
 /**
  * Interface for tracing through the embedder heap. During a V8 garbage
  * collection, V8 collects hidden fields of all potential wrappers, and at the
@@ -7952,6 +8340,9 @@ class V8_EXPORT EmbedderHeapTracer {
   /**
    * 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();
 
   /**
@@ -7963,7 +8354,7 @@ class V8_EXPORT EmbedderHeapTracer {
   virtual void RegisterV8References(
       const std::vector<std::pair<void*, void*> >& embedder_fields) = 0;
 
-  void RegisterEmbedderReference(const TracedReferenceBase<v8::Data>& ref);
+  void RegisterEmbedderReference(const BasicTracedReference<v8::Data>& ref);
 
   /**
    * Called at the beginning of a GC cycle.
@@ -8015,34 +8406,14 @@ class V8_EXPORT EmbedderHeapTracer {
   void FinalizeTracing();
 
   /**
-   * 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.
-   *
-   * 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 |ResetHandleInNonTracingGC|.
-   *
-   * 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.
+   * See documentation on EmbedderRootsHandler.
    */
   virtual bool IsRootForNonTracingGC(
       const v8::TracedReference<v8::Value>& handle);
   virtual bool IsRootForNonTracingGC(const v8::TracedGlobal<v8::Value>& handle);
 
   /**
-   * Used in combination with |IsRootForNonTracingGC|. Called by V8 when an
-   * object that is backed by a handle is reclaimed by a non-tracing garbage
-   * collection. It is up to the embedder to reset the original handle.
-   *
-   * Note that the |handle| is different from the handle that the embedder holds
-   * for retaining the object. It is up to the embedder to find the original
-   * handle via the object or class id.
+   * See documentation on EmbedderRootsHandler.
    */
   virtual void ResetHandleInNonTracingGC(
       const v8::TracedReference<v8::Value>& handle);
@@ -8084,8 +8455,8 @@ class V8_EXPORT EmbedderHeapTracer {
  * serialized verbatim.
  */
 struct SerializeInternalFieldsCallback {
-  typedef StartupData (*CallbackFunction)(Local<Object> holder, int index,
-                                          void* data);
+  using CallbackFunction = StartupData (*)(Local<Object> holder, int index,
+                                           void* data);
   SerializeInternalFieldsCallback(CallbackFunction function = nullptr,
                                   void* data_arg = nullptr)
       : callback(function), data(data_arg) {}
@@ -8094,15 +8465,15 @@ struct SerializeInternalFieldsCallback {
 };
 // Note that these fields are called "internal fields" in the API and called
 // "embedder fields" within V8.
-typedef SerializeInternalFieldsCallback SerializeEmbedderFieldsCallback;
+using SerializeEmbedderFieldsCallback = SerializeInternalFieldsCallback;
 
 /**
  * Callback and supporting data used to implement embedder logic to deserialize
  * internal fields.
  */
 struct DeserializeInternalFieldsCallback {
-  typedef void (*CallbackFunction)(Local<Object> holder, int index,
-                                   StartupData payload, void* data);
+  using CallbackFunction = void (*)(Local<Object> holder, int index,
+                                    StartupData payload, void* data);
   DeserializeInternalFieldsCallback(CallbackFunction function = nullptr,
                                     void* data_arg = nullptr)
       : callback(function), data(data_arg) {}
@@ -8110,7 +8481,7 @@ struct DeserializeInternalFieldsCallback {
                    void* data);
   void* data;
 };
-typedef DeserializeInternalFieldsCallback DeserializeEmbedderFieldsCallback;
+using DeserializeEmbedderFieldsCallback = DeserializeInternalFieldsCallback;
 
 /**
  * Controls how the default MeasureMemoryDelegate reports the result of
@@ -8186,26 +8557,15 @@ class V8_EXPORT Isolate {
   /**
    * Initial configuration parameters for a new Isolate.
    */
-  struct CreateParams {
-    CreateParams()
-        : code_event_handler(nullptr),
-          snapshot_blob(nullptr),
-          counter_lookup_callback(nullptr),
-          create_histogram_callback(nullptr),
-          add_histogram_sample_callback(nullptr),
-          array_buffer_allocator(nullptr),
-          array_buffer_allocator_shared(),
-          external_references(nullptr),
-          allow_atomics_wait(true),
-          only_terminate_in_safe_scope(false),
-          embedder_wrapper_type_index(-1),
-          embedder_wrapper_object_index(-1) {}
+  struct V8_EXPORT CreateParams {
+    CreateParams();
+    ~CreateParams();
 
     /**
      * Allows the host application to provide the address of a function that is
      * notified each time code is added, moved or removed.
      */
-    JitCodeEventHandler code_event_handler;
+    JitCodeEventHandler code_event_handler = nullptr;
 
     /**
      * ResourceConstraints to use for the new Isolate.
@@ -8215,14 +8575,13 @@ class V8_EXPORT Isolate {
     /**
      * Explicitly specify a startup snapshot blob. The embedder owns the blob.
      */
-    StartupData* snapshot_blob;
-
+    StartupData* snapshot_blob = nullptr;
 
     /**
      * Enables the host application to provide a mechanism for recording
      * statistics counters.
      */
-    CounterLookupCallback counter_lookup_callback;
+    CounterLookupCallback counter_lookup_callback = nullptr;
 
     /**
      * Enables the host application to provide a mechanism for recording
@@ -8230,8 +8589,8 @@ class V8_EXPORT Isolate {
      * histogram which will later be passed to the AddHistogramSample
      * function.
      */
-    CreateHistogramCallback create_histogram_callback;
-    AddHistogramSampleCallback add_histogram_sample_callback;
+    CreateHistogramCallback create_histogram_callback = nullptr;
+    AddHistogramSampleCallback add_histogram_sample_callback = nullptr;
 
     /**
      * The ArrayBuffer::Allocator to use for allocating and freeing the backing
@@ -8242,7 +8601,7 @@ class V8_EXPORT Isolate {
      * to the allocator, in order to facilitate lifetime
      * management for the allocator instance.
      */
-    ArrayBuffer::Allocator* array_buffer_allocator;
+    ArrayBuffer::Allocator* array_buffer_allocator = nullptr;
     std::shared_ptr<ArrayBuffer::Allocator> array_buffer_allocator_shared;
 
     /**
@@ -8251,34 +8610,38 @@ class V8_EXPORT Isolate {
      * deserialization. This array and its content must stay valid for the
      * entire lifetime of the isolate.
      */
-    const intptr_t* external_references;
+    const intptr_t* external_references = nullptr;
 
     /**
      * Whether calling Atomics.wait (a function that may block) is allowed in
      * this isolate. This can also be configured via SetAllowAtomicsWait.
      */
-    bool allow_atomics_wait;
+    bool allow_atomics_wait = true;
 
     /**
      * Termination is postponed when there is no active SafeForTerminationScope.
      */
-    bool only_terminate_in_safe_scope;
+    bool only_terminate_in_safe_scope = false;
 
     /**
      * The following parameters describe the offsets for addressing type info
      * for wrapped API objects and are used by the fast C API
      * (for details see v8-fast-api-calls.h).
      */
-    int embedder_wrapper_type_index;
-    int embedder_wrapper_object_index;
-  };
+    int embedder_wrapper_type_index = -1;
+    int embedder_wrapper_object_index = -1;
 
+    V8_DEPRECATED(
+        "Setting this has no effect. Embedders should ignore import assertions "
+        "that they do not use.")
+    std::vector<std::string> supported_import_assertions;
+  };
 
   /**
    * Stack-allocated class which sets the isolate for all operations
    * executed within a local scope.
    */
-  class V8_EXPORT Scope {
+  class V8_EXPORT V8_NODISCARD Scope {
    public:
     explicit Scope(Isolate* isolate) : isolate_(isolate) {
       isolate->Enter();
@@ -8294,11 +8657,10 @@ class V8_EXPORT Isolate {
     Isolate* const isolate_;
   };
 
-
   /**
    * Assert that no Javascript code is invoked.
    */
-  class V8_EXPORT DisallowJavascriptExecutionScope {
+  class V8_EXPORT V8_NODISCARD DisallowJavascriptExecutionScope {
    public:
     enum OnFailure { CRASH_ON_FAILURE, THROW_ON_FAILURE, DUMP_ON_FAILURE };
 
@@ -8313,14 +8675,17 @@ class V8_EXPORT Isolate {
 
    private:
     OnFailure on_failure_;
-    void* internal_;
-  };
+    Isolate* isolate_;
 
+    bool was_execution_allowed_assert_;
+    bool was_execution_allowed_throws_;
+    bool was_execution_allowed_dump_;
+  };
 
   /**
    * Introduce exception to DisallowJavascriptExecutionScope.
    */
-  class V8_EXPORT AllowJavascriptExecutionScope {
+  class V8_EXPORT V8_NODISCARD AllowJavascriptExecutionScope {
    public:
     explicit AllowJavascriptExecutionScope(Isolate* isolate);
     ~AllowJavascriptExecutionScope();
@@ -8332,16 +8697,17 @@ class V8_EXPORT Isolate {
         const AllowJavascriptExecutionScope&) = delete;
 
    private:
-    void* internal_throws_;
-    void* internal_assert_;
-    void* internal_dump_;
+    Isolate* isolate_;
+    bool was_execution_allowed_assert_;
+    bool was_execution_allowed_throws_;
+    bool was_execution_allowed_dump_;
   };
 
   /**
    * Do not run microtasks while this scope is active, even if microtasks are
    * automatically executed otherwise.
    */
-  class V8_EXPORT SuppressMicrotaskExecutionScope {
+  class V8_EXPORT V8_NODISCARD SuppressMicrotaskExecutionScope {
    public:
     explicit SuppressMicrotaskExecutionScope(
         Isolate* isolate, MicrotaskQueue* microtask_queue = nullptr);
@@ -8365,7 +8731,7 @@ class V8_EXPORT Isolate {
    * This scope allows terminations inside direct V8 API calls and forbid them
    * inside any recursive API calls without explicit SafeForTerminationScope.
    */
-  class V8_EXPORT SafeForTerminationScope {
+  class V8_EXPORT V8_NODISCARD SafeForTerminationScope {
    public:
     explicit SafeForTerminationScope(v8::Isolate* isolate);
     ~SafeForTerminationScope();
@@ -8424,8 +8790,8 @@ class V8_EXPORT Isolate {
     kArrayInstanceProtoModified = 27,
     kArrayInstanceConstructorModified = 28,
     kLegacyFunctionDeclaration = 29,
-    kRegExpPrototypeSourceGetter = 30,
-    kRegExpPrototypeOldFlagGetter = 31,
+    kRegExpPrototypeSourceGetter = 30,   // Unused.
+    kRegExpPrototypeOldFlagGetter = 31,  // Unused.
     kDecimalWithLeadingZeroInStrictMode = 32,
     kLegacyDateParser = 33,
     kDefineGetterOrSetterWouldThrow = 34,
@@ -8465,7 +8831,7 @@ class V8_EXPORT Isolate {
     kDateToLocaleTimeString = 68,
     kAttemptOverrideReadOnlyOnPrototypeSloppy = 69,
     kAttemptOverrideReadOnlyOnPrototypeStrict = 70,
-    kOptimizedFunctionWithOneShotBytecode = 71,
+    kOptimizedFunctionWithOneShotBytecode = 71,  // Unused.
     kRegExpMatchIsTrueishOnNonJSRegExp = 72,
     kRegExpMatchIsFalseishOnJSRegExp = 73,
     kDateGetTimezoneOffset = 74,  // Unused.
@@ -8503,8 +8869,10 @@ class V8_EXPORT Isolate {
     kWasmSimdOpcodes = 106,
     kVarRedeclaredCatchBinding = 107,
     kWasmRefTypes = 108,
-    kWasmBulkMemory = 109,
+    kWasmBulkMemory = 109,  // Unused.
     kWasmMultiValue = 110,
+    kWasmExceptionHandling = 111,
+    kInvalidatedMegaDOMProtector = 112,
 
     // If you add new values here, you'll also need to update Chromium's:
     // web_feature.mojom, use_counter_callback.cc, and enums.xml. V8 changes to
@@ -8522,8 +8890,8 @@ class V8_EXPORT Isolate {
                   kMessageWarning,
   };
 
-  typedef void (*UseCounterCallback)(Isolate* isolate,
-                                     UseCounterFeature feature);
+  using UseCounterCallback = void (*)(Isolate* isolate,
+                                      UseCounterFeature feature);
 
   /**
    * Allocates a new isolate but does not initialize it. Does not change the
@@ -8565,6 +8933,14 @@ class V8_EXPORT Isolate {
    */
   static Isolate* GetCurrent();
 
+  /**
+   * Returns the entered isolate for the current thread or NULL in
+   * case there is no current isolate.
+   *
+   * No checks are performed by this method.
+   */
+  static Isolate* TryGetCurrent();
+
   /**
    * Clears the set of objects held strongly by the heap. This set of
    * objects are originally built when a WeakRef is created or
@@ -8589,7 +8965,7 @@ class V8_EXPORT Isolate {
    * - the custom callback set returns true.
    * Otherwise, the custom callback will not be called and V8 will not abort.
    */
-  typedef bool (*AbortOnUncaughtExceptionCallback)(Isolate*);
+  using AbortOnUncaughtExceptionCallback = bool (*)(Isolate*);
   void SetAbortOnUncaughtExceptionCallback(
       AbortOnUncaughtExceptionCallback callback);
 
@@ -8597,9 +8973,19 @@ class V8_EXPORT Isolate {
    * This specifies the callback called by the upcoming dynamic
    * import() language feature to load modules.
    */
+  V8_DEPRECATE_SOON(
+      "Use the version of SetHostImportModuleDynamicallyCallback that takes a "
+      "HostImportModuleDynamicallyWithImportAssertionsCallback instead")
   void SetHostImportModuleDynamicallyCallback(
       HostImportModuleDynamicallyCallback callback);
 
+  /**
+   * This specifies the callback called by the upcoming dynamic
+   * import() language feature to load modules.
+   */
+  void SetHostImportModuleDynamicallyCallback(
+      HostImportModuleDynamicallyWithImportAssertionsCallback callback);
+
   /**
    * This specifies the callback called by the upcoming import.meta
    * language feature to retrieve host-defined meta data for a module.
@@ -8621,6 +9007,13 @@ class V8_EXPORT Isolate {
    */
   void MemoryPressureNotification(MemoryPressureLevel level);
 
+  /**
+   * Drop non-essential caches. Should only be called from testing code.
+   * The method can potentially block for a long time and does not necessarily
+   * trigger GC.
+   */
+  void ClearCachesForTesting();
+
   /**
    * Methods below this point require holding a lock (using Locker) in
    * a multi-threaded environment.
@@ -8753,7 +9146,7 @@ class V8_EXPORT Isolate {
       std::unique_ptr<MeasureMemoryDelegate> delegate,
       MeasureMemoryExecution execution = MeasureMemoryExecution::kDefault);
 
-  V8_DEPRECATE_SOON("Use the version with a delegate")
+  V8_DEPRECATED("Use the version with a delegate")
   MaybeLocal<Promise> MeasureMemory(Local<Context> context,
                                     MeasureMemoryMode mode);
 
@@ -8816,10 +9209,6 @@ class V8_EXPORT Isolate {
    */
   Local<Context> GetCurrentContext();
 
-  /** Returns the last context entered through V8's C++ API. */
-  V8_DEPRECATED("Use GetEnteredOrMicrotaskContext().")
-  Local<Context> GetEnteredContext();
-
   /**
    * Returns either the last context entered through V8's C++ API, or the
    * context of the currently running microtask while processing microtasks.
@@ -8834,6 +9223,17 @@ class V8_EXPORT Isolate {
    */
   Local<Context> GetIncumbentContext();
 
+  /**
+   * Schedules a v8::Exception::Error with the given message.
+   * See ThrowException for more details. Templatized to provide compile-time
+   * errors in case of too long strings (see v8::String::NewFromUtf8Literal).
+   */
+  template <int N>
+  Local<Value> ThrowError(const char (&message)[N]) {
+    return ThrowError(String::NewFromUtf8Literal(this, message));
+  }
+  Local<Value> ThrowError(Local<String> message);
+
   /**
    * Schedules an exception to be thrown when returning to JavaScript.  When an
    * exception has been scheduled it is illegal to invoke any JavaScript
@@ -8842,10 +9242,10 @@ class V8_EXPORT Isolate {
    */
   Local<Value> ThrowException(Local<Value> exception);
 
-  typedef void (*GCCallback)(Isolate* isolate, GCType type,
-                             GCCallbackFlags flags);
-  typedef void (*GCCallbackWithData)(Isolate* isolate, GCType type,
-                                     GCCallbackFlags flags, void* data);
+  using GCCallback = void (*)(Isolate* isolate, GCType type,
+                              GCCallbackFlags flags);
+  using GCCallbackWithData = void (*)(Isolate* isolate, GCType type,
+                                      GCCallbackFlags flags, void* data);
 
   /**
    * Enables the host application to receive a notification before a
@@ -8878,6 +9278,42 @@ class V8_EXPORT Isolate {
    */
   EmbedderHeapTracer* GetEmbedderHeapTracer();
 
+  /**
+   * Sets an embedder roots handle that V8 should consider when performing
+   * non-unified heap garbage collections.
+   *
+   * Using only EmbedderHeapTracer automatically sets up a default handler.
+   * The intended use case is for setting a custom handler after invoking
+   * `AttachCppHeap()`.
+   *
+   * V8 does not take ownership of the handler.
+   */
+  void SetEmbedderRootsHandler(EmbedderRootsHandler* handler);
+
+  /**
+   * Attaches a managed C++ heap as an extension to the JavaScript heap. The
+   * embedder maintains ownership of the CppHeap. At most one C++ heap can be
+   * attached to V8.
+   *
+   * This is an experimental feature and may still change significantly.
+   */
+  void AttachCppHeap(CppHeap*);
+
+  /**
+   * Detaches a managed C++ heap if one was attached using `AttachCppHeap()`.
+   *
+   * This is an experimental feature and may still change significantly.
+   */
+  void DetachCppHeap();
+
+  /**
+   * This is an experimental feature and may still change significantly.
+
+   * \returns the C++ heap managed by V8. Only available if such a heap has been
+   *   attached using `AttachCppHeap()`.
+   */
+  CppHeap* GetCppHeap() const;
+
   /**
    * Use for |AtomicsWaitCallback| to indicate the type of event it receives.
    */
@@ -8942,12 +9378,12 @@ class V8_EXPORT Isolate {
    * This callback may schedule exceptions, *unless* |event| is equal to
    * |kTerminatedExecution|.
    */
-  typedef void (*AtomicsWaitCallback)(AtomicsWaitEvent event,
-                                      Local<SharedArrayBuffer> array_buffer,
-                                      size_t offset_in_bytes, int64_t value,
-                                      double timeout_in_ms,
-                                      AtomicsWaitWakeHandle* stop_handle,
-                                      void* data);
+  using AtomicsWaitCallback = void (*)(AtomicsWaitEvent event,
+                                       Local<SharedArrayBuffer> array_buffer,
+                                       size_t offset_in_bytes, int64_t value,
+                                       double timeout_in_ms,
+                                       AtomicsWaitWakeHandle* stop_handle,
+                                       void* data);
 
   /**
    * Set a new |AtomicsWaitCallback|. This overrides an earlier
@@ -8979,7 +9415,7 @@ class V8_EXPORT Isolate {
                                 void* data = nullptr);
   void RemoveGCEpilogueCallback(GCCallback callback);
 
-  typedef size_t (*GetExternallyAllocatedMemoryInBytesCallback)();
+  using GetExternallyAllocatedMemoryInBytesCallback = size_t (*)();
 
   /**
    * Set the callback that tells V8 how much memory is currently allocated
@@ -9098,12 +9534,6 @@ class V8_EXPORT Isolate {
    */
   void SetPromiseRejectCallback(PromiseRejectCallback callback);
 
-  /**
-   * An alias for PerformMicrotaskCheckpoint.
-   */
-  V8_DEPRECATE_SOON("Use PerformMicrotaskCheckpoint.")
-  void RunMicrotasks() { PerformMicrotaskCheckpoint(); }
-
   /**
    * Runs the default MicrotaskQueue until it gets empty and perform other
    * microtask checkpoint steps, such as calling ClearKeptObjects. Asserts that
@@ -9145,16 +9575,12 @@ class V8_EXPORT Isolate {
    * Executing scripts inside the callback will not re-trigger microtasks and
    * the callback.
    */
-  V8_DEPRECATE_SOON("Use *WithData version.")
-  void AddMicrotasksCompletedCallback(MicrotasksCompletedCallback callback);
   void AddMicrotasksCompletedCallback(
       MicrotasksCompletedCallbackWithData callback, void* data = nullptr);
 
   /**
    * Removes callback that was installed by AddMicrotasksCompletedCallback.
    */
-  V8_DEPRECATE_SOON("Use *WithData version.")
-  void RemoveMicrotasksCompletedCallback(MicrotasksCompletedCallback callback);
   void RemoveMicrotasksCompletedCallback(
       MicrotasksCompletedCallbackWithData callback, void* data = nullptr);
 
@@ -9263,6 +9689,11 @@ class V8_EXPORT Isolate {
    */
   void SetRAILMode(RAILMode rail_mode);
 
+  /**
+   * Update load start time of the RAIL mode
+   */
+  void UpdateLoadStartTime();
+
   /**
    * Optional notification to tell V8 the current isolate is used for debugging
    * and requires higher heap limit.
@@ -9334,11 +9765,10 @@ class V8_EXPORT Isolate {
   void GetCodeRange(void** start, size_t* length_in_bytes);
 
   /**
-   * Returns the UnwindState necessary for use with the Unwinder API.
+   * As GetCodeRange, but for embedded builtins (these live in a distinct
+   * memory region from other V8 Code objects).
    */
-  // TODO(petermarshall): Remove this API.
-  V8_DEPRECATED("Use entry_stubs + code_pages version.")
-  UnwindState GetUnwindState();
+  void GetEmbeddedCodeRange(const void** start, size_t* length_in_bytes);
 
   /**
    * Returns the JSEntryStubs necessary for use with the Unwinder API.
@@ -9398,12 +9828,14 @@ class V8_EXPORT Isolate {
    * strings should be allowed.
    */
   V8_DEPRECATED(
-      "Use Isolate::SetModifyCodeGenerationFromStringsCallback instead. "
-      "See http://crbug.com/v8/10096.")
-  void SetAllowCodeGenerationFromStringsCallback(
-      AllowCodeGenerationFromStringsCallback callback);
+      "Use Isolate::SetModifyCodeGenerationFromStringsCallback with "
+      "ModifyCodeGenerationFromStringsCallback2 instead. See "
+      "http://crbug.com/1096017 and TC39 Dynamic Code Brand Checks proposal "
+      "at https://github.com/tc39/proposal-dynamic-code-brand-checks.")
   void SetModifyCodeGenerationFromStringsCallback(
       ModifyCodeGenerationFromStringsCallback callback);
+  void SetModifyCodeGenerationFromStringsCallback(
+      ModifyCodeGenerationFromStringsCallback2 callback);
 
   /**
    * Set the callback to invoke to check if wasm code generation should
@@ -9421,12 +9853,22 @@ class V8_EXPORT Isolate {
 
   void SetWasmStreamingCallback(WasmStreamingCallback callback);
 
-  void SetWasmThreadsEnabledCallback(WasmThreadsEnabledCallback callback);
-
   void SetWasmLoadSourceMapCallback(WasmLoadSourceMapCallback callback);
 
   void SetWasmSimdEnabledCallback(WasmSimdEnabledCallback callback);
 
+  void SetWasmExceptionsEnabledCallback(WasmExceptionsEnabledCallback callback);
+
+  void SetSharedArrayBufferConstructorEnabledCallback(
+      SharedArrayBufferConstructorEnabledCallback callback);
+
+  /**
+   * This function can be called by the embedder to signal V8 that the dynamic
+   * enabling of features has finished. V8 can now set up dynamically added
+   * features.
+   */
+  void InstallConditionalFeatures(Local<Context> context);
+
   /**
   * Check if V8 is dead and therefore unusable.  This is the case after
   * fatal errors such as out-of-memory situations.
@@ -9589,7 +10031,7 @@ class V8_EXPORT StartupData {
  * EntropySource is used as a callback function when v8 needs a source
  * of entropy.
  */
-typedef bool (*EntropySource)(unsigned char* buffer, size_t length);
+using EntropySource = bool (*)(unsigned char* buffer, size_t length);
 
 /**
  * ReturnAddressLocationResolver is used as a callback function when v8 is
@@ -9604,9 +10046,8 @@ typedef bool (*EntropySource)(unsigned char* buffer, size_t length);
  *
  * \note The resolver function must not cause garbage collection.
  */
-typedef uintptr_t (*ReturnAddressLocationResolver)(
-    uintptr_t return_addr_location);
-
+using ReturnAddressLocationResolver =
+    uintptr_t (*)(uintptr_t return_addr_location);
 
 /**
  * Container class for static utility functions.
@@ -9760,7 +10201,7 @@ class V8_EXPORT V8 {
    * \param context The third argument passed to the Linux signal handler, which
    * points to a ucontext_t structure.
    */
-  V8_DEPRECATE_SOON("Use TryHandleWebAssemblyTrapPosix")
+  V8_DEPRECATED("Use TryHandleWebAssemblyTrapPosix")
   static bool TryHandleSignal(int signal_number, void* info, void* context);
 #endif  // V8_OS_POSIX
 
@@ -9791,6 +10232,15 @@ class V8_EXPORT V8 {
    */
   static void GetSharedMemoryStatistics(SharedMemoryStatistics* statistics);
 
+  /**
+   * Notifies V8 that the process is cross-origin-isolated, which enables
+   * defining the SharedArrayBuffer function on the global object of Contexts.
+   */
+  V8_DEPRECATED(
+      "Use the command line argument --enable-sharedarraybuffer-per-context "
+      "together with SetSharedArrayBufferConstructorEnabledCallback")
+  static void SetIsCrossOriginIsolated();
+
  private:
   V8();
 
@@ -9840,6 +10290,8 @@ class V8_EXPORT V8 {
   static void ToLocalEmpty();
   static void InternalFieldOutOfBounds(int index);
   template <class T>
+  friend class BasicTracedReference;
+  template <class T>
   friend class Global;
   template <class T> friend class Local;
   template <class T>
@@ -9847,9 +10299,8 @@ class V8_EXPORT V8 {
   template <class T>
   friend class Maybe;
   template <class T>
-  friend class TracedReferenceBase;
-  template <class T>
   friend class TracedGlobal;
+  friend class TracedReferenceBase;
   template <class T>
   friend class TracedReference;
   template <class T>
@@ -10269,7 +10720,7 @@ class V8_EXPORT ExtensionConfiguration {
  * A sandboxed execution context with its own set of built-in objects
  * and functions.
  */
-class V8_EXPORT Context {
+class V8_EXPORT Context : public Data {
  public:
   /**
    * Returns the global proxy object.
@@ -10484,8 +10935,8 @@ class V8_EXPORT Context {
    * context, call the specified callback, and throw an exception.
    * To unset abort, pass nullptr as callback.
    */
-  typedef void (*AbortScriptExecutionCallback)(Isolate* isolate,
-                                               Local<Context> context);
+  using AbortScriptExecutionCallback = void (*)(Isolate* isolate,
+                                                Local<Context> context);
   void SetAbortScriptExecution(AbortScriptExecutionCallback callback);
 
   /**
@@ -10500,11 +10951,23 @@ class V8_EXPORT Context {
    */
   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
+   * receive the observed promise as the first argument. If a chaining
+   * operation is used on a promise, the init will additionally receive
+   * the parent promise as the second argument.
+   */
+  void SetPromiseHooks(Local<Function> init_hook,
+                       Local<Function> before_hook,
+                       Local<Function> after_hook,
+                       Local<Function> resolve_hook);
+
   /**
    * Stack-allocated class which sets the execution context for all
    * operations executed within a local scope.
    */
-  class Scope {
+  class V8_NODISCARD Scope {
    public:
     explicit V8_INLINE Scope(Local<Context> context) : context_(context) {
       context_->Enter();
@@ -10520,7 +10983,7 @@ class V8_EXPORT Context {
    * stack.
    * https://html.spec.whatwg.org/multipage/webappapis.html#backup-incumbent-settings-object-stack
    */
-  class V8_EXPORT BackupIncumbentScope final {
+  class V8_EXPORT V8_NODISCARD BackupIncumbentScope final {
    public:
     /**
      * |backup_incumbent_context| is pushed onto the backup incumbent settings
@@ -10546,18 +11009,21 @@ class V8_EXPORT Context {
     const BackupIncumbentScope* prev_ = nullptr;
   };
 
+  V8_INLINE static Context* Cast(Data* data);
+
  private:
   friend class Value;
   friend class Script;
   friend class Object;
   friend class Function;
 
+  static void CheckCast(Data* obj);
+
   internal::Address* GetDataFromSnapshotOnce(size_t index);
   Local<Value> SlowGetEmbedderData(int index);
   void* SlowGetAlignedPointerFromEmbedderData(int index);
 };
 
-
 /**
  * Multiple threads in V8 are allowed, but only one thread at a time is allowed
  * to use any given V8 isolate, see the comments in the Isolate class. The
@@ -10700,12 +11166,14 @@ class V8_EXPORT Unwinder {
    *
    * The unwinder also needs the virtual memory range of all possible V8 code
    * objects. There are two ranges required - the heap code range and the range
-   * for code embedded in the binary. The V8 API provides all required inputs
-   * via an UnwindState object through the Isolate::GetUnwindState() API. These
-   * values will not change after Isolate initialization, so the same
-   * |unwind_state| can be used for multiple calls.
+   * for code embedded in the binary.
+   *
+   * Available on x64, ARM64 and ARM32.
    *
-   * \param unwind_state Input state for the Isolate that the stack comes from.
+   * \param code_pages A list of all of the ranges in which V8 has allocated
+   * executable code. The caller should obtain this list by calling
+   * Isolate::CopyCodePages() during the same interrupt/thread suspension that
+   * captures the stack.
    * \param register_state The current registers. This is an in-out param that
    * will be overwritten with the register values after unwinding, on success.
    * \param stack_base The resulting stack pointer and frame pointer values are
@@ -10716,20 +11184,6 @@ class V8_EXPORT Unwinder {
    *
    * \return True on success.
    */
-  // TODO(petermarshall): Remove this API
-  V8_DEPRECATED("Use entry_stubs + code_pages version.")
-  static bool TryUnwindV8Frames(const UnwindState& unwind_state,
-                                RegisterState* register_state,
-                                const void* stack_base);
-
-  /**
-   * The same as above, but is available on x64, ARM64 and ARM32.
-   *
-   * \param code_pages A list of all of the ranges in which V8 has allocated
-   * executable code. The caller should obtain this list by calling
-   * Isolate::CopyCodePages() during the same interrupt/thread suspension that
-   * captures the stack.
-   */
   static bool TryUnwindV8Frames(const JSEntryStubs& entry_stubs,
                                 size_t code_pages_length,
                                 const MemoryRange* code_pages,
@@ -10737,20 +11191,13 @@ class V8_EXPORT Unwinder {
                                 const void* stack_base);
 
   /**
-   * Whether the PC is within the V8 code range represented by code_range or
-   * embedded_code_range in |unwind_state|.
+   * Whether the PC is within the V8 code range represented by code_pages.
    *
    * If this returns false, then calling UnwindV8Frames() with the same PC
    * and unwind_state will always fail. If it returns true, then unwinding may
    * (but not necessarily) be successful.
-   */
-  // TODO(petermarshall): Remove this API
-  V8_DEPRECATED("Use code_pages version.")
-  static bool PCIsInV8(const UnwindState& unwind_state, void* pc);
-
-  /**
-   * The same as above, but is available on x64, ARM64 and ARM32. See the
-   * comment on TryUnwindV8Frames.
+   *
+   * Available on x64, ARM64 and ARM32
    */
   static bool PCIsInV8(size_t code_pages_length, const MemoryRange* code_pages,
                        void* pc);
@@ -10769,8 +11216,8 @@ Local<T> Local<T>::New(Isolate* isolate, const PersistentBase<T>& that) {
 }
 
 template <class T>
-Local<T> Local<T>::New(Isolate* isolate, const TracedReferenceBase<T>& that) {
-  return New(isolate, that.val_);
+Local<T> Local<T>::New(Isolate* isolate, const BasicTracedReference<T>& that) {
+  return New(isolate, *that);
 }
 
 template <class T>
@@ -10840,7 +11287,7 @@ void Persistent<T, M>::Copy(const Persistent<S, M2>& that) {
 
 template <class T>
 bool PersistentBase<T>::IsWeak() const {
-  typedef internal::Internals I;
+  using I = internal::Internals;
   if (this->IsEmpty()) return false;
   return I::GetNodeState(reinterpret_cast<internal::Address*>(this->val_)) ==
          I::kNodeStateIsWeakValue;
@@ -10881,7 +11328,7 @@ template <typename P>
 V8_INLINE void PersistentBase<T>::SetWeak(
     P* parameter, typename WeakCallbackInfo<P>::Callback callback,
     WeakCallbackType type) {
-  typedef typename WeakCallbackInfo<void>::Callback Callback;
+  using Callback = WeakCallbackInfo<void>::Callback;
 #if (__GNUC__ >= 8) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-function-type"
@@ -10913,7 +11360,7 @@ void PersistentBase<T>::AnnotateStrongRetainer(const char* label) {
 
 template <class T>
 void PersistentBase<T>::SetWrapperClassId(uint16_t class_id) {
-  typedef internal::Internals I;
+  using I = internal::Internals;
   if (this->IsEmpty()) return;
   internal::Address* obj = reinterpret_cast<internal::Address*>(this->val_);
   uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
@@ -10923,7 +11370,7 @@ void PersistentBase<T>::SetWrapperClassId(uint16_t class_id) {
 
 template <class T>
 uint16_t PersistentBase<T>::WrapperClassId() const {
-  typedef internal::Internals I;
+  using I = internal::Internals;
   if (this->IsEmpty()) return 0;
   internal::Address* obj = reinterpret_cast<internal::Address*>(this->val_);
   uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
@@ -10957,23 +11404,69 @@ Global<T>& Global<T>::operator=(Global<S>&& rhs) {
 }
 
 template <class T>
-T* TracedReferenceBase<T>::New(Isolate* isolate, T* that, void* slot,
-                               DestructionMode destruction_mode) {
+internal::Address* BasicTracedReference<T>::New(
+    Isolate* isolate, T* that, void* slot, DestructionMode destruction_mode) {
   if (that == nullptr) return nullptr;
   internal::Address* p = reinterpret_cast<internal::Address*>(that);
-  return reinterpret_cast<T*>(V8::GlobalizeTracedReference(
+  return V8::GlobalizeTracedReference(
       reinterpret_cast<internal::Isolate*>(isolate), p,
       reinterpret_cast<internal::Address*>(slot),
-      destruction_mode == kWithDestructor));
+      destruction_mode == kWithDestructor);
 }
 
-template <class T>
-void TracedReferenceBase<T>::Reset() {
+void TracedReferenceBase::Reset() {
   if (IsEmpty()) return;
   V8::DisposeTracedGlobal(reinterpret_cast<internal::Address*>(val_));
   SetSlotThreadSafe(nullptr);
 }
 
+v8::Local<v8::Value> TracedReferenceBase::Get(v8::Isolate* isolate) const {
+  if (IsEmpty()) return Local<Value>();
+  return Local<Value>::New(isolate, reinterpret_cast<Value*>(val_));
+}
+
+V8_INLINE bool operator==(const TracedReferenceBase& lhs,
+                          const TracedReferenceBase& rhs) {
+  v8::internal::Address* a = reinterpret_cast<v8::internal::Address*>(lhs.val_);
+  v8::internal::Address* b = reinterpret_cast<v8::internal::Address*>(rhs.val_);
+  if (a == nullptr) return b == nullptr;
+  if (b == nullptr) return false;
+  return *a == *b;
+}
+
+template <typename U>
+V8_INLINE bool operator==(const TracedReferenceBase& lhs,
+                          const v8::Local<U>& rhs) {
+  v8::internal::Address* a = reinterpret_cast<v8::internal::Address*>(lhs.val_);
+  v8::internal::Address* b = reinterpret_cast<v8::internal::Address*>(*rhs);
+  if (a == nullptr) return b == nullptr;
+  if (b == nullptr) return false;
+  return *a == *b;
+}
+
+template <typename U>
+V8_INLINE bool operator==(const v8::Local<U>& lhs,
+                          const TracedReferenceBase& rhs) {
+  return rhs == lhs;
+}
+
+V8_INLINE bool operator!=(const TracedReferenceBase& lhs,
+                          const TracedReferenceBase& rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename U>
+V8_INLINE bool operator!=(const TracedReferenceBase& lhs,
+                          const v8::Local<U>& rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename U>
+V8_INLINE bool operator!=(const v8::Local<U>& lhs,
+                          const TracedReferenceBase& rhs) {
+  return !(rhs == lhs);
+}
+
 template <class T>
 template <class S>
 void TracedGlobal<T>::Reset(Isolate* isolate, const Local<S>& other) {
@@ -10981,7 +11474,7 @@ void TracedGlobal<T>::Reset(Isolate* isolate, const Local<S>& other) {
   Reset();
   if (other.IsEmpty()) return;
   this->val_ = this->New(isolate, other.val_, &this->val_,
-                         TracedReferenceBase<T>::kWithDestructor);
+                         BasicTracedReference<T>::kWithDestructor);
 }
 
 template <class T>
@@ -11031,7 +11524,7 @@ void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
   if (other.IsEmpty()) return;
   this->SetSlotThreadSafe(
       this->New(isolate, other.val_, &this->val_,
-                TracedReferenceBase<T>::kWithoutDestructor));
+                BasicTracedReference<T>::kWithoutDestructor));
 }
 
 template <class T>
@@ -11074,18 +11567,16 @@ TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
   return *this;
 }
 
-template <class T>
-void TracedReferenceBase<T>::SetWrapperClassId(uint16_t class_id) {
-  typedef internal::Internals I;
+void TracedReferenceBase::SetWrapperClassId(uint16_t class_id) {
+  using I = internal::Internals;
   if (IsEmpty()) return;
   internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
   uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
   *reinterpret_cast<uint16_t*>(addr) = class_id;
 }
 
-template <class T>
-uint16_t TracedReferenceBase<T>::WrapperClassId() const {
-  typedef internal::Internals I;
+uint16_t TracedReferenceBase::WrapperClassId() const {
+  using I = internal::Internals;
   if (IsEmpty()) return 0;
   internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
   uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kNodeClassIdOffset;
@@ -11115,7 +11606,7 @@ void ReturnValue<T>::Set(const Global<S>& handle) {
 
 template <typename T>
 template <typename S>
-void ReturnValue<T>::Set(const TracedReferenceBase<S>& handle) {
+void ReturnValue<T>::Set(const BasicTracedReference<S>& handle) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   if (V8_UNLIKELY(handle.IsEmpty())) {
     *value_ = GetDefaultValue();
@@ -11145,7 +11636,7 @@ void ReturnValue<T>::Set(double i) {
 template<typename T>
 void ReturnValue<T>::Set(int32_t i) {
   static_assert(std::is_base_of<T, Integer>::value, "type check");
-  typedef internal::Internals I;
+  using I = internal::Internals;
   if (V8_LIKELY(I::IsValidSmi(i))) {
     *value_ = I::IntToSmi(i);
     return;
@@ -11168,7 +11659,7 @@ void ReturnValue<T>::Set(uint32_t i) {
 template<typename T>
 void ReturnValue<T>::Set(bool value) {
   static_assert(std::is_base_of<T, Boolean>::value, "type check");
-  typedef internal::Internals I;
+  using I = internal::Internals;
   int root_index;
   if (value) {
     root_index = I::kTrueValueRootIndex;
@@ -11181,21 +11672,21 @@ void ReturnValue<T>::Set(bool value) {
 template<typename T>
 void ReturnValue<T>::SetNull() {
   static_assert(std::is_base_of<T, Primitive>::value, "type check");
-  typedef internal::Internals I;
+  using I = internal::Internals;
   *value_ = *I::GetRoot(GetIsolate(), I::kNullValueRootIndex);
 }
 
 template<typename T>
 void ReturnValue<T>::SetUndefined() {
   static_assert(std::is_base_of<T, Primitive>::value, "type check");
-  typedef internal::Internals I;
+  using I = internal::Internals;
   *value_ = *I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
 }
 
 template<typename T>
 void ReturnValue<T>::SetEmptyString() {
   static_assert(std::is_base_of<T, String>::value, "type check");
-  typedef internal::Internals I;
+  using I = internal::Internals;
   *value_ = *I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex);
 }
 
@@ -11207,7 +11698,7 @@ Isolate* ReturnValue<T>::GetIsolate() const {
 
 template <typename T>
 Local<Value> ReturnValue<T>::Get() const {
-  typedef internal::Internals I;
+  using I = internal::Internals;
   if (*value_ == *I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex))
     return Local<Value>(*Undefined(GetIsolate()));
   return Local<Value>::New(GetIsolate(), reinterpret_cast<Value*>(value_));
@@ -11235,22 +11726,14 @@ template<typename T>
 Local<Value> FunctionCallbackInfo<T>::operator[](int i) const {
   // values_ points to the first argument (not the receiver).
   if (i < 0 || length_ <= i) return Local<Value>(*Undefined(GetIsolate()));
-#ifdef V8_REVERSE_JSARGS
   return Local<Value>(reinterpret_cast<Value*>(values_ + i));
-#else
-  return Local<Value>(reinterpret_cast<Value*>(values_ - i));
-#endif
 }
 
 
 template<typename T>
 Local<Object> FunctionCallbackInfo<T>::This() const {
   // values_ points to the first argument (not the receiver).
-#ifdef V8_REVERSE_JSARGS
   return Local<Object>(reinterpret_cast<Object*>(values_ - 1));
-#else
-  return Local<Object>(reinterpret_cast<Object*>(values_ + 1));
-#endif
 }
 
 
@@ -11295,23 +11778,48 @@ int FunctionCallbackInfo<T>::Length() const {
   return length_;
 }
 
-ScriptOrigin::ScriptOrigin(Local<Value> resource_name,
-                           Local<Integer> resource_line_offset,
-                           Local<Integer> resource_column_offset,
-                           Local<Boolean> resource_is_shared_cross_origin,
-                           Local<Integer> script_id,
-                           Local<Value> source_map_url,
-                           Local<Boolean> resource_is_opaque,
-                           Local<Boolean> is_wasm, Local<Boolean> is_module,
+ScriptOrigin::ScriptOrigin(
+    Local<Value> resource_name, Local<Integer> line_offset,
+    Local<Integer> column_offset, Local<Boolean> is_shared_cross_origin,
+    Local<Integer> script_id, Local<Value> source_map_url,
+    Local<Boolean> is_opaque, Local<Boolean> is_wasm, Local<Boolean> is_module,
+    Local<PrimitiveArray> host_defined_options)
+    : ScriptOrigin(
+          Isolate::GetCurrent(), resource_name,
+          line_offset.IsEmpty() ? 0 : static_cast<int>(line_offset->Value()),
+          column_offset.IsEmpty() ? 0
+                                  : static_cast<int>(column_offset->Value()),
+          !is_shared_cross_origin.IsEmpty() && is_shared_cross_origin->IsTrue(),
+          static_cast<int>(script_id.IsEmpty() ? -1 : script_id->Value()),
+          source_map_url, !is_opaque.IsEmpty() && is_opaque->IsTrue(),
+          !is_wasm.IsEmpty() && is_wasm->IsTrue(),
+          !is_module.IsEmpty() && is_module->IsTrue(), host_defined_options) {}
+
+ScriptOrigin::ScriptOrigin(Local<Value> resource_name, int line_offset,
+                           int column_offset, bool is_shared_cross_origin,
+                           int script_id, Local<Value> source_map_url,
+                           bool is_opaque, bool is_wasm, bool is_module,
+                           Local<PrimitiveArray> host_defined_options)
+    : isolate_(Isolate::GetCurrent()),
+      resource_name_(resource_name),
+      resource_line_offset_(line_offset),
+      resource_column_offset_(column_offset),
+      options_(is_shared_cross_origin, is_opaque, is_wasm, is_module),
+      script_id_(script_id),
+      source_map_url_(source_map_url),
+      host_defined_options_(host_defined_options) {}
+
+ScriptOrigin::ScriptOrigin(Isolate* isolate, Local<Value> resource_name,
+                           int line_offset, int column_offset,
+                           bool is_shared_cross_origin, int script_id,
+                           Local<Value> source_map_url, bool is_opaque,
+                           bool is_wasm, bool is_module,
                            Local<PrimitiveArray> host_defined_options)
-    : resource_name_(resource_name),
-      resource_line_offset_(resource_line_offset),
-      resource_column_offset_(resource_column_offset),
-      options_(!resource_is_shared_cross_origin.IsEmpty() &&
-                   resource_is_shared_cross_origin->IsTrue(),
-               !resource_is_opaque.IsEmpty() && resource_is_opaque->IsTrue(),
-               !is_wasm.IsEmpty() && is_wasm->IsTrue(),
-               !is_module.IsEmpty() && is_module->IsTrue()),
+    : isolate_(isolate),
+      resource_name_(resource_name),
+      resource_line_offset_(line_offset),
+      resource_column_offset_(column_offset),
+      options_(is_shared_cross_origin, is_opaque, is_wasm, is_module),
       script_id_(script_id),
       source_map_url_(source_map_url),
       host_defined_options_(host_defined_options) {}
@@ -11323,17 +11831,22 @@ Local<PrimitiveArray> ScriptOrigin::HostDefinedOptions() const {
 }
 
 Local<Integer> ScriptOrigin::ResourceLineOffset() const {
-  return resource_line_offset_;
+  return v8::Integer::New(isolate_, resource_line_offset_);
 }
 
-
 Local<Integer> ScriptOrigin::ResourceColumnOffset() const {
-  return resource_column_offset_;
+  return v8::Integer::New(isolate_, resource_column_offset_);
 }
 
+Local<Integer> ScriptOrigin::ScriptID() const {
+  return v8::Integer::New(isolate_, script_id_);
+}
+
+int ScriptOrigin::LineOffset() const { return resource_line_offset_; }
 
-Local<Integer> ScriptOrigin::ScriptID() const { return script_id_; }
+int ScriptOrigin::ColumnOffset() const { return resource_column_offset_; }
 
+int ScriptOrigin::ScriptId() const { return script_id_; }
 
 Local<Value> ScriptOrigin::SourceMapUrl() const { return source_map_url_; }
 
@@ -11341,8 +11854,8 @@ ScriptCompiler::Source::Source(Local<String> string, const ScriptOrigin& origin,
                                CachedData* data)
     : source_string(string),
       resource_name(origin.ResourceName()),
-      resource_line_offset(origin.ResourceLineOffset()),
-      resource_column_offset(origin.ResourceColumnOffset()),
+      resource_line_offset(origin.LineOffset()),
+      resource_column_offset(origin.ColumnOffset()),
       resource_options(origin.Options()),
       source_map_url(origin.SourceMapUrl()),
       host_defined_options(origin.HostDefinedOptions()),
@@ -11407,8 +11920,8 @@ AccessorSignature* AccessorSignature::Cast(Data* data) {
 
 Local<Value> Object::GetInternalField(int index) {
 #ifndef V8_ENABLE_CHECKS
-  typedef internal::Address A;
-  typedef internal::Internals I;
+  using A = internal::Address;
+  using I = internal::Internals;
   A obj = *reinterpret_cast<A*>(this);
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
@@ -11435,8 +11948,8 @@ Local<Value> Object::GetInternalField(int index) {
 
 void* Object::GetAlignedPointerFromInternalField(int index) {
 #ifndef V8_ENABLE_CHECKS
-  typedef internal::Address A;
-  typedef internal::Internals I;
+  using A = internal::Address;
+  using I = internal::Internals;
   A obj = *reinterpret_cast<A*>(this);
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
@@ -11445,25 +11958,28 @@ void* Object::GetAlignedPointerFromInternalField(int index) {
                 instance_type == I::kJSApiObjectType ||
                 instance_type == I::kJSSpecialApiObjectType)) {
     int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index);
+#ifdef V8_HEAP_SANDBOX
+    offset += I::kEmbedderDataSlotRawPayloadOffset;
+#endif
     internal::Isolate* isolate = I::GetIsolateForHeapSandbox(obj);
-    A value = I::ReadExternalPointerField(isolate, obj, offset);
+    A value = I::ReadExternalPointerField(
+        isolate, obj, offset, internal::kEmbedderDataSlotPayloadTag);
     return reinterpret_cast<void*>(value);
   }
 #endif
   return SlowGetAlignedPointerFromInternalField(index);
 }
 
-String* String::Cast(v8::Value* value) {
+String* String::Cast(v8::Data* data) {
 #ifdef V8_ENABLE_CHECKS
-  CheckCast(value);
+  CheckCast(data);
 #endif
-  return static_cast<String*>(value);
+  return static_cast<String*>(data);
 }
 
-
 Local<String> String::Empty(Isolate* isolate) {
-  typedef internal::Address S;
-  typedef internal::Internals I;
+  using S = internal::Address;
+  using I = internal::Internals;
   I::CheckInitialized(isolate);
   S* slot = I::GetRoot(isolate, I::kEmptyStringRootIndex);
   return Local<String>(reinterpret_cast<String*>(slot));
@@ -11471,15 +11987,16 @@ Local<String> String::Empty(Isolate* isolate) {
 
 
 String::ExternalStringResource* String::GetExternalStringResource() const {
-  typedef internal::Address A;
-  typedef internal::Internals I;
+  using A = internal::Address;
+  using I = internal::Internals;
   A obj = *reinterpret_cast<const A*>(this);
 
   ExternalStringResource* result;
   if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) {
     internal::Isolate* isolate = I::GetIsolateForHeapSandbox(obj);
     A value =
-        I::ReadExternalPointerField(isolate, obj, I::kStringResourceOffset);
+        I::ReadExternalPointerField(isolate, obj, I::kStringResourceOffset,
+                                    internal::kExternalStringResourceTag);
     result = reinterpret_cast<String::ExternalStringResource*>(value);
   } else {
     result = GetExternalStringResourceSlow();
@@ -11493,8 +12010,8 @@ String::ExternalStringResource* String::GetExternalStringResource() const {
 
 String::ExternalStringResourceBase* String::GetExternalStringResourceBase(
     String::Encoding* encoding_out) const {
-  typedef internal::Address A;
-  typedef internal::Internals I;
+  using A = internal::Address;
+  using I = internal::Internals;
   A obj = *reinterpret_cast<const A*>(this);
   int type = I::GetInstanceType(obj) & I::kFullStringRepresentationMask;
   *encoding_out = static_cast<Encoding>(type & I::kStringEncodingMask);
@@ -11503,7 +12020,8 @@ String::ExternalStringResourceBase* String::GetExternalStringResourceBase(
       type == I::kExternalTwoByteRepresentationTag) {
     internal::Isolate* isolate = I::GetIsolateForHeapSandbox(obj);
     A value =
-        I::ReadExternalPointerField(isolate, obj, I::kStringResourceOffset);
+        I::ReadExternalPointerField(isolate, obj, I::kStringResourceOffset,
+                                    internal::kExternalStringResourceTag);
     resource = reinterpret_cast<ExternalStringResourceBase*>(value);
   } else {
     resource = GetExternalStringResourceBaseSlow(encoding_out);
@@ -11524,8 +12042,8 @@ bool Value::IsUndefined() const {
 }
 
 bool Value::QuickIsUndefined() const {
-  typedef internal::Address A;
-  typedef internal::Internals I;
+  using A = internal::Address;
+  using I = internal::Internals;
   A obj = *reinterpret_cast<const A*>(this);
   if (!I::HasHeapObjectTag(obj)) return false;
   if (I::GetInstanceType(obj) != I::kOddballType) return false;
@@ -11542,8 +12060,8 @@ bool Value::IsNull() const {
 }
 
 bool Value::QuickIsNull() const {
-  typedef internal::Address A;
-  typedef internal::Internals I;
+  using A = internal::Address;
+  using I = internal::Internals;
   A obj = *reinterpret_cast<const A*>(this);
   if (!I::HasHeapObjectTag(obj)) return false;
   if (I::GetInstanceType(obj) != I::kOddballType) return false;
@@ -11559,8 +12077,8 @@ bool Value::IsNullOrUndefined() const {
 }
 
 bool Value::QuickIsNullOrUndefined() const {
-  typedef internal::Address A;
-  typedef internal::Internals I;
+  using A = internal::Address;
+  using I = internal::Internals;
   A obj = *reinterpret_cast<const A*>(this);
   if (!I::HasHeapObjectTag(obj)) return false;
   if (I::GetInstanceType(obj) != I::kOddballType) return false;
@@ -11577,8 +12095,8 @@ bool Value::IsString() const {
 }
 
 bool Value::QuickIsString() const {
-  typedef internal::Address A;
-  typedef internal::Internals I;
+  using A = internal::Address;
+  using I = internal::Internals;
   A obj = *reinterpret_cast<const A*>(this);
   if (!I::HasHeapObjectTag(obj)) return false;
   return (I::GetInstanceType(obj) < I::kFirstNonstringType);
@@ -11589,30 +12107,34 @@ template <class T> Value* Value::Cast(T* value) {
   return static_cast<Value*>(value);
 }
 
-
-Boolean* Boolean::Cast(v8::Value* value) {
+template <>
+V8_INLINE Value* Value::Cast(Data* value) {
 #ifdef V8_ENABLE_CHECKS
   CheckCast(value);
 #endif
-  return static_cast<Boolean*>(value);
+  return static_cast<Value*>(value);
 }
 
-
-Name* Name::Cast(v8::Value* value) {
+Boolean* Boolean::Cast(v8::Data* data) {
 #ifdef V8_ENABLE_CHECKS
-  CheckCast(value);
+  CheckCast(data);
 #endif
-  return static_cast<Name*>(value);
+  return static_cast<Boolean*>(data);
 }
 
-
-Symbol* Symbol::Cast(v8::Value* value) {
+Name* Name::Cast(v8::Data* data) {
 #ifdef V8_ENABLE_CHECKS
-  CheckCast(value);
+  CheckCast(data);
 #endif
-  return static_cast<Symbol*>(value);
+  return static_cast<Name*>(data);
 }
 
+Symbol* Symbol::Cast(v8::Data* data) {
+#ifdef V8_ENABLE_CHECKS
+  CheckCast(data);
+#endif
+  return static_cast<Symbol*>(data);
+}
 
 Private* Private::Cast(Data* data) {
 #ifdef V8_ENABLE_CHECKS
@@ -11621,43 +12143,60 @@ Private* Private::Cast(Data* data) {
   return reinterpret_cast<Private*>(data);
 }
 
-
-Number* Number::Cast(v8::Value* value) {
+ModuleRequest* ModuleRequest::Cast(Data* data) {
 #ifdef V8_ENABLE_CHECKS
-  CheckCast(value);
+  CheckCast(data);
 #endif
-  return static_cast<Number*>(value);
+  return reinterpret_cast<ModuleRequest*>(data);
 }
 
+Module* Module::Cast(Data* data) {
+#ifdef V8_ENABLE_CHECKS
+  CheckCast(data);
+#endif
+  return reinterpret_cast<Module*>(data);
+}
 
-Integer* Integer::Cast(v8::Value* value) {
+Number* Number::Cast(v8::Data* data) {
 #ifdef V8_ENABLE_CHECKS
-  CheckCast(value);
+  CheckCast(data);
 #endif
-  return static_cast<Integer*>(value);
+  return static_cast<Number*>(data);
 }
 
+Integer* Integer::Cast(v8::Data* data) {
+#ifdef V8_ENABLE_CHECKS
+  CheckCast(data);
+#endif
+  return static_cast<Integer*>(data);
+}
 
-Int32* Int32::Cast(v8::Value* value) {
+Int32* Int32::Cast(v8::Data* data) {
 #ifdef V8_ENABLE_CHECKS
-  CheckCast(value);
+  CheckCast(data);
 #endif
-  return static_cast<Int32*>(value);
+  return static_cast<Int32*>(data);
 }
 
+Uint32* Uint32::Cast(v8::Data* data) {
+#ifdef V8_ENABLE_CHECKS
+  CheckCast(data);
+#endif
+  return static_cast<Uint32*>(data);
+}
 
-Uint32* Uint32::Cast(v8::Value* value) {
+BigInt* BigInt::Cast(v8::Data* data) {
 #ifdef V8_ENABLE_CHECKS
-  CheckCast(value);
+  CheckCast(data);
 #endif
-  return static_cast<Uint32*>(value);
+  return static_cast<BigInt*>(data);
 }
 
-BigInt* BigInt::Cast(v8::Value* value) {
+Context* Context::Cast(v8::Data* data) {
 #ifdef V8_ENABLE_CHECKS
-  CheckCast(value);
+  CheckCast(data);
 #endif
-  return static_cast<BigInt*>(value);
+  return static_cast<Context*>(data);
 }
 
 Date* Date::Cast(v8::Value* value) {
@@ -11761,6 +12300,13 @@ Proxy* Proxy::Cast(v8::Value* value) {
   return static_cast<Proxy*>(value);
 }
 
+WasmMemoryObject* WasmMemoryObject::Cast(v8::Value* value) {
+#ifdef V8_ENABLE_CHECKS
+  CheckCast(value);
+#endif
+  return static_cast<WasmMemoryObject*>(value);
+}
+
 WasmModuleObject* WasmModuleObject::Cast(v8::Value* value) {
 #ifdef V8_ENABLE_CHECKS
   CheckCast(value);
@@ -11948,7 +12494,7 @@ ReturnValue<T> PropertyCallbackInfo<T>::GetReturnValue() const {
 
 template <typename T>
 bool PropertyCallbackInfo<T>::ShouldThrowOnError() const {
-  typedef internal::Internals I;
+  using I = internal::Internals;
   if (args_[kShouldThrowOnErrorIndex] !=
       I::IntToSmi(I::kInferShouldThrowMode)) {
     return args_[kShouldThrowOnErrorIndex] != I::IntToSmi(I::kDontThrow);
@@ -11958,8 +12504,8 @@ bool PropertyCallbackInfo<T>::ShouldThrowOnError() const {
 }
 
 Local<Primitive> Undefined(Isolate* isolate) {
-  typedef internal::Address S;
-  typedef internal::Internals I;
+  using S = internal::Address;
+  using I = internal::Internals;
   I::CheckInitialized(isolate);
   S* slot = I::GetRoot(isolate, I::kUndefinedValueRootIndex);
   return Local<Primitive>(reinterpret_cast<Primitive*>(slot));
@@ -11967,8 +12513,8 @@ Local<Primitive> Undefined(Isolate* isolate) {
 
 
 Local<Primitive> Null(Isolate* isolate) {
-  typedef internal::Address S;
-  typedef internal::Internals I;
+  using S = internal::Address;
+  using I = internal::Internals;
   I::CheckInitialized(isolate);
   S* slot = I::GetRoot(isolate, I::kNullValueRootIndex);
   return Local<Primitive>(reinterpret_cast<Primitive*>(slot));
@@ -11976,8 +12522,8 @@ Local<Primitive> Null(Isolate* isolate) {
 
 
 Local<Boolean> True(Isolate* isolate) {
-  typedef internal::Address S;
-  typedef internal::Internals I;
+  using S = internal::Address;
+  using I = internal::Internals;
   I::CheckInitialized(isolate);
   S* slot = I::GetRoot(isolate, I::kTrueValueRootIndex);
   return Local<Boolean>(reinterpret_cast<Boolean*>(slot));
@@ -11985,8 +12531,8 @@ Local<Boolean> True(Isolate* isolate) {
 
 
 Local<Boolean> False(Isolate* isolate) {
-  typedef internal::Address S;
-  typedef internal::Internals I;
+  using S = internal::Address;
+  using I = internal::Internals;
   I::CheckInitialized(isolate);
   S* slot = I::GetRoot(isolate, I::kFalseValueRootIndex);
   return Local<Boolean>(reinterpret_cast<Boolean*>(slot));
@@ -11994,19 +12540,19 @@ Local<Boolean> False(Isolate* isolate) {
 
 
 void Isolate::SetData(uint32_t slot, void* data) {
-  typedef internal::Internals I;
+  using I = internal::Internals;
   I::SetEmbedderData(this, slot, data);
 }
 
 
 void* Isolate::GetData(uint32_t slot) {
-  typedef internal::Internals I;
+  using I = internal::Internals;
   return I::GetEmbedderData(this, slot);
 }
 
 
 uint32_t Isolate::GetNumberOfDataSlots() {
-  typedef internal::Internals I;
+  using I = internal::Internals;
   return I::kNumIsolateDataSlots;
 }
 
@@ -12019,8 +12565,8 @@ MaybeLocal<T> Isolate::GetDataFromSnapshotOnce(size_t index) {
 
 Local<Value> Context::GetEmbedderData(int index) {
 #ifndef V8_ENABLE_CHECKS
-  typedef internal::Address A;
-  typedef internal::Internals I;
+  using A = internal::Address;
+  using I = internal::Internals;
   A ctx = *reinterpret_cast<const A*>(this);
   A embedder_data =
       I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
@@ -12045,16 +12591,20 @@ Local<Value> Context::GetEmbedderData(int index) {
 
 void* Context::GetAlignedPointerFromEmbedderData(int index) {
 #ifndef V8_ENABLE_CHECKS
-  typedef internal::Address A;
-  typedef internal::Internals I;
+  using A = internal::Address;
+  using I = internal::Internals;
   A ctx = *reinterpret_cast<const A*>(this);
   A embedder_data =
       I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
   int value_offset =
       I::kEmbedderDataArrayHeaderSize + (I::kEmbedderDataSlotSize * index);
+#ifdef V8_HEAP_SANDBOX
+  value_offset += I::kEmbedderDataSlotRawPayloadOffset;
+#endif
   internal::Isolate* isolate = I::GetIsolateForHeapSandbox(ctx);
   return reinterpret_cast<void*>(
-      I::ReadExternalPointerField(isolate, embedder_data, value_offset));
+      I::ReadExternalPointerField(isolate, embedder_data, value_offset,
+                                  internal::kEmbedderDataSlotPayloadTag));
 #else
   return SlowGetAlignedPointerFromEmbedderData(index);
 #endif