iambroise/site-panzai
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
site-panzai/node_modules/@napi-rs/wasm-runtime/dist/emnapi-plugins.cjs

1486 lines
59 KiB
JavaScript
Raw Permalink Normal View History

first commit
2026-11-13 13:57:04 +01:00
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
// ../node_modules/@emnapi/core/dist/plugins/async-work.js
function asyncWork(emnapiPluginCtx) {
const { emnapiCtx, emnapiNodeBinding, emnapiAsyncWorkPoolSize } = emnapiPluginCtx;
var mod = (function(exports, emnapi_shared, emscripten_runtime) {
/**
* @__deps $emnapiCtx
* @__deps $emnapiEnv
* @__deps $emnapiNodeBinding
* @__deps $emnapiAsyncWorkPoolSize
* @__postset
* ```
* emnapiAWST.init();
* ```
*/
var emnapiAWST = {
idGen: {},
values: [void 0],
queued: /* @__PURE__ */ new Set(),
pending: [],
pendingHead: 0,
init: function() {
const idGen = {
nextId: 1,
list: [],
listHead: 0,
generate: function() {
let id;
if (idGen.listHead < idGen.list.length) {
id = idGen.list[idGen.listHead++];
if (idGen.listHead === idGen.list.length) {
idGen.list.length = 0;
idGen.listHead = 0;
}
} else {
id = idGen.nextId;
idGen.nextId++;
}
return id;
},
reuse: function(id) {
idGen.list.push(id);
}
};
emnapiAWST.idGen = idGen;
emnapiAWST.values = [void 0];
emnapiAWST.queued = /* @__PURE__ */ new Set();
emnapiAWST.pending = [];
emnapiAWST.pendingHead = 0;
},
create: function(env, resource, resourceName, execute, complete, data) {
let asyncId = 0;
let triggerAsyncId = 0;
if (emnapiNodeBinding) {
const asyncContext = emnapiNodeBinding.node.emitAsyncInit(resource, resourceName, -1);
asyncId = asyncContext.asyncId;
triggerAsyncId = asyncContext.triggerAsyncId;
}
const id = emnapiAWST.idGen.generate();
emnapiAWST.values[id] = {
env,
id,
resource,
asyncId,
triggerAsyncId,
status: 0,
execute,
complete,
data
};
return id;
},
callComplete: function(work, status) {
const complete = work.complete;
const env = work.env;
const data = work.data;
const callback = () => {
if (!complete) return;
const envObject = emnapi_shared.emnapiEnv;
const scope = emnapiCtx.openScope(envObject);
try {
envObject.callbackIntoModule(true, () => {
emnapiPluginCtx.wasmTable.get(complete)(env, status, data);
});
} finally {
emnapiCtx.closeScope(envObject, scope);
}
};
if (emnapiNodeBinding) emnapiNodeBinding.node.makeCallback(work.resource, callback, [], {
asyncId: work.asyncId,
triggerAsyncId: work.triggerAsyncId
});
else callback();
},
queue: function(id) {
const work = emnapiAWST.values[id];
if (!work) return;
if (work.status === 0) {
work.status = 1;
if (emnapiAWST.queued.size >= (Math.abs(emnapiAsyncWorkPoolSize) || 4)) {
if (emnapiAWST.pendingHead >= 1024 && emnapiAWST.pendingHead * 2 >= emnapiAWST.pending.length) {
emnapiAWST.pending.splice(0, emnapiAWST.pendingHead);
emnapiAWST.pendingHead = 0;
}
emnapiAWST.pending.push(id);
return;
}
emnapiAWST.queued.add(id);
const env = work.env;
const data = work.data;
const execute = work.execute;
work.status = 2;
emnapiCtx.features.setImmediate(() => {
emnapiPluginCtx.wasmTable.get(execute)(env, data);
emnapiAWST.queued.delete(id);
work.status = 3;
emnapiCtx.features.setImmediate(() => {
emnapiAWST.callComplete(work, 0);
});
if (emnapiAWST.pendingHead < emnapiAWST.pending.length) {
const nextWorkId = emnapiAWST.pending[emnapiAWST.pendingHead++];
if (emnapiAWST.pendingHead === emnapiAWST.pending.length) {
emnapiAWST.pending.length = 0;
emnapiAWST.pendingHead = 0;
}
emnapiAWST.values[nextWorkId].status = 0;
emnapiAWST.queue(nextWorkId);
}
});
}
},
cancel: function(id) {
const index = emnapiAWST.pending.indexOf(id, emnapiAWST.pendingHead);
if (index !== -1) {
const work = emnapiAWST.values[id];
if (work && work.status === 1) {
work.status = 4;
emnapiAWST.pending.splice(index, 1);
if (emnapiAWST.pendingHead === emnapiAWST.pending.length) {
emnapiAWST.pending.length = 0;
emnapiAWST.pendingHead = 0;
}
emnapiCtx.features.setImmediate(() => {
emnapiAWST.callComplete(work, 11);
});
return 0;
} else return 9;
}
return 9;
},
remove: function(id) {
const work = emnapiAWST.values[id];
if (!work) return;
if (emnapiNodeBinding) emnapiNodeBinding.node.emitAsyncDestroy({
asyncId: work.asyncId,
triggerAsyncId: work.triggerAsyncId
});
emnapiAWST.values[id] = void 0;
emnapiAWST.idGen.reuse(id);
}
};
const { _emnapi_node_emit_async_init, _emnapi_node_emit_async_destroy, _emnapi_runtime_keepalive_pop, _emnapi_runtime_keepalive_push } = emnapiPluginCtx;
var emnapiAWMT = {
pool: [],
workerReady: null,
globalAddress: 0,
globalOffset: {
idle_threads: 0,
q: 4,
next: 4,
prev: 8,
mutex: 12,
cond: 16,
exit_message: 20,
end: 28
},
offset: {
resource: 0,
async_id: 8,
trigger_async_id: 16,
env: 24,
status: 28,
queue: 32,
queue_next: 32,
queue_prev: 36,
data: 40,
execute: 44,
complete: 48,
end: 52
},
/**
* When another thread grows the shared WebAssembly.Memory, this agent's
* cached `wasmMemory.buffer` may still have the old shorter length
* (V8 refreshes it lazily). If a pointer derived from shared memory lies
* beyond the cached length, `wasmMemory.grow(0)` forces the agent to
* observe the current memory size and refreshes the buffer.
*/
ensureBufferFor(end) {
let buffer = emscripten_runtime.wasmMemory.buffer;
if (end > buffer.byteLength) {
emscripten_runtime.wasmMemory.grow(0);
buffer = emscripten_runtime.wasmMemory.buffer;
}
return buffer;
},
init() {
emnapiAWMT.pool = [];
emnapiAWMT.workerReady = null;
if (typeof emscripten_runtime.PThread !== "undefined") {
emscripten_runtime.PThread.unusedWorkers.forEach(emnapiAWMT.addListener);
Object.values(emscripten_runtime.PThread.pthreads).forEach(emnapiAWMT.addListener);
const __original_getNewWorker = emscripten_runtime.PThread.getNewWorker;
emscripten_runtime.PThread.getNewWorker = function() {
const r = __original_getNewWorker.apply(this, arguments);
emnapiAWMT.addListener(r);
return r;
};
}
},
addListener(worker) {
if (!worker) return false;
if (worker._emnapiAWMTListener) return true;
const handler = function(e) {
const __emnapi__ = (emscripten_runtime.ENVIRONMENT_IS_NODE ? e : e.data).__emnapi__;
if (__emnapi__) {
const type = __emnapi__.type;
const payload = __emnapi__.payload;
if (type === "async-work-complete") emnapiAWMT.callComplete(payload.work, 0);
}
};
const dispose = function() {
if (emscripten_runtime.ENVIRONMENT_IS_NODE) worker.off("message", handler);
else worker.removeEventListener("message", handler, false);
delete worker._emnapiAWMTListener;
};
worker._emnapiAWMTListener = {
handler,
dispose
};
if (emscripten_runtime.ENVIRONMENT_IS_NODE) worker.on("message", handler);
else worker.addEventListener("message", handler, false);
return true;
},
initGlobal() {
if (!emnapiAWMT.globalAddress) {
emnapiAWMT.globalAddress = emscripten_runtime._malloc(emnapiAWMT.globalOffset.end);
emnapiAWMT.globalAddress >>>= 0;
const size = emnapiAWMT.globalOffset.end;
const addr = emnapiAWMT.globalAddress;
new Uint8Array(emnapiAWMT.ensureBufferFor(addr + size), addr, size).fill(0);
emnapiAWMT.queueInit(emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.q);
emnapiAWMT.queueInit(emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.exit_message);
}
},
terminateWorkers() {
emnapiAWMT.pool.forEach((w) => {
w._emnapiAWMTListener?.dispose();
w._emnapiTSFNListener?.dispose();
w.terminate();
});
emnapiAWMT.pool.length = 0;
},
initWorkers(n) {
if (emscripten_runtime.ENVIRONMENT_IS_PTHREAD) return emnapiAWMT.workerReady || (emnapiAWMT.workerReady = Promise.resolve());
if (emnapiAWMT.workerReady) return emnapiAWMT.workerReady;
if (!("emnapi_async_worker_create" in emscripten_runtime.wasmInstance.exports)) throw new TypeError("`emnapi_async_worker_create` is not exported, please try to add `--export=emnapi_async_worker_create` to linker flags");
const emnapi_async_worker_create = emscripten_runtime.wasmInstance.exports.emnapi_async_worker_create;
const args = [];
emnapiAWMT.initGlobal();
for (let i = 0; i < n; ++i) args.push(emnapi_async_worker_create(1, emnapiAWMT.globalAddress));
const promises = args.map((index) => {
if (index === 0) return Promise.reject(/* @__PURE__ */ new Error("Failed to create async worker"));
let worker;
if (index < 0) {
worker = emnapiAWMT.pool[-index - 1];
if (worker) return worker.whenLoaded;
}
index >>>= 0;
const tidOffset = 20;
const tid = new DataView(emnapiAWMT.ensureBufferFor(index + tidOffset + 4)).getInt32(index + tidOffset, true);
worker = emscripten_runtime.PThread.pthreads[tid];
return worker.whenLoaded;
});
emnapiAWMT.workerReady = Promise.all(promises);
return emnapiAWMT.workerReady;
},
getResource(work) {
emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.resource + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
return GET_HEAP_DATA_VIEW().getUint32(work + emnapiAWMT.offset.resource, true);
},
getExecute(work) {
emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.execute + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
return GET_HEAP_DATA_VIEW().getUint32(work + emnapiAWMT.offset.execute, true);
},
getComplete(work) {
emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.complete + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
return GET_HEAP_DATA_VIEW().getUint32(work + emnapiAWMT.offset.complete, true);
},
getEnv(work) {
emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.env + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
return GET_HEAP_DATA_VIEW().getUint32(work + emnapiAWMT.offset.env, true);
},
getData(work) {
emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.data + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
return GET_HEAP_DATA_VIEW().getUint32(work + emnapiAWMT.offset.data, true);
},
getMutex() {
const index = emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.mutex;
const mutex = {
lock() {
const isBrowserMain = typeof window !== "undefined" && typeof document !== "undefined" && !emscripten_runtime.ENVIRONMENT_IS_NODE;
const i32a = new Int32Array(emnapiAWMT.ensureBufferFor(index + 4), index, 1);
if (isBrowserMain) {
while (true) if (Atomics.compareExchange(i32a, 0, 0, 10) === 0) return;
} else while (true) {
if (Atomics.compareExchange(i32a, 0, 0, 10) === 0) return;
Atomics.wait(i32a, 0, 10);
}
},
unlock() {
const i32a = new Int32Array(emnapiAWMT.ensureBufferFor(index + 4), index, 1);
if (Atomics.compareExchange(i32a, 0, 10, 0) !== 10) throw new Error("Tried to unlock while not holding the mutex");
Atomics.notify(i32a, 0, 1);
},
execute(fn) {
mutex.lock();
try {
return fn();
} finally {
mutex.unlock();
}
}
};
return mutex;
},
getCond() {
const index = emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.cond;
const mutex = emnapiAWMT.getMutex();
return {
wait() {
const i32a = new Int32Array(emnapiAWMT.ensureBufferFor(index + 4), index, 1);
const value = Atomics.load(i32a, 0);
mutex.unlock();
Atomics.wait(i32a, 0, value);
mutex.lock();
},
signal() {
const i32a = new Int32Array(emnapiAWMT.ensureBufferFor(index + 4), index, 1);
Atomics.add(i32a, 0, 1);
Atomics.notify(i32a, 0, 1);
}
};
},
queueInit(q) {
emnapiAWMT.ensureBufferFor(q + 4 + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
GET_HEAP_DATA_VIEW().setUint32(q, q, true);
GET_HEAP_DATA_VIEW().setUint32(q + 4, q, true);
},
queueInsertTail(h, q) {
emnapiAWMT.ensureBufferFor(h + 4 + 4);
emnapiAWMT.ensureBufferFor(q + 4 + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
GET_HEAP_DATA_VIEW().setUint32(q, h, true);
const tempValue = GET_HEAP_DATA_VIEW().getUint32(h + 4, true);
GET_HEAP_DATA_VIEW().setUint32(q + 4, tempValue, true);
const qprev = GET_HEAP_DATA_VIEW().getUint32(q + 4, true);
GET_HEAP_DATA_VIEW().setUint32(qprev, q, true);
GET_HEAP_DATA_VIEW().setUint32(h + 4, q, true);
},
queueRemove(q) {
emnapiAWMT.ensureBufferFor(q + 4 + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
const qprev = GET_HEAP_DATA_VIEW().getUint32(q + 4, true);
const qnext = GET_HEAP_DATA_VIEW().getUint32(q, true);
GET_HEAP_DATA_VIEW().setUint32(qprev, qnext, true);
GET_HEAP_DATA_VIEW().setUint32(qnext + 4, qprev, true);
},
queueEmpty(q) {
emnapiAWMT.ensureBufferFor(q + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
return q == GET_HEAP_DATA_VIEW().getUint32(q, true);
},
scheduleWork: function(work) {
if (!emnapiAWMT.workerReady?.ready) emnapiAWMT.initWorkers(emnapi_shared._emnapi_async_work_pool_size()).then(() => {
emnapiAWMT.workerReady.ready = true;
}).catch((err) => {
emnapiAWMT.workerReady = null;
throw err;
});
_emnapi_runtime_keepalive_push();
emnapiCtx.increaseWaitingRequestCounter();
const statusBuffer = new Int32Array(emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.status + 4), work + emnapiAWMT.offset.status, 1);
Atomics.store(statusBuffer, 0, 0);
const mutex = emnapiAWMT.getMutex();
const cond = emnapiAWMT.getCond();
mutex.lock();
try {
emnapiAWMT.queueInsertTail(emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.q, work + emnapiAWMT.offset.queue);
} catch (err) {
_emnapi_runtime_keepalive_pop();
emnapiCtx.decreaseWaitingRequestCounter();
mutex.unlock();
throw err;
}
emnapiAWMT.ensureBufferFor(emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.idle_threads + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
if (GET_HEAP_DATA_VIEW().getUint32(emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.idle_threads, true) > 0) cond.signal();
mutex.unlock();
},
cancelWork(work) {
let cancelled = false;
emnapiAWMT.getMutex().execute(() => {
emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.status + 4);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
cancelled = !emnapiAWMT.queueEmpty(work + emnapiAWMT.offset.queue) && GET_HEAP_DATA_VIEW().getInt32(work + emnapiAWMT.offset.status, true) !== 2;
if (cancelled) emnapiAWMT.queueRemove(work + emnapiAWMT.offset.queue);
});
if (!cancelled) return 9;
if (Atomics.compareExchange(new Int32Array(emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.status + 4), work + emnapiAWMT.offset.status, 1), 0, 0, 1) !== 0) return 9;
emnapiCtx.features.setImmediate(() => {
emnapiAWMT.callComplete(work, 11);
});
return 0;
},
callComplete: function(work, status) {
_emnapi_runtime_keepalive_pop();
emnapiCtx.decreaseWaitingRequestCounter();
const complete = emnapiAWMT.getComplete(work);
const env = emnapiAWMT.getEnv(work);
const data = emnapiAWMT.getData(work);
const envObject = emnapi_shared.emnapiEnv;
const scope = emnapiCtx.openScope(envObject);
const callback = () => {
if (!complete) return;
envObject.callbackIntoModule(true, () => {
emnapiPluginCtx.wasmTable.get(complete)(env, status, data);
});
};
try {
if (emnapiNodeBinding) {
const resource = emnapiAWMT.getResource(work);
const resource_value = emnapiCtx.getRef(resource).get();
const resourceObject = emnapiCtx.jsValueFromNapiValue(resource_value);
const view = new DataView(emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.trigger_async_id + 8));
const asyncId = view.getFloat64(work + emnapiAWMT.offset.async_id, true);
const triggerAsyncId = view.getFloat64(work + emnapiAWMT.offset.trigger_async_id, true);
emnapiNodeBinding.node.makeCallback(resourceObject, callback, [], {
asyncId,
triggerAsyncId
});
} else callback();
} finally {
emnapiCtx.closeScope(envObject, scope);
}
}
};
emnapiAWST.init();
emnapiAWMT.init();
/** @__sig ippppppp */
var napi_create_async_work = emnapi_shared.singleThreadAsyncWork ? function(env, resource, resource_name, execute, complete, data, result) {
if (!env) return 1;
const envObject = emnapi_shared.emnapiEnv;
envObject.checkGCAccess();
if (!execute) return envObject.setLastError(1);
if (!result) return envObject.setLastError(1);
let resourceObject;
if (resource) resourceObject = Object(emnapiCtx.jsValueFromNapiValue(resource));
else resourceObject = {};
if (!resource_name) return envObject.setLastError(1);
const resourceName = String(emnapiCtx.jsValueFromNapiValue(resource_name));
const id = emnapiAWST.create(env, resourceObject, resourceName, execute, complete, data);
result >>>= 0;
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
GET_HEAP_DATA_VIEW().setUint32(result, id, true);
return envObject.clearLastError();
} : function(env, resource, resource_name, execute, complete, data, result) {
if (!env) return 1;
const envObject = emnapi_shared.emnapiEnv;
envObject.checkGCAccess();
if (!execute) return envObject.setLastError(1);
if (!result) return envObject.setLastError(1);
let resourceObject;
if (resource) resourceObject = Object(emnapiCtx.jsValueFromNapiValue(resource));
else resourceObject = {};
if (!resource_name) return envObject.setLastError(1);
const sizeofAW = emnapiAWMT.offset.end;
let aw = emscripten_runtime._malloc(sizeofAW);
if (!aw) return envObject.setLastError(9);
aw >>>= 0;
new Uint8Array(emnapiAWMT.ensureBufferFor(aw + sizeofAW)).subarray(aw, aw + sizeofAW).fill(0);
const s = emnapiCtx.napiValueFromJsValue(resourceObject);
const resource_ = emnapiCtx.createReference(envObject, s, 1, 1).id;
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
GET_HEAP_DATA_VIEW().setUint32(aw, resource_, true);
_emnapi_node_emit_async_init(s, resource_name, -1, aw + emnapiAWMT.offset.async_id);
GET_HEAP_DATA_VIEW().setUint32(aw + emnapiAWMT.offset.env, env, true);
GET_HEAP_DATA_VIEW().setUint32(aw + emnapiAWMT.offset.execute, execute, true);
GET_HEAP_DATA_VIEW().setUint32(aw + emnapiAWMT.offset.complete, complete, true);
GET_HEAP_DATA_VIEW().setUint32(aw + emnapiAWMT.offset.data, data, true);
emnapiAWMT.queueInit(aw + emnapiAWMT.offset.queue);
result >>>= 0;
GET_HEAP_DATA_VIEW().setUint32(result, aw, true);
return envObject.clearLastError();
};
/** @__sig ipp */
var napi_delete_async_work = emnapi_shared.singleThreadAsyncWork ? function(env, work) {
if (!env) return 1;
const envObject = emnapi_shared.emnapiEnv;
envObject.checkGCAccess();
if (!work) return envObject.setLastError(1);
work >>>= 0;
emnapiAWST.remove(work);
return envObject.clearLastError();
} : function(env, work) {
if (!env) return 1;
const envObject = emnapi_shared.emnapiEnv;
envObject.checkGCAccess();
if (!work) return envObject.setLastError(1);
work >>>= 0;
const resource = emnapiAWMT.getResource(work);
emnapiCtx.getRef(resource).dispose();
if (emnapiNodeBinding) {
const view = new DataView(emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.trigger_async_id + 8));
const asyncId = view.getFloat64(work + emnapiAWMT.offset.async_id, true);
const triggerAsyncId = view.getFloat64(work + emnapiAWMT.offset.trigger_async_id, true);
_emnapi_node_emit_async_destroy(asyncId, triggerAsyncId);
}
emscripten_runtime._free(work);
return envObject.clearLastError();
};
/** @__sig ipp */
var napi_queue_async_work = emnapi_shared.singleThreadAsyncWork ? function(env, work) {
if (!env) return 1;
const envObject = emnapi_shared.emnapiEnv;
if (!work) return envObject.setLastError(1);
work >>>= 0;
emnapiAWST.queue(work);
return envObject.clearLastError();
} : function(env, work) {
if (!env) return 1;
const envObject = emnapi_shared.emnapiEnv;
if (!work) return envObject.setLastError(1);
work >>>= 0;
emnapiAWMT.scheduleWork(work);
return envObject.clearLastError();
};
/** @__sig ipp */
var napi_cancel_async_work = emnapi_shared.singleThreadAsyncWork ? function(env, work) {
if (!env) return 1;
const envObject = emnapi_shared.emnapiEnv;
if (!work) return envObject.setLastError(1);
work >>>= 0;
const status = emnapiAWST.cancel(work);
if (status === 0) return envObject.clearLastError();
return envObject.setLastError(status);
} : function(env, work) {
if (!env) return 1;
const envObject = emnapi_shared.emnapiEnv;
if (!work) return envObject.setLastError(1);
work >>>= 0;
const status = emnapiAWMT.cancelWork(work);
if (status === 0) return envObject.clearLastError();
return envObject.setLastError(status);
};
/** @__sig pp */
function _emnapi_async_worker(globalAddress) {
globalAddress >>>= 0;
emnapiAWMT.globalAddress = globalAddress;
const mutex = emnapiAWMT.getMutex();
const cond = emnapiAWMT.getCond();
mutex.lock();
const exitMessageAddr = globalAddress + emnapiAWMT.globalOffset.exit_message;
const idleThreadsAddr = globalAddress + emnapiAWMT.globalOffset.idle_threads;
const workerQueueAddr = globalAddress + emnapiAWMT.globalOffset.q;
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
for (;;) {
emnapiAWMT.ensureBufferFor(workerQueueAddr + 4);
while (emnapiAWMT.queueEmpty(workerQueueAddr)) {
Atomics.add(new Int32Array(emnapiAWMT.ensureBufferFor(idleThreadsAddr + 4), idleThreadsAddr, 1), 0, 1);
cond.wait();
Atomics.sub(new Int32Array(emnapiAWMT.ensureBufferFor(idleThreadsAddr + 4), idleThreadsAddr, 1), 0, 1);
}
const q = GET_HEAP_DATA_VIEW().getUint32(workerQueueAddr, true);
if (q === exitMessageAddr) {
cond.signal();
mutex.unlock();
break;
}
const work = q - emnapiAWMT.offset.queue;
emnapiAWMT.queueRemove(q);
emnapiAWMT.queueInit(q);
mutex.unlock();
const statusBuffer = new Int32Array(emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.status + 4), work + emnapiAWMT.offset.status, 1);
if (Atomics.load(statusBuffer, 0) === 1) emscripten_runtime.abort("unreachable");
const execute = emnapiAWMT.getExecute(work);
const env = emnapiAWMT.getEnv(work);
const data = emnapiAWMT.getData(work);
emnapiPluginCtx.wasmTable.get(execute)(env, data);
Atomics.store(statusBuffer, 0, 2);
const postMessage = emnapi_shared.addonModule.postMessage;
postMessage({ __emnapi__: {
type: "async-work-complete",
payload: { work }
} });
mutex.lock();
}
return 0;
}
/** @__sig ipp */
function _emnapi_spawn_worker(f, globalAddress) {
if (typeof emnapi_shared.onCreateWorker !== "function") throw new TypeError("`options.onCreateWorker` is not a function");
const promises = [];
const args = [];
if (!("emnapi_async_worker_create" in emscripten_runtime.wasmInstance.exports)) throw new TypeError("`emnapi_async_worker_create` is not exported, please try to add `--export=emnapi_async_worker_create` to linker flags");
args.push(emscripten_runtime.wasmInstance.exports.emnapi_async_worker_create(0, 0));
let ret;
try {
const worker = emnapi_shared.onCreateWorker({
type: "async-work",
name: "emnapi-async-worker"
});
const handleError = () => {
if (!worker.loaded) return;
Promise.resolve().then(() => {
emnapiAWMT.terminateWorkers();
emscripten_runtime.PThread.terminateAllThreads();
});
};
if (emscripten_runtime.ENVIRONMENT_IS_NODE) worker.on("error", handleError);
else worker.addEventListener("error", handleError, false);
const p = emscripten_runtime.PThread.loadWasmModuleToWorker(worker);
emnapiAWMT.addListener(worker);
if (typeof emnapiPluginCtx.emnapiTSFN !== "undefined") emnapiPluginCtx.emnapiTSFN.addListener(worker);
promises.push(p.then(() => {
if (typeof worker.unref === "function") worker.unref();
}));
ret = emnapiAWMT.pool.push(worker) - 1;
const arg = args[0];
worker.threadBlockBase = arg;
worker.postMessage({ __emnapi__: {
type: "async-worker-init",
payload: {
arg,
func: [f, globalAddress]
}
} });
} catch (err) {
const arg = args[0];
emscripten_runtime._free(arg);
throw err;
}
return ret;
}
function initWorker(startArg, func) {
if (emnapi_shared.addonModule.childThread) {
if (typeof emscripten_runtime.wasmInstance.exports.emnapi_async_worker_init !== "function") throw new TypeError("`emnapi_async_worker_init` is not exported, please try to add `--export=emnapi_async_worker_init` to linker flags");
emscripten_runtime.wasmInstance.exports.emnapi_async_worker_init(startArg);
emnapiPluginCtx.wasmTable.get(func[0])(func[1]);
} else throw new Error("startThread is only available in child threads");
}
emnapi_shared.addonModule.initWorker = initWorker;
exports._emnapi_async_worker = _emnapi_async_worker;
exports._emnapi_spawn_worker = _emnapi_spawn_worker;
exports.napi_cancel_async_work = napi_cancel_async_work;
exports.napi_create_async_work = napi_create_async_work;
exports.napi_delete_async_work = napi_delete_async_work;
exports.napi_queue_async_work = napi_queue_async_work;
return exports;
})({}, emnapiPluginCtx, emnapiPluginCtx);
return { importObject: (original) => {
Object.keys(mod).forEach((key) => {
if (key.startsWith("napi_") || key.startsWith("node_api_")) original.napi[key] = mod[key];
else original.env[key] = mod[key];
});
} };
}
// ../node_modules/@emnapi/core/dist/plugins/threadsafe-function.js
function threadsafeFunction(emnapiPluginCtx) {
const { emnapiCtx, emnapiNodeBinding, _emnapi_node_emit_async_destroy: __emnapi_node_emit_async_destroy, _emnapi_node_emit_async_init: __emnapi_node_emit_async_init, _emnapi_runtime_keepalive_pop: __emnapi_runtime_keepalive_pop, _emnapi_runtime_keepalive_push: __emnapi_runtime_keepalive_push } = emnapiPluginCtx;
var mod = (function(exports, emnapi_shared, emscripten_runtime) {
/**
* @__deps malloc
* @__deps free
* @__deps $emnapiCtx
* @__deps $emnapiEnv
* @__deps $emnapiNodeBinding
* @__deps _emnapi_node_emit_async_destroy
* @__deps _emnapi_runtime_keepalive_pop
* @__postset
* ```
* emnapiTSFN.init();
* ```
*/
const emnapiTSFN = {
_liveSet: {},
offset: {
__size__: 0,
resource: 0,
async_id: 0,
trigger_async_id: 0,
queue_size: 0,
is_some: 0,
queue: 0,
async_pending: 0,
async_u_fd: 0,
thread_count: 0,
state: 0,
dispatch_state: 0,
context: 0,
max_queue_size: 0,
ref: 0,
env: 0,
finalize_data: 0,
finalize_cb: 0,
call_js_cb: 0,
handles_closing: 0,
async_ref: 0,
mutex: 0,
cond: 0
},
init() {
emnapiTSFN._liveSet = /* @__PURE__ */ new Set();
emnapiTSFN.offset.__size__ = 184;
emnapiTSFN.offset.resource = 0;
emnapiTSFN.offset.async_id = 8;
emnapiTSFN.offset.trigger_async_id = 16;
emnapiTSFN.offset.queue_size = 60;
emnapiTSFN.offset.is_some = 24;
emnapiTSFN.offset.queue = 64;
emnapiTSFN.offset.async_pending = 132;
emnapiTSFN.offset.async_u_fd = 96;
emnapiTSFN.offset.thread_count = 136;
emnapiTSFN.offset.state = 140;
emnapiTSFN.offset.dispatch_state = 144;
emnapiTSFN.offset.context = 148;
emnapiTSFN.offset.max_queue_size = 152;
emnapiTSFN.offset.ref = 156;
emnapiTSFN.offset.env = 160;
emnapiTSFN.offset.finalize_data = 164;
emnapiTSFN.offset.finalize_cb = 168;
emnapiTSFN.offset.call_js_cb = 172;
emnapiTSFN.offset.handles_closing = 176;
emnapiTSFN.offset.async_ref = 180;
emnapiTSFN.offset.mutex = 32;
emnapiTSFN.offset.cond = 56;
emnapiTSFN.offset.mutex = emnapiTSFN.offset.mutex + 4;
if (typeof emscripten_runtime.PThread !== "undefined") {
emscripten_runtime.PThread.unusedWorkers.forEach(emnapiTSFN.addListener);
Object.values(emscripten_runtime.PThread.pthreads).forEach(emnapiTSFN.addListener);
const __original_getNewWorker = emscripten_runtime.PThread.getNewWorker;
emscripten_runtime.PThread.getNewWorker = function() {
const r = __original_getNewWorker.apply(this, arguments);
emnapiTSFN.addListener(r);
return r;
};
}
},
addListener(worker) {
if (!worker) return false;
if (worker._emnapiTSFNListener) return true;
const handler = function(e) {
const __emnapi__ = (emscripten_runtime.ENVIRONMENT_IS_NODE ? e : e.data).__emnapi__;
if (__emnapi__) {
const type = __emnapi__.type;
const payload = __emnapi__.payload;
if (type === "tsfn-send") {
const pendng = payload.tsfn + emnapiTSFN.offset.async_pending;
if (Atomics.load(new Int32Array(emnapiTSFN.ensureBufferFor(pendng + 4)), pendng >>> 2) !== 0) emnapiTSFN.enqueue(payload.tsfn);
}
}
};
const dispose = function() {
if (emscripten_runtime.ENVIRONMENT_IS_NODE) worker.off("message", handler);
else worker.removeEventListener("message", handler, false);
delete worker._emnapiTSFNListener;
};
worker._emnapiTSFNListener = {
handler,
dispose
};
if (emscripten_runtime.ENVIRONMENT_IS_NODE) worker.on("message", handler);
else worker.addEventListener("message", handler, false);
return true;
},
/**
* When another thread grows the shared WebAssembly.Memory, this agent's
* cached `wasmMemory.buffer` may still have the old shorter length
* (V8 refreshes it lazily). If a pointer derived from shared memory lies
* beyond the cached length, `wasmMemory.grow(0)` forces the agent to
* observe the current memory size and refreshes the buffer.
*/
ensureBufferFor(end) {
let buffer = emscripten_runtime.wasmMemory.buffer;
if (end > buffer.byteLength) {
emscripten_runtime.wasmMemory.grow(0);
buffer = emscripten_runtime.wasmMemory.buffer;
}
return buffer;
},
initQueue(func) {
const size = 8;
let queue = emscripten_runtime._malloc(size);
if (!queue) return false;
queue >>>= 0;
new Uint8Array(emnapiTSFN.ensureBufferFor(queue + size), queue, size).fill(0);
emnapiTSFN.storeSizeTypeValue(func + emnapiTSFN.offset.queue, queue, false);
return true;
},
destroyQueue(func) {
const queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);
if (queue) {
let node = emnapiTSFN.loadSizeTypeValue(queue, false);
while (node !== 0) {
const next = emnapiTSFN.loadSizeTypeValue(node + 4, false);
emscripten_runtime._free(node);
node = next;
}
emscripten_runtime._free(queue);
}
},
pushQueue(func, data) {
const queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);
const head = emnapiTSFN.loadSizeTypeValue(queue, false);
const tail = emnapiTSFN.loadSizeTypeValue(queue + 4, false);
let node = emscripten_runtime._malloc(8);
if (!node) throw new Error("OOM");
node >>>= 0;
emnapiTSFN.storeSizeTypeValue(node, data, false);
emnapiTSFN.storeSizeTypeValue(node + 4, 0, false);
if (head === 0 && tail === 0) {
emnapiTSFN.storeSizeTypeValue(queue, node, false);
emnapiTSFN.storeSizeTypeValue(queue + 4, node, false);
} else {
emnapiTSFN.storeSizeTypeValue(tail + 4, node, false);
emnapiTSFN.storeSizeTypeValue(queue + 4, node, false);
}
emnapiTSFN.addQueueSize(func);
},
shiftQueue(func) {
const queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);
const head = emnapiTSFN.loadSizeTypeValue(queue, false);
if (head === 0) return 0;
const node = head;
const next = emnapiTSFN.loadSizeTypeValue(head + 4, false);
emnapiTSFN.storeSizeTypeValue(queue, next, false);
if (next === 0) emnapiTSFN.storeSizeTypeValue(queue + 4, 0, false);
emnapiTSFN.storeSizeTypeValue(node + 4, 0, false);
const value = emnapiTSFN.loadSizeTypeValue(node, false);
emscripten_runtime._free(node);
emnapiTSFN.subQueueSize(func);
return value;
},
push(func, data, mode) {
const mutex = emnapiTSFN.getMutex(func);
const cond = emnapiTSFN.getCond(func);
const waitCondition = () => {
const queueSize = emnapiTSFN.getQueueSize(func);
const maxSize = emnapiTSFN.getMaxQueueSize(func);
return queueSize >= maxSize && maxSize > 0 && emnapiTSFN.getState(func) === 0;
};
const isBrowserMain = typeof window !== "undefined" && typeof document !== "undefined" && !emscripten_runtime.ENVIRONMENT_IS_NODE;
let shouldDelete = false;
const ret = mutex.execute(() => {
while (waitCondition()) {
if (mode === 0) return 15;
/**
* 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;
cond.wait();
}
if (emnapiTSFN.getState(func) === 0) {
emnapiTSFN.pushQueue(func, data);
emnapiTSFN.send(func);
return 0;
}
if (emnapiTSFN.getThreadCount(func) === 0) return 1;
emnapiTSFN.subThreadCount(func);
if (!(emnapiTSFN.getState(func) === 2 && emnapiTSFN.getThreadCount(func) === 0)) return 16;
shouldDelete = true;
return 16;
});
if (shouldDelete) emnapiTSFN.destroy(func);
return ret;
},
getMutex(func) {
const index = func + emnapiTSFN.offset.mutex;
const mutex = {
lock() {
const isBrowserMain = typeof window !== "undefined" && typeof document !== "undefined" && !emscripten_runtime.ENVIRONMENT_IS_NODE;
const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1);
if (isBrowserMain) {
while (true) if (Atomics.compareExchange(i32a, 0, 0, 10) === 0) return;
} else while (true) {
if (Atomics.compareExchange(i32a, 0, 0, 10) === 0) return;
Atomics.wait(i32a, 0, 10);
}
},
unlock() {
const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1);
if (Atomics.compareExchange(i32a, 0, 10, 0) !== 10) throw new Error("Tried to unlock while not holding the mutex");
Atomics.notify(i32a, 0, 1);
},
execute(fn) {
mutex.lock();
try {
return fn();
} finally {
mutex.unlock();
}
}
};
return mutex;
},
getCond(func) {
const index = func + emnapiTSFN.offset.cond;
const mutex = emnapiTSFN.getMutex(func);
return {
wait() {
const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1);
const value = Atomics.load(i32a, 0);
mutex.unlock();
Atomics.wait(i32a, 0, value);
mutex.lock();
},
signal() {
const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1);
Atomics.add(i32a, 0, 1);
Atomics.notify(i32a, 0, 1);
}
};
},
getQueueSize(func) {
return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue_size, true);
},
addQueueSize(func) {
const offset = emnapiTSFN.offset.queue_size;
let arr, index;
arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4));
index = func + offset >>> 2;
Atomics.add(arr, index, 1);
},
subQueueSize(func) {
const offset = emnapiTSFN.offset.queue_size;
let arr, index;
arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4));
index = func + offset >>> 2;
Atomics.sub(arr, index, 1);
},
getThreadCount(func) {
return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.thread_count, true);
},
addThreadCount(func) {
const offset = emnapiTSFN.offset.thread_count;
let arr, index;
arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4));
index = func + offset >>> 2;
Atomics.add(arr, index, 1);
},
subThreadCount(func) {
const offset = emnapiTSFN.offset.thread_count;
let arr, index;
arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4));
index = func + offset >>> 2;
Atomics.sub(arr, index, 1);
},
getState(func) {
return Atomics.load(new Int32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.state + 4)), func + emnapiTSFN.offset.state >>> 2);
},
setState(func, value) {
Atomics.store(new Int32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.state + 4)), func + emnapiTSFN.offset.state >>> 2, value);
},
getHandlesClosing(func) {
return Atomics.load(new Int8Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.handles_closing + 1)), func + emnapiTSFN.offset.handles_closing);
},
setHandlesClosing(func, value) {
Atomics.store(new Int8Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.handles_closing + 1)), func + emnapiTSFN.offset.handles_closing, value);
},
getDispatchState(func) {
return Atomics.load(new Uint32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.dispatch_state + 4)), func + emnapiTSFN.offset.dispatch_state >>> 2);
},
getContext(func) {
return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.context, false);
},
getMaxQueueSize(func) {
return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.max_queue_size, true);
},
getEnv(func) {
return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.env, false);
},
getCallJSCb(func) {
return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.call_js_cb, false);
},
getRef(func) {
return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.ref, false);
},
getResource(func) {
return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.resource, false);
},
getFinalizeCb(func) {
return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_cb, false);
},
getFinalizeData(func) {
return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_data, false);
},
loadSizeTypeValue(offset, unsigned) {
let ret;
let arr;
if (unsigned) {
arr = new Uint32Array(emnapiTSFN.ensureBufferFor(offset + 4));
ret = Atomics.load(arr, offset >>> 2);
return ret;
} else {
arr = new Int32Array(emnapiTSFN.ensureBufferFor(offset + 4));
ret = Atomics.load(arr, offset >>> 2);
return ret;
}
},
storeSizeTypeValue(offset, value, unsigned) {
let arr;
if (unsigned) {
arr = new Uint32Array(emnapiTSFN.ensureBufferFor(offset + 4));
Atomics.store(arr, offset >>> 2, value);
return;
} else {
arr = new Int32Array(emnapiTSFN.ensureBufferFor(offset + 4));
Atomics.store(arr, offset >>> 2, value >>> 0);
return;
}
},
releaseResources(func) {
if (emnapiTSFN.getState(func) !== 2) {
emnapiTSFN.getEnv(func);
const envObject = emnapi_shared.emnapiEnv;
const ref = emnapiTSFN.getRef(func);
if (ref) emnapiCtx.getRef(ref).dispose();
const resource = emnapiTSFN.getResource(func);
emnapiCtx.getRef(resource).dispose();
emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.is_some + 1);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
GET_HEAP_DATA_VIEW().setInt8(func + emnapiTSFN.offset.is_some, 0, true);
emnapiCtx.removeCleanupHook(envObject, emnapiTSFN.cleanup, func);
envObject.unref();
const asyncRefAddress = func + emnapiTSFN.offset.async_ref;
const asyncRefOffset = asyncRefAddress >>> 2;
const arr = new Uint32Array(emnapiTSFN.ensureBufferFor(asyncRefAddress + 4));
if (Atomics.load(arr, asyncRefOffset) > 0) {
Atomics.store(arr, asyncRefOffset, 0);
__emnapi_runtime_keepalive_pop();
emnapiCtx.decreaseWaitingRequestCounter();
}
if (emnapiNodeBinding) {
const view = new DataView(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.trigger_async_id + 8));
const asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true);
const triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true);
__emnapi_node_emit_async_destroy(asyncId, triggerAsyncId);
}
}
},
destroy(func) {
emnapiTSFN._liveSet.delete(func);
emnapiTSFN.destroyQueue(func);
emnapiTSFN.releaseResources(func);
emscripten_runtime._free(func);
},
emptyQueue(func) {
const drainQueue = [];
emnapiTSFN.getMutex(func).execute(() => {
while (emnapiTSFN.getQueueSize(func) > 0) drainQueue.push(emnapiTSFN.shiftQueue(func));
});
const callJsCb = emnapiTSFN.getCallJSCb(func);
const context = emnapiTSFN.getContext(func);
let data;
for (let i = 0; i < drainQueue.length; i++) {
data = drainQueue[i];
if (callJsCb) emnapiPluginCtx.wasmTable.get(callJsCb)(0, 0, context, data);
}
},
maybeDelete(func) {
emnapiTSFN.releaseResources(func);
let shouldDelete = false;
emnapiTSFN.getMutex(func).execute(() => {
emnapiTSFN.setState(func, 2);
shouldDelete = emnapiTSFN.getThreadCount(func) === 0;
});
if (shouldDelete) emnapiTSFN.destroy(func);
},
finalize(func) {
emnapiTSFN.getEnv(func);
const envObject = emnapi_shared.emnapiEnv;
emnapiCtx.openScope(envObject);
const finalize = emnapiTSFN.getFinalizeCb(func);
const data = emnapiTSFN.getFinalizeData(func);
const context = emnapiTSFN.getContext(func);
const f = () => {
envObject.callFinalizerInternal(0, finalize, data, context);
};
try {
emnapiTSFN.emptyQueue(func);
if (finalize) {
if (emnapiNodeBinding) {
const resource = emnapiTSFN.getResource(func);
const resource_value = emnapiCtx.getRef(resource).get();
const resourceObject = emnapiCtx.jsValueFromNapiValue(resource_value);
const view = new DataView(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.trigger_async_id + 8));
const asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true);
const triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true);
emnapiNodeBinding.node.makeCallback(resourceObject, f, [], {
asyncId,
triggerAsyncId
});
} else f();
}
emnapiTSFN.maybeDelete(func);
} finally {
emnapiCtx.closeScope(envObject);
}
},
cleanup(func) {
emnapiTSFN.closeHandlesAndMaybeDelete(func, 1);
},
closeHandlesAndMaybeDelete(func, set_closing) {
emnapiTSFN.getEnv(func);
const envObject = emnapi_shared.emnapiEnv;
emnapiCtx.openScope(envObject);
try {
if (set_closing) emnapiTSFN.getMutex(func).execute(() => {
emnapiTSFN.setState(func, 1);
if (emnapiTSFN.getMaxQueueSize(func) > 0) emnapiTSFN.getCond(func).signal();
});
if (emnapiTSFN.getHandlesClosing(func)) return;
emnapiTSFN.setHandlesClosing(func, 1);
Atomics.store(new Int32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.async_pending + 4)), func + emnapiTSFN.offset.async_pending >>> 2, 1);
emnapiCtx.features.setImmediate(() => {
emnapiTSFN.finalize(func);
});
} finally {
emnapiCtx.closeScope(envObject);
}
},
dispatchOne(func) {
let data = 0;
let popped_value = false;
let has_more = false;
const mutex = emnapiTSFN.getMutex(func);
const cond = emnapiTSFN.getCond(func);
mutex.execute(() => {
if (emnapiTSFN.getState(func) === 0) {
let size = emnapiTSFN.getQueueSize(func);
if (size > 0) {
data = emnapiTSFN.shiftQueue(func);
popped_value = true;
const maxQueueSize = emnapiTSFN.getMaxQueueSize(func);
if (size === maxQueueSize && maxQueueSize > 0) cond.signal();
size--;
}
if (size === 0) {
if (emnapiTSFN.getThreadCount(func) === 0) {
emnapiTSFN.setState(func, 1);
if (emnapiTSFN.getMaxQueueSize(func) > 0) cond.signal();
emnapiTSFN.closeHandlesAndMaybeDelete(func, 0);
}
} else has_more = true;
} else emnapiTSFN.closeHandlesAndMaybeDelete(func, 0);
});
if (popped_value) {
const env = emnapiTSFN.getEnv(func);
const envObject = emnapi_shared.emnapiEnv;
emnapiCtx.openScope(envObject);
const f = () => {
envObject.callbackIntoModule(false, () => {
const callJsCb = emnapiTSFN.getCallJSCb(func);
const ref = emnapiTSFN.getRef(func);
const js_callback = ref ? emnapiCtx.getRef(ref).get() : 0;
if (callJsCb) {
const context = emnapiTSFN.getContext(func);
emnapiPluginCtx.wasmTable.get(callJsCb)(env, js_callback, context, data);
} else {
const jsCallback = js_callback ? emnapiCtx.jsValueFromNapiValue(js_callback) : null;
if (typeof jsCallback === "function") jsCallback();
}
});
};
try {
if (emnapiNodeBinding) {
const resource = emnapiTSFN.getResource(func);
const resource_value = emnapiCtx.getRef(resource).get();
const resourceObject = emnapiCtx.jsValueFromNapiValue(resource_value);
const view = new DataView(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.trigger_async_id + 8));
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);
}
}
return has_more;
},
dispatch(func) {
let has_more = true;
let iterations_left = 1e3;
const dispatchStateAddress = func + emnapiTSFN.offset.dispatch_state;
const index = dispatchStateAddress >>> 2;
while (has_more && --iterations_left !== 0) {
Atomics.store(new Uint32Array(emnapiTSFN.ensureBufferFor(dispatchStateAddress + 4)), index, 1);
try {
has_more = emnapiTSFN.dispatchOne(func);
} catch (err) {
if (emnapiTSFN._liveSet.has(func)) {
Atomics.exchange(new Uint32Array(emnapiTSFN.ensureBufferFor(dispatchStateAddress + 4)), index, 0);
emnapiTSFN.send(func);
}
throw err;
}
if (Atomics.exchange(new Uint32Array(emnapiTSFN.ensureBufferFor(dispatchStateAddress + 4)), index, 0) !== 1) has_more = true;
}
if (has_more) emnapiTSFN.send(func);
},
enqueue(func) {
const pending = func + emnapiTSFN.offset.async_pending;
const scheduled = func + emnapiTSFN.offset.async_u_fd;
const end = Math.max(pending, scheduled) + 4;
const state = () => new Int32Array(emnapiTSFN.ensureBufferFor(end));
if (Atomics.exchange(state(), scheduled >>> 2, 1) !== 0) return;
emnapiCtx.features.setImmediate(() => {
if (!emnapiTSFN._liveSet.has(func)) return;
if (Atomics.load(state(), pending >>> 2) === 0) {
Atomics.store(state(), scheduled >>> 2, 0);
return;
}
emnapiCtx.features.setImmediate(() => {
if (!emnapiTSFN._liveSet.has(func)) return;
try {
if (Atomics.exchange(state(), pending >>> 2, 0) === 0) return;
emnapiTSFN.dispatch(func);
} finally {
if (emnapiTSFN._liveSet.has(func)) {
Atomics.store(state(), scheduled >>> 2, 0);
if (Atomics.load(state(), pending >>> 2) !== 0) emnapiTSFN.enqueue(func);
}
}
});
});
},
send(func) {
const dispatchStateAddress = func + emnapiTSFN.offset.dispatch_state;
if ((Atomics.or(new Uint32Array(emnapiTSFN.ensureBufferFor(dispatchStateAddress + 4)), dispatchStateAddress >>> 2, 2) & 1) === 1) return;
const pendng = func + emnapiTSFN.offset.async_pending;
if (Atomics.load(new Int32Array(emnapiTSFN.ensureBufferFor(pendng + 4)), pendng >>> 2) !== 0) return;
if (Atomics.exchange(new Int32Array(emnapiTSFN.ensureBufferFor(pendng + 4)), pendng >>> 2, 1) === 0) {
if (typeof emscripten_runtime.ENVIRONMENT_IS_PTHREAD !== "undefined" && emscripten_runtime.ENVIRONMENT_IS_PTHREAD) postMessage({ __emnapi__: {
type: "tsfn-send",
payload: { tsfn: func }
} });
else emnapiTSFN.enqueue(func);
}
}
};
emnapiTSFN.init();
emnapiPluginCtx.emnapiTSFN = emnapiTSFN;
/**
* @__deps _emnapi_node_emit_async_init
* @__deps _emnapi_runtime_keepalive_push
* @__sig ippppppppppp
*/
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) return 1;
const envObject = emnapi_shared.emnapiEnv;
envObject.checkGCAccess();
if (!async_resource_name) return envObject.setLastError(1);
max_queue_size >>>= 0;
initial_thread_count >>>= 0;
env >>>= 0;
thread_finalize_data >>>= 0;
thread_finalize_cb >>>= 0;
context >>>= 0;
call_js_cb >>>= 0;
max_queue_size = max_queue_size >>> 0;
initial_thread_count = initial_thread_count >>> 0;
if (initial_thread_count === 0) return envObject.setLastError(1);
if (!result) return envObject.setLastError(1);
let ref = 0;
func >>>= 0;
if (!func) {
if (!call_js_cb) return envObject.setLastError(1);
} else {
if (typeof emnapiCtx.jsValueFromNapiValue(func) !== "function") return envObject.setLastError(1);
ref = emnapiCtx.createReference(envObject, func, 1, 1).id;
}
let asyncResourceObject;
if (async_resource) {
asyncResourceObject = emnapiCtx.jsValueFromNapiValue(async_resource);
if (asyncResourceObject == null) return envObject.setLastError(2);
asyncResourceObject = Object(asyncResourceObject);
} else asyncResourceObject = {};
const resource = emnapiCtx.napiValueFromJsValue(asyncResourceObject);
let asyncResourceName = emnapiCtx.jsValueFromNapiValue(async_resource_name);
if (typeof asyncResourceName === "symbol") return envObject.setLastError(3);
asyncResourceName = String(asyncResourceName);
const resource_name = emnapiCtx.napiValueFromJsValue(asyncResourceName);
const sizeofTSFN = emnapiTSFN.offset.__size__;
let tsfn = emscripten_runtime._malloc(sizeofTSFN);
if (!tsfn) return envObject.setLastError(9);
tsfn >>>= 0;
new Uint8Array(emnapiTSFN.ensureBufferFor(tsfn + sizeofTSFN)).subarray(tsfn, tsfn + sizeofTSFN).fill(0);
const resourceRef = emnapiCtx.createReference(envObject, resource, 1, 1);
const resource_ = resourceRef.id;
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.resource, resource_, true);
if (!emnapiTSFN.initQueue(tsfn)) {
emscripten_runtime._free(tsfn);
resourceRef.dispose();
return envObject.setLastError(9);
}
__emnapi_node_emit_async_init(resource, resource_name, -1, tsfn + emnapiTSFN.offset.async_id);
GET_HEAP_DATA_VIEW().setInt8(tsfn + emnapiTSFN.offset.is_some, 1, true);
GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.thread_count, initial_thread_count, true);
GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.context, context, true);
GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.max_queue_size, max_queue_size, true);
GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.ref, ref, true);
GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.env, env, true);
GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.finalize_data, thread_finalize_data, true);
GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.finalize_cb, thread_finalize_cb, true);
GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.call_js_cb, call_js_cb, true);
emnapiCtx.addCleanupHook(envObject, emnapiTSFN.cleanup, tsfn);
emnapiTSFN._liveSet.add(tsfn);
envObject.ref();
__emnapi_runtime_keepalive_push();
emnapiCtx.increaseWaitingRequestCounter();
GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.async_ref, 1, true);
result >>>= 0;
GET_HEAP_DATA_VIEW().setUint32(result, tsfn, true);
return envObject.clearLastError();
}
/** @__sig ipp */
function napi_get_threadsafe_function_context(func, result) {
if (!func || !result) {
emscripten_runtime.abort();
return 1;
}
func >>>= 0;
result >>>= 0;
const context = emnapiTSFN.getContext(func);
var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer);
GET_HEAP_DATA_VIEW().setUint32(result, context, true);
return 0;
}
/** @__sig ippi */
function napi_call_threadsafe_function(func, data, mode) {
if (!func) {
emscripten_runtime.abort();
return 1;
}
func >>>= 0;
data >>>= 0;
return emnapiTSFN.push(func, data, mode);
}
/** @__sig ip */
function napi_acquire_threadsafe_function(func) {
if (!func) {
emscripten_runtime.abort();
return 1;
}
func >>>= 0;
return emnapiTSFN.getMutex(func).execute(() => {
if (emnapiTSFN.getState(func) === 0) {
emnapiTSFN.addThreadCount(func);
return 0;
}
return 16;
});
}
/** @__sig ipi */
function napi_release_threadsafe_function(func, mode) {
if (!func) {
emscripten_runtime.abort();
return 1;
}
func >>>= 0;
const mutex = emnapiTSFN.getMutex(func);
const cond = emnapiTSFN.getCond(func);
let shouldDelete = false;
const ret = mutex.execute(() => {
if (emnapiTSFN.getThreadCount(func) === 0) return 1;
emnapiTSFN.subThreadCount(func);
if (emnapiTSFN.getThreadCount(func) === 0 || mode === 1) {
if (emnapiTSFN.getState(func) === 0) {
if (mode === 1) emnapiTSFN.setState(func, 1);
if (emnapiTSFN.getState(func) === 1 && emnapiTSFN.getMaxQueueSize(func) > 0) cond.signal();
emnapiTSFN.send(func);
}
}
if (!(emnapiTSFN.getState(func) === 2 && emnapiTSFN.getThreadCount(func) === 0)) return 0;
shouldDelete = true;
return 0;
});
if (shouldDelete) emnapiTSFN.destroy(func);
return ret;
}
/**
* @__deps _emnapi_runtime_keepalive_pop
* @__sig ipp
*/
function napi_unref_threadsafe_function(env, func) {
if (!func) {
emscripten_runtime.abort();
return 1;
}
func >>>= 0;
const asyncRefAddress = func + emnapiTSFN.offset.async_ref;
const asyncRefOffset = asyncRefAddress >>> 2;
const arr = new Uint32Array(emnapiTSFN.ensureBufferFor(asyncRefAddress + 4));
const currentValue = Atomics.load(arr, asyncRefOffset);
if (currentValue > 0) {
Atomics.store(arr, asyncRefOffset, currentValue - 1);
if (currentValue === 1) {
__emnapi_runtime_keepalive_pop();
emnapiCtx.decreaseWaitingRequestCounter();
}
}
return 0;
}
/**
* @__deps _emnapi_runtime_keepalive_push
* @__sig ipp
*/
function napi_ref_threadsafe_function(env, func) {
if (!func) {
emscripten_runtime.abort();
return 1;
}
func >>>= 0;
const asyncRefAddress = func + emnapiTSFN.offset.async_ref;
const asyncRefOffset = asyncRefAddress >>> 2;
const arr = new Uint32Array(emnapiTSFN.ensureBufferFor(asyncRefAddress + 4));
const currentValue = Atomics.load(arr, asyncRefOffset);
if (!currentValue) {
__emnapi_runtime_keepalive_push();
emnapiCtx.increaseWaitingRequestCounter();
}
Atomics.store(arr, asyncRefOffset, currentValue + 1);
return 0;
}
exports.napi_acquire_threadsafe_function = napi_acquire_threadsafe_function;
exports.napi_call_threadsafe_function = napi_call_threadsafe_function;
exports.napi_create_threadsafe_function = napi_create_threadsafe_function;
exports.napi_get_threadsafe_function_context = napi_get_threadsafe_function_context;
exports.napi_ref_threadsafe_function = napi_ref_threadsafe_function;
exports.napi_release_threadsafe_function = napi_release_threadsafe_function;
exports.napi_unref_threadsafe_function = napi_unref_threadsafe_function;
return exports;
})({}, emnapiPluginCtx, emnapiPluginCtx);
return { importObject: (original) => {
Object.assign(original.napi, mod);
} };
}
// emnapi-plugins.js
const withAddonModuleAlias = (plugin) => {
const compatPlugin = (ctx) => {
if (ctx !== null && typeof ctx === "object" && !("addonModule" in ctx) && "napiModule" in ctx) Object.defineProperty(ctx, "addonModule", {
get: () => ctx.napiModule,
enumerable: false,
configurable: true
});
return plugin(ctx);
};
Object.defineProperty(compatPlugin, "name", { value: plugin.name });
return compatPlugin;
};
const emnapiAsyncWorkPlugin = withAddonModuleAlias(asyncWork);
const emnapiTSFNPlugin = withAddonModuleAlias(threadsafeFunction);
exports.emnapiAsyncWorkPlugin = emnapiAsyncWorkPlugin;
exports.emnapiTSFNPlugin = emnapiTSFNPlugin;
Reference in a new issue Copy permalink