harperdb 3.2.0 → 3.3.0

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

@@ -2,18 +2,26 @@
 #define SRC_NAPI_INL_H_
 
 ////////////////////////////////////////////////////////////////////////////////
-// N-API C++ Wrapper Classes
+// Node-API C++ Wrapper Classes
 //
-// Inline header-only implementations for "N-API" ABI-stable C APIs for Node.js.
+// Inline header-only implementations for "Node-API" ABI-stable C APIs for
+// Node.js.
 ////////////////////////////////////////////////////////////////////////////////
 
 // Note: Do not include this file directly! Include "napi.h" instead.
 
+#include <algorithm>
 #include <cstring>
+#include <mutex>
 #include <type_traits>
+#include <utility>
 
 namespace Napi {
 
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+namespace NAPI_CPP_CUSTOM_NAMESPACE {
+#endif
+
 // Helpers to handle functions exposed from C++.
 namespace details {
 
@@ -24,16 +32,23 @@ namespace details {
 template <typename FreeType>
 static inline napi_status AttachData(napi_env env,
                                      napi_value obj,
-                                     FreeType* data) {
+                                     FreeType* data,
+                                     napi_finalize finalizer = nullptr,
+                                     void* hint = nullptr) {
+  napi_status status;
+  if (finalizer == nullptr) {
+    finalizer = [](napi_env /*env*/, void* data, void* /*hint*/) {
+      delete static_cast<FreeType*>(data);
+    };
+  }
+#if (NAPI_VERSION < 5)
   napi_value symbol, external;
-  napi_status status = napi_create_symbol(env, nullptr, &symbol);
+  status = napi_create_symbol(env, nullptr, &symbol);
   if (status == napi_ok) {
     status = napi_create_external(env,
                               data,
-                              [](napi_env /*env*/, void* data, void* /*hint*/) {
-                                delete static_cast<FreeType*>(data);
-                              },
-                              nullptr,
+                              finalizer,
+                              hint,
                               &external);
     if (status == napi_ok) {
       napi_property_descriptor desc = {
@@ -49,6 +64,9 @@ static inline napi_status AttachData(napi_env env,
       status = napi_define_properties(env, obj, 1, &desc);
     }
   }
+#else  // NAPI_VERSION >= 5
+  status = napi_add_finalizer(env, obj, data, finalizer, hint, nullptr);
+#endif
   return status;
 }
 
@@ -70,6 +88,24 @@ inline napi_value WrapCallback(Callable callback) {
 #endif // NAPI_CPP_EXCEPTIONS
 }
 
+// For use in JS to C++ void callback wrappers to catch any Napi::Error
+// exceptions and rethrow them as JavaScript exceptions before returning from the
+// callback.
+template <typename Callable>
+inline void WrapVoidCallback(Callable callback) {
+#ifdef NAPI_CPP_EXCEPTIONS
+  try {
+    callback();
+  } catch (const Error& e) {
+    e.ThrowAsJavaScriptException();
+  }
+#else // NAPI_CPP_EXCEPTIONS
+  // When C++ exceptions are disabled, errors are immediately thrown as JS
+  // exceptions, so there is no need to catch and rethrow them here.
+  callback();
+#endif // NAPI_CPP_EXCEPTIONS
+}
+
 template <typename Callable, typename Return>
 struct CallbackData {
   static inline
@@ -105,27 +141,75 @@ struct CallbackData<Callable, void> {
   void* data;
 };
 
+template <void (*Callback)(const CallbackInfo& info)>
+static napi_value
+TemplatedVoidCallback(napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
+  return details::WrapCallback([&] {
+    CallbackInfo cbInfo(env, info);
+    Callback(cbInfo);
+    return nullptr;
+  });
+}
+
+template <Napi::Value (*Callback)(const CallbackInfo& info)>
+static napi_value
+TemplatedCallback(napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
+  return details::WrapCallback([&] {
+    CallbackInfo cbInfo(env, info);
+    return Callback(cbInfo);
+  });
+}
+
+template <typename T,
+          Napi::Value (T::*UnwrapCallback)(const CallbackInfo& info)>
+static napi_value
+TemplatedInstanceCallback(napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
+  return details::WrapCallback([&] {
+    CallbackInfo cbInfo(env, info);
+    T* instance = T::Unwrap(cbInfo.This().As<Object>());
+    return (instance->*UnwrapCallback)(cbInfo);
+  });
+}
+
+template <typename T, void (T::*UnwrapCallback)(const CallbackInfo& info)>
+static napi_value
+TemplatedInstanceVoidCallback(napi_env env,
+                              napi_callback_info info) NAPI_NOEXCEPT {
+  return details::WrapCallback([&] {
+    CallbackInfo cbInfo(env, info);
+    T* instance = T::Unwrap(cbInfo.This().As<Object>());
+    (instance->*UnwrapCallback)(cbInfo);
+    return nullptr;
+  });
+}
+
 template <typename T, typename Finalizer, typename Hint = void>
 struct FinalizeData {
-  static inline
-  void Wrapper(napi_env env, void* data, void* finalizeHint) {
-    FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
-    finalizeData->callback(Env(env), static_cast<T*>(data));
-    delete finalizeData;
+  static inline void Wrapper(napi_env env,
+                             void* data,
+                             void* finalizeHint) NAPI_NOEXCEPT {
+    WrapVoidCallback([&] {
+      FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
+      finalizeData->callback(Env(env), static_cast<T*>(data));
+      delete finalizeData;
+    });
   }
 
-  static inline
-  void WrapperWithHint(napi_env env, void* data, void* finalizeHint) {
-    FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
-    finalizeData->callback(Env(env), static_cast<T*>(data), finalizeData->hint);
-    delete finalizeData;
+  static inline void WrapperWithHint(napi_env env,
+                                     void* data,
+                                     void* finalizeHint) NAPI_NOEXCEPT {
+    WrapVoidCallback([&] {
+      FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
+      finalizeData->callback(Env(env), static_cast<T*>(data), finalizeData->hint);
+      delete finalizeData;
+    });
   }
 
   Finalizer callback;
   Hint* hint;
 };
 
-#if (NAPI_VERSION > 3)
+#if (NAPI_VERSION > 3 && !defined(__wasm32__))
 template <typename ContextType=void,
           typename Finalizer=std::function<void(Env, void*, ContextType*)>,
           typename FinalizerDataType=void>
@@ -138,9 +222,6 @@ struct ThreadSafeFinalize {
     ThreadSafeFinalize* finalizeData =
         static_cast<ThreadSafeFinalize*>(rawFinalizeData);
     finalizeData->callback(Env(env));
-    if (finalizeData->tsfn) {
-      *finalizeData->tsfn = nullptr;
-    }
     delete finalizeData;
   }
 
@@ -154,9 +235,6 @@ struct ThreadSafeFinalize {
     ThreadSafeFinalize* finalizeData =
         static_cast<ThreadSafeFinalize*>(rawFinalizeData);
     finalizeData->callback(Env(env), finalizeData->data);
-    if (finalizeData->tsfn) {
-      *finalizeData->tsfn = nullptr;
-    }
     delete finalizeData;
   }
 
@@ -170,9 +248,6 @@ struct ThreadSafeFinalize {
     ThreadSafeFinalize* finalizeData =
         static_cast<ThreadSafeFinalize*>(rawFinalizeData);
     finalizeData->callback(Env(env), static_cast<ContextType*>(rawContext));
-    if (finalizeData->tsfn) {
-      *finalizeData->tsfn = nullptr;
-    }
     delete finalizeData;
   }
 
@@ -187,17 +262,52 @@ struct ThreadSafeFinalize {
         static_cast<ThreadSafeFinalize*>(rawFinalizeData);
     finalizeData->callback(Env(env), finalizeData->data,
         static_cast<ContextType*>(rawContext));
-    if (finalizeData->tsfn) {
-      *finalizeData->tsfn = nullptr;
-    }
     delete finalizeData;
   }
 
   FinalizerDataType* data;
   Finalizer callback;
-  napi_threadsafe_function* tsfn;
 };
-#endif
+
+template <typename ContextType, typename DataType, typename CallJs, CallJs call>
+typename std::enable_if<call != nullptr>::type static inline CallJsWrapper(
+    napi_env env, napi_value jsCallback, void* context, void* data) {
+  call(env,
+       Function(env, jsCallback),
+       static_cast<ContextType*>(context),
+       static_cast<DataType*>(data));
+}
+
+template <typename ContextType, typename DataType, typename CallJs, CallJs call>
+typename std::enable_if<call == nullptr>::type static inline CallJsWrapper(
+    napi_env env, napi_value jsCallback, void* /*context*/, void* /*data*/) {
+  if (jsCallback != nullptr) {
+    Function(env, jsCallback).Call(0, nullptr);
+  }
+}
+
+#if NAPI_VERSION > 4
+
+template <typename CallbackType, typename TSFN>
+napi_value DefaultCallbackWrapper(napi_env /*env*/, std::nullptr_t /*cb*/) {
+  return nullptr;
+}
+
+template <typename CallbackType, typename TSFN>
+napi_value DefaultCallbackWrapper(napi_env /*env*/, Napi::Function cb) {
+  return cb;
+}
+
+#else
+template <typename CallbackType, typename TSFN>
+napi_value DefaultCallbackWrapper(napi_env env, Napi::Function cb) {
+  if (cb.IsEmpty()) {
+    return TSFN::EmptyFunctionFactory(env);
+  }
+  return cb;
+}
+#endif  // NAPI_VERSION > 4
+#endif  // NAPI_VERSION > 3 && !defined(__wasm32__)
 
 template <typename Getter, typename Setter>
 struct AccessorCallbackData {
@@ -239,12 +349,26 @@ struct AccessorCallbackData {
 // Module registration
 ////////////////////////////////////////////////////////////////////////////////
 
-#define NODE_API_MODULE(modname, regfunc)                 \
-  napi_value __napi_ ## regfunc(napi_env env,             \
-                                napi_value exports) {     \
-    return Napi::RegisterModule(env, exports, regfunc);   \
-  }                                                       \
-  NAPI_MODULE(modname, __napi_ ## regfunc)
+// Register an add-on based on an initializer function.
+#define NODE_API_MODULE(modname, regfunc)                                      \
+  static napi_value __napi_##regfunc(napi_env env, napi_value exports) {       \
+    return Napi::RegisterModule(env, exports, regfunc);                        \
+  }                                                                            \
+  NAPI_MODULE(modname, __napi_##regfunc)
+
+// Register an add-on based on a subclass of `Addon<T>` with a custom Node.js
+// module name.
+#define NODE_API_NAMED_ADDON(modname, classname)                 \
+  static napi_value __napi_ ## classname(napi_env env,           \
+                                         napi_value exports) {   \
+    return Napi::RegisterModule(env, exports, &classname::Init); \
+  }                                                              \
+  NAPI_MODULE(modname, __napi_ ## classname)
+
+// Register an add-on based on a subclass of `Addon<T>` with the Node.js module
+// name given by node-gyp from the `target_name` in binding.gyp.
+#define NODE_API_ADDON(classname) \
+  NODE_API_NAMED_ADDON(NODE_GYP_MODULE_NAME, classname)
 
 // Adapt the NAPI_MODULE registration function:
 //  - Wrap the arguments in NAPI wrappers.
@@ -258,6 +382,72 @@ inline napi_value RegisterModule(napi_env env,
   });
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Maybe class
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+bool Maybe<T>::IsNothing() const {
+  return !_has_value;
+}
+
+template <class T>
+bool Maybe<T>::IsJust() const {
+  return _has_value;
+}
+
+template <class T>
+void Maybe<T>::Check() const {
+  NAPI_CHECK(IsJust(), "Napi::Maybe::Check", "Maybe value is Nothing.");
+}
+
+template <class T>
+T Maybe<T>::Unwrap() const {
+  NAPI_CHECK(IsJust(), "Napi::Maybe::Unwrap", "Maybe value is Nothing.");
+  return _value;
+}
+
+template <class T>
+T Maybe<T>::UnwrapOr(const T& default_value) const {
+  return _has_value ? _value : default_value;
+}
+
+template <class T>
+bool Maybe<T>::UnwrapTo(T* out) const {
+  if (IsJust()) {
+    *out = _value;
+    return true;
+  };
+  return false;
+}
+
+template <class T>
+bool Maybe<T>::operator==(const Maybe& other) const {
+  return (IsJust() == other.IsJust()) &&
+         (!IsJust() || Unwrap() == other.Unwrap());
+}
+
+template <class T>
+bool Maybe<T>::operator!=(const Maybe& other) const {
+  return !operator==(other);
+}
+
+template <class T>
+Maybe<T>::Maybe() : _has_value(false) {}
+
+template <class T>
+Maybe<T>::Maybe(const T& t) : _has_value(true), _value(t) {}
+
+template <class T>
+inline Maybe<T> Nothing() {
+  return Maybe<T>();
+}
+
+template <class T>
+inline Maybe<T> Just(const T& t) {
+  return Maybe<T>(t);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Env class
 ////////////////////////////////////////////////////////////////////////////////
@@ -297,7 +487,7 @@ inline bool Env::IsExceptionPending() const {
   return result;
 }
 
-inline Error Env::GetAndClearPendingException() {
+inline Error Env::GetAndClearPendingException() const {
   napi_value value;
   napi_status status = napi_get_and_clear_last_exception(_env, &value);
   if (status != napi_ok) {
@@ -307,6 +497,84 @@ inline Error Env::GetAndClearPendingException() {
   return Error(_env, value);
 }
 
+inline MaybeOrValue<Value> Env::RunScript(const char* utf8script) const {
+  String script = String::New(_env, utf8script);
+  return RunScript(script);
+}
+
+inline MaybeOrValue<Value> Env::RunScript(const std::string& utf8script) const {
+  return RunScript(utf8script.c_str());
+}
+
+inline MaybeOrValue<Value> Env::RunScript(String script) const {
+  napi_value result;
+  napi_status status = napi_run_script(_env, script, &result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(
+      _env, status, Napi::Value(_env, result), Napi::Value);
+}
+
+#if NAPI_VERSION > 2
+template <typename Hook, typename Arg>
+void Env::CleanupHook<Hook, Arg>::Wrapper(void* data) NAPI_NOEXCEPT {
+  auto* cleanupData =
+      static_cast<typename Napi::Env::CleanupHook<Hook, Arg>::CleanupData*>(
+          data);
+  cleanupData->hook();
+  delete cleanupData;
+}
+
+template <typename Hook, typename Arg>
+void Env::CleanupHook<Hook, Arg>::WrapperWithArg(void* data) NAPI_NOEXCEPT {
+  auto* cleanupData =
+      static_cast<typename Napi::Env::CleanupHook<Hook, Arg>::CleanupData*>(
+          data);
+  cleanupData->hook(static_cast<Arg*>(cleanupData->arg));
+  delete cleanupData;
+}
+#endif  // NAPI_VERSION > 2
+
+#if NAPI_VERSION > 5
+template <typename T, Env::Finalizer<T> fini>
+inline void Env::SetInstanceData(T* data) const {
+  napi_status status =
+    napi_set_instance_data(_env, data, [](napi_env env, void* data, void*) {
+      fini(env, static_cast<T*>(data));
+    }, nullptr);
+  NAPI_THROW_IF_FAILED_VOID(_env, status);
+}
+
+template <typename DataType,
+          typename HintType,
+          Napi::Env::FinalizerWithHint<DataType, HintType> fini>
+inline void Env::SetInstanceData(DataType* data, HintType* hint) const {
+  napi_status status =
+    napi_set_instance_data(_env, data,
+      [](napi_env env, void* data, void* hint) {
+        fini(env, static_cast<DataType*>(data), static_cast<HintType*>(hint));
+      }, hint);
+  NAPI_THROW_IF_FAILED_VOID(_env, status);
+}
+
+template <typename T>
+inline T* Env::GetInstanceData() const {
+  void* data = nullptr;
+
+  napi_status status = napi_get_instance_data(_env, &data);
+  NAPI_THROW_IF_FAILED(_env, status, nullptr);
+
+  return static_cast<T*>(data);
+}
+
+template <typename T> void Env::DefaultFini(Env, T* data) {
+  delete data;
+}
+
+template <typename DataType, typename HintType>
+void Env::DefaultFiniWithHint(Env, DataType* data, HintType*) {
+  delete data;
+}
+#endif  // NAPI_VERSION > 5
+
 ////////////////////////////////////////////////////////////////////////////////
 // Value class
 ////////////////////////////////////////////////////////////////////////////////
@@ -371,13 +639,24 @@ inline bool Value::IsNumber() const {
   return Type() == napi_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
 inline bool Value::IsBigInt() const {
   return Type() == napi_bigint;
 }
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION > 5
+
+#if (NAPI_VERSION > 4)
+inline bool Value::IsDate() const {
+  if (IsEmpty()) {
+    return false;
+  }
+
+  bool result;
+  napi_status status = napi_is_date(_env, _value, &result);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return result;
+}
+#endif
 
 inline bool Value::IsString() const {
   return Type() == napi_string;
@@ -470,32 +749,32 @@ inline T Value::As() const {
   return T(_env, _value);
 }
 
-inline Boolean Value::ToBoolean() const {
+inline MaybeOrValue<Boolean> Value::ToBoolean() const {
   napi_value result;
   napi_status status = napi_coerce_to_bool(_env, _value, &result);
-  NAPI_THROW_IF_FAILED(_env, status, Boolean());
-  return Boolean(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(
+      _env, status, Napi::Boolean(_env, result), Napi::Boolean);
 }
 
-inline Number Value::ToNumber() const {
+inline MaybeOrValue<Number> Value::ToNumber() const {
   napi_value result;
   napi_status status = napi_coerce_to_number(_env, _value, &result);
-  NAPI_THROW_IF_FAILED(_env, status, Number());
-  return Number(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(
+      _env, status, Napi::Number(_env, result), Napi::Number);
 }
 
-inline String Value::ToString() const {
+inline MaybeOrValue<String> Value::ToString() const {
   napi_value result;
   napi_status status = napi_coerce_to_string(_env, _value, &result);
-  NAPI_THROW_IF_FAILED(_env, status, String());
-  return String(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(
+      _env, status, Napi::String(_env, result), Napi::String);
 }
 
-inline Object Value::ToObject() const {
+inline MaybeOrValue<Object> Value::ToObject() const {
   napi_value result;
   napi_status status = napi_coerce_to_object(_env, _value, &result);
-  NAPI_THROW_IF_FAILED(_env, status, Object());
-  return Object(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(
+      _env, status, Napi::Object(_env, result), Napi::Object);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -595,9 +874,7 @@ inline double Number::DoubleValue() const {
   return result;
 }
 
-// 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
 ////////////////////////////////////////////////////////////////////////////////
 // BigInt Class
 ////////////////////////////////////////////////////////////////////////////////
@@ -658,7 +935,38 @@ inline void BigInt::ToWords(int* sign_bit, size_t* word_count, uint64_t* words)
       _env, _value, sign_bit, word_count, words);
   NAPI_THROW_IF_FAILED_VOID(_env, status);
 }
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION > 5
+
+#if (NAPI_VERSION > 4)
+////////////////////////////////////////////////////////////////////////////////
+// Date Class
+////////////////////////////////////////////////////////////////////////////////
+
+inline Date Date::New(napi_env env, double val) {
+  napi_value value;
+  napi_status status = napi_create_date(env, val, &value);
+  NAPI_THROW_IF_FAILED(env, status, Date());
+  return Date(env, value);
+}
+
+inline Date::Date() : Value() {
+}
+
+inline Date::Date(napi_env env, napi_value value) : Value(env, value) {
+}
+
+inline Date::operator double() const {
+  return ValueOf();
+}
+
+inline double Date::ValueOf() const {
+  double result;
+  napi_status status = napi_get_date_value(
+      _env, _value, &result);
+  NAPI_THROW_IF_FAILED(_env, status, 0);
+  return result;
+}
+#endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // Name class
@@ -683,6 +991,12 @@ inline String String::New(napi_env env, const std::u16string& val) {
 }
 
 inline String String::New(napi_env env, const char* val) {
+  // TODO(@gabrielschulhof) Remove if-statement when core's error handling is
+  // available in all supported versions.
+  if (val == nullptr) {
+    // Throw an error that looks like it came from core.
+    NAPI_THROW_IF_FAILED(env, napi_invalid_arg, String());
+  }
   napi_value value;
   napi_status status = napi_create_string_utf8(env, val, std::strlen(val), &value);
   NAPI_THROW_IF_FAILED(env, status, String());
@@ -691,6 +1005,12 @@ inline String String::New(napi_env env, const char* val) {
 
 inline String String::New(napi_env env, const char16_t* val) {
   napi_value value;
+  // TODO(@gabrielschulhof) Remove if-statement when core's error handling is
+  // available in all supported versions.
+  if (val == nullptr) {
+    // Throw an error that looks like it came from core.
+    NAPI_THROW_IF_FAILED(env, napi_invalid_arg, String());
+  }
   napi_status status = napi_create_string_utf16(env, val, std::u16string(val).size(), &value);
   NAPI_THROW_IF_FAILED(env, status, String());
   return String(env, value);
@@ -777,8 +1097,56 @@ inline Symbol Symbol::New(napi_env env, napi_value description) {
   return Symbol(env, value);
 }
 
-inline Symbol Symbol::WellKnown(napi_env env, const std::string& name) {
+inline MaybeOrValue<Symbol> Symbol::WellKnown(napi_env env,
+                                              const std::string& name) {
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+  Value symbol_obj;
+  Value symbol_value;
+  if (Napi::Env(env).Global().Get("Symbol").UnwrapTo(&symbol_obj) &&
+      symbol_obj.As<Object>().Get(name).UnwrapTo(&symbol_value)) {
+    return Just<Symbol>(symbol_value.As<Symbol>());
+  }
+  return Nothing<Symbol>();
+#else
   return Napi::Env(env).Global().Get("Symbol").As<Object>().Get(name).As<Symbol>();
+#endif
+}
+
+inline MaybeOrValue<Symbol> Symbol::For(napi_env env,
+                                        const std::string& description) {
+  napi_value descriptionValue = String::New(env, description);
+  return Symbol::For(env, descriptionValue);
+}
+
+inline MaybeOrValue<Symbol> Symbol::For(napi_env env, const char* description) {
+  napi_value descriptionValue = String::New(env, description);
+  return Symbol::For(env, descriptionValue);
+}
+
+inline MaybeOrValue<Symbol> Symbol::For(napi_env env, String description) {
+  return Symbol::For(env, static_cast<napi_value>(description));
+}
+
+inline MaybeOrValue<Symbol> Symbol::For(napi_env env, napi_value description) {
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+  Value symbol_obj;
+  Value symbol_for_value;
+  Value symbol_value;
+  if (Napi::Env(env).Global().Get("Symbol").UnwrapTo(&symbol_obj) &&
+      symbol_obj.As<Object>().Get("for").UnwrapTo(&symbol_for_value) &&
+      symbol_for_value.As<Function>()
+          .Call(symbol_obj, {description})
+          .UnwrapTo(&symbol_value)) {
+    return Just<Symbol>(symbol_value.As<Symbol>());
+  }
+  return Nothing<Symbol>();
+#else
+  Object symbol_obj = Napi::Env(env).Global().Get("Symbol").As<Object>();
+  return symbol_obj.Get("for")
+      .As<Function>()
+      .Call(symbol_obj, {description})
+      .As<Symbol>();
+#endif
 }
 
 inline Symbol::Symbol() : Name() {
@@ -893,12 +1261,23 @@ String String::From(napi_env env, const T& value) {
 
 template <typename Key>
 inline Object::PropertyLValue<Key>::operator Value() const {
-  return Object(_env, _object).Get(_key);
+  MaybeOrValue<Value> val = Object(_env, _object).Get(_key);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  return val.Unwrap();
+#else
+  return val;
+#endif
 }
 
 template <typename Key> template <typename ValueType>
 inline Object::PropertyLValue<Key>& Object::PropertyLValue<Key>::operator =(ValueType value) {
-  Object(_env, _object).Set(_key, value);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  MaybeOrValue<bool> result =
+#endif
+      Object(_env, _object).Set(_key, value);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  result.Unwrap();
+#endif
   return *this;
 }
 
@@ -919,213 +1298,339 @@ inline Object::Object() : Value() {
 inline Object::Object(napi_env env, napi_value value) : Value(env, value) {
 }
 
-inline Object::PropertyLValue<std::string> Object::operator [](const char* utf8name) {
+inline Object::PropertyLValue<std::string> Object::operator[](
+    const char* utf8name) {
   return PropertyLValue<std::string>(*this, utf8name);
 }
 
-inline Object::PropertyLValue<std::string> Object::operator [](const std::string& utf8name) {
+inline Object::PropertyLValue<std::string> Object::operator[](
+    const std::string& utf8name) {
   return PropertyLValue<std::string>(*this, utf8name);
 }
 
-inline Object::PropertyLValue<uint32_t> Object::operator [](uint32_t index) {
+inline Object::PropertyLValue<uint32_t> Object::operator[](uint32_t index) {
   return PropertyLValue<uint32_t>(*this, index);
 }
 
-inline Value Object::operator [](const char* utf8name) const {
+inline Object::PropertyLValue<Value> Object::operator[](Value index) const {
+  return PropertyLValue<Value>(*this, index);
+}
+
+inline MaybeOrValue<Value> Object::operator[](const char* utf8name) const {
   return Get(utf8name);
 }
 
-inline Value Object::operator [](const std::string& utf8name) const {
+inline MaybeOrValue<Value> Object::operator[](
+    const std::string& utf8name) const {
   return Get(utf8name);
 }
 
-inline Value Object::operator [](uint32_t index) const {
+inline MaybeOrValue<Value> Object::operator[](uint32_t index) const {
   return Get(index);
 }
 
-inline bool Object::Has(napi_value key) const {
+inline MaybeOrValue<bool> Object::Has(napi_value key) const {
   bool result;
   napi_status status = napi_has_property(_env, _value, key, &result);
-  NAPI_THROW_IF_FAILED(_env, status, false);
-  return result;
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline bool Object::Has(Value key) const {
+inline MaybeOrValue<bool> Object::Has(Value key) const {
   bool result;
   napi_status status = napi_has_property(_env, _value, key, &result);
-  NAPI_THROW_IF_FAILED(_env, status, false);
-  return result;
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline bool Object::Has(const char* utf8name) const {
+inline MaybeOrValue<bool> Object::Has(const char* utf8name) const {
   bool result;
   napi_status status = napi_has_named_property(_env, _value, utf8name, &result);
-  NAPI_THROW_IF_FAILED(_env, status, false);
-  return result;
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline bool Object::Has(const std::string& utf8name) const {
+inline MaybeOrValue<bool> Object::Has(const std::string& utf8name) const {
   return Has(utf8name.c_str());
 }
 
-inline bool Object::HasOwnProperty(napi_value key) const {
+inline MaybeOrValue<bool> Object::HasOwnProperty(napi_value key) const {
   bool result;
   napi_status status = napi_has_own_property(_env, _value, key, &result);
-  NAPI_THROW_IF_FAILED(_env, status, false);
-  return result;
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline bool Object::HasOwnProperty(Value key) const {
+inline MaybeOrValue<bool> Object::HasOwnProperty(Value key) const {
   bool result;
   napi_status status = napi_has_own_property(_env, _value, key, &result);
-  NAPI_THROW_IF_FAILED(_env, status, false);
-  return result;
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline bool Object::HasOwnProperty(const char* utf8name) const {
+inline MaybeOrValue<bool> Object::HasOwnProperty(const char* utf8name) const {
   napi_value key;
   napi_status status = napi_create_string_utf8(_env, utf8name, std::strlen(utf8name), &key);
-  NAPI_THROW_IF_FAILED(_env, status, false);
+  NAPI_MAYBE_THROW_IF_FAILED(_env, status, bool);
   return HasOwnProperty(key);
 }
 
-inline bool Object::HasOwnProperty(const std::string& utf8name) const {
+inline MaybeOrValue<bool> Object::HasOwnProperty(
+    const std::string& utf8name) const {
   return HasOwnProperty(utf8name.c_str());
 }
 
-inline Value Object::Get(napi_value key) const {
+inline MaybeOrValue<Value> Object::Get(napi_value key) const {
   napi_value result;
   napi_status status = napi_get_property(_env, _value, key, &result);
-  NAPI_THROW_IF_FAILED(_env, status, Value());
-  return Value(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, Value(_env, result), Value);
 }
 
-inline Value Object::Get(Value key) const {
+inline MaybeOrValue<Value> Object::Get(Value key) const {
   napi_value result;
   napi_status status = napi_get_property(_env, _value, key, &result);
-  NAPI_THROW_IF_FAILED(_env, status, Value());
-  return Value(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, Value(_env, result), Value);
 }
 
-inline Value Object::Get(const char* utf8name) const {
+inline MaybeOrValue<Value> Object::Get(const char* utf8name) const {
   napi_value result;
   napi_status status = napi_get_named_property(_env, _value, utf8name, &result);
-  NAPI_THROW_IF_FAILED(_env, status, Value());
-  return Value(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, Value(_env, result), Value);
 }
 
-inline Value Object::Get(const std::string& utf8name) const {
+inline MaybeOrValue<Value> Object::Get(const std::string& utf8name) const {
   return Get(utf8name.c_str());
 }
 
 template <typename ValueType>
-inline void Object::Set(napi_value key, const ValueType& value) {
+inline MaybeOrValue<bool> Object::Set(napi_value key,
+                                      const ValueType& value) const {
   napi_status status =
       napi_set_property(_env, _value, key, Value::From(_env, value));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
 template <typename ValueType>
-inline void Object::Set(Value key, const ValueType& value) {
+inline MaybeOrValue<bool> Object::Set(Value key, const ValueType& value) const {
   napi_status status =
       napi_set_property(_env, _value, key, Value::From(_env, value));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
 template <typename ValueType>
-inline void Object::Set(const char* utf8name, const ValueType& value) {
+inline MaybeOrValue<bool> Object::Set(const char* utf8name,
+                                      const ValueType& value) const {
   napi_status status =
       napi_set_named_property(_env, _value, utf8name, Value::From(_env, value));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
 template <typename ValueType>
-inline void Object::Set(const std::string& utf8name, const ValueType& value) {
-  Set(utf8name.c_str(), value);
+inline MaybeOrValue<bool> Object::Set(const std::string& utf8name,
+                                      const ValueType& value) const {
+  return Set(utf8name.c_str(), value);
 }
 
-inline bool Object::Delete(napi_value key) {
+inline MaybeOrValue<bool> Object::Delete(napi_value key) const {
   bool result;
   napi_status status = napi_delete_property(_env, _value, key, &result);
-  NAPI_THROW_IF_FAILED(_env, status, false);
-  return result;
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline bool Object::Delete(Value key) {
+inline MaybeOrValue<bool> Object::Delete(Value key) const {
   bool result;
   napi_status status = napi_delete_property(_env, _value, key, &result);
-  NAPI_THROW_IF_FAILED(_env, status, false);
-  return result;
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline bool Object::Delete(const char* utf8name) {
+inline MaybeOrValue<bool> Object::Delete(const char* utf8name) const {
   return Delete(String::New(_env, utf8name));
 }
 
-inline bool Object::Delete(const std::string& utf8name) {
+inline MaybeOrValue<bool> Object::Delete(const std::string& utf8name) const {
   return Delete(String::New(_env, utf8name));
 }
 
-inline bool Object::Has(uint32_t index) const {
+inline MaybeOrValue<bool> Object::Has(uint32_t index) const {
   bool result;
   napi_status status = napi_has_element(_env, _value, index, &result);
-  NAPI_THROW_IF_FAILED(_env, status, false);
-  return result;
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline Value Object::Get(uint32_t index) const {
+inline MaybeOrValue<Value> Object::Get(uint32_t index) const {
   napi_value value;
   napi_status status = napi_get_element(_env, _value, index, &value);
-  NAPI_THROW_IF_FAILED(_env, status, Value());
-  return Value(_env, value);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, Value(_env, value), Value);
 }
 
 template <typename ValueType>
-inline void Object::Set(uint32_t index, const ValueType& value) {
+inline MaybeOrValue<bool> Object::Set(uint32_t index,
+                                      const ValueType& value) const {
   napi_status status =
       napi_set_element(_env, _value, index, Value::From(_env, value));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
-inline bool Object::Delete(uint32_t index) {
+inline MaybeOrValue<bool> Object::Delete(uint32_t index) const {
   bool result;
   napi_status status = napi_delete_element(_env, _value, index, &result);
-  NAPI_THROW_IF_FAILED(_env, status, false);
-  return result;
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline Array Object::GetPropertyNames() const {
+inline MaybeOrValue<Array> Object::GetPropertyNames() const {
   napi_value result;
   napi_status status = napi_get_property_names(_env, _value, &result);
-  NAPI_THROW_IF_FAILED(_env, status, Array());
-  return Array(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, Array(_env, result), Array);
 }
 
-inline void Object::DefineProperty(const PropertyDescriptor& property) {
+inline MaybeOrValue<bool> Object::DefineProperty(
+    const PropertyDescriptor& property) const {
   napi_status status = napi_define_properties(_env, _value, 1,
     reinterpret_cast<const napi_property_descriptor*>(&property));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
-inline void Object::DefineProperties(const std::initializer_list<PropertyDescriptor>& properties) {
+inline MaybeOrValue<bool> Object::DefineProperties(
+    const std::initializer_list<PropertyDescriptor>& properties) const {
   napi_status status = napi_define_properties(_env, _value, properties.size(),
     reinterpret_cast<const napi_property_descriptor*>(properties.begin()));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
-inline void Object::DefineProperties(const std::vector<PropertyDescriptor>& properties) {
+inline MaybeOrValue<bool> Object::DefineProperties(
+    const std::vector<PropertyDescriptor>& properties) const {
   napi_status status = napi_define_properties(_env, _value, properties.size(),
     reinterpret_cast<const napi_property_descriptor*>(properties.data()));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
-inline bool Object::InstanceOf(const Function& constructor) const {
+inline MaybeOrValue<bool> Object::InstanceOf(
+    const Function& constructor) const {
   bool result;
   napi_status status = napi_instanceof(_env, _value, constructor, &result);
-  NAPI_THROW_IF_FAILED(_env, status, false);
-  return result;
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
+}
+
+template <typename Finalizer, typename T>
+inline void Object::AddFinalizer(Finalizer finalizeCallback, T* data) const {
+  details::FinalizeData<T, Finalizer>* finalizeData =
+      new details::FinalizeData<T, Finalizer>(
+          {std::move(finalizeCallback), nullptr});
+  napi_status status =
+      details::AttachData(_env,
+                          *this,
+                          data,
+                          details::FinalizeData<T, Finalizer>::Wrapper,
+                          finalizeData);
+  if (status != napi_ok) {
+    delete finalizeData;
+    NAPI_THROW_IF_FAILED_VOID(_env, status);
+  }
+}
+
+template <typename Finalizer, typename T, typename Hint>
+inline void Object::AddFinalizer(Finalizer finalizeCallback,
+                                 T* data,
+                                 Hint* finalizeHint) const {
+  details::FinalizeData<T, Finalizer, Hint>* finalizeData =
+      new details::FinalizeData<T, Finalizer, Hint>(
+          {std::move(finalizeCallback), finalizeHint});
+  napi_status status =
+      details::AttachData(_env,
+                          *this,
+                          data,
+                          details::FinalizeData<T, Finalizer, Hint>::WrapperWithHint,
+                          finalizeData);
+  if (status != napi_ok) {
+    delete finalizeData;
+    NAPI_THROW_IF_FAILED_VOID(_env, status);
+  }
+}
+
+#ifdef NAPI_CPP_EXCEPTIONS
+inline Object::const_iterator::const_iterator(const Object* object,
+                                              const Type type) {
+  _object = object;
+  _keys = object->GetPropertyNames();
+  _index = type == Type::BEGIN ? 0 : _keys.Length();
+}
+
+inline Object::const_iterator Napi::Object::begin() const {
+  const_iterator it(this, Object::const_iterator::Type::BEGIN);
+  return it;
+}
+
+inline Object::const_iterator Napi::Object::end() const {
+  const_iterator it(this, Object::const_iterator::Type::END);
+  return it;
+}
+
+inline Object::const_iterator& Object::const_iterator::operator++() {
+  ++_index;
+  return *this;
+}
+
+inline bool Object::const_iterator::operator==(
+    const const_iterator& other) const {
+  return _index == other._index;
+}
+
+inline bool Object::const_iterator::operator!=(
+    const const_iterator& other) const {
+  return _index != other._index;
+}
+
+inline const std::pair<Value, Object::PropertyLValue<Value>>
+Object::const_iterator::operator*() const {
+  const Value key = _keys[_index];
+  const PropertyLValue<Value> value = (*_object)[key];
+  return {key, value};
+}
+
+inline Object::iterator::iterator(Object* object, const Type type) {
+  _object = object;
+  _keys = object->GetPropertyNames();
+  _index = type == Type::BEGIN ? 0 : _keys.Length();
+}
+
+inline Object::iterator Napi::Object::begin() {
+  iterator it(this, Object::iterator::Type::BEGIN);
+  return it;
 }
 
+inline Object::iterator Napi::Object::end() {
+  iterator it(this, Object::iterator::Type::END);
+  return it;
+}
+
+inline Object::iterator& Object::iterator::operator++() {
+  ++_index;
+  return *this;
+}
+
+inline bool Object::iterator::operator==(const iterator& other) const {
+  return _index == other._index;
+}
+
+inline bool Object::iterator::operator!=(const iterator& other) const {
+  return _index != other._index;
+}
+
+inline std::pair<Value, Object::PropertyLValue<Value>>
+Object::iterator::operator*() {
+  Value key = _keys[_index];
+  PropertyLValue<Value> value = (*_object)[key];
+  return {key, value};
+}
+#endif  // NAPI_CPP_EXCEPTIONS
+
+#if NAPI_VERSION >= 8
+inline MaybeOrValue<bool> Object::Freeze() const {
+  napi_status status = napi_object_freeze(_env, _value);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
+}
+
+inline MaybeOrValue<bool> Object::Seal() const {
+  napi_status status = napi_object_seal(_env, _value);
+  NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
+}
+#endif  // NAPI_VERSION >= 8
+
 ////////////////////////////////////////////////////////////////////////////////
 // External class
 ////////////////////////////////////////////////////////////////////////////////
@@ -1145,7 +1650,8 @@ inline External<T> External<T>::New(napi_env env,
                                     Finalizer finalizeCallback) {
   napi_value value;
   details::FinalizeData<T, Finalizer>* finalizeData =
-    new details::FinalizeData<T, Finalizer>({ finalizeCallback, nullptr });
+      new details::FinalizeData<T, Finalizer>(
+          {std::move(finalizeCallback), nullptr});
   napi_status status = napi_create_external(
     env,
     data,
@@ -1167,7 +1673,8 @@ inline External<T> External<T>::New(napi_env env,
                                     Hint* finalizeHint) {
   napi_value value;
   details::FinalizeData<T, Finalizer, Hint>* finalizeData =
-    new details::FinalizeData<T, Finalizer, Hint>({ finalizeCallback, finalizeHint });
+      new details::FinalizeData<T, Finalizer, Hint>(
+          {std::move(finalizeCallback), finalizeHint});
   napi_status status = napi_create_external(
     env,
     data,
@@ -1238,7 +1745,7 @@ inline ArrayBuffer ArrayBuffer::New(napi_env env, size_t byteLength) {
   napi_status status = napi_create_arraybuffer(env, byteLength, &data, &value);
   NAPI_THROW_IF_FAILED(env, status, ArrayBuffer());
 
-  return ArrayBuffer(env, value, data, byteLength);
+  return ArrayBuffer(env, value);
 }
 
 inline ArrayBuffer ArrayBuffer::New(napi_env env,
@@ -1249,7 +1756,7 @@ inline ArrayBuffer ArrayBuffer::New(napi_env env,
     env, externalData, byteLength, nullptr, nullptr, &value);
   NAPI_THROW_IF_FAILED(env, status, ArrayBuffer());
 
-  return ArrayBuffer(env, value, externalData, byteLength);
+  return ArrayBuffer(env, value);
 }
 
 template <typename Finalizer>
@@ -1259,7 +1766,8 @@ inline ArrayBuffer ArrayBuffer::New(napi_env env,
                                     Finalizer finalizeCallback) {
   napi_value value;
   details::FinalizeData<void, Finalizer>* finalizeData =
-    new details::FinalizeData<void, Finalizer>({ finalizeCallback, nullptr });
+      new details::FinalizeData<void, Finalizer>(
+          {std::move(finalizeCallback), nullptr});
   napi_status status = napi_create_external_arraybuffer(
     env,
     externalData,
@@ -1272,7 +1780,7 @@ inline ArrayBuffer ArrayBuffer::New(napi_env env,
     NAPI_THROW_IF_FAILED(env, status, ArrayBuffer());
   }
 
-  return ArrayBuffer(env, value, externalData, byteLength);
+  return ArrayBuffer(env, value);
 }
 
 template <typename Finalizer, typename Hint>
@@ -1283,7 +1791,8 @@ inline ArrayBuffer ArrayBuffer::New(napi_env env,
                                     Hint* finalizeHint) {
   napi_value value;
   details::FinalizeData<void, Finalizer, Hint>* finalizeData =
-    new details::FinalizeData<void, Finalizer, Hint>({ finalizeCallback, finalizeHint });
+      new details::FinalizeData<void, Finalizer, Hint>(
+          {std::move(finalizeCallback), finalizeHint});
   napi_status status = napi_create_external_arraybuffer(
     env,
     externalData,
@@ -1296,39 +1805,43 @@ inline ArrayBuffer ArrayBuffer::New(napi_env env,
     NAPI_THROW_IF_FAILED(env, status, ArrayBuffer());
   }
 
-  return ArrayBuffer(env, value, externalData, byteLength);
+  return ArrayBuffer(env, value);
 }
 
-inline ArrayBuffer::ArrayBuffer() : Object(), _data(nullptr), _length(0) {
+inline ArrayBuffer::ArrayBuffer() : Object() {
 }
 
 inline ArrayBuffer::ArrayBuffer(napi_env env, napi_value value)
-  : Object(env, value), _data(nullptr), _length(0) {
-}
-
-inline ArrayBuffer::ArrayBuffer(napi_env env, napi_value value, void* data, size_t length)
-  : Object(env, value), _data(data), _length(length) {
+  : Object(env, value) {
 }
 
 inline void* ArrayBuffer::Data() {
-  EnsureInfo();
-  return _data;
+  void* data;
+  napi_status status = napi_get_arraybuffer_info(_env, _value, &data, nullptr);
+  NAPI_THROW_IF_FAILED(_env, status, nullptr);
+  return data;
 }
 
 inline size_t ArrayBuffer::ByteLength() {
-  EnsureInfo();
-  return _length;
+  size_t length;
+  napi_status status = napi_get_arraybuffer_info(_env, _value, nullptr, &length);
+  NAPI_THROW_IF_FAILED(_env, status, 0);
+  return length;
 }
 
-inline void ArrayBuffer::EnsureInfo() const {
-  // The ArrayBuffer instance may have been constructed from a napi_value whose
-  // length/data are not yet known. Fetch and cache these values just once,
-  // since they can never change during the lifetime of the ArrayBuffer.
-  if (_data == nullptr) {
-    napi_status status = napi_get_arraybuffer_info(_env, _value, &_data, &_length);
-    NAPI_THROW_IF_FAILED_VOID(_env, status);
-  }
+#if NAPI_VERSION >= 7
+inline bool ArrayBuffer::IsDetached() const {
+  bool detached;
+  napi_status status = napi_is_detached_arraybuffer(_env, _value, &detached);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return detached;
+}
+
+inline void ArrayBuffer::Detach() {
+  napi_status status = napi_detach_arraybuffer(_env, _value);
+  NAPI_THROW_IF_FAILED_VOID(_env, status);
 }
+#endif  // NAPI_VERSION >= 7
 
 ////////////////////////////////////////////////////////////////////////////////
 // DataView class
@@ -1543,6 +2056,10 @@ inline uint8_t TypedArray::ElementSize() const {
     case napi_float32_array:
       return 4;
     case napi_float64_array:
+#if (NAPI_VERSION > 5)
+    case napi_bigint64_array:
+    case napi_biguint64_array:
+#endif  // (NAPI_VERSION > 5)
       return 8;
     default:
       return 0;
@@ -1615,8 +2132,16 @@ inline TypedArrayOf<T>::TypedArrayOf() : TypedArray(), _data(nullptr) {
 template <typename T>
 inline TypedArrayOf<T>::TypedArrayOf(napi_env env, napi_value value)
   : TypedArray(env, value), _data(nullptr) {
-  napi_status status = napi_get_typedarray_info(
-    _env, _value, &_type, &_length, reinterpret_cast<void**>(&_data), nullptr, nullptr);
+  napi_status status = napi_ok;
+  if (value != nullptr) {
+    void* data = nullptr;
+    status = napi_get_typedarray_info(
+        _env, _value, &_type, &_length, &data, nullptr, nullptr);
+    _data = static_cast<T*>(data);
+  } else {
+    _type = TypedArrayTypeForPrimitiveType<T>();
+    _length = 0;
+  }
   NAPI_THROW_IF_FAILED_VOID(_env, status);
 }
 
@@ -1674,14 +2199,54 @@ CreateFunction(napi_env env,
   return status;
 }
 
+template <Function::VoidCallback cb>
+inline Function Function::New(napi_env env, const char* utf8name, void* data) {
+  napi_value result = nullptr;
+  napi_status status = napi_create_function(env,
+                                            utf8name,
+                                            NAPI_AUTO_LENGTH,
+                                            details::TemplatedVoidCallback<cb>,
+                                            data,
+                                            &result);
+  NAPI_THROW_IF_FAILED(env, status, Function());
+  return Function(env, result);
+}
+
+template <Function::Callback cb>
+inline Function Function::New(napi_env env, const char* utf8name, void* data) {
+  napi_value result = nullptr;
+  napi_status status = napi_create_function(env,
+                                            utf8name,
+                                            NAPI_AUTO_LENGTH,
+                                            details::TemplatedCallback<cb>,
+                                            data,
+                                            &result);
+  NAPI_THROW_IF_FAILED(env, status, Function());
+  return Function(env, result);
+}
+
+template <Function::VoidCallback cb>
+inline Function Function::New(napi_env env,
+                              const std::string& utf8name,
+                              void* data) {
+  return Function::New<cb>(env, utf8name.c_str(), data);
+}
+
+template <Function::Callback cb>
+inline Function Function::New(napi_env env,
+                              const std::string& utf8name,
+                              void* data) {
+  return Function::New<cb>(env, utf8name.c_str(), data);
+}
+
 template <typename Callable>
 inline Function Function::New(napi_env env,
                               Callable cb,
                               const char* utf8name,
                               void* data) {
-  typedef decltype(cb(CallbackInfo(nullptr, nullptr))) ReturnType;
-  typedef details::CallbackData<Callable, ReturnType> CbData;
-  auto callbackData = new CbData({ cb, data });
+  using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
+  using CbData = details::CallbackData<Callable, ReturnType>;
+  auto callbackData = new CbData{std::move(cb), data};
 
   napi_value value;
   napi_status status = CreateFunction(env,
@@ -1711,53 +2276,87 @@ inline Function::Function() : Object() {
 inline Function::Function(napi_env env, napi_value value) : Object(env, value) {
 }
 
-inline Value Function::operator ()(const std::initializer_list<napi_value>& args) const {
+inline MaybeOrValue<Value> Function::operator()(
+    const std::initializer_list<napi_value>& args) const {
+  return Call(Env().Undefined(), args);
+}
+
+inline MaybeOrValue<Value> Function::Call(
+    const std::initializer_list<napi_value>& args) const {
   return Call(Env().Undefined(), args);
 }
 
-inline Value Function::Call(const std::initializer_list<napi_value>& args) const {
+inline MaybeOrValue<Value> Function::Call(
+    const std::vector<napi_value>& args) const {
   return Call(Env().Undefined(), args);
 }
 
-inline Value Function::Call(const std::vector<napi_value>& args) const {
+inline MaybeOrValue<Value> Function::Call(
+    const std::vector<Value>& args) const {
   return Call(Env().Undefined(), args);
 }
 
-inline Value Function::Call(size_t argc, const napi_value* args) const {
+inline MaybeOrValue<Value> Function::Call(size_t argc,
+                                          const napi_value* args) const {
   return Call(Env().Undefined(), argc, args);
 }
 
-inline Value Function::Call(napi_value recv, const std::initializer_list<napi_value>& args) const {
+inline MaybeOrValue<Value> Function::Call(
+    napi_value recv, const std::initializer_list<napi_value>& args) const {
   return Call(recv, args.size(), args.begin());
 }
 
-inline Value Function::Call(napi_value recv, const std::vector<napi_value>& args) const {
+inline MaybeOrValue<Value> Function::Call(
+    napi_value recv, const std::vector<napi_value>& args) const {
   return Call(recv, args.size(), args.data());
 }
 
-inline Value Function::Call(napi_value recv, size_t argc, const napi_value* args) const {
+inline MaybeOrValue<Value> Function::Call(
+    napi_value recv, const std::vector<Value>& args) const {
+  const size_t argc = args.size();
+  const size_t stackArgsCount = 6;
+  napi_value stackArgs[stackArgsCount];
+  std::vector<napi_value> heapArgs;
+  napi_value* argv;
+  if (argc <= stackArgsCount) {
+    argv = stackArgs;
+  } else {
+    heapArgs.resize(argc);
+    argv = heapArgs.data();
+  }
+
+  for (size_t index = 0; index < argc; index++) {
+    argv[index] = static_cast<napi_value>(args[index]);
+  }
+
+  return Call(recv, argc, argv);
+}
+
+inline MaybeOrValue<Value> Function::Call(napi_value recv,
+                                          size_t argc,
+                                          const napi_value* args) const {
   napi_value result;
   napi_status status = napi_call_function(
     _env, recv, _value, argc, args, &result);
-  NAPI_THROW_IF_FAILED(_env, status, Value());
-  return Value(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(
+      _env, status, Napi::Value(_env, result), Napi::Value);
 }
 
-inline Value Function::MakeCallback(
+inline MaybeOrValue<Value> Function::MakeCallback(
     napi_value recv,
     const std::initializer_list<napi_value>& args,
     napi_async_context context) const {
   return MakeCallback(recv, args.size(), args.begin(), context);
 }
 
-inline Value Function::MakeCallback(
+inline MaybeOrValue<Value> Function::MakeCallback(
     napi_value recv,
     const std::vector<napi_value>& args,
     napi_async_context context) const {
   return MakeCallback(recv, args.size(), args.data(), context);
 }
 
-inline Value Function::MakeCallback(
+inline MaybeOrValue<Value> Function::MakeCallback(
     napi_value recv,
     size_t argc,
     const napi_value* args,
@@ -1765,24 +2364,27 @@ inline Value Function::MakeCallback(
   napi_value result;
   napi_status status = napi_make_callback(
     _env, context, recv, _value, argc, args, &result);
-  NAPI_THROW_IF_FAILED(_env, status, Value());
-  return Value(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(
+      _env, status, Napi::Value(_env, result), Napi::Value);
 }
 
-inline Object Function::New(const std::initializer_list<napi_value>& args) const {
+inline MaybeOrValue<Object> Function::New(
+    const std::initializer_list<napi_value>& args) const {
   return New(args.size(), args.begin());
 }
 
-inline Object Function::New(const std::vector<napi_value>& args) const {
+inline MaybeOrValue<Object> Function::New(
+    const std::vector<napi_value>& args) const {
   return New(args.size(), args.data());
 }
 
-inline Object Function::New(size_t argc, const napi_value* args) const {
+inline MaybeOrValue<Object> Function::New(size_t argc,
+                                          const napi_value* args) const {
   napi_value result;
   napi_status status = napi_new_instance(
     _env, _value, argc, args, &result);
-  NAPI_THROW_IF_FAILED(_env, status, Object());
-  return Object(_env, result);
+  NAPI_RETURN_OR_THROW_IF_FAILED(
+      _env, status, Napi::Object(_env, result), Napi::Object);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1849,7 +2451,8 @@ inline Buffer<T> Buffer<T>::New(napi_env env,
                                 Finalizer finalizeCallback) {
   napi_value value;
   details::FinalizeData<T, Finalizer>* finalizeData =
-    new details::FinalizeData<T, Finalizer>({ finalizeCallback, nullptr });
+      new details::FinalizeData<T, Finalizer>(
+          {std::move(finalizeCallback), nullptr});
   napi_status status = napi_create_external_buffer(
     env,
     length * sizeof (T),
@@ -1873,7 +2476,8 @@ inline Buffer<T> Buffer<T>::New(napi_env env,
                                 Hint* finalizeHint) {
   napi_value value;
   details::FinalizeData<T, Finalizer, Hint>* finalizeData =
-    new details::FinalizeData<T, Finalizer, Hint>({ finalizeCallback, finalizeHint });
+      new details::FinalizeData<T, Finalizer, Hint>(
+          {std::move(finalizeCallback), finalizeHint});
   napi_status status = napi_create_external_buffer(
     env,
     length * sizeof (T),
@@ -1945,52 +2549,58 @@ inline void Buffer<T>::EnsureInfo() const {
 inline Error Error::New(napi_env env) {
   napi_status status;
   napi_value error = nullptr;
+  bool is_exception_pending;
+  napi_extended_error_info last_error_info_copy;
+
+  {
+    // We must retrieve the last error info before doing anything else because
+    // doing anything else will replace the last error info.
+    const napi_extended_error_info* last_error_info;
+    status = napi_get_last_error_info(env, &last_error_info);
+    NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_get_last_error_info");
+
+    // All fields of the `napi_extended_error_info` structure gets reset in
+    // subsequent Node-API function calls on the same `env`. This includes a
+    // call to `napi_is_exception_pending()`. So here it is necessary to make a
+    // copy of the information as the `error_code` field is used later on.
+    memcpy(&last_error_info_copy,
+           last_error_info,
+           sizeof(napi_extended_error_info));
+  }
 
-  const napi_extended_error_info* info;
-  status = napi_get_last_error_info(env, &info);
-  NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_get_last_error_info");
-
-  if (status == napi_ok) {
-    if (info->error_code == napi_pending_exception) {
-      status = napi_get_and_clear_last_exception(env, &error);
-      NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_get_and_clear_last_exception");
-    }
-    else {
-      const char* error_message = info->error_message != nullptr ?
-        info->error_message : "Error in native callback";
-
-      bool isExceptionPending;
-      status = napi_is_exception_pending(env, &isExceptionPending);
-      NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_is_exception_pending");
-
-      if (isExceptionPending) {
-        status = napi_get_and_clear_last_exception(env, &error);
-        NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_get_and_clear_last_exception");
-      }
+  status = napi_is_exception_pending(env, &is_exception_pending);
+  NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_is_exception_pending");
 
-      napi_value message;
-      status = napi_create_string_utf8(
-        env,
-        error_message,
-        std::strlen(error_message),
-        &message);
-      NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_create_string_utf8");
-
-      if (status == napi_ok) {
-        switch (info->error_code) {
-        case napi_object_expected:
-        case napi_string_expected:
-        case napi_boolean_expected:
-        case napi_number_expected:
-          status = napi_create_type_error(env, nullptr, message, &error);
-          break;
-        default:
-          status = napi_create_error(env, nullptr,  message, &error);
-          break;
-        }
-        NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_create_error");
-      }
+  // A pending exception takes precedence over any internal error status.
+  if (is_exception_pending) {
+    status = napi_get_and_clear_last_exception(env, &error);
+    NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_get_and_clear_last_exception");
+  }
+  else {
+    const char* error_message = last_error_info_copy.error_message != nullptr
+                                    ? last_error_info_copy.error_message
+                                    : "Error in native callback";
+
+    napi_value message;
+    status = napi_create_string_utf8(
+      env,
+      error_message,
+      std::strlen(error_message),
+      &message);
+    NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_create_string_utf8");
+
+    switch (last_error_info_copy.error_code) {
+      case napi_object_expected:
+      case napi_string_expected:
+      case napi_boolean_expected:
+      case napi_number_expected:
+        status = napi_create_type_error(env, nullptr, message, &error);
+        break;
+      default:
+        status = napi_create_error(env, nullptr, message, &error);
+        break;
     }
+    NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_create_error");
   }
 
   return Error(env, error);
@@ -2013,14 +2623,82 @@ inline Error::Error() : ObjectReference() {
 
 inline Error::Error(napi_env env, napi_value value) : ObjectReference(env, nullptr) {
   if (value != nullptr) {
+    // Attempting to create a reference on the error object.
+    // If it's not a Object/Function/Symbol, this call will return an error
+    // status.
     napi_status status = napi_create_reference(env, value, 1, &_ref);
 
+    if (status != napi_ok) {
+      napi_value wrappedErrorObj;
+
+      // Create an error object
+      status = napi_create_object(env, &wrappedErrorObj);
+      NAPI_FATAL_IF_FAILED(status, "Error::Error", "napi_create_object");
+
+      // property flag that we attach to show the error object is wrapped
+      napi_property_descriptor wrapObjFlag = {
+          ERROR_WRAP_VALUE(),  // Unique GUID identifier since Symbol isn't a
+                               // viable option
+          nullptr,
+          nullptr,
+          nullptr,
+          nullptr,
+          Value::From(env, value),
+          napi_enumerable,
+          nullptr};
+
+      status = napi_define_properties(env, wrappedErrorObj, 1, &wrapObjFlag);
+      NAPI_FATAL_IF_FAILED(status, "Error::Error", "napi_define_properties");
+
+      // Create a reference on the newly wrapped object
+      status = napi_create_reference(env, wrappedErrorObj, 1, &_ref);
+    }
+
     // Avoid infinite recursion in the failure case.
-    // Don't try to construct & throw another Error instance.
     NAPI_FATAL_IF_FAILED(status, "Error::Error", "napi_create_reference");
   }
 }
 
+inline Object Error::Value() const {
+  if (_ref == nullptr) {
+    return Object(_env, nullptr);
+  }
+
+  napi_value refValue;
+  napi_status status = napi_get_reference_value(_env, _ref, &refValue);
+  NAPI_THROW_IF_FAILED(_env, status, Object());
+
+  napi_valuetype type;
+  status = napi_typeof(_env, refValue, &type);
+  NAPI_THROW_IF_FAILED(_env, status, Object());
+
+  // If refValue isn't a symbol, then we proceed to whether the refValue has the
+  // wrapped error flag
+  if (type != napi_symbol) {
+    // We are checking if the object is wrapped
+    bool isWrappedObject = false;
+
+    status = napi_has_property(_env,
+                               refValue,
+                               String::From(_env, ERROR_WRAP_VALUE()),
+                               &isWrappedObject);
+
+    // Don't care about status
+    if (isWrappedObject) {
+      napi_value unwrappedValue;
+      status = napi_get_property(_env,
+                                 refValue,
+                                 String::From(_env, ERROR_WRAP_VALUE()),
+                                 &unwrappedValue);
+      NAPI_THROW_IF_FAILED(_env, status, Object());
+
+      return Object(_env, unwrappedValue);
+    }
+  }
+
+  return Object(_env, refValue);
+}
+
 inline Error::Error(Error&& other) : ObjectReference(std::move(other)) {
 }
 
@@ -2032,7 +2710,7 @@ inline Error& Error::operator =(Error&& other) {
 inline Error::Error(const Error& other) : ObjectReference(other) {
 }
 
-inline Error& Error::operator =(Error& other) {
+inline Error& Error::operator =(const Error& other) {
   Reset();
 
   _env = other.Env();
@@ -2058,21 +2736,55 @@ inline const std::string& Error::Message() const NAPI_NOEXCEPT {
       // the std::string::operator=, because this method may not throw.
     }
 #else // NAPI_CPP_EXCEPTIONS
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+    Napi::Value message_val;
+    if (Get("message").UnwrapTo(&message_val)) {
+      _message = message_val.As<String>();
+    }
+#else
     _message = Get("message").As<String>();
+#endif
 #endif // NAPI_CPP_EXCEPTIONS
   }
   return _message;
 }
 
+// we created an object on the &_ref
 inline void Error::ThrowAsJavaScriptException() const {
   HandleScope scope(_env);
   if (!IsEmpty()) {
-
+#ifdef NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS
+    bool pendingException = false;
+
+    // check if there is already a pending exception. If so don't try to throw a
+    // new one as that is not allowed/possible
+    napi_status status = napi_is_exception_pending(_env, &pendingException);
+
+    if ((status != napi_ok) ||
+        ((status == napi_ok) && (pendingException == false))) {
+      // We intentionally don't use `NAPI_THROW_*` macros here to ensure
+      // that there is no possible recursion as `ThrowAsJavaScriptException`
+      // is part of `NAPI_THROW_*` macro definition for noexcept.
+
+      status = napi_throw(_env, Value());
+
+      if (status == napi_pending_exception) {
+        // The environment must be terminating as we checked earlier and there
+        // was no pending exception. In this case continuing will result
+        // in a fatal error and there is nothing the author has done incorrectly
+        // in their code that is worth flagging through a fatal error
+        return;
+      }
+    } else {
+      status = napi_pending_exception;
+    }
+#else
     // We intentionally don't use `NAPI_THROW_*` macros here to ensure
     // that there is no possible recursion as `ThrowAsJavaScriptException`
     // is part of `NAPI_THROW_*` macro definition for noexcept.
 
     napi_status status = napi_throw(_env, Value());
+#endif
 
 #ifdef NAPI_CPP_EXCEPTIONS
     if (status != napi_ok) {
@@ -2092,6 +2804,10 @@ inline const char* Error::what() const NAPI_NOEXCEPT {
 
 #endif // NAPI_CPP_EXCEPTIONS
 
+inline const char* Error::ERROR_WRAP_VALUE() NAPI_NOEXCEPT {
+  return "4bda9e7e-4913-4dbc-95de-891cbf66598e-errorVal";
+}
+
 template <typename TError>
 inline TError Error::New(napi_env env,
                          const char* message,
@@ -2250,18 +2966,18 @@ inline T Reference<T>::Value() const {
 }
 
 template <typename T>
-inline uint32_t Reference<T>::Ref() {
+inline uint32_t Reference<T>::Ref() const {
   uint32_t result;
   napi_status status = napi_reference_ref(_env, _ref, &result);
-  NAPI_THROW_IF_FAILED(_env, status, 1);
+  NAPI_THROW_IF_FAILED(_env, status, 0);
   return result;
 }
 
 template <typename T>
-inline uint32_t Reference<T>::Unref() {
+inline uint32_t Reference<T>::Unref() const {
   uint32_t result;
   napi_status status = napi_reference_unref(_env, _ref, &result);
-  NAPI_THROW_IF_FAILED(_env, status, 1);
+  NAPI_THROW_IF_FAILED(_env, status, 0);
   return result;
 }
 
@@ -2349,99 +3065,150 @@ inline ObjectReference::ObjectReference(const ObjectReference& other)
   : Reference<Object>(other) {
 }
 
-inline Napi::Value ObjectReference::Get(const char* utf8name) const {
+inline MaybeOrValue<Napi::Value> ObjectReference::Get(
+    const char* utf8name) const {
   EscapableHandleScope scope(_env);
-  return scope.Escape(Value().Get(utf8name));
+  MaybeOrValue<Napi::Value> result = Value().Get(utf8name);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
+  if (scope.Env().IsExceptionPending()) {
+    return Value();
+  }
+  return scope.Escape(result);
+#endif
 }
 
-inline Napi::Value ObjectReference::Get(const std::string& utf8name) const {
+inline MaybeOrValue<Napi::Value> ObjectReference::Get(
+    const std::string& utf8name) const {
   EscapableHandleScope scope(_env);
-  return scope.Escape(Value().Get(utf8name));
+  MaybeOrValue<Napi::Value> result = Value().Get(utf8name);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
+  if (scope.Env().IsExceptionPending()) {
+    return Value();
+  }
+  return scope.Escape(result);
+#endif
 }
 
-inline void ObjectReference::Set(const char* utf8name, napi_value value) {
+inline MaybeOrValue<bool> ObjectReference::Set(const char* utf8name,
+                                               napi_value value) const {
   HandleScope scope(_env);
-  Value().Set(utf8name, value);
+  return Value().Set(utf8name, value);
 }
 
-inline void ObjectReference::Set(const char* utf8name, Napi::Value value) {
+inline MaybeOrValue<bool> ObjectReference::Set(const char* utf8name,
+                                               Napi::Value value) const {
   HandleScope scope(_env);
-  Value().Set(utf8name, value);
+  return Value().Set(utf8name, value);
 }
 
-inline void ObjectReference::Set(const char* utf8name, const char* utf8value) {
+inline MaybeOrValue<bool> ObjectReference::Set(const char* utf8name,
+                                               const char* utf8value) const {
   HandleScope scope(_env);
-  Value().Set(utf8name, utf8value);
+  return Value().Set(utf8name, utf8value);
 }
 
-inline void ObjectReference::Set(const char* utf8name, bool boolValue) {
+inline MaybeOrValue<bool> ObjectReference::Set(const char* utf8name,
+                                               bool boolValue) const {
   HandleScope scope(_env);
-  Value().Set(utf8name, boolValue);
+  return Value().Set(utf8name, boolValue);
 }
 
-inline void ObjectReference::Set(const char* utf8name, double numberValue) {
+inline MaybeOrValue<bool> ObjectReference::Set(const char* utf8name,
+                                               double numberValue) const {
   HandleScope scope(_env);
-  Value().Set(utf8name, numberValue);
+  return Value().Set(utf8name, numberValue);
 }
 
-inline void ObjectReference::Set(const std::string& utf8name, napi_value value) {
+inline MaybeOrValue<bool> ObjectReference::Set(const std::string& utf8name,
+                                               napi_value value) const {
   HandleScope scope(_env);
-  Value().Set(utf8name, value);
+  return Value().Set(utf8name, value);
 }
 
-inline void ObjectReference::Set(const std::string& utf8name, Napi::Value value) {
+inline MaybeOrValue<bool> ObjectReference::Set(const std::string& utf8name,
+                                               Napi::Value value) const {
   HandleScope scope(_env);
-  Value().Set(utf8name, value);
+  return Value().Set(utf8name, value);
 }
 
-inline void ObjectReference::Set(const std::string& utf8name, std::string& utf8value) {
+inline MaybeOrValue<bool> ObjectReference::Set(const std::string& utf8name,
+                                               std::string& utf8value) const {
   HandleScope scope(_env);
-  Value().Set(utf8name, utf8value);
+  return Value().Set(utf8name, utf8value);
 }
 
-inline void ObjectReference::Set(const std::string& utf8name, bool boolValue) {
+inline MaybeOrValue<bool> ObjectReference::Set(const std::string& utf8name,
+                                               bool boolValue) const {
   HandleScope scope(_env);
-  Value().Set(utf8name, boolValue);
+  return Value().Set(utf8name, boolValue);
 }
 
-inline void ObjectReference::Set(const std::string& utf8name, double numberValue) {
+inline MaybeOrValue<bool> ObjectReference::Set(const std::string& utf8name,
+                                               double numberValue) const {
   HandleScope scope(_env);
-  Value().Set(utf8name, numberValue);
+  return Value().Set(utf8name, numberValue);
 }
 
-inline Napi::Value ObjectReference::Get(uint32_t index) const {
+inline MaybeOrValue<Napi::Value> ObjectReference::Get(uint32_t index) const {
   EscapableHandleScope scope(_env);
-  return scope.Escape(Value().Get(index));
+  MaybeOrValue<Napi::Value> result = Value().Get(index);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
+  if (scope.Env().IsExceptionPending()) {
+    return Value();
+  }
+  return scope.Escape(result);
+#endif
 }
 
-inline void ObjectReference::Set(uint32_t index, napi_value value) {
+inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
+                                               napi_value value) const {
   HandleScope scope(_env);
-  Value().Set(index, value);
+  return Value().Set(index, value);
 }
 
-inline void ObjectReference::Set(uint32_t index, Napi::Value value) {
+inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
+                                               Napi::Value value) const {
   HandleScope scope(_env);
-  Value().Set(index, value);
+  return Value().Set(index, value);
 }
 
-inline void ObjectReference::Set(uint32_t index, const char* utf8value) {
+inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
+                                               const char* utf8value) const {
   HandleScope scope(_env);
-  Value().Set(index, utf8value);
+  return Value().Set(index, utf8value);
 }
 
-inline void ObjectReference::Set(uint32_t index, const std::string& utf8value) {
+inline MaybeOrValue<bool> ObjectReference::Set(
+    uint32_t index, const std::string& utf8value) const {
   HandleScope scope(_env);
-  Value().Set(index, utf8value);
+  return Value().Set(index, utf8value);
 }
 
-inline void ObjectReference::Set(uint32_t index, bool boolValue) {
+inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
+                                               bool boolValue) const {
   HandleScope scope(_env);
-  Value().Set(index, boolValue);
+  return Value().Set(index, boolValue);
 }
 
-inline void ObjectReference::Set(uint32_t index, double numberValue) {
+inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
+                                               double numberValue) const {
   HandleScope scope(_env);
-  Value().Set(index, numberValue);
+  return Value().Set(index, numberValue);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -2473,105 +3240,200 @@ inline FunctionReference& FunctionReference::operator =(FunctionReference&& othe
   return *this;
 }
 
-inline Napi::Value FunctionReference::operator ()(
+inline MaybeOrValue<Napi::Value> FunctionReference::operator()(
     const std::initializer_list<napi_value>& args) const {
   EscapableHandleScope scope(_env);
-  return scope.Escape(Value()(args));
+  MaybeOrValue<Napi::Value> result = Value()(args);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
+  if (scope.Env().IsExceptionPending()) {
+    return Value();
+  }
+  return scope.Escape(result);
+#endif
 }
 
-inline Napi::Value FunctionReference::Call(const std::initializer_list<napi_value>& args) const {
+inline MaybeOrValue<Napi::Value> FunctionReference::Call(
+    const std::initializer_list<napi_value>& args) const {
   EscapableHandleScope scope(_env);
-  Napi::Value result = Value().Call(args);
+  MaybeOrValue<Napi::Value> result = Value().Call(args);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
   if (scope.Env().IsExceptionPending()) {
     return Value();
   }
   return scope.Escape(result);
+#endif
 }
 
-inline Napi::Value FunctionReference::Call(const std::vector<napi_value>& args) const {
+inline MaybeOrValue<Napi::Value> FunctionReference::Call(
+    const std::vector<napi_value>& args) const {
   EscapableHandleScope scope(_env);
-  Napi::Value result = Value().Call(args);
+  MaybeOrValue<Napi::Value> result = Value().Call(args);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
   if (scope.Env().IsExceptionPending()) {
     return Value();
   }
   return scope.Escape(result);
+#endif
 }
 
-inline Napi::Value FunctionReference::Call(
+inline MaybeOrValue<Napi::Value> FunctionReference::Call(
     napi_value recv, const std::initializer_list<napi_value>& args) const {
   EscapableHandleScope scope(_env);
-  Napi::Value result = Value().Call(recv, args);
+  MaybeOrValue<Napi::Value> result = Value().Call(recv, args);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
   if (scope.Env().IsExceptionPending()) {
     return Value();
   }
   return scope.Escape(result);
+#endif
 }
 
-inline Napi::Value FunctionReference::Call(
+inline MaybeOrValue<Napi::Value> FunctionReference::Call(
     napi_value recv, const std::vector<napi_value>& args) const {
   EscapableHandleScope scope(_env);
-  Napi::Value result = Value().Call(recv, args);
+  MaybeOrValue<Napi::Value> result = Value().Call(recv, args);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
   if (scope.Env().IsExceptionPending()) {
     return Value();
   }
   return scope.Escape(result);
+#endif
 }
 
-inline Napi::Value FunctionReference::Call(
+inline MaybeOrValue<Napi::Value> FunctionReference::Call(
     napi_value recv, size_t argc, const napi_value* args) const {
   EscapableHandleScope scope(_env);
-  Napi::Value result = Value().Call(recv, argc, args);
+  MaybeOrValue<Napi::Value> result = Value().Call(recv, argc, args);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
   if (scope.Env().IsExceptionPending()) {
     return Value();
   }
   return scope.Escape(result);
+#endif
 }
 
-inline Napi::Value FunctionReference::MakeCallback(
+inline MaybeOrValue<Napi::Value> FunctionReference::MakeCallback(
     napi_value recv,
     const std::initializer_list<napi_value>& args,
     napi_async_context context) const {
   EscapableHandleScope scope(_env);
-  Napi::Value result = Value().MakeCallback(recv, args, context);
+  MaybeOrValue<Napi::Value> result = Value().MakeCallback(recv, args, context);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+
+  return result;
+#else
   if (scope.Env().IsExceptionPending()) {
     return Value();
   }
   return scope.Escape(result);
+#endif
 }
 
-inline Napi::Value FunctionReference::MakeCallback(
+inline MaybeOrValue<Napi::Value> FunctionReference::MakeCallback(
     napi_value recv,
     const std::vector<napi_value>& args,
     napi_async_context context) const {
   EscapableHandleScope scope(_env);
-  Napi::Value result = Value().MakeCallback(recv, args, context);
+  MaybeOrValue<Napi::Value> result = Value().MakeCallback(recv, args, context);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
   if (scope.Env().IsExceptionPending()) {
     return Value();
   }
   return scope.Escape(result);
+#endif
 }
 
-inline Napi::Value FunctionReference::MakeCallback(
+inline MaybeOrValue<Napi::Value> FunctionReference::MakeCallback(
     napi_value recv,
     size_t argc,
     const napi_value* args,
     napi_async_context context) const {
   EscapableHandleScope scope(_env);
-  Napi::Value result = Value().MakeCallback(recv, argc, args, context);
+  MaybeOrValue<Napi::Value> result =
+      Value().MakeCallback(recv, argc, args, context);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()));
+  }
+  return result;
+#else
   if (scope.Env().IsExceptionPending()) {
     return Value();
   }
   return scope.Escape(result);
+#endif
 }
 
-inline Object FunctionReference::New(const std::initializer_list<napi_value>& args) const {
+inline MaybeOrValue<Object> FunctionReference::New(
+    const std::initializer_list<napi_value>& args) const {
   EscapableHandleScope scope(_env);
-  return scope.Escape(Value().New(args)).As<Object>();
+  MaybeOrValue<Object> result = Value().New(args);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()).As<Object>());
+  }
+  return result;
+#else
+  if (scope.Env().IsExceptionPending()) {
+    return Object();
+  }
+  return scope.Escape(result).As<Object>();
+#endif
 }
 
-inline Object FunctionReference::New(const std::vector<napi_value>& args) const {
+inline MaybeOrValue<Object> FunctionReference::New(
+    const std::vector<napi_value>& args) const {
   EscapableHandleScope scope(_env);
-  return scope.Escape(Value().New(args)).As<Object>();
+  MaybeOrValue<Object> result = Value().New(args);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()).As<Object>());
+  }
+  return result;
+#else
+  if (scope.Env().IsExceptionPending()) {
+    return Object();
+  }
+  return scope.Escape(result).As<Object>();
+#endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -2644,6 +3506,91 @@ inline void CallbackInfo::SetData(void* data) {
 // PropertyDescriptor class
 ////////////////////////////////////////////////////////////////////////////////
 
+template <typename PropertyDescriptor::GetterCallback Getter>
+PropertyDescriptor
+PropertyDescriptor::Accessor(const char* utf8name,
+                             napi_property_attributes attributes,
+                             void* data) {
+  napi_property_descriptor desc = napi_property_descriptor();
+
+  desc.utf8name = utf8name;
+  desc.getter = details::TemplatedCallback<Getter>;
+  desc.attributes = attributes;
+  desc.data = data;
+
+  return desc;
+}
+
+template <typename PropertyDescriptor::GetterCallback Getter>
+PropertyDescriptor
+PropertyDescriptor::Accessor(const std::string& utf8name,
+                             napi_property_attributes attributes,
+                             void* data) {
+  return Accessor<Getter>(utf8name.c_str(), attributes, data);
+}
+
+template <typename PropertyDescriptor::GetterCallback Getter>
+PropertyDescriptor
+PropertyDescriptor::Accessor(Name name,
+                             napi_property_attributes attributes,
+                             void* data) {
+  napi_property_descriptor desc = napi_property_descriptor();
+
+  desc.name = name;
+  desc.getter = details::TemplatedCallback<Getter>;
+  desc.attributes = attributes;
+  desc.data = data;
+
+  return desc;
+}
+
+template <
+typename PropertyDescriptor::GetterCallback Getter,
+typename PropertyDescriptor::SetterCallback Setter>
+PropertyDescriptor
+PropertyDescriptor::Accessor(const char* utf8name,
+                             napi_property_attributes attributes,
+                             void* data) {
+
+  napi_property_descriptor desc = napi_property_descriptor();
+
+  desc.utf8name = utf8name;
+  desc.getter = details::TemplatedCallback<Getter>;
+  desc.setter = details::TemplatedVoidCallback<Setter>;
+  desc.attributes = attributes;
+  desc.data = data;
+
+  return desc;
+}
+
+template <
+typename PropertyDescriptor::GetterCallback Getter,
+typename PropertyDescriptor::SetterCallback Setter>
+PropertyDescriptor
+PropertyDescriptor::Accessor(const std::string& utf8name,
+                             napi_property_attributes attributes,
+                             void* data) {
+  return Accessor<Getter, Setter>(utf8name.c_str(), attributes, data);
+}
+
+template <
+typename PropertyDescriptor::GetterCallback Getter,
+typename PropertyDescriptor::SetterCallback Setter>
+PropertyDescriptor
+PropertyDescriptor::Accessor(Name name,
+                             napi_property_attributes attributes,
+                             void* data) {
+  napi_property_descriptor desc = napi_property_descriptor();
+
+  desc.name = name;
+  desc.getter = details::TemplatedCallback<Getter>;
+  desc.setter = details::TemplatedVoidCallback<Setter>;
+  desc.attributes = attributes;
+  desc.data = data;
+
+  return desc;
+}
+
 template <typename Getter>
 inline PropertyDescriptor
 PropertyDescriptor::Accessor(Napi::Env env,
@@ -2652,7 +3599,7 @@ PropertyDescriptor::Accessor(Napi::Env env,
                              Getter getter,
                              napi_property_attributes attributes,
                              void* data) {
-  typedef details::CallbackData<Getter, Napi::Value> CbData;
+  using CbData = details::CallbackData<Getter, Napi::Value>;
   auto callbackData = new CbData({ getter, data });
 
   napi_status status = AttachData(env, object, callbackData);
@@ -2690,7 +3637,7 @@ inline PropertyDescriptor PropertyDescriptor::Accessor(Napi::Env env,
                                                        Getter getter,
                                                        napi_property_attributes attributes,
                                                        void* data) {
-  typedef details::CallbackData<Getter, Napi::Value> CbData;
+  using CbData = details::CallbackData<Getter, Napi::Value>;
   auto callbackData = new CbData({ getter, data });
 
   napi_status status = AttachData(env, object, callbackData);
@@ -2719,7 +3666,7 @@ inline PropertyDescriptor PropertyDescriptor::Accessor(Napi::Env env,
                                                        Setter setter,
                                                        napi_property_attributes attributes,
                                                        void* data) {
-  typedef details::AccessorCallbackData<Getter, Setter> CbData;
+  using CbData = details::AccessorCallbackData<Getter, Setter>;
   auto callbackData = new CbData({ getter, setter, data });
 
   napi_status status = AttachData(env, object, callbackData);
@@ -2759,7 +3706,7 @@ inline PropertyDescriptor PropertyDescriptor::Accessor(Napi::Env env,
                                                        Setter setter,
                                                        napi_property_attributes attributes,
                                                        void* data) {
-  typedef details::AccessorCallbackData<Getter, Setter> CbData;
+  using CbData = details::AccessorCallbackData<Getter, Setter>;
   auto callbackData = new CbData({ getter, setter, data });
 
   napi_status status = AttachData(env, object, callbackData);
@@ -2871,45 +3818,379 @@ inline PropertyDescriptor::operator const napi_property_descriptor&() const {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ObjectWrap<T> class
+// InstanceWrap<T> class
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename T>
-inline ObjectWrap<T>::ObjectWrap(const Napi::CallbackInfo& callbackInfo) {
-  napi_env env = callbackInfo.Env();
-  napi_value wrapper = callbackInfo.This();
+inline void InstanceWrap<T>::AttachPropData(napi_env env,
+                                       napi_value value,
+                                       const napi_property_descriptor* prop) {
   napi_status status;
-  napi_ref ref;
-  T* instance = static_cast<T*>(this);
-  status = napi_wrap(env, wrapper, instance, FinalizeCallback, nullptr, &ref);
-  NAPI_THROW_IF_FAILED_VOID(env, status);
-
-  Reference<Object>* instanceRef = instance;
-  *instanceRef = Reference<Object>(env, ref);
+  if (!(prop->attributes & napi_static)) {
+    if (prop->method == T::InstanceVoidMethodCallbackWrapper) {
+      status = Napi::details::AttachData(env,
+                    value,
+                    static_cast<InstanceVoidMethodCallbackData*>(prop->data));
+      NAPI_THROW_IF_FAILED_VOID(env, status);
+    } else if (prop->method == T::InstanceMethodCallbackWrapper) {
+      status = Napi::details::AttachData(env,
+                        value,
+                        static_cast<InstanceMethodCallbackData*>(prop->data));
+      NAPI_THROW_IF_FAILED_VOID(env, status);
+    } else if (prop->getter == T::InstanceGetterCallbackWrapper ||
+        prop->setter == T::InstanceSetterCallbackWrapper) {
+      status = Napi::details::AttachData(env,
+                          value,
+                          static_cast<InstanceAccessorCallbackData*>(prop->data));
+      NAPI_THROW_IF_FAILED_VOID(env, status);
+    }
+  }
 }
 
-template<typename T>
-inline T* ObjectWrap<T>::Unwrap(Object wrapper) {
-  T* unwrapped;
-  napi_status status = napi_unwrap(wrapper.Env(), wrapper, reinterpret_cast<void**>(&unwrapped));
-  NAPI_THROW_IF_FAILED(wrapper.Env(), status, nullptr);
-  return unwrapped;
+template <typename T>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
+    const char* utf8name,
+    InstanceVoidMethodCallback method,
+    napi_property_attributes attributes,
+    void* data) {
+  InstanceVoidMethodCallbackData* callbackData =
+    new InstanceVoidMethodCallbackData({ method, data});
+
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.utf8name = utf8name;
+  desc.method = T::InstanceVoidMethodCallbackWrapper;
+  desc.data = callbackData;
+  desc.attributes = attributes;
+  return desc;
 }
 
 template <typename T>
-inline Function
-ObjectWrap<T>::DefineClass(Napi::Env env,
-                           const char* utf8name,
-                           const size_t props_count,
-                           const napi_property_descriptor* descriptors,
-                           void* data) {
-  napi_status status;
-  std::vector<napi_property_descriptor> props(props_count);
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
+    const char* utf8name,
+    InstanceMethodCallback method,
+    napi_property_attributes attributes,
+    void* data) {
+  InstanceMethodCallbackData* callbackData = new InstanceMethodCallbackData({ method, data });
 
-  // We copy the descriptors to a local array because before defining the class
-  // we must replace static method property descriptors with value property
-  // descriptors such that the value is a function-valued `napi_value` created
-  // with `CreateFunction()`.
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.utf8name = utf8name;
+  desc.method = T::InstanceMethodCallbackWrapper;
+  desc.data = callbackData;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
+    Symbol name,
+    InstanceVoidMethodCallback method,
+    napi_property_attributes attributes,
+    void* data) {
+  InstanceVoidMethodCallbackData* callbackData =
+    new InstanceVoidMethodCallbackData({ method, data});
+
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.name = name;
+  desc.method = T::InstanceVoidMethodCallbackWrapper;
+  desc.data = callbackData;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
+    Symbol name,
+    InstanceMethodCallback method,
+    napi_property_attributes attributes,
+    void* data) {
+  InstanceMethodCallbackData* callbackData = new InstanceMethodCallbackData({ method, data });
+
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.name = name;
+  desc.method = T::InstanceMethodCallbackWrapper;
+  desc.data = callbackData;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+template <typename InstanceWrap<T>::InstanceVoidMethodCallback method>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
+    const char* utf8name,
+    napi_property_attributes attributes,
+    void* data) {
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.utf8name = utf8name;
+  desc.method = details::TemplatedInstanceVoidCallback<T, method>;
+  desc.data = data;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+template <typename InstanceWrap<T>::InstanceMethodCallback method>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
+    const char* utf8name,
+    napi_property_attributes attributes,
+    void* data) {
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.utf8name = utf8name;
+  desc.method = details::TemplatedInstanceCallback<T, method>;
+  desc.data = data;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+template <typename InstanceWrap<T>::InstanceVoidMethodCallback method>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
+    Symbol name,
+    napi_property_attributes attributes,
+    void* data) {
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.name = name;
+  desc.method = details::TemplatedInstanceVoidCallback<T, method>;
+  desc.data = data;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+template <typename InstanceWrap<T>::InstanceMethodCallback method>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
+    Symbol name,
+    napi_property_attributes attributes,
+    void* data) {
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.name = name;
+  desc.method = details::TemplatedInstanceCallback<T, method>;
+  desc.data = data;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceAccessor(
+    const char* utf8name,
+    InstanceGetterCallback getter,
+    InstanceSetterCallback setter,
+    napi_property_attributes attributes,
+    void* data) {
+  InstanceAccessorCallbackData* callbackData =
+    new InstanceAccessorCallbackData({ getter, setter, data });
+
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.utf8name = utf8name;
+  desc.getter = getter != nullptr ? T::InstanceGetterCallbackWrapper : nullptr;
+  desc.setter = setter != nullptr ? T::InstanceSetterCallbackWrapper : nullptr;
+  desc.data = callbackData;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceAccessor(
+    Symbol name,
+    InstanceGetterCallback getter,
+    InstanceSetterCallback setter,
+    napi_property_attributes attributes,
+    void* data) {
+  InstanceAccessorCallbackData* callbackData =
+    new InstanceAccessorCallbackData({ getter, setter, data });
+
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.name = name;
+  desc.getter = getter != nullptr ? T::InstanceGetterCallbackWrapper : nullptr;
+  desc.setter = setter != nullptr ? T::InstanceSetterCallbackWrapper : nullptr;
+  desc.data = callbackData;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+template <typename InstanceWrap<T>::InstanceGetterCallback getter,
+          typename InstanceWrap<T>::InstanceSetterCallback setter>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceAccessor(
+    const char* utf8name,
+    napi_property_attributes attributes,
+    void* data) {
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.utf8name = utf8name;
+  desc.getter = details::TemplatedInstanceCallback<T, getter>;
+  desc.setter = This::WrapSetter(This::SetterTag<setter>());
+  desc.data = data;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+template <typename InstanceWrap<T>::InstanceGetterCallback getter,
+          typename InstanceWrap<T>::InstanceSetterCallback setter>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceAccessor(
+    Symbol name,
+    napi_property_attributes attributes,
+    void* data) {
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.name = name;
+  desc.getter = details::TemplatedInstanceCallback<T, getter>;
+  desc.setter = This::WrapSetter(This::SetterTag<setter>());
+  desc.data = data;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceValue(
+    const char* utf8name,
+    Napi::Value value,
+    napi_property_attributes attributes) {
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.utf8name = utf8name;
+  desc.value = value;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceValue(
+    Symbol name,
+    Napi::Value value,
+    napi_property_attributes attributes) {
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.name = name;
+  desc.value = value;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+inline napi_value InstanceWrap<T>::InstanceVoidMethodCallbackWrapper(
+    napi_env env,
+    napi_callback_info info) {
+  return details::WrapCallback([&] {
+    CallbackInfo callbackInfo(env, info);
+    InstanceVoidMethodCallbackData* callbackData =
+      reinterpret_cast<InstanceVoidMethodCallbackData*>(callbackInfo.Data());
+    callbackInfo.SetData(callbackData->data);
+    T* instance = T::Unwrap(callbackInfo.This().As<Object>());
+    auto cb = callbackData->callback;
+    (instance->*cb)(callbackInfo);
+    return nullptr;
+  });
+}
+
+template <typename T>
+inline napi_value InstanceWrap<T>::InstanceMethodCallbackWrapper(
+    napi_env env,
+    napi_callback_info info) {
+  return details::WrapCallback([&] {
+    CallbackInfo callbackInfo(env, info);
+    InstanceMethodCallbackData* callbackData =
+      reinterpret_cast<InstanceMethodCallbackData*>(callbackInfo.Data());
+    callbackInfo.SetData(callbackData->data);
+    T* instance = T::Unwrap(callbackInfo.This().As<Object>());
+    auto cb = callbackData->callback;
+    return (instance->*cb)(callbackInfo);
+  });
+}
+
+template <typename T>
+inline napi_value InstanceWrap<T>::InstanceGetterCallbackWrapper(
+    napi_env env,
+    napi_callback_info info) {
+  return details::WrapCallback([&] {
+    CallbackInfo callbackInfo(env, info);
+    InstanceAccessorCallbackData* callbackData =
+      reinterpret_cast<InstanceAccessorCallbackData*>(callbackInfo.Data());
+    callbackInfo.SetData(callbackData->data);
+    T* instance = T::Unwrap(callbackInfo.This().As<Object>());
+    auto cb = callbackData->getterCallback;
+    return (instance->*cb)(callbackInfo);
+  });
+}
+
+template <typename T>
+inline napi_value InstanceWrap<T>::InstanceSetterCallbackWrapper(
+    napi_env env,
+    napi_callback_info info) {
+  return details::WrapCallback([&] {
+    CallbackInfo callbackInfo(env, info);
+    InstanceAccessorCallbackData* callbackData =
+      reinterpret_cast<InstanceAccessorCallbackData*>(callbackInfo.Data());
+    callbackInfo.SetData(callbackData->data);
+    T* instance = T::Unwrap(callbackInfo.This().As<Object>());
+    auto cb = callbackData->setterCallback;
+    (instance->*cb)(callbackInfo, callbackInfo[0]);
+    return nullptr;
+  });
+}
+
+template <typename T>
+template <typename InstanceWrap<T>::InstanceSetterCallback method>
+inline napi_value InstanceWrap<T>::WrappedMethod(
+    napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
+  return details::WrapCallback([&] {
+    const CallbackInfo cbInfo(env, info);
+    T* instance = T::Unwrap(cbInfo.This().As<Object>());
+    (instance->*method)(cbInfo, cbInfo[0]);
+    return nullptr;
+  });
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ObjectWrap<T> class
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+inline ObjectWrap<T>::ObjectWrap(const Napi::CallbackInfo& callbackInfo) {
+  napi_env env = callbackInfo.Env();
+  napi_value wrapper = callbackInfo.This();
+  napi_status status;
+  napi_ref ref;
+  T* instance = static_cast<T*>(this);
+  status = napi_wrap(env, wrapper, instance, FinalizeCallback, nullptr, &ref);
+  NAPI_THROW_IF_FAILED_VOID(env, status);
+
+  Reference<Object>* instanceRef = instance;
+  *instanceRef = Reference<Object>(env, ref);
+}
+
+template <typename T>
+inline ObjectWrap<T>::~ObjectWrap() {
+  // If the JS object still exists at this point, remove the finalizer added
+  // through `napi_wrap()`.
+  if (!IsEmpty()) {
+    Object object = Value();
+    // It is not valid to call `napi_remove_wrap()` with an empty `object`.
+    // This happens e.g. during garbage collection.
+    if (!object.IsEmpty() && _construction_failed) {
+      napi_remove_wrap(Env(), object, nullptr);
+    }
+  }
+}
+
+template<typename T>
+inline T* ObjectWrap<T>::Unwrap(Object wrapper) {
+  void* unwrapped;
+  napi_status status = napi_unwrap(wrapper.Env(), wrapper, &unwrapped);
+  NAPI_THROW_IF_FAILED(wrapper.Env(), status, nullptr);
+  return static_cast<T*>(unwrapped);
+}
+
+template <typename T>
+inline Function
+ObjectWrap<T>::DefineClass(Napi::Env env,
+                           const char* utf8name,
+                           const size_t props_count,
+                           const napi_property_descriptor* descriptors,
+                           void* data) {
+  napi_status status;
+  std::vector<napi_property_descriptor> props(props_count);
+
+  // We copy the descriptors to a local array because before defining the class
+  // we must replace static method property descriptors with value property
+  // descriptors such that the value is a function-valued `napi_value` created
+  // with `CreateFunction()`.
   //
   // This replacement could be made for instance methods as well, but V8 aborts
   // if we do that, because it expects methods defined on the prototype template
@@ -2919,19 +4200,19 @@ ObjectWrap<T>::DefineClass(Napi::Env env,
     napi_property_descriptor* prop = &props[index];
     if (prop->method == T::StaticMethodCallbackWrapper) {
       status = CreateFunction(env,
-               utf8name,
-               prop->method,
-               static_cast<StaticMethodCallbackData*>(prop->data),
+                             utf8name,
+                             prop->method,
+                             static_cast<StaticMethodCallbackData*>(prop->data),
                &(prop->value));
       NAPI_THROW_IF_FAILED(env, status, Function());
       prop->method = nullptr;
       prop->data = nullptr;
     } else if (prop->method == T::StaticVoidMethodCallbackWrapper) {
       status = CreateFunction(env,
-               utf8name,
-               prop->method,
-               static_cast<StaticVoidMethodCallbackData*>(prop->data),
-               &(prop->value));
+                         utf8name,
+                         prop->method,
+                         static_cast<StaticVoidMethodCallbackData*>(prop->data),
+                         &(prop->value));
       NAPI_THROW_IF_FAILED(env, status, Function());
       prop->method = nullptr;
       prop->data = nullptr;
@@ -2961,24 +4242,10 @@ ObjectWrap<T>::DefineClass(Napi::Env env,
                           value,
                           static_cast<StaticAccessorCallbackData*>(prop->data));
       NAPI_THROW_IF_FAILED(env, status, Function());
-    } else if (prop->getter == T::InstanceGetterCallbackWrapper ||
-        prop->setter == T::InstanceSetterCallbackWrapper) {
-      status = Napi::details::AttachData(env,
-                          value,
-                          static_cast<InstanceAccessorCallbackData*>(prop->data));
-      NAPI_THROW_IF_FAILED(env, status, Function());
-    } else if (prop->method != nullptr && !(prop->attributes & napi_static)) {
-      if (prop->method == T::InstanceVoidMethodCallbackWrapper) {
-        status = Napi::details::AttachData(env,
-                      value,
-                      static_cast<InstanceVoidMethodCallbackData*>(prop->data));
-        NAPI_THROW_IF_FAILED(env, status, Function());
-      } else if (prop->method == T::InstanceMethodCallbackWrapper) {
-        status = Napi::details::AttachData(env,
-                          value,
-                          static_cast<InstanceMethodCallbackData*>(prop->data));
-        NAPI_THROW_IF_FAILED(env, status, Function());
-      }
+    } else {
+      // InstanceWrap<T>::AttachPropData is responsible for attaching the data
+      // of instance methods and accessors.
+      T::AttachPropData(env, value, prop);
     }
   }
 
@@ -3076,144 +4343,128 @@ inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
+template <typename ObjectWrap<T>::StaticVoidMethodCallback method>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
     const char* utf8name,
-    StaticGetterCallback getter,
-    StaticSetterCallback setter,
     napi_property_attributes attributes,
     void* data) {
-  StaticAccessorCallbackData* callbackData =
-    new StaticAccessorCallbackData({ getter, setter, data });
-
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.getter = getter != nullptr ? T::StaticGetterCallbackWrapper : nullptr;
-  desc.setter = setter != nullptr ? T::StaticSetterCallbackWrapper : nullptr;
-  desc.data = callbackData;
+  desc.method = details::TemplatedVoidCallback<method>;
+  desc.data = data;
   desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
+template <typename ObjectWrap<T>::StaticVoidMethodCallback method>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
     Symbol name,
-    StaticGetterCallback getter,
-    StaticSetterCallback setter,
     napi_property_attributes attributes,
     void* data) {
-  StaticAccessorCallbackData* callbackData =
-    new StaticAccessorCallbackData({ getter, setter, data });
-
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.getter = getter != nullptr ? T::StaticGetterCallbackWrapper : nullptr;
-  desc.setter = setter != nullptr ? T::StaticSetterCallbackWrapper : nullptr;
-  desc.data = callbackData;
+  desc.method = details::TemplatedVoidCallback<method>;
+  desc.data = data;
   desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
+template <typename ObjectWrap<T>::StaticMethodCallback method>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
     const char* utf8name,
-    InstanceVoidMethodCallback method,
     napi_property_attributes attributes,
     void* data) {
-  InstanceVoidMethodCallbackData* callbackData =
-    new InstanceVoidMethodCallbackData({ method, data});
-
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.method = T::InstanceVoidMethodCallbackWrapper;
-  desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.method = details::TemplatedCallback<method>;
+  desc.data = data;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
-    const char* utf8name,
-    InstanceMethodCallback method,
+template <typename ObjectWrap<T>::StaticMethodCallback method>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
+    Symbol name,
     napi_property_attributes attributes,
     void* data) {
-  InstanceMethodCallbackData* callbackData = new InstanceMethodCallbackData({ method, data });
-
   napi_property_descriptor desc = napi_property_descriptor();
-  desc.utf8name = utf8name;
-  desc.method = T::InstanceMethodCallbackWrapper;
-  desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.name = name;
+  desc.method = details::TemplatedCallback<method>;
+  desc.data = data;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
-    Symbol name,
-    InstanceVoidMethodCallback method,
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
+    const char* utf8name,
+    StaticGetterCallback getter,
+    StaticSetterCallback setter,
     napi_property_attributes attributes,
     void* data) {
-  InstanceVoidMethodCallbackData* callbackData =
-    new InstanceVoidMethodCallbackData({ method, data});
+  StaticAccessorCallbackData* callbackData =
+    new StaticAccessorCallbackData({ getter, setter, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
-  desc.name = name;
-  desc.method = T::InstanceVoidMethodCallbackWrapper;
+  desc.utf8name = utf8name;
+  desc.getter = getter != nullptr ? T::StaticGetterCallbackWrapper : nullptr;
+  desc.setter = setter != nullptr ? T::StaticSetterCallbackWrapper : nullptr;
   desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
     Symbol name,
-    InstanceMethodCallback method,
+    StaticGetterCallback getter,
+    StaticSetterCallback setter,
     napi_property_attributes attributes,
     void* data) {
-  InstanceMethodCallbackData* callbackData = new InstanceMethodCallbackData({ method, data });
+  StaticAccessorCallbackData* callbackData =
+    new StaticAccessorCallbackData({ getter, setter, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.method = T::InstanceMethodCallbackWrapper;
+  desc.getter = getter != nullptr ? T::StaticGetterCallbackWrapper : nullptr;
+  desc.setter = setter != nullptr ? T::StaticSetterCallbackWrapper : nullptr;
   desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceAccessor(
+template <typename ObjectWrap<T>::StaticGetterCallback getter,
+          typename ObjectWrap<T>::StaticSetterCallback setter>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
     const char* utf8name,
-    InstanceGetterCallback getter,
-    InstanceSetterCallback setter,
     napi_property_attributes attributes,
     void* data) {
-  InstanceAccessorCallbackData* callbackData =
-    new InstanceAccessorCallbackData({ getter, setter, data });
-
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.getter = getter != nullptr ? T::InstanceGetterCallbackWrapper : nullptr;
-  desc.setter = setter != nullptr ? T::InstanceSetterCallbackWrapper : nullptr;
-  desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.getter = details::TemplatedCallback<getter>;
+  desc.setter = This::WrapStaticSetter(This::StaticSetterTag<setter>());
+  desc.data = data;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceAccessor(
+template <typename ObjectWrap<T>::StaticGetterCallback getter,
+          typename ObjectWrap<T>::StaticSetterCallback setter>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
     Symbol name,
-    InstanceGetterCallback getter,
-    InstanceSetterCallback setter,
     napi_property_attributes attributes,
     void* data) {
-  InstanceAccessorCallbackData* callbackData =
-    new InstanceAccessorCallbackData({ getter, setter, data });
-
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.getter = getter != nullptr ? T::InstanceGetterCallbackWrapper : nullptr;
-  desc.setter = setter != nullptr ? T::InstanceSetterCallbackWrapper : nullptr;
-  desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.getter = details::TemplatedCallback<getter>;
+  desc.setter = This::WrapStaticSetter(This::StaticSetterTag<setter>());
+  desc.data = data;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
@@ -3238,28 +4489,16 @@ inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticValue(Symbol name,
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceValue(
-    const char* utf8name,
-    Napi::Value value,
-    napi_property_attributes attributes) {
-  napi_property_descriptor desc = napi_property_descriptor();
-  desc.utf8name = utf8name;
-  desc.value = value;
-  desc.attributes = attributes;
-  return desc;
+inline Value ObjectWrap<T>::OnCalledAsFunction(
+    const Napi::CallbackInfo& callbackInfo) {
+  NAPI_THROW(
+      TypeError::New(callbackInfo.Env(),
+                     "Class constructors cannot be invoked without 'new'"),
+      Napi::Value());
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceValue(
-    Symbol name,
-    Napi::Value value,
-    napi_property_attributes attributes) {
-  napi_property_descriptor desc = napi_property_descriptor();
-  desc.name = name;
-  desc.value = value;
-  desc.attributes = attributes;
-  return desc;
-}
+inline void ObjectWrap<T>::Finalize(Napi::Env /*env*/) {}
 
 template <typename T>
 inline napi_value ObjectWrap<T>::ConstructorCallbackWrapper(
@@ -3271,14 +4510,25 @@ inline napi_value ObjectWrap<T>::ConstructorCallbackWrapper(
 
   bool isConstructCall = (new_target != nullptr);
   if (!isConstructCall) {
-    napi_throw_type_error(env, nullptr, "Class constructors cannot be invoked without 'new'");
-    return nullptr;
+    return details::WrapCallback(
+        [&] { return T::OnCalledAsFunction(CallbackInfo(env, info)); });
   }
 
-  T* instance;
   napi_value wrapper = details::WrapCallback([&] {
     CallbackInfo callbackInfo(env, info);
-    instance = new T(callbackInfo);
+    T* instance = new T(callbackInfo);
+#ifdef NAPI_CPP_EXCEPTIONS
+    instance->_construction_failed = false;
+#else
+    if (callbackInfo.Env().IsExceptionPending()) {
+      // We need to clear the exception so that removing the wrap might work.
+      Error e = callbackInfo.Env().GetAndClearPendingException();
+      delete instance;
+      e.ThrowAsJavaScriptException();
+    } else {
+      instance->_construction_failed = false;
+    }
+# endif  // NAPI_CPP_EXCEPTIONS
     return callbackInfo.This();
   });
 
@@ -3340,73 +4590,24 @@ inline napi_value ObjectWrap<T>::StaticSetterCallbackWrapper(
 }
 
 template <typename T>
-inline napi_value ObjectWrap<T>::InstanceVoidMethodCallbackWrapper(
-    napi_env env,
-    napi_callback_info info) {
-  return details::WrapCallback([&] {
-    CallbackInfo callbackInfo(env, info);
-    InstanceVoidMethodCallbackData* callbackData =
-      reinterpret_cast<InstanceVoidMethodCallbackData*>(callbackInfo.Data());
-    callbackInfo.SetData(callbackData->data);
-    T* instance = Unwrap(callbackInfo.This().As<Object>());
-    auto cb = callbackData->callback;
-    (instance->*cb)(callbackInfo);
-    return nullptr;
-  });
-}
-
-template <typename T>
-inline napi_value ObjectWrap<T>::InstanceMethodCallbackWrapper(
-    napi_env env,
-    napi_callback_info info) {
-  return details::WrapCallback([&] {
-    CallbackInfo callbackInfo(env, info);
-    InstanceMethodCallbackData* callbackData =
-      reinterpret_cast<InstanceMethodCallbackData*>(callbackInfo.Data());
-    callbackInfo.SetData(callbackData->data);
-    T* instance = Unwrap(callbackInfo.This().As<Object>());
-    auto cb = callbackData->callback;
-    return (instance->*cb)(callbackInfo);
-  });
-}
-
-template <typename T>
-inline napi_value ObjectWrap<T>::InstanceGetterCallbackWrapper(
-    napi_env env,
-    napi_callback_info info) {
-  return details::WrapCallback([&] {
-    CallbackInfo callbackInfo(env, info);
-    InstanceAccessorCallbackData* callbackData =
-      reinterpret_cast<InstanceAccessorCallbackData*>(callbackInfo.Data());
-    callbackInfo.SetData(callbackData->data);
-    T* instance = Unwrap(callbackInfo.This().As<Object>());
-    auto cb = callbackData->getterCallback;
-    return (instance->*cb)(callbackInfo);
-  });
+inline void ObjectWrap<T>::FinalizeCallback(napi_env env, void* data, void* /*hint*/) {
+  HandleScope scope(env);
+  T* instance = static_cast<T*>(data);
+  instance->Finalize(Napi::Env(env));
+  delete instance;
 }
 
 template <typename T>
-inline napi_value ObjectWrap<T>::InstanceSetterCallbackWrapper(
-    napi_env env,
-    napi_callback_info info) {
+template <typename ObjectWrap<T>::StaticSetterCallback method>
+inline napi_value ObjectWrap<T>::WrappedMethod(
+    napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
   return details::WrapCallback([&] {
-    CallbackInfo callbackInfo(env, info);
-    InstanceAccessorCallbackData* callbackData =
-      reinterpret_cast<InstanceAccessorCallbackData*>(callbackInfo.Data());
-    callbackInfo.SetData(callbackData->data);
-    T* instance = Unwrap(callbackInfo.This().As<Object>());
-    auto cb = callbackData->setterCallback;
-    (instance->*cb)(callbackInfo, callbackInfo[0]);
+    const CallbackInfo cbInfo(env, info);
+    method(cbInfo, cbInfo[0]);
     return nullptr;
   });
 }
 
-template <typename T>
-inline void ObjectWrap<T>::FinalizeCallback(napi_env /*env*/, void* data, void* /*hint*/) {
-  T* instance = reinterpret_cast<T*>(data);
-  delete instance;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // HandleScope class
 ////////////////////////////////////////////////////////////////////////////////
@@ -3421,7 +4622,10 @@ inline HandleScope::HandleScope(Napi::Env env) : _env(env) {
 }
 
 inline HandleScope::~HandleScope() {
-  napi_close_handle_scope(_env, _scope);
+  napi_status status = napi_close_handle_scope(_env, _scope);
+  NAPI_FATAL_IF_FAILED(status,
+                       "HandleScope::~HandleScope",
+                       "napi_close_handle_scope");
 }
 
 inline HandleScope::operator napi_handle_scope() const {
@@ -3446,7 +4650,10 @@ inline EscapableHandleScope::EscapableHandleScope(Napi::Env env) : _env(env) {
 }
 
 inline EscapableHandleScope::~EscapableHandleScope() {
-  napi_close_escapable_handle_scope(_env, _scope);
+  napi_status status = napi_close_escapable_handle_scope(_env, _scope);
+  NAPI_FATAL_IF_FAILED(status,
+                       "EscapableHandleScope::~EscapableHandleScope",
+                       "napi_close_escapable_handle_scope");
 }
 
 inline EscapableHandleScope::operator napi_escapable_handle_scope() const {
@@ -3482,7 +4689,10 @@ inline CallbackScope::CallbackScope(napi_env env, napi_async_context context)
 }
 
 inline CallbackScope::~CallbackScope() {
-  napi_close_callback_scope(_env, _scope);
+  napi_status status = napi_close_callback_scope(_env, _scope);
+  NAPI_FATAL_IF_FAILED(status,
+                       "CallbackScope::~CallbackScope",
+                       "napi_close_callback_scope");
 }
 
 inline CallbackScope::operator napi_callback_scope() const {
@@ -3503,10 +4713,9 @@ inline AsyncContext::AsyncContext(napi_env env, const char* resource_name)
 }
 
 inline AsyncContext::AsyncContext(napi_env env,
-		                  const char* resource_name,
+                                  const char* resource_name,
                                   const Object& resource)
-  : _env(env),
-    _context(nullptr) {
+    : _env(env), _context(nullptr) {
   napi_value resource_id;
   napi_status status = napi_create_string_utf8(
       _env, resource_name, NAPI_AUTO_LENGTH, &resource_id);
@@ -3542,6 +4751,10 @@ inline AsyncContext::operator napi_async_context() const {
   return _context;
 }
 
+inline Napi::Env AsyncContext::Env() const {
+  return Napi::Env(_env);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // AsyncWorker class
 ////////////////////////////////////////////////////////////////////////////////
@@ -3591,8 +4804,8 @@ inline AsyncWorker::AsyncWorker(const Object& receiver,
       _env, resource_name, NAPI_AUTO_LENGTH, &resource_id);
   NAPI_THROW_IF_FAILED_VOID(_env, status);
 
-  status = napi_create_async_work(_env, resource, resource_id, OnExecute,
-                                  OnWorkComplete, this, &_work);
+  status = napi_create_async_work(_env, resource, resource_id, OnAsyncWorkExecute,
+                                  OnAsyncWorkComplete, this, &_work);
   NAPI_THROW_IF_FAILED_VOID(_env, status);
 }
 
@@ -3617,132 +4830,627 @@ inline AsyncWorker::AsyncWorker(Napi::Env env,
       _env, resource_name, NAPI_AUTO_LENGTH, &resource_id);
   NAPI_THROW_IF_FAILED_VOID(_env, status);
 
-  status = napi_create_async_work(_env, resource, resource_id, OnExecute,
-                                  OnWorkComplete, this, &_work);
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  status = napi_create_async_work(_env, resource, resource_id, OnAsyncWorkExecute,
+                                  OnAsyncWorkComplete, this, &_work);
+  NAPI_THROW_IF_FAILED_VOID(_env, status);
+}
+
+inline AsyncWorker::~AsyncWorker() {
+  if (_work != nullptr) {
+    napi_delete_async_work(_env, _work);
+    _work = nullptr;
+  }
+}
+
+inline void AsyncWorker::Destroy() {
+  delete this;
+}
+
+inline AsyncWorker::AsyncWorker(AsyncWorker&& other) {
+  _env = other._env;
+  other._env = nullptr;
+  _work = other._work;
+  other._work = nullptr;
+  _receiver = std::move(other._receiver);
+  _callback = std::move(other._callback);
+  _error = std::move(other._error);
+  _suppress_destruct = other._suppress_destruct;
+}
+
+inline AsyncWorker& AsyncWorker::operator =(AsyncWorker&& other) {
+  _env = other._env;
+  other._env = nullptr;
+  _work = other._work;
+  other._work = nullptr;
+  _receiver = std::move(other._receiver);
+  _callback = std::move(other._callback);
+  _error = std::move(other._error);
+  _suppress_destruct = other._suppress_destruct;
+  return *this;
+}
+
+inline AsyncWorker::operator napi_async_work() const {
+  return _work;
+}
+
+inline Napi::Env AsyncWorker::Env() const {
+  return Napi::Env(_env);
+}
+
+inline void AsyncWorker::Queue() {
+  napi_status status = napi_queue_async_work(_env, _work);
+  NAPI_THROW_IF_FAILED_VOID(_env, status);
+}
+
+inline void AsyncWorker::Cancel() {
+  napi_status status = napi_cancel_async_work(_env, _work);
+  NAPI_THROW_IF_FAILED_VOID(_env, status);
+}
+
+inline ObjectReference& AsyncWorker::Receiver() {
+  return _receiver;
+}
+
+inline FunctionReference& AsyncWorker::Callback() {
+  return _callback;
+}
+
+inline void AsyncWorker::SuppressDestruct() {
+  _suppress_destruct = true;
+}
+
+inline void AsyncWorker::OnOK() {
+  if (!_callback.IsEmpty()) {
+    _callback.Call(_receiver.Value(), GetResult(_callback.Env()));
+  }
+}
+
+inline void AsyncWorker::OnError(const Error& e) {
+  if (!_callback.IsEmpty()) {
+    _callback.Call(_receiver.Value(), std::initializer_list<napi_value>{ e.Value() });
+  }
+}
+
+inline void AsyncWorker::SetError(const std::string& error) {
+  _error = error;
+}
+
+inline std::vector<napi_value> AsyncWorker::GetResult(Napi::Env /*env*/) {
+  return {};
+}
+// The OnAsyncWorkExecute method receives an napi_env argument. However, do NOT
+// use it within this method, as it does not run on the JavaScript thread and
+// must not run any method that would cause JavaScript to run. In practice,
+// this means that almost any use of napi_env will be incorrect.
+inline void AsyncWorker::OnAsyncWorkExecute(napi_env env, void* asyncworker) {
+  AsyncWorker* self = static_cast<AsyncWorker*>(asyncworker);
+  self->OnExecute(env);
+}
+// The OnExecute method receives an napi_env argument. However, do NOT
+// use it within this method, as it does not run on the JavaScript thread and
+// must not run any method that would cause JavaScript to run. In practice,
+// this means that almost any use of napi_env will be incorrect.
+inline void AsyncWorker::OnExecute(Napi::Env /*DO_NOT_USE*/) {
+#ifdef NAPI_CPP_EXCEPTIONS
+  try {
+    Execute();
+  } catch (const std::exception& e) {
+    SetError(e.what());
+  }
+#else // NAPI_CPP_EXCEPTIONS
+  Execute();
+#endif // NAPI_CPP_EXCEPTIONS
+}
+
+inline void AsyncWorker::OnAsyncWorkComplete(napi_env env,
+                                             napi_status status,
+                                             void* asyncworker) {
+  AsyncWorker* self = static_cast<AsyncWorker*>(asyncworker);
+  self->OnWorkComplete(env, status);
+}
+inline void AsyncWorker::OnWorkComplete(Napi::Env /*env*/, napi_status status) {
+  if (status != napi_cancelled) {
+    HandleScope scope(_env);
+    details::WrapCallback([&] {
+      if (_error.size() == 0) {
+        OnOK();
+      }
+      else {
+        OnError(Error::New(_env, _error));
+      }
+      return nullptr;
+    });
+  }
+  if (!_suppress_destruct) {
+    Destroy();
+  }
+}
+
+#if (NAPI_VERSION > 3 && !defined(__wasm32__))
+////////////////////////////////////////////////////////////////////////////////
+// TypedThreadSafeFunction<ContextType,DataType,CallJs> class
+////////////////////////////////////////////////////////////////////////////////
+
+// Starting with NAPI 5, the JavaScript function `func` parameter of
+// `napi_create_threadsafe_function` is optional.
+#if NAPI_VERSION > 4
+// static, with Callback [missing] Resource [missing] Finalizer [missing]
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+template <typename ResourceString>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::New(
+    napi_env env,
+    ResourceString resourceName,
+    size_t maxQueueSize,
+    size_t initialThreadCount,
+    ContextType* context) {
+  TypedThreadSafeFunction<ContextType, DataType, CallJs> tsfn;
+
+  napi_status status =
+      napi_create_threadsafe_function(env,
+                                      nullptr,
+                                      nullptr,
+                                      String::From(env, resourceName),
+                                      maxQueueSize,
+                                      initialThreadCount,
+                                      nullptr,
+                                      nullptr,
+                                      context,
+                                      CallJsInternal,
+                                      &tsfn._tsfn);
+  if (status != napi_ok) {
+    NAPI_THROW_IF_FAILED(
+        env, status, TypedThreadSafeFunction<ContextType, DataType, CallJs>());
+  }
+
+  return tsfn;
+}
+
+// static, with Callback [missing] Resource [passed] Finalizer [missing]
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+template <typename ResourceString>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::New(
+    napi_env env,
+    const Object& resource,
+    ResourceString resourceName,
+    size_t maxQueueSize,
+    size_t initialThreadCount,
+    ContextType* context) {
+  TypedThreadSafeFunction<ContextType, DataType, CallJs> tsfn;
+
+  napi_status status =
+      napi_create_threadsafe_function(env,
+                                      nullptr,
+                                      resource,
+                                      String::From(env, resourceName),
+                                      maxQueueSize,
+                                      initialThreadCount,
+                                      nullptr,
+                                      nullptr,
+                                      context,
+                                      CallJsInternal,
+                                      &tsfn._tsfn);
+  if (status != napi_ok) {
+    NAPI_THROW_IF_FAILED(
+        env, status, TypedThreadSafeFunction<ContextType, DataType, CallJs>());
+  }
+
+  return tsfn;
+}
+
+// static, with Callback [missing] Resource [missing] Finalizer [passed]
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+template <typename ResourceString,
+          typename Finalizer,
+          typename FinalizerDataType>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::New(
+    napi_env env,
+    ResourceString resourceName,
+    size_t maxQueueSize,
+    size_t initialThreadCount,
+    ContextType* context,
+    Finalizer finalizeCallback,
+    FinalizerDataType* data) {
+  TypedThreadSafeFunction<ContextType, DataType, CallJs> tsfn;
+
+  auto* finalizeData = new details::
+      ThreadSafeFinalize<ContextType, Finalizer, FinalizerDataType>(
+          {data, finalizeCallback});
+  napi_status status = napi_create_threadsafe_function(
+      env,
+      nullptr,
+      nullptr,
+      String::From(env, resourceName),
+      maxQueueSize,
+      initialThreadCount,
+      finalizeData,
+      details::ThreadSafeFinalize<ContextType, Finalizer, FinalizerDataType>::
+          FinalizeFinalizeWrapperWithDataAndContext,
+      context,
+      CallJsInternal,
+      &tsfn._tsfn);
+  if (status != napi_ok) {
+    delete finalizeData;
+    NAPI_THROW_IF_FAILED(
+        env, status, TypedThreadSafeFunction<ContextType, DataType, CallJs>());
+  }
+
+  return tsfn;
+}
+
+// static, with Callback [missing] Resource [passed] Finalizer [passed]
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+template <typename ResourceString,
+          typename Finalizer,
+          typename FinalizerDataType>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>
+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) {
+  TypedThreadSafeFunction<ContextType, DataType, CallJs> tsfn;
+
+  auto* finalizeData = new details::
+      ThreadSafeFinalize<ContextType, Finalizer, FinalizerDataType>(
+          {data, finalizeCallback});
+  napi_status status = napi_create_threadsafe_function(
+      env,
+      nullptr,
+      resource,
+      String::From(env, resourceName),
+      maxQueueSize,
+      initialThreadCount,
+      finalizeData,
+      details::ThreadSafeFinalize<ContextType, Finalizer, FinalizerDataType>::
+          FinalizeFinalizeWrapperWithDataAndContext,
+      context,
+      CallJsInternal,
+      &tsfn._tsfn);
+  if (status != napi_ok) {
+    delete finalizeData;
+    NAPI_THROW_IF_FAILED(
+        env, status, TypedThreadSafeFunction<ContextType, DataType, CallJs>());
+  }
+
+  return tsfn;
+}
+#endif
+
+// static, with Callback [passed] Resource [missing] Finalizer [missing]
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+template <typename ResourceString>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::New(
+    napi_env env,
+    const Function& callback,
+    ResourceString resourceName,
+    size_t maxQueueSize,
+    size_t initialThreadCount,
+    ContextType* context) {
+  TypedThreadSafeFunction<ContextType, DataType, CallJs> tsfn;
+
+  napi_status status =
+      napi_create_threadsafe_function(env,
+                                      callback,
+                                      nullptr,
+                                      String::From(env, resourceName),
+                                      maxQueueSize,
+                                      initialThreadCount,
+                                      nullptr,
+                                      nullptr,
+                                      context,
+                                      CallJsInternal,
+                                      &tsfn._tsfn);
+  if (status != napi_ok) {
+    NAPI_THROW_IF_FAILED(
+        env, status, TypedThreadSafeFunction<ContextType, DataType, CallJs>());
+  }
+
+  return tsfn;
 }
 
-inline AsyncWorker::~AsyncWorker() {
-  if (_work != nullptr) {
-    napi_delete_async_work(_env, _work);
-    _work = nullptr;
+// static, with Callback [passed] Resource [passed] Finalizer [missing]
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+template <typename ResourceString>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::New(
+    napi_env env,
+    const Function& callback,
+    const Object& resource,
+    ResourceString resourceName,
+    size_t maxQueueSize,
+    size_t initialThreadCount,
+    ContextType* context) {
+  TypedThreadSafeFunction<ContextType, DataType, CallJs> tsfn;
+
+  napi_status status =
+      napi_create_threadsafe_function(env,
+                                      callback,
+                                      resource,
+                                      String::From(env, resourceName),
+                                      maxQueueSize,
+                                      initialThreadCount,
+                                      nullptr,
+                                      nullptr,
+                                      context,
+                                      CallJsInternal,
+                                      &tsfn._tsfn);
+  if (status != napi_ok) {
+    NAPI_THROW_IF_FAILED(
+        env, status, TypedThreadSafeFunction<ContextType, DataType, CallJs>());
   }
-}
 
-inline void AsyncWorker::Destroy() {
-  delete this;
+  return tsfn;
 }
 
-inline AsyncWorker::AsyncWorker(AsyncWorker&& other) {
-  _env = other._env;
-  other._env = nullptr;
-  _work = other._work;
-  other._work = nullptr;
-  _receiver = std::move(other._receiver);
-  _callback = std::move(other._callback);
-  _error = std::move(other._error);
-  _suppress_destruct = other._suppress_destruct;
+// static, with Callback [passed] Resource [missing] Finalizer [passed]
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+template <typename ResourceString,
+          typename Finalizer,
+          typename FinalizerDataType>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>
+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) {
+  TypedThreadSafeFunction<ContextType, DataType, CallJs> tsfn;
+
+  auto* finalizeData = new details::
+      ThreadSafeFinalize<ContextType, Finalizer, FinalizerDataType>(
+          {data, finalizeCallback});
+  napi_status status = napi_create_threadsafe_function(
+      env,
+      callback,
+      nullptr,
+      String::From(env, resourceName),
+      maxQueueSize,
+      initialThreadCount,
+      finalizeData,
+      details::ThreadSafeFinalize<ContextType, Finalizer, FinalizerDataType>::
+          FinalizeFinalizeWrapperWithDataAndContext,
+      context,
+      CallJsInternal,
+      &tsfn._tsfn);
+  if (status != napi_ok) {
+    delete finalizeData;
+    NAPI_THROW_IF_FAILED(
+        env, status, TypedThreadSafeFunction<ContextType, DataType, CallJs>());
+  }
+
+  return tsfn;
 }
 
-inline AsyncWorker& AsyncWorker::operator =(AsyncWorker&& other) {
-  _env = other._env;
-  other._env = nullptr;
-  _work = other._work;
-  other._work = nullptr;
-  _receiver = std::move(other._receiver);
-  _callback = std::move(other._callback);
-  _error = std::move(other._error);
-  _suppress_destruct = other._suppress_destruct;
-  return *this;
+// static, with: Callback [passed] Resource [passed] Finalizer [passed]
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+template <typename CallbackType,
+          typename ResourceString,
+          typename Finalizer,
+          typename FinalizerDataType>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>
+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) {
+  TypedThreadSafeFunction<ContextType, DataType, CallJs> tsfn;
+
+  auto* finalizeData = new details::
+      ThreadSafeFinalize<ContextType, Finalizer, FinalizerDataType>(
+          {data, finalizeCallback});
+  napi_status status = napi_create_threadsafe_function(
+      env,
+      details::DefaultCallbackWrapper<
+          CallbackType,
+          TypedThreadSafeFunction<ContextType, DataType, CallJs>>(env,
+                                                                  callback),
+      resource,
+      String::From(env, resourceName),
+      maxQueueSize,
+      initialThreadCount,
+      finalizeData,
+      details::ThreadSafeFinalize<ContextType, Finalizer, FinalizerDataType>::
+          FinalizeFinalizeWrapperWithDataAndContext,
+      context,
+      CallJsInternal,
+      &tsfn._tsfn);
+  if (status != napi_ok) {
+    delete finalizeData;
+    NAPI_THROW_IF_FAILED(
+        env, status, TypedThreadSafeFunction<ContextType, DataType, CallJs>());
+  }
+
+  return tsfn;
 }
 
-inline AsyncWorker::operator napi_async_work() const {
-  return _work;
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>::
+    TypedThreadSafeFunction()
+    : _tsfn() {}
+
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>::
+    TypedThreadSafeFunction(napi_threadsafe_function tsfn)
+    : _tsfn(tsfn) {}
+
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline TypedThreadSafeFunction<ContextType, DataType, CallJs>::
+operator napi_threadsafe_function() const {
+  return _tsfn;
+}
+
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline napi_status
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::BlockingCall(
+    DataType* data) const {
+  return napi_call_threadsafe_function(_tsfn, data, napi_tsfn_blocking);
+}
+
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline napi_status
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::NonBlockingCall(
+    DataType* data) const {
+  return napi_call_threadsafe_function(_tsfn, data, napi_tsfn_nonblocking);
+}
+
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline void TypedThreadSafeFunction<ContextType, DataType, CallJs>::Ref(
+    napi_env env) const {
+  if (_tsfn != nullptr) {
+    napi_status status = napi_ref_threadsafe_function(env, _tsfn);
+    NAPI_THROW_IF_FAILED_VOID(env, status);
+  }
 }
 
-inline Napi::Env AsyncWorker::Env() const {
-  return Napi::Env(_env);
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline void TypedThreadSafeFunction<ContextType, DataType, CallJs>::Unref(
+    napi_env env) const {
+  if (_tsfn != nullptr) {
+    napi_status status = napi_unref_threadsafe_function(env, _tsfn);
+    NAPI_THROW_IF_FAILED_VOID(env, status);
+  }
 }
 
-inline void AsyncWorker::Queue() {
-  napi_status status = napi_queue_async_work(_env, _work);
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline napi_status
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::Acquire() const {
+  return napi_acquire_threadsafe_function(_tsfn);
 }
 
-inline void AsyncWorker::Cancel() {
-  napi_status status = napi_cancel_async_work(_env, _work);
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline napi_status
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::Release() const {
+  return napi_release_threadsafe_function(_tsfn, napi_tsfn_release);
 }
 
-inline ObjectReference& AsyncWorker::Receiver() {
-  return _receiver;
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline napi_status
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::Abort() const {
+  return napi_release_threadsafe_function(_tsfn, napi_tsfn_abort);
 }
 
-inline FunctionReference& AsyncWorker::Callback() {
-  return _callback;
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+inline ContextType*
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::GetContext() const {
+  void* context;
+  napi_status status = napi_get_threadsafe_function_context(_tsfn, &context);
+  NAPI_FATAL_IF_FAILED(status,
+                       "TypedThreadSafeFunction::GetContext",
+                       "napi_get_threadsafe_function_context");
+  return static_cast<ContextType*>(context);
 }
 
-inline void AsyncWorker::SuppressDestruct() {
-  _suppress_destruct = true;
+// static
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+void TypedThreadSafeFunction<ContextType, DataType, CallJs>::CallJsInternal(
+    napi_env env, napi_value jsCallback, void* context, void* data) {
+  details::CallJsWrapper<ContextType, DataType, decltype(CallJs), CallJs>(
+      env, jsCallback, context, data);
 }
 
-inline void AsyncWorker::OnOK() {
-  if (!_callback.IsEmpty()) {
-    _callback.Call(_receiver.Value(), GetResult(_callback.Env()));
-  }
+#if NAPI_VERSION == 4
+// static
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+Napi::Function
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::EmptyFunctionFactory(
+    Napi::Env env) {
+  return Napi::Function::New(env, [](const CallbackInfo& cb) {});
 }
 
-inline void AsyncWorker::OnError(const Error& e) {
-  if (!_callback.IsEmpty()) {
-    _callback.Call(_receiver.Value(), std::initializer_list<napi_value>{ e.Value() });
+// static
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+Napi::Function
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::FunctionOrEmpty(
+    Napi::Env env, Napi::Function& callback) {
+  if (callback.IsEmpty()) {
+    return EmptyFunctionFactory(env);
   }
+  return callback;
 }
 
-inline void AsyncWorker::SetError(const std::string& error) {
-  _error = error;
+#else
+// static
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+std::nullptr_t
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::EmptyFunctionFactory(
+    Napi::Env /*env*/) {
+  return nullptr;
 }
 
-inline std::vector<napi_value> AsyncWorker::GetResult(Napi::Env /*env*/) {
-  return {};
-}
-// The OnExecute method receives an napi_env argument. However, do NOT
-// use it within this method, as it does not run on the main thread and must
-// not run any method that would cause JavaScript to run. In practice, this
-// means that almost any use of napi_env will be incorrect.
-inline void AsyncWorker::OnExecute(napi_env /*DO_NOT_USE*/, void* this_pointer) {
-  AsyncWorker* self = static_cast<AsyncWorker*>(this_pointer);
-#ifdef NAPI_CPP_EXCEPTIONS
-  try {
-    self->Execute();
-  } catch (const std::exception& e) {
-    self->SetError(e.what());
-  }
-#else // NAPI_CPP_EXCEPTIONS
-  self->Execute();
-#endif // NAPI_CPP_EXCEPTIONS
+// static
+template <typename ContextType,
+          typename DataType,
+          void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
+Napi::Function
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::FunctionOrEmpty(
+    Napi::Env /*env*/, Napi::Function& callback) {
+  return callback;
 }
 
-inline void AsyncWorker::OnWorkComplete(
-    napi_env /*env*/, napi_status status, void* this_pointer) {
-  AsyncWorker* self = static_cast<AsyncWorker*>(this_pointer);
-  if (status != napi_cancelled) {
-    HandleScope scope(self->_env);
-    details::WrapCallback([&] {
-      if (self->_error.size() == 0) {
-        self->OnOK();
-      }
-      else {
-        self->OnError(Error::New(self->_env, self->_error));
-      }
-      return nullptr;
-    });
-  }
-  if (!self->_suppress_destruct) {
-    self->Destroy();
-  }
-}
+#endif
 
-#if (NAPI_VERSION > 3)
 ////////////////////////////////////////////////////////////////////////////////
 // ThreadSafeFunction class
 ////////////////////////////////////////////////////////////////////////////////
@@ -3919,35 +5627,28 @@ inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env,
 }
 
 inline ThreadSafeFunction::ThreadSafeFunction()
-  : _tsfn(new napi_threadsafe_function(nullptr)) {
+  : _tsfn() {
 }
 
 inline ThreadSafeFunction::ThreadSafeFunction(
     napi_threadsafe_function tsfn)
-  : _tsfn(new napi_threadsafe_function(tsfn)) {
+  : _tsfn(tsfn) {
 }
 
-inline ThreadSafeFunction::ThreadSafeFunction(ThreadSafeFunction&& other)
-  : _tsfn(std::move(other._tsfn)) {
-  other._tsfn.reset();
-}
-
-inline ThreadSafeFunction& ThreadSafeFunction::operator =(
-    ThreadSafeFunction&& other) {
-  if (*_tsfn != nullptr) {
-    Error::Fatal("ThreadSafeFunction::operator =",
-        "You cannot assign a new TSFN because existing one is still alive.");
-    return *this;
-  }
-  _tsfn = std::move(other._tsfn);
-  other._tsfn.reset();
-  return *this;
+inline ThreadSafeFunction::operator napi_threadsafe_function() const {
+  return _tsfn;
 }
 
 inline napi_status ThreadSafeFunction::BlockingCall() const {
   return CallInternal(nullptr, napi_tsfn_blocking);
 }
 
+template <>
+inline napi_status ThreadSafeFunction::BlockingCall(
+    void* data) const {
+  return napi_call_threadsafe_function(_tsfn, data, napi_tsfn_blocking);
+}
+
 template <typename Callback>
 inline napi_status ThreadSafeFunction::BlockingCall(
     Callback callback) const {
@@ -3967,6 +5668,12 @@ inline napi_status ThreadSafeFunction::NonBlockingCall() const {
   return CallInternal(nullptr, napi_tsfn_nonblocking);
 }
 
+template <>
+inline napi_status ThreadSafeFunction::NonBlockingCall(
+    void* data) const {
+  return napi_call_threadsafe_function(_tsfn, data, napi_tsfn_nonblocking);
+}
+
 template <typename Callback>
 inline napi_status ThreadSafeFunction::NonBlockingCall(
     Callback callback) const {
@@ -3982,22 +5689,37 @@ inline napi_status ThreadSafeFunction::NonBlockingCall(
   return CallInternal(new CallbackWrapper(wrapper), napi_tsfn_nonblocking);
 }
 
+inline void ThreadSafeFunction::Ref(napi_env env) const {
+  if (_tsfn != nullptr) {
+    napi_status status = napi_ref_threadsafe_function(env, _tsfn);
+    NAPI_THROW_IF_FAILED_VOID(env, status);
+  }
+}
+
+inline void ThreadSafeFunction::Unref(napi_env env) const {
+  if (_tsfn != nullptr) {
+    napi_status status = napi_unref_threadsafe_function(env, _tsfn);
+    NAPI_THROW_IF_FAILED_VOID(env, status);
+  }
+}
+
 inline napi_status ThreadSafeFunction::Acquire() const {
-  return napi_acquire_threadsafe_function(*_tsfn);
+  return napi_acquire_threadsafe_function(_tsfn);
 }
 
-inline napi_status ThreadSafeFunction::Release() {
-  return napi_release_threadsafe_function(*_tsfn, napi_tsfn_release);
+inline napi_status ThreadSafeFunction::Release() const {
+  return napi_release_threadsafe_function(_tsfn, napi_tsfn_release);
 }
 
-inline napi_status ThreadSafeFunction::Abort() {
-  return napi_release_threadsafe_function(*_tsfn, napi_tsfn_abort);
+inline napi_status ThreadSafeFunction::Abort() const {
+  return napi_release_threadsafe_function(_tsfn, napi_tsfn_abort);
 }
 
 inline ThreadSafeFunction::ConvertibleContext
 ThreadSafeFunction::GetContext() const {
   void* context;
-  napi_get_threadsafe_function_context(*_tsfn, &context);
+  napi_status status = napi_get_threadsafe_function_context(_tsfn, &context);
+  NAPI_FATAL_IF_FAILED(status, "ThreadSafeFunction::GetContext", "napi_get_threadsafe_function_context");
   return ConvertibleContext({ context });
 }
 
@@ -4020,10 +5742,10 @@ inline ThreadSafeFunction ThreadSafeFunction::New(napi_env env,
 
   ThreadSafeFunction tsfn;
   auto* finalizeData = new details::ThreadSafeFinalize<ContextType, Finalizer,
-      FinalizerDataType>({ data, finalizeCallback, tsfn._tsfn.get() });
+      FinalizerDataType>({ data, finalizeCallback });
   napi_status status = napi_create_threadsafe_function(env, callback, resource,
       Value::From(env, resourceName), maxQueueSize, initialThreadCount,
-      finalizeData, wrapper, context, CallJS, tsfn._tsfn.get());
+      finalizeData, wrapper, context, CallJS, &tsfn._tsfn);
   if (status != napi_ok) {
     delete finalizeData;
     NAPI_THROW_IF_FAILED(env, status, ThreadSafeFunction());
@@ -4036,7 +5758,7 @@ inline napi_status ThreadSafeFunction::CallInternal(
     CallbackWrapper* callbackWrapper,
     napi_threadsafe_function_call_mode mode) const {
   napi_status status = napi_call_threadsafe_function(
-      *_tsfn, callbackWrapper, mode);
+      _tsfn, callbackWrapper, mode);
   if (status != napi_ok && callbackWrapper != nullptr) {
     delete callbackWrapper;
   }
@@ -4061,8 +5783,354 @@ inline void ThreadSafeFunction::CallJS(napi_env env,
     Function(env, jsCallback).Call({});
   }
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// Async Progress Worker Base class
+////////////////////////////////////////////////////////////////////////////////
+template <typename DataType>
+inline AsyncProgressWorkerBase<DataType>::AsyncProgressWorkerBase(const Object& receiver,
+                                                                  const Function& callback,
+                                                                  const char* resource_name,
+                                                                  const Object& resource,
+                                                                  size_t queue_size)
+  : AsyncWorker(receiver, callback, resource_name, resource) {
+  // Fill all possible arguments to work around ambiguous ThreadSafeFunction::New signatures.
+  _tsfn = ThreadSafeFunction::New(callback.Env(),
+                                  callback,
+                                  resource,
+                                  resource_name,
+                                  queue_size,
+                                  /** initialThreadCount */ 1,
+                                  /** context */ this,
+                                  OnThreadSafeFunctionFinalize,
+                                  /** finalizeData */ this);
+}
+
+#if NAPI_VERSION > 4
+template <typename DataType>
+inline AsyncProgressWorkerBase<DataType>::AsyncProgressWorkerBase(Napi::Env env,
+                                                                  const char* resource_name,
+                                                                  const Object& resource,
+                                                                  size_t queue_size)
+  : AsyncWorker(env, resource_name, resource) {
+  // TODO: Once the changes to make the callback optional for threadsafe
+  // functions are available on all versions we can remove the dummy Function here.
+  Function callback;
+  // Fill all possible arguments to work around ambiguous ThreadSafeFunction::New signatures.
+  _tsfn = ThreadSafeFunction::New(env,
+                                  callback,
+                                  resource,
+                                  resource_name,
+                                  queue_size,
+                                  /** initialThreadCount */ 1,
+                                  /** context */ this,
+                                  OnThreadSafeFunctionFinalize,
+                                  /** finalizeData */ this);
+}
+#endif
+
+template<typename DataType>
+inline AsyncProgressWorkerBase<DataType>::~AsyncProgressWorkerBase() {
+  // Abort pending tsfn call.
+  // Don't send progress events after we've already completed.
+  // It's ok to call ThreadSafeFunction::Abort and ThreadSafeFunction::Release duplicated.
+  _tsfn.Abort();
+}
+
+template <typename DataType>
+inline void AsyncProgressWorkerBase<DataType>::OnAsyncWorkProgress(Napi::Env /* env */,
+                                Napi::Function /* jsCallback */,
+                                void* data) {
+  ThreadSafeData* tsd = static_cast<ThreadSafeData*>(data);
+  tsd->asyncprogressworker()->OnWorkProgress(tsd->data());
+  delete tsd;
+}
+
+template <typename DataType>
+inline napi_status AsyncProgressWorkerBase<DataType>::NonBlockingCall(DataType* data) {
+  auto tsd = new AsyncProgressWorkerBase::ThreadSafeData(this, data);
+  return _tsfn.NonBlockingCall(tsd, OnAsyncWorkProgress);
+}
+
+template <typename DataType>
+inline void AsyncProgressWorkerBase<DataType>::OnWorkComplete(Napi::Env /* env */, napi_status status) {
+  _work_completed = true;
+  _complete_status = status;
+  _tsfn.Release();
+}
+
+template <typename DataType>
+inline void AsyncProgressWorkerBase<DataType>::OnThreadSafeFunctionFinalize(Napi::Env env, void* /* data */, AsyncProgressWorkerBase* context) {
+  if (context->_work_completed) {
+    context->AsyncWorker::OnWorkComplete(env, context->_complete_status);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Async Progress Worker class
+////////////////////////////////////////////////////////////////////////////////
+template<class T>
+inline AsyncProgressWorker<T>::AsyncProgressWorker(const Function& callback)
+  : AsyncProgressWorker(callback, "generic") {
+}
+
+template<class T>
+inline AsyncProgressWorker<T>::AsyncProgressWorker(const Function& callback,
+                                const char* resource_name)
+  : AsyncProgressWorker(callback, resource_name, Object::New(callback.Env())) {
+}
+
+template<class T>
+inline AsyncProgressWorker<T>::AsyncProgressWorker(const Function& callback,
+                                const char* resource_name,
+                                const Object& resource)
+  : AsyncProgressWorker(Object::New(callback.Env()),
+                callback,
+                resource_name,
+                resource) {
+}
+
+template<class T>
+inline AsyncProgressWorker<T>::AsyncProgressWorker(const Object& receiver,
+                                                   const Function& callback)
+  : AsyncProgressWorker(receiver, callback, "generic") {
+}
+
+template<class T>
+inline AsyncProgressWorker<T>::AsyncProgressWorker(const Object& receiver,
+                                                   const Function& callback,
+                                                   const char* resource_name)
+  : AsyncProgressWorker(receiver,
+                callback,
+                resource_name,
+                Object::New(callback.Env())) {
+}
+
+template<class T>
+inline AsyncProgressWorker<T>::AsyncProgressWorker(const Object& receiver,
+                                                   const Function& callback,
+                                                   const char* resource_name,
+                                                   const Object& resource)
+  : AsyncProgressWorkerBase(receiver, callback, resource_name, resource),
+    _asyncdata(nullptr),
+    _asyncsize(0) {
+}
+
+#if NAPI_VERSION > 4
+template<class T>
+inline AsyncProgressWorker<T>::AsyncProgressWorker(Napi::Env env)
+  : AsyncProgressWorker(env, "generic") {
+}
+
+template<class T>
+inline AsyncProgressWorker<T>::AsyncProgressWorker(Napi::Env env,
+                                                   const char* resource_name)
+  : AsyncProgressWorker(env, resource_name, Object::New(env)) {
+}
+
+template<class T>
+inline AsyncProgressWorker<T>::AsyncProgressWorker(Napi::Env env,
+                                                   const char* resource_name,
+                                                   const Object& resource)
+  : AsyncProgressWorkerBase(env, resource_name, resource),
+    _asyncdata(nullptr),
+    _asyncsize(0) {
+}
+#endif
+
+template<class T>
+inline AsyncProgressWorker<T>::~AsyncProgressWorker() {
+  {
+    std::lock_guard<std::mutex> lock(this->_mutex);
+    _asyncdata = nullptr;
+    _asyncsize = 0;
+  }
+}
+
+template<class T>
+inline void AsyncProgressWorker<T>::Execute() {
+  ExecutionProgress progress(this);
+  Execute(progress);
+}
+
+template<class T>
+inline void AsyncProgressWorker<T>::OnWorkProgress(void*) {
+  T* data;
+  size_t size;
+  {
+    std::lock_guard<std::mutex> lock(this->_mutex);
+    data = this->_asyncdata;
+    size = this->_asyncsize;
+    this->_asyncdata = nullptr;
+    this->_asyncsize = 0;
+  }
+
+  /**
+   * The callback of ThreadSafeFunction is not been invoked immediately on the
+   * callback of uv_async_t (uv io poll), rather the callback of TSFN is
+   * invoked on the right next uv idle callback. There are chances that during
+   * the deferring the signal of uv_async_t is been sent again, i.e. potential
+   * not coalesced two calls of the TSFN callback.
+   */
+  if (data == nullptr) {
+    return;
+  }
+
+  this->OnProgress(data, size);
+  delete[] data;
+}
+
+template<class T>
+inline void AsyncProgressWorker<T>::SendProgress_(const T* data, size_t count) {
+    T* new_data = new T[count];
+    std::copy(data, data + count, new_data);
+
+    T* old_data;
+    {
+      std::lock_guard<std::mutex> lock(this->_mutex);
+      old_data = _asyncdata;
+      _asyncdata = new_data;
+      _asyncsize = count;
+    }
+    this->NonBlockingCall(nullptr);
+
+    delete[] old_data;
+}
+
+template<class T>
+inline void AsyncProgressWorker<T>::Signal() const {
+  this->NonBlockingCall(static_cast<T*>(nullptr));
+}
+
+template<class T>
+inline void AsyncProgressWorker<T>::ExecutionProgress::Signal() const {
+  _worker->Signal();
+}
+
+template<class T>
+inline void AsyncProgressWorker<T>::ExecutionProgress::Send(const T* data, size_t count) const {
+  _worker->SendProgress_(data, count);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Async Progress Queue Worker class
+////////////////////////////////////////////////////////////////////////////////
+template<class T>
+inline AsyncProgressQueueWorker<T>::AsyncProgressQueueWorker(const Function& callback)
+  : AsyncProgressQueueWorker(callback, "generic") {
+}
+
+template<class T>
+inline AsyncProgressQueueWorker<T>::AsyncProgressQueueWorker(const Function& callback,
+                                                             const char* resource_name)
+  : AsyncProgressQueueWorker(callback, resource_name, Object::New(callback.Env())) {
+}
+
+template<class T>
+inline AsyncProgressQueueWorker<T>::AsyncProgressQueueWorker(const Function& callback,
+                                                             const char* resource_name,
+                                                             const Object& resource)
+  : AsyncProgressQueueWorker(Object::New(callback.Env()),
+                             callback,
+                             resource_name,
+                             resource) {
+}
+
+template<class T>
+inline AsyncProgressQueueWorker<T>::AsyncProgressQueueWorker(const Object& receiver,
+                                                             const Function& callback)
+  : AsyncProgressQueueWorker(receiver, callback, "generic") {
+}
+
+template<class T>
+inline AsyncProgressQueueWorker<T>::AsyncProgressQueueWorker(const Object& receiver,
+                                                             const Function& callback,
+                                                             const char* resource_name)
+  : AsyncProgressQueueWorker(receiver,
+                             callback,
+                             resource_name,
+                             Object::New(callback.Env())) {
+}
+
+template<class T>
+inline AsyncProgressQueueWorker<T>::AsyncProgressQueueWorker(const Object& receiver,
+                                                             const Function& callback,
+                                                             const char* resource_name,
+                                                             const Object& resource)
+  : AsyncProgressWorkerBase<std::pair<T*, size_t>>(receiver, callback, resource_name, resource, /** unlimited queue size */0) {
+}
+
+#if NAPI_VERSION > 4
+template<class T>
+inline AsyncProgressQueueWorker<T>::AsyncProgressQueueWorker(Napi::Env env)
+  : AsyncProgressQueueWorker(env, "generic") {
+}
+
+template<class T>
+inline AsyncProgressQueueWorker<T>::AsyncProgressQueueWorker(Napi::Env env,
+                                const char* resource_name)
+  : AsyncProgressQueueWorker(env, resource_name, Object::New(env)) {
+}
+
+template<class T>
+inline AsyncProgressQueueWorker<T>::AsyncProgressQueueWorker(Napi::Env env,
+                                                             const char* resource_name,
+                                                             const Object& resource)
+  : AsyncProgressWorkerBase<std::pair<T*, size_t>>(env, resource_name, resource, /** unlimited queue size */0) {
+}
 #endif
 
+template<class T>
+inline void AsyncProgressQueueWorker<T>::Execute() {
+  ExecutionProgress progress(this);
+  Execute(progress);
+}
+
+template<class T>
+inline void AsyncProgressQueueWorker<T>::OnWorkProgress(std::pair<T*, size_t>* datapair) {
+  if (datapair == nullptr) {
+    return;
+  }
+
+  T *data = datapair->first;
+  size_t size = datapair->second;
+
+  this->OnProgress(data, size);
+  delete datapair;
+  delete[] data;
+}
+
+template<class T>
+inline void AsyncProgressQueueWorker<T>::SendProgress_(const T* data, size_t count) {
+    T* new_data = new T[count];
+    std::copy(data, data + count, new_data);
+
+    auto pair = new std::pair<T*, size_t>(new_data, count);
+    this->NonBlockingCall(pair);
+}
+
+template<class T>
+inline void AsyncProgressQueueWorker<T>::Signal() const {
+  this->NonBlockingCall(nullptr);
+}
+
+template<class T>
+inline void AsyncProgressQueueWorker<T>::OnWorkComplete(Napi::Env env, napi_status status) {
+  // Draining queued items in TSFN.
+  AsyncProgressWorkerBase<std::pair<T*, size_t>>::OnWorkComplete(env, status);
+}
+
+template<class T>
+inline void AsyncProgressQueueWorker<T>::ExecutionProgress::Signal() const {
+  _worker->Signal();
+}
+
+template<class T>
+inline void AsyncProgressQueueWorker<T>::ExecutionProgress::Send(const T* data, size_t count) const {
+  _worker->SendProgress_(data, count);
+}
+#endif  // NAPI_VERSION > 3 && !defined(__wasm32__)
+
 ////////////////////////////////////////////////////////////////////////////////
 // Memory Management class
 ////////////////////////////////////////////////////////////////////////////////
@@ -4092,6 +6160,100 @@ inline const napi_node_version* VersionManagement::GetNodeVersion(Env env) {
   return result;
 }
 
+#if NAPI_VERSION > 5
+////////////////////////////////////////////////////////////////////////////////
+// Addon<T> class
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+inline Object Addon<T>::Init(Env env, Object exports) {
+  T* addon = new T(env, exports);
+  env.SetInstanceData(addon);
+  return addon->entry_point_;
+}
+
+template <typename T>
+inline T* Addon<T>::Unwrap(Object wrapper) {
+  return wrapper.Env().GetInstanceData<T>();
+}
+
+template <typename T>
+inline void
+Addon<T>::DefineAddon(Object exports,
+                      const std::initializer_list<AddonProp>& props) {
+  DefineProperties(exports, props);
+  entry_point_ = exports;
+}
+
+template <typename T>
+inline Napi::Object
+Addon<T>::DefineProperties(Object object,
+                           const std::initializer_list<AddonProp>& props) {
+  const napi_property_descriptor* properties =
+    reinterpret_cast<const napi_property_descriptor*>(props.begin());
+  size_t size = props.size();
+  napi_status status = napi_define_properties(object.Env(),
+                                              object,
+                                              size,
+                                              properties);
+  NAPI_THROW_IF_FAILED(object.Env(), status, object);
+  for (size_t idx = 0; idx < size; idx++)
+    T::AttachPropData(object.Env(), object, &properties[idx]);
+  return object;
+}
+#endif  // NAPI_VERSION > 5
+
+#if NAPI_VERSION > 2
+template <typename Hook, typename Arg>
+Env::CleanupHook<Hook, Arg> Env::AddCleanupHook(Hook hook, Arg* arg) {
+  return CleanupHook<Hook, Arg>(*this, hook, arg);
+}
+
+template <typename Hook>
+Env::CleanupHook<Hook> Env::AddCleanupHook(Hook hook) {
+  return CleanupHook<Hook>(*this, hook);
+}
+
+template <typename Hook, typename Arg>
+Env::CleanupHook<Hook, Arg>::CleanupHook(Napi::Env env, Hook hook)
+    : wrapper(Env::CleanupHook<Hook, Arg>::Wrapper) {
+  data = new CleanupData{std::move(hook), nullptr};
+  napi_status status = napi_add_env_cleanup_hook(env, wrapper, data);
+  if (status != napi_ok) {
+    delete data;
+    data = nullptr;
+  }
+}
+
+template <typename Hook, typename Arg>
+Env::CleanupHook<Hook, Arg>::CleanupHook(Napi::Env env, Hook hook, Arg* arg)
+    : wrapper(Env::CleanupHook<Hook, Arg>::WrapperWithArg) {
+  data = new CleanupData{std::move(hook), arg};
+  napi_status status = napi_add_env_cleanup_hook(env, wrapper, data);
+  if (status != napi_ok) {
+    delete data;
+    data = nullptr;
+  }
+}
+
+template <class Hook, class Arg>
+bool Env::CleanupHook<Hook, Arg>::Remove(Env env) {
+  napi_status status = napi_remove_env_cleanup_hook(env, wrapper, data);
+  delete data;
+  data = nullptr;
+  return status == napi_ok;
+}
+
+template <class Hook, class Arg>
+bool Env::CleanupHook<Hook, Arg>::IsEmpty() const {
+  return data == nullptr;
+}
+#endif  // NAPI_VERSION > 2
+
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+}  // namespace NAPI_CPP_CUSTOM_NAMESPACE
+#endif
+
 } // namespace Napi
 
 #endif // SRC_NAPI_INL_H_