harperdb 3.2.0 → 3.3.0

package/node_modules/node-addon-api/napi.h

@@ -5,6 +5,7 @@
 #include <functional>
 #include <initializer_list>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -33,6 +34,13 @@ static_assert(sizeof(char16_t) == sizeof(wchar_t), "Size mismatch between char16
   #endif
 #endif
 
+// If C++ NAPI_CPP_EXCEPTIONS are enabled, NODE_ADDON_API_ENABLE_MAYBE should
+// not be set
+#if defined(NAPI_CPP_EXCEPTIONS) && defined(NODE_ADDON_API_ENABLE_MAYBE)
+#error NODE_ADDON_API_ENABLE_MAYBE should not be set when \
+    NAPI_CPP_EXCEPTIONS is defined.
+#endif
+
 #ifdef _NOEXCEPT
   #define NAPI_NOEXCEPT _NOEXCEPT
 #else
@@ -76,90 +84,210 @@ static_assert(sizeof(char16_t) == sizeof(wchar_t), "Size mismatch between char16
     return;                                              \
   } while (0)
 
-#define NAPI_THROW_IF_FAILED(env, status, ...)           \
-  if ((status) != napi_ok) {                             \
-    Napi::Error::New(env).ThrowAsJavaScriptException();  \
-    return __VA_ARGS__;                                  \
+#define NAPI_THROW_IF_FAILED(env, status, ...)                                 \
+  if ((status) != napi_ok) {                                                   \
+    Napi::Error::New(env).ThrowAsJavaScriptException();                        \
+    return __VA_ARGS__;                                                        \
   }
 
-#define NAPI_THROW_IF_FAILED_VOID(env, status)           \
-  if ((status) != napi_ok) {                             \
-    Napi::Error::New(env).ThrowAsJavaScriptException();  \
-    return;                                              \
+#define NAPI_THROW_IF_FAILED_VOID(env, status)                                 \
+  if ((status) != napi_ok) {                                                   \
+    Napi::Error::New(env).ThrowAsJavaScriptException();                        \
+    return;                                                                    \
   }
 
 #endif // NAPI_CPP_EXCEPTIONS
 
-#define NAPI_FATAL_IF_FAILED(status, location, message)  \
-  do {                                                   \
-    if ((status) != napi_ok) {                           \
-      Napi::Error::Fatal((location), (message));         \
-    }                                                    \
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+#define NAPI_MAYBE_THROW_IF_FAILED(env, status, type)                          \
+  NAPI_THROW_IF_FAILED(env, status, Napi::Nothing<type>())
+
+#define NAPI_RETURN_OR_THROW_IF_FAILED(env, status, result, type)              \
+  NAPI_MAYBE_THROW_IF_FAILED(env, status, type);                               \
+  return Napi::Just<type>(result);
+#else
+#define NAPI_MAYBE_THROW_IF_FAILED(env, status, type)                          \
+  NAPI_THROW_IF_FAILED(env, status, type())
+
+#define NAPI_RETURN_OR_THROW_IF_FAILED(env, status, result, type)              \
+  NAPI_MAYBE_THROW_IF_FAILED(env, status, type);                               \
+  return result;
+#endif
+
+# define NAPI_DISALLOW_ASSIGN(CLASS) void operator=(const CLASS&) = delete;
+# define NAPI_DISALLOW_COPY(CLASS) CLASS(const CLASS&) = delete;
+
+#define NAPI_DISALLOW_ASSIGN_COPY(CLASS)  \
+    NAPI_DISALLOW_ASSIGN(CLASS)           \
+    NAPI_DISALLOW_COPY(CLASS)
+
+#define NAPI_CHECK(condition, location, message)                               \
+  do {                                                                         \
+    if (!(condition)) {                                                        \
+      Napi::Error::Fatal((location), (message));                               \
+    }                                                                          \
   } while (0)
 
+#define NAPI_FATAL_IF_FAILED(status, location, message)                        \
+  NAPI_CHECK((status) == napi_ok, location, message)
+
 ////////////////////////////////////////////////////////////////////////////////
-/// N-API C++ Wrapper Classes
+/// Node-API C++ Wrapper Classes
 ///
-/// These classes wrap the "N-API" ABI-stable C APIs for Node.js, providing a
+/// These classes wrap the "Node-API" ABI-stable C APIs for Node.js, providing a
 /// C++ object model and C++ exception-handling semantics with low overhead.
 /// The wrappers are all header-only so that they do not affect the ABI.
 ////////////////////////////////////////////////////////////////////////////////
 namespace Napi {
 
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+// NAPI_CPP_CUSTOM_NAMESPACE can be #define'd per-addon to avoid symbol
+// conflicts between different instances of node-addon-api
+
+// First dummy definition of the namespace to make sure that Napi::(name) still
+// refers to the right things inside this file.
+namespace NAPI_CPP_CUSTOM_NAMESPACE {}
+using namespace NAPI_CPP_CUSTOM_NAMESPACE;
+
+namespace NAPI_CPP_CUSTOM_NAMESPACE {
+#endif
+
   // Forward declarations
   class Env;
   class Value;
   class Boolean;
   class Number;
-// currently experimental guard with version of NAPI_VERSION that it is
-// released in once it is no longer experimental
-#if (NAPI_VERSION > 2147483646)
+#if NAPI_VERSION > 5
   class BigInt;
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION > 5
+#if (NAPI_VERSION > 4)
+  class Date;
+#endif
   class String;
   class Object;
   class Array;
+  class ArrayBuffer;
   class Function;
-  template <typename T> class Buffer;
   class Error;
   class PropertyDescriptor;
   class CallbackInfo;
-  template <typename T> class Reference;
   class TypedArray;
   template <typename T> class TypedArrayOf;
 
-  typedef TypedArrayOf<int8_t> Int8Array;     ///< Typed-array of signed 8-bit integers
-  typedef TypedArrayOf<uint8_t> Uint8Array;   ///< Typed-array of unsigned 8-bit integers
-  typedef TypedArrayOf<int16_t> Int16Array;   ///< Typed-array of signed 16-bit integers
-  typedef TypedArrayOf<uint16_t> Uint16Array; ///< Typed-array of unsigned 16-bit integers
-  typedef TypedArrayOf<int32_t> Int32Array;   ///< Typed-array of signed 32-bit integers
-  typedef TypedArrayOf<uint32_t> Uint32Array; ///< Typed-array of unsigned 32-bit integers
-  typedef TypedArrayOf<float> Float32Array;   ///< Typed-array of 32-bit floating-point values
-  typedef TypedArrayOf<double> Float64Array;  ///< Typed-array of 64-bit floating-point values
-// currently experimental guard with version of NAPI_VERSION that it is
-// released in once it is no longer experimental
-#if (NAPI_VERSION > 2147483646)
-  typedef TypedArrayOf<int64_t> BigInt64Array;   ///< Typed array of signed 64-bit integers
-  typedef TypedArrayOf<uint64_t> BigUint64Array; ///< Typed array of unsigned 64-bit integers
-#endif  // NAPI_EXPERIMENTAL
-
-  /// Defines the signature of a N-API C++ module's registration callback (init) function.
-  typedef Object (*ModuleRegisterCallback)(Env env, Object exports);
+  using Int8Array =
+      TypedArrayOf<int8_t>;  ///< Typed-array of signed 8-bit integers
+  using Uint8Array =
+      TypedArrayOf<uint8_t>;  ///< Typed-array of unsigned 8-bit integers
+  using Int16Array =
+      TypedArrayOf<int16_t>;  ///< Typed-array of signed 16-bit integers
+  using Uint16Array =
+      TypedArrayOf<uint16_t>;  ///< Typed-array of unsigned 16-bit integers
+  using Int32Array =
+      TypedArrayOf<int32_t>;  ///< Typed-array of signed 32-bit integers
+  using Uint32Array =
+      TypedArrayOf<uint32_t>;  ///< Typed-array of unsigned 32-bit integers
+  using Float32Array =
+      TypedArrayOf<float>;  ///< Typed-array of 32-bit floating-point values
+  using Float64Array =
+      TypedArrayOf<double>;  ///< Typed-array of 64-bit floating-point values
+#if NAPI_VERSION > 5
+  using BigInt64Array =
+      TypedArrayOf<int64_t>;  ///< Typed array of signed 64-bit integers
+  using BigUint64Array =
+      TypedArrayOf<uint64_t>;  ///< Typed array of unsigned 64-bit integers
+#endif  // NAPI_VERSION > 5
+
+  /// Defines the signature of a Node-API C++ module's registration callback
+  /// (init) function.
+  using ModuleRegisterCallback = Object (*)(Env env, Object exports);
 
   class MemoryManagement;
 
-  /// Environment for N-API values and operations.
+  /// A simple Maybe type, representing an object which may or may not have a
+  /// value.
   ///
-  /// All N-API values and operations must be associated with an environment. An environment
-  /// instance is always provided to callback functions; that environment must then be used for any
-  /// creation of N-API values or other N-API operations within the callback. (Many methods infer
-  /// the environment from the `this` instance that the method is called on.)
+  /// If an API method returns a Maybe<>, the API method can potentially fail
+  /// either because an exception is thrown, or because an exception is pending,
+  /// e.g. because a previous API call threw an exception that hasn't been
+  /// caught yet. In that case, a "Nothing" value is returned.
+  template <class T>
+  class Maybe {
+   public:
+    bool IsNothing() const;
+    bool IsJust() const;
+
+    /// Short-hand for Unwrap(), which doesn't return a value. Could be used
+    /// where the actual value of the Maybe is not needed like Object::Set.
+    /// If this Maybe is nothing (empty), node-addon-api will crash the
+    /// process.
+    void Check() const;
+
+    /// Return the value of type T contained in the Maybe. If this Maybe is
+    /// nothing (empty), node-addon-api will crash the process.
+    T Unwrap() const;
+
+    /// Return the value of type T contained in the Maybe, or using a default
+    /// value if this Maybe is nothing (empty).
+    T UnwrapOr(const T& default_value) const;
+
+    /// Converts this Maybe to a value of type T in the out. If this Maybe is
+    /// nothing (empty), `false` is returned and `out` is left untouched.
+    bool UnwrapTo(T* out) const;
+
+    bool operator==(const Maybe& other) const;
+    bool operator!=(const Maybe& other) const;
+
+   private:
+    Maybe();
+    explicit Maybe(const T& t);
+
+    bool _has_value;
+    T _value;
+
+    template <class U>
+    friend Maybe<U> Nothing();
+    template <class U>
+    friend Maybe<U> Just(const U& u);
+  };
+
+  template <class T>
+  inline Maybe<T> Nothing();
+
+  template <class T>
+  inline Maybe<T> Just(const T& t);
+
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+  template <typename T>
+  using MaybeOrValue = Maybe<T>;
+#else
+  template <typename T>
+  using MaybeOrValue = T;
+#endif
+
+  /// Environment for Node-API values and operations.
+  ///
+  /// All Node-API values and operations must be associated with an environment.
+  /// An environment instance is always provided to callback functions; that
+  /// environment must then be used for any creation of Node-API values or other
+  /// Node-API operations within the callback. (Many methods infer the
+  /// environment from the `this` instance that the method is called on.)
   ///
-  /// In the future, multiple environments per process may be supported, although current
-  /// implementations only support one environment per process.
+  /// In the future, multiple environments per process may be supported,
+  /// although current implementations only support one environment per process.
   ///
-  /// In the V8 JavaScript engine, a N-API environment approximately corresponds to an Isolate.
+  /// In the V8 JavaScript engine, a Node-API environment approximately
+  /// corresponds to an Isolate.
   class Env {
+   private:
+#if NAPI_VERSION > 2
+    template <typename Hook, typename Arg = void>
+    class CleanupHook;
+#endif  // NAPI_VERSION > 2
+#if NAPI_VERSION > 5
+    template <typename T> static void DefaultFini(Env, T* data);
+    template <typename DataType, typename HintType>
+    static void DefaultFiniWithHint(Env, DataType* data, HintType* hint);
+#endif  // NAPI_VERSION > 5
   public:
     Env(napi_env env);
 
@@ -170,11 +298,61 @@ namespace Napi {
     Value Null() const;
 
     bool IsExceptionPending() const;
-    Error GetAndClearPendingException();
+    Error GetAndClearPendingException() const;
+
+    MaybeOrValue<Value> RunScript(const char* utf8script) const;
+    MaybeOrValue<Value> RunScript(const std::string& utf8script) const;
+    MaybeOrValue<Value> RunScript(String script) const;
+
+#if NAPI_VERSION > 2
+    template <typename Hook>
+    CleanupHook<Hook> AddCleanupHook(Hook hook);
+
+    template <typename Hook, typename Arg>
+    CleanupHook<Hook, Arg> AddCleanupHook(Hook hook, Arg* arg);
+#endif  // NAPI_VERSION > 2
+
+#if NAPI_VERSION > 5
+    template <typename T>
+    T* GetInstanceData() const;
+
+    template <typename T> using Finalizer = void (*)(Env, T*);
+    template <typename T, Finalizer<T> fini = Env::DefaultFini<T>>
+    void SetInstanceData(T* data) const;
+
+    template <typename DataType, typename HintType>
+    using FinalizerWithHint = void (*)(Env, DataType*, HintType*);
+    template <typename DataType,
+              typename HintType,
+              FinalizerWithHint<DataType, HintType> fini =
+                  Env::DefaultFiniWithHint<DataType, HintType>>
+    void SetInstanceData(DataType* data, HintType* hint) const;
+#endif  // NAPI_VERSION > 5
 
   private:
     napi_env _env;
+
+#if NAPI_VERSION > 2
+    template <typename Hook, typename Arg>
+    class CleanupHook {
+     public:
+      CleanupHook(Env env, Hook hook, Arg* arg);
+      CleanupHook(Env env, Hook hook);
+      bool Remove(Env env);
+      bool IsEmpty() const;
+
+     private:
+      static inline void Wrapper(void* data) NAPI_NOEXCEPT;
+      static inline void WrapperWithArg(void* data) NAPI_NOEXCEPT;
+
+      void (*wrapper)(void* arg);
+      struct CleanupData {
+        Hook hook;
+        Arg* arg;
+      } * data;
+    };
   };
+#endif  // NAPI_VERSION > 2
 
   /// A JavaScript value of unknown type.
   ///
@@ -190,7 +368,8 @@ namespace Napi {
   class Value {
   public:
     Value();                               ///< Creates a new _empty_ Value instance.
-    Value(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
+    Value(napi_env env,
+          napi_value value);  ///< Wraps a Node-API value primitive.
 
     /// Creates a JS value from a C++ primitive.
     ///
@@ -207,7 +386,7 @@ namespace Napi {
     template <typename T>
     static Value From(napi_env env, const T& value);
 
-    /// Converts to a N-API value primitive.
+    /// Converts to a Node-API value primitive.
     ///
     /// If the instance is _empty_, this returns `nullptr`.
     operator napi_value() const;
@@ -241,11 +420,12 @@ namespace Napi {
     bool IsNull() const;        ///< Tests if a value is a null JavaScript value.
     bool IsBoolean() const;     ///< Tests if a value is a JavaScript boolean.
     bool IsNumber() const;      ///< Tests if a value is a JavaScript number.
-// currently experimental guard with version of NAPI_VERSION that it is
-// released in once it is no longer experimental
-#if (NAPI_VERSION > 2147483646)
+#if NAPI_VERSION > 5
     bool IsBigInt() const;      ///< Tests if a value is a JavaScript bigint.
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION > 5
+#if (NAPI_VERSION > 4)
+    bool IsDate() const;        ///< Tests if a value is a JavaScript date.
+#endif
     bool IsString() const;      ///< Tests if a value is a JavaScript string.
     bool IsSymbol() const;      ///< Tests if a value is a JavaScript symbol.
     bool IsArray() const;       ///< Tests if a value is a JavaScript array.
@@ -264,12 +444,16 @@ namespace Napi {
     /// value type will throw `Napi::Error`.
     template <typename T> T As() const;
 
-    Boolean ToBoolean() const; ///< Coerces a value to a JavaScript boolean.
-    Number ToNumber() const;   ///< Coerces a value to a JavaScript number.
-    String ToString() const;   ///< Coerces a value to a JavaScript string.
-    Object ToObject() const;   ///< Coerces a value to a JavaScript object.
+    MaybeOrValue<Boolean> ToBoolean()
+        const;  ///< Coerces a value to a JavaScript boolean.
+    MaybeOrValue<Number> ToNumber()
+        const;  ///< Coerces a value to a JavaScript number.
+    MaybeOrValue<String> ToString()
+        const;  ///< Coerces a value to a JavaScript string.
+    MaybeOrValue<Object> ToObject()
+        const;  ///< Coerces a value to a JavaScript object.
 
-  protected:
+   protected:
     /// !cond INTERNAL
     napi_env _env;
     napi_value _value;
@@ -279,200 +463,255 @@ namespace Napi {
   /// A JavaScript boolean value.
   class Boolean : public Value {
   public:
-    static Boolean New(
-      napi_env env, ///< N-API environment
-      bool value    ///< Boolean value
-    );
+   static Boolean New(napi_env env,  ///< Node-API environment
+                      bool value     ///< Boolean value
+   );
 
-    Boolean();                               ///< Creates a new _empty_ Boolean instance.
-    Boolean(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
+   Boolean();  ///< Creates a new _empty_ Boolean instance.
+   Boolean(napi_env env,
+           napi_value value);  ///< Wraps a Node-API value primitive.
 
-    operator bool() const; ///< Converts a Boolean value to a boolean primitive.
-    bool Value() const;    ///< Converts a Boolean value to a boolean primitive.
+   operator bool() const;  ///< Converts a Boolean value to a boolean primitive.
+   bool Value() const;     ///< Converts a Boolean value to a boolean primitive.
   };
 
   /// A JavaScript number value.
   class Number : public Value {
   public:
-    static Number New(
-      napi_env env, ///< N-API environment
-      double value  ///< Number value
-    );
-
-    Number();                               ///< Creates a new _empty_ Number instance.
-    Number(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
-
-    operator int32_t() const;  ///< Converts a Number value to a 32-bit signed integer value.
-    operator uint32_t() const; ///< Converts a Number value to a 32-bit unsigned integer value.
-    operator int64_t() const;  ///< Converts a Number value to a 64-bit signed integer value.
-    operator float() const;    ///< Converts a Number value to a 32-bit floating-point value.
-    operator double() const;   ///< Converts a Number value to a 64-bit floating-point value.
-
-    int32_t Int32Value() const;   ///< Converts a Number value to a 32-bit signed integer value.
-    uint32_t Uint32Value() const; ///< Converts a Number value to a 32-bit unsigned integer value.
-    int64_t Int64Value() const;   ///< Converts a Number value to a 64-bit signed integer value.
-    float FloatValue() const;     ///< Converts a Number value to a 32-bit floating-point value.
-    double DoubleValue() const;   ///< Converts a Number value to a 64-bit floating-point value.
+   static Number New(napi_env env,  ///< Node-API environment
+                     double value   ///< Number value
+   );
+
+   Number();  ///< Creates a new _empty_ Number instance.
+   Number(napi_env env,
+          napi_value value);  ///< Wraps a Node-API value primitive.
+
+   operator int32_t()
+       const;  ///< Converts a Number value to a 32-bit signed integer value.
+   operator uint32_t()
+       const;  ///< Converts a Number value to a 32-bit unsigned integer value.
+   operator int64_t()
+       const;  ///< Converts a Number value to a 64-bit signed integer value.
+   operator float()
+       const;  ///< Converts a Number value to a 32-bit floating-point value.
+   operator double()
+       const;  ///< Converts a Number value to a 64-bit floating-point value.
+
+   int32_t Int32Value()
+       const;  ///< Converts a Number value to a 32-bit signed integer value.
+   uint32_t Uint32Value()
+       const;  ///< Converts a Number value to a 32-bit unsigned integer value.
+   int64_t Int64Value()
+       const;  ///< Converts a Number value to a 64-bit signed integer value.
+   float FloatValue()
+       const;  ///< Converts a Number value to a 32-bit floating-point value.
+   double DoubleValue()
+       const;  ///< Converts a Number value to a 64-bit floating-point value.
   };
 
-// currently experimental guard with version of NAPI_VERSION that it is
-// released in once it is no longer experimental
-#if (NAPI_VERSION > 2147483646)
+#if NAPI_VERSION > 5
   /// A JavaScript bigint value.
   class BigInt : public Value {
   public:
-    static BigInt New(
-      napi_env env, ///< N-API environment
-      int64_t value ///< Number value
-    );
-    static BigInt New(
-      napi_env env,  ///< N-API environment
-      uint64_t value ///< Number value
-    );
-
-    /// Creates a new BigInt object using a specified sign bit and a
-    /// specified list of digits/words.
-    /// The resulting number is calculated as:
-    /// (-1)^sign_bit * (words[0] * (2^64)^0 + words[1] * (2^64)^1 + ...)
-    static BigInt New(
-      napi_env env,          ///< N-API environment
-      int sign_bit,          ///< Sign bit. 1 if negative.
-      size_t word_count,     ///< Number of words in array
-      const uint64_t* words  ///< Array of words
-    );
-
-    BigInt();                               ///< Creates a new _empty_ BigInt instance.
-    BigInt(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
+   static BigInt New(napi_env env,  ///< Node-API environment
+                     int64_t value  ///< Number value
+   );
+   static BigInt New(napi_env env,   ///< Node-API environment
+                     uint64_t value  ///< Number value
+   );
+
+   /// Creates a new BigInt object using a specified sign bit and a
+   /// specified list of digits/words.
+   /// The resulting number is calculated as:
+   /// (-1)^sign_bit * (words[0] * (2^64)^0 + words[1] * (2^64)^1 + ...)
+   static BigInt New(napi_env env,          ///< Node-API environment
+                     int sign_bit,          ///< Sign bit. 1 if negative.
+                     size_t word_count,     ///< Number of words in array
+                     const uint64_t* words  ///< Array of words
+   );
+
+   BigInt();  ///< Creates a new _empty_ BigInt instance.
+   BigInt(napi_env env,
+          napi_value value);  ///< Wraps a Node-API value primitive.
+
+   int64_t Int64Value(bool* lossless)
+       const;  ///< Converts a BigInt value to a 64-bit signed integer value.
+   uint64_t Uint64Value(bool* lossless)
+       const;  ///< Converts a BigInt value to a 64-bit unsigned integer value.
+
+   size_t WordCount() const;  ///< The number of 64-bit words needed to store
+                              ///< the result of ToWords().
+
+   /// Writes the contents of this BigInt to a specified memory location.
+   /// `sign_bit` must be provided and will be set to 1 if this BigInt is
+   /// negative.
+   /// `*word_count` has to be initialized to the length of the `words` array.
+   /// Upon return, it will be set to the actual number of words that would
+   /// be needed to store this BigInt (i.e. the return value of `WordCount()`).
+   void ToWords(int* sign_bit, size_t* word_count, uint64_t* words);
+  };
+#endif  // NAPI_VERSION > 5
 
-    int64_t Int64Value(bool* lossless) const;   ///< Converts a BigInt value to a 64-bit signed integer value.
-    uint64_t Uint64Value(bool* lossless) const; ///< Converts a BigInt value to a 64-bit unsigned integer value.
+#if (NAPI_VERSION > 4)
+  /// A JavaScript date value.
+  class Date : public Value {
+  public:
+    /// Creates a new Date value from a double primitive.
+   static Date New(napi_env env,  ///< Node-API environment
+                   double value   ///< Number value
+   );
 
-    size_t WordCount() const; ///< The number of 64-bit words needed to store the result of ToWords().
+   Date();  ///< Creates a new _empty_ Date instance.
+   Date(napi_env env, napi_value value);  ///< Wraps a Node-API value primitive.
+   operator double() const;  ///< Converts a Date value to double primitive
 
-    /// Writes the contents of this BigInt to a specified memory location.
-    /// `sign_bit` must be provided and will be set to 1 if this BigInt is negative.
-    /// `*word_count` has to be initialized to the length of the `words` array.
-    /// Upon return, it will be set to the actual number of words that would
-    /// be needed to store this BigInt (i.e. the return value of `WordCount()`).
-    void ToWords(int* sign_bit, size_t* word_count, uint64_t* words);
+   double ValueOf() const;  ///< Converts a Date value to a double primitive.
   };
-#endif  // NAPI_EXPERIMENTAL
+  #endif
 
   /// A JavaScript string or symbol value (that can be used as a property name).
   class Name : public Value {
   public:
     Name();                               ///< Creates a new _empty_ Name instance.
-    Name(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
+    Name(napi_env env,
+         napi_value value);  ///< Wraps a Node-API value primitive.
   };
 
   /// A JavaScript string value.
   class String : public Name {
   public:
     /// Creates a new String value from a UTF-8 encoded C++ string.
-    static String New(
-      napi_env env,            ///< N-API environment
-      const std::string& value ///< UTF-8 encoded C++ string
-    );
-
-    /// Creates a new String value from a UTF-16 encoded C++ string.
-    static String New(
-      napi_env env,               ///< N-API environment
-      const std::u16string& value ///< UTF-16 encoded C++ string
-    );
-
-    /// Creates a new String value from a UTF-8 encoded C string.
-    static String New(
-      napi_env env,     ///< N-API environment
-      const char* value ///< UTF-8 encoded null-terminated C string
-    );
-
-    /// Creates a new String value from a UTF-16 encoded C string.
-    static String New(
-      napi_env env,         ///< N-API environment
-      const char16_t* value ///< UTF-16 encoded null-terminated C string
-    );
-
-    /// Creates a new String value from a UTF-8 encoded C string with specified length.
-    static String New(
-      napi_env env,      ///< N-API environment
-      const char* value, ///< UTF-8 encoded C string (not necessarily null-terminated)
-      size_t length      ///< length of the string in bytes
-    );
-
-    /// Creates a new String value from a UTF-16 encoded C string with specified length.
-    static String New(
-      napi_env env,          ///< N-API environment
-      const char16_t* value, ///< UTF-16 encoded C string (not necessarily null-terminated)
-      size_t length          ///< Length of the string in 2-byte code units
-    );
-
-    /// Creates a new String based on the original object's type.
-    ///
-    /// `value` may be any of:
-    /// - const char* (encoded using UTF-8, null-terminated)
-    /// - const char16_t* (encoded using UTF-16-LE, null-terminated)
-    /// - std::string (encoded using UTF-8)
-    /// - std::u16string
-    template <typename T>
-    static String From(napi_env env, const T& value);
-
-    String();                               ///< Creates a new _empty_ String instance.
-    String(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
-
-    operator std::string() const;      ///< Converts a String value to a UTF-8 encoded C++ string.
-    operator std::u16string() const;   ///< Converts a String value to a UTF-16 encoded C++ string.
-    std::string Utf8Value() const;     ///< Converts a String value to a UTF-8 encoded C++ string.
-    std::u16string Utf16Value() const; ///< Converts a String value to a UTF-16 encoded C++ string.
+   static String New(napi_env env,             ///< Node-API environment
+                     const std::string& value  ///< UTF-8 encoded C++ string
+   );
+
+   /// Creates a new String value from a UTF-16 encoded C++ string.
+   static String New(napi_env env,                ///< Node-API environment
+                     const std::u16string& value  ///< UTF-16 encoded C++ string
+   );
+
+   /// Creates a new String value from a UTF-8 encoded C string.
+   static String New(
+       napi_env env,      ///< Node-API environment
+       const char* value  ///< UTF-8 encoded null-terminated C string
+   );
+
+   /// Creates a new String value from a UTF-16 encoded C string.
+   static String New(
+       napi_env env,          ///< Node-API environment
+       const char16_t* value  ///< UTF-16 encoded null-terminated C string
+   );
+
+   /// Creates a new String value from a UTF-8 encoded C string with specified
+   /// length.
+   static String New(napi_env env,       ///< Node-API environment
+                     const char* value,  ///< UTF-8 encoded C string (not
+                                         ///< necessarily null-terminated)
+                     size_t length       ///< length of the string in bytes
+   );
+
+   /// Creates a new String value from a UTF-16 encoded C string with specified
+   /// length.
+   static String New(
+       napi_env env,           ///< Node-API environment
+       const char16_t* value,  ///< UTF-16 encoded C string (not necessarily
+                               ///< null-terminated)
+       size_t length           ///< Length of the string in 2-byte code units
+   );
+
+   /// Creates a new String based on the original object's type.
+   ///
+   /// `value` may be any of:
+   /// - const char* (encoded using UTF-8, null-terminated)
+   /// - const char16_t* (encoded using UTF-16-LE, null-terminated)
+   /// - std::string (encoded using UTF-8)
+   /// - std::u16string
+   template <typename T>
+   static String From(napi_env env, const T& value);
+
+   String();  ///< Creates a new _empty_ String instance.
+   String(napi_env env,
+          napi_value value);  ///< Wraps a Node-API value primitive.
+
+   operator std::string()
+       const;  ///< Converts a String value to a UTF-8 encoded C++ string.
+   operator std::u16string()
+       const;  ///< Converts a String value to a UTF-16 encoded C++ string.
+   std::string Utf8Value()
+       const;  ///< Converts a String value to a UTF-8 encoded C++ string.
+   std::u16string Utf16Value()
+       const;  ///< Converts a String value to a UTF-16 encoded C++ string.
   };
 
   /// A JavaScript symbol value.
   class Symbol : public Name {
   public:
     /// Creates a new Symbol value with an optional description.
-    static Symbol New(
-      napi_env env,                     ///< N-API environment
-      const char* description = nullptr ///< Optional UTF-8 encoded null-terminated C string
-                                        ///  describing the symbol
-    );
-
-    /// Creates a new Symbol value with a description.
-    static Symbol New(
-      napi_env env,                  ///< N-API environment
-      const std::string& description ///< UTF-8 encoded C++ string describing the symbol
-    );
-
-    /// Creates a new Symbol value with a description.
-    static Symbol New(
-      napi_env env,      ///< N-API environment
-      String description ///< String value describing the symbol
-    );
-
-    /// Creates a new Symbol value with a description.
-    static Symbol New(
-      napi_env env,          ///< N-API environment
-      napi_value description ///< String value describing the symbol
-    );
-
-    /// Get a public Symbol (e.g. Symbol.iterator).
-    static Symbol WellKnown(napi_env, const std::string& name);
-
-    Symbol();                               ///< Creates a new _empty_ Symbol instance.
-    Symbol(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
+   static Symbol New(
+       napi_env env,  ///< Node-API environment
+       const char* description =
+           nullptr  ///< Optional UTF-8 encoded null-terminated C string
+                    ///  describing the symbol
+   );
+
+   /// Creates a new Symbol value with a description.
+   static Symbol New(
+       napi_env env,  ///< Node-API environment
+       const std::string&
+           description  ///< UTF-8 encoded C++ string describing the symbol
+   );
+
+   /// Creates a new Symbol value with a description.
+   static Symbol New(napi_env env,       ///< Node-API environment
+                     String description  ///< String value describing the symbol
+   );
+
+   /// Creates a new Symbol value with a description.
+   static Symbol New(
+       napi_env env,           ///< Node-API environment
+       napi_value description  ///< String value describing the symbol
+   );
+
+   /// Get a public Symbol (e.g. Symbol.iterator).
+   static MaybeOrValue<Symbol> WellKnown(napi_env, const std::string& name);
+
+   // Create a symbol in the global registry, UTF-8 Encoded cpp string
+   static MaybeOrValue<Symbol> For(napi_env env,
+                                   const std::string& description);
+
+   // Create a symbol in the global registry, C style string (null terminated)
+   static MaybeOrValue<Symbol> For(napi_env env, const char* description);
+
+   // Create a symbol in the global registry, String value describing the symbol
+   static MaybeOrValue<Symbol> For(napi_env env, String description);
+
+   // Create a symbol in the global registry, napi_value describing the symbol
+   static MaybeOrValue<Symbol> For(napi_env env, napi_value description);
+
+   Symbol();  ///< Creates a new _empty_ Symbol instance.
+   Symbol(napi_env env,
+          napi_value value);  ///< Wraps a Node-API value primitive.
   };
 
   /// A JavaScript object value.
   class Object : public Value {
   public:
-    /// Enables property and element assignments using indexing syntax.
-    ///
-    /// Example:
-    ///
-    ///     Napi::Value propertyValue = object1['A'];
-    ///     object2['A'] = propertyValue;
-    ///     Napi::Value elementValue = array[0];
-    ///     array[1] = elementValue;
-    template <typename Key>
-    class PropertyLValue {
+   /// Enables property and element assignments using indexing syntax.
+   ///
+   /// This is a convenient helper to get and set object properties. As
+   /// getting and setting object properties may throw with JavaScript
+   /// exceptions, it is notable that these operations may fail.
+   /// When NODE_ADDON_API_ENABLE_MAYBE is defined, the process will abort
+   /// on JavaScript exceptions.
+   ///
+   /// Example:
+   ///
+   ///     Napi::Value propertyValue = object1['A'];
+   ///     object2['A'] = propertyValue;
+   ///     Napi::Value elementValue = array[0];
+   ///     array[1] = elementValue;
+   template <typename Key>
+   class PropertyLValue {
     public:
       /// Converts an L-value to a value.
       operator Value() const;
@@ -490,201 +729,249 @@ namespace Napi {
       Key _key;
 
       friend class Napi::Object;
-    };
+   };
 
     /// Creates a new Object value.
-    static Object New(
-      napi_env env ///< N-API environment
+    static Object New(napi_env env  ///< Node-API environment
     );
 
     Object();                               ///< Creates a new _empty_ Object instance.
-    Object(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
+    Object(napi_env env,
+           napi_value value);  ///< Wraps a Node-API value primitive.
 
     /// Gets or sets a named property.
-    PropertyLValue<std::string> operator [](
-      const char* utf8name ///< UTF-8 encoded null-terminated property name
+    PropertyLValue<std::string> operator[](
+        const char* utf8name  ///< UTF-8 encoded null-terminated property name
     );
 
     /// Gets or sets a named property.
-    PropertyLValue<std::string> operator [](
-      const std::string& utf8name ///< UTF-8 encoded property name
+    PropertyLValue<std::string> operator[](
+        const std::string& utf8name  ///< UTF-8 encoded property name
     );
 
     /// Gets or sets an indexed property or array element.
-    PropertyLValue<uint32_t> operator [](
-      uint32_t index /// Property / element index
+    PropertyLValue<uint32_t> operator[](
+        uint32_t index  /// Property / element index
     );
 
+    /// Gets or sets an indexed property or array element.
+    PropertyLValue<Value> operator[](Value index  /// Property / element index
+    ) const;
+
     /// Gets a named property.
-    Value operator [](
-      const char* utf8name ///< UTF-8 encoded null-terminated property name
+    MaybeOrValue<Value> operator[](
+        const char* utf8name  ///< UTF-8 encoded null-terminated property name
     ) const;
 
     /// Gets a named property.
-    Value operator [](
-      const std::string& utf8name ///< UTF-8 encoded property name
+    MaybeOrValue<Value> operator[](
+        const std::string& utf8name  ///< UTF-8 encoded property name
     ) const;
 
     /// Gets an indexed property or array element.
-    Value operator [](
-      uint32_t index ///< Property / element index
+    MaybeOrValue<Value> operator[](uint32_t index  ///< Property / element index
     ) const;
 
     /// Checks whether a property is present.
-    bool Has(
-      napi_value key ///< Property key primitive
+    MaybeOrValue<bool> Has(napi_value key  ///< Property key primitive
     ) const;
 
     /// Checks whether a property is present.
-    bool Has(
-      Value key ///< Property key
+    MaybeOrValue<bool> Has(Value key  ///< Property key
     ) const;
 
     /// Checks whether a named property is present.
-    bool Has(
-      const char* utf8name ///< UTF-8 encoded null-terminated property name
+    MaybeOrValue<bool> Has(
+        const char* utf8name  ///< UTF-8 encoded null-terminated property name
     ) const;
 
     /// Checks whether a named property is present.
-    bool Has(
-      const std::string& utf8name ///< UTF-8 encoded property name
+    MaybeOrValue<bool> Has(
+        const std::string& utf8name  ///< UTF-8 encoded property name
     ) const;
 
     /// Checks whether a own property is present.
-    bool HasOwnProperty(
-      napi_value key ///< Property key primitive
+    MaybeOrValue<bool> HasOwnProperty(
+        napi_value key  ///< Property key primitive
     ) const;
 
     /// Checks whether a own property is present.
-    bool HasOwnProperty(
-      Value key ///< Property key
+    MaybeOrValue<bool> HasOwnProperty(Value key  ///< Property key
     ) const;
 
     /// Checks whether a own property is present.
-    bool HasOwnProperty(
-      const char* utf8name ///< UTF-8 encoded null-terminated property name
+    MaybeOrValue<bool> HasOwnProperty(
+        const char* utf8name  ///< UTF-8 encoded null-terminated property name
     ) const;
 
     /// Checks whether a own property is present.
-    bool HasOwnProperty(
-      const std::string& utf8name ///< UTF-8 encoded property name
+    MaybeOrValue<bool> HasOwnProperty(
+        const std::string& utf8name  ///< UTF-8 encoded property name
     ) const;
 
     /// Gets a property.
-    Value Get(
-      napi_value key ///< Property key primitive
+    MaybeOrValue<Value> Get(napi_value key  ///< Property key primitive
     ) const;
 
     /// Gets a property.
-    Value Get(
-      Value key ///< Property key
+    MaybeOrValue<Value> Get(Value key  ///< Property key
     ) const;
 
     /// Gets a named property.
-    Value Get(
-      const char* utf8name ///< UTF-8 encoded null-terminated property name
+    MaybeOrValue<Value> Get(
+        const char* utf8name  ///< UTF-8 encoded null-terminated property name
     ) const;
 
     /// Gets a named property.
-    Value Get(
-      const std::string& utf8name ///< UTF-8 encoded property name
+    MaybeOrValue<Value> Get(
+        const std::string& utf8name  ///< UTF-8 encoded property name
     ) const;
 
     /// Sets a property.
     template <typename ValueType>
-    void Set(
-      napi_value key,  ///< Property key primitive
-      const ValueType& value ///< Property value primitive
-    );
+    MaybeOrValue<bool> Set(napi_value key,         ///< Property key primitive
+                           const ValueType& value  ///< Property value primitive
+    ) const;
 
     /// Sets a property.
     template <typename ValueType>
-    void Set(
-      Value key,  ///< Property key
-      const ValueType& value ///< Property value
-    );
+    MaybeOrValue<bool> Set(Value key,              ///< Property key
+                           const ValueType& value  ///< Property value
+    ) const;
 
     /// Sets a named property.
     template <typename ValueType>
-    void Set(
-      const char* utf8name, ///< UTF-8 encoded null-terminated property name
-      const ValueType& value
-    );
+    MaybeOrValue<bool> Set(
+        const char* utf8name,  ///< UTF-8 encoded null-terminated property name
+        const ValueType& value) const;
 
     /// Sets a named property.
     template <typename ValueType>
-    void Set(
-      const std::string& utf8name, ///< UTF-8 encoded property name
-      const ValueType& value             ///< Property value primitive
-    );
+    MaybeOrValue<bool> Set(
+        const std::string& utf8name,  ///< UTF-8 encoded property name
+        const ValueType& value        ///< Property value primitive
+    ) const;
 
     /// Delete property.
-    bool Delete(
-      napi_value key ///< Property key primitive
-    );
+    MaybeOrValue<bool> Delete(napi_value key  ///< Property key primitive
+    ) const;
 
     /// Delete property.
-    bool Delete(
-      Value key ///< Property key
-    );
+    MaybeOrValue<bool> Delete(Value key  ///< Property key
+    ) const;
 
     /// Delete property.
-    bool Delete(
-      const char* utf8name ///< UTF-8 encoded null-terminated property name
-    );
+    MaybeOrValue<bool> Delete(
+        const char* utf8name  ///< UTF-8 encoded null-terminated property name
+    ) const;
 
     /// Delete property.
-    bool Delete(
-      const std::string& utf8name ///< UTF-8 encoded property name
-    );
+    MaybeOrValue<bool> Delete(
+        const std::string& utf8name  ///< UTF-8 encoded property name
+    ) const;
 
     /// Checks whether an indexed property is present.
-    bool Has(
-      uint32_t index ///< Property / element index
+    MaybeOrValue<bool> Has(uint32_t index  ///< Property / element index
     ) const;
 
     /// Gets an indexed property or array element.
-    Value Get(
-      uint32_t index ///< Property / element index
+    MaybeOrValue<Value> Get(uint32_t index  ///< Property / element index
     ) const;
 
     /// Sets an indexed property or array element.
     template <typename ValueType>
-    void Set(
-      uint32_t index,  ///< Property / element index
-      const ValueType& value ///< Property value primitive
-    );
+    MaybeOrValue<bool> Set(uint32_t index,         ///< Property / element index
+                           const ValueType& value  ///< Property value primitive
+    ) const;
 
     /// Deletes an indexed property or array element.
-    bool Delete(
-      uint32_t index ///< Property / element index
-    );
+    MaybeOrValue<bool> Delete(uint32_t index  ///< Property / element index
+    ) const;
 
-    Array GetPropertyNames() const; ///< Get all property names
+    /// This operation can fail in case of Proxy.[[OwnPropertyKeys]] and
+    /// Proxy.[[GetOwnProperty]] calling into JavaScript. See:
+    /// -
+    /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys
+    /// -
+    /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getownproperty-p
+    MaybeOrValue<Array> GetPropertyNames() const;  ///< Get all property names
 
     /// Defines a property on the object.
-    void DefineProperty(
-      const PropertyDescriptor& property ///< Descriptor for the property to be defined
-    );
+    ///
+    /// This operation can fail in case of Proxy.[[DefineOwnProperty]] calling
+    /// into JavaScript. See
+    /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc
+    MaybeOrValue<bool> DefineProperty(
+        const PropertyDescriptor&
+            property  ///< Descriptor for the property to be defined
+    ) const;
 
     /// Defines properties on the object.
-    void DefineProperties(
-      const std::initializer_list<PropertyDescriptor>& properties
+    ///
+    /// This operation can fail in case of Proxy.[[DefineOwnProperty]] calling
+    /// into JavaScript. See
+    /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc
+    MaybeOrValue<bool> DefineProperties(
+        const std::initializer_list<PropertyDescriptor>& properties
         ///< List of descriptors for the properties to be defined
-    );
+    ) const;
 
     /// Defines properties on the object.
-    void DefineProperties(
-      const std::vector<PropertyDescriptor>& properties
+    ///
+    /// This operation can fail in case of Proxy.[[DefineOwnProperty]] calling
+    /// into JavaScript. See
+    /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc
+    MaybeOrValue<bool> DefineProperties(
+        const std::vector<PropertyDescriptor>& properties
         ///< Vector of descriptors for the properties to be defined
-    );
+    ) const;
 
     /// Checks if an object is an instance created by a constructor function.
     ///
     /// This is equivalent to the JavaScript `instanceof` operator.
-    bool InstanceOf(
-      const Function& constructor ///< Constructor function
+    ///
+    /// This operation can fail in case of Proxy.[[GetPrototypeOf]] calling into
+    /// JavaScript.
+    /// See
+    /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof
+    MaybeOrValue<bool> InstanceOf(
+        const Function& constructor  ///< Constructor function
     ) const;
+
+    template <typename Finalizer, typename T>
+    inline void AddFinalizer(Finalizer finalizeCallback, T* data) const;
+
+    template <typename Finalizer, typename T, typename Hint>
+    inline void AddFinalizer(Finalizer finalizeCallback,
+                             T* data,
+                             Hint* finalizeHint) const;
+
+#ifdef NAPI_CPP_EXCEPTIONS
+    class const_iterator;
+
+    inline const_iterator begin() const;
+
+    inline const_iterator end() const;
+
+    class iterator;
+
+    inline iterator begin();
+
+    inline iterator end();
+#endif  // NAPI_CPP_EXCEPTIONS
+
+#if NAPI_VERSION >= 8
+    /// This operation can fail in case of Proxy.[[GetPrototypeOf]] calling into
+    /// JavaScript.
+    /// See
+    /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof
+    MaybeOrValue<bool> Freeze() const;
+    /// This operation can fail in case of Proxy.[[GetPrototypeOf]] calling into
+    /// JavaScript.
+    /// See
+    /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof
+    MaybeOrValue<bool> Seal() const;
+#endif  // NAPI_VERSION >= 8
   };
 
   template <typename T>
@@ -721,57 +1008,119 @@ namespace Napi {
     uint32_t Length() const;
   };
 
-  /// A JavaScript array buffer value.
-  class ArrayBuffer : public Object {
-  public:
-    /// Creates a new ArrayBuffer instance over a new automatically-allocated buffer.
-    static ArrayBuffer New(
-      napi_env env,     ///< N-API environment
-      size_t byteLength ///< Length of the buffer to be allocated, in bytes
-    );
+#ifdef NAPI_CPP_EXCEPTIONS
+  class Object::const_iterator {
+   private:
+    enum class Type { BEGIN, END };
 
-    /// Creates a new ArrayBuffer instance, using an external buffer with specified byte length.
-    static ArrayBuffer New(
-      napi_env env,       ///< N-API environment
-      void* externalData, ///< Pointer to the external buffer to be used by the array
-      size_t byteLength   ///< Length of the external buffer to be used by the array, in bytes
-    );
+    inline const_iterator(const Object* object, const Type type);
 
-    /// Creates a new ArrayBuffer instance, using an external buffer with specified byte length.
-    template <typename Finalizer>
-    static ArrayBuffer New(
-      napi_env env,              ///< N-API environment
-      void* externalData,        ///< Pointer to the external buffer to be used by the array
-      size_t byteLength,         ///< Length of the external buffer to be used by the array,
-                                 ///  in bytes
-      Finalizer finalizeCallback ///< Function to be called when the array buffer is destroyed;
-                                 ///  must implement `void operator()(Env env, void* externalData)`
-    );
+   public:
+    inline const_iterator& operator++();
 
-    /// Creates a new ArrayBuffer instance, using an external buffer with specified byte length.
-    template <typename Finalizer, typename Hint>
-    static ArrayBuffer New(
-      napi_env env,               ///< N-API environment
-      void* externalData,         ///< Pointer to the external buffer to be used by the array
-      size_t byteLength,          ///< Length of the external buffer to be used by the array,
-                                  ///  in bytes
-      Finalizer finalizeCallback, ///< Function to be called when the array buffer is destroyed;
-                                  ///  must implement `void operator()(Env env, void* externalData, Hint* hint)`
-      Hint* finalizeHint          ///< Hint (second parameter) to be passed to the finalize callback
-    );
+    inline bool operator==(const const_iterator& other) const;
 
-    ArrayBuffer();                               ///< Creates a new _empty_ ArrayBuffer instance.
-    ArrayBuffer(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
+    inline bool operator!=(const const_iterator& other) const;
 
-    void* Data();        ///< Gets a pointer to the data buffer.
-    size_t ByteLength(); ///< Gets the length of the array buffer in bytes.
+    inline const std::pair<Value, Object::PropertyLValue<Value>> operator*()
+        const;
 
-  private:
-    mutable void* _data;
-    mutable size_t _length;
+   private:
+    const Napi::Object* _object;
+    Array _keys;
+    uint32_t _index;
 
-    ArrayBuffer(napi_env env, napi_value value, void* data, size_t length);
-    void EnsureInfo() const;
+    friend class Object;
+  };
+
+  class Object::iterator {
+   private:
+    enum class Type { BEGIN, END };
+
+    inline iterator(Object* object, const Type type);
+
+   public:
+    inline iterator& operator++();
+
+    inline bool operator==(const iterator& other) const;
+
+    inline bool operator!=(const iterator& other) const;
+
+    inline std::pair<Value, Object::PropertyLValue<Value>> operator*();
+
+   private:
+    Napi::Object* _object;
+    Array _keys;
+    uint32_t _index;
+
+    friend class Object;
+  };
+#endif  // NAPI_CPP_EXCEPTIONS
+
+  /// A JavaScript array buffer value.
+  class ArrayBuffer : public Object {
+  public:
+    /// Creates a new ArrayBuffer instance over a new automatically-allocated buffer.
+   static ArrayBuffer New(
+       napi_env env,      ///< Node-API environment
+       size_t byteLength  ///< Length of the buffer to be allocated, in bytes
+   );
+
+   /// Creates a new ArrayBuffer instance, using an external buffer with
+   /// specified byte length.
+   static ArrayBuffer New(
+       napi_env env,        ///< Node-API environment
+       void* externalData,  ///< Pointer to the external buffer to be used by
+                            ///< the array
+       size_t byteLength    ///< Length of the external buffer to be used by the
+                            ///< array, in bytes
+   );
+
+   /// Creates a new ArrayBuffer instance, using an external buffer with
+   /// specified byte length.
+   template <typename Finalizer>
+   static ArrayBuffer New(
+       napi_env env,        ///< Node-API environment
+       void* externalData,  ///< Pointer to the external buffer to be used by
+                            ///< the array
+       size_t byteLength,   ///< Length of the external buffer to be used by the
+                            ///< array,
+                            ///  in bytes
+       Finalizer finalizeCallback  ///< Function to be called when the array
+                                   ///< buffer is destroyed;
+                                   ///  must implement `void operator()(Env env,
+                                   ///  void* externalData)`
+   );
+
+   /// Creates a new ArrayBuffer instance, using an external buffer with
+   /// specified byte length.
+   template <typename Finalizer, typename Hint>
+   static ArrayBuffer New(
+       napi_env env,        ///< Node-API environment
+       void* externalData,  ///< Pointer to the external buffer to be used by
+                            ///< the array
+       size_t byteLength,   ///< Length of the external buffer to be used by the
+                            ///< array,
+                            ///  in bytes
+       Finalizer finalizeCallback,  ///< Function to be called when the array
+                                    ///< buffer is destroyed;
+                                    ///  must implement `void operator()(Env
+                                    ///  env, void* externalData, Hint* hint)`
+       Hint* finalizeHint  ///< Hint (second parameter) to be passed to the
+                           ///< finalize callback
+   );
+
+   ArrayBuffer();  ///< Creates a new _empty_ ArrayBuffer instance.
+   ArrayBuffer(napi_env env,
+               napi_value value);  ///< Wraps a Node-API value primitive.
+
+   void* Data();         ///< Gets a pointer to the data buffer.
+   size_t ByteLength();  ///< Gets the length of the array buffer in bytes.
+
+#if NAPI_VERSION >= 7
+    bool IsDetached() const;
+    void Detach();
+#endif  // NAPI_VERSION >= 7
   };
 
   /// A JavaScript typed-array value with unknown array type.
@@ -786,7 +1135,8 @@ namespace Napi {
   class TypedArray : public Object {
   public:
     TypedArray();                               ///< Creates a new _empty_ TypedArray instance.
-    TypedArray(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
+    TypedArray(napi_env env,
+               napi_value value);  ///< Wraps a Node-API value primitive.
 
     napi_typedarray_type TypedArrayType() const; ///< Gets the type of this typed-array.
     Napi::ArrayBuffer ArrayBuffer() const;       ///< Gets the backing array buffer.
@@ -819,12 +1169,10 @@ namespace Napi {
         : std::is_same<T, uint32_t>::value ? napi_uint32_array
         : std::is_same<T, float>::value ? napi_float32_array
         : std::is_same<T, double>::value ? napi_float64_array
-// currently experimental guard with version of NAPI_VERSION that it is
-// released in once it is no longer experimental
-#if (NAPI_VERSION > 2147483646)
+#if NAPI_VERSION > 5
         : std::is_same<T, int64_t>::value ? napi_bigint64_array
         : std::is_same<T, uint64_t>::value ? napi_biguint64_array
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION > 5
         : unknown_array_type;
     }
     /// !endcond
@@ -843,16 +1191,19 @@ namespace Napi {
     /// parameter T), except when creating a "clamped" array:
     ///
     ///     Uint8Array::New(env, length, napi_uint8_clamped_array)
-    static TypedArrayOf New(
-      napi_env env,         ///< N-API environment
-      size_t elementLength, ///< Length of the created array, as a number of elements
+   static TypedArrayOf New(
+       napi_env env,          ///< Node-API environment
+       size_t elementLength,  ///< Length of the created array, as a number of
+                              ///< elements
 #if defined(NAPI_HAS_CONSTEXPR)
-      napi_typedarray_type type = TypedArray::TypedArrayTypeForPrimitiveType<T>()
+       napi_typedarray_type type =
+           TypedArray::TypedArrayTypeForPrimitiveType<T>()
 #else
-      napi_typedarray_type type
+       napi_typedarray_type type
 #endif
-        ///< Type of array, if different from the default array type for the template parameter T.
-    );
+       ///< Type of array, if different from the default array type for the
+       ///< template parameter T.
+   );
 
     /// Creates a new TypedArray instance over a provided array buffer.
     ///
@@ -860,21 +1211,26 @@ namespace Napi {
     /// parameter T), except when creating a "clamped" array:
     ///
     ///     Uint8Array::New(env, length, buffer, 0, napi_uint8_clamped_array)
-    static TypedArrayOf New(
-      napi_env env,                  ///< N-API environment
-      size_t elementLength,          ///< Length of the created array, as a number of elements
-      Napi::ArrayBuffer arrayBuffer, ///< Backing array buffer instance to use
-      size_t bufferOffset,           ///< Offset into the array buffer where the typed-array starts
+   static TypedArrayOf New(
+       napi_env env,          ///< Node-API environment
+       size_t elementLength,  ///< Length of the created array, as a number of
+                              ///< elements
+       Napi::ArrayBuffer arrayBuffer,  ///< Backing array buffer instance to use
+       size_t bufferOffset,  ///< Offset into the array buffer where the
+                             ///< typed-array starts
 #if defined(NAPI_HAS_CONSTEXPR)
-      napi_typedarray_type type = TypedArray::TypedArrayTypeForPrimitiveType<T>()
+       napi_typedarray_type type =
+           TypedArray::TypedArrayTypeForPrimitiveType<T>()
 #else
-      napi_typedarray_type type
+       napi_typedarray_type type
 #endif
-        ///< Type of array, if different from the default array type for the template parameter T.
-    );
+       ///< Type of array, if different from the default array type for the
+       ///< template parameter T.
+   );
 
     TypedArrayOf();                               ///< Creates a new _empty_ TypedArrayOf instance.
-    TypedArrayOf(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
+    TypedArrayOf(napi_env env,
+                 napi_value value);  ///< Wraps a Node-API value primitive.
 
     T& operator [](size_t index);             ///< Gets or sets an element in the array.
     const T& operator [](size_t index) const; ///< Gets an element in the array.
@@ -916,7 +1272,8 @@ namespace Napi {
                         size_t byteLength);
 
     DataView();                               ///< Creates a new _empty_ DataView instance.
-    DataView(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
+    DataView(napi_env env,
+             napi_value value);  ///< Wraps a Node-API value primitive.
 
     Napi::ArrayBuffer ArrayBuffer() const;    ///< Gets the backing array buffer.
     size_t ByteOffset() const;    ///< Gets the offset into the buffer where the array starts.
@@ -955,47 +1312,81 @@ namespace Napi {
 
   class Function : public Object {
   public:
-    /// Callable must implement operator() accepting a const CallbackInfo&
-    /// and return either void or Value.
-    template <typename Callable>
-    static Function New(napi_env env,
-                        Callable cb,
-                        const char* utf8name = nullptr,
-                        void* data = nullptr);
-    /// Callable must implement operator() accepting a const CallbackInfo&
-    /// and return either void or Value.
-    template <typename Callable>
-    static Function New(napi_env env,
-                        Callable cb,
-                        const std::string& utf8name,
-                        void* data = nullptr);
-
-    Function();
-    Function(napi_env env, napi_value value);
-
-    Value operator ()(const std::initializer_list<napi_value>& args) const;
-
-    Value Call(const std::initializer_list<napi_value>& args) const;
-    Value Call(const std::vector<napi_value>& args) const;
-    Value Call(size_t argc, const napi_value* args) const;
-    Value Call(napi_value recv, const std::initializer_list<napi_value>& args) const;
-    Value Call(napi_value recv, const std::vector<napi_value>& args) const;
-    Value Call(napi_value recv, size_t argc, const napi_value* args) const;
-
-    Value MakeCallback(napi_value recv,
-                       const std::initializer_list<napi_value>& args,
-                       napi_async_context context = nullptr) const;
-    Value MakeCallback(napi_value recv,
-                       const std::vector<napi_value>& args,
-                       napi_async_context context = nullptr) const;
-    Value MakeCallback(napi_value recv,
-                       size_t argc,
-                       const napi_value* args,
-                       napi_async_context context = nullptr) const;
-
-    Object New(const std::initializer_list<napi_value>& args) const;
-    Object New(const std::vector<napi_value>& args) const;
-    Object New(size_t argc, const napi_value* args) const;
+   using VoidCallback = void (*)(const CallbackInfo& info);
+   using Callback = Value (*)(const CallbackInfo& info);
+
+   template <VoidCallback cb>
+   static Function New(napi_env env,
+                       const char* utf8name = nullptr,
+                       void* data = nullptr);
+
+   template <Callback cb>
+   static Function New(napi_env env,
+                       const char* utf8name = nullptr,
+                       void* data = nullptr);
+
+   template <VoidCallback cb>
+   static Function New(napi_env env,
+                       const std::string& utf8name,
+                       void* data = nullptr);
+
+   template <Callback cb>
+   static Function New(napi_env env,
+                       const std::string& utf8name,
+                       void* data = nullptr);
+
+   /// Callable must implement operator() accepting a const CallbackInfo&
+   /// and return either void or Value.
+   template <typename Callable>
+   static Function New(napi_env env,
+                       Callable cb,
+                       const char* utf8name = nullptr,
+                       void* data = nullptr);
+   /// Callable must implement operator() accepting a const CallbackInfo&
+   /// and return either void or Value.
+   template <typename Callable>
+   static Function New(napi_env env,
+                       Callable cb,
+                       const std::string& utf8name,
+                       void* data = nullptr);
+
+   Function();
+   Function(napi_env env, napi_value value);
+
+   MaybeOrValue<Value> operator()(
+       const std::initializer_list<napi_value>& args) const;
+
+   MaybeOrValue<Value> Call(
+       const std::initializer_list<napi_value>& args) const;
+   MaybeOrValue<Value> Call(const std::vector<napi_value>& args) const;
+   MaybeOrValue<Value> Call(const std::vector<Value>& args) const;
+   MaybeOrValue<Value> Call(size_t argc, const napi_value* args) const;
+   MaybeOrValue<Value> Call(
+       napi_value recv, const std::initializer_list<napi_value>& args) const;
+   MaybeOrValue<Value> Call(napi_value recv,
+                            const std::vector<napi_value>& args) const;
+   MaybeOrValue<Value> Call(napi_value recv,
+                            const std::vector<Value>& args) const;
+   MaybeOrValue<Value> Call(napi_value recv,
+                            size_t argc,
+                            const napi_value* args) const;
+
+   MaybeOrValue<Value> MakeCallback(
+       napi_value recv,
+       const std::initializer_list<napi_value>& args,
+       napi_async_context context = nullptr) const;
+   MaybeOrValue<Value> MakeCallback(napi_value recv,
+                                    const std::vector<napi_value>& args,
+                                    napi_async_context context = nullptr) const;
+   MaybeOrValue<Value> MakeCallback(napi_value recv,
+                                    size_t argc,
+                                    const napi_value* args,
+                                    napi_async_context context = nullptr) const;
+
+   MaybeOrValue<Object> New(
+       const std::initializer_list<napi_value>& args) const;
+   MaybeOrValue<Object> New(const std::vector<napi_value>& args) const;
+   MaybeOrValue<Object> New(size_t argc, const napi_value* args) const;
   };
 
   class Promise : public Object {
@@ -1070,7 +1461,7 @@ namespace Napi {
     // A reference can be moved but cannot be copied.
     Reference(Reference<T>&& other);
     Reference<T>& operator =(Reference<T>&& other);
-    Reference<T>& operator =(Reference<T>&) = delete;
+    NAPI_DISALLOW_ASSIGN(Reference<T>)
 
     operator napi_ref() const;
     bool operator ==(const Reference<T> &other) const;
@@ -1083,14 +1474,16 @@ namespace Napi {
     // within a HandleScope so that the value handle gets cleaned up efficiently.
     T Value() const;
 
-    uint32_t Ref();
-    uint32_t Unref();
+    uint32_t Ref() const;
+    uint32_t Unref() const;
     void Reset();
     void Reset(const T& value, uint32_t refcount = 0);
 
-    // Call this on a reference that is declared as static data, to prevent its destructor
-    // from running at program shutdown time, which would attempt to reset the reference when
-    // the environment is no longer valid.
+    // Call this on a reference that is declared as static data, to prevent its
+    // destructor from running at program shutdown time, which would attempt to
+    // reset the reference when the environment is no longer valid. Avoid using
+    // this if at all possible. If you do need to use static data, MAKE SURE to
+    // warn your users that your addon is NOT threadsafe.
     void SuppressDestruct();
 
   protected:
@@ -1115,30 +1508,33 @@ namespace Napi {
     ObjectReference& operator =(Reference<Object>&& other);
     ObjectReference(ObjectReference&& other);
     ObjectReference& operator =(ObjectReference&& other);
-    ObjectReference& operator =(ObjectReference&) = delete;
-
-    Napi::Value Get(const char* utf8name) const;
-    Napi::Value Get(const std::string& utf8name) const;
-    void Set(const char* utf8name, napi_value value);
-    void Set(const char* utf8name, Napi::Value value);
-    void Set(const char* utf8name, const char* utf8value);
-    void Set(const char* utf8name, bool boolValue);
-    void Set(const char* utf8name, double numberValue);
-    void Set(const std::string& utf8name, napi_value value);
-    void Set(const std::string& utf8name, Napi::Value value);
-    void Set(const std::string& utf8name, std::string& utf8value);
-    void Set(const std::string& utf8name, bool boolValue);
-    void Set(const std::string& utf8name, double numberValue);
-
-    Napi::Value Get(uint32_t index) const;
-    void Set(uint32_t index, const napi_value value);
-    void Set(uint32_t index, const Napi::Value value);
-    void Set(uint32_t index, const char* utf8value);
-    void Set(uint32_t index, const std::string& utf8value);
-    void Set(uint32_t index, bool boolValue);
-    void Set(uint32_t index, double numberValue);
-
-  protected:
+    NAPI_DISALLOW_ASSIGN(ObjectReference)
+
+    MaybeOrValue<Napi::Value> Get(const char* utf8name) const;
+    MaybeOrValue<Napi::Value> Get(const std::string& utf8name) const;
+    MaybeOrValue<bool> Set(const char* utf8name, napi_value value) const;
+    MaybeOrValue<bool> Set(const char* utf8name, Napi::Value value) const;
+    MaybeOrValue<bool> Set(const char* utf8name, const char* utf8value) const;
+    MaybeOrValue<bool> Set(const char* utf8name, bool boolValue) const;
+    MaybeOrValue<bool> Set(const char* utf8name, double numberValue) const;
+    MaybeOrValue<bool> Set(const std::string& utf8name, napi_value value) const;
+    MaybeOrValue<bool> Set(const std::string& utf8name,
+                           Napi::Value value) const;
+    MaybeOrValue<bool> Set(const std::string& utf8name,
+                           std::string& utf8value) const;
+    MaybeOrValue<bool> Set(const std::string& utf8name, bool boolValue) const;
+    MaybeOrValue<bool> Set(const std::string& utf8name,
+                           double numberValue) const;
+
+    MaybeOrValue<Napi::Value> Get(uint32_t index) const;
+    MaybeOrValue<bool> Set(uint32_t index, const napi_value value) const;
+    MaybeOrValue<bool> Set(uint32_t index, const Napi::Value value) const;
+    MaybeOrValue<bool> Set(uint32_t index, const char* utf8value) const;
+    MaybeOrValue<bool> Set(uint32_t index, const std::string& utf8value) const;
+    MaybeOrValue<bool> Set(uint32_t index, bool boolValue) const;
+    MaybeOrValue<bool> Set(uint32_t index, double numberValue) const;
+
+   protected:
     ObjectReference(const ObjectReference&);
   };
 
@@ -1152,30 +1548,39 @@ namespace Napi {
     FunctionReference& operator =(Reference<Function>&& other);
     FunctionReference(FunctionReference&& other);
     FunctionReference& operator =(FunctionReference&& other);
-    FunctionReference(const FunctionReference&) = delete;
-    FunctionReference& operator =(FunctionReference&) = delete;
-
-    Napi::Value operator ()(const std::initializer_list<napi_value>& args) const;
-
-    Napi::Value Call(const std::initializer_list<napi_value>& args) const;
-    Napi::Value Call(const std::vector<napi_value>& args) const;
-    Napi::Value Call(napi_value recv, const std::initializer_list<napi_value>& args) const;
-    Napi::Value Call(napi_value recv, const std::vector<napi_value>& args) const;
-    Napi::Value Call(napi_value recv, size_t argc, const napi_value* args) const;
-
-    Napi::Value MakeCallback(napi_value recv,
-                             const std::initializer_list<napi_value>& args,
-                             napi_async_context context = nullptr) const;
-    Napi::Value MakeCallback(napi_value recv,
-                             const std::vector<napi_value>& args,
-                             napi_async_context context = nullptr) const;
-    Napi::Value MakeCallback(napi_value recv,
-                             size_t argc,
-                             const napi_value* args,
-                             napi_async_context context = nullptr) const;
-
-    Object New(const std::initializer_list<napi_value>& args) const;
-    Object New(const std::vector<napi_value>& args) const;
+    NAPI_DISALLOW_ASSIGN_COPY(FunctionReference)
+
+    MaybeOrValue<Napi::Value> operator()(
+        const std::initializer_list<napi_value>& args) const;
+
+    MaybeOrValue<Napi::Value> Call(
+        const std::initializer_list<napi_value>& args) const;
+    MaybeOrValue<Napi::Value> Call(const std::vector<napi_value>& args) const;
+    MaybeOrValue<Napi::Value> Call(
+        napi_value recv, const std::initializer_list<napi_value>& args) const;
+    MaybeOrValue<Napi::Value> Call(napi_value recv,
+                                   const std::vector<napi_value>& args) const;
+    MaybeOrValue<Napi::Value> Call(napi_value recv,
+                                   size_t argc,
+                                   const napi_value* args) const;
+
+    MaybeOrValue<Napi::Value> MakeCallback(
+        napi_value recv,
+        const std::initializer_list<napi_value>& args,
+        napi_async_context context = nullptr) const;
+    MaybeOrValue<Napi::Value> MakeCallback(
+        napi_value recv,
+        const std::vector<napi_value>& args,
+        napi_async_context context = nullptr) const;
+    MaybeOrValue<Napi::Value> MakeCallback(
+        napi_value recv,
+        size_t argc,
+        const napi_value* args,
+        napi_async_context context = nullptr) const;
+
+    MaybeOrValue<Object> New(
+        const std::initializer_list<napi_value>& args) const;
+    MaybeOrValue<Object> New(const std::vector<napi_value>& args) const;
   };
 
   // Shortcuts to creating a new reference with inferred type and refcount = 0.
@@ -1188,43 +1593,48 @@ namespace Napi {
   ObjectReference Persistent(Object value);
   FunctionReference Persistent(Function value);
 
-  /// A persistent reference to a JavaScript error object. Use of this class depends somewhat
-  /// on whether C++ exceptions are enabled at compile time.
+  /// A persistent reference to a JavaScript error object. Use of this class
+  /// depends somewhat on whether C++ exceptions are enabled at compile time.
   ///
   /// ### Handling Errors With C++ Exceptions
   ///
-  /// If C++ exceptions are enabled, then the `Error` class extends `std::exception` and enables
-  /// integrated error-handling for C++ exceptions and JavaScript exceptions.
+  /// If C++ exceptions are enabled, then the `Error` class extends
+  /// `std::exception` and enables integrated error-handling for C++ exceptions
+  /// and JavaScript exceptions.
   ///
-  /// If a N-API call fails without executing any JavaScript code (for example due to an invalid
-  /// argument), then the N-API wrapper automatically converts and throws the error as a C++
-  /// exception of type `Napi::Error`. Or if a JavaScript function called by C++ code via N-API
-  /// throws a JavaScript exception, then the N-API wrapper automatically converts and throws it as
-  /// a C++ exception of type `Napi::Error`.
+  /// If a Node-API call fails without executing any JavaScript code (for
+  /// example due to an invalid argument), then the Node-API wrapper
+  /// automatically converts and throws the error as a C++ exception of type
+  /// `Napi::Error`. Or if a JavaScript function called by C++ code via Node-API
+  /// throws a JavaScript exception, then the Node-API wrapper automatically
+  /// converts and throws it as a C++ exception of type `Napi::Error`.
   ///
-  /// If a C++ exception of type `Napi::Error` escapes from a N-API C++ callback, then the N-API
-  /// wrapper automatically converts and throws it as a JavaScript exception. Therefore, catching
-  /// a C++ exception of type `Napi::Error` prevents a JavaScript exception from being thrown.
+  /// If a C++ exception of type `Napi::Error` escapes from a Node-API C++
+  /// callback, then the Node-API wrapper automatically converts and throws it
+  /// as a JavaScript exception. Therefore, catching a C++ exception of type
+  /// `Napi::Error` prevents a JavaScript exception from being thrown.
   ///
   /// #### Example 1A - Throwing a C++ exception:
   ///
   ///     Napi::Env env = ...
   ///     throw Napi::Error::New(env, "Example exception");
   ///
-  /// Following C++ statements will not be executed. The exception will bubble up as a C++
-  /// exception of type `Napi::Error`, until it is either caught while still in C++, or else
-  /// automatically propataged as a JavaScript exception when the callback returns to JavaScript.
+  /// Following C++ statements will not be executed. The exception will bubble
+  /// up as a C++ exception of type `Napi::Error`, until it is either caught
+  /// while still in C++, or else automatically propataged as a JavaScript
+  /// exception when the callback returns to JavaScript.
   ///
-  /// #### Example 2A - Propagating a N-API C++ exception:
+  /// #### Example 2A - Propagating a Node-API C++ exception:
   ///
   ///     Napi::Function jsFunctionThatThrows = someObj.As<Napi::Function>();
   ///     Napi::Value result = jsFunctionThatThrows({ arg1, arg2 });
   ///
-  /// Following C++ statements will not be executed. The exception will bubble up as a C++
-  /// exception of type `Napi::Error`, until it is either caught while still in C++, or else
-  /// automatically propagated as a JavaScript exception when the callback returns to JavaScript.
+  /// Following C++ statements will not be executed. The exception will bubble
+  /// up as a C++ exception of type `Napi::Error`, until it is either caught
+  /// while still in C++, or else automatically propagated as a JavaScript
+  /// exception when the callback returns to JavaScript.
   ///
-  /// #### Example 3A - Handling a N-API C++ exception:
+  /// #### Example 3A - Handling a Node-API C++ exception:
   ///
   ///     Napi::Function jsFunctionThatThrows = someObj.As<Napi::Function>();
   ///     Napi::Value result;
@@ -1234,38 +1644,42 @@ namespace Napi {
   ///       cerr << "Caught JavaScript exception: " + e.what();
   ///     }
   ///
-  /// Since the exception was caught here, it will not be propagated as a JavaScript exception.
+  /// Since the exception was caught here, it will not be propagated as a
+  /// JavaScript exception.
   ///
   /// ### Handling Errors Without C++ Exceptions
   ///
-  /// If C++ exceptions are disabled (by defining `NAPI_DISABLE_CPP_EXCEPTIONS`) then this class
-  /// does not extend `std::exception`, and APIs in the `Napi` namespace do not throw C++
-  /// exceptions when they fail. Instead, they raise _pending_ JavaScript exceptions and
-  /// return _empty_ `Value`s. Calling code should check `Value::IsEmpty()` before attempting
-  /// to use a returned value, and may use methods on the `Env` class to check for, get, and
-  /// clear a pending JavaScript exception. If the pending exception is not cleared, it will
-  /// be thrown when the native callback returns to JavaScript.
+  /// If C++ exceptions are disabled (by defining `NAPI_DISABLE_CPP_EXCEPTIONS`)
+  /// then this class does not extend `std::exception`, and APIs in the `Napi`
+  /// namespace do not throw C++ exceptions when they fail. Instead, they raise
+  /// _pending_ JavaScript exceptions and return _empty_ `Value`s. Calling code
+  /// should check `Value::IsEmpty()` before attempting to use a returned value,
+  /// and may use methods on the `Env` class to check for, get, and clear a
+  /// pending JavaScript exception. If the pending exception is not cleared, it
+  /// will be thrown when the native callback returns to JavaScript.
   ///
   /// #### Example 1B - Throwing a JS exception
   ///
   ///     Napi::Env env = ...
-  ///     Napi::Error::New(env, "Example exception").ThrowAsJavaScriptException();
-  ///     return;
+  ///     Napi::Error::New(env, "Example
+  ///     exception").ThrowAsJavaScriptException(); return;
   ///
-  /// After throwing a JS exception, the code should generally return immediately from the native
-  /// callback, after performing any necessary cleanup.
+  /// After throwing a JS exception, the code should generally return
+  /// immediately from the native callback, after performing any necessary
+  /// cleanup.
   ///
-  /// #### Example 2B - Propagating a N-API JS exception:
+  /// #### Example 2B - Propagating a Node-API JS exception:
   ///
   ///     Napi::Function jsFunctionThatThrows = someObj.As<Napi::Function>();
   ///     Napi::Value result = jsFunctionThatThrows({ arg1, arg2 });
   ///     if (result.IsEmpty()) return;
   ///
-  /// An empty value result from a N-API call indicates an error occurred, and a JavaScript
-  /// exception is pending. To let the exception propagate, the code should generally return
-  /// immediately from the native callback, after performing any necessary cleanup.
+  /// An empty value result from a Node-API call indicates an error occurred,
+  /// and a JavaScript exception is pending. To let the exception propagate, the
+  /// code should generally return immediately from the native callback, after
+  /// performing any necessary cleanup.
   ///
-  /// #### Example 3B - Handling a N-API JS exception:
+  /// #### Example 3B - Handling a Node-API JS exception:
   ///
   ///     Napi::Function jsFunctionThatThrows = someObj.As<Napi::Function>();
   ///     Napi::Value result = jsFunctionThatThrows({ arg1, arg2 });
@@ -1274,8 +1688,8 @@ namespace Napi {
   ///       cerr << "Caught JavaScript exception: " + e.Message();
   ///     }
   ///
-  /// Since the exception was cleared here, it will not be propagated as a JavaScript exception
-  /// after the native callback returns.
+  /// Since the exception was cleared here, it will not be propagated as a
+  /// JavaScript exception after the native callback returns.
   class Error : public ObjectReference
 #ifdef NAPI_CPP_EXCEPTIONS
     , public std::exception
@@ -1295,28 +1709,34 @@ namespace Napi {
     Error(Error&& other);
     Error& operator =(Error&& other);
     Error(const Error&);
-    Error& operator =(Error&);
+    Error& operator =(const Error&);
 
     const std::string& Message() const NAPI_NOEXCEPT;
     void ThrowAsJavaScriptException() const;
 
+    Object Value() const;
+
 #ifdef NAPI_CPP_EXCEPTIONS
     const char* what() const NAPI_NOEXCEPT override;
 #endif // NAPI_CPP_EXCEPTIONS
 
   protected:
     /// !cond INTERNAL
-    typedef napi_status (*create_error_fn)(napi_env envb, napi_value code, napi_value msg, napi_value* result);
-
-    template <typename TError>
-    static TError New(napi_env env,
-                      const char* message,
-                      size_t length,
-                      create_error_fn create_error);
-    /// !endcond
+   using create_error_fn = napi_status (*)(napi_env envb,
+                                           napi_value code,
+                                           napi_value msg,
+                                           napi_value* result);
+
+   template <typename TError>
+   static TError New(napi_env env,
+                     const char* message,
+                     size_t length,
+                     create_error_fn create_error);
+   /// !endcond
 
   private:
-    mutable std::string _message;
+   static inline const char* ERROR_WRAP_VALUE() NAPI_NOEXCEPT;
+   mutable std::string _message;
   };
 
   class TypeError : public Error {
@@ -1343,8 +1763,7 @@ namespace Napi {
     ~CallbackInfo();
 
     // Disallow copying to prevent multiple free of _dynamicArgs
-    CallbackInfo(CallbackInfo const &) = delete;
-    void operator=(CallbackInfo const &) = delete;
+    NAPI_DISALLOW_ASSIGN_COPY(CallbackInfo)
 
     Napi::Env Env() const;
     Value NewTarget() const;
@@ -1369,6 +1788,9 @@ namespace Napi {
 
   class PropertyDescriptor {
   public:
+   using GetterCallback = Napi::Value (*)(const Napi::CallbackInfo& info);
+   using SetterCallback = void (*)(const Napi::CallbackInfo& info);
+
 #ifndef NODE_ADDON_API_DISABLE_DEPRECATED
     template <typename Getter>
     static PropertyDescriptor Accessor(const char* utf8name,
@@ -1436,6 +1858,36 @@ namespace Napi {
                                        void* data = nullptr);
 #endif // !NODE_ADDON_API_DISABLE_DEPRECATED
 
+    template <GetterCallback Getter>
+    static PropertyDescriptor Accessor(const char* utf8name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
+    template <GetterCallback Getter>
+    static PropertyDescriptor Accessor(const std::string& utf8name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
+    template <GetterCallback Getter>
+    static PropertyDescriptor Accessor(Name name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
+    template <GetterCallback Getter, SetterCallback Setter>
+    static PropertyDescriptor Accessor(const char* utf8name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
+    template <GetterCallback Getter, SetterCallback Setter>
+    static PropertyDescriptor Accessor(const std::string& utf8name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
+    template <GetterCallback Getter, SetterCallback Setter>
+    static PropertyDescriptor Accessor(Name name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
     template <typename Getter>
     static PropertyDescriptor Accessor(Napi::Env env,
                                        Napi::Object object,
@@ -1541,6 +1993,120 @@ namespace Napi {
     napi_property_descriptor _desc;
   };
 
+  template <typename T, typename TCallback>
+  struct MethodCallbackData {
+    TCallback callback;
+    void* data;
+  };
+
+  template <typename T, typename TGetterCallback, typename TSetterCallback>
+  struct AccessorCallbackData {
+    TGetterCallback getterCallback;
+    TSetterCallback setterCallback;
+    void* data;
+  };
+
+  template <typename T>
+  class InstanceWrap {
+   public:
+    using InstanceVoidMethodCallback = void (T::*)(const CallbackInfo& info);
+    using InstanceMethodCallback = Napi::Value (T::*)(const CallbackInfo& info);
+    using InstanceGetterCallback = Napi::Value (T::*)(const CallbackInfo& info);
+    using InstanceSetterCallback = void (T::*)(const CallbackInfo& info,
+                                               const Napi::Value& value);
+
+    using PropertyDescriptor = ClassPropertyDescriptor<T>;
+
+    static PropertyDescriptor InstanceMethod(const char* utf8name,
+                                             InstanceVoidMethodCallback method,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    static PropertyDescriptor InstanceMethod(const char* utf8name,
+                                             InstanceMethodCallback method,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    static PropertyDescriptor InstanceMethod(Symbol name,
+                                             InstanceVoidMethodCallback method,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    static PropertyDescriptor InstanceMethod(Symbol name,
+                                             InstanceMethodCallback method,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    template <InstanceVoidMethodCallback method>
+    static PropertyDescriptor InstanceMethod(const char* utf8name,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    template <InstanceMethodCallback method>
+    static PropertyDescriptor InstanceMethod(const char* utf8name,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    template <InstanceVoidMethodCallback method>
+    static PropertyDescriptor InstanceMethod(Symbol name,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    template <InstanceMethodCallback method>
+    static PropertyDescriptor InstanceMethod(Symbol name,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    static PropertyDescriptor InstanceAccessor(const char* utf8name,
+                                               InstanceGetterCallback getter,
+                                               InstanceSetterCallback setter,
+                                               napi_property_attributes attributes = napi_default,
+                                               void* data = nullptr);
+    static PropertyDescriptor InstanceAccessor(Symbol name,
+                                               InstanceGetterCallback getter,
+                                               InstanceSetterCallback setter,
+                                               napi_property_attributes attributes = napi_default,
+                                               void* data = nullptr);
+    template <InstanceGetterCallback getter, InstanceSetterCallback setter=nullptr>
+    static PropertyDescriptor InstanceAccessor(const char* utf8name,
+                                               napi_property_attributes attributes = napi_default,
+                                               void* data = nullptr);
+    template <InstanceGetterCallback getter, InstanceSetterCallback setter=nullptr>
+    static PropertyDescriptor InstanceAccessor(Symbol name,
+                                               napi_property_attributes attributes = napi_default,
+                                               void* data = nullptr);
+    static PropertyDescriptor InstanceValue(const char* utf8name,
+                                            Napi::Value value,
+                                            napi_property_attributes attributes = napi_default);
+    static PropertyDescriptor InstanceValue(Symbol name,
+                                            Napi::Value value,
+                                            napi_property_attributes attributes = napi_default);
+
+   protected:
+    static void AttachPropData(napi_env env, napi_value value, const napi_property_descriptor* prop);
+
+   private:
+    using This = InstanceWrap<T>;
+
+    using InstanceVoidMethodCallbackData =
+        MethodCallbackData<T, InstanceVoidMethodCallback>;
+    using InstanceMethodCallbackData =
+        MethodCallbackData<T, InstanceMethodCallback>;
+    using InstanceAccessorCallbackData =
+        AccessorCallbackData<T, InstanceGetterCallback, InstanceSetterCallback>;
+
+    static napi_value InstanceVoidMethodCallbackWrapper(napi_env env, napi_callback_info info);
+    static napi_value InstanceMethodCallbackWrapper(napi_env env, napi_callback_info info);
+    static napi_value InstanceGetterCallbackWrapper(napi_env env, napi_callback_info info);
+    static napi_value InstanceSetterCallbackWrapper(napi_env env, napi_callback_info info);
+
+    template <InstanceSetterCallback method>
+    static napi_value WrappedMethod(napi_env env,
+                                    napi_callback_info info) NAPI_NOEXCEPT;
+
+    template <InstanceSetterCallback setter> struct SetterTag {};
+
+    template <InstanceSetterCallback setter>
+    static napi_callback WrapSetter(SetterTag<setter>) NAPI_NOEXCEPT {
+      return &This::WrappedMethod<setter>;
+    }
+    static napi_callback WrapSetter(SetterTag<nullptr>) NAPI_NOEXCEPT {
+      return nullptr;
+    }
+  };
+
   /// Base class to be extended by C++ classes exposed to JavaScript; each C++ class instance gets
   /// "wrapped" by a JavaScript object that is managed by this class.
   ///
@@ -1555,8 +2121,8 @@ namespace Napi {
   ///       public:
   ///         static void Initialize(Napi::Env& env, Napi::Object& target) {
   ///           Napi::Function constructor = DefineClass(env, "Example", {
-  ///             InstanceAccessor("value", &Example::GetSomething, &Example::SetSomething),
-  ///             InstanceMethod("doSomething", &Example::DoSomething),
+  ///             InstanceAccessor<&Example::GetSomething, &Example::SetSomething>("value"),
+  ///             InstanceMethod<&Example::DoSomething>("doSomething"),
   ///           });
   ///           target.Set("Example", constructor);
   ///         }
@@ -1567,23 +2133,21 @@ namespace Napi {
   ///         Napi::Value DoSomething(const Napi::CallbackInfo& info);
   ///     }
   template <typename T>
-  class ObjectWrap : public Reference<Object> {
+  class ObjectWrap : public InstanceWrap<T>, public Reference<Object> {
   public:
     ObjectWrap(const CallbackInfo& callbackInfo);
+    virtual ~ObjectWrap();
 
     static T* Unwrap(Object wrapper);
 
     // Methods exposed to JavaScript must conform to one of these callback signatures.
-    typedef void (*StaticVoidMethodCallback)(const CallbackInfo& info);
-    typedef Napi::Value (*StaticMethodCallback)(const CallbackInfo& info);
-    typedef Napi::Value (*StaticGetterCallback)(const CallbackInfo& info);
-    typedef void (*StaticSetterCallback)(const CallbackInfo& info, const Napi::Value& value);
-    typedef void (T::*InstanceVoidMethodCallback)(const CallbackInfo& info);
-    typedef Napi::Value (T::*InstanceMethodCallback)(const CallbackInfo& info);
-    typedef Napi::Value (T::*InstanceGetterCallback)(const CallbackInfo& info);
-    typedef void (T::*InstanceSetterCallback)(const CallbackInfo& info, const Napi::Value& value);
+    using StaticVoidMethodCallback = void (*)(const CallbackInfo& info);
+    using StaticMethodCallback = Napi::Value (*)(const CallbackInfo& info);
+    using StaticGetterCallback = Napi::Value (*)(const CallbackInfo& info);
+    using StaticSetterCallback = void (*)(const CallbackInfo& info,
+                                          const Napi::Value& value);
 
-    typedef ClassPropertyDescriptor<T> PropertyDescriptor;
+    using PropertyDescriptor = ClassPropertyDescriptor<T>;
 
     static Function DefineClass(Napi::Env env,
                                 const char* utf8name,
@@ -1609,6 +2173,22 @@ namespace Napi {
                                            StaticMethodCallback method,
                                            napi_property_attributes attributes = napi_default,
                                            void* data = nullptr);
+    template <StaticVoidMethodCallback method>
+    static PropertyDescriptor StaticMethod(const char* utf8name,
+                                           napi_property_attributes attributes = napi_default,
+                                           void* data = nullptr);
+    template <StaticVoidMethodCallback method>
+    static PropertyDescriptor StaticMethod(Symbol name,
+                                           napi_property_attributes attributes = napi_default,
+                                           void* data = nullptr);
+    template <StaticMethodCallback method>
+    static PropertyDescriptor StaticMethod(const char* utf8name,
+                                           napi_property_attributes attributes = napi_default,
+                                           void* data = nullptr);
+    template <StaticMethodCallback method>
+    static PropertyDescriptor StaticMethod(Symbol name,
+                                           napi_property_attributes attributes = napi_default,
+                                           void* data = nullptr);
     static PropertyDescriptor StaticAccessor(const char* utf8name,
                                              StaticGetterCallback getter,
                                              StaticSetterCallback setter,
@@ -1619,55 +2199,32 @@ namespace Napi {
                                              StaticSetterCallback setter,
                                              napi_property_attributes attributes = napi_default,
                                              void* data = nullptr);
-    static PropertyDescriptor InstanceMethod(const char* utf8name,
-                                             InstanceVoidMethodCallback method,
-                                             napi_property_attributes attributes = napi_default,
-                                             void* data = nullptr);
-    static PropertyDescriptor InstanceMethod(const char* utf8name,
-                                             InstanceMethodCallback method,
-                                             napi_property_attributes attributes = napi_default,
-                                             void* data = nullptr);
-    static PropertyDescriptor InstanceMethod(Symbol name,
-                                             InstanceVoidMethodCallback method,
+    template <StaticGetterCallback getter, StaticSetterCallback setter=nullptr>
+    static PropertyDescriptor StaticAccessor(const char* utf8name,
                                              napi_property_attributes attributes = napi_default,
                                              void* data = nullptr);
-    static PropertyDescriptor InstanceMethod(Symbol name,
-                                             InstanceMethodCallback method,
+    template <StaticGetterCallback getter, StaticSetterCallback setter=nullptr>
+    static PropertyDescriptor StaticAccessor(Symbol name,
                                              napi_property_attributes attributes = napi_default,
                                              void* data = nullptr);
-    static PropertyDescriptor InstanceAccessor(const char* utf8name,
-                                               InstanceGetterCallback getter,
-                                               InstanceSetterCallback setter,
-                                               napi_property_attributes attributes = napi_default,
-                                               void* data = nullptr);
-    static PropertyDescriptor InstanceAccessor(Symbol name,
-                                               InstanceGetterCallback getter,
-                                               InstanceSetterCallback setter,
-                                               napi_property_attributes attributes = napi_default,
-                                               void* data = nullptr);
     static PropertyDescriptor StaticValue(const char* utf8name,
                                           Napi::Value value,
                                           napi_property_attributes attributes = napi_default);
     static PropertyDescriptor StaticValue(Symbol name,
                                           Napi::Value value,
                                           napi_property_attributes attributes = napi_default);
-    static PropertyDescriptor InstanceValue(const char* utf8name,
-                                            Napi::Value value,
-                                            napi_property_attributes attributes = napi_default);
-    static PropertyDescriptor InstanceValue(Symbol name,
-                                            Napi::Value value,
-                                            napi_property_attributes attributes = napi_default);
+    static Napi::Value OnCalledAsFunction(
+        const Napi::CallbackInfo& callbackInfo);
+    virtual void Finalize(Napi::Env env);
 
   private:
+    using This = ObjectWrap<T>;
+
     static napi_value ConstructorCallbackWrapper(napi_env env, napi_callback_info info);
     static napi_value StaticVoidMethodCallbackWrapper(napi_env env, napi_callback_info info);
     static napi_value StaticMethodCallbackWrapper(napi_env env, napi_callback_info info);
     static napi_value StaticGetterCallbackWrapper(napi_env env, napi_callback_info info);
     static napi_value StaticSetterCallbackWrapper(napi_env env, napi_callback_info info);
-    static napi_value InstanceVoidMethodCallbackWrapper(napi_env env, napi_callback_info info);
-    static napi_value InstanceMethodCallbackWrapper(napi_env env, napi_callback_info info);
-    static napi_value InstanceGetterCallbackWrapper(napi_env env, napi_callback_info info);
-    static napi_value InstanceSetterCallbackWrapper(napi_env env, napi_callback_info info);
     static void FinalizeCallback(napi_env env, void* data, void* hint);
     static Function DefineClass(Napi::Env env,
                                 const char* utf8name,
@@ -1675,26 +2232,31 @@ namespace Napi {
                                 const napi_property_descriptor* props,
                                 void* data = nullptr);
 
-    template <typename TCallback>
-    struct MethodCallbackData {
-      TCallback callback;
-      void* data;
-    };
-    typedef MethodCallbackData<StaticVoidMethodCallback> StaticVoidMethodCallbackData;
-    typedef MethodCallbackData<StaticMethodCallback> StaticMethodCallbackData;
-    typedef MethodCallbackData<InstanceVoidMethodCallback> InstanceVoidMethodCallbackData;
-    typedef MethodCallbackData<InstanceMethodCallback> InstanceMethodCallbackData;
-
-    template <typename TGetterCallback, typename TSetterCallback>
-    struct AccessorCallbackData {
-      TGetterCallback getterCallback;
-      TSetterCallback setterCallback;
-      void* data;
-    };
-    typedef AccessorCallbackData<StaticGetterCallback, StaticSetterCallback>
-      StaticAccessorCallbackData;
-    typedef AccessorCallbackData<InstanceGetterCallback, InstanceSetterCallback>
-      InstanceAccessorCallbackData;
+    using StaticVoidMethodCallbackData =
+        MethodCallbackData<T, StaticVoidMethodCallback>;
+    using StaticMethodCallbackData =
+        MethodCallbackData<T, StaticMethodCallback>;
+
+    using StaticAccessorCallbackData =
+        AccessorCallbackData<T, StaticGetterCallback, StaticSetterCallback>;
+
+    template <StaticSetterCallback method>
+    static napi_value WrappedMethod(napi_env env,
+                                    napi_callback_info info) NAPI_NOEXCEPT;
+
+    template <StaticSetterCallback setter> struct StaticSetterTag {};
+
+    template <StaticSetterCallback setter>
+    static napi_callback WrapStaticSetter(StaticSetterTag<setter>)
+        NAPI_NOEXCEPT {
+      return &This::WrappedMethod<setter>;
+    }
+    static napi_callback WrapStaticSetter(StaticSetterTag<nullptr>)
+        NAPI_NOEXCEPT {
+      return nullptr;
+    }
+
+    bool _construction_failed = true;
   };
 
   class HandleScope {
@@ -1703,6 +2265,9 @@ namespace Napi {
     explicit HandleScope(Napi::Env env);
     ~HandleScope();
 
+    // Disallow copying to prevent double close of napi_handle_scope
+    NAPI_DISALLOW_ASSIGN_COPY(HandleScope)
+
     operator napi_handle_scope() const;
 
     Napi::Env Env() const;
@@ -1718,6 +2283,9 @@ namespace Napi {
     explicit EscapableHandleScope(Napi::Env env);
     ~EscapableHandleScope();
 
+    // Disallow copying to prevent double close of napi_escapable_handle_scope
+    NAPI_DISALLOW_ASSIGN_COPY(EscapableHandleScope)
+
     operator napi_escapable_handle_scope() const;
 
     Napi::Env Env() const;
@@ -1735,6 +2303,9 @@ namespace Napi {
     CallbackScope(napi_env env, napi_async_context context);
     virtual ~CallbackScope();
 
+    // Disallow copying to prevent double close of napi_callback_scope
+    NAPI_DISALLOW_ASSIGN_COPY(CallbackScope)
+
     operator napi_callback_scope() const;
 
     Napi::Env Env() const;
@@ -1753,11 +2324,12 @@ namespace Napi {
 
     AsyncContext(AsyncContext&& other);
     AsyncContext& operator =(AsyncContext&& other);
-    AsyncContext(const AsyncContext&) = delete;
-    AsyncContext& operator =(AsyncContext&) = delete;
+    NAPI_DISALLOW_ASSIGN_COPY(AsyncContext)
 
     operator napi_async_context() const;
 
+    Napi::Env Env() const;
+
   private:
     napi_env _env;
     napi_async_context _context;
@@ -1770,8 +2342,7 @@ namespace Napi {
     // An async worker can be moved but cannot be copied.
     AsyncWorker(AsyncWorker&& other);
     AsyncWorker& operator =(AsyncWorker&& other);
-    AsyncWorker(const AsyncWorker&) = delete;
-    AsyncWorker& operator =(AsyncWorker&) = delete;
+    NAPI_DISALLOW_ASSIGN_COPY(AsyncWorker)
 
     operator napi_async_work() const;
 
@@ -1784,6 +2355,10 @@ namespace Napi {
     ObjectReference& Receiver();
     FunctionReference& Callback();
 
+    virtual void OnExecute(Napi::Env env);
+    virtual void OnWorkComplete(Napi::Env env,
+                                napi_status status);
+
   protected:
     explicit AsyncWorker(const Function& callback);
     explicit AsyncWorker(const Function& callback,
@@ -1817,10 +2392,10 @@ namespace Napi {
     void SetError(const std::string& error);
 
   private:
-    static void OnExecute(napi_env env, void* this_pointer);
-    static void OnWorkComplete(napi_env env,
-                               napi_status status,
-                               void* this_pointer);
+    static inline void OnAsyncWorkExecute(napi_env env, void* asyncworker);
+    static inline void OnAsyncWorkComplete(napi_env env,
+                                           napi_status status,
+                                           void* asyncworker);
 
     napi_env _env;
     napi_async_work _work;
@@ -1830,7 +2405,7 @@ namespace Napi {
     bool _suppress_destruct;
   };
 
-  #if (NAPI_VERSION > 3)
+  #if (NAPI_VERSION > 3 && !defined(__wasm32__))
   class ThreadSafeFunction {
   public:
     // This API may only be called from the main thread.
@@ -1960,8 +2535,7 @@ namespace Napi {
     ThreadSafeFunction();
     ThreadSafeFunction(napi_threadsafe_function tsFunctionValue);
 
-    ThreadSafeFunction(ThreadSafeFunction&& other);
-    ThreadSafeFunction& operator=(ThreadSafeFunction&& other);
+    operator napi_threadsafe_function() const;
 
     // This API may be called from any thread.
     napi_status BlockingCall() const;
@@ -1985,14 +2559,20 @@ namespace Napi {
     template <typename DataType, typename Callback>
     napi_status NonBlockingCall(DataType* data, Callback callback) const;
 
+    // This API may only be called from the main thread.
+    void Ref(napi_env env) const;
+
+    // This API may only be called from the main thread.
+    void Unref(napi_env env) const;
+
     // This API may be called from any thread.
     napi_status Acquire() const;
 
     // This API may be called from any thread.
-    napi_status Release();
+    napi_status Release() const;
 
     // This API may be called from any thread.
-    napi_status Abort();
+    napi_status Abort() const;
 
     struct ConvertibleContext
     {
@@ -2028,9 +2608,356 @@ namespace Napi {
                        void* context,
                        void* data);
 
-    std::unique_ptr<napi_threadsafe_function> _tsfn;
+    napi_threadsafe_function _tsfn;
   };
-  #endif
+
+  // A TypedThreadSafeFunction by default has no context (nullptr) and can
+  // accept any type (void) to its CallJs.
+  template <typename ContextType = std::nullptr_t,
+            typename DataType = void,
+            void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*) =
+                nullptr>
+  class TypedThreadSafeFunction {
+   public:
+    // This API may only be called from the main thread.
+    // Helper function that returns nullptr if running Node-API 5+, otherwise a
+    // non-empty, no-op Function. This provides the ability to specify at
+    // compile-time a callback parameter to `New` that safely does no action
+    // when targeting _any_ Node-API version.
+#if NAPI_VERSION > 4
+    static std::nullptr_t EmptyFunctionFactory(Napi::Env env);
+#else
+    static Napi::Function EmptyFunctionFactory(Napi::Env env);
+#endif
+    static Napi::Function FunctionOrEmpty(Napi::Env env,
+                                          Napi::Function& callback);
+
+#if NAPI_VERSION > 4
+    // This API may only be called from the main thread.
+    // Creates a new threadsafe function with:
+    //   Callback [missing] Resource [missing] Finalizer [missing]
+    template <typename ResourceString>
+    static TypedThreadSafeFunction<ContextType, DataType, CallJs> New(
+        napi_env env,
+        ResourceString resourceName,
+        size_t maxQueueSize,
+        size_t initialThreadCount,
+        ContextType* context = nullptr);
+
+    // This API may only be called from the main thread.
+    // Creates a new threadsafe function with:
+    //   Callback [missing] Resource [passed] Finalizer [missing]
+    template <typename ResourceString>
+    static TypedThreadSafeFunction<ContextType, DataType, CallJs> New(
+        napi_env env,
+        const Object& resource,
+        ResourceString resourceName,
+        size_t maxQueueSize,
+        size_t initialThreadCount,
+        ContextType* context = nullptr);
+
+    // This API may only be called from the main thread.
+    // Creates a new threadsafe function with:
+    //   Callback [missing] Resource [missing] Finalizer [passed]
+    template <typename ResourceString,
+              typename Finalizer,
+              typename FinalizerDataType = void>
+    static TypedThreadSafeFunction<ContextType, DataType, CallJs> New(
+        napi_env env,
+        ResourceString resourceName,
+        size_t maxQueueSize,
+        size_t initialThreadCount,
+        ContextType* context,
+        Finalizer finalizeCallback,
+        FinalizerDataType* data = nullptr);
+
+    // This API may only be called from the main thread.
+    // Creates a new threadsafe function with:
+    //   Callback [missing] Resource [passed] Finalizer [passed]
+    template <typename ResourceString,
+              typename Finalizer,
+              typename FinalizerDataType = void>
+    static TypedThreadSafeFunction<ContextType, DataType, CallJs> New(
+        napi_env env,
+        const Object& resource,
+        ResourceString resourceName,
+        size_t maxQueueSize,
+        size_t initialThreadCount,
+        ContextType* context,
+        Finalizer finalizeCallback,
+        FinalizerDataType* data = nullptr);
+#endif
+
+    // This API may only be called from the main thread.
+    // Creates a new threadsafe function with:
+    //   Callback [passed] Resource [missing] Finalizer [missing]
+    template <typename ResourceString>
+    static TypedThreadSafeFunction<ContextType, DataType, CallJs> New(
+        napi_env env,
+        const Function& callback,
+        ResourceString resourceName,
+        size_t maxQueueSize,
+        size_t initialThreadCount,
+        ContextType* context = nullptr);
+
+    // This API may only be called from the main thread.
+    // Creates a new threadsafe function with:
+    //   Callback [passed] Resource [passed] Finalizer [missing]
+    template <typename ResourceString>
+    static TypedThreadSafeFunction<ContextType, DataType, CallJs> New(
+        napi_env env,
+        const Function& callback,
+        const Object& resource,
+        ResourceString resourceName,
+        size_t maxQueueSize,
+        size_t initialThreadCount,
+        ContextType* context = nullptr);
+
+    // This API may only be called from the main thread.
+    // Creates a new threadsafe function with:
+    //   Callback [passed] Resource [missing] Finalizer [passed]
+    template <typename ResourceString,
+              typename Finalizer,
+              typename FinalizerDataType = void>
+    static TypedThreadSafeFunction<ContextType, DataType, CallJs> New(
+        napi_env env,
+        const Function& callback,
+        ResourceString resourceName,
+        size_t maxQueueSize,
+        size_t initialThreadCount,
+        ContextType* context,
+        Finalizer finalizeCallback,
+        FinalizerDataType* data = nullptr);
+
+    // This API may only be called from the main thread.
+    // Creates a new threadsafe function with:
+    //   Callback [passed] Resource [passed] Finalizer [passed]
+    template <typename CallbackType,
+              typename ResourceString,
+              typename Finalizer,
+              typename FinalizerDataType>
+    static TypedThreadSafeFunction<ContextType, DataType, CallJs> New(
+        napi_env env,
+        CallbackType callback,
+        const Object& resource,
+        ResourceString resourceName,
+        size_t maxQueueSize,
+        size_t initialThreadCount,
+        ContextType* context,
+        Finalizer finalizeCallback,
+        FinalizerDataType* data = nullptr);
+
+    TypedThreadSafeFunction();
+    TypedThreadSafeFunction(napi_threadsafe_function tsFunctionValue);
+
+    operator napi_threadsafe_function() const;
+
+    // This API may be called from any thread.
+    napi_status BlockingCall(DataType* data = nullptr) const;
+
+    // This API may be called from any thread.
+    napi_status NonBlockingCall(DataType* data = nullptr) const;
+
+    // This API may only be called from the main thread.
+    void Ref(napi_env env) const;
+
+    // This API may only be called from the main thread.
+    void Unref(napi_env env) const;
+
+    // This API may be called from any thread.
+    napi_status Acquire() const;
+
+    // This API may be called from any thread.
+    napi_status Release() const;
+
+    // This API may be called from any thread.
+    napi_status Abort() const;
+
+    // This API may be called from any thread.
+    ContextType* GetContext() const;
+
+   private:
+    template <typename ResourceString,
+              typename Finalizer,
+              typename FinalizerDataType>
+    static TypedThreadSafeFunction<ContextType, DataType, CallJs> New(
+        napi_env env,
+        const Function& callback,
+        const Object& resource,
+        ResourceString resourceName,
+        size_t maxQueueSize,
+        size_t initialThreadCount,
+        ContextType* context,
+        Finalizer finalizeCallback,
+        FinalizerDataType* data,
+        napi_finalize wrapper);
+
+    static void CallJsInternal(napi_env env,
+                               napi_value jsCallback,
+                               void* context,
+                               void* data);
+
+   protected:
+    napi_threadsafe_function _tsfn;
+  };
+  template <typename DataType>
+  class AsyncProgressWorkerBase : public AsyncWorker {
+    public:
+     virtual void OnWorkProgress(DataType* data) = 0;
+     class ThreadSafeData {
+       public:
+        ThreadSafeData(AsyncProgressWorkerBase* asyncprogressworker, DataType* data)
+          : _asyncprogressworker(asyncprogressworker), _data(data) {}
+
+        AsyncProgressWorkerBase* asyncprogressworker() { return _asyncprogressworker; };
+        DataType* data() { return _data; };
+
+       private:
+        AsyncProgressWorkerBase* _asyncprogressworker;
+        DataType* _data;
+     };
+     void OnWorkComplete(Napi::Env env, napi_status status) override;
+    protected:
+     explicit AsyncProgressWorkerBase(const Object& receiver,
+                                      const Function& callback,
+                                      const char* resource_name,
+                                      const Object& resource,
+                                      size_t queue_size = 1);
+    virtual ~AsyncProgressWorkerBase();
+
+// Optional callback of Napi::ThreadSafeFunction only available after NAPI_VERSION 4.
+// Refs: https://github.com/nodejs/node/pull/27791
+#if NAPI_VERSION > 4
+     explicit AsyncProgressWorkerBase(Napi::Env env,
+                                      const char* resource_name,
+                                      const Object& resource,
+                                      size_t queue_size = 1);
+#endif
+
+     static inline void OnAsyncWorkProgress(Napi::Env env,
+                                            Napi::Function jsCallback,
+                                            void* data);
+
+     napi_status NonBlockingCall(DataType* data);
+
+    private:
+     ThreadSafeFunction _tsfn;
+     bool _work_completed = false;
+     napi_status _complete_status;
+     static inline void OnThreadSafeFunctionFinalize(Napi::Env env, void* data, AsyncProgressWorkerBase* context);
+  };
+
+  template<class T>
+  class AsyncProgressWorker : public AsyncProgressWorkerBase<void> {
+    public:
+     virtual ~AsyncProgressWorker();
+
+     class ExecutionProgress {
+        friend class AsyncProgressWorker;
+       public:
+        void Signal() const;
+        void Send(const T* data, size_t count) const;
+       private:
+        explicit ExecutionProgress(AsyncProgressWorker* worker) : _worker(worker) {}
+        AsyncProgressWorker* const _worker;
+     };
+
+     void OnWorkProgress(void*) override;
+
+    protected:
+     explicit AsyncProgressWorker(const Function& callback);
+     explicit AsyncProgressWorker(const Function& callback,
+                                  const char* resource_name);
+     explicit AsyncProgressWorker(const Function& callback,
+                                  const char* resource_name,
+                                  const Object& resource);
+     explicit AsyncProgressWorker(const Object& receiver,
+                                  const Function& callback);
+     explicit AsyncProgressWorker(const Object& receiver,
+                                  const Function& callback,
+                                  const char* resource_name);
+     explicit AsyncProgressWorker(const Object& receiver,
+                                  const Function& callback,
+                                  const char* resource_name,
+                                  const Object& resource);
+
+// Optional callback of Napi::ThreadSafeFunction only available after NAPI_VERSION 4.
+// Refs: https://github.com/nodejs/node/pull/27791
+#if NAPI_VERSION > 4
+     explicit AsyncProgressWorker(Napi::Env env);
+     explicit AsyncProgressWorker(Napi::Env env,
+                                  const char* resource_name);
+     explicit AsyncProgressWorker(Napi::Env env,
+                                  const char* resource_name,
+                                  const Object& resource);
+#endif
+     virtual void Execute(const ExecutionProgress& progress) = 0;
+     virtual void OnProgress(const T* data, size_t count) = 0;
+
+    private:
+     void Execute() override;
+     void Signal() const;
+     void SendProgress_(const T* data, size_t count);
+
+     std::mutex _mutex;
+     T* _asyncdata;
+     size_t _asyncsize;
+  };
+
+  template<class T>
+  class AsyncProgressQueueWorker : public AsyncProgressWorkerBase<std::pair<T*, size_t>> {
+    public:
+     virtual ~AsyncProgressQueueWorker() {};
+
+     class ExecutionProgress {
+        friend class AsyncProgressQueueWorker;
+       public:
+        void Signal() const;
+        void Send(const T* data, size_t count) const;
+       private:
+        explicit ExecutionProgress(AsyncProgressQueueWorker* worker) : _worker(worker) {}
+        AsyncProgressQueueWorker* const _worker;
+     };
+
+     void OnWorkComplete(Napi::Env env, napi_status status) override;
+     void OnWorkProgress(std::pair<T*, size_t>*) override;
+
+    protected:
+     explicit AsyncProgressQueueWorker(const Function& callback);
+     explicit AsyncProgressQueueWorker(const Function& callback,
+                                       const char* resource_name);
+     explicit AsyncProgressQueueWorker(const Function& callback,
+                                       const char* resource_name,
+                                       const Object& resource);
+     explicit AsyncProgressQueueWorker(const Object& receiver,
+                                       const Function& callback);
+     explicit AsyncProgressQueueWorker(const Object& receiver,
+                                       const Function& callback,
+                                       const char* resource_name);
+     explicit AsyncProgressQueueWorker(const Object& receiver,
+                                       const Function& callback,
+                                       const char* resource_name,
+                                       const Object& resource);
+
+// Optional callback of Napi::ThreadSafeFunction only available after NAPI_VERSION 4.
+// Refs: https://github.com/nodejs/node/pull/27791
+#if NAPI_VERSION > 4
+     explicit AsyncProgressQueueWorker(Napi::Env env);
+     explicit AsyncProgressQueueWorker(Napi::Env env,
+                                       const char* resource_name);
+     explicit AsyncProgressQueueWorker(Napi::Env env,
+                                       const char* resource_name,
+                                       const Object& resource);
+#endif
+     virtual void Execute(const ExecutionProgress& progress) = 0;
+     virtual void OnProgress(const T* data, size_t count) = 0;
+
+    private:
+     void Execute() override;
+     void Signal() const;
+     void SendProgress_(const T* data, size_t count);
+  };
+  #endif  // NAPI_VERSION > 3 && !defined(__wasm32__)
 
   // Memory management.
   class MemoryManagement {
@@ -2045,6 +2972,29 @@ namespace Napi {
       static const napi_node_version* GetNodeVersion(Env env);
   };
 
+#if NAPI_VERSION > 5
+  template <typename T>
+  class Addon : public InstanceWrap<T> {
+   public:
+    static inline Object Init(Env env, Object exports);
+    static T* Unwrap(Object wrapper);
+
+   protected:
+    using AddonProp = ClassPropertyDescriptor<T>;
+    void DefineAddon(Object exports,
+                     const std::initializer_list<AddonProp>& props);
+    Napi::Object DefineProperties(Object object,
+                                 const std::initializer_list<AddonProp>& props);
+
+   private:
+    Object entry_point_;
+  };
+#endif  // NAPI_VERSION > 5
+
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+  }  // namespace NAPI_CPP_CUSTOM_NAMESPACE
+#endif
+
 } // namespace Napi
 
 // Inline implementations of all the above class methods are included here.