emnapi 0.33.1 → 0.35.0

package/dist/library_napi.js

@@ -1,37 +1,33 @@
 {{{ ((DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.indexOf("$emnapiInit") === -1 ? DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.push("$emnapiInit") : undefined), "") }}}
 {{{ ((EXPORTED_RUNTIME_METHODS.indexOf("emnapiInit") === -1 ? EXPORTED_RUNTIME_METHODS.push("emnapiInit") : undefined), "") }}}
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function emnapiCreateIdGenerator() {
-    var obj = {
-        nextId: 1,
-        list: [],
-        generate: function () {
-            var id;
-            if (obj.list.length) {
-                id = obj.list.shift();
-            }
-            else {
-                id = obj.nextId;
-                obj.nextId++;
-            }
-            return id;
-        },
-        reuse: function (id) {
-            obj.list.push(id);
-        }
-    };
-    return obj;
-}
-var emnapiAsyncWork = {
+var emnapiAWST = {
     idGen: {},
     values: [undefined],
     queued: new Set(),
     pending: [],
     init: function () {
-        emnapiAsyncWork.idGen = emnapiCreateIdGenerator();
-        emnapiAsyncWork.values = [undefined];
-        emnapiAsyncWork.queued = new Set();
-        emnapiAsyncWork.pending = [];
+        var idGen = {
+            nextId: 1,
+            list: [],
+            generate: function () {
+                var id;
+                if (idGen.list.length) {
+                    id = idGen.list.shift();
+                }
+                else {
+                    id = idGen.nextId;
+                    idGen.nextId++;
+                }
+                return id;
+            },
+            reuse: function (id) {
+                idGen.list.push(id);
+            }
+        };
+        emnapiAWST.idGen = idGen;
+        emnapiAWST.values = [undefined];
+        emnapiAWST.queued = new Set();
+        emnapiAWST.pending = [];
     },
     create: function (env, resource, resourceName, execute, complete, data) {
         var asyncId = 0;
@@ -41,12 +37,11 @@ var emnapiAsyncWork = {
             asyncId = asyncContext.asyncId;
             triggerAsyncId = asyncContext.triggerAsyncId;
         }
-        var id = emnapiAsyncWork.idGen.generate();
-        emnapiAsyncWork.values[id] = {
+        var id = emnapiAWST.idGen.generate();
+        emnapiAWST.values[id] = {
             env: env,
             id: id,
             resource: resource,
-            resourceName: resourceName,
             asyncId: asyncId,
             triggerAsyncId: triggerAsyncId,
             status: 0,
@@ -62,6 +57,8 @@ var emnapiAsyncWork = {
         var env = work.env;
         var data = work.data;
         var callback = function () {
+            if (!complete)
+                return;
             var envObject = emnapiCtx.envStore.get(env);
             var scope = emnapiCtx.openScope(envObject);
             try {
@@ -84,16 +81,16 @@ var emnapiAsyncWork = {
         }
     },
     queue: function (id) {
-        var work = emnapiAsyncWork.values[id];
+        var work = emnapiAWST.values[id];
         if (!work)
             return;
         if (work.status === 0) {
             work.status = 1;
-            if (emnapiAsyncWork.queued.size >= 4) {
-                emnapiAsyncWork.pending.push(id);
+            if (emnapiAWST.queued.size >= (Math.abs(emnapiAsyncWorkPoolSize) || 4)) {
+                emnapiAWST.pending.push(id);
                 return;
             }
-            emnapiAsyncWork.queued.add(id);
+            emnapiAWST.queued.add(id);
             var env_1 = work.env;
             var data_1 = work.data;
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -101,25 +98,29 @@ var emnapiAsyncWork = {
             work.status = 2;
             emnapiCtx.feature.setImmediate(function () {
                 {{{ makeDynCall('vpp', 'execute') }}}(env_1, data_1);
-                emnapiAsyncWork.queued.delete(id);
+                emnapiAWST.queued.delete(id);
                 work.status = 3;
-                emnapiAsyncWork.callComplete(work, 0 /* napi_status.napi_ok */);
-                if (emnapiAsyncWork.pending.length > 0) {
-                    var nextWorkId = emnapiAsyncWork.pending.shift();
-                    emnapiAsyncWork.values[nextWorkId].status = 0;
-                    emnapiAsyncWork.queue(nextWorkId);
+                emnapiCtx.feature.setImmediate(function () {
+                    emnapiAWST.callComplete(work, 0 /* napi_status.napi_ok */);
+                });
+                if (emnapiAWST.pending.length > 0) {
+                    var nextWorkId = emnapiAWST.pending.shift();
+                    emnapiAWST.values[nextWorkId].status = 0;
+                    emnapiAWST.queue(nextWorkId);
                 }
             });
         }
     },
     cancel: function (id) {
-        var index = emnapiAsyncWork.pending.indexOf(id);
+        var index = emnapiAWST.pending.indexOf(id);
         if (index !== -1) {
-            var work = emnapiAsyncWork.values[id];
-            if (work && (work.status === 1)) {
-                work.status = 4;
-                emnapiAsyncWork.pending.splice(index, 1);
-                emnapiAsyncWork.callComplete(work, 11 /* napi_status.napi_cancelled */);
+            var work_1 = emnapiAWST.values[id];
+            if (work_1 && (work_1.status === 1)) {
+                work_1.status = 4;
+                emnapiAWST.pending.splice(index, 1);
+                emnapiCtx.feature.setImmediate(function () {
+                    emnapiAWST.callComplete(work_1, 11 /* napi_status.napi_cancelled */);
+                });
                 return 0 /* napi_status.napi_ok */;
             }
             else {
@@ -129,7 +130,7 @@ var emnapiAsyncWork = {
         return 9 /* napi_status.napi_generic_failure */;
     },
     remove: function (id) {
-        var work = emnapiAsyncWork.values[id];
+        var work = emnapiAWST.values[id];
         if (!work)
             return;
         if (emnapiNodeBinding) {
@@ -138,68 +139,11 @@ var emnapiAsyncWork = {
                 triggerAsyncId: work.triggerAsyncId
             });
         }
-        emnapiAsyncWork.values[id] = undefined;
-        emnapiAsyncWork.idGen.reuse(id);
+        emnapiAWST.values[id] = undefined;
+        emnapiAWST.idGen.reuse(id);
     }
 };
-function _napi_create_async_work(env, resource, resource_name, execute, complete, data, result) {
-    if (env == 0)
-        return 1 /* napi_status.napi_invalid_arg */;
-    var envObject = emnapiCtx.envStore.get(env);
-    if (execute == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    if (result == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    var resourceObject;
-    if (resource) {
-        resourceObject = Object(emnapiCtx.handleStore.get(resource).value);
-    }
-    else {
-        resourceObject = {};
-    }
-    if (resource_name == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    var resourceName = String(emnapiCtx.handleStore.get(resource_name).value);
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    var id = emnapiAsyncWork.create(env, resourceObject, resourceName, execute, complete, data);
-    {{{ makeSetValue('result', 0, 'id', '*') }}};
-    return envObject.clearLastError();
-}
-function _napi_delete_async_work(env, work) {
-    if (env == 0)
-        return 1 /* napi_status.napi_invalid_arg */;
-    var envObject = emnapiCtx.envStore.get(env);
-    if (work == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    emnapiAsyncWork.remove(work);
-    return envObject.clearLastError();
-}
-function _napi_queue_async_work(env, work) {
-    if (env == 0)
-        return 1 /* napi_status.napi_invalid_arg */;
-    var envObject = emnapiCtx.envStore.get(env);
-    if (work == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    emnapiAsyncWork.queue(work);
-    return envObject.clearLastError();
-}
-function _napi_cancel_async_work(env, work) {
-    if (env == 0)
-        return 1 /* napi_status.napi_invalid_arg */;
-    var envObject = emnapiCtx.envStore.get(env);
-    if (work == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    var status = emnapiAsyncWork.cancel(work);
-    if (status === 0 /* napi_status.napi_ok */)
-        return envObject.clearLastError();
-    return envObject.setLastError(status);
-}
-emnapiImplementHelper('$emnapiCreateIdGenerator', undefined, emnapiCreateIdGenerator, []);
-emnapiDefineVar('$emnapiAsyncWork', emnapiAsyncWork, ['$emnapiCreateIdGenerator'], 'emnapiAsyncWork.init();');
-emnapiImplement('napi_create_async_work', 'ippppppp', _napi_create_async_work, ['$emnapiAsyncWork']);
-emnapiImplement('napi_delete_async_work', 'ipp', _napi_delete_async_work, ['$emnapiAsyncWork']);
-emnapiImplement('napi_queue_async_work', 'ipp', _napi_queue_async_work, ['$emnapiAsyncWork']);
-emnapiImplement('napi_cancel_async_work', 'ipp', _napi_cancel_async_work, ['$emnapiAsyncWork']);
+emnapiDefineVar('$emnapiAWST', emnapiAWST, ['$emnapiAsyncWorkPoolSize'], 'emnapiAWST.init();');
 function _emnapi_create_memory_view(env, typedarray_type, external_data, byte_length, finalize_cb, finalize_hint, result
 // @ts-expect-error
 ) {
@@ -800,14 +744,14 @@ emnapiImplement('node_api_create_syntax_error', 'ipppp', node_api_create_syntax_
 emnapiImplement('napi_is_exception_pending', 'ipp', napi_is_exception_pending);
 emnapiImplement('napi_fatal_error', 'vpppp', napi_fatal_error, ['$emnapiUtf8ToString']);
 emnapiImplement('napi_fatal_exception', 'ipp', napi_fatal_exception);
-/* eslint-disable @typescript-eslint/restrict-plus-operands */
 // @ts-expect-error
 function napi_create_function(env, utf8name, length, cb, data, result) {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     var value;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_10 = emnapiCtx.envStore.get(env);
+    var envObject_10 = emnapiCtx
+        .envStore.get(env);
     if (envObject_10.tryCatch.hasCaught())
         return envObject_10.setLastError(10 /* napi_status.napi_pending_exception */);
     envObject_10.clearLastError();
@@ -881,7 +825,8 @@ function napi_call_function(env, recv, func, argc, argv, result
     var v;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_11 = emnapiCtx.envStore.get(env);
+    var envObject_11 = emnapiCtx
+        .envStore.get(env);
     if (envObject_11.tryCatch.hasCaught())
         return envObject_11.setLastError(10 /* napi_status.napi_pending_exception */);
     envObject_11.clearLastError();
@@ -927,7 +872,8 @@ function napi_new_instance(env, constructor, argc, argv, result
     var v;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_12 = emnapiCtx.envStore.get(env);
+    var envObject_12 = emnapiCtx
+        .envStore.get(env);
     if (envObject_12.tryCatch.hasCaught())
         return envObject_12.setLastError(10 /* napi_status.napi_pending_exception */);
     envObject_12.clearLastError();
@@ -1545,7 +1491,6 @@ function __emnapi_node_make_callback(env, async_resource, cb, argv, size, async_
     size = size >>> 0;
     var arr = Array(size);
     for (; i < size; i++) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/restrict-plus-operands
         var argVal = {{{ makeGetValue('argv', 'i * ' + POINTER_SIZE, '*') }}};
         arr[i] = emnapiCtx.handleStore.get(argVal).value;
     }
@@ -1641,7 +1586,6 @@ function napi_make_callback(env, async_context, recv, func, argc, argv, result)
         argc = argc >>> 0;
         var arr_1 = Array(argc);
         for (; i < argc; i++) {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/restrict-plus-operands
             var argVal_4 = {{{ makeGetValue("argv", "i * " + POINTER_SIZE, "*") }}};
             arr_1[i] = emnapiCtx.handleStore.get(argVal_4).value;
         }
@@ -2517,69 +2461,844 @@ function napi_run_script(env, script, result) {
     return status;
 }
 emnapiImplement('napi_run_script', 'ippp', napi_run_script, ['napi_set_last_error']);
-function __emnapi_set_immediate(callback, data) {
-    emnapiCtx.feature.setImmediate(function () {
-        {{{ makeDynCall('vp', 'callback') }}}(data);
-    });
-}
-function __emnapi_next_tick(callback, data) {
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    Promise.resolve().then(function () {
-        {{{ makeDynCall('vp', 'callback') }}}(data);
-    });
-}
-function __emnapi_call_into_module(env, callback, data, close_scope_if_throw) {
-    var envObject = emnapiCtx.envStore.get(env);
-    var scope = emnapiCtx.openScope(envObject);
-    try {
-        envObject.callIntoModule(function () {
-            {{{ makeDynCall('vpp', 'callback') }}}(env, data);
+/* eslint-disable @typescript-eslint/indent */
+var emnapiTSFN = {
+    offset: {
+        /* napi_ref */ resource: 0,
+        /* double */ async_id: 8,
+        /* double */ trigger_async_id: 16,
+        /* size_t */ queue_size: 24,
+        /* void* */ queue: 1 * {{{ POINTER_SIZE }}} + 24,
+        /* size_t */ thread_count: 2 * {{{ POINTER_SIZE }}} + 24,
+        /* bool */ is_closing: 3 * {{{ POINTER_SIZE }}} + 24,
+        /* atomic_uchar */ dispatch_state: 3 * {{{ POINTER_SIZE }}} + 28,
+        /* void* */ context: 3 * {{{ POINTER_SIZE }}} + 32,
+        /* size_t */ max_queue_size: 4 * {{{ POINTER_SIZE }}} + 32,
+        /* napi_ref */ ref: 5 * {{{ POINTER_SIZE }}} + 32,
+        /* napi_env */ env: 6 * {{{ POINTER_SIZE }}} + 32,
+        /* void* */ finalize_data: 7 * {{{ POINTER_SIZE }}} + 32,
+        /* napi_finalize */ finalize_cb: 8 * {{{ POINTER_SIZE }}} + 32,
+        /* napi_threadsafe_function_call_js */ call_js_cb: 9 * {{{ POINTER_SIZE }}} + 32,
+        /* bool */ handles_closing: 10 * {{{ POINTER_SIZE }}} + 32,
+        /* bool */ async_ref: 10 * {{{ POINTER_SIZE }}} + 36,
+        /* int32_t */ mutex: 10 * {{{ POINTER_SIZE }}} + 40,
+        /* int32_t */ cond: 10 * {{{ POINTER_SIZE }}} + 44,
+        end: 10 * {{{ POINTER_SIZE }}} + 48
+    },
+    init: function () {
+        if (typeof PThread !== 'undefined') {
+            PThread.unusedWorkers.forEach(emnapiTSFN.addListener);
+            PThread.runningWorkers.forEach(emnapiTSFN.addListener);
+            var __original_getNewWorker_1 = PThread.getNewWorker;
+            PThread.getNewWorker = function () {
+                var r = __original_getNewWorker_1.apply(this, arguments);
+                emnapiTSFN.addListener(r);
+                return r;
+            };
+        }
+    },
+    addListener: function (worker) {
+        if (!worker)
+            return false;
+        if (worker._emnapiTSFNListener)
+            return true;
+        var handler = function (e) {
+            var data = ENVIRONMENT_IS_NODE ? e : e.data;
+            var __emnapi__ = data.__emnapi__;
+            if (__emnapi__) {
+                var type = __emnapi__.type;
+                var payload = __emnapi__.payload;
+                if (type === 'tsfn-send') {
+                    emnapiTSFN.dispatch(payload.tsfn);
+                }
+            }
+        };
+        var dispose = function () {
+            if (ENVIRONMENT_IS_NODE) {
+                worker.off('message', handler);
+            }
+            else {
+                worker.removeEventListener('message', handler, false);
+            }
+            delete worker._emnapiTSFNListener;
+        };
+        worker._emnapiTSFNListener = { handler: handler, dispose: dispose };
+        if (ENVIRONMENT_IS_NODE) {
+            worker.on('message', handler);
+        }
+        else {
+            worker.addEventListener('message', handler, false);
+        }
+        return true;
+    },
+    initQueue: function (func) {
+        var size = 2 * {{{ POINTER_SIZE }}};
+        var queue = {{{ makeMalloc('emnapiTSFN.initQueue', 'size') }}};
+        if (!queue)
+            return false;
+        new Uint8Array(wasmMemory.buffer, queue, size).fill(0);
+        emnapiTSFN.storeSizeTypeValue(func + emnapiTSFN.offset.queue, queue, false);
+        return true;
+    },
+    destroyQueue: function (func) {
+        var queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);
+        if (queue) {
+            _free({{{ to64('queue') }}});
+        }
+    },
+    pushQueue: function (func, data) {
+        var queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);
+        var head = emnapiTSFN.loadSizeTypeValue(queue, false);
+        var tail = emnapiTSFN.loadSizeTypeValue(queue + {{{ POINTER_SIZE }}}, false);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        var size = 2 * {{{ POINTER_SIZE }}};
+        var node = {{{ makeMalloc('emnapiTSFN.pushQueue', 'size') }}};
+        if (!node)
+            throw new Error('OOM');
+        emnapiTSFN.storeSizeTypeValue(node, data, false);
+        emnapiTSFN.storeSizeTypeValue(node + {{{ POINTER_SIZE }}}, 0, false);
+        if (head === 0 && tail === 0) {
+            emnapiTSFN.storeSizeTypeValue(queue, node, false);
+            emnapiTSFN.storeSizeTypeValue(queue + {{{ POINTER_SIZE }}}, node, false);
+        }
+        else {
+            emnapiTSFN.storeSizeTypeValue(tail + {{{ POINTER_SIZE }}}, node, false);
+            emnapiTSFN.storeSizeTypeValue(queue + {{{ POINTER_SIZE }}}, node, false);
+        }
+        emnapiTSFN.addQueueSize(func);
+    },
+    shiftQueue: function (func) {
+        var queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);
+        var head = emnapiTSFN.loadSizeTypeValue(queue, false);
+        if (head === 0)
+            return 0;
+        var node = head;
+        var next = emnapiTSFN.loadSizeTypeValue(head + {{{ POINTER_SIZE }}}, false);
+        emnapiTSFN.storeSizeTypeValue(queue, next, false);
+        if (next === 0) {
+            emnapiTSFN.storeSizeTypeValue(queue + {{{ POINTER_SIZE }}}, 0, false);
+        }
+        emnapiTSFN.storeSizeTypeValue(node + {{{ POINTER_SIZE }}}, 0, false);
+        var value = emnapiTSFN.loadSizeTypeValue(node, false);
+        _free({{{ to64('node') }}});
+        emnapiTSFN.subQueueSize(func);
+        return value;
+    },
+    push: function (func, data, mode) {
+        var mutex = emnapiTSFN.getMutex(func);
+        var cond = emnapiTSFN.getCond(func);
+        var waitCondition = function () {
+            var queueSize = emnapiTSFN.getQueueSize(func);
+            var maxSize = emnapiTSFN.getMaxQueueSize(func);
+            var isClosing = emnapiTSFN.getIsClosing(func);
+            return queueSize >= maxSize && maxSize > 0 && !isClosing;
+        };
+        var isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE;
+        return mutex.execute(function () {
+            while (waitCondition()) {
+                if (mode === 0 /* napi_threadsafe_function_call_mode.napi_tsfn_nonblocking */) {
+                    return 15 /* napi_status.napi_queue_full */;
+                }
+                /**
+                 * Browser JS main thread can not use `Atomics.wait`
+                 *
+                 * Related:
+                 * https://github.com/nodejs/node/pull/32689
+                 * https://github.com/nodejs/node/pull/33453
+                 */
+                if (isBrowserMain) {
+                    return 21 /* napi_status.napi_would_deadlock */;
+                }
+                cond.wait();
+            }
+            if (emnapiTSFN.getIsClosing(func)) {
+                if (emnapiTSFN.getThreadCount(func) === 0) {
+                    return 1 /* napi_status.napi_invalid_arg */;
+                }
+                else {
+                    emnapiTSFN.subThreadCount(func);
+                    return 16 /* napi_status.napi_closing */;
+                }
+            }
+            else {
+                emnapiTSFN.pushQueue(func, data);
+                emnapiTSFN.send(func);
+                return 0 /* napi_status.napi_ok */;
+            }
         });
-    }
-    catch (err) {
-        emnapiCtx.closeScope(envObject, scope);
-        if (close_scope_if_throw) {
+    },
+    getMutex: function (func) {
+        var index = func + emnapiTSFN.offset.mutex;
+        var mutex = {
+            lock: function () {
+                var isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE;
+                var i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                if (isBrowserMain) {
+                    while (true) {
+                        var oldValue = Atomics.compareExchange(i32a, 0, 0, 1);
+                        if (oldValue === 0) {
+                            return;
+                        }
+                    }
+                }
+                else {
+                    while (true) {
+                        var oldValue = Atomics.compareExchange(i32a, 0, 0, 1);
+                        if (oldValue === 0) {
+                            return;
+                        }
+                        Atomics.wait(i32a, 0, 1);
+                    }
+                }
+            },
+            /* lockAsync () {
+              return new Promise<void>(resolve => {
+                const again = (): void => { fn() }
+                const fn = (): void => {
+                  const i32a = new Int32Array(wasmMemory.buffer, index, 1)
+                  const oldValue = Atomics.compareExchange(i32a, 0, 0, 1)
+                  if (oldValue === 0) {
+                    resolve()
+                    return
+                  }
+                  (Atomics as any).waitAsync(i32a, 0, 1).value.then(again)
+                }
+                fn()
+              })
+            }, */
+            unlock: function () {
+                var i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                var oldValue = Atomics.compareExchange(i32a, 0, 1, 0);
+                if (oldValue !== 1) {
+                    throw new Error('Tried to unlock while not holding the mutex');
+                }
+                Atomics.notify(i32a, 0, 1);
+            },
+            execute: function (fn) {
+                mutex.lock();
+                try {
+                    return fn();
+                }
+                finally {
+                    mutex.unlock();
+                }
+            } /* ,
+            executeAsync<T> (fn: () => Promise<T>): Promise<T> {
+              return mutex.lockAsync().then(() => {
+                const r = fn()
+                mutex.unlock()
+                return r
+              }, (err) => {
+                mutex.unlock()
+                throw err
+              })
+            } */
+        };
+        return mutex;
+    },
+    getCond: function (func) {
+        var index = func + emnapiTSFN.offset.cond;
+        var mutex = emnapiTSFN.getMutex(func);
+        var cond = {
+            wait: function () {
+                var i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                var value = Atomics.load(i32a, 0);
+                mutex.unlock();
+                Atomics.wait(i32a, 0, value);
+                mutex.lock();
+            },
+            /* waitAsync () {
+              const i32a = new Int32Array(wasmMemory.buffer, index, 1)
+              const value = Atomics.load(i32a, 0)
+              mutex.unlock()
+              const lock = (): Promise<void> => mutex.lockAsync()
+              try {
+                return (Atomics as any).waitAsync(i32a, 0, value).value.then(lock, lock)
+              } catch (err) {
+                return lock()
+              }
+            }, */
+            signal: function () {
+                var i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                Atomics.add(i32a, 0, 1);
+                Atomics.notify(i32a, 0, 1);
+            }
+        };
+        return cond;
+    },
+    getQueueSize: function (func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue_size, true);
+    },
+    addQueueSize: function (func) {
+        var offset = emnapiTSFN.offset.queue_size;
+        var arr, index;
+#if MEMORY64
+        arr = new BigUint64Array(wasmMemory.buffer);
+        index = (func + offset) >> 3;
+#else
+        arr = new Uint32Array(wasmMemory.buffer);
+        index = (func + offset) >> 2;
+#endif
+        Atomics.add(arr, index, {{{ to64('1') }}});
+    },
+    subQueueSize: function (func) {
+        var offset = emnapiTSFN.offset.queue_size;
+        var arr, index;
+#if MEMORY64
+        arr = new BigUint64Array(wasmMemory.buffer);
+        index = (func + offset) >> 3;
+#else
+        arr = new Uint32Array(wasmMemory.buffer);
+        index = (func + offset) >> 2;
+#endif
+        Atomics.sub(arr, index, {{{ to64('1') }}});
+    },
+    getThreadCount: function (func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.thread_count, true);
+    },
+    addThreadCount: function (func) {
+        var offset = emnapiTSFN.offset.thread_count;
+        var arr, index;
+#if MEMORY64
+        arr = new BigUint64Array(wasmMemory.buffer);
+        index = (func + offset) >> 3;
+#else
+        arr = new Uint32Array(wasmMemory.buffer);
+        index = (func + offset) >> 2;
+#endif
+        Atomics.add(arr, index, {{{ to64('1') }}});
+    },
+    subThreadCount: function (func) {
+        var offset = emnapiTSFN.offset.thread_count;
+        var arr, index;
+#if MEMORY64
+        arr = new BigUint64Array(wasmMemory.buffer);
+        index = (func + offset) >> 3;
+#else
+        arr = new Uint32Array(wasmMemory.buffer);
+        index = (func + offset) >> 2;
+#endif
+        Atomics.sub(arr, index, {{{ to64('1') }}});
+    },
+    getIsClosing: function (func) {
+        return Atomics.load(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.is_closing) >> 2);
+    },
+    setIsClosing: function (func, value) {
+        Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.is_closing) >> 2, value);
+    },
+    getHandlesClosing: function (func) {
+        return Atomics.load(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.handles_closing) >> 2);
+    },
+    setHandlesClosing: function (func, value) {
+        Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.handles_closing) >> 2, value);
+    },
+    getDispatchState: function (func) {
+        return Atomics.load(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >> 2);
+    },
+    getContext: function (func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.context, false);
+    },
+    getMaxQueueSize: function (func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.max_queue_size, true);
+    },
+    getEnv: function (func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.env, false);
+    },
+    getCallJSCb: function (func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.call_js_cb, false);
+    },
+    getRef: function (func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.ref, false);
+    },
+    getResource: function (func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.resource, false);
+    },
+    getFinalizeCb: function (func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_cb, false);
+    },
+    getFinalizeData: function (func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_data, false);
+    },
+    loadSizeTypeValue: function (offset, unsigned) {
+        var ret;
+        var arr;
+        if (unsigned) {
+#if MEMORY64
+            arr = new BigUint64Array(wasmMemory.buffer);
+            ret = Number(Atomics.load(arr, offset >> 3));
+#else
+            arr = new Uint32Array(wasmMemory.buffer);
+            ret = Atomics.load(arr, offset >> 2);
+#endif
+            return ret;
+        }
+        else {
+#if MEMORY64
+            arr = new BigInt64Array(wasmMemory.buffer);
+            ret = Number(Atomics.load(arr, offset >> 3));
+#else
+            arr = new Int32Array(wasmMemory.buffer);
+            ret = Atomics.load(arr, offset >> 2);
+#endif
+            return ret;
+        }
+    },
+    storeSizeTypeValue: function (offset, value, unsigned) {
+        var arr;
+        if (unsigned) {
+#if MEMORY64
+            arr = new BigUint64Array(wasmMemory.buffer);
+            Atomics.store(arr, offset >> 3, BigInt(value));
+#else
+            arr = new Uint32Array(wasmMemory.buffer);
+            Atomics.store(arr, offset >> 2, value);
+#endif
+            return undefined;
+        }
+        else {
+#if MEMORY64
+            arr = new BigInt64Array(wasmMemory.buffer);
+            Atomics.store(arr, offset >> 3, BigInt(value >>> 0));
+#else
+            arr = new Int32Array(wasmMemory.buffer);
+            Atomics.store(arr, offset >> 2, value >>> 0);
+#endif
+            return undefined;
+        }
+    },
+    destroy: function (func) {
+        emnapiTSFN.destroyQueue(func);
+        var env = emnapiTSFN.getEnv(func);
+        var envObject = emnapiCtx.envStore.get(env);
+        var ref = emnapiTSFN.getRef(func);
+        if (ref) {
+            emnapiCtx.refStore.get(ref).dispose();
+        }
+        emnapiCtx.removeCleanupHook(envObject, emnapiTSFN.cleanup, func);
+        envObject.unref();
+        var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >> 2;
+        var arr = new Int32Array(wasmMemory.buffer);
+        if (Atomics.load(arr, asyncRefOffset)) {
+            Atomics.store(arr, asyncRefOffset, 0);
+            __emnapi_runtime_keepalive_pop();
+            emnapiCtx.decreaseWaitingRequestCounter();
+        }
+        var resource = emnapiTSFN.getResource(func);
+        emnapiCtx.refStore.get(resource).dispose();
+        if (emnapiNodeBinding) {
+            var view = new DataView(wasmMemory.buffer);
+            var asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true);
+            var triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true);
+            __emnapi_node_emit_async_destroy(asyncId, triggerAsyncId);
+        }
+        _free({{{ to64('func') }}});
+    },
+    emptyQueueAndDelete: function (func) {
+        var callJsCb = emnapiTSFN.getCallJSCb(func);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        var context = emnapiTSFN.getContext(func);
+        var data;
+        while (emnapiTSFN.getQueueSize(func) > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            data = emnapiTSFN.shiftQueue(func);
+            if (callJsCb) {
+                {{{ makeDynCall('vpppp', 'callJsCb') }}}({{{ to64('0') }}}, {{{ to64('0') }}}, {{{ to64('context') }}}, {{{ to64('data') }}});
+            }
+        }
+        emnapiTSFN.destroy(func);
+    },
+    finalize: function (func) {
+        var env = emnapiTSFN.getEnv(func);
+        var envObject = emnapiCtx.envStore.get(env);
+        emnapiCtx.openScope(envObject);
+        var finalize = emnapiTSFN.getFinalizeCb(func);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        var data = emnapiTSFN.getFinalizeData(func);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        var context = emnapiTSFN.getContext(func);
+        var f = function () {
+            envObject.callFinalizer({{{ to64('finalize') }}}, {{{ to64('data') }}}, {{{ to64('context') }}});
+        };
+        try {
+            if (finalize) {
+                if (emnapiNodeBinding) {
+                    var resource = emnapiTSFN.getResource(func);
+                    var resource_value = emnapiCtx.refStore.get(resource).get();
+                    var resourceObject = emnapiCtx.handleStore.get(resource_value).value;
+                    var view = new DataView(wasmMemory.buffer);
+                    var asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true);
+                    var triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true);
+                    emnapiNodeBinding.node.makeCallback(resourceObject, f, [], {
+                        asyncId: asyncId,
+                        triggerAsyncId: triggerAsyncId
+                    });
+                }
+                else {
+                    f();
+                }
+            }
+            emnapiTSFN.emptyQueueAndDelete(func);
+        }
+        finally {
             emnapiCtx.closeScope(envObject);
         }
-        throw err;
-    }
-    emnapiCtx.closeScope(envObject, scope);
-}
-function __emnapi_ctx_increase_waiting_request_counter() {
-    emnapiCtx.increaseWaitingRequestCounter();
-}
-function __emnapi_ctx_decrease_waiting_request_counter() {
-    emnapiCtx.decreaseWaitingRequestCounter();
-}
-emnapiImplementInternal('_emnapi_set_immediate', 'vpp', __emnapi_set_immediate);
-emnapiImplementInternal('_emnapi_next_tick', 'vpp', __emnapi_next_tick);
-emnapiImplementInternal('_emnapi_call_into_module', 'vpppi', __emnapi_call_into_module);
-emnapiImplementInternal('_emnapi_ctx_increase_waiting_request_counter', 'v', __emnapi_ctx_increase_waiting_request_counter);
-emnapiImplementInternal('_emnapi_ctx_decrease_waiting_request_counter', 'v', __emnapi_ctx_decrease_waiting_request_counter);
-function __emnapi_call_finalizer(env, callback, data, hint) {
-    var envObject = emnapiCtx.envStore.get(env);
-    {{{ from64('callback') }}};
-    envObject.callFinalizer(callback, data, hint);
-}
-emnapiImplementInternal('_emnapi_call_finalizer', 'vpppp', __emnapi_call_finalizer);
-/* eslint-disable @typescript-eslint/indent */
-function _napi_set_last_error(env, error_code, engine_error_code, engine_reserved) {
-    var envObject = emnapiCtx.envStore.get(env);
-    return envObject.setLastError(error_code, engine_error_code, engine_reserved);
-}
-function _napi_clear_last_error(env) {
-    var envObject = emnapiCtx.envStore.get(env);
-    return envObject.clearLastError();
-}
-function __emnapi_get_node_version(major, minor, patch) {
-    {{{ from64('major') }}};
-    {{{ from64('minor') }}};
-    {{{ from64('patch') }}};
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    var versions = (typeof process === 'object' && process !== null &&
-        typeof process.versions === 'object' && process.versions !== null &&
-        typeof process.versions.node === 'string')
-        ? process.versions.node.split('.').map(function (n) { return Number(n); })
+    },
+    cleanup: function (func) {
+        emnapiTSFN.closeHandlesAndMaybeDelete(func, 1);
+    },
+    closeHandlesAndMaybeDelete: function (func, set_closing) {
+        var env = emnapiTSFN.getEnv(func);
+        var envObject = emnapiCtx.envStore.get(env);
+        emnapiCtx.openScope(envObject);
+        try {
+            if (set_closing) {
+                emnapiTSFN.getMutex(func).execute(function () {
+                    emnapiTSFN.setIsClosing(func, 1);
+                    if (emnapiTSFN.getMaxQueueSize(func) > 0) {
+                        emnapiTSFN.getCond(func).signal();
+                    }
+                });
+            }
+            if (emnapiTSFN.getHandlesClosing(func)) {
+                return;
+            }
+            emnapiTSFN.setHandlesClosing(func, 1);
+            emnapiCtx.feature.setImmediate(function () {
+                emnapiTSFN.finalize(func);
+            });
+        }
+        finally {
+            emnapiCtx.closeScope(envObject);
+        }
+    },
+    dispatchOne: function (func) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        var data = 0;
+        var popped_value = false;
+        var has_more = false;
+        var mutex = emnapiTSFN.getMutex(func);
+        var cond = emnapiTSFN.getCond(func);
+        mutex.execute(function () {
+            if (emnapiTSFN.getIsClosing(func)) {
+                emnapiTSFN.closeHandlesAndMaybeDelete(func, 0);
+            }
+            else {
+                var size = emnapiTSFN.getQueueSize(func);
+                if (size > 0) {
+                    data = emnapiTSFN.shiftQueue(func);
+                    popped_value = true;
+                    var maxQueueSize = emnapiTSFN.getMaxQueueSize(func);
+                    if (size === maxQueueSize && maxQueueSize > 0) {
+                        cond.signal();
+                    }
+                    size--;
+                }
+                if (size === 0) {
+                    if (emnapiTSFN.getThreadCount(func) === 0) {
+                        emnapiTSFN.setIsClosing(func, 1);
+                        if (emnapiTSFN.getMaxQueueSize(func) > 0) {
+                            cond.signal();
+                        }
+                        emnapiTSFN.closeHandlesAndMaybeDelete(func, 0);
+                    }
+                }
+                else {
+                    has_more = true;
+                }
+            }
+        });
+        if (popped_value) {
+            var env = emnapiTSFN.getEnv(func);
+            var envObject_36 = emnapiCtx.envStore.get(env);
+            emnapiCtx.openScope(envObject_36);
+            var f = function () {
+                envObject_36.callIntoModule(function () {
+                    var callJsCb = emnapiTSFN.getCallJSCb(func);
+                    var ref = emnapiTSFN.getRef(func);
+                    var js_callback = ref ? emnapiCtx.refStore.get(ref).get() : 0;
+                    if (callJsCb) {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        var context = emnapiTSFN.getContext(func);
+                        {{{ makeDynCall('vpppp', 'callJsCb') }}}({{{ to64('env') }}}, {{{ to64('js_callback') }}}, {{{ to64('context') }}}, {{{ to64('data') }}});
+                    }
+                    else {
+                        var jsCallback = js_callback ? emnapiCtx.handleStore.get(js_callback).value : null;
+                        if (typeof jsCallback === 'function') {
+                            jsCallback();
+                        }
+                    }
+                });
+            };
+            try {
+                if (emnapiNodeBinding) {
+                    var resource = emnapiTSFN.getResource(func);
+                    var resource_value = emnapiCtx.refStore.get(resource).get();
+                    var resourceObject = emnapiCtx.handleStore.get(resource_value).value;
+                    var view = new DataView(wasmMemory.buffer);
+                    emnapiNodeBinding.node.makeCallback(resourceObject, f, [], {
+                        asyncId: view.getFloat64(func + emnapiTSFN.offset.async_id, true),
+                        triggerAsyncId: view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true)
+                    });
+                }
+                else {
+                    f();
+                }
+            }
+            finally {
+                emnapiCtx.closeScope(envObject_36);
+            }
+        }
+        return has_more;
+    },
+    dispatch: function (func) {
+        var has_more = true;
+        var iterations_left = 1000;
+        var ui32a = new Uint32Array(wasmMemory.buffer);
+        var index = (func + emnapiTSFN.offset.dispatch_state) >> 2;
+        while (has_more && --iterations_left !== 0) {
+            Atomics.store(ui32a, index, 1);
+            has_more = emnapiTSFN.dispatchOne(func);
+            if (Atomics.exchange(ui32a, index, 0) !== 1) {
+                has_more = true;
+            }
+        }
+        if (has_more) {
+            emnapiTSFN.send(func);
+        }
+    },
+    send: function (func) {
+        var current_state = Atomics.or(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >> 2, 1 << 1);
+        if ((current_state & 1) === 1) {
+            return;
+        }
+        if (ENVIRONMENT_IS_PTHREAD) {
+            postMessage({
+                __emnapi__: {
+                    type: 'tsfn-send',
+                    payload: {
+                        tsfn: func
+                    }
+                }
+            });
+        }
+        else {
+            emnapiCtx.feature.setImmediate(function () {
+                emnapiTSFN.dispatch(func);
+            });
+        }
+    }
+};
+function _napi_create_threadsafe_function(env, func, async_resource, async_resource_name, max_queue_size, initial_thread_count, thread_finalize_data, thread_finalize_cb, context, call_js_cb, result) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (async_resource_name == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); /* napi_ref */
+    {{{ from64('max_queue_size') }}};
+    {{{ from64('initial_thread_count') }}};
+    {{{ from64('env') }}};
+    {{{ from64('thread_finalize_data') }}};
+    {{{ from64('thread_finalize_cb') }}};
+    {{{ from64('context') }}};
+    {{{ from64('call_js_cb') }}};
+    max_queue_size = max_queue_size >>> 0;
+    initial_thread_count = initial_thread_count >>> 0;
+    if (initial_thread_count === 0) {
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    }
+    if (result == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); /* napi_ref */
+    var ref = 0;
+    {{{ from64('func') }}};
+    if (!func) {
+        if (call_js_cb == 0)
+            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); /* napi_ref */
+    }
+    else {
+        var funcValue = emnapiCtx.handleStore.get(func).value;
+        if (typeof funcValue !== 'function') {
+            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ref = emnapiCtx.createReference(envObject, func, 1, 1 /* Ownership.kUserland */).id;
+    }
+    var asyncResourceObject;
+    if (async_resource) {
+        asyncResourceObject = emnapiCtx.handleStore.get(async_resource).value;
+        if (asyncResourceObject == null) {
+            return envObject.setLastError(2 /* napi_status.napi_object_expected */);
+        }
+        asyncResourceObject = Object(asyncResourceObject);
+    }
+    else {
+        asyncResourceObject = {};
+    }
+    var resource = envObject.ensureHandleId(asyncResourceObject);
+    var asyncResourceName = emnapiCtx.handleStore.get(async_resource_name).value;
+    if (typeof asyncResourceName === 'symbol') {
+        return envObject.setLastError(3 /* napi_status.napi_string_expected */);
+    }
+    asyncResourceName = String(asyncResourceName);
+    var resource_name = envObject.ensureHandleId(asyncResourceName);
+    // tsfn create
+    var sizeofTSFN = emnapiTSFN.offset.end;
+    var tsfn = {{{ makeMalloc('napi_create_threadsafe_function', 'sizeofTSFN') }}};
+    if (!tsfn)
+        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
+    new Uint8Array(wasmMemory.buffer).subarray(tsfn, tsfn + sizeofTSFN).fill(0);
+    var resourceRef = emnapiCtx.createReference(envObject, resource, 1, 1 /* Ownership.kUserland */);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var resource_ = resourceRef.id;
+    {{{ makeSetValue('tsfn', 0, 'resource_', '*') }}};
+    if (!emnapiTSFN.initQueue(tsfn)) {
+        _free({{{ to64('tsfn') }}});
+        resourceRef.dispose();
+        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
+    }
+    __emnapi_node_emit_async_init(resource, resource_name, -1, tsfn + emnapiTSFN.offset.async_id);
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.thread_count', 'initial_thread_count', SIZE_TYPE) }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.context', 'context', '*') }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.max_queue_size', 'max_queue_size', SIZE_TYPE) }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.ref', 'ref', '*') }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.env', 'env', '*') }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.finalize_data', 'thread_finalize_data', '*') }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.finalize_cb', 'thread_finalize_cb', '*') }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.call_js_cb', 'call_js_cb', '*') }}};
+    emnapiCtx.addCleanupHook(envObject, emnapiTSFN.cleanup, tsfn);
+    envObject.ref();
+    __emnapi_runtime_keepalive_push();
+    emnapiCtx.increaseWaitingRequestCounter();
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.async_ref', '1', 'i32') }}};
+    {{{ from64('result') }}};
+    {{{ makeSetValue('result', 0, 'tsfn', '*') }}};
+    return envObject.clearLastError();
+}
+function _napi_get_threadsafe_function_context(func, result) {
+    if (!func || !result) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    {{{ from64('result') }}};
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var context = emnapiTSFN.getContext(func);
+    {{{ makeSetValue('result', 0, 'context', '*') }}};
+    return 0 /* napi_status.napi_ok */;
+}
+function _napi_call_threadsafe_function(func, data, mode) {
+    if (!func) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    {{{ from64('data') }}};
+    return emnapiTSFN.push(func, data, mode);
+}
+function _napi_acquire_threadsafe_function(func) {
+    if (!func) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    var mutex = emnapiTSFN.getMutex(func);
+    return mutex.execute(function () {
+        if (emnapiTSFN.getIsClosing(func)) {
+            return 16 /* napi_status.napi_closing */;
+        }
+        emnapiTSFN.addThreadCount(func);
+        return 0 /* napi_status.napi_ok */;
+    });
+}
+function _napi_release_threadsafe_function(func, mode) {
+    if (!func) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    var mutex = emnapiTSFN.getMutex(func);
+    var cond = emnapiTSFN.getCond(func);
+    return mutex.execute(function () {
+        if (emnapiTSFN.getThreadCount(func) === 0) {
+            return 1 /* napi_status.napi_invalid_arg */;
+        }
+        emnapiTSFN.subThreadCount(func);
+        if (emnapiTSFN.getThreadCount(func) === 0 || mode === 1 /* napi_threadsafe_function_release_mode.napi_tsfn_abort */) {
+            var isClosing = emnapiTSFN.getIsClosing(func);
+            if (!isClosing) {
+                var isClosingValue = (mode === 1 /* napi_threadsafe_function_release_mode.napi_tsfn_abort */) ? 1 : 0;
+                emnapiTSFN.setIsClosing(func, isClosingValue);
+                if (isClosingValue && emnapiTSFN.getMaxQueueSize(func) > 0) {
+                    cond.signal();
+                }
+                emnapiTSFN.send(func);
+            }
+        }
+        return 0 /* napi_status.napi_ok */;
+    });
+}
+function _napi_unref_threadsafe_function(env, func) {
+    if (!func) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >> 2;
+    var arr = new Int32Array(wasmMemory.buffer);
+    if (Atomics.load(arr, asyncRefOffset)) {
+        Atomics.store(arr, asyncRefOffset, 0);
+        __emnapi_runtime_keepalive_pop();
+        emnapiCtx.decreaseWaitingRequestCounter();
+    }
+    return 0 /* napi_status.napi_ok */;
+}
+function _napi_ref_threadsafe_function(env, func) {
+    if (!func) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >> 2;
+    var arr = new Int32Array(wasmMemory.buffer);
+    if (!Atomics.load(arr, asyncRefOffset)) {
+        Atomics.store(arr, asyncRefOffset, 1);
+        __emnapi_runtime_keepalive_push();
+        emnapiCtx.increaseWaitingRequestCounter();
+    }
+    return 0 /* napi_status.napi_ok */;
+}
+emnapiDefineVar('$emnapiTSFN', emnapiTSFN, [
+    '$emnapiInit',
+    '$PThread',
+    '_emnapi_node_emit_async_init',
+    '_emnapi_node_emit_async_destroy',
+    '_emnapi_runtime_keepalive_pop',
+    '_emnapi_runtime_keepalive_push'
+], 'emnapiTSFN.init();');
+emnapiImplement('napi_create_threadsafe_function', 'ippppppppppp', _napi_create_threadsafe_function, ['$emnapiTSFN']);
+emnapiImplement('napi_get_threadsafe_function_context', 'ipp', _napi_get_threadsafe_function_context, ['$emnapiTSFN']);
+emnapiImplement('napi_call_threadsafe_function', 'ippi', _napi_call_threadsafe_function, ['$emnapiTSFN']);
+emnapiImplement('napi_acquire_threadsafe_function', 'ip', _napi_acquire_threadsafe_function, ['$emnapiTSFN']);
+emnapiImplement('napi_release_threadsafe_function', 'ipi', _napi_release_threadsafe_function, ['$emnapiTSFN']);
+emnapiImplement('napi_unref_threadsafe_function', 'ipp', _napi_unref_threadsafe_function, ['$emnapiTSFN']);
+emnapiImplement('napi_ref_threadsafe_function', 'ipp', _napi_ref_threadsafe_function, ['$emnapiTSFN']);
+/* eslint-disable @typescript-eslint/indent */
+function _napi_set_last_error(env, error_code, engine_error_code, engine_reserved) {
+    var envObject = emnapiCtx.envStore.get(env);
+    return envObject.setLastError(error_code, engine_error_code, engine_reserved);
+}
+function _napi_clear_last_error(env) {
+    var envObject = emnapiCtx.envStore.get(env);
+    return envObject.clearLastError();
+}
+function __emnapi_get_node_version(major, minor, patch) {
+    {{{ from64('major') }}};
+    {{{ from64('minor') }}};
+    {{{ from64('patch') }}};
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var versions = (typeof process === 'object' && process !== null &&
+        typeof process.versions === 'object' && process.versions !== null &&
+        typeof process.versions.node === 'string')
+        ? process.versions.node.split('.').map(function (n) { return Number(n); })
         : [0, 0, 0];
     {{{ makeSetValue('major', 0, 'versions[0]', 'u32') }}};
     {{{ makeSetValue('minor', 0, 'versions[1]', 'u32') }}};
@@ -2598,6 +3317,51 @@ function __emnapi_runtime_keepalive_pop() {
 }
 emnapiImplementInternal('_emnapi_runtime_keepalive_push', 'v', __emnapi_runtime_keepalive_push, ['$runtimeKeepalivePush']);
 emnapiImplementInternal('_emnapi_runtime_keepalive_pop', 'v', __emnapi_runtime_keepalive_pop, ['$runtimeKeepalivePop']);
+function __emnapi_set_immediate(callback, data) {
+    emnapiCtx.feature.setImmediate(function () {
+        {{{ makeDynCall('vp', 'callback') }}}(data);
+    });
+}
+function __emnapi_next_tick(callback, data) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    Promise.resolve().then(function () {
+        {{{ makeDynCall('vp', 'callback') }}}(data);
+    });
+}
+function __emnapi_call_into_module(env, callback, data, close_scope_if_throw) {
+    var envObject = emnapiCtx.envStore.get(env);
+    var scope = emnapiCtx.openScope(envObject);
+    try {
+        envObject.callIntoModule(function () {
+            {{{ makeDynCall('vpp', 'callback') }}}(env, data);
+        });
+    }
+    catch (err) {
+        emnapiCtx.closeScope(envObject, scope);
+        if (close_scope_if_throw) {
+            emnapiCtx.closeScope(envObject);
+        }
+        throw err;
+    }
+    emnapiCtx.closeScope(envObject, scope);
+}
+function __emnapi_call_finalizer(env, callback, data, hint) {
+    var envObject = emnapiCtx.envStore.get(env);
+    {{{ from64('callback') }}};
+    envObject.callFinalizer(callback, data, hint);
+}
+function __emnapi_ctx_increase_waiting_request_counter() {
+    emnapiCtx.increaseWaitingRequestCounter();
+}
+function __emnapi_ctx_decrease_waiting_request_counter() {
+    emnapiCtx.decreaseWaitingRequestCounter();
+}
+emnapiImplementInternal('_emnapi_set_immediate', 'vpp', __emnapi_set_immediate);
+emnapiImplementInternal('_emnapi_next_tick', 'vpp', __emnapi_next_tick);
+emnapiImplementInternal('_emnapi_call_into_module', 'vpppi', __emnapi_call_into_module);
+emnapiImplementInternal('_emnapi_call_finalizer', 'vpppp', __emnapi_call_finalizer);
+emnapiImplementInternal('_emnapi_ctx_increase_waiting_request_counter', 'v', __emnapi_ctx_increase_waiting_request_counter);
+emnapiImplementInternal('_emnapi_ctx_decrease_waiting_request_counter', 'v', __emnapi_ctx_decrease_waiting_request_counter);
 function napi_typeof(env, value, result) {
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
@@ -2657,24 +3421,24 @@ function napi_coerce_to_bool(env, value, result) {
     var v;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_36 = emnapiCtx.envStore.get(env);
-    if (envObject_36.tryCatch.hasCaught())
-        return envObject_36.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_36.clearLastError();
+    var envObject_37 = emnapiCtx.envStore.get(env);
+    if (envObject_37.tryCatch.hasCaught())
+        return envObject_37.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_37.clearLastError();
     try {
         if (value == 0)
-            return envObject_36.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_37.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_36.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_37.setLastError(1 /* napi_status.napi_invalid_arg */);
         var handle_5 = emnapiCtx.handleStore.get(value);
         {{{ from64("result") }}};
         v = handle_5.value ? 4 /* GlobalHandle.TRUE */ : 3 /* GlobalHandle.FALSE */;
         {{{ makeSetValue("result", 0, "v", "*") }}};
-        return envObject_36.getReturnStatus();
+        return envObject_37.getReturnStatus();
     }
     catch (err_37) {
-        envObject_36.tryCatch.setError(err_37);
-        return envObject_36.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_37.tryCatch.setError(err_37);
+        return envObject_37.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 // @ts-expect-error
@@ -2683,15 +3447,15 @@ function napi_coerce_to_number(env, value, result) {
     var v;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_37 = emnapiCtx.envStore.get(env);
-    if (envObject_37.tryCatch.hasCaught())
-        return envObject_37.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_37.clearLastError();
+    var envObject_38 = emnapiCtx.envStore.get(env);
+    if (envObject_38.tryCatch.hasCaught())
+        return envObject_38.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_38.clearLastError();
     try {
         if (value == 0)
-            return envObject_37.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_38.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_37.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_38.setLastError(1 /* napi_status.napi_invalid_arg */);
         var handle_6 = emnapiCtx.handleStore.get(value);
         if (handle_6.isBigInt()) {
             throw new TypeError("Cannot convert a BigInt value to a number");
@@ -2700,11 +3464,11 @@ function napi_coerce_to_number(env, value, result) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         v = emnapiCtx.addToCurrentScope(Number(handle_6.value)).id;
         {{{ makeSetValue("result", 0, "v", "*") }}};
-        return envObject_37.getReturnStatus();
+        return envObject_38.getReturnStatus();
     }
     catch (err_38) {
-        envObject_37.tryCatch.setError(err_38);
-        return envObject_37.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_38.tryCatch.setError(err_38);
+        return envObject_38.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 // @ts-expect-error
@@ -2713,28 +3477,28 @@ function napi_coerce_to_object(env, value, result) {
     var v;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_38 = emnapiCtx.envStore.get(env);
-    if (envObject_38.tryCatch.hasCaught())
-        return envObject_38.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_38.clearLastError();
+    var envObject_39 = emnapiCtx.envStore.get(env);
+    if (envObject_39.tryCatch.hasCaught())
+        return envObject_39.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_39.clearLastError();
     try {
         if (value == 0)
-            return envObject_38.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_39.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_38.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_39.setLastError(1 /* napi_status.napi_invalid_arg */);
         var handle_7 = emnapiCtx.handleStore.get(value);
         if (handle_7.value == null) {
             throw new TypeError("Cannot convert undefined or null to object");
         }
         {{{ from64("result") }}};
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        v = envObject_38.ensureHandleId(Object(handle_7.value));
+        v = envObject_39.ensureHandleId(Object(handle_7.value));
         {{{ makeSetValue("result", 0, "v", "*") }}};
-        return envObject_38.getReturnStatus();
+        return envObject_39.getReturnStatus();
     }
     catch (err_39) {
-        envObject_38.tryCatch.setError(err_39);
-        return envObject_38.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_39.tryCatch.setError(err_39);
+        return envObject_39.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 // @ts-expect-error
@@ -2743,15 +3507,15 @@ function napi_coerce_to_string(env, value, result) {
     var v;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_39 = emnapiCtx.envStore.get(env);
-    if (envObject_39.tryCatch.hasCaught())
-        return envObject_39.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_39.clearLastError();
+    var envObject_40 = emnapiCtx.envStore.get(env);
+    if (envObject_40.tryCatch.hasCaught())
+        return envObject_40.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_40.clearLastError();
     try {
         if (value == 0)
-            return envObject_39.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_40.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_39.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_40.setLastError(1 /* napi_status.napi_invalid_arg */);
         var handle_8 = emnapiCtx.handleStore.get(value);
         if (handle_8.isSymbol()) {
             throw new TypeError("Cannot convert a Symbol value to a string");
@@ -2760,11 +3524,11 @@ function napi_coerce_to_string(env, value, result) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         v = emnapiCtx.addToCurrentScope(String(handle_8.value)).id;
         {{{ makeSetValue("result", 0, "v", "*") }}};
-        return envObject_39.getReturnStatus();
+        return envObject_40.getReturnStatus();
     }
     catch (err_40) {
-        envObject_39.tryCatch.setError(err_40);
-        return envObject_39.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_40.tryCatch.setError(err_40);
+        return envObject_40.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 // @ts-expect-error
@@ -2773,32 +3537,32 @@ function napi_instanceof(env, object, constructor, result) {
     var r;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_40 = emnapiCtx.envStore.get(env);
-    if (envObject_40.tryCatch.hasCaught())
-        return envObject_40.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_40.clearLastError();
+    var envObject_41 = emnapiCtx.envStore.get(env);
+    if (envObject_41.tryCatch.hasCaught())
+        return envObject_41.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_41.clearLastError();
     try {
         if (object == 0)
-            return envObject_40.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_41.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_40.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_41.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (constructor == 0)
-            return envObject_40.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_41.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64("result") }}};
         {{{ makeSetValue("result", 0, "0", "i8") }}};
         var ctor_1 = emnapiCtx.handleStore.get(constructor);
         if (!ctor_1.isFunction()) {
-            return envObject_40.setLastError(5 /* napi_status.napi_function_expected */);
+            return envObject_41.setLastError(5 /* napi_status.napi_function_expected */);
         }
         var val_1 = emnapiCtx.handleStore.get(object).value;
         var ret_7 = val_1 instanceof ctor_1.value;
         r = ret_7 ? 1 : 0;
         {{{ makeSetValue("result", 0, "r", "i8") }}};
-        return envObject_40.getReturnStatus();
+        return envObject_41.getReturnStatus();
     }
     catch (err_41) {
-        envObject_40.tryCatch.setError(err_41);
-        return envObject_40.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_41.tryCatch.setError(err_41);
+        return envObject_41.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 function napi_is_array(env, value, result) {
@@ -2912,27 +3676,27 @@ function napi_strict_equals(env, lhs, rhs, result) {
     var r;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_41 = emnapiCtx.envStore.get(env);
-    if (envObject_41.tryCatch.hasCaught())
-        return envObject_41.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_41.clearLastError();
+    var envObject_42 = emnapiCtx.envStore.get(env);
+    if (envObject_42.tryCatch.hasCaught())
+        return envObject_42.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_42.clearLastError();
     try {
         if (lhs == 0)
-            return envObject_41.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_42.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (rhs == 0)
-            return envObject_41.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_42.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_41.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_42.setLastError(1 /* napi_status.napi_invalid_arg */);
         var lv_1 = emnapiCtx.handleStore.get(lhs).value;
         var rv_1 = emnapiCtx.handleStore.get(rhs).value;
         {{{ from64("result") }}};
         r = (lv_1 === rv_1) ? 1 : 0;
         {{{ makeSetValue("result", 0, "r", "i8") }}};
-        return envObject_41.getReturnStatus();
+        return envObject_42.getReturnStatus();
     }
     catch (err_42) {
-        envObject_41.tryCatch.setError(err_42);
-        return envObject_41.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_42.tryCatch.setError(err_42);
+        return envObject_42.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 function napi_detach_arraybuffer(env, arraybuffer) {
@@ -2962,15 +3726,15 @@ function napi_detach_arraybuffer(env, arraybuffer) {
 function napi_is_detached_arraybuffer(env, arraybuffer, result) {
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_42 = emnapiCtx.envStore.get(env);
-    if (envObject_42.tryCatch.hasCaught())
-        return envObject_42.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_42.clearLastError();
+    var envObject_43 = emnapiCtx.envStore.get(env);
+    if (envObject_43.tryCatch.hasCaught())
+        return envObject_43.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_43.clearLastError();
     try {
         if (arraybuffer == 0)
-            return envObject_42.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_43.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_42.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_43.setLastError(1 /* napi_status.napi_invalid_arg */);
         var h_17 = emnapiCtx.handleStore.get(arraybuffer);
         {{{ from64("result") }}};
         if (h_17.isArrayBuffer() && h_17.value.byteLength === 0) {
@@ -2980,15 +3744,15 @@ function napi_is_detached_arraybuffer(env, arraybuffer, result) {
             }
             catch (_11) {
                 {{{ makeSetValue("result", 0, "1", "i8") }}};
-                return envObject_42.getReturnStatus();
+                return envObject_43.getReturnStatus();
             }
         }
         {{{ makeSetValue("result", 0, "0", "i8") }}};
-        return envObject_42.getReturnStatus();
+        return envObject_43.getReturnStatus();
     }
     catch (err_43) {
-        envObject_42.tryCatch.setError(err_43);
-        return envObject_42.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_43.tryCatch.setError(err_43);
+        return envObject_43.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 emnapiImplement('napi_typeof', 'ippp', napi_typeof);
@@ -3014,29 +3778,29 @@ function napi_define_class(env, utf8name, length, constructor, callback_data, pr
     var propPtr, valueHandleId, attributes;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_43 = emnapiCtx.envStore.get(env);
-    if (envObject_43.tryCatch.hasCaught())
-        return envObject_43.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_43.clearLastError();
+    var envObject_44 = emnapiCtx.envStore.get(env);
+    if (envObject_44.tryCatch.hasCaught())
+        return envObject_44.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_44.clearLastError();
     try {
         if (result == 0)
-            return envObject_43.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_44.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (constructor == 0)
-            return envObject_43.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_44.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64("length") }}};
         {{{ from64("properties") }}};
         {{{ from64("property_count") }}};
         property_count = property_count >>> 0;
         if (property_count > 0) {
             if (!properties)
-                return envObject_43.setLastError(1 /* napi_status.napi_invalid_arg */);
+                return envObject_44.setLastError(1 /* napi_status.napi_invalid_arg */);
         }
         if ((length < -1) || (length > 2147483647) || (!utf8name)) {
-            return envObject_43.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_44.setLastError(1 /* napi_status.napi_invalid_arg */);
         }
-        var fresult_2 = emnapiCreateFunction(envObject_43, utf8name, length, constructor, callback_data);
+        var fresult_2 = emnapiCreateFunction(envObject_44, utf8name, length, constructor, callback_data);
         if (fresult_2.status !== 0 /* napi_status.napi_ok */)
-            return envObject_43.setLastError(fresult_2.status);
+            return envObject_44.setLastError(fresult_2.status);
         var F_1 = fresult_2.f;
         var propertyName_2 = void 0;
         for (var i_3 = 0; i_3 < property_count; i_3++) {
@@ -3056,29 +3820,29 @@ function napi_define_class(env, utf8name, length, constructor, callback_data, pr
             }
             else {
                 if (!name_3) {
-                    return envObject_43.setLastError(4 /* napi_status.napi_name_expected */);
+                    return envObject_44.setLastError(4 /* napi_status.napi_name_expected */);
                 }
                 propertyName_2 = emnapiCtx.handleStore.get(name_3).value;
                 if (typeof propertyName_2 !== "string" && typeof propertyName_2 !== "symbol") {
-                    return envObject_43.setLastError(4 /* napi_status.napi_name_expected */);
+                    return envObject_44.setLastError(4 /* napi_status.napi_name_expected */);
                 }
             }
             if ((attributes & 1024 /* napi_property_attributes.napi_static */) !== 0) {
-                emnapiDefineProperty(envObject_43, F_1, propertyName_2, method_2, getter_2, setter_2, value_3, attributes, data_3);
+                emnapiDefineProperty(envObject_44, F_1, propertyName_2, method_2, getter_2, setter_2, value_3, attributes, data_3);
                 continue;
             }
-            emnapiDefineProperty(envObject_43, F_1.prototype, propertyName_2, method_2, getter_2, setter_2, value_3, attributes, data_3);
+            emnapiDefineProperty(envObject_44, F_1.prototype, propertyName_2, method_2, getter_2, setter_2, value_3, attributes, data_3);
         }
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         var valueHandle_2 = emnapiCtx.addToCurrentScope(F_1);
         valueHandleId = valueHandle_2.id;
         {{{ from64("result") }}};
         {{{ makeSetValue("result", 0, "valueHandleId", "*") }}};
-        return envObject_43.getReturnStatus();
+        return envObject_44.getReturnStatus();
     }
     catch (err_44) {
-        envObject_43.tryCatch.setError(err_44);
-        return envObject_43.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_44.tryCatch.setError(err_44);
+        return envObject_44.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 function napi_wrap(env, js_object, native_object, finalize_cb, finalize_hint, result) {
@@ -3086,33 +3850,33 @@ function napi_wrap(env, js_object, native_object, finalize_cb, finalize_hint, re
         if (finalize_cb) {
             if (env == 0)
                 return 1 /* napi_status.napi_invalid_arg */;
-            var envObject_44 = emnapiCtx.envStore.get(env);
-            if (envObject_44.tryCatch.hasCaught())
-                return envObject_44.setLastError(10 /* napi_status.napi_pending_exception */);
-            envObject_44.clearLastError();
+            var envObject_45 = emnapiCtx.envStore.get(env);
+            if (envObject_45.tryCatch.hasCaught())
+                return envObject_45.setLastError(10 /* napi_status.napi_pending_exception */);
+            envObject_45.clearLastError();
             try {
                 throw emnapiCtx.createNotSupportWeakRefError("napi_wrap", "Parameter \"finalize_cb\" must be 0(NULL)");
                 return null;
             }
             catch (err_45) {
-                envObject_44.tryCatch.setError(err_45);
-                return envObject_44.setLastError(10 /* napi_status.napi_pending_exception */);
+                envObject_45.tryCatch.setError(err_45);
+                return envObject_45.setLastError(10 /* napi_status.napi_pending_exception */);
             }
         }
         if (result) {
             if (env == 0)
                 return 1 /* napi_status.napi_invalid_arg */;
-            var envObject_45 = emnapiCtx.envStore.get(env);
-            if (envObject_45.tryCatch.hasCaught())
-                return envObject_45.setLastError(10 /* napi_status.napi_pending_exception */);
-            envObject_45.clearLastError();
+            var envObject_46 = emnapiCtx.envStore.get(env);
+            if (envObject_46.tryCatch.hasCaught())
+                return envObject_46.setLastError(10 /* napi_status.napi_pending_exception */);
+            envObject_46.clearLastError();
             try {
                 throw emnapiCtx.createNotSupportWeakRefError("napi_wrap", "Parameter \"result\" must be 0(NULL)");
                 return null;
             }
             catch (err_46) {
-                envObject_45.tryCatch.setError(err_46);
-                return envObject_45.setLastError(10 /* napi_status.napi_pending_exception */);
+                envObject_46.tryCatch.setError(err_46);
+                return envObject_46.setLastError(10 /* napi_status.napi_pending_exception */);
             }
         }
     }
@@ -3128,25 +3892,25 @@ function napi_remove_wrap(env, js_object, result) {
 function napi_type_tag_object(env, object, type_tag) {
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_46 = emnapiCtx.envStore.get(env);
-    if (envObject_46.tryCatch.hasCaught())
-        return envObject_46.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_46.clearLastError();
+    var envObject_47 = emnapiCtx.envStore.get(env);
+    if (envObject_47.tryCatch.hasCaught())
+        return envObject_47.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_47.clearLastError();
     try {
         if (!object) {
-            return envObject_46.setLastError(envObject_46.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
+            return envObject_47.setLastError(envObject_47.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
         }
         var value_4 = emnapiCtx.handleStore.get(object);
         if (!(value_4.isObject() || value_4.isFunction())) {
-            return envObject_46.setLastError(envObject_46.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */);
+            return envObject_47.setLastError(envObject_47.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */);
         }
         {{{ from64("type_tag") }}};
         if (!type_tag) {
-            return envObject_46.setLastError(envObject_46.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
+            return envObject_47.setLastError(envObject_47.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
         }
-        var binding_2 = envObject_46.getObjectBinding(value_4.value);
+        var binding_2 = envObject_47.getObjectBinding(value_4.value);
         if (binding_2.tag !== null) {
-            return envObject_46.setLastError(envObject_46.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
+            return envObject_47.setLastError(envObject_47.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
         }
         binding_2.tag = [
             {{{ makeGetValue("type_tag", "0", "u32") }}},
@@ -3154,11 +3918,11 @@ function napi_type_tag_object(env, object, type_tag) {
             {{{ makeGetValue("type_tag", "8", "u32") }}},
             {{{ makeGetValue("type_tag", "12", "u32") }}}
         ];
-        return envObject_46.getReturnStatus();
+        return envObject_47.getReturnStatus();
     }
     catch (err_47) {
-        envObject_46.tryCatch.setError(err_47);
-        return envObject_46.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_47.tryCatch.setError(err_47);
+        return envObject_47.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 // @ts-expect-error
@@ -3167,25 +3931,25 @@ function napi_check_object_type_tag(env, object, type_tag, result) {
     var ret = true, i;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_47 = emnapiCtx.envStore.get(env);
-    if (envObject_47.tryCatch.hasCaught())
-        return envObject_47.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_47.clearLastError();
+    var envObject_48 = emnapiCtx.envStore.get(env);
+    if (envObject_48.tryCatch.hasCaught())
+        return envObject_48.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_48.clearLastError();
     try {
         if (!object) {
-            return envObject_47.setLastError(envObject_47.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
+            return envObject_48.setLastError(envObject_48.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
         }
         var value_5 = emnapiCtx.handleStore.get(object);
         if (!(value_5.isObject() || value_5.isFunction())) {
-            return envObject_47.setLastError(envObject_47.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */);
+            return envObject_48.setLastError(envObject_48.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */);
         }
         if (!type_tag) {
-            return envObject_47.setLastError(envObject_47.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
+            return envObject_48.setLastError(envObject_48.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
         }
         if (!result) {
-            return envObject_47.setLastError(envObject_47.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
+            return envObject_48.setLastError(envObject_48.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);
         }
-        var binding_3 = envObject_47.getObjectBinding(value_5.value);
+        var binding_3 = envObject_48.getObjectBinding(value_5.value);
         if (binding_3.tag !== null) {
             {{{ from64("type_tag") }}};
             for (i = 0; i < 4; i++) {
@@ -3201,11 +3965,11 @@ function napi_check_object_type_tag(env, object, type_tag, result) {
         }
         {{{ from64("result") }}};
         {{{ makeSetValue("result", 0, "ret ? 1 : 0", "i8") }}};
-        return envObject_47.getReturnStatus();
+        return envObject_48.getReturnStatus();
     }
     catch (err_48) {
-        envObject_47.tryCatch.setError(err_48);
-        return envObject_47.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_48.tryCatch.setError(err_48);
+        return envObject_48.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -3445,28 +4209,28 @@ function napi_get_date_value(env, value, result) {
     var v;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_48 = emnapiCtx.envStore.get(env);
-    if (envObject_48.tryCatch.hasCaught())
-        return envObject_48.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_48.clearLastError();
+    var envObject_49 = emnapiCtx.envStore.get(env);
+    if (envObject_49.tryCatch.hasCaught())
+        return envObject_49.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_49.clearLastError();
     try {
         if (value == 0)
-            return envObject_48.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_49.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_48.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_49.setLastError(1 /* napi_status.napi_invalid_arg */);
         var handle_9 = emnapiCtx.handleStore.get(value);
         if (!handle_9.isDate()) {
-            return envObject_48.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_49.setLastError(1 /* napi_status.napi_invalid_arg */);
         }
         {{{ from64("result") }}};
         v = (handle_9.value).valueOf();
         {{{ makeSetValue("result", 0, "v", "double") }}};
-        return envObject_48.getReturnStatus();
+        return envObject_49.getReturnStatus();
     }
     catch (err_49) {
-        envObject_48.tryCatch
+        envObject_49.tryCatch
             .setError(err_49);
-        return envObject_48.setLastError(10 /* napi_status.napi_pending_exception */);
+        return envObject_49.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 function napi_get_value_bool(env, value, result) {
@@ -4047,21 +4811,21 @@ function napi_create_bigint_words(env, sign_bit, word_count, words, result) {
     var v, i;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_49 = emnapiCtx.envStore.get(env);
-    if (envObject_49.tryCatch.hasCaught())
-        return envObject_49.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_49.clearLastError();
+    var envObject_50 = emnapiCtx.envStore.get(env);
+    if (envObject_50.tryCatch.hasCaught())
+        return envObject_50.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_50.clearLastError();
     try {
         if (!emnapiCtx.feature.supportBigInt) {
             throw emnapiCtx.createNotSupportBigIntError("napi_create_bigint_words", "This API is unavailable");
         }
         if (result == 0)
-            return envObject_49.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_50.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64("words") }}};
         {{{ from64("word_count") }}};
         word_count = word_count >>> 0;
         if (word_count > 2147483647) {
-            return envObject_49.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_50.setLastError(1 /* napi_status.napi_invalid_arg */);
         }
         if (word_count > (16384)) {
             throw new RangeError("Maximum BigInt size exceeded");
@@ -4077,11 +4841,11 @@ function napi_create_bigint_words(env, sign_bit, word_count, words, result) {
         {{{ from64("result") }}};
         v = emnapiCtx.addToCurrentScope(value_6).id;
         {{{ makeSetValue("result", 0, "v", "*") }}};
-        return envObject_49.clearLastError();
+        return envObject_50.clearLastError();
     }
     catch (err_50) {
-        envObject_49.tryCatch.setError(err_50);
-        return envObject_49.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_50.tryCatch.setError(err_50);
+        return envObject_50.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 emnapiImplement('napi_create_int32', 'ipip', napi_create_int32);
@@ -4138,25 +4902,25 @@ function napi_create_arraybuffer(env, byte_length, data, result) {
     var value;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_50 = emnapiCtx.envStore
+    var envObject_51 = emnapiCtx.envStore
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         .
             get(env);
-    if (envObject_50.tryCatch.hasCaught())
-        return envObject_50.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_50.clearLastError();
+    if (envObject_51.tryCatch.hasCaught())
+        return envObject_51.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_51.clearLastError();
     try {
         if (result == 0)
-            return envObject_50.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_51.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64("result") }}};
         var arrayBuffer_1 = emnapiCreateArrayBuffer(byte_length, data);
         value = emnapiCtx.addToCurrentScope(arrayBuffer_1).id;
         {{{ makeSetValue("result", 0, "value", "*") }}};
-        return envObject_50.getReturnStatus();
+        return envObject_51.getReturnStatus();
     }
     catch (err_51) {
-        envObject_50.tryCatch.setError(err_51);
-        return envObject_50.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_51.tryCatch.setError(err_51);
+        return envObject_51.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 // @ts-expect-error
@@ -4165,25 +4929,25 @@ function napi_create_date(env, time, result) {
     var value;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_51 = emnapiCtx.envStore
+    var envObject_52 = emnapiCtx.envStore
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         .
             get(env);
-    if (envObject_51.tryCatch.hasCaught())
-        return envObject_51.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_51.clearLastError();
+    if (envObject_52.tryCatch.hasCaught())
+        return envObject_52.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_52.clearLastError();
     try {
         if (result == 0)
-            return envObject_51.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_52.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64("result") }}};
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         value = emnapiCtx.addToCurrentScope(new Date(time)).id;
         {{{ makeSetValue("result", 0, "value", "*") }}};
-        return envObject_51.getReturnStatus();
+        return envObject_52.getReturnStatus();
     }
     catch (err_52) {
-        envObject_51.tryCatch.setError(err_52);
-        return envObject_51.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_52.tryCatch.setError(err_52);
+        return envObject_52.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 // @ts-expect-error
@@ -4192,31 +4956,31 @@ function napi_create_external(env, data, finalize_cb, finalize_hint, result) {
     var value;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_52 = emnapiCtx.envStore
+    var envObject_53 = emnapiCtx.envStore
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         .
             get(env);
-    if (envObject_52.tryCatch.hasCaught())
-        return envObject_52.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_52.clearLastError();
+    if (envObject_53.tryCatch.hasCaught())
+        return envObject_53.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_53.clearLastError();
     try {
         if (result == 0)
-            return envObject_52.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_53.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (!emnapiCtx.feature.supportFinalizer && finalize_cb) {
             throw emnapiCtx.createNotSupportWeakRefError("napi_create_external", "Parameter \"finalize_cb\" must be 0(NULL)");
         }
-        var externalHandle_1 = emnapiCtx.getCurrentScope().addExternal(envObject_52, data);
+        var externalHandle_1 = emnapiCtx.getCurrentScope().addExternal(envObject_53, data);
         if (finalize_cb) {
-            emnapiCtx.createReference(envObject_52, externalHandle_1.id, 0, 0 /* Ownership.kRuntime */, finalize_cb, data, finalize_hint);
+            emnapiCtx.createReference(envObject_53, externalHandle_1.id, 0, 0 /* Ownership.kRuntime */, finalize_cb, data, finalize_hint);
         }
         {{{ from64("result") }}};
         value = externalHandle_1.id;
         {{{ makeSetValue("result", 0, "value", "*") }}};
-        return envObject_52.clearLastError();
+        return envObject_53.clearLastError();
     }
     catch (err_53) {
-        envObject_52.tryCatch.setError(err_53);
-        return envObject_52.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_53.tryCatch.setError(err_53);
+        return envObject_53.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 function napi_create_external_arraybuffer(env, external_data, byte_length, finalize_cb, finalize_hint, result
@@ -4226,16 +4990,16 @@ function napi_create_external_arraybuffer(env, external_data, byte_length, final
     var value;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_53 = emnapiCtx.envStore
+    var envObject_54 = emnapiCtx.envStore
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         .
             get(env);
-    if (envObject_53.tryCatch.hasCaught())
-        return envObject_53.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_53.clearLastError();
+    if (envObject_54.tryCatch.hasCaught())
+        return envObject_54.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_54.clearLastError();
     try {
         if (result == 0)
-            return envObject_53.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_54.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64("byte_length") }}};
         {{{ from64("external_data") }}};
         {{{ from64("result") }}};
@@ -4267,21 +5031,21 @@ function napi_create_external_arraybuffer(env, external_data, byte_length, final
         if (finalize_cb) {
             var status_2 = _napi_add_finalizer(env, handle_10.id, external_data, finalize_cb, finalize_hint, 0);
             if (status_2 === 10 /* napi_status.napi_pending_exception */) {
-                var err_54 = envObject_53.tryCatch.extractException();
-                envObject_53.clearLastError();
+                var err_54 = envObject_54.tryCatch.extractException();
+                envObject_54.clearLastError();
                 throw err_54;
             }
             else if (status_2 !== 0 /* napi_status.napi_ok */) {
-                return envObject_53.setLastError(status_2);
+                return envObject_54.setLastError(status_2);
             }
         }
         value = handle_10.id;
         {{{ makeSetValue("result", 0, "value", "*") }}};
-        return envObject_53.getReturnStatus();
+        return envObject_54.getReturnStatus();
     }
     catch (err_55) {
-        envObject_53.tryCatch.setError(err_55);
-        return envObject_53.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_54.tryCatch.setError(err_55);
+        return envObject_54.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 function napi_create_object(env, result) {
@@ -4327,26 +5091,26 @@ function napi_create_typedarray(env, type, length, arraybuffer, byte_offset, res
     var value;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_54 = emnapiCtx.envStore
+    var envObject_55 = emnapiCtx.envStore
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         .
             get(env);
-    if (envObject_54.tryCatch.hasCaught())
-        return envObject_54.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_54.clearLastError();
+    if (envObject_55.tryCatch.hasCaught())
+        return envObject_55.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_55.clearLastError();
     try {
         if (arraybuffer == 0)
-            return envObject_54.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_55.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_54.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_55.setLastError(1 /* napi_status.napi_invalid_arg */);
         var handle_11 = emnapiCtx.handleStore.get(arraybuffer);
         var buffer_1 = handle_11.value;
         if (!(buffer_1 instanceof ArrayBuffer)) {
-            return envObject_54.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_55.setLastError(1 /* napi_status.napi_invalid_arg */);
         }
         {{{ from64("byte_offset") }}};
         {{{ from64("length") }}};
-        var createTypedArray_1 = function (envObject_54, Type, size_of_element, buffer_1, byte_offset, length) {
+        var createTypedArray_1 = function (envObject_55, Type, size_of_element, buffer_1, byte_offset, length) {
             var _a;
             byte_offset = byte_offset >>> 0;
             length = length >>> 0;
@@ -4354,15 +5118,15 @@ function napi_create_typedarray(env, type, length, arraybuffer, byte_offset, res
                 if ((byte_offset) % (size_of_element) !== 0) {
                     var err_57 = new RangeError("start offset of ".concat((_a = Type.name) !== null && _a !== void 0 ? _a : "", " should be a multiple of ").concat(size_of_element));
                     err_57.code = "ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT";
-                    envObject_54.tryCatch.setError(err_57);
-                    return envObject_54.setLastError(9 /* napi_status.napi_generic_failure */);
+                    envObject_55.tryCatch.setError(err_57);
+                    return envObject_55.setLastError(9 /* napi_status.napi_generic_failure */);
                 }
             }
             if (((length * size_of_element) + byte_offset) > buffer_1.byteLength) {
                 var err_58 = new RangeError("Invalid typed array length");
                 err_58.code = "ERR_NAPI_INVALID_TYPEDARRAY_LENGTH";
-                envObject_54.tryCatch.setError(err_58);
-                return envObject_54.setLastError(9 /* napi_status.napi_generic_failure */);
+                envObject_55.tryCatch.setError(err_58);
+                return envObject_55.setLastError(9 /* napi_status.napi_generic_failure */);
             }
             var out_1 = new Type(buffer_1, byte_offset, length);
             if (buffer_1 === wasmMemory.buffer) {
@@ -4380,39 +5144,39 @@ function napi_create_typedarray(env, type, length, arraybuffer, byte_offset, res
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
             value = emnapiCtx.addToCurrentScope(out_1).id;
             {{{ makeSetValue("result", 0, "value", "*") }}};
-            return envObject_54.getReturnStatus();
+            return envObject_55.getReturnStatus();
         };
         switch (type) {
             case 0 /* napi_typedarray_type.napi_int8_array */:
-                return createTypedArray_1(envObject_54, Int8Array, 1, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, Int8Array, 1, buffer_1, byte_offset, length);
             case 1 /* napi_typedarray_type.napi_uint8_array */:
-                return createTypedArray_1(envObject_54, Uint8Array, 1, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, Uint8Array, 1, buffer_1, byte_offset, length);
             case 2 /* napi_typedarray_type.napi_uint8_clamped_array */:
-                return createTypedArray_1(envObject_54, Uint8ClampedArray, 1, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, Uint8ClampedArray, 1, buffer_1, byte_offset, length);
             case 3 /* napi_typedarray_type.napi_int16_array */:
-                return createTypedArray_1(envObject_54, Int16Array, 2, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, Int16Array, 2, buffer_1, byte_offset, length);
             case 4 /* napi_typedarray_type.napi_uint16_array */:
-                return createTypedArray_1(envObject_54, Uint16Array, 2, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, Uint16Array, 2, buffer_1, byte_offset, length);
             case 5 /* napi_typedarray_type.napi_int32_array */:
-                return createTypedArray_1(envObject_54, Int32Array, 4, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, Int32Array, 4, buffer_1, byte_offset, length);
             case 6 /* napi_typedarray_type.napi_uint32_array */:
-                return createTypedArray_1(envObject_54, Uint32Array, 4, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, Uint32Array, 4, buffer_1, byte_offset, length);
             case 7 /* napi_typedarray_type.napi_float32_array */:
-                return createTypedArray_1(envObject_54, Float32Array, 4, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, Float32Array, 4, buffer_1, byte_offset, length);
             case 8 /* napi_typedarray_type.napi_float64_array */:
-                return createTypedArray_1(envObject_54, Float64Array, 8, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, Float64Array, 8, buffer_1, byte_offset, length);
             case 9 /* napi_typedarray_type.napi_bigint64_array */:
-                return createTypedArray_1(envObject_54, BigInt64Array, 8, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, BigInt64Array, 8, buffer_1, byte_offset, length);
             case 10 /* napi_typedarray_type.napi_biguint64_array */:
-                return createTypedArray_1(envObject_54, BigUint64Array, 8, buffer_1, byte_offset, length);
+                return createTypedArray_1(envObject_55, BigUint64Array, 8, buffer_1, byte_offset, length);
             default:
-                return envObject_54.setLastError(1 /* napi_status.napi_invalid_arg */);
+                return envObject_55.setLastError(1 /* napi_status.napi_invalid_arg */);
         }
         return null;
     }
     catch (err_56) {
-        envObject_54.tryCatch.setError(err_56);
-        return envObject_54.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_55.tryCatch.setError(err_56);
+        return envObject_55.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 function napi_create_buffer(env, size, data, result
@@ -4423,16 +5187,16 @@ function napi_create_buffer(env, size, data, result
     var value, pointer;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_55 = emnapiCtx.envStore
+    var envObject_56 = emnapiCtx.envStore
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         .
             get(env);
-    if (envObject_55.tryCatch.hasCaught())
-        return envObject_55.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_55.clearLastError();
+    if (envObject_56.tryCatch.hasCaught())
+        return envObject_56.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_56.clearLastError();
     try {
         if (result == 0)
-            return envObject_55.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_56.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64("result") }}};
         var Buffer_1 = emnapiCtx.feature.Buffer;
         var buffer_2 = void 0;
@@ -4463,11 +5227,11 @@ function napi_create_buffer(env, size, data, result
             {{{ from64("data") }}};
             {{{ makeSetValue("data", 0, "pointer", "*") }}};
         }
-        return envObject_55.getReturnStatus();
+        return envObject_56.getReturnStatus();
     }
     catch (err_59) {
-        envObject_55.tryCatch.setError(err_59);
-        return envObject_55.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_56.tryCatch.setError(err_59);
+        return envObject_56.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 function napi_create_buffer_copy(env, length, data, result_data, result
@@ -4477,16 +5241,16 @@ function napi_create_buffer_copy(env, length, data, result_data, result
     var value;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_56 = emnapiCtx.envStore
+    var envObject_57 = emnapiCtx.envStore
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         .
             get(env);
-    if (envObject_56.tryCatch.hasCaught())
-        return envObject_56.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_56.clearLastError();
+    if (envObject_57.tryCatch.hasCaught())
+        return envObject_57.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_57.clearLastError();
     try {
         if (result == 0)
-            return envObject_56.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_57.setLastError(1 /* napi_status.napi_invalid_arg */);
         var arrayBuffer_3 = emnapiCreateArrayBuffer(length, result_data);
         var Buffer_2 = emnapiCtx.feature.Buffer;
         var buffer_4 = Buffer_2.from(arrayBuffer_3);
@@ -4496,11 +5260,11 @@ function napi_create_buffer_copy(env, length, data, result_data, result
         value = emnapiCtx.addToCurrentScope(buffer_4).id;
         {{{ from64("result") }}};
         {{{ makeSetValue("result", 0, "value", "*") }}};
-        return envObject_56.getReturnStatus();
+        return envObject_57.getReturnStatus();
     }
     catch (err_60) {
-        envObject_56.tryCatch.setError(err_60);
-        return envObject_56.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_57.tryCatch.setError(err_60);
+        return envObject_57.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 function napi_create_external_buffer(env, length, data, finalize_cb, finalize_hint, result) {
@@ -4513,18 +5277,18 @@ function napi_create_dataview(env, byte_length, arraybuffer, byte_offset, result
     var value;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_57 = emnapiCtx.envStore
+    var envObject_58 = emnapiCtx.envStore
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         .
             get(env);
-    if (envObject_57.tryCatch.hasCaught())
-        return envObject_57.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_57.clearLastError();
+    if (envObject_58.tryCatch.hasCaught())
+        return envObject_58.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_58.clearLastError();
     try {
         if (arraybuffer == 0)
-            return envObject_57.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_58.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_57.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_58.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64("byte_length") }}};
         {{{ from64("byte_offset") }}};
         byte_length = byte_length >>> 0;
@@ -4532,13 +5296,13 @@ function napi_create_dataview(env, byte_length, arraybuffer, byte_offset, result
         var handle_12 = emnapiCtx.handleStore.get(arraybuffer);
         var buffer_5 = handle_12.value;
         if (!(buffer_5 instanceof ArrayBuffer)) {
-            return envObject_57.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_58.setLastError(1 /* napi_status.napi_invalid_arg */);
         }
         if ((byte_length + byte_offset) > buffer_5.byteLength) {
             var err_61 = new RangeError("byte_offset + byte_length should be less than or equal to the size in bytes of the array passed in");
             err_61.code = "ERR_NAPI_INVALID_DATAVIEW_ARGS";
-            envObject_57.tryCatch.setError(err_61);
-            return envObject_57.setLastError(10 /* napi_status.napi_pending_exception */);
+            envObject_58.tryCatch.setError(err_61);
+            return envObject_58.setLastError(10 /* napi_status.napi_pending_exception */);
         }
         var dataview_1 = new DataView(buffer_5, byte_offset, byte_length);
         if (buffer_5 === wasmMemory.buffer) {
@@ -4556,11 +5320,11 @@ function napi_create_dataview(env, byte_length, arraybuffer, byte_offset, result
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         value = emnapiCtx.addToCurrentScope(dataview_1).id;
         {{{ makeSetValue("result", 0, "value", "*") }}};
-        return envObject_57.getReturnStatus();
+        return envObject_58.getReturnStatus();
     }
     catch (err_62) {
-        envObject_57.tryCatch.setError(err_62);
-        return envObject_57.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_58.tryCatch.setError(err_62);
+        return envObject_58.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 function node_api_symbol_for(env, utf8description, length, result) {
@@ -4648,6 +5412,62 @@ emnapiImplement('napi_get_boolean', 'ipip', napi_get_boolean);
 emnapiImplement('napi_get_global', 'ipp', napi_get_global);
 emnapiImplement('napi_get_null', 'ipp', napi_get_null);
 emnapiImplement('napi_get_undefined', 'ipp', napi_get_undefined);
+function _napi_create_async_work(env, resource, resource_name, execute, complete, data, result) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (execute == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    if (result == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    var resourceObject;
+    if (resource) {
+        resourceObject = Object(emnapiCtx.handleStore.get(resource).value);
+    }
+    else {
+        resourceObject = {};
+    }
+    if (resource_name == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    var resourceName = String(emnapiCtx.handleStore.get(resource_name).value);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var id = emnapiAWST.create(env, resourceObject, resourceName, execute, complete, data);
+    {{{ makeSetValue('result', 0, 'id', '*') }}};
+    return envObject.clearLastError();
+}
+function _napi_delete_async_work(env, work) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (work == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    emnapiAWST.remove(work);
+    return envObject.clearLastError();
+}
+function _napi_queue_async_work(env, work) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (work == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    emnapiAWST.queue(work);
+    return envObject.clearLastError();
+}
+function _napi_cancel_async_work(env, work) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (work == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    var status = emnapiAWST.cancel(work);
+    if (status === 0 /* napi_status.napi_ok */)
+        return envObject.clearLastError();
+    return envObject.setLastError(status);
+}
+emnapiImplement('napi_create_async_work', 'ippppppp', _napi_create_async_work, ['$emnapiAWST']);
+emnapiImplement('napi_delete_async_work', 'ipp', _napi_delete_async_work, ['$emnapiAWST']);
+emnapiImplement('napi_queue_async_work', 'ipp', _napi_queue_async_work, ['$emnapiAWST']);
+emnapiImplement('napi_cancel_async_work', 'ipp', _napi_cancel_async_work, ['$emnapiAWST']);
 mergeInto(LibraryManager.library, {
     _emnapi_worker_unref__sig: 'vp',
     _emnapi_worker_unref__deps: ['$PThread'],
@@ -4742,23 +5562,23 @@ function emnapi_get_module_object(env, result) {
     var value;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_58 = emnapiCtx.envStore.get(env);
-    if (envObject_58.tryCatch
+    var envObject_59 = emnapiCtx.envStore.get(env);
+    if (envObject_59.tryCatch
         .hasCaught())
-        return envObject_58.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_58.clearLastError();
+        return envObject_59.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_59.clearLastError();
     try {
         if (result == 0)
-            return envObject_58.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_59.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64("result") }}};
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        value = envObject_58.ensureHandleId(Module);
+        value = envObject_59.ensureHandleId(Module);
         {{{ makeSetValue("result", 0, "value", "*") }}};
-        return envObject_58.getReturnStatus();
+        return envObject_59.getReturnStatus();
     }
     catch (err_63) {
-        envObject_58.tryCatch.setError(err_63);
-        return envObject_58.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_59.tryCatch.setError(err_63);
+        return envObject_59.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 // @ts-expect-error
@@ -4767,26 +5587,26 @@ function emnapi_get_module_property(env, utf8name, result) {
     var value;
     if (env == 0)
         return 1 /* napi_status.napi_invalid_arg */;
-    var envObject_59 = emnapiCtx.envStore.get(env);
-    if (envObject_59.tryCatch
+    var envObject_60 = emnapiCtx.envStore.get(env);
+    if (envObject_60.tryCatch
         .hasCaught())
-        return envObject_59.setLastError(10 /* napi_status.napi_pending_exception */);
-    envObject_59.clearLastError();
+        return envObject_60.setLastError(10 /* napi_status.napi_pending_exception */);
+    envObject_60.clearLastError();
     try {
         if (utf8name == 0)
-            return envObject_59.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_60.setLastError(1 /* napi_status.napi_invalid_arg */);
         if (result == 0)
-            return envObject_59.setLastError(1 /* napi_status.napi_invalid_arg */);
+            return envObject_60.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64("utf8name") }}};
         {{{ from64("result") }}};
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        value = envObject_59.ensureHandleId(Module[UTF8ToString(utf8name)]);
+        value = envObject_60.ensureHandleId(Module[UTF8ToString(utf8name)]);
         {{{ makeSetValue("result", 0, "value", "*") }}};
-        return envObject_59.getReturnStatus();
+        return envObject_60.getReturnStatus();
     }
     catch (err_64) {
-        envObject_59.tryCatch.setError(err_64);
-        return envObject_59.setLastError(10 /* napi_status.napi_pending_exception */);
+        envObject_60.tryCatch.setError(err_64);
+        return envObject_60.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
 emnapiImplement2('emnapi_get_module_object', 'ipp', emnapi_get_module_object);
@@ -4798,6 +5618,7 @@ emnapiDefineVar('$emnapiModule', {
     loaded: false,
     filename: ''
 });
+emnapiDefineVar('$emnapiAsyncWorkPoolSize', 0);
 function emnapiInit(options) {
     if (emnapiModule.loaded)
         return emnapiModule.exports;
@@ -4819,6 +5640,18 @@ function emnapiInit(options) {
         }
         emnapiNodeBinding = nodeBinding;
     }
+    if ('asyncWorkPoolSize' in options) {
+        if (typeof options.asyncWorkPoolSize !== 'number') {
+            throw new TypeError('options.asyncWorkPoolSize must be a integer');
+        }
+        emnapiAsyncWorkPoolSize = options.asyncWorkPoolSize >> 0;
+        if (emnapiAsyncWorkPoolSize > 1024) {
+            emnapiAsyncWorkPoolSize = 1024;
+        }
+        else if (emnapiAsyncWorkPoolSize < -1024) {
+            emnapiAsyncWorkPoolSize = -1024;
+        }
+    }
     // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
     var envObject = emnapiModule.envObject || (emnapiModule.envObject = emnapiCtx.createEnv(function (cb) { return {{{ makeDynCall('vppp', 'cb') }}}; }, function (cb) { return {{{ makeDynCall('vp', 'cb') }}}; }));
     var scope = emnapiCtx.openScope(envObject);
@@ -4840,7 +5673,11 @@ function emnapiInit(options) {
     delete emnapiModule.envObject;
     return emnapiModule.exports;
 }
-emnapiImplementHelper('$emnapiInit', undefined, emnapiInit, ['$emnapiModule', '$emnapiCtx', '$emnapiNodeBinding', 'napi_register_wasm_v1']);
+emnapiImplementHelper('$emnapiInit', undefined, emnapiInit, ['$emnapiModule', '$emnapiCtx', '$emnapiNodeBinding', '$emnapiAsyncWorkPoolSize', 'napi_register_wasm_v1']);
+function __emnapi_async_work_pool_size() {
+    return Math.abs(emnapiAsyncWorkPoolSize);
+}
+emnapiImplementInternal('_emnapi_async_work_pool_size', 'i', __emnapi_async_work_pool_size, ['$emnapiAsyncWorkPoolSize']);
 function __emnapi_get_filename(buf, len) {
     if (!buf) {
         return lengthBytesUTF8(emnapiModule.filename);