emnapi
Version:
Node-API implementation for Emscripten
1,348 lines • 300 kB
JavaScript
{{{ ((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 no-unreachable */
/* eslint-disable no-new-func */
/* eslint-disable @typescript-eslint/no-implied-eval */
var emnapiCtx = undefined;
var emnapiNodeBinding = undefined;
var emnapiAsyncWorkPoolSize = 0;
var emnapiModule = {
exports: {},
loaded: false,
filename: ''
};
/**
* @__deps napi_register_wasm_v1
* @__deps node_api_module_get_api_version_v1
*/
function emnapiInit(options) {
if (emnapiModule.loaded)
return emnapiModule.exports;
if (typeof options !== 'object' || options === null) {
throw new TypeError('Invalid emnapi init option');
}
var context = options.context;
if (typeof context !== 'object' || context === null) {
throw new TypeError("Invalid `options.context`. Use `import { getDefaultContext } from '@emnapi/runtime'`");
}
emnapiCtx = context;
var filename = typeof options.filename === 'string' ? options.filename : '';
emnapiModule.filename = filename;
if ('nodeBinding' in options) {
var nodeBinding = options.nodeBinding;
if (typeof nodeBinding !== 'object' || nodeBinding === null) {
throw new TypeError('Invalid `options.nodeBinding`. Use @emnapi/node-binding package');
}
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;
}
}
var moduleApiVersion = _node_api_module_get_api_version_v1();
// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
var envObject = emnapiModule.envObject || (emnapiModule.envObject = emnapiCtx.createEnv(filename, moduleApiVersion, function (cb) { return {{{ makeDynCall('vppp', 'cb') }}}; }, function (cb) { return {{{ makeDynCall('vp', 'cb') }}}; }, abort, emnapiNodeBinding));
var scope = emnapiCtx.openScope(envObject);
try {
envObject.callIntoModule(function (_envObject) {
var exports = emnapiModule.exports;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var exportsHandle = scope.add(exports);
var napiValue = _napi_register_wasm_v1({{{ to64('_envObject.id') }}}, {{{ to64('exportsHandle.id') }}});
emnapiModule.exports = (!napiValue) ? exports : emnapiCtx.handleStore.get(napiValue).value;
});
}
catch (err) {
emnapiCtx.closeScope(envObject, scope);
throw err;
}
emnapiCtx.closeScope(envObject, scope);
emnapiModule.loaded = true;
delete emnapiModule.envObject;
return emnapiModule.exports;
}
/**
* @__sig i
*/
function __emnapi_async_work_pool_size() {
return Math.abs(emnapiAsyncWorkPoolSize);
}
/* eslint-disable @typescript-eslint/indent */
/**
* @__sig ipiip
*/
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);
}
/**
* @__sig ip
*/
function _napi_clear_last_error(env) {
var envObject = emnapiCtx.envStore.get(env);
return envObject.clearLastError();
}
/**
* @__sig vppp
*/
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') }}};
{{{ makeSetValue('patch', 0, 'versions[2]', 'u32') }}};
}
/**
* @__sig v
* @__deps $runtimeKeepalivePush
*/
function __emnapi_runtime_keepalive_push() {
if (typeof runtimeKeepalivePush === 'function')
runtimeKeepalivePush();
}
/**
* @__sig v
* @__deps $runtimeKeepalivePop
*/
function __emnapi_runtime_keepalive_pop() {
if (typeof runtimeKeepalivePop === 'function')
runtimeKeepalivePop();
}
/**
* @__sig vpp
*/
function __emnapi_set_immediate(callback, data) {
emnapiCtx.feature.setImmediate(function () {
{{{ makeDynCall('vp', 'callback') }}}(data);
});
}
/**
* @__sig vpp
*/
function __emnapi_next_tick(callback, data) {
// eslint-disable-next-line @typescript-eslint/no-floating-promises
Promise.resolve().then(function () {
{{{ makeDynCall('vp', 'callback') }}}(data);
});
}
/**
* @__sig vipppi
*/
function __emnapi_callback_into_module(forceUncaught, env, callback, data, close_scope_if_throw) {
var envObject = emnapiCtx.envStore.get(env);
var scope = emnapiCtx.openScope(envObject);
try {
envObject.callbackIntoModule(Boolean(forceUncaught), 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);
}
/**
* @__sig vipppp
*/
function __emnapi_call_finalizer(forceUncaught, env, callback, data, hint) {
var envObject = emnapiCtx.envStore.get(env);
{{{ from64('callback') }}};
envObject.callFinalizerInternal(forceUncaught, callback, data, hint);
}
/**
* @__sig v
*/
function __emnapi_ctx_increase_waiting_request_counter() {
emnapiCtx.increaseWaitingRequestCounter();
}
/**
* @__sig v
*/
function __emnapi_ctx_decrease_waiting_request_counter() {
emnapiCtx.decreaseWaitingRequestCounter();
}
function emnapiSetValueI64(result, numberValue) {
var tempDouble;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var tempI64 = [
numberValue >>> 0,
(tempDouble = numberValue, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)
];
{{{ makeSetValue('result', 0, 'tempI64[0]', 'i32') }}};
{{{ makeSetValue('result', 4, 'tempI64[1]', 'i32') }}};
}
/* eslint-disable eqeqeq */
/* eslint-disable @typescript-eslint/no-unused-vars */
/* eslint-disable @typescript-eslint/indent */
/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
/* eslint-disable @typescript-eslint/explicit-function-return-type */
/**
* @__deps emscripten_resize_heap
* @__sig ipjp
*/
function _napi_adjust_external_memory(env, low, high, adjusted_value) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
var envObject = emnapiCtx.envStore.get(env);
var change_in_bytes;
#if WASM_BIGINT
if (!high)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
change_in_bytes = Number(low);
#else
if (!adjusted_value)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
change_in_bytes = (low >>> 0) + (high * Math.pow(2, 32));
#endif
if (change_in_bytes < 0) {
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
}
if (change_in_bytes > 0) {
var old_size = wasmMemory.buffer.byteLength;
var new_size = old_size + change_in_bytes;
if (!_emscripten_resize_heap(new_size)) {
return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
}
}
#if WASM_BIGINT
{{{ from64('high') }}};
if (emnapiCtx.feature.supportBigInt) {
{{{ makeSetValue('high', 0, 'wasmMemory.buffer.byteLength', 'i64') }}};
}
else {
emnapiSetValueI64(high, wasmMemory.buffer.byteLength);
}
#else
{{{ from64('adjusted_value') }}};
{{{ makeSetValue('adjusted_value', 0, 'wasmMemory.buffer.byteLength', 'i64') }}};
#endif
return envObject.clearLastError();
}
/**
* @__deps $PThread
* @__sig vp
*/
function __emnapi_worker_unref(pid) {
var worker = PThread.pthreads[pid];
worker = worker.worker || worker;
if (typeof worker.unref === 'function') {
worker.unref();
}
}
/**
* if EMNAPI_USE_PROXYING=1 (default is 1 if emscripten version >= 3.1.9),
* the following helpers won't be linked into runtime code
*
* @__deps $PThread
* @__postset
* ```
* PThread.unusedWorkers.forEach(emnapiAddSendListener);
* PThread.runningWorkers.forEach(emnapiAddSendListener);
* (function () {
* var __original_getNewWorker = PThread.getNewWorker;
* PThread.getNewWorker = function () {
* var r = __original_getNewWorker.apply(this, arguments);
* emnapiAddSendListener(r);
* return r;
* };
* })();
* ```
*/
function emnapiAddSendListener(worker) {
if (!worker)
return false;
if (worker._emnapiSendListener)
return true;
var handler = function (e) {
var data = ENVIRONMENT_IS_NODE ? e : e.data;
var __emnapi__ = data.__emnapi__;
if (__emnapi__ && __emnapi__.type === 'async-send') {
if (ENVIRONMENT_IS_PTHREAD) {
postMessage({ __emnapi__: __emnapi__ });
}
else {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var callback = __emnapi__.payload.callback;
{{{ makeDynCall('vp', 'callback') }}}(__emnapi__.payload.data);
}
}
};
var dispose = function () {
if (ENVIRONMENT_IS_NODE) {
worker.off('message', handler);
}
else {
worker.removeEventListener('message', handler, false);
}
delete worker._emnapiSendListener;
};
worker._emnapiSendListener = { handler: handler, dispose: dispose };
if (ENVIRONMENT_IS_NODE) {
worker.on('message', handler);
}
else {
worker.addEventListener('message', handler, false);
}
return true;
}
/**
* @__sig vipp
*/
function __emnapi_async_send_js(type, callback, data) {
if (ENVIRONMENT_IS_PTHREAD) {
postMessage({
__emnapi__: {
type: 'async-send',
payload: {
callback: callback,
data: data
}
}
});
}
else {
switch (type) {
case 0:
__emnapi_set_immediate(callback, data);
break;
case 1:
__emnapi_next_tick(callback, data);
break;
default: break;
}
}
}
/**
* @__postset
* ```
* emnapiAWST.init();
* ```
*/
var emnapiAWST = {
idGen: {},
values: [undefined],
queued: new Set(),
pending: [],
init: function () {
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;
var triggerAsyncId = 0;
if (emnapiNodeBinding) {
var asyncContext = emnapiNodeBinding.node.emitAsyncInit(resource, resourceName, -1);
asyncId = asyncContext.asyncId;
triggerAsyncId = asyncContext.triggerAsyncId;
}
var id = emnapiAWST.idGen.generate();
emnapiAWST.values[id] = {
env: env,
id: id,
resource: resource,
asyncId: asyncId,
triggerAsyncId: triggerAsyncId,
status: 0,
execute: execute,
complete: complete,
data: data
};
return id;
},
callComplete: function (work, status) {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var complete = work.complete;
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 {
envObject.callbackIntoModule(true, function () {
{{{ makeDynCall('vpip', '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) {
var work = emnapiAWST.values[id];
if (!work)
return;
if (work.status === 0) {
work.status = 1;
if (emnapiAWST.queued.size >= (Math.abs(emnapiAsyncWorkPoolSize) || 4)) {
emnapiAWST.pending.push(id);
return;
}
emnapiAWST.queued.add(id);
var env_1 = work.env;
var data_1 = work.data;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var execute = work.execute;
work.status = 2;
emnapiCtx.feature.setImmediate(function () {
{{{ makeDynCall('vpp', 'execute') }}}(env_1, data_1);
emnapiAWST.queued.delete(id);
work.status = 3;
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 = emnapiAWST.pending.indexOf(id);
if (index !== -1) {
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 {
return 9 /* napi_status.napi_generic_failure */;
}
}
return 9 /* napi_status.napi_generic_failure */;
},
remove: function (id) {
var work = emnapiAWST.values[id];
if (!work)
return;
if (emnapiNodeBinding) {
emnapiNodeBinding.node.emitAsyncDestroy({
asyncId: work.asyncId,
triggerAsyncId: work.triggerAsyncId
});
}
emnapiAWST.values[id] = undefined;
emnapiAWST.idGen.reuse(id);
}
};
/**
* @__sig ippppppp
*/
function _napi_create_async_work(env, resource, resource_name, execute, complete, data, result) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!execute)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
if (!result)
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)
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();
}
/**
* @__sig ipp
*/
function _napi_delete_async_work(env, work) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!work)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
emnapiAWST.remove(work);
return envObject.clearLastError();
}
/**
* @__sig ipp
*/
function _napi_queue_async_work(env, work) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
var envObject = emnapiCtx.envStore.get(env);
if (!work)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
emnapiAWST.queue(work);
return envObject.clearLastError();
}
/**
* @__sig ipp
*/
function _napi_cancel_async_work(env, work) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
var envObject = emnapiCtx.envStore.get(env);
if (!work)
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);
}
/* eslint-disable @typescript-eslint/indent */
/**
* @__postset
* ```
* emnapiString.init();
* ```
*/
var emnapiString = {
utf8Decoder: undefined,
utf16Decoder: undefined,
init: function () {
#if !TEXTDECODER || TEXTDECODER == 1
var fallbackDecoder = {
decode: function (bytes) {
var inputIndex = 0;
var pendingSize = Math.min(0x1000, bytes.length + 1);
var pending = new Uint16Array(pendingSize);
var chunks = [];
var pendingIndex = 0;
for (;;) {
var more = inputIndex < bytes.length;
if (!more || (pendingIndex >= pendingSize - 1)) {
var subarray = pending.subarray(0, pendingIndex);
var arraylike = subarray;
chunks.push(String.fromCharCode.apply(null, arraylike));
if (!more) {
return chunks.join('');
}
bytes = bytes.subarray(inputIndex);
inputIndex = 0;
pendingIndex = 0;
}
var byte1 = bytes[inputIndex++];
if ((byte1 & 0x80) === 0) {
pending[pendingIndex++] = byte1;
}
else if ((byte1 & 0xe0) === 0xc0) {
var byte2 = bytes[inputIndex++] & 0x3f;
pending[pendingIndex++] = ((byte1 & 0x1f) << 6) | byte2;
}
else if ((byte1 & 0xf0) === 0xe0) {
var byte2 = bytes[inputIndex++] & 0x3f;
var byte3 = bytes[inputIndex++] & 0x3f;
pending[pendingIndex++] = ((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3;
}
else if ((byte1 & 0xf8) === 0xf0) {
var byte2 = bytes[inputIndex++] & 0x3f;
var byte3 = bytes[inputIndex++] & 0x3f;
var byte4 = bytes[inputIndex++] & 0x3f;
var codepoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
if (codepoint > 0xffff) {
codepoint -= 0x10000;
pending[pendingIndex++] = (codepoint >>> 10) & 0x3ff | 0xd800;
codepoint = 0xdc00 | codepoint & 0x3ff;
}
pending[pendingIndex++] = codepoint;
}
else {
// invalid
}
}
}
};
#endif
var utf8Decoder;
#if !TEXTDECODER
utf8Decoder = fallbackDecoder;
#elif TEXTDECODER == 1
utf8Decoder = typeof TextDecoder === 'function' ? new TextDecoder() : fallbackDecoder;
#elif TEXTDECODER == 2
utf8Decoder = new TextDecoder();
#endif
emnapiString.utf8Decoder = utf8Decoder;
#if !TEXTDECODER || TEXTDECODER == 1
var fallbackDecoder2 = {
decode: function (input) {
var bytes = new Uint16Array(input.buffer, input.byteOffset, input.byteLength / 2);
if (bytes.length <= 0x1000) {
return String.fromCharCode.apply(null, bytes);
}
var chunks = [];
var i = 0;
var len = 0;
for (; i < bytes.length; i += len) {
len = Math.min(0x1000, bytes.length - i);
chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, i + len)));
}
return chunks.join('');
}
};
#endif
var utf16Decoder;
#if !TEXTDECODER
utf16Decoder = fallbackDecoder2;
#elif TEXTDECODER == 1
utf16Decoder = typeof TextDecoder === 'function' ? new TextDecoder('utf-16le') : fallbackDecoder2;
#elif TEXTDECODER == 2
utf16Decoder = new TextDecoder('utf-16le');
#endif
emnapiString.utf16Decoder = utf16Decoder;
},
lengthBytesUTF8: function (str) {
var c;
var len = 0;
for (var i = 0; i < str.length; ++i) {
c = str.charCodeAt(i);
if (c <= 0x7F) {
len++;
}
else if (c <= 0x7FF) {
len += 2;
}
else if (c >= 0xD800 && c <= 0xDFFF) {
len += 4;
++i;
}
else {
len += 3;
}
}
return len;
},
UTF8ToString: function (ptr, length) {
if (!ptr || !length)
return '';
ptr >>>= 0;
var HEAPU8 = new Uint8Array(wasmMemory.buffer);
var end = ptr;
if (length === -1) {
for (; HEAPU8[end];)
++end;
}
else {
end = ptr + (length >>> 0);
}
#if TEXTDECODER != 2
length = end - ptr;
if (length <= 16) {
var idx = ptr;
var str = '';
while (idx < end) {
var u0 = HEAPU8[idx++];
if (!(u0 & 0x80)) {
str += String.fromCharCode(u0);
continue;
}
var u1 = HEAPU8[idx++] & 63;
if ((u0 & 0xE0) === 0xC0) {
str += String.fromCharCode(((u0 & 31) << 6) | u1);
continue;
}
var u2 = HEAPU8[idx++] & 63;
if ((u0 & 0xF0) === 0xE0) {
u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
}
else {
u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (HEAPU8[idx++] & 63);
}
if (u0 < 0x10000) {
str += String.fromCharCode(u0);
}
else {
var ch = u0 - 0x10000;
str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
}
}
return str;
}
#endif
return emnapiString.utf8Decoder.decode({{{ getUnsharedTextDecoderView('HEAPU8', 'ptr', 'end') }}});
},
stringToUTF8: function (str, outPtr, maxBytesToWrite) {
var HEAPU8 = new Uint8Array(wasmMemory.buffer);
var outIdx = outPtr;
outIdx >>>= 0;
if (!(maxBytesToWrite > 0)) {
return 0;
}
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 0xD800 && u <= 0xDFFF) {
var u1 = str.charCodeAt(++i);
u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
}
if (u <= 0x7F) {
if (outIdx >= endIdx)
break;
HEAPU8[outIdx++] = u;
}
else if (u <= 0x7FF) {
if (outIdx + 1 >= endIdx)
break;
HEAPU8[outIdx++] = 0xC0 | (u >> 6);
HEAPU8[outIdx++] = 0x80 | (u & 63);
}
else if (u <= 0xFFFF) {
if (outIdx + 2 >= endIdx)
break;
HEAPU8[outIdx++] = 0xE0 | (u >> 12);
HEAPU8[outIdx++] = 0x80 | ((u >> 6) & 63);
HEAPU8[outIdx++] = 0x80 | (u & 63);
}
else {
if (outIdx + 3 >= endIdx)
break;
HEAPU8[outIdx++] = 0xF0 | (u >> 18);
HEAPU8[outIdx++] = 0x80 | ((u >> 12) & 63);
HEAPU8[outIdx++] = 0x80 | ((u >> 6) & 63);
HEAPU8[outIdx++] = 0x80 | (u & 63);
}
}
HEAPU8[outIdx] = 0;
return outIdx - startIdx;
},
UTF16ToString: function (ptr, length) {
if (!ptr || !length)
return '';
ptr >>>= 0;
var end = ptr;
if (length === -1) {
var idx = end >> 1;
var HEAPU16 = new Uint16Array(wasmMemory.buffer);
while (HEAPU16[idx])
++idx;
end = idx << 1;
}
else {
end = ptr + (length >>> 0) * 2;
}
#if TEXTDECODER != 2
length = end - ptr;
if (length <= 32) {
return String.fromCharCode.apply(null, new Uint16Array(wasmMemory.buffer, ptr, length / 2));
}
#endif
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var HEAPU8 = new Uint8Array(wasmMemory.buffer);
return emnapiString.utf16Decoder.decode({{{ getUnsharedTextDecoderView('HEAPU8', 'ptr', 'end') }}});
},
stringToUTF16: function (str, outPtr, maxBytesToWrite) {
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 0x7FFFFFFF;
}
if (maxBytesToWrite < 2)
return 0;
maxBytesToWrite -= 2;
var startPtr = outPtr;
var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length;
for (var i = 0; i < numCharsToWrite; ++i) {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var codeUnit = str.charCodeAt(i);
{{{ makeSetValue('outPtr', 0, 'codeUnit', 'i16') }}};
outPtr += 2;
}
{{{ makeSetValue('outPtr', 0, '0', 'i16') }}};
return outPtr - startPtr;
},
newString: function (env, str, length, result, stringMaker) {
{{{ from64('length') }}};
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
var autoLength = length === -1;
var sizelength = length >>> 0;
if (length !== 0) {
if (!str)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
}
if (!result)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
if (!(autoLength || (sizelength <= 2147483647)))
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
{{{ from64('str') }}};
var strValue = stringMaker(str, autoLength, sizelength);
{{{ from64('result') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var value = emnapiCtx.addToCurrentScope(strValue).id;
{{{ makeSetValue('result', 0, 'value', '*') }}};
return envObject.clearLastError();
},
newExternalString: function (env, str, length, finalize_callback, finalize_hint, result, copied, createApi, stringMaker) {
{{{ from64('length') }}};
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
var autoLength = length === -1;
var sizelength = length >>> 0;
if (length !== 0) {
if (!str)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
}
if (!result)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
if (!(autoLength || (sizelength <= 2147483647)))
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
var status = createApi(env, str, length, result);
if (status === 0 /* napi_status.napi_ok */) {
if (copied) {
{{{ makeSetValue('copied', 0, '1', 'i8') }}};
}
if (finalize_callback) {
envObject.callFinalizer(finalize_callback, str, finalize_hint);
}
}
return status;
}
};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
/**
* @__sig ipp
*/
function _emnapi_get_module_object(env, result) {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var value;
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!envObject.tryCatch.isEmpty())
return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
if (!envObject.canCallIntoJs())
return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);
envObject.clearLastError();
try {
if (!result)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
{{{ from64('result') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
value = envObject.ensureHandleId(Module);
{{{ makeSetValue('result', 0, 'value', '*') }}};
return envObject.getReturnStatus();
}
catch (err) {
envObject.tryCatch.setError(err);
return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
}
}
/**
* @__sig ippp
*/
function _emnapi_get_module_property(env, utf8name, result) {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var value;
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!envObject.tryCatch.isEmpty())
return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
if (!envObject.canCallIntoJs())
return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);
envObject.clearLastError();
try {
if (!utf8name)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
if (!result)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
{{{ from64('utf8name') }}};
{{{ from64('result') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
value = envObject.ensureHandleId(Module[emnapiString.UTF8ToString(utf8name, -1)]);
{{{ makeSetValue('result', 0, 'value', '*') }}};
return envObject.getReturnStatus();
}
catch (err) {
envObject.tryCatch.setError(err);
return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
}
}
/**
* @__deps malloc
* @__deps free
* @__postset
* ```
* emnapiExternalMemory.init();
* ```
*/
var emnapiExternalMemory = {
registry: typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(function (_pointer) { _free({{{ to64('_pointer') }}}); }) : undefined,
table: new WeakMap(),
wasmMemoryViewTable: new WeakMap(),
init: function () {
emnapiExternalMemory.registry = typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(function (_pointer) { _free({{{ to64('_pointer') }}}); }) : undefined;
emnapiExternalMemory.table = new WeakMap();
emnapiExternalMemory.wasmMemoryViewTable = new WeakMap();
},
isDetachedArrayBuffer: function (arrayBuffer) {
if (arrayBuffer.byteLength === 0) {
try {
// eslint-disable-next-line no-new
new Uint8Array(arrayBuffer);
}
catch (_) {
return true;
}
}
return false;
},
getArrayBufferPointer: function (arrayBuffer, shouldCopy) {
var _a;
var info = {
address: 0,
ownership: 0 /* ReferenceOwnership.kRuntime */,
runtimeAllocated: 0
};
if (arrayBuffer === wasmMemory.buffer) {
return info;
}
var isDetached = emnapiExternalMemory.isDetachedArrayBuffer(arrayBuffer);
if (emnapiExternalMemory.table.has(arrayBuffer)) {
var cachedInfo = emnapiExternalMemory.table.get(arrayBuffer);
if (isDetached) {
cachedInfo.address = 0;
return cachedInfo;
}
if (shouldCopy && cachedInfo.ownership === 0 /* ReferenceOwnership.kRuntime */ && cachedInfo.runtimeAllocated === 1) {
new Uint8Array(wasmMemory.buffer).set(new Uint8Array(arrayBuffer), cachedInfo.address);
}
return cachedInfo;
}
if (isDetached || (arrayBuffer.byteLength === 0)) {
return info;
}
if (!shouldCopy) {
return info;
}
var pointer = _malloc({{{ to64('arrayBuffer.byteLength') }}});
if (!pointer)
throw new Error('Out of memory');
new Uint8Array(wasmMemory.buffer).set(new Uint8Array(arrayBuffer), pointer);
info.address = pointer;
info.ownership = emnapiExternalMemory.registry ? 0 /* ReferenceOwnership.kRuntime */ : 1 /* ReferenceOwnership.kUserland */;
info.runtimeAllocated = 1;
emnapiExternalMemory.table.set(arrayBuffer, info);
(_a = emnapiExternalMemory.registry) === null || _a === void 0 ? void 0 : _a.register(arrayBuffer, pointer);
return info;
},
getOrUpdateMemoryView: function (view) {
if (view.buffer === wasmMemory.buffer) {
if (!emnapiExternalMemory.wasmMemoryViewTable.has(view)) {
emnapiExternalMemory.wasmMemoryViewTable.set(view, {
Ctor: view.constructor,
address: view.byteOffset,
length: view instanceof DataView ? view.byteLength : view.length,
ownership: 1 /* ReferenceOwnership.kUserland */,
runtimeAllocated: 0
});
}
return view;
}
var maybeOldWasmMemory = emnapiExternalMemory.isDetachedArrayBuffer(view.buffer) ||
((typeof SharedArrayBuffer === 'function') && (view.buffer instanceof SharedArrayBuffer));
if (maybeOldWasmMemory && emnapiExternalMemory.wasmMemoryViewTable.has(view)) {
var info = emnapiExternalMemory.wasmMemoryViewTable.get(view);
var Ctor = info.Ctor;
var newView = void 0;
var Buffer = emnapiCtx.feature.Buffer;
if (typeof Buffer === 'function' && Ctor === Buffer) {
newView = Buffer.from(wasmMemory.buffer, info.address, info.length);
}
else {
newView = new Ctor(wasmMemory.buffer, info.address, info.length);
}
emnapiExternalMemory.wasmMemoryViewTable.set(newView, info);
return newView;
}
return view;
},
getViewPointer: function (view, shouldCopy) {
view = emnapiExternalMemory.getOrUpdateMemoryView(view);
if (view.buffer === wasmMemory.buffer) {
if (emnapiExternalMemory.wasmMemoryViewTable.has(view)) {
var _a = emnapiExternalMemory.wasmMemoryViewTable.get(view), address_1 = _a.address, ownership_1 = _a.ownership, runtimeAllocated_1 = _a.runtimeAllocated;
return { address: address_1, ownership: ownership_1, runtimeAllocated: runtimeAllocated_1, view: view };
}
return { address: view.byteOffset, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0, view: view };
}
var _b = emnapiExternalMemory.getArrayBufferPointer(view.buffer, shouldCopy), address = _b.address, ownership = _b.ownership, runtimeAllocated = _b.runtimeAllocated;
return { address: address === 0 ? 0 : (address + view.byteOffset), ownership: ownership, runtimeAllocated: runtimeAllocated, view: view };
}
};
/**
* @__sig ippp
*/
function _napi_get_array_length(env, value, result) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!envObject.tryCatch.isEmpty())
return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
if (!envObject.canCallIntoJs())
return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);
envObject.clearLastError();
try {
if (!value)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
if (!result)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
var handle = emnapiCtx.handleStore.get(value);
if (!handle.isArray()) {
return envObject.setLastError(8 /* napi_status.napi_array_expected */);
}
{{{ from64('result') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var v = handle.value.length >>> 0;
{{{ makeSetValue('result', 0, 'v', 'u32') }}};
return envObject.getReturnStatus();
}
catch (err) {
envObject.tryCatch.setError(err);
return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
}
}
/**
* @__sig ipppp
*/
function _napi_get_arraybuffer_info(env, arraybuffer, data, byte_length) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!arraybuffer)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
var handle = emnapiCtx.handleStore.get(arraybuffer);
if (!handle.isArrayBuffer()) {
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
}
if (data) {
{{{ from64('data') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var p = emnapiExternalMemory.getArrayBufferPointer(handle.value, true).address;
{{{ makeSetValue('data', 0, 'p', '*') }}};
}
if (byte_length) {
{{{ from64('byte_length') }}};
{{{ makeSetValue('byte_length', 0, 'handle.value.byteLength', SIZE_TYPE) }}};
}
return envObject.clearLastError();
}
/**
* @__sig ippp
*/
function _napi_get_prototype(env, value, result) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!envObject.tryCatch.isEmpty())
return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
if (!envObject.canCallIntoJs())
return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);
envObject.clearLastError();
try {
if (!value)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
if (!result)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
var handle = emnapiCtx.handleStore.get(value);
if (handle.value == null) {
throw new TypeError('Cannot convert undefined or null to object');
}
var v = void 0;
try {
v = handle.isObject() || handle.isFunction() ? handle.value : Object(handle.value);
}
catch (_) {
return envObject.setLastError(2 /* napi_status.napi_object_expected */);
}
{{{ from64('result') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var p = envObject.ensureHandleId(Object.getPrototypeOf(v));
{{{ makeSetValue('result', 0, 'p', '*') }}};
return envObject.getReturnStatus();
}
catch (err) {
envObject.tryCatch.setError(err);
return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
}
}
/**
* @__sig ippppppp
*/
function _napi_get_typedarray_info(env, typedarray, type, length, data, arraybuffer, byte_offset) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!typedarray)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
var handle = emnapiCtx.handleStore.get(typedarray);
if (!handle.isTypedArray()) {
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
}
var v = handle.value;
if (type) {
{{{ from64('type') }}};
var t = void 0;
if (v instanceof Int8Array) {
t = 0 /* napi_typedarray_type.napi_int8_array */;
}
else if (v instanceof Uint8Array) {
t = 1 /* napi_typedarray_type.napi_uint8_array */;
}
else if (v instanceof Uint8ClampedArray) {
t = 2 /* napi_typedarray_type.napi_uint8_clamped_array */;
}
else if (v instanceof Int16Array) {
t = 3 /* napi_typedarray_type.napi_int16_array */;
}
else if (v instanceof Uint16Array) {
t = 4 /* napi_typedarray_type.napi_uint16_array */;
}
else if (v instanceof Int32Array) {
t = 5 /* napi_typedarray_type.napi_int32_array */;
}
else if (v instanceof Uint32Array) {
t = 6 /* napi_typedarray_type.napi_uint32_array */;
}
else if (v instanceof Float32Array) {
t = 7 /* napi_typedarray_type.napi_float32_array */;
}
else if (v instanceof Float64Array) {
t = 8 /* napi_typedarray_type.napi_float64_array */;
}
else if (v instanceof BigInt64Array) {
t = 9 /* napi_typedarray_type.napi_bigint64_array */;
}
else if (v instanceof BigUint64Array) {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
t = 10 /* napi_typedarray_type.napi_biguint64_array */;
}
else {
return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
}
{{{ makeSetValue('type', 0, 't', 'i32') }}};
}
if (length) {
{{{ from64('length') }}};
{{{ makeSetValue('length', 0, 'v.length', SIZE_TYPE) }}};
}
var buffer;
if (data || arraybuffer) {
buffer = v.buffer;
if (data) {
{{{ from64('data') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var p = emnapiExternalMemory.getViewPointer(v, true).address;
{{{ makeSetValue('data', 0, 'p', '*') }}};
}
if (arraybuffer) {
{{{ from64('arraybuffer') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var ab = envObject.ensureHandleId(buffer);
{{{ makeSetValue('arraybuffer', 0, 'ab', '*') }}};
}
}
if (byte_offset) {
{{{ from64('byte_offset') }}};
{{{ makeSetValue('byte_offset', 0, 'v.byteOffset', SIZE_TYPE) }}};
}
return envObject.clearLastError();
}
/**
* @__sig ipppp
*/
function _napi_get_buffer_info(env, buffer, data, length) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!buffer)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
var handle = emnapiCtx.handleStore.get(buffer);
if (!handle.isBuffer(emnapiCtx.feature.Buffer))
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
if (handle.isDataView()) {
return _napi_get_dataview_info(env, buffer, length, data, 0, 0);
}
return _napi_get_typedarray_info(env, buffer, 0, length, data, 0, 0);
}
/**
* @__sig ipppppp
*/
function _napi_get_dataview_info(env, dataview, byte_length, data, arraybuffer, byte_offset) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!dataview)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
var handle = emnapiCtx.handleStore.get(dataview);
if (!handle.isDataView()) {
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
}
var v = handle.value;
if (byte_length) {
{{{ from64('byte_length') }}};
{{{ makeSetValue('byte_length', 0, 'v.byteLength', SIZE_TYPE) }}};
}
var buffer;
if (data || arraybuffer) {
buffer = v.buffer;
if (data) {
{{{ from64('data') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var p = emnapiExternalMemory.getViewPointer(v, true).address;
{{{ makeSetValue('data', 0, 'p', '*') }}};
}
if (arraybuffer) {
{{{ from64('arraybuffer') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var ab = envObject.ensureHandleId(buffer);
{{{ makeSetValue('arraybuffer', 0, 'ab', '*') }}};
}
}
if (byte_offset) {
{{{ from64('byte_offset') }}};
{{{ makeSetValue('byte_offset', 0, 'v.byteOffset', SIZE_TYPE) }}};
}
return envObject.clearLastError();
}
/**
* @__sig ippp
*/
function _napi_get_date_value(env, value, result) {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var v;
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!envObject.tryCatch.isEmpty())
return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
if (!envObject.canCallIntoJs())
return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);
envObject.clearLastError();
try {
if (!value)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
if (!result)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
var handle = emnapiCtx.handleStore.get(value);
if (!handle.isDate()) {
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
}
{{{ from64('result') }}};
v = handle.value.valueOf();
{{{ makeSetValue('result', 0, 'v', 'double') }}};
return envObject.getReturnStatus();
}
catch (err) {
envObject.tryCatch.setError(err);
return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
}
}
/**
* @__sig ippp
*/
function _napi_get_value_bool(env, value, result) {
if (!env)
return 1 /* napi_status.napi_invalid_arg */;
// @ts-expect-error
var envObject = emnapiCtx.envStore.get(env);
envObject.checkGCAccess();
if (!value)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
if (!result)
return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
var handle = emnapiCtx.handleStore.get(value);
if (typeof handle.value !== 'boolean') {
return envObject.setLastError(7 /* napi_status.napi_boolean_expected */);
}
{{{ from64('result') }}};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var r = handle.value ? 1 : 0;
{{{ makeSetValue('result', 0, 'r', 'i8') }}};
return envObject.clearLastError();
}
/**
* @__sig ippp
*/
function _napi_get_value_double(env, va