const char* module_name,

int32_t module_api_version) {

std::string error_message;

error_message += module_name;

error_message += " requires Node-API version ";

error_message += std::to_string(module_api_version);

error_message += ", but this version of Node.js only supports version ";

error_message += NODE_STRINGIFY(NODE_API_SUPPORTED_VERSION_MAX) " add-ons.";

node_env->ThrowError(error_message.c_str());

const std::string& module_filename,

int32_t module_api_version) {

node_napi_env result;

// Validate module_api_version.

if (module_api_version < NODE_API_DEFAULT_MODULE_API_VERSION) {

module_api_version = NODE_API_DEFAULT_MODULE_API_VERSION;

} else if (module_api_version > NODE_API_SUPPORTED_VERSION_MAX &&

module_api_version != NAPI_VERSION_EXPERIMENTAL) {

node::Environment* node_env = node::Environment::GetCurrent(context);

CHECK_NOT_NULL(node_env);

v8impl::ThrowNodeApiVersionError(

node_env, module_filename.c_str(), module_api_version);

return nullptr;

}

result = new node_napi_env__(context, module_filename, module_api_version);

// TODO(addaleax): There was previously code that tried to delete the

// napi_env when its v8::Context was garbage collected;

// However, as long as Node-API addons using this napi_env are in place,

// the Context needs to be accessible and alive.

// Ideally, we'd want an on-addon-unload hook that takes care of this

// once all Node-API addons using this napi_env are unloaded.

// For now, a per-Environment cleanup hook is the best we can do.

result->node_env()->AddCleanupHook(

[](void* arg) { static_cast<napi_env>(arg)->Unref(); },

static_cast<void*>(result));

return result;

const std::string& module_filename,

int32_t module_api_version)

: napi_env__(context, module_api_version), filename(module_filename) {

CHECK_NOT_NULL(node_env());

destructing = true;

DrainFinalizerQueue();

napi_env__::DeleteMe();

v8::HandleScope handle_scope(isolate);

v8::Context::Scope context_scope(context());

CallbackIntoModule<enforceUncaughtExceptionPolicy>(

[&](napi_env env) { cb(env, data, hint); });

napi_env__::EnqueueFinalizer(finalizer);

// Schedule a second pass only when it has not been scheduled, and not

// destructing the env.

// When the env is being destructed, queued finalizers are drained in the

// loop of `node_napi_env__::DrainFinalizerQueue`.

if (!finalization_scheduled && !destructing) {

finalization_scheduled = true;

Ref();

node_env()->SetImmediate([this](node::Environment* node_env) {

finalization_scheduled = false;

Unref();

DrainFinalizerQueue();

});

}

// As userland code can delete additional references in one finalizer,

// the list of pending finalizers may be mutated as we execute them, so

// we keep iterating it until it is empty.

while (!pending_finalizers.empty()) {

v8impl::RefTracker* ref_tracker = *pending_finalizers.begin();

pending_finalizers.erase(ref_tracker);

ref_tracker->Finalize();

}

v8::Local<v8::Message> local_msg =

v8::Exception::CreateMessage(isolate, local_err);

node::errors::TriggerUncaughtException(isolate, local_err, local_msg);

CallIntoModule(call, [](napi_env env_, v8::Local<v8::Value> local_err) {

node_napi_env__* env = static_cast<node_napi_env__*>(env_);

if (env->terminatedOrTerminating()) {

return;

}

node::Environment* node_env = env->node_env();

// If the module api version is less than 10, and the option

// --force-node-api-uncaught-exceptions-policy is not specified, emit a

// warning about the uncaught exception instead of triggering the uncaught

// exception event.

if (env->module_api_version < 10 &&

!node_env->options()->force_node_api_uncaught_exceptions_policy &&

!enforceUncaughtExceptionPolicy) {

ProcessEmitDeprecationWarning(

node_env,

"Uncaught Node-API callback exception detected, please run node "

"with option --force-node-api-uncaught-exceptions-policy=true "

"to handle those exceptions properly.",

"DEP0168");

return;

}

// If there was an unhandled exception in the complete callback,

// report it as a fatal exception. (There is no JavaScript on the

// call stack that can possibly handle it.)

env->trigger_fatal_exception(local_err);

});

public:

static BufferFinalizer* New(napi_env env,

napi_finalize finalize_callback,

void* finalize_data,

void* finalize_hint) {

return new BufferFinalizer(

env, finalize_callback, finalize_data, finalize_hint);

}

// node::Buffer::FreeCallback

static void FinalizeBufferCallback(char* data, void* hint) {

std::unique_ptr<BufferFinalizer, Deleter> finalizer{

static_cast<BufferFinalizer*>(hint)};

// It is safe to call into JavaScript at this point.

finalizer->CallFinalizer();

}

struct Deleter {

void operator()(BufferFinalizer* finalizer) { delete finalizer; }

};

private:

BufferFinalizer(napi_env env,

napi_finalize finalize_callback,

void* finalize_data,

void* finalize_hint)

: Finalizer(env, finalize_callback, finalize_data, finalize_hint) {

env->Ref();

}

~BufferFinalizer() { env()->Unref(); }

public:

ThreadSafeFunction(v8::Local<v8::Function> func,

v8::Local<v8::Object> resource,

v8::Local<v8::String> name,

size_t thread_count_,

void* context_,

size_t max_queue_size_,

node_napi_env env_,

void* finalize_data_,

napi_finalize finalize_cb_,

napi_threadsafe_function_call_js call_js_cb_)

: async_resource(std::in_place,

env_->isolate,

resource,

node::Utf8Value(env_->isolate, name).ToStringView()),

thread_count(thread_count_),

state(kOpen),

dispatch_state(kDispatchIdle),

context(context_),

max_queue_size(max_queue_size_),

env(env_),

finalize_data(finalize_data_),

finalize_cb(finalize_cb_),

call_js_cb(call_js_cb_ == nullptr ? CallJs : call_js_cb_),

handles_closing(false) {

ref.Reset(env->isolate, func);

node::AddEnvironmentCleanupHook(env->isolate, Cleanup, this);

env->Ref();

}

~ThreadSafeFunction() { ReleaseResources(); }

// These methods can be called from any thread.

napi_status Push(void* data, napi_threadsafe_function_call_mode mode) {

{

node::Mutex::ScopedLock lock(this->mutex);

while (queue.size() >= max_queue_size && max_queue_size > 0 &&

state == kOpen) {

if (mode == napi_tsfn_nonblocking) {

return napi_queue_full;

}

cond->Wait(lock);

}

if (state == kOpen) {

queue.push(data);

Send();

return napi_ok;

}

if (thread_count == 0) {

return napi_invalid_arg;

}

thread_count--;

if (!(state == kClosed && thread_count == 0)) {

return napi_closing;

}

}

// Make sure to release lock before destroying

delete this;

return napi_closing;

}

napi_status Acquire() {

node::Mutex::ScopedLock lock(this->mutex);

if (state == kOpen) {

thread_count++;

return napi_ok;

}

return napi_closing;

}

napi_status Release(napi_threadsafe_function_release_mode mode) {

{

node::Mutex::ScopedLock lock(this->mutex);

if (thread_count == 0) {

return napi_invalid_arg;

}

thread_count--;

if (thread_count == 0 || mode == napi_tsfn_abort) {

if (state == kOpen) {

if (mode == napi_tsfn_abort) {

state = kClosing;

}

if (state == kClosing && max_queue_size > 0) {

cond->Signal(lock);

}

Send();

}

}

if (!(state == kClosed && thread_count == 0)) {

return napi_ok;

}

}

// Make sure to release lock before destroying

delete this;

return napi_ok;

}

void EmptyQueue() {

std::queue<void*> drain_queue;

{

node::Mutex::ScopedLock lock(this->mutex);

queue.swap(drain_queue);

}

for (; !drain_queue.empty(); drain_queue.pop()) {

call_js_cb(nullptr, nullptr, context, drain_queue.front());

}

}

void MaybeDelete() {

{

node::Mutex::ScopedLock lock(this->mutex);

if (thread_count > 0) {

// At this point this TSFN is effectively done, but we need to keep

// it alive for other threads that still have pointers to it until

// they release them.

// But we already release all the resources that we can at this point

ReleaseResources();

return;

}

}

// Make sure to release lock before destroying

delete this;

}

// These methods must only be called from the loop thread.

napi_status Init() {

ThreadSafeFunction* ts_fn = this;

uv_loop_t* loop = env->node_env()->event_loop();

if (uv_async_init(loop, &async, AsyncCb) == 0) {

if (max_queue_size > 0) {

cond = std::make_unique<node::ConditionVariable>();

}

if (max_queue_size == 0 || cond) {

return napi_ok;

}

env->node_env()->CloseHandle(

reinterpret_cast<uv_handle_t*>(&async),

[](uv_handle_t* handle) -> void {

ThreadSafeFunction* ts_fn =

node::ContainerOf(&ThreadSafeFunction::async,

reinterpret_cast<uv_async_t*>(handle));

delete ts_fn;

});

// Prevent the thread-safe function from being deleted here, because

// the callback above will delete it.

ts_fn = nullptr;

}

delete ts_fn;

return napi_generic_failure;

}

napi_status Unref() {

uv_unref(reinterpret_cast<uv_handle_t*>(&async));

return napi_ok;

}

napi_status Ref() {

uv_ref(reinterpret_cast<uv_handle_t*>(&async));

return napi_ok;

}

inline void* Context() { return context; }

protected:

void ReleaseResources() {

if (state != kClosed) {

state = kClosed;

ref.Reset();

node::RemoveEnvironmentCleanupHook(env->isolate, Cleanup, this);

env->Unref();

async_resource.reset();

}

}

void Dispatch() {

bool has_more = true;

// Limit maximum synchronous iteration count to prevent event loop

// starvation. See `src/node_messaging.cc` for an inspiration.

unsigned int iterations_left = kMaxIterationCount;

while (has_more && --iterations_left != 0) {

dispatch_state = kDispatchRunning;

has_more = DispatchOne();

// Send() was called while we were executing the JS function

if (dispatch_state.exchange(kDispatchIdle) != kDispatchRunning) {

has_more = true;

}

}

if (has_more) {

Send();

}

}

bool DispatchOne() {

void* data = nullptr;

bool popped_value = false;

bool has_more = false;

{

node::Mutex::ScopedLock lock(this->mutex);

if (state == kOpen) {

size_t size = queue.size();

if (size > 0) {

data = queue.front();

queue.pop();

popped_value = true;

if (size == max_queue_size && max_queue_size > 0) {

cond->Signal(lock);

}

size--;

}

if (size == 0) {

if (thread_count == 0) {

state = kClosing;

if (max_queue_size > 0) {

cond->Signal(lock);

}

CloseHandlesAndMaybeDelete();

}

} else {

has_more = true;

}

} else {

CloseHandlesAndMaybeDelete();

}

}

if (popped_value) {

v8::HandleScope scope(env->isolate);

AsyncResource::CallbackScope cb_scope(&*async_resource);

napi_value js_callback = nullptr;

if (!ref.IsEmpty()) {

v8::Local<v8::Function> js_cb =

v8::Local<v8::Function>::New(env->isolate, ref);

js_callback = v8impl::JsValueFromV8LocalValue(js_cb);

}

env->CallbackIntoModule<false>(

[&](napi_env env) { call_js_cb(env, js_callback, context, data); });

}

return has_more;

}

void Finalize() {

v8::HandleScope scope(env->isolate);

EmptyQueue();

if (finalize_cb) {

AsyncResource::CallbackScope cb_scope(&*async_resource);

env->CallFinalizer<false>(finalize_cb, finalize_data, context);

}

MaybeDelete();

}

void CloseHandlesAndMaybeDelete(bool set_closing = false) {

v8::HandleScope scope(env->isolate);

if (set_closing) {

node::Mutex::ScopedLock lock(this->mutex);

state = kClosing;

if (max_queue_size > 0) {

cond->Signal(lock);

}

}

if (handles_closing) {

return;

}

handles_closing = true;

env->node_env()->CloseHandle(

reinterpret_cast<uv_handle_t*>(&async),

[](uv_handle_t* handle) -> void {

ThreadSafeFunction* ts_fn =

node::ContainerOf(&ThreadSafeFunction::async,

reinterpret_cast<uv_async_t*>(handle));

ts_fn->Finalize();

});

}

void Send() {

// Ask currently running Dispatch() to make one more iteration

unsigned char current_state = dispatch_state.fetch_or(kDispatchPending);

if ((current_state & kDispatchRunning) == kDispatchRunning) {

return;

}

CHECK_EQ(0, uv_async_send(&async));

}

// Default way of calling into JavaScript. Used when ThreadSafeFunction is

// without a call_js_cb_.

static void CallJs(napi_env env, napi_value cb, void* context, void* data) {

if (!(env == nullptr || cb == nullptr)) {

napi_value recv;

napi_status status;

status = napi_get_undefined(env, &recv);

if (status != napi_ok) {

napi_throw_error(env,

"ERR_NAPI_TSFN_GET_UNDEFINED",

"Failed to retrieve undefined value");

return;

}

status = napi_call_function(env, recv, cb, 0, nullptr, nullptr);

if (status != napi_ok && status != napi_pending_exception) {

napi_throw_error(

env, "ERR_NAPI_TSFN_CALL_JS", "Failed to call JS callback");

return;

}

}

}

static void AsyncCb(uv_async_t* async) {

ThreadSafeFunction* ts_fn =

node::ContainerOf(&ThreadSafeFunction::async, async);

ts_fn->Dispatch();

}

static void Cleanup(void* data) {

reinterpret_cast<ThreadSafeFunction*>(data)->CloseHandlesAndMaybeDelete(

true);

}

private:

// Needed because node::AsyncResource::CallbackScope is protected

class AsyncResource : public node::AsyncResource {

public:

using node::AsyncResource::AsyncResource;

using node::AsyncResource::CallbackScope;

};

enum State : unsigned char { kOpen, kClosing, kClosed };

static const unsigned char kDispatchIdle = 0;

static const unsigned char kDispatchRunning = 1 << 0;

static const unsigned char kDispatchPending = 1 << 1;

static const unsigned int kMaxIterationCount = 1000;

std::optional<AsyncResource> async_resource;

// These are variables protected by the mutex.

node::Mutex mutex;

std::unique_ptr<node::ConditionVariable> cond;

std::queue<void*> queue;

uv_async_t async;

size_t thread_count;

State state;

std::atomic_uchar dispatch_state;

// These are variables set once, upon creation, and then never again, which

// means we don't need the mutex to read them.

void* context;

size_t max_queue_size;

// These are variables accessed only from the loop thread.

v8impl::Persistent<v8::Function> ref;

node_napi_env env;

void* finalize_data;

napi_finalize finalize_cb;

napi_threadsafe_function_call_js call_js_cb;

bool handles_closing;

public:

AsyncContext(node_napi_env env,

v8::Local<v8::Object> resource_object,

v8::Local<v8::String> resource_name)

: env_(env) {

async_id_ = node_env()->new_async_id();

trigger_async_id_ = node_env()->get_default_trigger_async_id();

v8::Isolate* isolate = node_env()->isolate();

resource_.Reset(isolate, resource_object);

context_frame_.Reset(isolate, node::async_context_frame::current(isolate));

node::AsyncWrap::EmitAsyncInit(node_env(),

resource_object,

resource_name,

async_id_,

trigger_async_id_);

}

~AsyncContext() { node::AsyncWrap::EmitDestroy(node_env(), async_id_); }

inline v8::MaybeLocal<v8::Value> MakeCallback(

v8::Local<v8::Object> recv,

const v8::Local<v8::Function> callback,

int argc,

v8::Local<v8::Value> argv[]) {

return node::InternalMakeCallback(

node_env(),

resource(),

recv,

callback,

argc,

argv,

{async_id_, trigger_async_id_},

context_frame_.Get(node_env()->isolate()));

}

inline napi_callback_scope OpenCallbackScope() {

auto scope = new HeapAllocatedCallbackScope(this);

env_->open_callback_scopes++;

return scope->to_opaque();

}

inline node::Environment* node_env() { return env_->node_env(); }

inline v8::Local<v8::Object> resource() {

return resource_.Get(node_env()->isolate());

}

inline node::async_context async_context() {

return {async_id_, trigger_async_id_};

}

static inline void CloseCallbackScope(node_napi_env env,

napi_callback_scope s) {

delete HeapAllocatedCallbackScope::FromOpaque(s);

CHECK_GT(env->open_callback_scopes, 0);

env->open_callback_scopes--;

}

private:

class HeapAllocatedCallbackScope final {

public:

napi_callback_scope to_opaque() {

return reinterpret_cast<napi_callback_scope>(this);

}

static HeapAllocatedCallbackScope* FromOpaque(napi_callback_scope s) {

return reinterpret_cast<HeapAllocatedCallbackScope*>(s);

}

explicit HeapAllocatedCallbackScope(AsyncContext* async_context)

: cs_(async_context->node_env(),

&async_context->resource_,

async_context->async_context()) {}

private:

node::CallbackScope cs_;

};

node_napi_env env_;

double async_id_;

double trigger_async_id_;

v8::Global<v8::Object> resource_;

v8::Global<v8::Value> context_frame_;

v8::Local<v8::Value> module,

v8::Local<v8::Context> context,

void* priv) {

napi_module_register_by_symbol(

exports,

module,

context,

static_cast<const napi_module*>(priv)->nm_register_func);

v8::Local<v8::Value> module,

v8::Local<v8::Context> context,

void* priv) {

napi_module_register_by_symbol(

exports,

module,

context,

reinterpret_cast<napi_addon_register_func>(priv),

module_api_version);

node::Environment* node_env,

const char* module_name,

int32_t module_api_version) {

static_assert(

NODE_API_SUPPORTED_VERSION_MAX == 10,

"New version of Node-API requires adding another else-if statement below "

"for the new version and updating this assert condition.");

if (module_api_version == 9) {

return node_api_context_register_func<9>;

} else if (module_api_version == 10) {

return node_api_context_register_func<10>;

} else if (module_api_version == NAPI_VERSION_EXPERIMENTAL) {

return node_api_context_register_func<NAPI_VERSION_EXPERIMENTAL>;

} else if (module_api_version >= NODE_API_SUPPORTED_VERSION_MIN &&

module_api_version <= NODE_API_DEFAULT_MODULE_API_VERSION) {

return node_api_context_register_func<NODE_API_DEFAULT_MODULE_API_VERSION>;

} else {

v8impl::ThrowNodeApiVersionError(node_env, module_name, module_api_version);

return nullptr;

}

v8::Local<v8::Value> module,

v8::Local<v8::Context> context,

napi_addon_register_func init,

int32_t module_api_version) {

node::Environment* node_env = node::Environment::GetCurrent(context);

CHECK_NOT_NULL(node_env);

std::string module_filename = "";

if (init == nullptr) {

node_env->ThrowError("Module has no declared entry point.");

return;

}

// We set `env->filename` from `module.filename` here, but we could just as

// easily add a private property to `exports` in `process.dlopen`, which

// receives the file name from JS, and retrieve *that* here. Thus, we are not

// endorsing commonjs here by making use of `module.filename`.

v8::Local<v8::Value> filename_js;

v8::Local<v8::Object> modobj;

if (module->ToObject(context).ToLocal(&modobj) &&

modobj->Get(context, node_env->filename_string()).ToLocal(&filename_js) &&

filename_js->IsString()) {

node::Utf8Value filename(node_env->isolate(), filename_js);

// Turn the absolute path into a URL. Currently the absolute path is always

// a file system path.

// TODO(gabrielschulhof): Pass the `filename` through unchanged if/when we

// receive it as a URL already.

module_filename = node::url::FromFilePath(filename.ToStringView());

}

// Create a new napi_env for this specific module.

napi_env env =

node_napi_env__::New(context, module_filename, module_api_version);

napi_value _exports = nullptr;

env->CallIntoModule([&](napi_env env) {

_exports = init(env, v8impl::JsValueFromV8LocalValue(exports));

});

// If register function returned a non-null exports object different from

// the exports object we passed it, set that as the "exports" property of

// the module.

if (_exports != nullptr &&

_exports != v8impl::JsValueFromV8LocalValue(exports)) {

napi_value _module = v8impl::JsValueFromV8LocalValue(module);

napi_set_named_property(env, _module, "exports", _exports);

}

return {

-1,

mod->nm_flags | NM_F_DELETEME,

nullptr,

mod->nm_filename,

nullptr,

napi_module_register_cb,

mod->nm_modname,

const_cast<napi_module*>(mod), // priv

nullptr,

};

node::node_module* nm =

new node::node_module(node::napi_module_to_node_module(mod));

node::node_module_register(nm);

napi_cleanup_hook fun,

void* arg) {

CHECK_ENV(env);

CHECK_ARG(env, fun);

node::AddEnvironmentCleanupHook(env->isolate, fun, arg);

return napi_ok;

napi_cleanup_hook fun,

void* arg) {

CHECK_ENV(env);

CHECK_ARG(env, fun);

node::RemoveEnvironmentCleanupHook(env->isolate, fun, arg);

return napi_ok;

napi_async_cleanup_hook_handle__(napi_env env,

napi_async_cleanup_hook user_hook,

void* user_data)

: env_(env), user_hook_(user_hook), user_data_(user_data) {

handle_ = node::AddEnvironmentCleanupHook(env->isolate, Hook, this);

env->Ref();

}

~napi_async_cleanup_hook_handle__() {

node::RemoveEnvironmentCleanupHook(std::move(handle_));

if (done_cb_ != nullptr) done_cb_(done_data_);

// Release the `env` handle asynchronously since it would be surprising if

// a call to a Node-API function would destroy `env` synchronously.

static_cast<node_napi_env>(env_)->node_env()->SetImmediate(

[env = env_](node::Environment*) { env->Unref(); });

}

static void Hook(void* data, void (*done_cb)(void*), void* done_data) {

napi_async_cleanup_hook_handle__* handle =

static_cast<napi_async_cleanup_hook_handle__*>(data);

handle->done_cb_ = done_cb;

handle->done_data_ = done_data;

handle->user_hook_(handle, handle->user_data_);

}

node::AsyncCleanupHookHandle handle_;

napi_env env_ = nullptr;

napi_async_cleanup_hook user_hook_ = nullptr;

void* user_data_ = nullptr;

void (*done_cb_)(void*) = nullptr;

void* done_data_ = nullptr;

napi_async_cleanup_hook hook,

void* arg,

napi_async_cleanup_hook_handle* remove_handle) {

napi_env env = const_cast<napi_env>(basic_env);

CHECK_ENV(env);

CHECK_ARG(env, hook);

napi_async_cleanup_hook_handle__* handle =

new napi_async_cleanup_hook_handle__(env, hook, arg);

if (remove_handle != nullptr) *remove_handle = handle;

return napi_clear_last_error(env);

if (remove_handle == nullptr) return napi_invalid_arg;

delete remove_handle;

return napi_ok;

NAPI_PREAMBLE(env);

CHECK_ARG(env, err);

v8::Local<v8::Value> local_err = v8impl::V8LocalValueFromJsValue(err);

static_cast<node_napi_env>(env)->trigger_fatal_exception(local_err);

return napi_clear_last_error(env);

size_t location_len,

const char* message,

size_t message_len) {

std::string location_string;

std::string message_string;

if (location_len != NAPI_AUTO_LENGTH) {

location_string.assign(const_cast<char*>(location), location_len);

} else {

location_string.assign(const_cast<char*>(location), strlen(location));

}

if (message_len != NAPI_AUTO_LENGTH) {

message_string.assign(const_cast<char*>(message), message_len);

} else {

message_string.assign(const_cast<char*>(message), strlen(message));

}

node::OnFatalError(location_string.c_str(), message_string.c_str());

napi_value /** ignored */,

napi_async_context async_context_handle,

napi_callback_scope* result) {

// Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw

// JS exceptions.

CHECK_ENV(env);

CHECK_ARG(env, result);

v8impl::AsyncContext* node_async_context =

reinterpret_cast<v8impl::AsyncContext*>(async_context_handle);

*result = node_async_context->OpenCallbackScope();

return napi_clear_last_error(env);

napi_callback_scope scope) {

// Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw

// JS exceptions.

CHECK_ENV(env);

CHECK_ARG(env, scope);

if (env->open_callback_scopes == 0) {

return napi_callback_scope_mismatch;

}

v8impl::AsyncContext::CloseCallbackScope(reinterpret_cast<node_napi_env>(env),

scope);

return napi_clear_last_error(env);

napi_value async_resource,

napi_value async_resource_name,

napi_async_context* result) {

CHECK_ENV_NOT_IN_GC(env);

CHECK_ARG(env, async_resource_name);

CHECK_ARG(env, result);

v8::Isolate* isolate = env->isolate;

v8::Local<v8::Context> context = env->context();

v8::Local<v8::Object> v8_resource;

if (async_resource != nullptr) {

CHECK_TO_OBJECT(env, context, v8_resource, async_resource);

} else {

v8_resource = v8::Object::New(isolate);

}

v8::Local<v8::String> v8_resource_name;

CHECK_TO_STRING(env, context, v8_resource_name, async_resource_name);

v8impl::AsyncContext* async_context = new v8impl::AsyncContext(

reinterpret_cast<node_napi_env>(env), v8_resource, v8_resource_name);

*result = reinterpret_cast<napi_async_context>(async_context);

return napi_clear_last_error(env);

napi_async_context async_context) {

CHECK_ENV_NOT_IN_GC(env);

CHECK_ARG(env, async_context);

v8impl::AsyncContext* node_async_context =

reinterpret_cast<v8impl::AsyncContext*>(async_context);

delete node_async_context;

return napi_clear_last_error(env);